💡 Lighting Fundamentals

How Lighting Works in Real-Time Engines

Before diving into Unreal's specific lighting tools, it's crucial to understand what makes real-time lighting different from the lighting you might see in animated films or architectural visualizations. This understanding will inform every lighting decision you make.

The Real-Time Challenge

In offline rendering (like Pixar films or pre-rendered cinematics), computers can spend hours calculating how light bounces around a scene. Every ray of light can be traced as it reflects off surfaces, passes through glass, scatters in fog, and eventually reaches the camera. The results are physically accurate and beautiful—but completely impractical for interactive experiences.

Games and real-time applications need to render 30 to 120 frames every second. That gives each frame roughly 8 to 33 milliseconds to calculate everything—including lighting. This constraint drives every technique and tradeoff in real-time rendering.

Figure: Offline rendering prioritizes accuracy; real-time rendering prioritizes speed.

Real-Time Lighting Strategies

To achieve acceptable lighting within milliseconds, real-time engines use several strategies:

Pre-calculation (Baking): Calculate complex lighting ahead of time and store the results in textures. At runtime, just look up the pre-computed values. This is fast but only works for things that don't move.

Approximation: Use mathematical shortcuts that look "close enough" to real physics. For example, instead of tracing millions of light rays, approximate ambient light with a single color or a simple gradient.

Screen-Space Effects: Calculate effects based only on what's visible on screen. Cheaper than world-space calculations, but can have artifacts at screen edges.

Hybrid Approaches: Combine baked lighting for static elements with real-time lighting for dynamic elements. This is the most common approach in games.

Unreal Engine 5's Lighting Evolution

Unreal Engine has evolved dramatically in its approach to lighting:

UE4 Era: Primarily relied on baked lighting (Lightmass) for quality results. Dynamic lighting was expensive and limited in bounce/indirect light.

UE5 with Lumen: Introduced fully dynamic global illumination and reflections. Light bounces, color bleeding, and soft shadows update in real-time without baking. This is revolutionary for real-time graphics.

You'll learn to use both approaches—Lumen is powerful but has hardware requirements, and baked lighting remains valuable for mobile, VR, and performance-critical scenarios.

timeline
    title Unreal Engine Lighting Evolution
    
    section UE4 Traditional
        Lightmass Baking : Static GI
        : Pre-calculated lightmaps
        : Hours of build time
        : Beautiful but inflexible
    
    section UE5 Lumen
        Dynamic GI : Real-time light bounces
        : No baking required
        : Instant iteration
        : Hardware requirements
    
    section Modern Approach
        Hybrid Solutions : Best of both worlds
        : Lumen for hero areas
        : Baked for performance
        : Platform-appropriate choices
                

Figure: Unreal's lighting has evolved from purely baked to fully dynamic options.

Direct vs. Indirect Lighting

Understanding the difference between direct and indirect lighting is fundamental to creating realistic, visually appealing scenes. Both components work together to create the lighting we see in the real world.

Direct Lighting

Direct lighting is light that travels straight from a light source to a surface without bouncing off anything else. When sunlight hits your desk, that's direct lighting. When a spotlight shines on an actor's face, that's direct lighting.

Characteristics of direct lighting:

• Creates hard shadows (penumbra softness depends on light size)
• Produces bright highlights on surfaces facing the light
• Defines the primary direction of illumination
• Relatively cheap to calculate in real-time

Indirect Lighting (Global Illumination)

Indirect lighting—also called Global Illumination (GI)—is light that has bounced off at least one surface before reaching another. The light illuminating the shadow side of objects, the color bleeding from a red wall onto nearby surfaces, the soft ambient glow filling a room—all indirect lighting.

Characteristics of indirect lighting:

• Fills in shadows with soft, diffuse light
• Transfers color between surfaces (color bleeding)
• Creates ambient occlusion in crevices and corners
• Much more expensive to calculate accurately

Figure: Direct light creates clear shadows; indirect light fills them and transfers color between surfaces.

Why Both Matter

A scene lit only with direct lighting looks harsh and artificial—areas not directly facing the light become pitch black. This was a common look in early 3D games, and you'll recognize it immediately as "gamey."

Indirect lighting is what makes CG imagery look photorealistic. Even on a cloudy day when there's no visible sun, light bounces between the clouds, ground, and buildings to illuminate everything with soft, directional light. Indoor scenes rely almost entirely on indirect lighting—light entering through windows bounces around the room many times.

How Unreal Handles Each Type

Direct lighting in Unreal is straightforward—place lights, and surfaces facing them get illuminated. Shadow maps handle the shadows. This works the same whether you're using baked or dynamic lighting.

Indirect lighting in Unreal can come from several sources:

Lightmass (Baked): Pre-calculates light bounces and stores them in lightmaps. High quality, zero runtime cost, but static.

Lumen (Dynamic): Calculates light bounces in real-time using software ray tracing or hardware ray tracing. Fully dynamic but has performance cost.

Screen Space Global Illumination (SSGI): Approximates GI using only screen information. Cheaper than Lumen but less accurate.

Ambient Cubemaps/Skylights: Simple approximations that add uniform or directional ambient light. Very cheap but not physically accurate.

flowchart LR
    subgraph Quality["Quality (Best to Approximate)"]
        direction TB
        Q1["Lumen Hardware RT"]
        Q2["Lumen Software RT"]
        Q3["Lightmass Baked"]
        Q4["SSGI"]
        Q5["Skylight + Ambient"]
    end
    
    subgraph Cost["Performance Cost"]
        direction TB
        C1["High"]
        C2["Medium-High"]
        C3["Zero Runtime"]
        C4["Medium"]
        C5["Low"]
    end
    
    subgraph Flexibility["Dynamic Capability"]
        direction TB
        F1["Fully Dynamic"]
        F2["Fully Dynamic"]
        F3["Static Only"]
        F4["Limited Dynamic"]
        F5["Static/Simple"]
    end
    
    Q1 --- C1 --- F1
    Q2 --- C2 --- F2
    Q3 --- C3 --- F3
    Q4 --- C4 --- F4
    Q5 --- C5 --- F5
    
    style Q1 fill:#4CAF50,color:#fff
    style Q2 fill:#8BC34A,color:#fff
    style Q3 fill:#FF9800,color:#fff
    style Q4 fill:#FFC107,color:#333
    style Q5 fill:#f44336,color:#fff
                

Figure: Different indirect lighting methods trade quality for performance and flexibility.

Light Types Overview

Unreal Engine provides four primary light types, each designed for different real-world lighting scenarios. Understanding their characteristics helps you choose the right tool for each situation.

Directional Light

A Directional Light simulates light from an infinitely distant source—like the sun. All light rays are parallel, and the light's position in the world doesn't matter, only its rotation (direction). Moving a directional light around has no effect; rotating it changes where shadows fall.

Real-world equivalents: Sun, moon, distant stadium lights

Characteristics:

• Parallel light rays (no falloff with distance)
• Illuminates the entire world uniformly
• Only rotation matters, not position
• Creates long, parallel shadows
• Typically paired with Sky Atmosphere for outdoor scenes

Figure: Directional Light casts parallel rays, simulating infinitely distant sources like the sun.

Point Light

A Point Light emits light equally in all directions from a single point—like a bare light bulb. Light intensity falls off with distance following the inverse square law (or Unreal's adjustable falloff).

Real-world equivalents: Light bulbs, candles, torches, explosions

Characteristics:

• Omnidirectional emission (360° in all directions)
• Intensity decreases with distance
• Attenuation Radius defines how far the light reaches
• Position matters significantly
• Good for general room illumination

Figure: Point Light emits in all directions with intensity falling off over distance.

Spot Light

A Spot Light emits light in a cone shape from a single point. It combines the point-source nature of a Point Light with directional control. The cone has an inner angle (full intensity) and outer angle (falloff to zero).

Real-world equivalents: Flashlights, stage spotlights, car headlights, recessed ceiling lights

Characteristics:

• Conical emission pattern
• Inner Cone Angle: full brightness area
• Outer Cone Angle: soft falloff edge
• Both position and rotation matter
• Great for focused, dramatic lighting

Figure: Spot Light creates a cone of light with soft edges defined by inner and outer angles.

Rect Light (Area Light)

A Rect Light (Rectangle Light) emits light from a rectangular surface rather than a point. This creates softer, more natural shadows because the light source has physical size. The larger the rectangle, the softer the shadows.

Real-world equivalents: Windows, TV screens, fluorescent panel lights, softboxes in photography

Characteristics:

• Emits from a rectangular area
• Creates soft shadows (penumbra)
• More physically accurate than point sources
• Source Width and Height control shadow softness
• More expensive than Point/Spot lights

Figure: Rect Light emits from a surface area, creating physically accurate soft shadows.

Light Type Comparison

Figure: Each light type has specific strengths and performance characteristics.

Light Mobility: Static, Stationary, Movable

Every light in Unreal Engine has a Mobility setting that fundamentally affects how it's processed, what features it supports, and its performance impact. This single dropdown—found in the Details panel under Transform—is one of the most important decisions you'll make for each light.

Static Lights

Static lights are completely baked into lightmaps during the lighting build process. At runtime, they have zero cost—the lighting information is just texture data applied to surfaces. However, nothing about a static light can change during gameplay.

Characteristics:

• Fully baked into lightmaps (requires lighting build)
• Zero runtime cost for direct and indirect lighting
• Cannot move, rotate, or change color/intensity at runtime
• Supports full global illumination in baked results
• Only affects static geometry (objects also set to Static)
• Dynamic objects receive no direct light from static lights

Best for: Architectural visualization, unchanging environmental lighting, performance-critical scenarios where lights never need to change.

Figure: Static lights are baked once and have zero runtime cost, but cannot change.

Stationary Lights

Stationary lights are a hybrid approach. Their indirect lighting (bounced light, color bleeding) is baked into lightmaps, but their direct lighting and shadows are calculated at runtime. This gives you the quality of baked GI with the flexibility of dynamic shadows.

Characteristics:

• Indirect lighting is baked (requires lighting build)
• Direct lighting calculated at runtime
• Can change color and intensity at runtime
• Cannot move or rotate at runtime
• Supports dynamic shadows on moving objects
• Limited to 4 overlapping stationary lights per surface

Best for: Most game lighting scenarios—outdoor sun, interior lights that might flicker or change color, any light where you want baked GI but need dynamic object shadows.

Figure: Stationary lights combine baked indirect lighting with runtime direct lighting and shadows.

Movable Lights

Movable lights are fully dynamic—everything is calculated at runtime. They can move, rotate, change color and intensity freely. However, they have no baked contribution, which means no pre-calculated global illumination (unless you're using Lumen).

Characteristics:

• All lighting calculated at runtime
• Can move, rotate, and change all properties freely
• No baked contribution (no lightmap data)
• Without Lumen: no indirect lighting/GI
• With Lumen: full dynamic GI
• Highest runtime cost (especially shadows)
• No overlap limits

Best for: Flashlights, vehicle headlights, swinging lamps, any light that must physically move. Also the only option when using Lumen without baking.

flowchart TB
    subgraph Static["STATIC"]
        S1["Position: Fixed"]
        S2["Color/Intensity: Fixed"]
        S3["Shadows: Baked"]
        S4["GI: Baked"]
        S5["Cost: Zero runtime"]
    end
    
    subgraph Stationary["STATIONARY"]
        ST1["Position: Fixed"]
        ST2["Color/Intensity: Dynamic"]
        ST3["Shadows: Dynamic"]
        ST4["GI: Baked"]
        ST5["Cost: Medium"]
    end
    
    subgraph Movable["MOVABLE"]
        M1["Position: Dynamic"]
        M2["Color/Intensity: Dynamic"]
        M3["Shadows: Dynamic"]
        M4["GI: None (or Lumen)"]
        M5["Cost: High"]
    end
    
    style Static fill:#4CAF50,color:#fff
    style Stationary fill:#FF9800,color:#fff
    style Movable fill:#f44336,color:#fff
                

Figure: The three mobility types offer different tradeoffs between flexibility and performance.

How to Change Light Mobility

Select any light in your level and look at the Details panel. Under the Transform section, you'll find the Mobility dropdown. The icon next to the light in the viewport also indicates its mobility:

• Static: Light bulb icon with no additional indicator
• Stationary: Light bulb with a small dot
• Movable: Light bulb with radiating lines

Performance Implications

Lighting is often the biggest performance factor in real-time rendering. Understanding the costs helps you budget wisely and make informed decisions about where to spend your frame time.

Shadow Rendering Costs

Shadows are typically the most expensive part of lighting. Each shadow-casting light requires the scene to be rendered from the light's perspective to create a shadow map. More lights with shadows = more rendering passes = lower frame rate.

Shadow cost factors:

Number of shadow-casting lights: Each light with Cast Shadows enabled adds rendering overhead. Disable shadows on fill lights and small accent lights when possible.

Shadow map resolution: Higher resolution means sharper shadows but more memory and processing. Adjust per-light in the Details panel.

Shadow distance: How far shadows render from the camera. Distant shadows can use lower resolution or be disabled entirely.

Dynamic shadow casters: Moving objects that cast shadows require shadow map updates every frame. Static shadow casters can be cached.

Figure: Multiple factors contribute to shadow rendering costs—optimize each based on importance.

Light Complexity by Type

Different light types have different baseline costs:

Directional Light: Typically one per scene for the sun. Uses Cascaded Shadow Maps which are efficient but cover large distances. Moderate cost.

Spot Light: Cheapest local light for shadows because it only needs a single shadow map from one direction.

Point Light: More expensive than spot lights because omnidirectional shadows require rendering a cubemap (6 faces) instead of one shadow map.

Rect Light: Most expensive light type due to area shadow calculations. Use sparingly with shadows enabled.

Figure: Spot lights are cheapest; Rect lights are most expensive when casting shadows.

Mobility and Performance

Your choice of mobility has significant performance implications:

Static lights: Zero runtime cost—all lighting is baked. However, they require lighting build time (which can be hours for complex scenes) and add to lightmap memory usage.

Stationary lights: Baked indirect lighting has no runtime cost, but dynamic direct lighting and shadows do cost. Good middle ground for most scenarios.

Movable lights: Full runtime cost for everything. Without Lumen, no GI contribution. With Lumen, add Lumen's overhead on top.

Lumen Performance Considerations

Lumen (UE5's global illumination system) adds its own performance characteristics:

Software Ray Tracing: Works on any hardware but uses screen-space information and signed distance fields. Moderate cost, some approximation artifacts.

Hardware Ray Tracing: Requires RTX/DXR capable GPU. Higher quality with fewer artifacts. Significant GPU cost but increasingly viable on modern hardware.

With Lumen, you don't need baked lighting—all lights can be Movable and still contribute GI. But this comes at a runtime cost that varies based on scene complexity and hardware.

Optimization Strategies

Disable shadows on unimportant lights: Fill lights and ambient lights often don't need shadows. Every shadow-casting light you disable saves significant GPU time.

Use appropriate shadow resolution: Distant or less important lights can use lower shadow map resolution without noticeable quality loss.

Limit dynamic shadow casters: Use static shadows where possible. Only enable dynamic shadows on objects that actually move.

Use light functions instead of many lights: A single light with a cookie/light function can simulate multiple light sources (like light through blinds).

Consider baking where appropriate: Even with Lumen available, strategic use of baked lighting for static elements can improve performance significantly.

flowchart TD
    Start["Light Performance Issue?"] --> Q1{"Does light
need shadows?"}
    
    Q1 -->|"No"| A1["Disable Cast Shadows
✓ Big savings"]
    Q1 -->|"Yes"| Q2{"Does light
move?"}
    
    Q2 -->|"No"| Q3{"Does color/
intensity change?"}
    Q2 -->|"Yes"| A2["Must be Movable
Optimize shadow resolution"]
    
    Q3 -->|"No"| A3["Use Static
✓ Zero runtime cost"]
    Q3 -->|"Yes"| A4["Use Stationary
✓ Baked GI + dynamic direct"]
    
    style A1 fill:#4CAF50,color:#fff
    style A3 fill:#4CAF50,color:#fff
    style A4 fill:#FF9800,color:#fff
    style A2 fill:#f44336,color:#fff
                

Figure: Decision tree for optimizing light performance based on requirements.

Choosing the Right Approach

With so many options available—light types, mobility settings, Lumen vs. baked lighting—how do you decide what to use? The answer depends on your project's requirements, target hardware, and creative goals.

Platform Considerations

Your target platform heavily influences lighting decisions:

High-End PC / Next-Gen Console: Lumen is viable and recommended for most scenarios. Fully dynamic lighting with real-time GI provides maximum flexibility and visual quality. Hardware ray tracing available for highest quality.

Mid-Range PC / Current-Gen Console: Hybrid approaches work well. Use Lumen with Software Ray Tracing, or combine baked indirect lighting (Stationary lights) with dynamic direct lighting. Balance quality and performance based on your specific game.

Mobile / VR / Low-End PC: Baked lighting is often essential. Static lights with fully baked lightmaps provide the best performance. Use Movable lights sparingly and without shadows when possible. Forward rendering may be preferred over deferred.

Figure: Target platform determines which lighting approaches are viable.

Project Type Considerations

Different types of projects have different lighting needs:

Open World Games: Time of day is often important. Lumen excels here because it handles the constantly changing sun position. Alternatively, use a Stationary Directional Light and accept that GI won't update with sun position (or use time-of-day-specific lightmap bakes).

Linear Story Games: Controlled environments allow for heavily optimized, baked lighting. You know exactly what players will see, so you can craft perfect lighting for each area. Mixed Stationary/Static lighting often works well.

Multiplayer Shooters: Consistent frame rate is critical. Simpler lighting with Stationary or Static lights often preferred. Dynamic elements (muzzle flash, explosions) can be Movable without shadows.

Horror Games: Dynamic lighting (flashlights, flickering lights) is essential for atmosphere. Lumen or Movable lights are often necessary for core mechanics, but can be balanced with baked ambient lighting.

Architectural Visualization: Quality is paramount, interactivity requirements are low. Static baked lighting with high-quality lightmaps often produces the best results. Lumen also excellent for real-time client walkthroughs.

Common Lighting Scenarios

Here are recommended approaches for typical scenarios:

Outdoor Daytime Scene

Key Light: Directional Light (Stationary or Movable) for sun

Sky: Sky Atmosphere + SkyLight (Stationary or Movable)

Fill: Exponential Height Fog for atmospheric depth

Approach: With Lumen: all Movable, dynamic time of day possible. Without Lumen: Stationary sun with baked GI, fixed time.

Indoor Room with Windows

Key Light: Directional Light coming through windows

Fill: Rect Lights at window positions for soft interior fill

Practical Lights: Point/Spot lights for lamps, ceiling fixtures

Approach: Stationary for main lights, Static for decorative lights that won't change.

Underground/Cave Environment

Key Light: None (no sun)

Practical Lights: Point lights for torches, Spot lights for focused areas

Emissive: Glowing crystals, bioluminescence via emissive materials

Approach: Heavy use of Static lights for ambient, select Stationary for important hero lights.

Night Scene with Artificial Lighting

Key Light: Dim Directional for moonlight (optional)

Practical Lights: Street lights (Spot), building windows (Rect), car headlights (Spot Movable)

Approach: Stationary for static fixtures, Movable for vehicle lights and interactive elements.

flowchart TD
    Start["What's your scenario?"] --> Q1{"Outdoor with
changing sun?"}
    
    Q1 -->|Yes| A1["Lumen recommended
Movable Directional Light"]
    Q1 -->|No/Fixed time| Q2{"Interior
heavy scene?"}
    
    Q2 -->|Yes| Q3{"Performance
critical?"}
    Q2 -->|"Outdoor fixed"| A2["Stationary Directional
+ Baked GI"]
    
    Q3 -->|Yes| A3["Static lights
Fully baked"]
    Q3 -->|"Quality focus"| A4["Stationary lights
+ select Movable"]
    
    A1 --> R1["Dynamic time of day
Full GI response"]
    A2 --> R2["Good GI
Fixed lighting"]
    A3 --> R3["Best performance
No flexibility"]
    A4 --> R4["Balanced approach
Some dynamic capability"]
    
    style A1 fill:#4CAF50,color:#fff
    style A2 fill:#FF9800,color:#fff
    style A3 fill:#2196F3,color:#fff
    style A4 fill:#9C27B0,color:#fff
                

Figure: Match your lighting approach to your scenario requirements.

Iteration and Flexibility

One often overlooked factor: iteration speed. During development, you'll adjust lighting constantly. Consider:

Lumen: Changes are instant—move a light, see the result immediately. Excellent for iteration but requires appropriate hardware during development.

Baked Lighting: Every change requires a lighting build. Production builds can take hours for complex scenes. Use Preview quality during development, Production quality for final builds.

Many teams use Lumen during development for fast iteration, then evaluate whether to ship with Lumen or switch to baked lighting for performance based on target platform requirements.

The Lighting Pipeline Summary

Figure: A typical lighting workflow from blockout to polish.

Summary

You now have a solid foundation in real-time lighting concepts. Let's recap the essential knowledge:

Light Types Quick Reference

Mobility Quick Reference

What's Next?

With these fundamentals in place, you're ready to start lighting actual scenes. In the next lesson, we'll focus on outdoor lighting—setting up the Directional Light as the sun, configuring the Sky Atmosphere for realistic skies, adding atmospheric fog, and using SkyLight for proper ambient illumination. You'll create a complete outdoor daytime environment from scratch.

The concepts from this lesson will guide every lighting decision you make. Return here whenever you need to refresh your understanding of light types, mobility, or performance considerations.