Getting textures from Blender into Unreal Engine 5 should be straightforward. In practice, it is one of the most error-prone parts of the indie game development pipeline. Normal maps appear inverted. Roughness looks wrong. Metallic materials render as flat gray. Textures import with the wrong color space. These are not edge cases — they happen to nearly everyone, and each one can cost an hour of confused debugging if you do not know what to look for.

This guide walks through the complete texture pipeline from material creation in Blender to final import in UE5, highlighting every place where things commonly go wrong and how to prevent it.

Step 1: Material Creation in Blender

Before you bake anything, your Blender materials need to be set up correctly. There are two common starting points:

Procedural Materials

If your materials are built from Blender's procedural nodes (Noise Texture, Voronoi, Color Ramp, etc.), they are resolution-independent and only exist as a node graph. To get them into Unreal, you must bake them to image textures. The node tree itself cannot transfer — Blender's shader nodes and Unreal's material nodes are completely different systems.

Image-Based Materials

If your materials already use image textures (downloaded PBR sets, textures from Substance Painter or similar), you can either re-bake them to new UV layouts or export the source images directly. Re-baking is necessary if you have modified the textures with additional nodes (overlay effects, color corrections, mixed layers).

Material Setup Checklist

Before baking, verify:

• UV maps are clean. No overlapping UVs for unique bake targets. Overlapping is fine for tiling materials but will cause bake artifacts for unique assets
• Materials use Principled BSDF. Custom shader setups can bake, but Principled BSDF maps most cleanly to UE5's material model
• Normal maps are connected to the Normal Map node (not directly to the Principled BSDF Normal input). This matters for correct baking
• Roughness and Metallic are separate channels, not mixed together. UE5 expects separate control over each

Step 2: Baking PBR Maps in Blender

Blender's built-in baking system works but requires careful configuration for each map type. Here is what you need to bake for a standard PBR workflow:

Base Color (Albedo)

• Bake type: Diffuse (with only Color pass enabled — disable Direct and Indirect lighting contributions)
• Color space: sRGB (this is a color map, it stores perceived color)
• Common mistake: Leaving Direct/Indirect enabled, which bakes lighting into your albedo. Your texture will look pre-lit and wrong under any other lighting condition

Bake settings for Base Color:
- Bake Type: Diffuse
- Influence > Color: ON
- Influence > Direct: OFF
- Influence > Indirect: OFF
- Image color space: sRGB

Normal Map

• Bake type: Normal
• Color space: Non-Color (this is data, not color)
• Space: Tangent (for standard game engine use)
• Common mistake: Baking in Object space instead of Tangent space. Object space normals break when the mesh is deformed or rotated

Roughness

• Bake type: Roughness (available in Blender 3.0+), or bake from the Roughness output using an Emission shader trick
• Color space: Non-Color
• Common mistake: Saving as JPEG, which introduces compression artifacts in grayscale data. Use PNG or EXR

Metallic

• Bake type: Emit with the Metallic value routed to an Emission shader
• Color space: Non-Color
• Note: Blender does not have a native Metallic bake pass. The standard workaround is to temporarily connect your metallic data to an Emission shader and bake the Emit pass

Ambient Occlusion

• Bake type: Ambient Occlusion
• Color space: Non-Color
• Note: This is baked AO from geometry proximity, useful for adding depth to crevices

Height / Displacement

• Bake type: Emit with height data routed to Emission, or use a dedicated height bake setup
• Color space: Non-Color

The manual process of configuring each bake pass, creating target images, setting color spaces, and baking one map at a time is tedious and error-prone. For a single material, you might spend 20-30 minutes just on baking. For a project with dozens of materials, this adds up to days of repetitive work. This is exactly why we built One-Click PBR Bake & Export — it handles all of these passes, color space settings, and output configurations in a single click, but understanding the manual process is important so you know what the tool is doing and can troubleshoot when needed.

Step 3: The DirectX vs OpenGL Normal Map Problem

This is the single most common texture pipeline error between Blender and Unreal, and it is worth understanding thoroughly.

The Problem

Blender uses OpenGL normal map convention. Unreal Engine uses DirectX normal map convention. The difference is the green channel (Y axis) — it is inverted between the two standards.

Visually, an OpenGL normal map used in a DirectX engine will make bumps appear as dents and dents appear as bumps. It is subtle on flat surfaces but immediately obvious on anything with clear directional detail (bricks, tiles, fabric weave).

How to Identify the Problem

Look at the green channel of your normal map:

• OpenGL (Blender): Bright green = up (positive Y)
• DirectX (Unreal): Dark green = up (inverted Y)

If your normal maps look wrong in Unreal — details appear inverted, light catches edges on the wrong side — this is almost certainly the issue.

The Fix

You have three options:

1. Flip the green channel before export. In Blender's compositor or an image editor, invert just the green channel. This is the cleanest approach
2. Flip in Unreal on import. In the texture import settings, enable "Flip Green Channel." This works but is easy to forget and inconsistent across a project
3. Use a baking tool that handles it automatically. One-Click PBR Bake & Export includes a DirectX normal map option that flips the green channel during bake, so the exported texture is immediately correct for Unreal

Our recommendation: Handle it at the source (option 1 or 3) so you never have to remember per-texture import settings in Unreal.

Step 4: ORM Packing

Unreal Engine's default material setup expects textures to be channel-packed for efficiency. The most common packing format is ORM:

• R (Red channel): Ambient Occlusion
• G (Green channel): Roughness
• B (Blue channel): Metallic

Why Pack Channels?

Three separate grayscale textures use three texture samples in the shader. One ORM-packed texture uses one sample. On a material with many properties, this difference matters for GPU performance. Unreal's default material template includes an ORM input specifically for this.

How to Pack in Blender

Manually, you would:

1. Open each grayscale map (AO, Roughness, Metallic) in Blender's compositor or an image editor
2. Assign each to the correct RGB channel of a new image
3. Save the combined image

In Python, this looks like:

import numpy as np
from PIL import Image

ao = np.array(Image.open("AO.png").convert("L"))
roughness = np.array(Image.open("Roughness.png").convert("L"))
metallic = np.array(Image.open("Metallic.png").convert("L"))

orm = np.stack([ao, roughness, metallic], axis=-1)
Image.fromarray(orm).save("ORM.png")

The important detail: the ORM texture must be imported into Unreal with sRGB disabled (it is data, not color). If sRGB is enabled, Unreal applies a gamma curve that shifts all your roughness and metallic values.

Again, One-Click PBR Bake & Export handles ORM packing as part of its export pipeline, assembling the packed texture from the individual baked maps automatically.

Step 5: Export Settings from Blender

Image Format

• PNG for most textures (lossless, widely supported)
• EXR if you need 16-bit or 32-bit precision (height maps, displacement)
• Never JPEG for PBR data maps (roughness, metallic, normal). JPEG compression destroys the precise values these maps rely on. It is acceptable for albedo if file size is critical, but PNG is preferred

Resolution

Match your target platform:

• 4K (4096x4096) for hero assets and close-up materials
• 2K (2048x2048) for standard props and environment materials
• 1K (1024x1024) for distant objects, LODs, or mobile targets

Unreal will compress textures on import anyway, but starting with clean high-resolution sources gives the compression algorithm better input.

Color Space Verification

Before exporting, double-check every texture's color space in Blender:

Getting this wrong is the second most common pipeline error after the normal map flip. A roughness map in sRGB will look too bright in the midtones, making everything appear more glossy than intended.

Step 6: Importing into Unreal Engine 5

Texture Import Settings

When importing textures into UE5, verify these settings:

Base Color:

• Compression: Default (DXT1/BC1 for opaque, DXT5/BC3 with alpha)
• sRGB: Enabled

Normal Map:

• Compression: Normalmap (DXT5n/BC5)
• sRGB: Disabled
• Texture Group: WorldNormalMap
• Flip Green Channel: Only if you did not handle the DirectX conversion at export

ORM (Packed):

• Compression: Masks (no sRGB, preserves channel independence)
• sRGB: Disabled

Height/Displacement:

• Compression: Grayscale or Alpha
• sRGB: Disabled

Common Import Pitfalls

Auto-detected sRGB. Unreal tries to auto-detect whether a texture is sRGB based on naming. If your files are not named with standard suffixes (_N for normal, _ORM for packed), Unreal may guess wrong. Always verify.

Compression artifacts on normals. The default DXT1 compression is lossy and destroys normal map quality. Always set normal maps to the Normalmap compression setting, which uses BC5 and preserves the X and Y channels with higher precision.

Texture streaming pool. If you import many 4K textures, you may exceed Unreal's default texture streaming pool size. Increase it in Project Settings > Engine > Rendering > Textures if you see blurry textures at runtime.

Step 7: Material Setup in Unreal

Create a Material or Material Instance in Unreal that uses your imported textures:

Base Color → Texture Sample (Base Color map)
Normal → Texture Sample (Normal map)
Ambient Occlusion → R channel of ORM
Roughness → G channel of ORM
Metallic → B channel of ORM

The ORM texture connects to a single Texture Sample node, and you break out individual channels using a ComponentMask or by connecting directly to the separate material inputs.

For materials that use all standard PBR channels, consider making a master Material with parameters and creating Material Instances for each specific material. This reduces shader compilation and makes iteration faster.

The Full Pipeline Checklist

Here is a condensed checklist you can reference every time you move textures from Blender to Unreal:

1. UV maps are clean and non-overlapping (for unique bakes)
2. Materials use Principled BSDF
3. Each PBR map baked with correct settings and color space
4. Normal map green channel flipped for DirectX convention
5. ORM texture packed (AO/Roughness/Metallic in R/G/B)
6. All textures exported as PNG, correct color space
7. Textures imported into Unreal with correct compression settings
8. sRGB enabled only for Base Color, disabled for everything else
9. Normal maps using Normalmap compression
10. Material wired with correct channel connections

Every item on this list is a place where the pipeline can silently break. The texture will import, the material will compile, but something will look subtly wrong — and tracking down which step went wrong can take hours.

Understanding this pipeline end to end is what separates a smooth asset workflow from a frustrating one. Whether you automate parts of it with tools or do it manually, knowing what each step does and why it matters will save you significant debugging time across any project.