The Body That Nobody's Watching

You shoot an enemy in a corridor and he tumbles backward through a doorway. The moment he clears the frame, something changes. The simulation running his body quietly strips itself down to a skeleton half as complex as the one you just watched crumple, and the game's physics budget exhales like a surgeon putting down a scalpel.

You never see it happen.

This is ragdoll level-of-detail, one of the more quietly elegant pieces of engineering in modern game development. Engines decide which joints to simulate through a layered system of spatial distance, camera visibility, and a skeletal hierarchy that pre-ranks every joint by how much it contributes to readable motion. The joints that matter to your eye stay live. The rest get frozen, blended out, or handed to a much cheaper approximation.

Go a little deeper and the logic gets genuinely interesting.

Bones Are Not Free

A full humanoid rig in a contemporary action game typically carries somewhere between 60 and 100 bones. Fingers alone can account for 15 of those. Simulate every joint with real constraint-based physics, resolve all the contact points, handle self-collision, and you're looking at a calculation that costs real milliseconds per character per frame.

Multiply that by a chaotic scene where a grenade sends eight enemies airborne simultaneously. Physics budgets in most engines are hard-capped, because a spike that pushes a frame from 16ms to 40ms is indistinguishable from a crash to the person holding the controller.

So engines cheat. Strategically, carefully, invisibly.

The cheat is called physics LOD, borrowing from the older graphical level-of-detail system that swaps a detailed mesh for a simpler one as a model moves away from camera. Same principle, different domain. It works because players are not looking at fingers.

The Hierarchy That Does the Heavy Lifting

Before any runtime decision gets made, a rigger and a technical animator have already done the crucial work: they've assigned every bone in the skeleton a LOD tier.

Tier zero is the spine, pelvis, clavicles, upper arms, and upper legs. These are the joints your visual system tracks automatically. You read a character's momentum and weight almost entirely from this set, and if you simulate them wrong, the body looks broken in a way that no amount of correct finger physics will fix.

Tier one adds forearms, shins, and the head. Still important, especially when a face is visible, but perceptually forgiving at distance.

Tier two is everything else: fingers, toes, individual vertebrae in a detailed spine rig, the small bones of the jaw. These exist for close-up cinematics and idle animations. In a live physics simulation, their contribution to the overall silhouette is nearly zero.

At runtime the engine consults this hierarchy constantly. A body that's active, on-screen, and within roughly ten meters of camera runs a full Tier 0+1 simulation with optional Tier 2. A body that's fallen behind cover runs Tier 0 only. A body that's fully offscreen might run nothing at all, its final pose frozen in memory until it re-enters a visibility volume.

The specific thresholds vary by studio. Unreal Engine's physics asset system exposes these LOD settings directly to developers, letting them tune per-skeleton which bodies get simplified at which distances. The defaults are conservative. Most shipped titles push them harder.

What "Simulate Nothing" Actually Means

Freezing a ragdoll offscreen sounds simple. It isn't.

The problem is re-entry. Hard-freeze a body's joints and then have a player spin the camera back toward it, and the snap from frozen pose to active simulation is immediately jarring. So engines don't hard-freeze so much as they run a ghost simulation: a single rigid body approximating the whole character as one capsule, just enough to keep it tumbling plausibly on a slope, just enough that when the full simulation reactivates, the pose hasn't teleported somewhere absurd.

Think of it like a drummer keeping time offstage while the rest of the band is on break. The orchestra can re-enter on beat because someone never stopped counting.

Some engines go further with kinematic blending, where a fully offscreen body's pose interpolates toward a pre-authored dead pose over roughly half a second. By the time you look back, the body is in a position that reads as naturally settled, even though an animator crafted that position years before you fired the shot.

The Visibility Test (and Why It's Cheaper Than You Think)

How does the engine know a character is offscreen? Frustum culling handles the obvious case: if the bounding box isn't inside the camera's view frustum, it's invisible. But that's incomplete.

A character behind a thin wall is inside the frustum and genuinely occluded. Running full physics on them is pure waste. So engines layer occlusion culling on top, a fast approximate test using either a depth buffer readback or a dedicated occlusion query that asks the GPU whether any pixel from the character's bounding volume actually reached screen.

This test doesn't run every frame for every character. It runs on a staggered schedule, roughly every four to eight frames per character, with results cached. The physics LOD system reads those cached results and adjusts simulation tier accordingly. Latency between a character going invisible and their simulation stepping down is usually under 150 milliseconds: long enough that no transition artifact is visible, short enough that the budget saving is real.

For the character on the other side of a door you're about to open, this creates an interesting edge case. They might be at reduced LOD the instant before the door swings, which is why physics-heavy games typically maintain a minimum LOD tier for any character within about five meters regardless of visibility. You're about to see them. Keep them ready.

Two Players, One Grenade, Very Different Outcomes

Here's a worked example worth sitting with. Maya is playing on a high-end desktop with a physics budget set to allow twelve simultaneous full-tier ragdolls. She throws a grenade into a crowd of ten enemies. All ten go airborne. Eight are fully in frame. The engine assigns Tier 0+1 to all eight and Tier 0 to the two tumbling offscreen left. Every finger is frozen. Every toe is frozen. The spines, hips, and limbs do the work. It looks spectacular and runs fine.

Dan is playing the same game on a mid-range console with a budget for six full-tier ragdolls. Same grenade, same crowd. The engine assigns full simulation to the six closest to camera and drops the other four to ghost capsules immediately. Dan sees the same hero deaths in frame, the same satisfying weight. The four bodies out of frame settle into pre-authored dead poses.

Neither player notices a difference, because the difference was designed to be unnoticeable. That's the engineering goal, stated plainly: spend physics budget where eyes are pointed.

The Joint You Never Miss

Here's an opinion the spec-sheet crowd won't love: more simulation is not always better. A fully active finger joint during a high-velocity tumble can vibrate, clip geometry, and produce an artifact that reads immediately as a bug rather than realism. Freezing it and blending the hand toward a neutral pose is often the cleaner result. The human visual system is remarkably tolerant of a still hand on a tumbling body. It is not tolerant of a hand jackhammering through a wall at sixty frames per second.

So the hierarchy isn't purely about budget. It's about which joints, when simulated imperfectly under stress, create the worst-looking failures. Tier two bones sit at the bottom of the list partly because they're expensive and rarely seen, and partly because they fail badly when the physics solver is pushed. That lesson came out of the early ragdoll era, when games first enabled full-body physics and players spent more time laughing at vibrating fingers than admiring the falls.

And honestly, that era is why any of this engineering exists at all.

The bones that survived the cut are the ones that carry weight in both senses of the word.