Growing planets from tectonic plates

The standard way to make procedural terrain is to stack a few octaves of Perlin or simplex noise and call the result mountains. It works on screenshots and fails on globes. Real continents are not statistically uniform: mountain belts run in long arcs along plate boundaries, river systems drain into basins that exist for structural reasons, and the west side of a mountain range is often soaked while the east side is desert. Noise has none of that causality, so noise planets feel like texture, not place.

REACT therefore generates terrain the way the Earth did: it simulates a compressed geological history, around 140 million years of it, and treats the elevation map as the output of that history rather than the input.

World generation runs once, offline, when a planet is created. It is a six stage pipeline, and each stage consumes exactly what the previous one produced. On a desktop machine the whole thing takes about 70 seconds for an Earth-sized world.

Boundary classification is where the planet's large features are decided. Each pair of neighboring plates is classified by their relative motion, and each class produces a different uplift signature, the same taxonomy a geology textbook uses:

The sea floor follows the same discipline. Continental shelves, slopes, abyssal plains, mid-ocean ridges and trenches are generated in the proportions Harris and colleagues measured when they mapped the geomorphology of Earth's actual oceans, so diving off a REACT coast crosses the same sequence of provinces a real submersible would.

The interesting consequence is that nothing downstream is arbitrary. If you find a desert in a REACT world, there is a mountain range upwind of it that stole its rain. If you follow a river upstream, you arrive at the highlands the simulation built during a plate collision.

Raw uplift produces mountain belts in the right places, but they come out as smooth ridges. What makes terrain look real is erosion. REACT uses the stream power law, the standard model in geomorphology for how rivers cut into bedrock:

Each erosion step computes flow directions over the current terrain, accumulates drainage area, erodes by the formula above, and deposits part of the sediment downstream. Run that 200 times against continuing uplift and the two processes reach an equilibrium: peaks stay sharp where uplift is active, while older ranges decay into rounded hills with broad foothills.

for (int step = 0; step < w_erosion_steps; ++step) {
    ComputeFlowDirections(height, flow);   // steepest descent per cell
    AccumulateDrainage(flow, area);        // upstream area, O(n) sweep
    ApplyUplift(height, uplift, dt);       // tectonics keep pushing

    // stream power law: E = K * A^m * S^n  (m = 0.5, n = 1)
    ErodeStreamPower(height, area, K, 0.5f, 1.0f, dt);
    DepositSediment(height, flow, 0.35f);  // 35% settles downstream
}

Erosion runs on a 4,096 by 2,048 spherical grid on the GPU. That is far too coarse to walk on, which is what the next section is about: the simulation provides the large structure, and detail is synthesized underneath it at render time, conditioned on what the geology says each spot should be made of.

A planet is too large for any fixed mesh. REACT maps six quadtrees onto the faces of a cube projected onto the sphere, and subdivides each one toward the camera. Every node, leaf or not, carries the same 33 by 33 vertex patch, so the triangle count per node is constant and the detail level is set purely by how deep the tree splits.

Geomorphing blends each patch toward its parent before a split or merge, so the surface never pops. Positions are computed camera relative in double precision on the CPU and only then handed to the GPU in floats, which is what keeps the geometry stable when you are standing on a beach 6,371 km from the planet's origin.

The budget below is the part that makes planetary scale practical: because each quadtree level covers four times the area of the one below it, the triangle count per distance ring stays roughly flat. You spend your triangles where the player is looking, and the whole rest of the planet costs less than the nearest kilometer.

All of this machinery exists for one reason: places with history feel different to play in. A valley in REACT is somewhere a river decided to be over millions of simulated years. When a story scene is staged in that valley, the geography is load bearing, and the player can feel that even if they never know why.

It is also the studio's proof of headroom. The first game is not a planet sim; it is a story-driven title in hand-built scenes. But an engine that streams a whole world with no loading screens runs those scenes with an enormous margin, and this system is where that margin was earned.

The terrain system is tuned through console variables, all adjustable live in the in-engine console. The interesting ones: