Ambient occlusion (AO) is one of those small details that separates polished game assets from assets that look flat and unfinished. Add it wrong and you waste texture memory. Skip it entirely and your models look like they're floating in mid-air. This guide gives you the exact Blender workflow to bake clean AO maps and plug them correctly into Unity, Unreal Engine 5, and Godot 4.
What Ambient Occlusion Actually Does for Game Assets
Ambient occlusion simulates soft shadows in crevices, corners, and contact points — the darkening you see where a bolt sits in a hole or where two surfaces nearly touch. Real-time AO (SSAO in Unity, GTAO in UE5) is a post-process approximation. Baked AO is exact, free at runtime, and works on any hardware. The trade-off: you bake it into a texture, so it doesn't update with dynamic lighting. For static props and environment assets, that's almost always the right call.
AO is usually combined with PBR textures in one of two ways:
- Standalone AO map: a dedicated grayscale texture sampled in the material.
- Channel-packed ORM: AO baked into the Red channel alongside Roughness (Green) and Metallic (Blue). This is the most memory-efficient approach and what Unity's URP and UE5 both support natively.
Setting Up Blender for AO Baking
Before you touch the Bake panel, your scene needs to be ready. A bad setup here produces streaked, incorrect, or blown-out results.
1. Apply all transforms.
Select every object you plan to bake, then `Ctrl+A → All Transforms`. Un-applied scale is the most common cause of distorted AO.
2. Unwrap your UV map.
You need a unique (non-overlapping) UV layout in channel 0. Smart UV Project works for blocky props; for organic or high-value hero assets, unwrap manually. Set your texel density first — 10.24 px/cm is a solid default for hero props at 2K resolution.
3. Create and assign a blank image texture node.
In the Shader Editor, add an Image Texture node (`Shift+A → Texture → Image Texture`). Create a new image at your target resolution (2048×2048 or 4096×4096). Leave the node disconnected — Blender bakes to whichever image texture node is *selected*, not the one connected in the graph. This trips up a lot of artists.
4. Bake settings in Cycles.
AO baking requires Cycles. Switch your render engine, then open Render Properties → Bake:
```
Bake Type: Ambient Occlusion
Selected to Active: OFF (unless baking high-to-low)
Max Ray Distance: 0.0 (auto)
Margin: 4–16 px (increase for final bakes to prevent edge bleeding)
Samples: 64–128 (use 32 for iteration, 128 for final)
```
Hit Bake. For a 2K image at 128 samples on a mid-range GPU, expect 20–90 seconds per object.
5. Save the result.
Image Editor → Image → Save As. Export as 16-bit PNG if you plan to composite or edit further, 8-bit PNG for direct engine import.
Baking High-Poly Detail onto a Low-Poly Mesh
This is where AO baking pays off most — capturing the shadow detail from a high-poly sculpt or detailed mesh and projecting it onto the low-poly game asset.
Setup:
- Name your meshes clearly: `prop_crate_LP` and `prop_crate_HP`.
- Position them in the exact same world-space location.
- Select the low-poly first, then Shift-click the high-poly (high-poly must be the active object).
- Enable Selected to Active in the Bake panel.
- Set Extrusion to 0.02–0.05 (start low, increase if you see projection errors).
- Set Max Ray Distance to match your extrusion value.
This workflow captures contact shadows and fine surface detail that would be invisible on the low-poly geometry alone — invaluable for hero props like crates, barrels, and weapons.
| Setting | Iteration Bake | Final Bake |
|---|---|---|
| Samples | 32 | 128 |
| Resolution | 1024×1024 | 2048×2048 or 4096×4096 |
| Margin | 4 px | 16 px |
| Extrusion (H→L) | 0.05 | 0.02–0.03 |
Importing AO into Unity, Unreal Engine 5, and Godot 4
Each engine handles AO differently. Here's the exact setup for each.
Unity (URP and HDRP)
In URP's Lit shader, set the Occlusion Map slot to your AO texture. Change its import settings: Texture Type → Default, sRGB (Color Texture) → OFF (AO is a linear data map, not a color). HDRP uses the same logic in the Mask Map, where AO goes in the Green channel. If you're channel-packing, combine in Blender or Photoshop: R = Metallic, G = AO, B = Detail mask, A = Smoothness (inverted roughness).
Unreal Engine 5
UE5's default material expects an ORM texture: Occlusion in R, Roughness in G, Metallic in B. In your material graph, connect the texture to the Ambient Occlusion pin. Set the texture's Compression to `Masks` and disable sRGB. For Nanite meshes, AO works the same — baked AO doesn't conflict with Lumen's real-time GI; they complement each other.
Godot 4
In StandardMaterial3D, assign your AO texture to the Ambient Occlusion slot. Toggle On and set AO Light Affect to control how strongly it darkens lit surfaces (0.5 is a good starting point). Godot also supports the ORM texture via the `ORM` texture slot, which expects the same channel layout as UE5 (Occlusion R, Roughness G, Metallic B).
```python
# Godot 4 GDScript: set AO texture at runtime
var mat = $Mesh.get_active_material(0) as StandardMaterial3D
mat.ao_enabled = true
mat.ao_texture = preload("res://textures/prop_crate_AO.png")
mat.ao_light_affect = 0.5
```
Common AO Baking Problems and Fixes
Dark splotches or all-black output: Un-applied scale. Go back to `Ctrl+A → All Transforms`.
Hard seams visible at UV borders: Increase Margin to 16 px. For persistent seams, enable Dilate in your image editing software to push bake data into the padding.
Bake comes out flat or white with no occlusion: The image texture node in the shader is not selected (highlighted in orange). Click it to select, then bake.
Projection errors on high-to-low bakes: Increase Extrusion slightly (0.05 → 0.08). If one face looks fine but adjacent faces blow out, the high-poly is penetrating the low-poly — fix the mesh alignment first.
AO too strong in engine: In Unity, reduce the Occlusion Strength slider. In UE5, multiply the AO channel by a scalar parameter in the material. In Godot, lower `ao_light_affect`.
Final Thoughts
Ambient occlusion baking is a one-time cost that pays runtime dividends for the life of a static asset. The Blender workflow is stable, the output is predictable, and all three major engines have first-class support for it. For a library of professionally baked, game-ready 3D assets you can drop straight into your project, browse the BitSoul marketplace — every asset ships with complete PBR maps including AO. Save the bake time and get back to building your game.