Lumen: Global Illumination in Unreal Engine

Team Members

Jasper Liu, Zihan Liao, Junming Chen, Jinglun Zhang

Introduction

"Real-time global illumination has always been a holy grail of computer graphics."

Lumen is a dynamic global illumination and reflections system implemented in Unreal Engine (UE) 5. Lumen Global Illumination solves diffuse indirect lighting. For example, light bouncing diffusely off a surface picks up the color of that surface and reflects the colored light onto other nearby surfaces, creating an effect called color bleed. Meshes in scenes also block indirect lighting, which also produces indirect shadowing.

Lumen Global Illumination
Figure 1: Example scene from Unreal official sites that demonstrates the rendering effect of Lumen

The magic of Lumen is that it provides infinite diffuse bounces within a limited time. In this project, we aim to explore how Lumen realizes real-time global illumination and improve the rendering efficiency without compromising too many visual effects.

In this final project, we aim to explore and implement the core and essential idea behind Lumen. Ignoring the complex engineering and framework limitations, we want to build a global illumination renderer that traces the ray to collect direct light, but uses a Radiosity-based method for accumulating indirect light as Lumen does. Our goal is to achieve amazing global illumination quality faster than our Path Tracing baselines running on CPU.

Problem Description

Solving the Discretized Rendering Equation

In general, the difficulty of real-time global illumination lies in solving the rendering equation:

\[B(x) = B_e(x) + \rho(x) \cdot \int_{M} B(y) \cdot \frac{G(x \leftrightarrow y) \cdot V(x \leftrightarrow y)}{\pi} \mathrm{d}A_y\] \[\underbrace{\frac{G(x \leftrightarrow y) \cdot V(x \leftrightarrow y)}{\pi}}_{G'(x \leftrightarrow y)}\]

By discretizing the equation and breaking the continuous surface into surface elements, we are able to reach the following linear equations:

\[B_i = B_{e,i} + \rho_i \sum_{j=1}^{n} F_{ij} B_j\]

where \(B_i\) represents the radiosity of the i-th surface element, \(B_{e,i}\) is the emission from the i-th surface element and the form factors is given by:

\[F_{ij} = \frac{1}{A_i} \int_{A_i} \int_{A_j} G'(x \leftrightarrow y) \, \mathrm{d}A_{y,j} \, \mathrm{d}A_{x,i}\]

Now the question is, how to efficiently solve the above linear equation. One way is to use Gaussian elimination, but the time complexity goes up in cubic order with respect to the number of surface elements.

Lumen's Approach

Lumen incorporates two new idea: surface and radiance cache. They store \(B_i\) and the corresponding material information at t-th time step, and use them to update the Bs at t+1-th time step.

\[B_i^{t+1} = B_{e,i} + \rho_i \sum_{j=1}^{N} B_j^t \cdot F_{ij}\]

This method relies on one condition to converge quickly and accurately to the true global illumination solution: the radiosity of the i+1-th surface element at t-th time step does not differ significantly from itself at t-th time step. And this condition is generally true in scenarios where real-time rendering is needed.

Bottleneck and Our Goal

To calculate \(B_i\) at t+1 time step, we need to know what surface element is able to contribute to \(B_i\). This still requires us to sample numerous outgoing radiance and perform raytracing. And we need to perform these operations for every surface element.

Our goal is to preserve the real-time rendering efficiency while not compromising too much of the visual effect. Specifically, we aim to explore the dynamic combination of radiosity calculation using radiance cache and distance field in Lumen.

Goals and Deliverables

  1. What we plan to deliver: We hope to deliver a demo that demonstrates our global illumination algorithm using the ideas that are proposed in Lumen. For simplicity of the project, we will first only consider the rendering within a distance range of 0-2 m.
  2. What we hope to achieve if things go well and you get ahead of schedule: The current Lumen global illumination algorithm divides the area into three parts based on their distance to the camera and uses a) ray intersection b) distance field c) handle lighting from different distances. We hope that we can unify the above-mentioned methods by proposing a dynamically integrated voxel-distance field-radiance cache approach.

Schedule

Week 1-2: Implementation of distance field and Ray matching.
Week 3-4: Implementation of surface and radiance cache. Explore voxel lighting for the rendering of far-away objects, if possible.

Resources

[1] Jaroslav Křivánek. Computer graphics III – Rendering equation and its solution
[2] UE5 Unreal Engine: https://github.com/EpicGames/UnrealEngine.git