Part 2: DIRECT LIGHTING

You can find all light types in the Place Actors panel under Lights:

Light Types Toolbar

Spot Light

• Directional cone-shaped emission
• Inner/outer cone angles control falloff
• Good for: Stage lights, flashlights, focused fixtures, car headlights

Spot Light Example

Point Light

• Emits equally in all directions from a point
• Like a bare light bulb
• Most expensive light type — internally calculated as 6 spot lights (one for each direction of a cube)
• Good for: Lamps, candles, small fixtures

Point Light Example

Rect Light

• Emits from a rectangular surface
• Most accurate for panel lights, softboxes, LED panels
• Has Source Width/Height properties
• Expensive — calculates light contribution across the entire rectangular area, not a single point. More accurate area lighting = more computation.
• Good for: Studio lighting, product visualization, industrial panels

Rect Light Example

Directional Light

• Parallel rays from infinitely far away
• No falloff — same intensity everywhere
• Has Source Angle property (affects shadow softness)
• Typically only one in a scene — represents the sun. With advanced understanding, you can have multiple (e.g., sun and moon) but this requires careful setup.
• Intensity measured in Lux, not Lumens — because the sun is so large that Lumens would be an impractically small measurement

Directional Light Example

Note: We'll cover light units and measurements in Part 6: Exposure.

Like meshes, lights also have a Mobility setting:

Light Mobility Panel

Light Mobility Setting

For lights, Mobility controls how they interact with baked vs dynamic lighting:

Performance: Static and Stationary lights normally offer significant performance savings through baked lightmaps and cached shadows. With Force No Precompute enabled, those baked benefits are eliminated — lighting calculations become fully dynamic for all lights. However, mobility still matters: Static lights have lower transform overhead (like Static meshes), and Stationary lights can still benefit from cached shadow maps.

Tip: For this course, we're using Moveable lights with Lumen for fully dynamic global illumination. This gives us real-time feedback as we learn.

Note: Baked lighting workflows and mobility optimization strategies are separate topics we won't cover here.

Unreal uses real-world photometric units. Local lights and Directional lights use different units:

Local Lights (Point, Spot, Rect):

Intensity Units Dropdown

Directional Light (Sun/Moon):

Lux Setting for Directional Light

Why Lux for Directional? The sun's total lumen output would be an impractically large number. Lux measures light landing on a surface — much more useful for sunlight.

Mental model:

• Lumens = how much total light leaves the bulb
• Candelas = how bright it is looking directly at the beam
• Lux = how much light lands on your desk

Why Use Lumens?

• Real-world reference — Look up any bulb's specs and use that value directly
• Consistent across light types — 1000 lm Point Light = 1000 lm Spot Light (same total output)
• Predictable exposure — Camera settings work correctly when lights use physical values

Note: We'll cover physical light values and exposure in detail in Part 6: Exposure.

Attenuation controls how far a light's influence extends. All distances in Unreal are in centimeters (1 Unreal Unit = 1 cm).

Attenuation Radius Setting

Spot Light	Point Light	Rect Light
Spot Light Attenuation	Point Light Attenuation	Rect Light Attenuation

Tip: Attenuation Radius controls how far light travels. Source Radius/Angle controls shadow softness. These are independent — increasing one doesn't affect the other.

What Determines Shadow Softness?

The bigger the apparent size of the light source, the softer the shadow.

Shadow softness depends on the apparent size of the light source as seen from the subject — not its actual size.

A light source can be massive, but if it's far away, it appears small and creates hard shadows.

Apparent Size = Actual Size ÷ Distance

How Real-World Lights Work

The Sun — Hard Shadows

The sun is enormous (1.4 million km diameter), but it's 150 million km away. From Earth, it only spans about 0.5 degrees of the sky — a tiny dot.

Result: Sharp, hard-edged shadows on a clear day.

TODO: Add real-world sun hard shadow reference image

Overcast Sky — Soft Shadows

When clouds roll in, the sun's light scatters through the cloud layer. Now the entire sky becomes your light source — thousands of times larger in apparent size.

Result: Soft, diffused shadows (or nearly invisible shadows).

TODO: Add overcast soft shadow reference image

A Bare Bulb — Changes with Distance

Move a bare light bulb close to an object:

• Bulb appears large relative to subject
• Soft shadows

Move the same bulb far away:

• Bulb appears small (approaches a point)
• Hard shadows

This is the inverse of what you might expect — for a given source size, moving the light closer increases its apparent size relative to the subject, creating softer shadows.

The Photography Studio Approach

Photographers figured this out long ago:

Your light box works the same way — it's a large diffuse panel placed close to the product, maximizing apparent size for soft, even illumination.

Now let's see how Unreal implements these concepts with specific controls per light type.

Source Radius / Source Angle

Unreal simulates shadow softness with different controls per light type:

For Point/Spot Lights: Source Radius

• Simulates the physical size of the bulb/fixture
• Larger radius = softer shadows
• 0 = infinitely small point = hard shadows

With Source Radius = 0, you get sharp, hard-edged shadows:

Source Radius Zero

Hard Shadow from Point Light

Increase the Source Radius to simulate a larger light source:

Source Radius Large

Soft Shadow from Point Light

Notice how the shadow edges become softer and more gradual — this is physically accurate to how real area lights behave.

For Directional Light: Source Angle

• Simulates the angular size of the sun disk
• 0.5° ≈ real sun on clear day (hard shadows)
• Larger values = overcast sky effect (soft shadows)
• 5°+ = heavily overcast, very soft
• Typically you don't need to change this — the default is physically accurate for sunlight

With a small Source Angle (like the real sun):

Source Angle Small

Directional Hard Shadow

Increase the Source Angle to simulate overcast conditions:

Source Angle Large

Directional Soft Shadow

Note: Realistically, the sun rarely exceeds ~5° Source Angle. Setting the angle too high can introduce artifacts and noise in shadows. Achieving truly soft directional lighting (like heavy overcast) requires additional techniques we'll cover later.

For Rect Lights: Source Width/Height

• Physical dimensions of the light panel
• Larger panel = softer shadows
• Directly matches real softbox behavior

Small Source Width/Height values create harder shadows:

Rect Light Dimensions Small

Rect Light Hard Shadow

Larger dimensions create softer, more diffused shadows:

Rect Light Dimensions Large

Rect Light Soft Shadow

Distance Still Matters

In Unreal, the Source Radius/Angle is the base softness. The actual shadow softness also depends on:

• Distance from light to object (affects apparent size)
• Distance from object to shadow-receiving surface (affects penumbra spread)

Light close to subject — larger apparent size, softer shadows:

Point Light Close

Same light moved further away — smaller apparent size, harder shadows:

Point Light Far

A Rect Light that looks soft up close will cast harder shadows on distant objects — just like reality.

Tip: This is why photographers use large softboxes positioned close to their subjects. The combination of large size + close distance maximizes shadow softness.

Terminology Note: Shadow Maps is the method (project setting). Cascade Shadow Maps (CSM) is a technique within that method, specifically used for Directional Lights. Local lights (Point, Spot, Rect) use traditional shadow maps without cascades.

The methods differ most visibly in how they handle shadow softness from area lights:

• Shadow Maps (including CSM) use depth-based shadow mapping — stable and fast, but produces hard shadows by default. Soft shadows require PCSS filtering.
• VSM calculates penumbra mathematically — applies a blur to shadow edges. The shadow shape is always the same regardless of light geometry.
• Distance Fields approximate area shadows using mesh distance data — creates soft shadows but with resolution limitations.
• Hardware RT actually traces rays to different points on the light source — the shadow shape reflects the light's physical geometry (rectangular penumbra from Rect Lights, round from Source Radius).

Cascade Shadow Maps split the camera's view frustum into multiple distance bands ("cascades"), each with its own shadow map:

• Near camera = highest resolution shadows
• Far from camera = lower resolution shadows

This technique addresses the resolution problem unique to Directional Lights — they illuminate the entire scene, so a single shadow map would be stretched too thin.

• Shadow Maps dynamic shadows are relevant for Stationary and Moveable lights.
• Static lights normally rely on baked shadows (Lightmass). If you're using Force No Precomputed Lighting, you won't get baked shadows anyway.

• You're maintaining a legacy project or pipeline that already relies on Shadow Maps tuning
• You're intentionally avoiding VSM for compatibility or simplicity reasons

In project settings:

Edit → Project Settings → Engine → Rendering → Shadows → Shadow Map Method

• Shadow Maps = Traditional shadow mapping (CSM for Directional, standard for local lights)
• Virtual Shadow Maps = Modern VSM workflow

(TODO: Add screenshot of Shadow Map Method setting.)

When using the Shadow Maps method, CSM tuning for Directional Lights happens in the light's Details panel:

• Dynamic Shadow Distance (MovableLight / StationaryLight): how far CSM shadows render
• Num Dynamic Shadow Cascades: how many cascades (more = higher quality, higher cost)
• Cascade Distribution Exponent: pushes more resolution near camera (higher = tighter near camera)
• Cascade Transition Fraction: blends between cascades to reduce visible "bands"

Tip: If you see cascade "popping" while moving the camera, increase the transition fraction and/or adjust the distribution exponent.

All lights using the Shadow Maps method produce hard shadows by default:

This is a fundamental limitation of depth-based shadow mapping. The shadow map stores "is this pixel in shadow?" as a binary yes/no, resulting in sharp edges.

To get soft shadows in Shadow Maps mode, you have two options:

Option 1: PCSS Filtering (affects all lights)

r.Shadow.FilterMethod 1

This enables Percentage-Closer Soft Shadows (PCSS), which dynamically adjusts shadow softness based on the distance between occluder and receiver.

Note: PCSS adds a performance cost and may introduce aliasing artifacts in some scenarios.

Option 2: Increase Source Radius (local lights only)

For Point, Spot, and Rect lights, increasing the Source Radius property (or Source Width/Height for Rect Lights) will produce softer shadows — but only when combined with PCSS or other filtering.

• Hard shadow edges: All lights produce hard shadows by default
• Cascade lines / popping: (Directional only) transitions between cascades become visible during movement
• Aliasing / stair-step edges: limited resolution, especially in mid/far cascades
• Shadow "swimming": (Directional only) subtle instability as the cascades re-fit around the camera

VSM uses massive 16K×16K shadow textures split into tiles, with different structures per light type:

1. Scene is divided into pages/tiles
2. Only visible tiles get rendered
3. Tiles near camera get higher resolution
4. Distant tiles get lower resolution
5. Results are cached and reused across frames

Note: Local lights provide significant resolution increase vs traditional shadow maps, but very large local lights can run out of virtual resolution. Use Directional Lights for large-scale shadows.

VSM is the right default for most projects:

• Works with all light mobilities (Static, Stationary, Moveable)
• Works on any GPU — no special hardware required
• Excellent shadow detail and resolution
• Handles many lights efficiently
• Good performance with static or slow-moving content

VSM behaves differently depending on distance and mesh type:

Far Distance:

• Nanite vs Non-Nanite meshes may have different shadow behavior at long distances
• VSM clipmaps handle this automatically, but you may see quality differences

Close Distance:

• Generally excellent detail due to high virtual resolution
• The clipmap system allocates more pages near the camera

VSM builds quality over multiple frames through temporal accumulation. When the camera or objects move quickly:

• Flickering at shadow edges
• Shimmering artifacts
• A "crawling" look during camera motion

This isn't a bug — it's the cache updating. Usually subtle, but noticeable on fast-moving shots.

VSM calculates soft shadows mathematically based on Source Radius/Angle and distance. The softness looks good, but it's an approximation — all lights produce the same generic soft edge regardless of their actual shape.

Penumbra noise is controlled by ray count. At Epic scalability, both local and Directional Lights use 8 rays by default.

• Fewer rays = visible noise in penumbra
• Setting to 0 = disables SMRT, reverts to single-sample hard shadows

Most VSM controls live under these namespaces:

• r.Shadow.Virtual.* — general VSM settings (resolution, caching, page management)
• r.Shadow.Virtual.SMRT.* — soft shadow ray tracing settings (ray counts, samples)

Tip: Use r.Shadow.Virtual. in the console and press Tab to see all available options.

To visualize how VSM is working, use the viewport debug modes:

Show → Virtual Shadow Map → [Visualization Mode]

VSM Debug Visualization

Tip: VSM is already enabled by default. You don't need to change any settings unless you want to use a different shadow system.

A distance field stores, for every point in space around a mesh, how far away the nearest surface is. This pre-computed data lets the engine quickly determine shadow coverage without tracing individual rays.

Distance fields are generated at mesh import time, but the system must be enabled in project settings.

Enable Mesh Distance Fields

Required for Distance Field Shadows.

Edit → Project Settings → Engine → Rendering → Software Ray Tracing

☑ Generate Mesh Distance Fields

After enabling, reimport meshes or restart the editor for distance fields to generate.

Per-Light Enable:

Distance Field Shadows Setting

• Select the light actor
• Details panel → Distance Field Shadows: Enabled

Distance Field Settings

This is an important distinction for Directional Lights:

Why the difference? CSM and Distance Fields are separate systems that can complement each other. VSM is a unified system that replaces both — it handles near and far shadows internally, so Distance Fields become an alternative rather than a supplement.

Good for:

• Large open worlds with distant shadows
• Soft area shadows from Directional Lights
• Stylized projects where approximate softness is acceptable

Limitations:

• Resolution depends on distance field quality
• Thin geometry may not cast accurate shadows
• Memory overhead from distance field data
• Less accurate than hardware ray tracing for close-up area light shadows

Note: With CSM workflow, Distance Field Shadows and CSM can work together — DF for distant/soft shadows, CSM for nearby detail. With VSM, you choose one or the other.

To visualize mesh distance fields in the viewport:

Show → Visualize → Mesh DistanceFields

Mesh Distance Fields Visualization

If meshes appear pink/magenta, distance fields are not generated for them — check that Generate Mesh Distance Fields is enabled and reimport the meshes.

With hardware ray tracing, Unreal shoots rays from surfaces toward the light source:

• Point lights: One ray toward a single point — simple shadow
• Area lights (Rect Light, lights with Source Radius): Multiple rays toward different points across the light's surface

The result: shadow shapes that actually reflect the light's geometry. A Rect Light casts a shadow with a rectangular penumbra. A light with Source Radius creates round soft edges. This matches real-world photography.

Use RT shadows when:

• You need accurate shadow shapes from area lights
• You're doing cinematics or virtual production
• Shadow quality is critical to your visual target
• You have RTX hardware and frame budget to spare

Stick with VSM/Distance Fields when:

• You need to support non-RTX hardware
• Performance is critical (real-time gameplay)
• Shadow shape accuracy isn't important to your art style

Tip: Many projects use both — VSM for gameplay, RT for cutscenes. You can switch per-light or globally.

Far Distance — Culling CVars:

At far distances, Unreal culls objects from the ray tracing scene (TLAS) to save performance. This can cause shadows to disappear on distant objects.

Solid-Angle Culling Explained:

The r.RayTracing.Culling.Angle CVar controls "cone" culling — it removes objects that appear too small in angle from the camera's perspective, especially outside the direct view.

• Base threshold is 5 degrees, and the CVar is a multiplier
• Default 1 = ~5° threshold
• 0.5 = ~2.5° (less aggressive, keeps more geometry)
• 0 = disable culling entirely (expensive)

Tip: If distant objects are missing RT shadows, try r.RayTracing.Culling 0 to test, then tune the radius/angle for your scene.

Close Distance — Near Clip:

For very close objects, RT can miss geometry due to camera near clip settings. If RT shadows disappear on close objects:

r.SetNearClipPlane 0.005

This allows RT to trace geometry much closer to the camera (useful for product visualization, VR, etc.).

Step 1: Enable Hardware Ray Tracing

Enable Hardware Ray Tracing

Master switch for all RT features. Requires editor restart.

Edit → Project Settings → Engine → Rendering → Hardware Ray Tracing

☑ Support Hardware Ray Tracing

Hardware Ray Tracing Settings

Step 2: Enable RT Shadows

Per-Light (Recommended) — Selective control:

• Select light actor
• Details panel → Cast Ray Traced Shadows: Enabled

Cast Ray Traced Shadows - Use Project Setting

Cast Ray Traced Shadows - Enabled

Global — All lights use RT:

Enable Ray Traced Shadows Globally

Enables RT shadows for all lights in the project at once.

Edit → Project Settings → Engine → Rendering → Ray Tracing

☑ Ray Traced Shadows

Ray Traced Shadows Global Setting

RT shadows use sampling — more rays = cleaner shadows but higher GPU cost.

Why noise happens: With limited rays, you're sampling a probability. 4 rays might give 2 blocked, 2 unblocked = 50% shadow. More samples averages this out for cleaner results.

Per-Light: Details panel → Ray Tracing → Samples Per Pixel

Global: Console variable r.RayTracing.Shadow.SamplesPerPixel [value]

Samples Per Pixel - 1 sample

1 Sample - Noisy Shadow

Samples Per Pixel - 10 samples

10 Samples - Clean Shadow

Key Points:

• UE5 supports multiple shadow systems, including legacy CSM and modern VSM
• VSM works on any GPU with good quality; shows temporal artifacts on fast motion
• Distance Fields enable long-distance soft shadows (Stationary/Moveable only)
• Hardware RT produces accurate shadow shapes but requires RTX hardware
• Choose based on your hardware targets, performance budget, and visual requirements