Normal Map Creation: From High-Poly Bake
You've finished the sculpt, retopology looks clean, and the low-poly asset is sitting under the high-poly source exactly where it should. Then the bake finishes and the render shows black seams, swollen corners, or details that appear to melt across the UV borders. Most normal map failures start before the baker opens. The mesh, transforms, UVs, smoothing, cage, and tangent convention all have to agree before RGB pixels can describe the surface correctly.
Normal map creation is therefore a choice and validation problem, not just a button in Substance Painter or Blender. A bake can deliver convincing small-scale detail at low geometry cost, while an image-derived map can rescue a reference-driven material without a sculpt. In other cases, displacement or actual geometry is the more honest solution. The workflow below focuses on those decisions, with the production checks that prevent the artifacts beginners usually discover only after export.
Table of Contents
- What a Normal Map Does
- Pre-Bake Checklist That Prevents Most Failures
- Baking From High-Poly to Low-Poly
- Generating Normal Maps From Images and AI
- Editing, Painting, and Fixing Normal Maps
- When Normal Maps Are the Wrong Choice
- Export Settings for Games and 3D Printing
What a Normal Map Does
A normal map stores a per-pixel 3D direction vector in three RGB channels. Each channel commonly remaps one component of a surface normal from −1 to 1 into a color range from 0 to 255, so standard texture formats and rendering hardware can carry directional lighting data. The technique became a recognized graphics method through work presented at SIGGRAPH in 1996, followed by research and real-time hardware adoption in the late 1990s and early 2000s (historical overview of normal mapping).
The neutral tangent-space normal is commonly displayed as RGB 128, 128, 255. It tells the renderer to use the low-poly surface direction without adding a perturbation. Red and green values tilt the normal across the tangent plane, while blue usually remains dominant because it represents the direction away from the surface in tangent space. The map does not carve a groove into the mesh. It changes how light is calculated across the existing surface.
Tangent space is the practical default
Tangent-space maps store directions relative to each point on the low-poly surface. The map follows the mesh as a character bends, making tangent space the usual choice for skinned characters, deforming props, and assets shared between real-time engines. Object-space and world-space maps describe directions in fixed coordinate systems. They can suit rigid assets or specialized pipelines, but they become less flexible when a model rotates, mirrors, or deforms.
A bump map begins with grayscale height information and perturbs shading in a similar way. A normal map stores the resulting direction directly. Displacement changes geometry, so it can alter silhouettes, cast physical shadows, and support physical output. A normal map only changes lighting on the existing surface, which makes it efficient for small detail but unsuitable for changing an outline.
The choice should follow the result you need. Bake a normal map when the detail must read in lighting but does not need physical depth. Generate one from an image when a reference provides surface information without a high-poly source, then inspect it for false edges and inconsistent direction. Skip the map when silhouette, shadow shape, or printed relief depends on real depth. For context on how maps fit into asset production, see 3D models and textures.
Pre-Bake Checklist That Prevents Most Failures
A high-poly mesh that hasn't been validated can poison every later step. Holes, internal faces, duplicate shells, non-manifold edges, and accidental overlaps create ambiguous projection rays. The baker may still produce an image, but the result can contain blurred gradients, noisy patches, or details projected from the wrong side.
Start with the source mesh
Check the high-poly first, then inspect the low-poly as a separate asset. In Blender, Mesh Analysis can reveal non-manifold conditions and overlapping elements. Maya's Cleanup tools help identify problematic topology, while ZBrush's geometry and mesh repair functions can expose holes or damaged surfaces.
Use this order:
- Confirm the high-poly is clean. Remove internal faces, duplicate geometry, hidden shells, and zero-thickness construction surfaces that shouldn't contribute to the bake.
- Match the projection surfaces. The high- and low-poly meshes need to overlap in world space. If the low-poly sits outside the sculpt in one region, the cage can't recover the missing information.
- Apply transforms. Freeze or apply scale and rotation before baking. Confirm that the asset's axis orientation matches the target application.
- Validate the low-poly structure. Remove interior faces and duplicate geometry. Check that face normals point outward, because reversed normals can make a valid surface behave like an inverted projection target.
The low-poly doesn't need identical vertex positions, but its surface must represent the same object. Pay special attention to thin panels, deep cavities, overlapping parts, and hard edges.
Treat UVs and shading as one system
UV islands shouldn't overlap unless the mirrored arrangement is deliberate and supported by the baker and engine. Keep the intended bake UVs in channel 0, preserve enough padding for texture dilation, and make every hard edge correspond to a UV seam. A hard edge without a matching seam forces one texture pixel area to represent incompatible tangent directions. A seam without a reason can increase visible discontinuities and make painting less predictable.
Practical rule: If a hard edge and UV seam disagree, fix the mesh or UV layout before changing texture settings.
Use the same tangent-space convention from bake through import. Mismatches between the baker, DCC, and engine are a leading cause of inverted or split shading. A production-oriented checklist also recommends checking world-space overlap, applied transforms, outward-facing normals, clean low-poly topology, fully unwrapped UVs, and engine-compatible tangents before export (normal-map baking error guidance).
Red flags include stretched UVs, mixed smoothing behavior, unapplied scale, zero-thickness shells, interior faces, and mismatched cages. Fix those first. Higher texture resolution won't repair a projection that starts with conflicting geometry.
Baking From High-Poly to Low-Poly
Keep the high-poly and low-poly meshes in the same scene file and use predictable names such as asset_high and asset_low. Clear pairing makes rebakes reproducible and prevents the baker from projecting one object onto the wrong counterpart. It also makes it easier to isolate a single component when only a handle, bolt group, or trim piece needs another pass.
Set the bake target according to the asset's texel-density plan, not habit. Use tangent space for assets that deform or need to move between real-time tools. Object space remains useful for rigid assets and certain technical workflows, but it won't provide the same flexibility across animation and engine handoff.
Cage behavior matters more than decorative settings
A cage gives the baker a controlled projection surface. Inflate it enough to cover the low-poly without crossing nearby parts, and inspect concave and convex regions independently. A cage that's too small leaves gaps and missing pixels. One that's too large captures unrelated surfaces, especially around fingers, grilles, folded metal, and layered clothing.
Enable use cage explicitly where the tool provides that option. Ray distance alone can work on uncomplicated objects, but it becomes unreliable when surface spacing changes sharply. Configure front and rear projection limits, then inspect the cage from multiple angles before committing to a full bake.
Padding protects the result during mipmapping and texture filtering. Practical baking guidance recommends at least 8 to 16 pixels of padding at 2K, with 4 pixels as a minimum margin at 2K in some workflows (bake padding and validation guidance). Use power-of-two output dimensions such as 1024, 2048, or 4096 when your target pipeline expects them, and choose the smallest resolution that preserves the asset's important detail.
A practical tool comparison
| Setting | Blender Cycles | Substance Painter | Marmoset Toolbag | xNormal |
|---|---|---|---|---|
| Projection control | Ray distance and cage workflow | Match by mesh name, cage or distance | Explicit cage and skew control | Strong cage and ray controls |
| Tangent handling | Match the destination engine | Set the project convention before baking | Select the target tangent basis | Confirm exported tangent data |
| Padding | Set dilation and margin deliberately | Configure dilation and padding | Set edge padding before export | Use dilation to prevent empty borders |
| Best use | Integrated Blender scenes | Multi-map texturing and painting | Fast visual bake inspection | Dedicated projection control |
After baking, inspect corners and thin features before studying broad flat areas. Those regions reveal cage errors fastest. In tiled workflows, re-bake only the affected tile when possible, then compare it against the previous result in the target renderer. For low-poly preparation before this stage, the workflow in how to make low-poly models in Blender covers the modeling side that determines whether the bake has a stable target.
Generating Normal Maps From Images and AI
Image-to-normal generation starts with a different source problem. There may be no sculpt, only a photograph, painted albedo, scanned reference, or generated depth image. The usual route is to derive a height-like signal, estimate its gradients, and convert those gradients into a normalized surface direction. Graphics references describe this process through neighboring pixel differences, tangent construction, and a normalized cross product (technical explanation of height-to-normal conversion).
Photoshop's normal filter is convenient for quick tests and simple tileable textures. Substance 3D Sampler offers a more material-focused route, with filtering and channel controls that help when the source image needs cleanup first. CrazyBump remains useful for fast experimentation because it exposes height, occlusion, and normal interpretation without requiring a sculpting pass.
AI-assisted approaches fit earlier in the design process. Material Maker can build procedural materials from masks and nodes. Kaedim can help turn visual references into starting geometry, after which a conventional bake may still be necessary. Depth-to-normal workflows built around generative image tools can create plausible relief for concept props, but they inherit the weaknesses of the depth estimate.
| Method | Input | Output quality | Best use case |
|---|---|---|---|
| High-poly bake | Sculpted or modeled detail plus low-poly mesh | Strong local accuracy and consistent projection | Hero game assets and production props |
| Height conversion | Grayscale height or processed image | Good for repeated surface patterns, dependent on source quality | Materials, decals, and reference-based surfaces |
| AI depth-to-normal | Image, depth estimate, or generated concept | Fast and plausible, but less reliable at contacts and views | Stylized exploration and blockout |
| Manual painting | Existing map or rendered reference | Artist-controlled local correction | Repairing isolated bake errors |
The biggest limitation is multi-view consistency. A photograph or AI depth image can describe what a surface looks like from one view, but it doesn't know the true back side, contact edge, or silhouette. Dark-to-light gradients can also invert the intended relief, producing a normal that appears inside out. Always preview the result under a moving light and verify the tangent convention before building the rest of the material.
Normal maps are one part of a broader PBR set, alongside roughness, AO, displacement, and other supporting channels. A PBR texture generator can be relevant when the source is an image and you need a coordinated material set rather than an isolated normal texture. If the final asset is headed toward a broader no-code production workflow, this best game engine no code tools guide provides adjacent context, but it won't replace tangent-space validation.
Independent analysis also notes that normal-map generation includes manual, automated, and deep-learning methods, with normalization after generation helping keep encoded vectors consistent and reduce shading artifacts (technical analysis of normal-map generation).
Editing, Painting, and Fixing Normal Maps
A rendered artifact usually tells you which stage failed. A vertical seam that follows a UV boundary often points to a tangent split or hard-edge mismatch. A bright or dark strip along a mirrored island can indicate that the mirrored tangent basis wasn't handled correctly. Repeating bands usually suggest a projection or cage problem rather than a painting problem.
Start with the cheapest correction. Re-bake with a better cage, adjusted front and rear distances, or improved padding. If the seam remains, inspect the UV border and smoothing setup. Only paint after you've established that the source mesh and projection are sound.
Read the color, then isolate the cause
A normal map's colors are diagnostic, not decorative:
- Magenta or sharply contrasting edges often reveal tangent discontinuities or incompatible vertex normals.
- Gray pools or empty-looking patches can indicate missing projection data, insufficient padding, or rays that never reached the high-poly.
- Repeating stripes point toward cage intersections, skewed projection, or an object that's being sampled from the wrong side.
- Broad inverted shading usually means a channel convention mismatch or reversed geometry normals.
Mirrored UVs deserve a dedicated check. If the detail looks correct on one side but flips direction on the mirrored side, the bake and engine may disagree about mirrored tangents. Test the asset in the destination engine rather than trusting the baker preview. Import settings can change the interpretation even when the texture file itself is valid.
Paint only after the technical fixes
Substance Painter is a strong place to repair a localized area because you can paint with normal-aware tools and preserve the rest of the baked map. Photoshop can handle direct RGB edits, but it's easy to create a vector that isn't unit length or that blends poorly with neighboring normals. When combining two normal maps with a mask, use a proper normal-blend operation instead of just adding RGB values. You're blending directions, not colors.
For a broader discussion of stylus ergonomics during detailed texture work, this guide to palm rejection is useful context, especially when painting seams or small corrective regions. Keep the source bake, correction layers, cage, and export settings together. A flattened repair may hide the symptom today and make the next rebake unnecessarily expensive.
Flipping the green channel is a convention conversion, not a universal artifact fix. It can resolve a DirectX and OpenGL Y-direction mismatch, but it won't repair bad smoothing, incorrect cage projection, or a low-poly mesh that doesn't overlap the sculpt. Diagnose the rendered behavior first, then change one variable at a time.
When Normal Maps Are the Wrong Choice
Normal maps lose their advantage when the viewer can see the silhouette or when the detail must interact with the scene as physical form. A normal can make a stamped groove catch light, but it can't push the outline outward. It also won't create actual self-shadowing geometry in the way displacement or modeled forms can.
Choose detail by what the camera can prove
Use a normal map for small surface variation on a game prop, a character material, or a repeated environment surface. Use micro-geometry when individual features need to affect the silhouette and the target renderer can handle the added vertex or instance cost. Use displacement or vector displacement when the asset is viewed close enough that parallax, self-shadowing, and relief depth matter.
That choice changes across platforms. A normal map may be sensible for a mobile prop viewed at a distance, while a close-up VR asset may need actual relief to avoid a flat appearance during head movement. For a 3D print, the decision is absolute: a normal map has no physical meaning. Slicers don't turn its RGB directions into raised or recessed material. The detail must exist in the mesh, or you must convert a height representation into geometry before slicing.
Ask four questions before you bake:
- Is the silhouette visible? If yes, favor geometry or displacement.
- How close is the camera? Close views expose flattened relief.
- What platform receives the asset? Mobile, VR, desktop, offline rendering, and printing impose different costs.
- Must the detail deform or cast shadows? If it must, a texture-only solution may be insufficient.
The practical answer is often hybrid. Keep broad forms and silhouette changes in geometry, bake medium-scale sculpt detail into tangent-space normals, and use tiling material normals for fine surface noise. Don't spend texture memory simulating a form that the camera can identify as a missing edge.
Export Settings for Games and 3D Printing
Export changes the result more often than artists expect. A map can look correct in Substance Painter and appear inverted, soft, or oddly lit in an engine because the file is tagged as color data, the green channel uses another convention, or the imported mesh carries different tangents.
Use PNG when broad compatibility and standard 8-bit-per-channel output are enough. Use EXR or TIFF when the workflow needs higher channel precision for large, detailed, or displacement-related surfaces. A tangent-space normal map should generally be treated as data, not color, so disable sRGB interpretation where the destination tool expects linear vector values.
Channel conventions need an explicit decision
OpenGL and DirectX commonly use opposite Y directions in the green channel. In practice, that means a map may need its green channel inverted before import, but the correct action depends on the baker, the DCC, and the engine combination. Don't flip channels by habit. Generate a small test asset, light it from several directions, and compare the result against the source.
Y-up versus Z-up is a separate coordinate issue. It affects scene orientation and export transforms, while the green-channel question concerns tangent-space direction. Blender, Maya, Substance Painter, Unity, and Unreal can each participate in a pipeline with different import or export expectations, so record the convention in the asset notes and keep it consistent from bake to runtime.
| Tool or target | Default channel convention | Recommended format | Y-up versus Z-up handling |
|---|---|---|---|
| Blender | Project and export dependent | PNG for standard maps, EXR or TIFF for higher precision | Set scene and export axes deliberately |
| Substance Painter | Project convention controls output | PNG for game maps, higher precision formats where required | Match the destination during export |
| Unity | Import settings interpret the map | PNG with normal-map import enabled | Confirm model axis conversion on import |
| Unreal Engine | Import settings and tangent basis matter | PNG for common runtime maps | Validate imported mesh orientation |
| 3D printing slicer | Normal maps are ignored as physical detail | Export actual mesh geometry, often STL or 3MF | Apply transforms before slicing |
Mip generation can soften fine detail or make it appear to swim at distance. Inspect the material across viewing distances, and adjust mip behavior or sharpening only when the target platform supports it and the result remains stable. Compression can also introduce subtle color changes that become visible as shading noise, so review the compressed asset in-engine rather than judging only the uncompressed source.
Final production checklist
Before delivery, confirm:
- Resolution and padding: The map uses the planned texture size, with sufficient edge dilation.
- Data interpretation: sRGB is disabled for the normal texture where required.
- Naming: High, low, material, and map names make rebakes traceable.
- Tangent space: The bake, mesh export, and engine import use the same basis.
- Green channel: The Y direction has been tested, not guessed.
- Geometry choice: Silhouette, deformation, shadows, and printing requirements still justify a normal map.
Sculpty can fit the earlier asset stages by combining image-to-3D or text-to-3D generation with PBR texturing, remeshing, retopology, and exports for downstream tools. If you're testing whether a generated asset should receive a bake, an image-derived map, or actual geometry, visit Sculpty to generate and prepare the model before committing to the final pipeline.