Atlas Bake - A blender Add-on for Texture Baking

Bake clean, engine-ready textures (BaseColor, Normal, Metallic, Roughness, AO, Opacity), build custom channel packs, handle UVs, project High→Low, and export FBX, all in a safe background subprocess so your open .blend stays untouched.

Blender 4.2+ Windows · macOS · Linux GPL-3.0-or-later
Atlas Bake Landing

Overview

Texture baking condenses complex, multi-material shaders into a compact set of textures ready for engines like Unity and Unreal. Engines expect specific color spaces and often packed channels (Unity’s Metallic+Smoothness, Unreal/glTF’s ORM).

Typical manual steps
  • Pick Cycles + samples
  • Ensure correct UVs
  • Create images & color spaces
  • Handle scalar reroutes (Metal/Rough)
  • Normals (OpenGL/DirectX)
  • AO / Opacity
  • Packed outputs (ex. MS/HDRP/ORM)
  • Build atlas material & export
Atlas Bake solves this

Automates end-to-end with safe defaults and clear status.

  • Correct color spaces per map
  • OpenGL (Y+) / DirectX (Y−) normals
  • Custom channel packs with presets
  • Smart UV or Use Selected UV
  • High→Low baking (max ray, cage, extrusion)
  • Atlas material & optional FBX export
  • Runs in a background headless Blender subprocess
A simple baking process
A simple baking process.

Key features at a glance

  • Per-map baking: Base Color (sRGB), Emission (sRGB), Normal (Non-Color), Metallic (Non-Color), Roughness (Non-Color), AO (Non-Color), Opacity (Non-Color). Metallic & Roughness use a safe temporary Emission reroute for scalar accuracy.
  • Material selection (whitelist): Only included materials are processed in Atlas/Smart-UV.
  • Custom Packs: Build your own packs, or use the presets MS, HDRP Mask, ORM. Dependency-aware and reusable via a preferences folder (absolute and // relative paths supported).
  • UV handling: MANUAL (pick existing UV) or SMART (auto-create & unwrap AtlasBakedUV with Angle Limit & Island Margin; applied to included materials).
  • High→Low projected baking: Selected→Active with Max Ray Distance, Cage Object, or Virtual Cage Extrusion.
  • Exports: Optional FBX of a duplicate with atlas material; UV0 enforced. Option to Keep Final .blend with relative paths (or packed images).
  • Normals: OpenGL (Y+) or DirectX (Y−) with optional Flip Normal Y.
  • Performance & Quality: GPU Compute (optional), Resolution, Bake Margin (px) vs UV Island Margin.
  • Clear status & safe operation: Work runs in a background, headless Blender subprocess using a temporary copy. Your open file remains responsive and unmodified while it receives regularly updates about the progress.

Installation

  1. Download the packaged .zip.
  2. In Blender: Edit → Preferences → Add-ons → Install… and select the file.
  3. Enable Atlas Bake.
  4. Find it in 3D View → N-Panel → Atlas Bake.
Add-on Preferences
  • Enable Logs: write detailed bake logs (e.g., logs.txt) into the output folder.
  • Custom Channel Pack Folder: where your pack definitions live (absolute or // relative to the current .blend).
Add-On Preferences
Add-On Preferences.

Quick Start - Simple model baking

  1. Select one source mesh.
  2. In Textures, enable the maps you want.
  3. Choose UV Mode:
    • MANUAL → pick your UV map, or
    • SMART → set UV Angle Limit & UV Island Margin.
  4. In Materials to Include, check materials to process (default: all).
  5. Pick Normal Convention (OpenGL vs DirectX); optionally Flip Normal Y.
  6. Set Resolution, Samples, Bake Margin (px), and optionally Use GPU.
  7. (Optional) Add Custom Packs (or use the presets: MS/HDRP/ORM.)
  8. Choose a valid Output Folder.
  9. (Optional) Enable Export FBX / Keep Final .blend.
  10. Click Bake and watch the status/progress as your open file stays safe.
Result: Game ready asset packed with the selected basic textures.
Result: Game ready asset packed with the selected basic textures.

Custom Channel Packing, a Metallic–Smoothness example

Why pack channels? Engines often require packed maps to reduce sampler count and bandwidth, and to match expected inputs: Unity Standard/URP uses Metallic + Smoothness (A), glTF/Unreal use ORM (R=AO, G=Roughness, B=Metallic), and Unity HDRP uses a Mask Map (typically R=Metallic, G=AO, B=Detail, A=Smoothness).

Key concept: Metallic–Smoothness means R = Metallic, A = 1 − Roughness (Smoothness). ORM means R = AO, G = Roughness, B = Metallic.

  1. Follow the Quick Start steps to set up your bake.
  2. Open Custom Packs → New Pack, name it MetallicSmoothness_Unity, set Output Format = RGBA (8-bit).
  3. Map channels:
    • R → Metallic
    • G → None (0)
    • B → None (0)
    • A → Roughness with Invert (Smoothness)
    Ensure Metallic and Roughness inputs are enabled for the pack. Alternatively, use Add Presets to append MS / ORM / HDRP mask in one click.
  4. Click Bake to generate the packed texture.
  5. Assign in-engine (Unity): set Base Map = BaseColor; Metallic Map = the packed Metallic–Smoothness (A channel drives Smoothness).
Custom channel pack settings for Metallic Smoothness
Custom pack settings for Metallic–Smoothness.
Result: one RGBA packed map driving Metallic (R) and Smoothness (A).
Result: one RGBA packed map driving Metallic (R) and Smoothness (A).

High → Low poly baking, a keyboard / keys scenario

Goal: Bake the High keyboard (with text meshes) into the Low keyboard (no text meshes) so the low-poly keycaps get textures containing the legends.

The high-poly and low-poly models
The high-poly and low-poly models.
  1. Follow Quick Start to prepare your settings.
  2. Select Source & Target: Select High (source), enable Bake to Target, set Target = Low (receiver). Keep both objects aligned with identical origins.
  3. Projection control:
    • Start with Max Ray Distance ≈ 0.2–0.5% of model size.
    • For tight gaps/decals, use a Cage or Cage Extrusion (~0.2–0.5% outward).
    • Thin legends: add slight thickness on High (e.g., 0.2–0.5 mm) or rely on a cage to capture shallow relief.
  4. Click Bake and monitor the progress UI.
  5. Assign the baked textures to the Low model and verify the result.
High to Low Poly Bake Settings
High→Low bake settings.
Bake process completed. The low-poly result model with the assigned textures.
Bake completed - Low-poly with assigned textures.

Output & naming

Textures are saved into your chosen Output Folder. Typical names:

<Object>_<Map>_<Resolution>.png
  # e.g., Crate_BaseColor_2048.png, Crate_Normal_2048.png

Packed outputs follow their pack name:

<Object>_MS_2048.png
  <Object>_HDRPMask_2048.png
  <Object>_ORM_2048.png

FAQ / Tips

Check the Normal Convention: OpenGL (Y+) vs DirectX (Y−). Try toggling Flip Normal Y if your target engine uses the opposite convention.

Increase UV Island Margin and/or Bake Margin (px). For tight assets, consider MANUAL UVs or limit Smart UV to specific materials via the whitelist.

No. Baking runs in a background headless Blender subprocess on a temporary copy of your scene. Your open file stays responsive and unmodified.

Atlas Bake runs the bake in a headless Blender subprocess so your open file remains safe. If that worker crashes, the UI may appear to be “stuck on Baking…”.

Quick recovery:
  1. Click Cancel Bake. This drops a cancel.flag into the worker folder and the UI should clear within a few seconds.
  2. If the UI still looks stuck, press Cancel Bake again, then toggle the panel (collapse/expand) or switch tabs to force a refresh.
  3. Open the Worker folder path shown in the panel (if displayed) and delete the temporary worker directory to clean up.
  4. As a last resort, save your .blend and restart Blender (your open scene was never modified by the worker.)
Tip: Check the bake.log inside the worker folder for the crash reason (GPU memory, missing textures, etc.).

Baking performance depends on scene complexity, texture size, and device setup.
  • Use GPU: In Preferences → System, enable your GPU (CUDA/OptiX/Metal). In Atlas Bake, enable Use GPU.
  • Lower samples for scalar maps: BaseColor/Normal might need more samples in some pipelines, but Metallic/Roughness/AO usually look identical at 1–4 samples.
  • Reduce texture size: Try 2K instead of 4K while iterating.
  • Limit included materials/objects: Bake only what you need.
  • Apply Scale/Rotation on high/low before high→low baking to avoid projection re-tries.
  • Disable heavy modifiers (or use a duplicate export mesh) to reduce geometry the worker has to process.
  • Close other heavy apps to free VRAM/RAM.
If you still see stalls, check bake.log in the worker folder for time sinks (UV unwrap, subdivision, memory).

Currently Atlas Bake exports PNG (lossless, RGBA). This is a solid default for engines and DCC tools.

Recommended color spaces in Blender:
  • sRGB: Base Color (albedo).
  • Non-Color: Metallic, Roughness, AO, Opacity, packed channels, Normal maps.

Atlas Bake currently exports FBX and a baked .blend copy of the result.
  • FBX: Engine-ready (Unity/Unreal friendly). Textures are written to your output folder; materials are set up to reference those files.
  • .blend: A saved baked scene you can re-open and tweak.

Use the Output directory in Atlas Bake’s panel.
  • Paths starting with // are relative to your .blend (e.g., //atlas_bake_packs/).
  • If the .blend is unsaved, Atlas Bake resolves to a safe temporary location and shows the raw string in the UI so you can adjust it.
  • Each job creates a worker folder for logs and intermediates; final textures and exports go to the output directory.

Open the worker folder path (shown during a bake, if available). You’ll find logs.text. These logs capture device selection, UV unwrap, image saves, and exporter output. It's the fastest way to spot missing textures or GPU memory errors.

Click Cancel Bake. Atlas Bake writes a cancel.flag to the worker folder and stops the job cleanly without touching your open scene. If you’ve mapped Esc to call the same operator, pressing Esc will do the same. Once canceled, the status changes to “Cancel requested…” and the UI clears when the worker exits.

Contact

Questions or issues? Open an issue on the GitHub Repository or Email: john.deligiannis1@gmail.com.

License

GPL-3.0-or-later. See the LICENSE file for details.

Back to top ↑