Real-time global illumination

Everything a renderer does is an attempt at the rendering equation, which says that the light leaving a surface is whatever it emits, plus everything arriving from the entire hemisphere above it, weighted by the material:

Rasterization handles the direct part: light that travels from a source to a surface to the camera. The recursive part, light that arrives via other surfaces, is global illumination, and skipping it is why older games looked like everything was lit by a flash bulb. The figure below is what the recursion means physically.

Path tracers solve the rendering equation by following thousands of rays per pixel, which is beautiful and slow. REACT instead uses voxel cone tracing, introduced by Crassin and colleagues in 2011. The idea has two halves.

First, build a crude copy of the scene: rasterize everything into a 3D grid of voxels, where each voxel stores the direct light falling on the geometry inside it. Second, generate mipmaps of that grid, so each level is a half-resolution, pre-blurred version of the one below. A cone marched through this structure samples coarser mips as it widens, which gives you an approximation of gathering light over a solid angle at a tiny fraction of the cost of the rays it replaces.

vec3 TraceCone(vec3 origin, vec3 dir, float aperture) {
    vec3  radiance  = vec3(0.0);
    float occlusion = 0.0;
    float t         = u_voxelSize;          // skip self-lighting

    while (occlusion < 1.0 && t < u_maxDistance) {
        float diameter = 2.0 * aperture * t;
        float mip      = log2(diameter / u_voxelSize);
        vec4  s        = SampleClipmap(origin + dir * t, mip);

        radiance  += (1.0 - occlusion) * s.rgb;  // front-to-back blend
        occlusion += (1.0 - occlusion) * s.a;
        t         += diameter * 0.5;             // step grows with the cone
    }
    return radiance;
}

The three cascades trade resolution for reach. Close to the camera, voxels are small enough to capture contact bounce off a desk lamp; the far cascade only needs to carry the broad strokes of distant skylight:

The injection pass copies direct lighting into the voxel grid, but it also copies emission. That one detail has an outsized visual payoff: any material that glows becomes a real light source, with soft falloff and colored bounce, without anyone placing a light. The neon scenes in the gallery are lit entirely this way. The bars themselves are the only sources in the scene, and the pink wash on the floor is the GI system doing its job.

Fig. 3

This is also why the system survives art iteration. A level artist can paint glow onto a sign, drop it into a scene, and the lighting is simply correct, every frame, with no bake step to wait for and no probe grid to maintain.

Reading about bounce light only gets you so far. The room below is a live, if simplified, global-illumination solver running in your browser, and it walks you through what bounce light adds in three stages: direct light alone, then the first bounce filling the room, then the colored wall bleeding its hue across everything. Your scroll runs the solve — scroll down and the bounces build, scroll back and they unwind. Grab the sun to steer the light, and swap the wall color to bleed a different hue.

The whole GI stack costs 3.2 ms at 1440p on the studio's RTX 4070 reference machine. The breakdown below is from the engine profiler, averaged over 1,000 frames of the atrium scene.

The main quality knob is the number of cones traced per pixel. More cones sample the hemisphere more finely, but the win fades fast: going from 2 to 6 cones cuts the error against a path-traced reference by two thirds, while going from 6 to 16 barely moves it and more than doubles the trace cost. REACT ships with 6.

The GI system exposes its knobs through the console, including the debug views used for every screenshot in this article: