Unreal 5.8 - Materials Masterclass - Chapter 4: What are Normal maps?

Main ideas / lessons

• Normal maps solve a performance/quality problem in real-time 3D

  • High-detail models (millions of polygons) are too expensive for games and can overwhelm the GPU.
  • Normal maps let you keep geometry flat while tricking the lighting engine into rendering the surface as if it has fine bumps, cracks, and depth.

• Normal maps are “baked” from a high-detail mesh

  • A detailed source mesh is used to generate a texture that encodes lighting/geometry cues.
  • This precomputation step is called baking: converting runtime-heavy detail into a compact texture.

• How normal maps store direction (RGB channels as vector components)

  • Normal maps are not “images” visually; they encode vector direction.
  • The RGB channels represent the surface direction along axes:
    • Red = X
    • Green = Y (may be reversed depending on engine: DirectX vs OpenGL)
    • Blue = Z depth / toward camera
  • For a perfectly flat surface:
    • Blue is ~100%
    • Red and Green are ~50% each, producing the common purple/blue appearance.
  • The engine uses these values per pixel to compute lighting, creating a depth illusion without extra polygons.

• Mental model: normal maps as pre-baked lighting responses

  • A simplified analogy:
    • Shine a red light from the right → highlights/shadows correspond to “right/left” direction data.
    • Shine a green light from above → highlights/shadows correspond to “up/down” direction data.
  • In practice, the engine evaluates the normal map data for each pixel many times per second.

• Adjusting normal strength in Unreal

  • If the relief is too strong/weak, use the Flatten Normal node to control intensity.
  • The node behaves like:
    • Flatness = 0 → no change (default strength)
    • Flatness > 0 (e.g., 0.5) → reduces convexity/relief
    • Flatness = 1 → makes it fully flat (smooth plastic)
    • Flatness < 0 (e.g., -1, -2) → exaggerates relief, producing sharper/deeper shadows in crevices

• Stacking multiple normal maps (brick + rain/water)

  • To simulate water runoff:
    • Overlay a second normal map that represents river/water flow.
    • Animate it with a panner so it moves downward.
  • Normal maps can’t be naively added like colors; they require correct vector blending.
  • Use Blend Angle Corrected Normals to combine two normal maps properly.

• Simulated refraction using the normal map’s red/green data (UV distortion trick)

  • True refraction is possible but performance-heavy and may require layered approaches or multiple objects.
  • Instead, reuse normal map vector data to distort UVs:
    • Extract red and green from the water normal map (direction information).
    • Multiply by a small scalar (e.g., 0.01) to control distortion strength.
    • Add this to the base Texture Coordinates UVs.
    • Feed the distorted UVs into the brick textures (base color, roughness, and normal) so the brick appears refracted by moving water.

• AAA-level considerations

  • For a more professional “wet surfaces” look:
    • Darken the brick when wet (e.g., via roughness changes so wet areas become shinier over time).
    • Add runtime parameters to control water amount/speed if weather changes dynamically.
  • Improvements like these are planned to be covered later using material parameters.

---

Methodology / step-by-step instructions (Unreal material workflow)

A) Create a brick wall material using normal maps

• Add Texture Sample nodes:
  • Brick Base Color texture (e.g., “brick 001” color)
  • Brick Roughness texture (select version with roughness parameter)
  • Brick Normal texture (select the normal map)
• Duplicate nodes as needed (e.g., Ctrl + D).
• Initially enable base color + roughness, keep normals off.
• Verify the preview looks correct, then:
  • Connect the normal texture to the material’s Normal output.
  • If lighting looks wrong, ensure the correct normal map was chosen.

B) Control normal map intensity (Flatten Normal)

• Add a Flatten Normal node.
• Connect:
  • Flatten Normal RGB output/input wiring:
    • Plug the existing normal into the node’s first input (normal vector / Vector3).
  • Create/plug a scalar into Flatness.
• Use the Flatness behavior:
  • 0 → default strength
  • 0.5 → weaker relief
  • 1 → completely flat
  • -1 or -2 → stronger relief / sharper crevices

C) Overlay a moving water normal map

• Add a second Texture Sample for a water/river flow normal map.
• Animate it:
  • Add a Panner node.
  • Connect Panner output to the normal map’s UV input.
  • Set a small vertical speed (e.g., -0.1) so it flows downward.

D) Blend brick normal + water normal correctly

• Use Blend Angle Corrected Normals instead of Add.
• Connect:
  • Brick normal → Base Normal
  • Water normal → Additional Normal
• Optionally reduce water effect using Flatten Normal (example given: 0.5).

E) Simulate refraction by distorting brick UVs using water normal data

• From the water normal map:
  • Use a Mask component to extract Red and Green channels.
• Multiply extracted RG by a small scalar (e.g., 0.01).
• Add this distortion to Texture Coordinate UVs:
  • Multiply output → add input
  • TextureCoordinate → other add input
• Use resulting distorted UVs to drive:
  • Brick Base Color UVs
  • Brick Roughness UVs
  • Brick Normal UVs
• Result:
  • The brick texture appears to be refracted and “carried” by water flow.

---

Speakers / sources featured

• Enrique (the channel/instructor; explicitly says “I’m Enrique” and teaches the lesson)