Rigid body physics simulation for game graphics

Rigid Body Physics Simulation for Game Graphics

Destructible building in a game does not look like a rock falling on ground in reality — and that is correct. Game rigid body physics solves not the task of physical accuracy, but the task of visual believability at minimal computational cost. The difference is fundamental: PhysX in Unity calculates rigid body interactions in real time on CPU, and with 50 simultaneously active Rigidbody with mesh collider instead of primitives, you easily lose 10ms frame time on physics in an empty scene.

Rigidbody Architecture for Destruction Visual Effects

Debris simulation during destruction is the most common task. A building explodes, pieces fly apart. Naive approach: split the mesh into pieces, add Rigidbody to each, activate on explosion. Problems with this approach become apparent after first profiling.

Mesh Collider vs primitives. Mesh Collider for each fragment is convex mesh computation at each FixedUpdate. For 20 fragments on GPU this is acceptable, for 200 — not. Correct solution: composite collider from primitives (several Box Collider or Capsule Collider on one GameObject) that approximate the fragment shape. This is 5–10 times cheaper, visually almost indistinguishable at fast debris movement.

Sleeping. Rigidbody enters Sleep state when velocity drops below Physics.sleepThreshold. Sleeping Rigidbody do not consume CPU. Critical: ensure that sleepThreshold is not too low (default 0.005 — usually normal), and that objects actually sleep after landing. If a fragment lies on uneven surface and micro-vibrates — it never sleeps. This is fixed through AddTorque = 0 + forced rigidbody.Sleep() via Coroutine with velocity < threshold check.

Pooling. Debris objects should return to Object Pool, not be destroyed through Destroy(). Destroy() causes GC allocation, giving frame spike exactly when explosion happens — when performance is already under load. Pool with fixed maximum 50–100 fragments, LRU eviction (oldest deactivated when space runs out) — standard pattern.

Fractured Mesh and Pre-Broken Geometry

Realtime fracturing (Voronoi subdivision on impact) — looks great in demo, expensive in production. On PC this is acceptable for rare events (explosion once every 30 seconds), on mobile — practically unacceptable.

Industry standard: pre-broken geometry. The object is fractured into pieces in advance in DCC tool (Blender Fracture Modifier, 3ds Max ProBoolean, or specialized tool like RayFire). All fragments exist in scene initially, but without Rigidbody, in Kinematic mode or simply static. On explosion: enable Rigidbody, apply AddExplosionForce, fragments scatter.

Explosion Force in Unity: Rigidbody.AddExplosionForce(force, explosionPos, radius, upwardsModifier). upwardsModifier is important parameter, often ignored. It adds vertical component to force, making explosion more "upward" instead of purely radial scatter. Value 0.5–1.0 creates more cinematic look.

For large objects (building, wall), fragments can be hierarchical: large chunks fracture into smaller ones on landing through secondary fracture trigger.

Cloth Simulation as Part of Rigid Body Scene

PhysX in Unity contains Cloth component for Skinned Mesh Renderer — this is soft body simulation. Flag in wind, character cape, ropes — all this is Cloth. Cloth and Rigidbody integration is a common task: a flag attached to a pole that falls as Rigidbody.

Cloth Constraint — this is fixed particles (vertices pinned to transform) and free ones. On pole falling: Constraint Target transforms along with Rigidbody pole, cloth follows. Limitation: Unity Cloth does not support collision with dynamic Rigidbody — only with spheres and capsules, specified through cloth.capsuleColliders and cloth.sphereColliders. This means cloth will not correctly interact with debris — need either approximation through primitives or fake through animation.

Ragdoll and Active Ragdoll for Characters

Ragdoll is a set of Rigidbody + Joint on character skeleton, activated on death or fall. Standard Unity Ragdoll Wizard creates basic structure, but its result requires fine tuning.

Key problems with default ragdoll:

• ConfigurableJoint with too wide angular limits → limbs fold into physically impossible poses
• Small Rigidbody (fingers, feet) with low mass → solver instability, jitter
• Transition from Animator to Ragdoll visible as pose "click"

Active Ragdoll — hybrid approach: Animator continues working, but Rigidbody joints apply force to follow animated poses. In Unity, this is implemented through ConfigurableJoint.targetRotation = difference between current joint rotation and target from Animator. Weight of physics vs animation managed through Joint.slerpDrive.positionSpring. This gives procedural falling with preserved animation control — character "fights" physics instead of instantly becoming a ragdoll.

Cost is calculated individually. Need description of scene, number of simultaneous objects, target platform, and existing physics architecture of the project.