Optimizing Baked Lighting for Game Graphics

Mastering Baked Lighting for Games

Lightmap baking is often considered "outdated" compared to Lumen and real-time GI. In practice, it remains the primary method for achieving high-quality, performant lighting on mobile platforms and budget PCs. Even Unreal Engine 5 projects use baked lighting for static interiors because Lumen, despite its advantages, does not provide the same shadow sharpness or performance on weaker hardware.

As a team of game development engineers with 10 years of experience, we guarantee that the quality of baked lighting is always the result of fine-tuning a dozen parameters. Most issues with "bad" lightmaps stem from incorrect configuration of these parameters. Order an audit of your project — we will identify bottlenecks and propose a solution.

Why UV2 and Texel Density Are the Main Cause of Artifacts?

Lightmaps in Unity or Unreal are baked into a separate UV channel — UV2 (or Lightmap UV in Unreal). This is not the same as the albedo UV. Lightmap UV has strict requirements:

• No overlapping: each triangle occupies a unique place in UV2
• Minimum padding between islands: at least 2 texels at the target lightmap resolution. If the lightmap is 512px and padding is 2px, that's ~0.4% of the texture per seam. At 2048px — 0.1%. Insufficient padding causes light bleeding into dark areas through adjacent UV islands.
• No mirrored UVs: mirroring works for albedo but in lightmaps doubles the lighting on symmetric parts.

Unity automatically generates Lightmap UV on import (Generate Lightmap UVs in Import Settings). For simple geometry this works. For complex meshes with sharp angles or thin details, auto-generation creates incorrect islands that result in visible seams on the lightmap. In such cases, UV2 is created manually in DCC tools (Blender, Maya, 3ds Max) and imported ready.

Texel density in Lightmap UV is how many lightmap pixels cover a unit area of surface. Large flat surfaces (floors, walls) need more UV2 space. Small details (baseboards, door handles) need less. Unity and Unreal let you control this via Scale in Lightmap (Unity) and Lightmap Resolution Scale (Unreal) per object. Using the same Scale for all objects is a typical mistake: small objects get excessive resolution, large objects insufficient.

How to Properly Configure Progressive Lightmapper?

In Unity, the main baking tool is Progressive Lightmapper (since 2018.3 LTS, GPU-accelerated version later). According to the Unity documentation, the key parameters affecting the result:

Indirect Bounces. Number of light reflections. At Bounces=0: direct lighting only, no GI. At Bounces=2: light reflects twice, filling shadows with soft ambient. For dark interiors, Bounces=2–3 is the minimum for believable results. For bright outdoor scenes, 1–2 is often enough.

Indirect Intensity and Albedo Boost. Indirect Intensity scales the GI brightness globally. Albedo Boost amplifies the effect of surface colors on reflected light — at 1.0, a bright red surface creates reddish ambient on neighboring surfaces (color bleeding). At Albedo Boost > 1, the effect intensifies; at < 1, colors influence GI less. For realistic rendering, Albedo Boost = 1; for a less "dirty" ambient, use 0.5–0.8.

Prioritize View and Progressive Updates. When baking, Progressive Lightmapper starts with pixels visible in the Scene View — convenient for iterative work, but for final baking it's better to disable for uniform quality across the scene.

A typical problem with large scenes is light leaking: light passing through thin walls. The cause: shadow rays in the path tracer pass through geometry thinner than a certain threshold. The solution: make walls and floors at least 0.2–0.3 units thick (depending on scene scale) and ensure no geometry holes. Alternatively, adjust Shadow Bias on light sources, but this only partially solves the issue.

Unreal Engine: Lightmass and Its Specifics

In Unreal, baking uses Lightmass — a Global Illumination system with parameters in World Settings → Lightmass. For production quality, the Unreal documentation recommends:

• Static Lighting Level Scale. Global scale for baking quality — lower values increase lightmap detail but increase bake time. Default 1.0; for production, reduce to 0.5–0.75.
• Num Indirect Lighting Bounces. Similar to Bounces in Unity. For dark interiors: 4–6, for outdoor: 3–4.
• Indirect Lighting Quality. Multiplier for indirect lighting samples. Default 1.0; for clean production, 2.0–4.0. High values significantly increase bake time.

Progressive Lightmapper on GPU is up to 2x faster than Lightmass for small scenes, but Lightmass with Swarm scales better for large projects.

In Unreal, Lightmass bakes via Swarm — a distributed system that can use multiple computers simultaneously. For large levels with high-resolution lightmaps (4096+), baking can take 8–24 hours without Swarm; with several machines in Swarm, 4–8 times faster.

Volumetric Lightmap in Unreal is the equivalent of Light Probes in Unity. It is automatically built during baking and provides ambient for dynamic objects. The Volumetric Lightmap Detail Cell Size parameter in World Settings controls grid density. Smaller values yield more accurate ambient for dynamic objects but increase data volume.

Common Baking Problems and Their Solutions

How We Bake Lightmaps: Step-by-Step Process

1. Audit — check UV2 layouts, Import Settings, current bake settings. Identify bottlenecks and artifacts.
2. Design — distribute texel density across scene objects, set Scale in Lightmap for each element.
3. Parameter configuration — Indirect Bounces, Intensity, Albedo Boost, sample quality. Depends on scene and target platform.
4. Iterative baking — progressively increase quality while monitoring results. Adjust parameters as needed.
5. Final verification — visual inspection for artifacts, performance measurements (FPS budget), fix remaining issues.
6. Delivery — ready lightmaps, documentation of settings, recommendations for further optimization.

What We Deliver

• Full audit of UV2 channel and Import Settings
• Configuration of Progressive Lightmapper or Lightmass for your project
• Iterative baking with quality control
• Artifact removal (seams, light leaking, color bleeding)
• Documentation of all parameters and final settings
• Support for 2 weeks after delivery
• Access to final lightmaps and settings files
• Training session on adjusting parameters for your team

Pricing and Savings

By optimizing baking, clients typically reduce baking time by 30–50% and achieve cleaner results. Our pricing is transparent: a small room bake costs $500, a medium interior $1500, and a large outdoor level $5000. Contact us for a precise quote based on your project’s complexity.

We are a team with 10 years of game dev experience, having completed over 50 projects with high-quality lighting. Contact us for an evaluation of your project — get a consultation on lightmap baking.

First, audit UV2 layouts and Import Settings, then design texel density distribution, iterative baking with increasing quality, final artifact check, and delivery.

Pricing is determined individually after analyzing the project: scene size, number of lights, target platform, and current UV2 state. Contact us — we will evaluate your project within a day.

What problems does lighting setup solve?

A studio spends four hours per bake per scene. A UV seam artifact appears, the artist fixes it, and waits another four hours. This repeats three to five times daily across multiple scenes, wasting weeks. An incorrect lighting strategy from the start — all sources in Realtime — can cost 30–50% FPS on mobile or consoles at release. Our Expert Lighting and Rendering Setup Services address two core pain points: baking time and runtime performance. We audit the existing system, choose the right mix of dynamic lighting and baked methods, and deliver measurable gains. Over 30 projects delivered, from indie to AA. Certified Unity specialists guarantee the result.

Dynamic, static, and mixed lighting: how to choose?

Each light source in Unity has three modes. The table shows how they affect performance:

A common mistake: a studio sets all lights to Realtime, resulting in 12 shadow-casting lights on screen. On mobile, that’s a guaranteed 30% FPS drop. Mixed Lighting with Subtractive or Shadowmask sub-modes is the practical compromise. Static objects get baked shadows, dynamic objects get realtime shadows from same sources — a balanced dynamic lighting mix.

Typical artifacts and their causes

How to optimize baked lighting without losing quality?

Choosing between Enlighten and Progressive Lightmapper

Unity supports two baking backends. Enlighten is legacy real‑time GI — officially outdated but still used on mobile due to low system requirements. Progressive Lightmapper (GPU) is a modern path‑tracing backend. On an NVIDIA RTX card, GPU baking is 5–10x faster than CPU. We default to Progressive Lightmapper (GPU) for PC and consoles.

Key parameters for a typical scene:

Lightmap Resolution:    10–20 texels/unit
Max Bounces:            2–4 (not default 8)
Samples (Direct):       32–64
Samples (Indirect):     512–1024
Denoiser:               OIDN or OptiX

Denoiser is mandatory. Without it, you need thousands of samples for clean results. With denoiser, 256–512 samples suffice. Iteration takes minutes, not hours. According to Unity documentation, this setup reduces baking time by 50–70% without quality loss.

Light Probes and Reflection Probes: why and how to set up?

Light Probes give dynamic objects the illusion of baked lighting. Place probes every 2–4 meters in areas with lighting variation. Too sparse placement causes sharp jumps when characters move. Probe Volumes (HDRP) replace manual placement with a volumetric grid — saves time on large open scenes.

Reflection Probes correct reflections on PBR materials. Without them, metal and mirrors reflect the skybox instead of the environment. Settings:

• Baked for static rooms
• Realtime for zones with changing environment (TV, screens)
• Box Projection for correct room geometry reflection

Applying these rules reduces draw calls for reflections by up to 40%.

What is the impact of scene organization on baking speed?

Scene scale is the main enemy of fast baking. Here’s the process we use:

1. Exclude objects smaller than 0.5 units — they receive lighting via Light Probes.
2. Use Instanced Meshes for repetitive objects (trees, rocks, fences) — one UV atlas shared.
3. Bake Terrain separately at reduced resolution (2–5 texels/unit).
4. Check Backface Tolerance on complex geometry — prevents dark spots.

Following these steps cuts total bake time by 50–70%. In one open‑world Unity project, original bake time was 4 hours per scene. After optimization: 1 hour 20 minutes. Monthly time savings exceeded 40 hours, equivalent to $3,000 monthly cost reduction.

What’s included in lighting setup work

Our turnkey service delivers:

1. Audit of current system — profiling via Frame Debugger and RenderDoc, identifying bottlenecks.
2. Lighting strategy — documentation with mode selection (Mixed/Baked/Realtime) for your platform.
3. Baking optimization — UV unwrapping, Progressive Lightmapper configuration, Light Probes.
4. Reflection Probes setup and post‑processing (SSAO, SSR, Bloom) matching your artistic style.
5. Final report with performance metrics (FPS budget, draw calls, frame times).
6. Post‑delivery support for two weeks — remote session to review any issues and transfer knowledge.

Work process and timeline

We follow a clear workflow:

• Analysis (1–2 days) — review scene, take screenshots, profile.
• Design (1 day) — select strategy, create optimization plan.
• Implementation (3–7 days depending on complexity) — UV fixes, Lightmapper settings, Light Probes, post‑processing.
• Testing (1–2 days) — measure performance, remove artifacts.
• Delivery — scene files, documentation, checklist.

Typical timeframe: 5 to 15 business days. Pricing is individual — contact us for a project estimate.

Get a free audit of your current lighting setup. Reach out to discuss your project — we will provide a concrete plan and timeline.