PBR texture baking is one of those topics that every game developer needs to understand but few tutorials explain clearly from the start. Most guides jump straight into node setups without explaining why you are doing what you are doing. This post starts from the beginning: what baking is, why games need it, and then walks through the entire manual process with every setting explained.

If you have ever baked textures in Blender and gotten black images, weird artifacts, inverted normals, or colors that look wrong in your game engine — this guide is for you.

What Is Texture Baking?

Texture baking is the process of converting 3D material information into flat 2D image files. Your Blender material might be a complex network of procedural nodes — Noise Textures, Voronoi patterns, Color Ramps, math operations — producing beautiful results in the viewport. But that node network only works inside Blender. Game engines like Unreal Engine and Unity use different material systems that cannot read Blender's node trees.

Baking takes a snapshot of what each material property (color, roughness, normal, etc.) looks like on the surface of your mesh and writes it into an image texture. That image texture is universal — any game engine can read it.

Think of it like printing a photograph of something that previously only existed as a live performance. The performance (your procedural material) is dynamic and resolution-independent. The photograph (your baked texture) is static but portable.

Why Games Need Baked Textures

Three reasons:

1. Portability

Blender's shader nodes do not exist in Unreal Engine or Unity. A Noise Texture node in Blender has no direct equivalent in UE5's material editor. Baked image textures work everywhere.

2. Performance

Procedural materials compute their values per-pixel at render time. For a film render, that is fine — you have seconds or minutes per frame. For a game running at 60fps, you have 16.6 milliseconds per frame total. Pre-computed image textures are vastly cheaper to sample than real-time procedural calculations.

3. Detail Transfer

Baking is also how you transfer detail from a high-poly sculpt to a low-poly game mesh. A character sculpted with 2 million polygons can have its surface detail baked into normal and displacement maps on a 10,000-polygon game mesh. The low-poly mesh looks nearly as detailed but runs at game-friendly performance.

The Manual Baking Process (The Full Pain)

Let's walk through baking a complete PBR texture set manually in Blender. This is deliberately thorough — understanding each step helps you diagnose problems when things go wrong.

Prerequisites

Before you start:

• Your mesh needs clean UV maps. Open the UV Editor and verify your UVs are unwrapped with no overlapping islands (for unique textures). Overlapping UVs cause bake artifacts where multiple surface areas write to the same texture pixels
• Your material must use the Principled BSDF shader (the standard PBR shader in Blender)
• You need to be using Cycles as your render engine. Baking does not work with EEVEE (as of Blender 4.x)

Step 1: Create Target Images

For each PBR map you want to bake, you need to create a blank image in Blender's Image Editor:

1. Open the Image Editor
2. Click New to create an image
3. Set the resolution (1024, 2048, or 4096 depending on your needs)
4. Name it clearly: MyAsset_BaseColor, MyAsset_Normal, MyAsset_Roughness, etc.
5. Critical: Set the color space correctly:
   • Base Color → sRGB (it represents perceived color)
   • Normal, Roughness, Metallic, AO, Height → Non-Color (these are data, not color)

Repeat this for every map you need. For a standard PBR set, that is 5-6 images.

Step 2: Add Image Texture Nodes

This is the part that confuses beginners. For each bake pass:

1. Open the Shader Editor
2. Add an Image Texture node (Add > Texture > Image Texture)
3. Select the target image you created in Step 1
4. Do not connect it to anything. The node just needs to exist and be selected (highlighted) in the shader editor
5. The selected Image Texture node is where Blender writes the bake result

You need to select the correct target image before each bake pass. Baking Base Color? Select the BaseColor image texture node. Baking Roughness? Select the Roughness image texture node.

Step 3: Configure Bake Settings

Open the Render Properties panel and scroll to the Bake section.

Baking Base Color

Bake Type: Diffuse
  Contributions:
    Color: ON
    Direct: OFF  ← Critical!
    Indirect: OFF  ← Critical!

Turning off Direct and Indirect lighting is essential. If you leave them on, Blender bakes lighting into your albedo texture. Your texture will look pre-lit — bright on one side, dark on the other — and will look wrong under any other lighting condition in your game.

Click Bake. Wait. The result writes to whichever Image Texture node is selected in the shader editor.

Baking Normal Map

Bake Type: Normal
  Space: Tangent (for game engine use)

Select your Normal target image node. Click Bake.

Baking Roughness

Blender has a dedicated Roughness bake type since version 3.0:

Bake Type: Roughness

If you are on an older version, the workaround is:

1. Temporarily disconnect your Roughness input from the Principled BSDF
2. Create an Emission shader
3. Connect your roughness data to the Emission Color
4. Bake as Emit type
5. Reconnect your original material

Select your Roughness target image node. Click Bake.

Baking Metallic

There is no native Metallic bake type. Use the Emission workaround:

1. Connect your Metallic data to an Emission shader
2. Set bake type to Emit
3. Bake

Reconnect your material afterward.

Baking Ambient Occlusion

Bake Type: Ambient Occlusion

This bakes based on geometry proximity — how much each surface point is occluded by nearby geometry.

Baking Height

Height maps require the Emission workaround with your height/displacement data connected to Emission.

Step 4: Save Each Image

After baking, each image exists only in memory. You must save them to disk:

1. Go to the Image Editor
2. Select each baked image
3. Image > Save As
4. Choose PNG format for game textures (lossless)
5. Verify the color space is correct in the save dialog

The Tally

For a single material with 5 PBR maps, the manual process requires:

• Creating 5 blank images with correct settings
• Adding 5 Image Texture nodes
• Configuring bake settings 5 times (with 2 requiring shader rewiring)
• Clicking Bake 5 times and waiting for each
• Saving 5 images to disk with correct formats

For a project with 20 materials, multiply all of that by 20. It is 100 bake operations, 100 images to manage, and many opportunities for error at each step.

This is the reality of manual PBR baking. It works, and understanding it is valuable. But the mechanical repetition is exactly the kind of work that should be automated.

Common Mistakes That Ruin Your Bakes

Mistake 1: Wrong Color Space

The most common error. If your Normal map is set to sRGB instead of Non-Color, the values get gamma-corrected, which shifts the normals. Your surface detail will look washed out and subtly wrong. The same applies to Roughness, Metallic, and AO.

Rule: Only Base Color (albedo) uses sRGB. Everything else is Non-Color.

Mistake 2: Baking Lighting into Albedo

Leaving Direct and Indirect contributions enabled when baking Diffuse color. Your albedo texture will have shadows and highlights baked in, making it look wrong under any lighting condition other than the one present during baking.

Rule: For Base Color, enable only Color contribution. Disable Direct and Indirect.

Mistake 3: Overlapping UVs

If UV islands overlap, multiple parts of the mesh write to the same texture pixels. The result is a garbled mess in those areas. Overlapping UVs are fine for tiling materials but fatal for unique bakes.

Rule: For unique asset baking, ensure zero UV overlap. Use Blender's UV overlap check (UV Editor > Overlays > Display Stretch or use the Pack Islands function).

Mistake 4: No Margin / Island Bleed

Baked textures need margin (also called island bleed or padding) — extra pixels painted beyond the UV island edges. Without margin, you get visible seam lines where bilinear filtering samples the black background between UV islands.

Rule: Set bake margin to at least 4-8 pixels for 1K textures, 8-16 for 2K, 16-32 for 4K.

Mistake 5: Wrong Normal Map Convention

Blender bakes OpenGL normal maps. Unreal Engine expects DirectX normal maps. The green channel is inverted between the two conventions. If your normal maps look inverted in your game engine (bumps appear as dents), this is why.

Rule: Flip the green channel for DirectX engines (Unreal), or handle it during export.

Mistake 6: Forgetting to Select the Target Node

Blender writes the bake result to whichever Image Texture node is currently selected (highlighted) in the shader editor. If you forget to select the right one, your bake overwrites a previously baked texture.

Rule: Always verify the selected node before clicking Bake. Name your nodes clearly.

Channel Isolation: Getting Clean Single-Channel Maps

Some PBR properties are single-channel (grayscale) data: Roughness, Metallic, AO, Height. But Blender bakes them as RGB images. For game engine import, you often want clean single-channel data.

When baking single-channel data:

1. Ensure the target image is created as a Non-Color / Linear image
2. After baking, the RGB channels will all contain the same grayscale data
3. When importing to your game engine, you can extract any single channel, or the engine may automatically detect it as grayscale

For ORM channel packing (Occlusion, Roughness, Metallic into R, G, B channels of a single texture), you need to combine your individual bakes into a packed texture. This requires post-processing in an image editor or a script.

The Better Way: Automated Baking

After walking through all of that, you can probably see why automated baking tools exist. The manual process is well-defined — every step follows clear rules — but it is tedious, error-prone, and repetitive.

One-Click PBR Bake & Export exists specifically to eliminate this repetition. It handles all the steps described above — creating target images, configuring bake settings per pass, managing color spaces, selecting the correct nodes, baking every map, handling normal map convention conversion, packing ORM channels, and saving to disk — in a single click.

The value is not in doing something you could not do manually. It is in doing it correctly every time, without the 15-30 minutes of setup per material and without the risk of any of the six common mistakes above. When you understand the manual process (which you now do), you can appreciate what the automation handles and troubleshoot intelligently when something unexpected happens.

What Resolution Should You Bake At?

A common beginner question. The answer depends on your use case:

You can always re-bake at a higher resolution later. Start low during development for fast iteration and increase resolution when finalizing assets for release.

Baking High-Poly to Low-Poly

One specific baking use case deserves mention: transferring detail from a high-polygon sculpt to a low-polygon game mesh.

The process:

1. Create your high-poly sculpt (millions of polygons with fine surface detail)
2. Create a low-poly game mesh (retopologized, clean topology, game-friendly poly count)
3. UV unwrap the low-poly mesh
4. In Blender's bake settings, enable Selected to Active
5. Select the high-poly mesh, then Shift-select the low-poly mesh (making it active)
6. Set Ray Distance appropriately (usually 0.01-0.1 depending on mesh scale)
7. Bake Normal map — the high-poly surface detail transfers to the low-poly normal map

This is the standard game industry workflow for characters, weapons, and detailed props. The low-poly mesh renders at game-friendly performance while the normal map gives it the visual complexity of the high-poly version.

Conclusion

PBR texture baking is a fundamental skill for any game developer working in Blender. The concept is simple — convert 3D material information to 2D image files — but the execution has many places where things can go wrong silently. Understanding the manual process, the correct settings for each map type, the common mistakes, and the reasoning behind each step gives you the knowledge to produce correct textures consistently.

Whether you bake manually or use automation tools, this knowledge is the foundation. When something looks wrong in your game engine, you will know exactly which step in the pipeline to check first. And that diagnostic ability is worth more than any single tool.