Flat, lifeless environments kill immersion faster than any framerate drop. If your Unity URP scenes look plasticky and unlit, the problem is almost always that you're relying on real-time lights for geometry that never moves. Lightmap baking trades build time for runtime performance — and in URP it's the single highest-leverage technique for making static levels look polished and run fast on every platform.
Why Lightmaps Still Matter in Unity URP
Real-time global illumination sounds appealing, but for most games — especially mobile, VR, and mid-range PC titles — it's a budget you can't afford. Lightmaps pre-compute indirect bounce lighting, soft area shadows, and ambient occlusion into texture atlases that cost almost nothing to sample at runtime.
Unity's Universal Render Pipeline supports two lightmappers: the legacy CPU-based Enlighten and the newer Progressive Lightmapper (CPU and GPU variants). For almost all new projects you want Progressive. It gives you predictive bake times, live preview during baking, and support for the full Unity light feature set including area lights, light probes, and mixed lighting modes.
The key architectural rule: any mesh that doesn't animate should be marked Static (or at least Contribute GI). Walls, floors, ceiling geometry, props, debris — all of it. Dynamic objects (characters, vehicles, physics props) pick up indirect light from Light Probes placed around the scene, which are baked at the same time.
Lightmaps in URP behave identically to the Built-In pipeline's baked lighting — the same `Lightmap` asset type, the same `Lightmapping` API, the same `LightProbeGroup` component. The difference is in the post-processing and shader output: URP shaders read lightmap UVs from UV channel 1 (index 1, zero-based), which Unity auto-generates unless you supply them yourself.
Setting Up Static Objects and Lightmap UVs
Before you open the Lighting window, get your mesh setup right. Every static prop needs two UV sets:
- UV0 — your standard texture coordinates used for albedo, normal maps, PBR textures
- UV1 — a non-overlapping lightmap UV layout, where every polygon gets its own unique space in the 0–1 range
Unity can generate UV1 automatically via Generate Lightmap UVs in the mesh importer, but the results are often wasteful. For hero assets — large floors, featured props, architectural elements — hand-unwrap UV1 in Blender and export it in the second UV channel. Go to Object Data Properties → UV Maps, add a second UV map named `UVMap.001` (or any name; Unity reads by index), and unwrap it manually. Maximize texel coverage for the surfaces players look at most.
For smaller or repeated props, Unity's auto-generation is fine. In the importer settings (select the FBX or GLB in the Project window → Model tab), check Generate Lightmap UVs and expand the settings:
```
Hard Angle: 88
Angle Error: 8
Area Error: 15
Pack Margin: 4
```
Lower `Pack Margin` to 2 for small atlases; raise it to 8 if you see bleeding artefacts at seams. After changing any of these, click Apply and allow Unity to reimport — the baked result will change significantly if UV1 was wrong.
Mark objects as static by selecting them in the Hierarchy and ticking Static in the Inspector top-right. If you only want lightmap contribution and not navmesh/occlusion culling (which can be expensive to compute), click the dropdown arrow next to Static and enable only Contribute GI and Reflect Lightmaps.
Configuring the Lighting Settings Window
Open Window → Rendering → Lighting. The key settings live across three tabs: Scene, Environment, and Baked Lightmaps.
Scene tab — Lightmapping Settings:
| Setting | Recommended Value | Notes |
|---|---|---|
| Lightmapper | Progressive GPU | Use CPU if GPU VRAM < 4 GB |
| Lightmap Resolution | 20–40 texels/unit | Higher = better quality, longer bake |
| Lightmap Padding | 2 | Minimum to avoid cross-prop bleeding |
| Max Lightmap Size | 1024 or 2048 | 4096 rarely justified; increases memory |
| Compress Lightmaps | Enabled | BC6H on desktop, ASTC on mobile |
| Ambient Occlusion | Enabled | Max Distance 1–2m for interior |
| Final Gather | Disabled | Only needed for cinematic quality |
| Direct Samples | 32 | Raise to 64 if direct light is noisy |
| Indirect Samples | 512 | 256 for fast iteration, 1024 for final |
| Environment Samples | 256 | Controls sky GI quality |
The Lightmap Resolution setting is the single biggest quality/time lever. At 20 texels/unit on a 10m × 10m floor, that's a 200 × 200 texel patch — barely enough for soft shadows. For featured surfaces, boost to 40–80 by adding a Lightmap Parameters asset (right-click in Project → Create → Rendering → Lightmap Parameters) and assigning it per-renderer in the Mesh Renderer → Lightmapping → Lightmap Parameters field.
Disable Auto Generate in the Lighting window during development. Auto-bake triggers on every scene change and will destroy your iteration speed. Bake manually via Generate Lighting when you're ready.
Bake Modes and Light Types
Unity URP supports three light modes for lightmap baking:
Baked — light contributes only to lightmaps; has no runtime cost whatsoever. Use for fill lights, bounce fill, sky portals. The tradeoff: no real-time shadows on dynamic objects (they still receive light probe influence).
Mixed — light bakes indirect bounce and static shadows into lightmaps, but also renders real-time direct lighting on dynamic objects. This is the sweet spot for most games. Set your key directional light (sun) to Mixed to get soft baked shadows on terrain and static props while keeping hard real-time shadows on characters.
Realtime — contributes nothing to lightmaps. Reserve for player torches, muzzle flashes, vehicle headlights.
For interior spaces, place area lights (use Light → Area in the Hierarchy) mapped to window openings to simulate natural bounce from outside. Area lights are baked-only in Unity — they have no runtime fallback — but they produce visually accurate soft shadows that no spot or point light can replicate.
Light probes belong in every scene with dynamic objects. Create a Light Probe Group (GameObject → Light → Light Probe Group) and distribute probes throughout the playable volume: near floors, at doorways, in corners, and at ceiling height. The probe baker samples baked indirect and skylight at each probe position, so characters moving through the scene smoothly pick up the ambient colour from each area.
Optimizing Bake Times and Reducing Lightmap Atlases
Slow bakes are productivity killers. Here's a practical checklist for cutting bake time without sacrificing quality:
- Switch to Progressive GPU if you haven't. GPU bake is 5–10× faster than CPU on a mid-range discrete card.
- Use Prioritize View: in the Lighting → Scene tab, enable Prioritize View so the lightmapper refines the camera frustum first. You can assess quality after a few minutes rather than waiting for the full bake.
- Reduce Indirect Samples during iteration: set to 128 for layout passes, 512 for review, 1024 only for final.
- Limit GI contributors: select props that never receive indirect light (small debris, distant buildings) and uncheck Contribute GI to remove them from the bake. This can cut bake time 20–40% in dense scenes.
- Reduce lightmap atlases: the more atlases Unity generates, the more memory and draw calls. Keep Max Lightmap Size at 2048 and use the Baked Lightmaps tab to inspect atlas utilization. If you have five 10%-utilized atlases, lower individual mesh lightmap scale multipliers (Mesh Renderer → Lightmapping → Scale In Lightmap) on small objects until they pack efficiently.
After baking, check the Lightmap Exposure in the Environment tab. If baked light looks washed out, your scene is over-exposed — reduce environment intensity or adjust the directional light intensity before re-baking. If it looks too dark, check that your materials have correct albedo values: pure black (0, 0, 0) materials absorb all light and produce no bounce.
A common pitfall: baking then moving a static object. If you reposition a Contribute GI mesh post-bake, its lightmap UV placement is now wrong and you'll see mismatched shadows. Bake after you finish layout, not before.
Ready-to-Use Assets on the BitSoul Marketplace
Building lightmapped environments from scratch means producing every static prop yourself — a time sink that slows shipping. The BitSoul marketplace stocks hundreds of Unity-compatible static environment assets with hand-authored UV1 lightmap channels and correct import settings out of the box. Filter by GLB or FBX, check the asset page for "Lightmap UVs included," and you skip the UV unwrap entirely.
Whether you're blocking out a dungeon, building a sci-fi corridor, or furnishing an open-world settlement, starting from battle-tested assets lets you go straight to bake configuration and scene composition.
Explore game-ready static props at https://bitsoulhosting.com/marketplace and ship scenes that look lit, not lazy.