In short: generate or bake a height/detail source, turn it into a tangent-space normal map, keep the image as data, connect it through the material normal input and validate its direction in the final engine. A normal map changes lighting response, not silhouette. The generated texture is only useful when the channel convention, colour space and mesh tangents agree.
The common failure is not “the normal map looks wrong.” It is a specific disagreement between data and renderer: green channel inverted, source interpreted as sRGB, tangents missing or the wrong channel packed. If you test those contracts before adjusting artistic strength, most problems become easy to identify.
Can Blender AI generate a normal map?
Yes, when the workflow starts from real height or high-poly detail. Blender AI can generate material ideas, a height source or a detailed high-poly mesh. It cannot guarantee that every generated colour image is a physically coherent normal map. Treat the visual preview as the brief and the data conversion as the technical step.
| Source | Good for | What still needs checking |
|---|---|---|
| Grayscale height texture | Panels, fabric, scratches, tileable surface detail | Luminance, seams, scale and false baked lighting |
| High-poly mesh | Accurate detail transferred onto a game low-poly model | UVs, cage, ray distance and tangent space |
| Procedural shader detail | Control, variation and clean data generation | Conversion to an image map and consistent scale |
| Generated colour concept | Visual direction and material palette | Whether any usable height or normal information exists |
What does a normal map actually store?
A normal map stores surface-direction vectors in the RGB channels. In a tangent-space map, those vectors are relative to the mesh UV tangent, bitangent and normal. A neutral flat surface normally sits near the familiar blue-purple value, while the red and green channels tilt that direction across the surface.
This is why normal maps are data textures. Their colours are not the visible material colour. The renderer uses them to perturb lighting at shading time. Object-space normal maps store a different coordinate space and are not interchangeable with tangent-space maps.
- R: horizontal direction relative to the tangent.
- G: vertical direction, commonly the channel that varies between OpenGL and DirectX conventions.
- B: the surface-facing direction in tangent space.
How do you turn height into a normal map in Blender?
Read the height texture as non-colour data, derive slope from its luminance and feed the result through a Bump node into the surface Normal input. Adjust the node strength and distance against a simple test scene before baking or exporting the image. The Blender shader-node documentation is the reference for node behaviour and colour management.
A practical setup is:
- Place a neutral gray-to-white height texture in the shader.
- Set the image Color Space to Non-Color.
- Feed the image through a Bump node.
- Connect Bump Normal to the surface Normal input.
- Inspect a raised ridge with one directional light.
- Bake or export a tangent-space normal image when required.
For detailed high-poly to low-poly transfer, use the texture-baking workflow. Baking compares real surface geometry, while height conversion infers slope from grayscale values.
Should you use OpenGL or DirectX normal direction?
Use the direction required by the target engine and content pipeline. The two conventions differ primarily in how the green channel is interpreted. A map that looks correct in Blender can appear lit backwards after import if the convention changes without conversion.
| Check | Correct result | Wrong result |
|---|---|---|
| One light from above | Raised bevels catch light from above | Bevels appear indented |
| Screen-space highlight | Light moves consistently across surface detail | Detail reacts in the opposite direction |
| Camera orbit | Direction remains attached to the surface | Highlights shift like a misaligned screen-space effect |
| Engine import | Compression and normal type preserve direction | Flat, noisy or inverted shading |
Do not invert channels until you confirm the import convention. Make a backup of the source map and document whether the delivered file is OpenGL- or DirectX-style.
How do you apply a normal map in Blender?
For an image normal map, open the material’s Shader Editor and connect the image to the Color input of a Normal Map node, then connect the Normal Map node to the BSDF surface Normal input. Set the image to Non-Color and choose the tangent-space orientation the map was authored with.
Keep the mesh UVs and tangents intact. A normal map cannot compensate for stretched UV islands, missing tangents or an object with broken transforms. Test on a neutral material first so roughness, metallic reflections or baked colour do not hide direction errors.
- Texture mode: use a normal-data texture, not a colour image.
- Strength: adjust after direction is correct; high strength does not repair an inverted map.
- UVs: keep island scale consistent so detail does not stretch across seams.
- Material: inspect base colour, roughness and metallic channels independently.
Why does a normal map look inverted or washed out?
Inversion usually comes from the green-channel convention or an inverted height source. Washed-out detail commonly comes from sRGB interpretation, excessive image compression, a strength setting that is too low or a neutral base value that is not neutral. Diagnose one cause at a time.
| Symptom | Likely cause | Check |
|---|---|---|
| Bevels look pressed inward | Opposite green convention or reversed height | Single directional light and channel comparison |
| Surface looks flat | sRGB data, low strength or weak source contrast | Color Space, node strength and height range |
| Noise and blocky rings | Overaggressive JPEG/block compression | Lossless/PNG source and engine compression |
| Lighting changes at UV seams | Tangent or UV mismatch | Seam placement, smoothing, tangents and padding |
| Strength keeps looking wrong | The map direction is incorrect | Stop adjusting strength; fix channel direction first |
How do you validate a normal map in Unity or Unreal?
Import the texture with the engine’s normal-map type, confirm it is not treated as sRGB colour, then test it on a lit sphere and on the final mesh. Compare neutral, raised and recessed areas. A sphere isolates direction; the final asset exposes UV, tangent and seam problems.
In Unity, inspect the texture importer and material slot with the Unity texture import reference. In Unreal, follow the normal-map guidance, then compare the final material under the project’s real lighting. Engine preview thumbnails are not enough.
- Use a neutral test sphere before testing the hero asset.
- Rotate one light around the surface and inspect direction.
- Check tiling and seam density at gameplay distance.
- Inspect texture compression and normal-map flags after import.
- Verify the final shader uses the correct UV channel.
What should you generate and what needs hand checking?
Generate the material direction and height source freely. Hand-check the data contract: neutral value, height range, tangent convention, colour space, UV density and engine import. This is a small technical pass that prevents a visually attractive texture from becoming a lighting bug across the whole asset.
| Task | AI-assisted | Human verification |
|---|---|---|
| Material concept | Yes | Scale, direction and production restraint |
| Height source | Yes | False lighting, seams and value range |
| High-to-low normal bake | Partial geometry assistance | Cage, ray distance, UVs and tangent space |
| Engine import | No | Normal type, compression, UV channel and green convention |
| Final art acceptance | No | Gameplay distance, lighting and material readability |
Key takeaways
- Generate height or high-poly detail before treating a texture as a normal map.
- Normal maps store direction; they must be handled as Non-Color data.
- Confirm OpenGL or DirectX direction with one controlled light before changing artistic strength.
- Test the map on a sphere for direction and on the final mesh for UVs, tangents and seams.
- Validate the actual Unity or Unreal import. A Blender viewport preview does not prove engine correctness.