Textures and HDRIs

Normal Maps vs Bump Maps vs Displacement Maps

How normal, bump and displacement maps differ, what each costs in performance, when to use which, and how to set up and combine them in Blender.

On this page
  1. The short answer
  2. Comparison table
  3. Bump maps
  4. Normal maps
  5. Displacement maps
  6. Parallax occlusion mapping: the in-between option
  7. Setting each up in Blender
  8. Which one should you use?
  9. Can you combine them?

The short answer

All three add surface detail, but in different ways:

  • Bump maps are grayscale height images that fake detail by changing how light shades the surface. The geometry doesn’t change.
  • Normal maps are RGB images that store the direction each point of the surface faces. They also fake detail without changing geometry, but more accurately than bump maps.
  • Displacement maps actually move the mesh’s vertices, so the detail is real geometry. It changes the silhouette and casts real shadows, but it needs a dense mesh and costs more to render.

Bump and normal maps are cheap tricks for shading. Displacement is the real thing.

Comparison table

Bump map Normal map Displacement map
Image type Grayscale (height) RGB (direction) Grayscale height, or RGB for vector displacement
Changes geometry? No No Yes
Changes silhouette? No No Yes
Self-shadowing / occlusion No No Yes
Performance cost Low Low High (needs many polygons)
Typical use Fine detail: pores, scratches, fabric weave Game assets, baked high-poly detail Close-up terrain, rock, brick, sculpted detail in renders
Works on low-poly meshes? Yes Yes Needs subdivision or dense geometry

Bump maps

A bump map is a black-and-white image where white means “higher” and black means “lower”. The renderer compares neighboring pixel values to work out the slope at each point, then tilts the shading normal as if the surface had that slope. The result is shading that suggests small bumps and grooves.

Strengths:

  • Easy to make and edit. You can paint one by hand, or use a procedural noise texture.
  • Great for fine, shallow detail like skin pores, leather grain or light scratches.
  • Cheap to render.

Limitations:

  • Because the slope is calculated from neighboring pixels, bump maps can look soft or show stepping artifacts with low-resolution or 8-bit images.
  • The detail is fake: the edges of the object stay perfectly smooth, and bumps don’t cast real shadows on each other.
  • Game engines generally prefer normal maps, so bump maps are more common in offline rendering.

Normal maps

A normal map stores a direction rather than a height. Each pixel’s red, green and blue values describe which way the surface points along three axes. That’s why most normal maps look purple-blue: a pixel facing straight out is encoded as a mid-value in red and green and a high value in blue.

Because the direction is stored directly, the renderer doesn’t have to estimate slopes, so normal maps give sharper, more accurate lighting detail than bump maps. They are the standard way to transfer detail from a high-poly sculpt onto a low-poly game model. You bake the high-poly detail into a normal map, apply it to the low-poly mesh, and the low-poly model shades almost as if it had all those polygons.

Like bump maps, normal maps don’t change the silhouette. Look at the edge of a normal-mapped brick wall at a grazing angle and you’ll see it’s flat.

Tangent space vs object space

  • Tangent-space normal maps (the purple-blue ones) store directions relative to the surface itself. They work on deforming meshes like characters and can be reused on tiling materials. This is by far the most common type.
  • Object-space normal maps (rainbow-colored) store directions relative to the whole object. They can be slightly more precise for rigid objects, but they can’t be tiled or reused on other meshes and don’t suit deforming meshes.

Downloaded materials almost always use tangent-space normal maps.

OpenGL vs DirectX normal maps

There are two conventions for the green channel:

  • OpenGL (Y+): used by Blender, Unity, Godot and Maya.
  • DirectX (Y−): used by Unreal Engine and 3ds Max.

If you use the wrong one, the lighting on small details looks upside-down: bumps look like dents and grooves look raised. Many libraries offer both versions (often labeled _gl and _dx). If you only have one, invert the green channel in an image editor, or in Blender, use a Separate Color node, invert the green channel with an Invert or Math node, and recombine with Combine Color before the Normal Map node.

Displacement maps

A displacement map uses height data to actually move the vertices of the mesh. White areas push the surface outward, black areas pull it in (or stay put, depending on the midlevel setting). Because the geometry really changes, you get:

  • Correct silhouettes, so a displaced rock wall has a bumpy edge.
  • Real self-shadowing and occlusion between bumps.
  • Detail that holds up in extreme close-ups.

The catch is that displacement can only move vertices that exist. A plane with four vertices can’t show brick detail, so you need to subdivide the mesh heavily, or use adaptive subdivision, which adds more polygons close to the camera and fewer far away. This uses more memory and render time.

For that reason, displacement is most common in offline renders (film, archviz, product shots) and for large features like terrain. In real-time engines, it’s used more selectively, for example with tessellation or with dense meshes generated in advance.

Vector displacement

Standard displacement only moves the surface in and out along its normal. Vector displacement maps use RGB values to move each point in any direction, which allows overhangs and shapes that plain height maps can’t produce, like horns or curled leaves. Sculpting tools can bake vector displacement from detailed sculpts, and Blender’s sculpt mode can use vector displacement brushes.

Parallax occlusion mapping: the in-between option

Game engines often offer parallax occlusion mapping (POM), sometimes called parallax mapping or height mapping. It uses a height map to offset the texture in the shader based on the viewing angle, which creates an illusion of depth stronger than a normal map can, without moving any geometry. Bricks look like they recess into the mortar as you walk past.

POM is more expensive than a normal map but much cheaper than true displacement. The silhouette is still flat, and the effect can break down at very steep angles. Unity’s HDRP and Unreal Engine both support parallax-style effects in their material systems.

Setting each up in Blender

All three maps should be loaded in Image Texture nodes set to Non-Color.

Bump map:

  1. Connect the height image’s Color output to a Bump node’s Height input.
  2. Connect the Bump node’s Normal output to the Principled BSDF’s Normal input.
  3. Adjust Strength (and Distance) to taste.

Normal map:

  1. Connect the normal image’s Color output to a Normal Map node’s Color input.
  2. Leave the Normal Map node set to Tangent Space for most downloaded textures.
  3. Connect the Normal Map node’s Normal output to the Principled BSDF’s Normal input.

Displacement map:

  1. Connect the height image to a Displacement node’s Height input.
  2. Connect the Displacement node to the Displacement input of the Material Output node.
  3. Set Scale to something small at first, such as 0.05–0.1, then increase it. The right value depends on your scene’s scale.
  4. Add enough geometry with a Subdivision Surface modifier (Simple mode keeps the shape of flat surfaces).
  5. In Cycles, open the material’s Settings panel and set displacement to Displacement Only or Displacement and Bump. With the default bump-only setting, Cycles treats displacement as a bump effect and the geometry won’t move.

Cycles also supports adaptive subdivision, which has historically been listed under the Experimental feature set; check the option’s location in your Blender version. EEVEE’s displacement support is more limited, so Cycles is the usual choice for true displacement renders.

For the general process of loading textures onto a model, see how to apply an image texture to a model in Blender.

Which one should you use?

  • Game assets: normal maps, nearly always. Add parallax occlusion mapping where you need extra depth on surfaces like brick floors and cobblestones.
  • Fine detail in renders (skin pores, fabric, light scratches): bump or normal maps. Bump maps are quicker to paint or generate procedurally.
  • Large detail seen up close or in silhouette (rocky terrain, deep brick, tree bark at the edge of frame): displacement.
  • Baked detail from a high-poly sculpt: normal maps for game models; displacement maps when rendering offline and you want the sculpted shape back.
  • Performance-limited scenes: avoid displacement on distant or small objects. A normal map gives most of the look for a fraction of the cost.

Can you combine them?

Yes, and it’s common. Some typical combinations:

  • Displacement for large forms, normal map for fine detail. A stone wall uses displacement to push the stones out of the mortar, and a normal map for small surface cracks.
  • Normal map plus bump map. In Blender, connect the Normal Map node’s output into the Normal input of a Bump node, then connect the Bump node to the shader. The bump detail is layered on top of the normal map. This is useful for adding procedural scratches or grime to a downloaded material.
  • Cycles’ “Displacement and Bump” mode uses the same height map for both, so geometry handles larger shapes and bump shading fills in detail finer than the mesh resolution.

If you want to understand how these maps fit into a full material, our explanation of PBR texture maps covers albedo, roughness, metallic and the rest. For materials that include all of these maps, see where to get free textures for Blender and Unity, and if you need to create height or normal maps from a photo, try one of the free texture generators we cover.

The complete guide to textures and hdris

Where to Get Free Textures for Blender and Unity
Read the guide

Keep exploring

Guides from other topics

All topics →