Baking Examples

Baking Examples: A Practical Guide

Baking is the process of precomputing data — usually lighting, ambient occlusion, or shader information — and storing it in textures or static files so the runtime doesn't have to recalculate it every frame. When people talk about baking examples, they're usually referring to sample projects, scene setups, or reference renders that demonstrate how baking works in practice. This is a huge topic because the exact approach depends entirely on what you're trying to bake and what engine or software you're working in. In game engines like Unity and Unreal, or in tools like Blender and Maya, baking takes something expensive to compute — a lightmap, a normal map, GI cache, cage animation — and writes it out to disk as a texture or static data block. After that, the GPU or CPU reads that precomputed result instead of recalculating it live. This is why baked lighting in a game uses almost zero runtime cost compared to real-time dynamic lighting. The tradeoff is straightforward: you spend time up front computing the data, and you lose the ability to change it dynamically. If you move a light after baking, nothing updates. You have to rebake. This is the first thing most beginners get burned by.

How to Set Up a Basic Baking Workflow

Let me walk through a practical example using Blender since it's free and the baking pipeline is reasonably well documented. I'll keep this focused on the two most common use cases: baked ambient occlusion and baked lightmaps. For baked ambient occlusion, start by making sure your mesh has proper UVs. Baking AO onto a non-UV'd mesh either fails or produces garbage results. Go to the Render Properties tab, find the Bake section, set the bake type to Ambient Occlusion, make sure your image editor has a new blank image open and selected, and hit Bake. The defaults — multiply blend mode, color set to white, and a sample count around 128 to 256 — will get you a usable result on a static mesh. Export the resulting texture as PNG or EXR depending on your needs. For baked lightmaps in a game engine, the process is more involved. In Unity with the built-in renderer, you set light types to Mixed or Baked, assign lightmap scale values to each light in the scene, make sure every static mesh has a lightmap UV set in its import settings, and then go to Window > Rendering > Lighting and click Bake. The engine will compute indirect lighting, shadow maps, and ambient occlusion across your scene and output them as lightmap textures. In Unreal Engine 5, you use the Lumen system for real-time GI but can still bake static lighting by setting your light mode to Stationary or Baked, then hitting Build in the Lighting menu. UE5's Nanite workflow changes how you think about it because Nanite meshes don't use traditional lightmaps the same way — they get lit through virtual geometry shading instead.

Common Pitfalls and What I've Learned the Hard Way

Here are the things that will cost you time if you don't know about them upfront. Lightmap UV seams show up as dark lines. This is the most common complaint I see. Your mesh has a proper UV unwrap but the lightmap still has seams. The reason is usually one of three things: the UV islands are too close together and bleeding is happening, the lightmap resolution is too low for the detail level in your UV layout, or you haven't enabled the "Generate Lightmap UVs" option and are relying on your existing UV channel which wasn't designed for lightmapping. In Blender, there's a dedicated second UV channel specifically for lightmap unwrapping. Use it. Pack your islands with adequate spacing — at least a few pixels between them depending on your lightmap resolution. Baked GI looks blotchy or noisy. This happens when you don't have enough samples. Every baking engine uses some form of Monte Carlo integration, which means more samples equal less noise but longer bake times. In Cycles inside Blender, bumping your sample count from 64 to 512 on a complex indoor scene can turn a noisy mess into something clean, but the bake time goes from maybe 30 seconds to 5 minutes on a decent GPU. In Unity, the built-in baker has a "resolution" slider per-light and a global "mode" setting — Normal is fast but low quality, High is slow but produces clean results. Don't skimp here if your scene is going to be viewed closely.

I spent an entire day once debugging a scene where the baked lighting looked completely wrong on certain characters but fine on the environment. The issue was that the characters had a custom shader that didn't read the lightmap UV channel at all. It was using the diffuse UV channel instead, which was at a totally different scale and orientation. The fix was adding a single line to the shader to sample from the correct UV channel. That could have been avoided with a basic sanity check on the first pass.

Advanced: When Baking Fails You

There are scenarios where baking simply isn't the right answer, and knowing this will save you from wasting hours on something that won't work. Moving objects with baked lighting don't cast correct shadows. If you bake a lightmap for a scene and then animate an object through that scene, the shadow it casts will stay locked to its original position relative to the lightmap coordinates. This is a fundamental limitation. For moving objects, you need real-time shadows or a hybrid approach where only the static environment is baked and dynamic objects use real-time shadow casting. Most commercial games use this hybrid model. The building stays baked. The player character gets real-time shadows. Large outdoor scenes bake impractically long. I once tried to bake a 2km² open world area in Unreal Engine 4 with static lighting. The bake ran for approximately 14 hours and the resulting lightmap textures ate about 18GB of VRAM. The scene looked mediocre because the lightmap resolution had to be so low to fit in memory. The workaround was to switch to a hierarchical approach: bake the core playable area at high resolution, use distance fog and sky lighting to mask the edges, and only increase detail as the player gets closer. UE5's World Partition and Virtual Shadow Maps make this easier now, but the principle hasn't changed.

Normal map baking from a high poly to low poly needs cage geometry. If you try to bake a normal map without a cage, the rays that shoot out from the low poly surface will intersect with distant high-poly geometry and give you incorrect normals. Setting up a proper cage — a slightly expanded version of your low poly mesh placed between the object and the camera — is essential. In Blender, you can add a modifier to your low poly mesh, set the cage offset, and the UV unwrap baker will respect it. I usually set the cage offset to about 2 to 5 times the average edge length of the low poly mesh. Too small and you get pinching artifacts. Too large and you lose detail accuracy.

Recommended Baking Examples to Study

If you want to see baking examples in action, these resources will show you the process end to end rather than just the final result: The Blender Guru donut tutorial covers basic baking in a structured way. It's beginner-friendly but accurate. The default cycles render settings and the procedural material workflow give you a clear baseline for understanding what each bake pass contributes. John Dufault's YouTube channel has a series on Unity baked GI that walks through the entire pipeline from lightmap UV setup through final in-engine tuning. His explanation of lightmap scale and texture resolution tradeoffs is one of the clearest I've seen. He also covers the common mistake of forgetting to mark objects as static, which causes the baker to skip them entirely.

For Unreal Engine specifically, the official Epic Games documentation on static lighting has a section with downloadable sample projects. The "BakingLighting" example scene shows progressive improvement as you adjust lightmass settings. It's useful for seeing the difference between fast, normal, and high quality modes side by side. On the shader side, the OpenGL Red Book has a chapter on precomputed radiance transfer that explains the mathematics behind spherical harmonics baking. It's dense but it's the foundation for understanding why baked GI sometimes looks flat on curved surfaces. The technique encodes lighting as coefficients rather than raw textures, which is more memory efficient but loses some directional accuracy.

Practical Tips That Aren't Obviously Useful

Always bake at a higher resolution than you think you need and downscale in post if necessary. It's easier to reduce detail later than to add it back. A 1024x1024 lightmap with good content will look better than a 2048x2048 one that's undersampled because you were worried about memory. Use EXR format for any baked data that involves HDR information — lightmaps, GI caches, emission textures. PNG compresses the data and can introduce banding in gradient areas. EXR preserves the full float range and your post-processing steps won't fight against quantization artifacts. Keep your bake logs. In Unity, the console output tells you exactly which lights were baked, how many bounces were computed, and how long each pass took. When a bake produces unexpected results, those logs will tell you whether the engine actually baked what you thought it was baking. I've lost count of how many times I've assumed a light was set to Baked mode when it was actually set to Realtime, and the entire bake looked wrong because half the scene had no indirect lighting at all.

Version your baked textures. A project I was on had three different bakes floating around — one from last week, one from yesterday, and one that someone generated at 2am. The art director approved the 2am version without realizing it was missing the AO pass that the yesterday version had. This kind of thing happens constantly. Name your baked files with dates and descriptions. It takes five seconds and prevents hours of confusion later. If you're baking normal maps for game assets, bake them twice — once with and once without the high-poly detail you're trying to capture. Some engines and tools handle the subtraction differently, and having both gives you control over how aggressive the normal transformation is. A purely additive bake will make everything look crushed. A subtractive bake (high minus low) is the standard approach and gives you the true surface deviation.