The Cape That Doesn't Move

You're forty hours into an open-world RPG. Your character storms into a crowded marketplace, thirty NPCs milling around, and you notice it: your hero's cloak ripples in the wind, but the merchant two feet away is wearing what appears to be a shirt cast from concrete. His collar doesn't shift. His sleeves don't react when you brush past. He looks, briefly, like a mannequin someone dressed in a hurry.

That isn't a bug. It's a decision. A fast, automated, ruthless one.

The Budget Problem No One Talks About

Cloth physics is expensive in a very specific way. Unlike rendering a static mesh, simulating cloth means treating fabric as a grid of interconnected points (vertices) and solving for the forces acting on each one dozens of times per second. Gravity pulls down. Wind pushes sideways. Collision geometry pushes back. Each vertex influences its neighbours, and for a single high-quality cape with roughly 2,000 simulated vertices running at 60 frames per second, you're looking at millions of constraint-solving operations every second, just for that one piece of cloth.

Scale that to a battle scene with 40 characters.

You don't have a physics problem. You have a budget crisis.

Engines solve this with a tiered simulation system, and the tiers are ruthless.

How the Tiers Actually Work

The core mechanism is distance-based level of detail, or LOD, applied to physics rather than geometry. Most modern engines, including Unreal Engine's Chaos Cloth system, Unity's DOTS-based cloth, and proprietary systems like the one Naughty Dog built for The Last of Us Part II, maintain a priority queue that re-evaluates every frame or every few frames.

The rules feeding that queue stack up like this:

Camera distance. The single biggest factor. A character within roughly 8 to 10 metres of the camera gets full simulation. From 10 to 25 metres, the engine cuts vertex count, often by half or more, and drops the solver iteration count from something like 8 passes per frame down to 2 or 3. Beyond 25 metres, many engines switch to a pre-baked animation blend: a recorded approximation of cloth movement, looping with a small randomisation offset so it doesn't look mechanical. You never notice, because at that distance you couldn't see the difference regardless.

Screen-space coverage. Distance alone isn't enough. A character might be close to the camera but mostly occluded by a wall, covering only 0.3% of the screen. Smarter engines weight by actual pixel coverage rather than raw distance. A giant NPC filling 15% of the frame at 20 metres gets more simulation budget than a tiny background figure at 12 metres.

Player character first, always. The protagonist's cloth is ring-fenced. Full simulation regardless of scene load, because in third-person games players are staring at it constantly. Every other character competes for what's left.

Importance flags set by designers. This one is manual. A narrative designer can tag a specific NPC as high-priority, say a villain in a cutscene, and that flag overrides the distance calculation entirely. The engine's automation handles the anonymous crowd; the humans handle the moments that matter.

Picture a battle sequence: 38 background soldiers, one named ally, the player character. The player's cloak gets full simulation, always. The named ally within 6 metres gets full simulation. Eight soldiers in the mid-range band get reduced solver passes and a simplified mesh. The remaining 29 soldiers beyond 22 metres get pre-baked cloth animation, possibly no simulation at all. Total cloth simulation budget for that frame: roughly equivalent to 4 to 6 full-quality capes, not 40.

That trade-off is not a failure of ambition. It is the whole game.

The Misconceptions Worth Correcting

The common assumption is that this is purely a GPU problem. It isn't. Cloth physics runs on the CPU (or increasingly on a compute shader, but that's a separate conversation). The constraint solver is serial in structure, which means it doesn't parallelize as cleanly as rendering does. Throwing more GPU power at a game won't automatically improve cloth quality in crowd scenes. The bottleneck is CPU time and memory bandwidth, and no amount of shinier graphics cards fixes that.

The other misconception: that lower-quality cloth on distant characters signals developer laziness. The opposite is true, and it's one of the more underappreciated engineering challenges in real-time graphics. Building a robust LOD system for physics is significantly harder than just simulating everything at full quality. You have to ensure transitions between tiers aren't visible, that characters don't snap or pop as they cross distance thresholds, and that pre-baked animations loop with enough variation to pass a casual glance. Think of it like a stage magician's misdirection: the trick only works if you never see the seams.

Red Dead Redemption 2's crowd systems are a good example of this done right. Stand in a busy saloon and watch the NPCs. The transitions are invisible, which required a serious amount of engineering to pull off.

There's also a subtler issue worth knowing. Cloth simulation interacts with collision detection, and a cape that clips through an arm looks worse than a cape that doesn't move at all. So at lower LOD tiers, engines often disable collision entirely and let the cloth run free of any collision response. That's why a distant NPC's cloak sometimes phases through their own body without consequence. The engine made a judgment call: visible clipping at 30 metres is less distracting than the CPU cost of preventing it.

Ask yourself: when did you last actually notice a background NPC's sleeve phasing through a wall?

Exactly.

The Frame Budget Is a Negotiation

Every frame your hardware renders is a negotiation between competing systems. Cloth is one line item. Shadow maps, ambient occlusion, particle effects, AI pathfinding, they're all in the same room fighting for milliseconds. The cloth physics manager receives a time budget from a central scheduler, something like "you have 1.2 milliseconds this frame," and it allocates that across all active simulations using the priority rules above.

When scenes get heavy, that budget shrinks. The cloth system responds by demoting characters down the tiers faster, tightening the distance thresholds. This is why cloth quality in crowd scenes can vary between a quiet village and a battle sequence even when you're standing in the exact same spot.

So the next time you spot a cape moving beautifully in the middle of a chaotic fight, that's not luck. Some engineer spent real time making sure the priority system protected that moment.

The frozen merchant collar is the cost. The rippling hero's cloak is the point. The best systems make that trade so cleanly you spend forty hours never once thinking about it, which is its own kind of craft.