Part 13: REFLECTION SYSTEMS

Note on Reflection Captures: Reflection Captures (Sphere/Box) require baked lighting data to function. Since we're using Force No Precompute throughout this course, Reflection Captures won't work in our setup. They're covered briefly for completeness, but for dynamic workflows, use Lumen or SSR instead.

Like shadow systems, it's useful to think in three layers:

1. What data does the system use? (cubemap, screen pixels, ray hits)
2. How accurate is the result? (static vs dynamic, parallax vs flat)
3. What breaks first? (screen edges, noise, performance)

1) What data is being queried?

• Sky Light Cubemap (HDRI): a distant environment map — same from every position
• Screen Space: the rendered frame buffer — only what's on screen
• Lumen: Lumen's scene representation — ray traced against cached surfaces
• Hardware RT: ray queries against actual geometry — most accurate

2) How accurate is the result?

• Sky Light Cubemap (HDRI): no parallax — reflections don't shift as you move
• Screen Space: view-dependent — can only reflect visible content
• Lumen: dynamic with good accuracy — handles most scenarios
• Hardware RT: physically accurate — traces actual geometry

3) What problems should you expect?

• Sky Light Cubemap (HDRI): flat, distant-looking reflections
• Screen Space: artifacts at screen edges, missing off-screen content
• Lumen: some noise, limited by Lumen's scene representation quality
• Hardware RT: noise with low samples, highest GPU cost

• Default for most projects: Lumen Reflections (good quality, dynamic)
• Performance-critical: Screen Space as primary
• Cinematics / Product Viz: Hardware RT (highest accuracy)
• Always available: Sky Light Cubemap (HDRI) (lowest quality fallback)

• Section 48 — Sky Light Cubemap (HDRI): the always-available fallback
• Section 49 — Screen Space Reflections: fast but limited
• Section 50 — Lumen & Hardware RT Reflections: dynamic high-quality options

The Sky Light cubemap (HDRI) is the always-available reflection fallback. Every reflective surface can see it, even without any other reflection system enabled.

How it works:

• Sky Light captures the environment (HDRI or scene) into a cubemap (HDRI)
• Reflective surfaces sample this cubemap (HDRI) for reflection data
• The same reflection appears regardless of position — no parallax

Limitations:

• Distant, flat-looking reflections
• Doesn't reflect local geometry
• Same reflection from every angle

When Sky Light reflections look wrong:

• Black reflections: HDRI Backdrop Size too small (increase it)
• Wrong environment: Sky Light not recaptured after changes (click Recapture)

Remember: In Part 6, we covered Sky Light setup. The same cubemap (HDRI) that provides ambient lighting also provides fallback reflection data.

Reflection Captures (Sphere and Box) are baked environment snapshots that capture local geometry at specific points. They provide local parallax that the Sky Light cubemap (HDRI) cannot.

However: Reflection Captures require baked lighting data to function properly. Since we enabled Force No Precompute in Part 3, Reflection Captures won't work in our workflow.

If you need Reflection Captures:

• Disable Force No Precompute
• Build lighting to bake reflection data
• Use Build → Build Reflection Captures

For dynamic workflows (our approach): Use Lumen Reflections instead — they provide local parallax and update automatically without baking.

1. For each reflective pixel, trace a ray in screen space
2. If the ray hits another pixel on screen, use that color as the reflection
3. If the ray goes off-screen or hits nothing, fall back to Sky Light cubemap (HDRI)

In Part 2: Project Setup, we set Reflection Method: None to see pure lighting without reflections. Now let's enable a reflection method.

Project Settings > Engine > Rendering > Reflections:
    Reflection Method: Screen Space

With your BP_LHT_RF_Reference in the scene:

1. Enable Screen Space reflections in Project Settings
2. Position camera so nearby geometry is both visible AND reflected in the chrome sphere
3. The reflection works — you see local geometry in the sphere
4. Now rotate camera so that geometry moves off-screen
5. The reflection disappears — SSR can only reflect what's rendered

TODO: Screenshot - SSR showing reflection of on-screen geometry

TODO: Screenshot - Same view with geometry off-screen, reflection missing

• Fast real-time reflections on capable hardware
• Scenes where most reflective surfaces face on-screen content
• Performance-critical scenarios where Lumen is too expensive

Lumen Reflections use Lumen's scene representation to ray trace reflections — dynamic and handles off-screen content.

Enabling Lumen Reflections

Project Settings > Engine > Rendering > Reflections:
    Reflection Method: Lumen

That's it — Lumen Reflections are now active. Quality is controlled by scalability settings and the Ray Lighting Mode in Project Settings.

Ray Lighting Mode for Reflections

Project Settings > Engine > Rendering > Lumen:
    Ray Lighting Mode: Surface Cache (default) or Hit Lighting

Surface Cache (default/recommended):

• Uses Lumen's cached surface data for reflection lighting
• Faster, good for most projects

Hit Lighting:

• Evaluates full lighting at each ray hit point
• More accurate but more expensive

Note: Hit Lighting for reflections is cheaper than Hit Lighting for GI. When Ray Lighting Mode is set to Hit Lighting, it affects both GI and reflections, but the reflection cost is lower since reflections trace fewer rays. For most projects, Surface Cache provides excellent quality at lower cost.

Demonstrating Lumen Reflections

With your BP_LHT_RF_Reference in the scene:

1. Set Reflection Method to Lumen in Project Settings
2. Position camera so geometry is reflected in the chrome sphere
3. Rotate camera so geometry moves off-screen
4. The reflection persists — Lumen can reflect off-screen content (within its range)

TODO: Screenshot - Lumen reflecting off-screen geometry

When Lumen Reflections Work Well

• Dynamic scenes with moving objects/lights
• Need to reflect off-screen content
• Good balance of quality and performance
• Most modern UE5 projects

Lumen Reflection Limitations

• Some noise (controlled by scalability settings)
• Limited by Lumen's scene representation quality
• May miss very small or thin geometry

For highest accuracy, Hardware RT traces rays against actual scene geometry.

Enabling Hardware RT Reflections

Project Settings > Engine > Rendering:
    ☑ Support Hardware Ray Tracing

Project Settings > Engine > Rendering > Ray Tracing:
    ☑ Ray Traced Reflections

RT Reflection Quality

Samples Per Pixel controls noise vs performance:

When to Use Hardware RT Reflections

TODO: Screenshot - Hardware RT reflections on chrome sphere showing accurate geometry

Key Points:

• Reflection sources from lowest to highest quality: Sky Light Cubemap (HDRI) → SSR → Lumen → Hardware RT
• Sky Light Cubemap (HDRI) is always available but has no parallax
• Reflection Captures require baked lighting — don't work with Force No Precompute
• Screen Space is fast but limited to on-screen content
• Lumen Reflections are dynamic and handle off-screen content
• Hardware RT provides highest accuracy for product/automotive work
• Surface Cache is recommended for Ray Lighting Mode — Hit Lighting for reflections is cheaper than for GI
• Black reflections usually mean HDRI Size is too small

With reflections complete, we've covered everything that contributes to the rendered image — direct light, ambient fill, indirect bounces, and reflections. Now we move to post-processing: effects applied after rendering. In Part 14: Bloom, we'll explore how bloom adds glow to bright areas and why it's independent of your lighting systems.