Physics Pipeline

The broadphase is the initial, coarse culling stage of the collision detection pipeline. Its purpose is to efficiently eliminate pairs of objects that are obviously too far apart to collide, drastically reducing the number of expensive precise tests required.

• Key Data Structures: Uses spatial partitioning systems like Bounding Volume Hierarchies (BVH), grids, or sweep-and-prune algorithms.
• Performance Impact: Operates in O(n log n) or near O(n) time, where n is the number of objects. It is the primary bottleneck for scenes with thousands of dynamic bodies.
• Output: A reduced list of potentially colliding pairs passed to the narrowphase.

The narrowphase performs precise geometric intersection tests on the candidate pairs provided by the broadphase. It calculates the exact contact data required for resolving collisions.

• Core Algorithms: Employs shape-specific tests (sphere-sphere, box-box) and general algorithms like the Gilbert–Johnson–Keerthi (GJK) algorithm for convex shapes and the Expanding Polytope Algorithm (EPA) for penetration depth.
• Output: For each colliding pair, it generates contact manifolds containing:
  • Contact Points: World-space points of intersection.
  • Contact Normal: The direction to separate the objects.
  • Penetration Depth: How far the objects are intersecting.

This stage formulates the physical laws and interactions as mathematical constraints and solves for the forces and impulses needed to satisfy them. Contacts from the narrowphase are converted into velocity-level or position-level constraints.

• Constraint Types: Includes contact constraints (prevent inter-penetration), friction constraints, and joint constraints (e.g., hinges, sliders).
• Solver Methods: Typically solved as a Linear Complementarity Problem (LCP) or using iterative solvers like Projected Gauss-Seidel (PGS). The solver finds impulses that satisfy J*v >= 0, where J is the Jacobian matrix and v is velocity.
• Objective: To compute the final velocity delta for each body that respects all constraints simultaneously.

Time integration is the final stage where the computed forces, torques, and constraint impulses are applied to update the kinematic state (position, orientation, velocity) of every body forward by the simulation time step (dt).

• Core Equation: Solves Newton's second law, F = m*a, by integrating acceleration to update velocity and position.
• Common Integrators:
  • Semi-Implicit Euler (Symplectic Euler): v_new = v + (F/m)*dt; p_new = p + v_new*dt. Most common for real-time engines due to stability.
  • Runge-Kutta Methods (RK4): Higher accuracy for predictive simulations, at greater computational cost.
• Result: Produces the new world state for rendering or the next simulation tick.

Continuous Collision Detection (CCD) is a safeguard stage, often integrated with broad/narrowphase, that prevents tunneling—where fast-moving or small objects pass through thin geometry in a single time step.

• Mechanism: Instead of testing static shapes, it tests the swept volume (the path of motion) between time steps for intersection.
• Algorithms: Uses conservative advancement, ray casting, or continuous versions of GJK.
• Use Case: Critical for simulating bullets, fast-moving robots, or objects in low-framerate simulations. It is computationally expensive and often applied selectively.

An optimization stage that groups interacting bodies into islands (connected graphs via constraints/contacts) and puts inactive islands to sleep. This dramatically reduces per-frame computation.

• Island Creation: After constraint solving, a graph traversal identifies isolated groups of bodies that can be solved independently.
• Sleep Criteria: An island is put to sleep when its kinetic energy falls below a threshold for several frames, indicating it is at rest.
• Wake-up: Sleeping islands are reactivated when a collision or external force is applied to any member. This is a key performance optimization for large, static environments.

The broadphase is the first, high-efficiency stage of the collision detection pipeline. Its primary function is to cull obviously non-interacting object pairs to reduce the computational load for the more expensive narrowphase. It uses spatial data structures to organize the simulation world.

• Key Data Structures: Bounding Volume Hierarchies (BVH), spatial hashing, sweep and prune, and uniform grids.
• Purpose: Generates a potential collision pair list of objects whose bounding volumes overlap.
• Performance Impact: Critical for scaling simulations with thousands of objects, as it reduces O(n²) pairwise checks to near O(n log n).

The narrowphase receives the potential collision pairs from the broadphase and performs precise geometric tests to determine if and how the objects intersect. This stage outputs detailed contact manifolds.

• Precise Algorithms: Uses algorithms like GJK (Gilbert–Johnson–Keerthi) for distance/computation and EPA (Expanding Polytope Algorithm) for penetration depth on convex shapes.
• Contact Manifold: The set of data describing a collision: contact points, a collision normal vector, and penetration depth.
• Output: A list of concrete contacts fed to the constraint solver to resolve interpenetration.

The constraint solver processes all contacts and joints to calculate the impulses or forces needed to satisfy physical constraints, such as preventing interpenetration (contact) or maintaining joint connections.

• Mathematical Framework: Often formulated as a Linear Complementarity Problem (LCP) or a system of equations.
• Iterative Solvers: Projected Gauss-Seidel (PGS) or its faster variant, Sequential Impulse, are common iterative solvers that handle multiple constraints simultaneously.
• Purpose: Ensures simulated bodies behave as solid objects (they don't pass through each other) and that articulated systems (like robots) move according to their joint limits.

Time integration is the final core stage that advances the simulation state forward in time. It takes the net forces and torques (from constraints, gravity, user input) and updates the position and velocity of each body.

• Numerical Methods: Common integrators include the semi-implicit Euler method (fast, moderate stability) and higher-order methods like Runge-Kutta 4 (RK4) (more accurate, computationally heavier).
• State Update: Computes new linear/angular velocities and translates/rotates bodies based on a fixed or variable time step (Δt).
• Stability vs. Accuracy: The choice of integrator and time step is a trade-off between simulation speed, energy conservation, and stability, especially for stiff systems.

Beyond the core four-stage pipeline, modern physics engines implement additional stages and optimizations for robustness, performance, and specific effects.

• Continuous Collision Detection (CCD): Prevents tunneling of fast-moving objects by testing collisions along their swept trajectory, often integrated after broadphase.
• Island Management: Groups interacting bodies into islands so the constraint solver works on independent sets, enabling parallel solving.
• Sleeping: Deactivates computations for bodies at rest to save CPU cycles, reactivating them when a potential collision is detected.

Different physics engines implement the pipeline with varying emphases on speed, accuracy, and feature set.

• NVIDIA PhysX: A dominant real-time engine. Uses a PGS solver, supports GPU acceleration for broadphase and narrowphase, and features specialized pipelines for rigid bodies, cloth, and particles.
• Bullet Physics: Popular in robotics and visual effects. Known for its robust GJK/EPA implementation and support for Featherstone's algorithms for articulated bodies.
• Open Dynamics Engine (ODE): A classic open-source engine. Uses a LCP-based solver and is known for its stability in simulating complex jointed mechanisms.
• MuJoCo: Designed for robotics research. Features a unique constraint solver that combines contacts and joints in a unified framework, prioritizing stability and differentiability for control optimization.

The broadphase is the initial, low-precision stage of the collision detection pipeline. Its purpose is to efficiently cull pairs of objects that are obviously not colliding, drastically reducing the number of expensive pairwise checks needed in the next stage. It uses spatial data structures like Bounding Volume Hierarchies (BVH) or spatial hashing to quickly identify potentially intersecting pairs.

• Purpose: Prune the O(n²) collision problem.
• Common Algorithms: Sweep and Prune, Dynamic AABB Trees, Grid-based partitioning.
• Output: A list of potentially colliding pairs for the narrowphase.

The narrowphase is the second, high-precision stage of collision detection. It takes the list of potentially colliding pairs from the broadphase and performs exact geometric tests to determine if a collision has actually occurred. This stage computes critical contact data:

• Contact Points: The exact location(s) of intersection.
• Penetration Depth: How far one object has intruded into another.
• Contact Normal: The direction to push the objects apart.

Algorithms like the Gilbert–Johnson–Keerthi (GJK) algorithm for convex shapes or the Separating Axis Theorem (SAT) are used here.

A constraint solver is the algorithmic core that resolves all forces and impulses to satisfy the physical rules of the simulation. After collisions are detected, the solver's job is to compute how to push intersecting objects apart (contact constraints) and how to enforce connections like hinges or sliders (joint constraints).

• Mathematical Framework: Often formulated as a Linear Complementarity Problem (LCP).
• Common Solvers: Projected Gauss-Seidel (PGS), Sequential Impulse, or Direct solvers.
• Goal: Find forces that prevent penetration and satisfy joint limits while respecting friction and restitution.

Time integration is the final stage that advances the simulation state forward in time. It takes the net forces and torques calculated for each body (from constraints, gravity, user input) and solves Newton's equations of motion to update positions and velocities.

• Core Equation: Solves F = ma (and its rotational equivalent).
• Common Integrators: Semi-implicit Euler (Symplectic Euler), Verlet, or Runge-Kutta methods.
• Challenge: Balancing stability (avoiding explosion) with accuracy and performance. The choice of timestep (fixed vs. variable) is critical.

Continuous Collision Detection (CCD) is a specialized technique that prevents tunneling, where fast-moving or small objects pass through thin geometry between discrete time steps. Instead of checking for collisions only at the end of a time step, CCD tests the continuous swept volume of an object's motion.

• Use Case: Essential for simulating bullets, fast-moving robots, or objects in low-framerate simulations.
• Methods: Swept sphere tests, conservative advancement, or speculative contacts.
• Trade-off: Computationally more expensive than discrete collision detection.

Contact generation is a sub-process within the narrowphase that produces the specific data structures (contact manifolds) used by the constraint solver. It is responsible for turning a detected geometric intersection into usable simulation information.

• Manifold Contents: Typically includes 1-4 contact points, a shared contact normal, and penetration depth.
• Clustering: Reduces multiple contact points to a stable set to improve solver performance.
• Persistence: Manifolds are often cached and updated across frames for temporal coherence, improving stability.