Unreal 5.8 - Materials Masterclass - Chapter 5: Essential Material Math

Main ideas and lessons (what the chapter teaches)

• Material math is the key to advanced texture effects beyond basic UV scaling/offsetting and normal-map usage.
• Unreal Engine’s Material Editor math nodes can:
  • Modify contrast and shape masks (Power / Saturate / OneMinus).
  • Blend textures or values using controlled mixing (Lerp).
  • Safely handle value ranges so masks don’t break (Clamp/Saturate).
  • Generate repeating patterns and animated effects procedurally (Sine, with Time, plus normalization).

---

Methodology / node-instruction walkthroughs

1) Power node (contrast shaping)

Concept: Raise values (typically 0–1) to an exponent to change the distribution of gray tones.

How it works

• Values of 0 stay 0; values of 1 stay 1.
• Values >1 grow exponentially (can cause issues if used as mask values).
• Values between 0 and 1 shrink toward 0 when exponent increases.

Practical effect

• Exponent > 1: pushes mid-grays toward black, creating crisper masks.
• Exponent = 1: no change.
• Exponent < 1: pushes mid-grays toward white, increasing highlight dominance.

Common use case in the video

• Take a soft grunge texture (mask with fuzzy gray edges).
• Feed it into Power with a higher exponent to crush gray tones into a sharp black/white mask for paint splatters.

---

2) Lerp node (linear interpolation / crossfade)

Concept: Blend between A and B using an alpha factor (0–1).

Node inputs

• A: first value/texture (or color)
• B: second value/texture (or color)
• Alpha: mix amount

Behavior

• alpha = 0 → output = A
• alpha = 1 → output = B
• alpha = 0.5 → halfway blend

Applies to multiple data types

• Scalars (values)
• Colors (as vectors)
• Textures (via Texture Sample outputs)

Mask-driven blending workflow

• Build/prepare a mask (e.g., via Power).
• Use it as Lerp alpha to decide where texture A vs texture B appears.

---

3) Inverting masks correctly (OneMinus instead of “* -1”)

Concept: Mask inversion should map 0→1 and 1→0.

Wrong instinct explained

• Multiplying a mask by -1 fails because Lerp alpha expects 0–1, not negative values.

Correct approach

• Use the OneMinus node.
• Rule: output = 1 - input

Practical outcome

• Black becomes white and white becomes black, producing the opposite distribution of moss/paint.

---

4) Reinforcing mask detail with Power + Multiply (and why Saturate matters)

Goal: Make moss appear stronger mainly on mortar, with controlled brightness.

Strategy shown

• Use a brick/mortar texture channel that already separates brick vs mortar.
• Feed it into Power to strengthen the contrast of the mask.
• Multiply the result by a larger number (e.g., 5/10/25/50) to amplify visibility.

Problem encountered

• After multiplying, some “white” mask regions become greater than 1.
• Feeding values >1 into Lerp alpha causes the blend to effectively exceed expected range, producing glow/oversaturation/radioactive colors.

Fix

• Use Saturate (or clamp to [0,1]) before Lerp.
• Saturate rules
  • Negative values → 0
  • Values >1 → 1
• This acts like a safety net so masks remain valid for mixing.

---

5) Sine node (procedural waves) + making them usable as 0–1 masks

Concept: Sine creates smooth oscillation; output range is -1 to 1.

Without extra math

• Applying sine to a 0→1 gradient turns it into a repeating wave pattern.

Controlling repetition frequency

• Multiply the input to sine by a number (e.g., 5 or 10).
• That number becomes the count of wave repeats across the texture.

Animating the wave

• Use Time node feeding into the sine input (via multiplication).
• Higher multiplier → faster pulsation; lower multiplier → slower.

Handling negative values

• Since sine outputs negative values, those appear as black, causing discontinuities.

Three solutions demonstrated

• Absolute (Abs): make all values positive (negative lobes flip upward).
• Offset + scale (typical breathing curve):
  • Add 1 to sine output → range becomes 0 to 2
  • Divide by 2 → range becomes 0 to 1
• (Overall purpose: keep oscillation usable as mask/alpha.)

---

Building the example multilayer moss material (combined application)

Overall workflow:

1. Prepare textures (brick + moss color/roughness + moss normals).
2. Create a moss mask:
   • Take a chosen moss texture channel (green chosen).
   • Apply Power (to narrow/crisp it).
   • Apply Multiply (to strengthen values).
   • Apply Saturate (to prevent out-of-range issues).
3. Use Lerp nodes to apply moss mask to different material properties:
   • Base Color: Lerp between brick color (A) and moss color (B) using moss mask alpha.
   • Roughness: Lerp using moss mask with roughness computed from moss channel through Power/Multiply/Saturate.
4. Normals blending workflow (more complex than color/roughness):
   • Start with Blend Angle Corrected Normals to combine brick and moss normals correctly.
   • Then gate it with a third Lerp so the combined “mossy” normals show only where the moss mask is present.
5. Add graffiti/extra overlay:
   • Use texture alpha (for PNG transparency) as Lerp alpha to overlay graffiti color.
   • Optionally multiply the graffiti alpha by a scalar (e.g., 0.7–0.8) to reduce opacity and let wall/moss show through.
6. Exercise suggestion (not demonstrated fully)
   • Use additional mask operations (e.g., lerp metallic, or subtraction to prevent moss from growing over graffiti).

---

Final section: Using Sine to create glowing graffiti with a moving diagonal stripe mask

Goal: Emit (glow) only on graffiti areas, with animated diagonal stripes.

Create a diagonal stripe mask procedurally

• Use UV data:
  • Break the UV into components (U and V).
  • Combine them via addition to form a diagonal gradient.
• Normalize the gradient range (divide by 2 / multiply by 0.5).
• Apply Sign after scaling, producing a striped wave that repeats.
• Control stripe frequency by multiplying the wave input (e.g., 5, 10, or fractions like 0.25).
• Make the “number of bands” user-controllable via a multiplication node parameter rather than hard-coding a combined constant.

Animate the stripes

• Use Time to offset the UV/gradient input (scaled and moved, including negative offset to change direction).

Make stripes thin

• Apply Power with a high exponent (e.g., 40–50) to narrow the bright stripe regions.
• Use Saturate to keep values non-negative and mask-safe.

Restrict glow to graffiti

• Multiply the procedural stripe mask by the graffiti texture alpha so the glow only appears where graffiti is.

Apply to emissive

• Multiply final mask by graffiti texture RGB output.
• Connect the result to the material’s Emissive output.

Result

• Graffiti glows in intervals with moving diagonal stripes while the rest of the wall remains unaffected.

---

Speakers / sources featured

• Enrique (host/instructor; mentioned at the end: “I’m Enrique, and I’ll see you in the next video.”)