Flat-lit 3D assets look fake. The telltale sign? Every surface reads the same regardless of geometry—corners don't darken, recesses don't deepen, and nothing looks like it's actually sitting in a scene. Ambient occlusion baking fixes that, and it costs you zero GPU cycles at runtime.
What Is Ambient Occlusion and Why Bake It?
Ambient occlusion (AO) simulates how much ambient light reaches a surface point. Crevices, corners, and tight geometry gaps receive less light and appear darker; open surfaces receive more and stay bright. It's a subtle effect, but it's the difference between a prop that looks hand-crafted and one that looks like a test sphere.
The "baking" part means you pre-calculate this lighting and store it in a texture map. Your game engine reads that texture at render time just like it reads a diffuse color—no ray-casting, no runtime computation. The GPU sees it as a simple texture sample, which is essentially free.
This makes AO baking one of the highest-value optimizations available to a game artist. You get ray-traced quality contact shadows for the cost of a texture lookup.
When to bake AO vs. use screen-space AO (SSAO):
| Technique | Cost | Quality | Scope |
|---|---|---|---|
| Baked AO | One-time offline | High, geometry-accurate | Per-asset |
| SSAO (runtime) | Per-frame GPU | Moderate, view-dependent | Scene-wide |
| HBAO+ / GTAO | Per-frame GPU | High, but expensive | Scene-wide |
For most game assets—especially those destined for mobile or mid-range hardware—baked AO wins every time.
Setting Up Your Scene for AO Baking in Blender
Before you touch the bake button, your scene needs to be in the right state. Skipping this causes artifacts, incorrect results, or a bake that simply does nothing.
Step 1: Apply all transforms. In Object Mode, select your mesh and press `Ctrl+A → All Transforms`. Un-applied scale is the number one cause of AO baking artifacts—Blender computes occlusion in world space, so a scaled-but-not-applied object will produce wrong ray distances.
Step 2: Check for overlapping UVs. Your mesh needs a non-overlapping UV layout for baking. The UVs used for your albedo/roughness textures often have overlapping shells (mirrored objects share UV space to save texture memory). Create a dedicated UV channel for baking:
```python
import bpy
obj = bpy.context.active_object
# Add a second UV map named 'LightmapUV'
obj.data.uv_layers.new(name='LightmapUV')
# Select it as the active UV layer
obj.data.uv_layers['LightmapUV'].active = True
```
Then run `U → Lightmap Pack` in Edit Mode to auto-generate a clean, non-overlapping unwrap suitable for baking.
Step 3: Create the target image. In the UV Editor, go to `Image → New Image`. Set resolution to 2048×2048 (or 4096×4096 for hero assets), select 32-bit float, and name it `AO_Bake`. Leave the color black.
Step 4: Assign the image node. In your material's Shader Editor, add an `Image Texture` node, load your new `AO_Bake` image into it, and leave it selected (highlighted). This tells Blender's baker where to write the result.
Baking AO Maps: Step-by-Step Workflow
With the scene prepped, open Render Properties and switch the render engine to Cycles. Baking is a Cycles-exclusive feature in Blender—EEVEE cannot bake.
Bake settings that matter:
```
Render Engine: Cycles
Bake Type: Ambient Occlusion
Samples: 64–128 (higher = less noise, slower bake)
Max Ray Distance: 0 (auto) or ~10% of asset size
Margin: 4–16px (prevents UV seam bleeding)
```
Hit Bake. For a 2048 texture with 128 samples, expect 30 seconds to 5 minutes depending on mesh complexity and your hardware. GPU baking via CUDA/Metal/HIP is dramatically faster than CPU—enable it under `Edit → Preferences → System → Cycles Render Devices`.
Interpreting the result: A good AO bake looks like a greyscale x-ray of your mesh. Open areas are white. Tight seams, undercuts, and cavity areas graduate toward black. If the entire map is white, your ray distance is too small. If it's mostly black, check that transforms are applied.
Denoise the bake: At 64 samples you will see grain. Apply Blender's compositor denoiser:
```
Compositor → Use Nodes → Add: Image (your AO map) → Denoise → Viewer
```
Or export the raw bake and run it through OIDN (Open Image Denoise), which ships with recent Blender builds.
Integrating Baked AO into Your PBR Material
Once exported (save as 16-bit PNG or EXR for maximum precision), the AO map plugs into your material in a specific way—multiplied into your albedo channel, not applied directly.
In Blender (Principled BSDF):
```
Image Texture (AO) → MixRGB (Multiply) → Base Color of Principled BSDF
↑
Image Texture (Albedo/Diffuse)
```
Set the MixRGB blend factor to 0.7–0.9. Going full 1.0 makes dark areas too heavy. The AO is also wired into the shader's dedicated AO socket for engines that support it.
In Unity (URP/HDRP): Import your AO map and assign it to the Occlusion Map slot in the Lit shader. Unity automatically multiplies it against indirect lighting—the intended behavior per the PBR spec.
In Unreal Engine 5: In your material graph, plug the AO texture sample into the Ambient Occlusion pin on the Material node. For Nanite meshes, also consider Unreal's built-in baking tools as a supplement.
In Godot 4: Import the texture as `For Detail Only` mode, then assign it to the `ao_texture` property on a `StandardMaterial3D` or ORM Material.
Exporting and Testing in Unity, Unreal, and Godot
Before uploading to the BitSoul marketplace or delivering to a client, verify the AO map works correctly in-engine.
Checklist before shipping:
- [ ] AO map exports at correct resolution (2K or 4K)
- [ ] Saved as sRGB OFF (AO is a data texture—linear space only)
- [ ] No visible UV seams in the baked result
- [ ] Dark areas align with actual geometric occlusion (cavities, corners, overlaps)
- [ ] Tested in target engine with direct lighting enabled
- [ ] Included as a separate `_AO` suffixed file in the asset package
- [ ] Second UV channel exported with the mesh if engine requires it
A common mistake is exporting AO with sRGB color space enabled, which double-corrects the gamma and makes shadows look washed out in engine. In Blender's image editor, set `Image → Color Space → Non-Color` before saving.
For buyers browsing BitSoul's marketplace, a well-baked AO map is one of the strongest quality signals you can include. It proves geometric complexity was considered at the texturing stage—not just a surface painted in Substance Painter.
---
Ready to put baked AO to work on your next asset? Browse game-ready 3D models built with proper bake workflows at bitsoulhosting.com/marketplace—or upload your own AO-baked assets and reach thousands of developers worldwide.
---
*This post is part of the Ultimate Guide to Free 3D Game Assets — BitSoul's complete reference for formats, texturing, rigging, optimization, and engine integration.*