Why the sky is blue, and how to render it

Sunlight reaching your eye through the atmosphere has been redirected by two very different populations of particles. Air molecules are thousands of times smaller than the wavelength of visible light, and scatter according to Rayleigh theory. Aerosols, meaning dust, salt and water droplets, are about the same size as the wavelength, and scatter according to Mie theory. Every visual property of the sky comes from the interplay of these two.

The Rayleigh part carries the color. Its strength falls off with the fourth power of wavelength, which is a brutally steep curve:

Look up on a clear day and you see sunlight that scattered into your eye from the side: mostly blue, by the curve above. Look at the sun at the horizon and you see what is left after a long slant path through the air: the blue has been scattered away en route, leaving red. One curve explains both the noon sky and the sunset, which is exactly the kind of economy you want from a model.

Mie scattering from aerosols is nearly wavelength independent, which is why haze looks white. What makes it visually distinctive is its direction: aerosols throw light strongly forward, producing the bright glow around the sun. REACT models this with the Henyey-Greenstein phase function, where a single parameter g controls how forward-biased the scattering is.

Putting it together: the light arriving at the camera along a view ray is the sum, over every point on that ray, of sunlight that survived the trip into the atmosphere, scattered toward the camera at that point, and then survived the trip back out. Survival is governed by transmittance, which is Beer-Lambert attenuation along the path:

Evaluating this nested integral by brute force for every pixel every frame is hopeless: 32 view samples times a transmittance integral each is thousands of operations per pixel. The standard solution, which REACT adopts from Bruneton and Neyret, is to notice that the integrals depend on only a handful of parameters, like altitude and the angles to the sun. Anything that depends on few parameters can be precomputed into a lookup table.

When a planet loads, REACT bakes its atmosphere into a small set of textures. Transmittance from any altitude in any direction becomes one 2D table. Single scattering becomes a compact 3D table. Multiple scattering, light that bounced through the air more than once, is computed by iterating on the previous tables three more times. It accounts for most of the sky's brightness at dusk, so skipping it is not an option.

The exact tables, their resolutions and what they are parameterized by:

At runtime, evaluating the entire sky comes down to a handful of texture fetches and two phase functions:

vec3 SkyRadiance(vec3 eye, vec3 dir, vec3 sunDir) {
    ScatterParams p = ParamsFor(eye, dir, sunDir);
    float mu = dot(dir, sunDir);

    vec3 rayleigh = texture(u_scatterLUT, p.uvw).rgb * RayleighPhase(mu);
    vec3 mie      = texture(u_mieLUT,     p.uvw).rgb * HGPhase(mu, a_mie_g);

    return (rayleigh + mie) * u_sunIrradiance;
}

Because the tables are parameterized by altitude, the same data serves a hiker on the surface and a ship in orbit. The earthrise shot at the top of this page and a sunset on the ground are the same lookup tables, sampled from two ends.

The clouds living inside this sky are their own system, built on Schneider and Vos's Horizon Zero Dawn cloudscapes and the Nubis follow-ups: density fields carved from Worley's cellular noise layered with Perlin, raymarched in 64 steps, with their powder-sugar darkening at the sun-facing edges. The shafts of light they cast come from Mitchell's post-process volumetric scattering, which is why god rays through a cloud gap cost a fraction of a millisecond rather than a real volumetric pass.

Everything in this article is tunable from the in-engine console: