The Field That Isn't Really Moving

You're riding across a meadow, wind rolling through the grass ahead of you, a ripple spreading outward like something invisible just exhaled across the field. It feels physical. Alive, even.

It's almost entirely fake.

And the fakery is one of the more elegant engineering tricks in modern software. Game engines don't animate every blade of grass. They can't. A single square kilometer of dense field geometry, fully simulated, would collapse any GPU on the planet. What they do instead is make decisions, dozens of them per frame, about which blades matter right now, to this camera, in this moment. The result looks indistinguishable from full simulation. Understanding how that works is understanding something genuinely interesting about how computers lie to your eyes.

The Culling Cascade

Before any animation runs, the engine needs to decide what even exists.

Frustum culling comes first. The camera has a viewing cone, and anything outside it is simply not processed. The grass behind your character, beside you, beyond the horizon: gone from the pipeline entirely. This alone cuts the workload by roughly 80% in a typical outdoor scene.

Then distance culling. Grass past a certain radius, often 150 to 300 meters in most modern titles, gets swapped to an impostor: a flat texture, a particle system, or nothing at all. You don't see fine blade animation at that range. The pixels are too small to care.

Occlusion culling handles the rest. A hill blocking a valley means the valley's grass doesn't render. A stone wall, same logic. The engine maintains a rough depth buffer and skips anything behind solid geometry.

What survives all three passes is a surprisingly small slice of the total field. That slice gets animated. Everything else gets a convincing impression of animation at almost zero cost.

The Wind Is a Math Function, Not a Simulation

This is the part that surprises people most.

There is no wind in a game field. No fluid simulation, no particle pressure, no physics of air moving through geometry. What there is: a sine wave.

A typical grass shader takes a blade's world-space position, feeds it into a sine function alongside a time value and a direction vector, and outputs a displacement. The blade bends. Neighboring blades have slightly different X and Z positions, so they get slightly different inputs, so they bend at slightly different phases. The ripple emerges from math, not physics. It's less like simulating weather and more like conducting an orchestra where every musician is playing the same score, just slightly out of step.

Ubisoft's documentation on Far Cry 5 and later titles made this visible: the wind is essentially a texture scrolling across the world, a noise map encoding gust intensity at every point. The shader samples that texture at each blade's position and scales the sine displacement accordingly. Strong gust zone, big displacement. Calm zone, small one. The texture scrolls over time, and gusts appear to travel.

The cost is trivial. A sine function and a texture sample per blade per frame, running on hundreds of thousands of blades simultaneously in a single GPU compute pass.

The LOD Ladder: Where the Real Decisions Happen

Level of Detail, LOD, is where the engine earns its keep on grass specifically, because grass presents a harder LOD problem than almost any other object in a scene.

A tree has one trunk, a few major branches, manageable geometry. A field has no natural hierarchy. Every blade is equally important, and equally unimportant. So engines build an artificial hierarchy called a hierarchical LOD system, sometimes shortened to HLOD.

Here's how it plays out. Within ten meters of your character, individual blades render as full 3D geometry, each one a few triangles, animated at full fidelity with per-blade sine displacement. From ten to fifty meters, the engine switches to clusters: groups of eight to twelve blades represented as a single mesh, animated as a unit. From fifty to two hundred meters, you get billboard cards, flat quads that always face the camera, with wind animation baked into a texture flip or a simple vertex shader. Beyond that, the grass is a colored texture on the terrain mesh itself.

The transition between LOD levels is where bad implementations fall apart. A field that pops, where blades visibly appear at a distance threshold, is a LOD transition problem, full stop. Good engines cross-fade between levels using alpha blending, spending a few frames dissolving one representation into the next. The Witcher 3 became notorious among players for its grass density settings partly because CD Projekt Red's LOD transitions were unusually smooth for their era, and players could actually see the difference when the setting was lowered.

Consider two players running the same game on different hardware. Priya plays on a high-end desktop with LOD distances pushed to 200 meters and smooth cross-fades. Her friend Marcus runs a mid-tier laptop and gets LOD transitions at 80 meters with faster fades. Priya's field looks like a painting. Marcus's field looks fine. Neither of them can see the actual mechanism.

That's the point.

Interaction: When the Player Walks Through It

Static wind animation is one thing. The harder problem is interaction: what happens when something large moves through the grass and the grass is supposed to respond.

The common approach is a world-space interaction buffer, a small render target often 512x512 pixels representing a patch of ground around the player. When the character moves, the engine writes displacement vectors into this buffer at the character's foot positions. The grass shader samples the buffer alongside the wind texture and bends away from high-displacement regions.

This creates the parting-grass effect. It's cheap, convincing, and physically nonsensical in detail (the displacement doesn't propagate with real momentum), but the eye accepts it because the broad strokes are right.

Some engines add a spring term so displaced blades snap back over a second or two after the character passes. Ghost of Tsushima is the game journalists reach for most when describing this effect, and fairly so: Sucker Punch pushed interaction quality noticeably further than contemporaries, using a combination of interaction buffers and per-blade return forces that made the grass feel genuinely weighted underfoot.

What People Assume That Isn't True

The common assumption is that better-looking grass means more blades being animated. More polygons, more simulation, more grass.

Wrong, mostly.

The biggest visual gains in grass rendering have come from better noise functions for wind, better LOD cross-fading, and better interaction response, not from raw blade counts. A field of 200,000 well-shaded, well-animated billboard cards can look more convincing than 2,000,000 poorly-lit individual blades. Density without quality is just noise, and any engine developer will tell you the same thing.

Also, and this is worth knowing if you're tweaking settings: grass animation sliders on PC are among the most GPU-expensive toggles you can pull. Doubling grass density doesn't double the cost. It can quadruple it, because you're not just adding blades, you're adding blades that each need LOD evaluation, shader sampling, and culling decisions every frame. So if your frame rate is struggling, check that slider before you blame shadows or resolution.

The Honest Limitation

None of this is simulation. The wind doesn't know the grass is there. The grass doesn't know the wind is real.

What you're watching is a carefully coordinated illusion: culling to limit scope, sine functions to fake physics, LOD hierarchies to manage cost, interaction buffers to fake presence. The whole system is built on a single accurate observation about human vision: we're not optimized to audit the physics of grass. We're optimized to detect motion, rough direction, and the presence of something alive.

Game engines have figured out exactly how much reality it takes to satisfy that detector without doing one frame of unnecessary work. That's not a limitation. That's the craft.