Collision Response

This is the most common method for simulating rigid body collisions. It calculates an instantaneous change in velocity (an impulse) to be applied at the point of contact, derived from principles of Newtonian mechanics and the conservation of momentum.

• Key Formula: The impulse magnitude j is calculated considering the relative velocity, collision normal, and the combined inverse mass and inertia of the bodies.
• Primary Use: Ideal for simulating high-speed impacts and bounces where forces act over a very short time period, such as billiard balls colliding or a character jumping off a platform.

This approach simulates collision response by applying a continuous spring-like force that pushes intersecting objects apart. The force is proportional to the depth of penetration.

• Mechanism: Treats the inter-penetration as a spring, with the force calculated using a spring constant (k) and a damping coefficient. F = -k * penetration_depth - damping * relative_velocity.
• Trade-offs: Simpler to implement but can lead to unstable, "jittery" simulations if spring constants are too high, or overly soft, "squishy" collisions if they are too low. Often used for soft bodies or in simpler real-time applications.

Coefficient of Restitution (COR) is a scalar value between 0 and 1 that defines the "bounciness" of a collision. It determines how much kinetic energy is conserved in the direction of the collision normal.

• COR = 1: Perfectly elastic collision (e.g., superball). All kinetic energy is conserved; objects bounce apart with reversed relative velocity.
• COR = 0: Perfectly inelastic collision (e.g., lump of clay). No bounce; objects stick together, maximizing kinetic energy loss.
• Real-World Values: A basketball on a hardwood floor has a COR of ~0.75. This parameter is critical for achieving physical realism and is a core input to impulse-based calculations.

Friction opposes the relative tangential motion between surfaces in contact. In collision response, it is typically modeled using Coulomb friction with static and dynamic (kinetic) coefficients.

• Static Friction: Prevents sliding from starting. Applied when the relative tangential velocity is near zero.
• Dynamic Friction: Opposes sliding motion. The friction impulse is proportional to the normal impulse and the friction coefficient.
• Anisotropic Friction: Different coefficients can be applied in different tangential directions (e.g., a ski on snow). Accurate friction is essential for simulating objects coming to rest, sliding, or rolling.

Advanced physics engines treat contacts as velocity constraints that must be solved simultaneously. Instead of applying impulses sequentially, a solver finds a set of impulses that satisfy all contact and friction constraints at once.

• Process: Collisions generate constraints (e.g., "these two bodies should not inter-penetrate"). A solver, often using the Sequential Impulse or Projected Gauss-Seidel method, iteratively solves for the impulses that satisfy these constraints.
• Advantage: Produces more stable and accurate stacks of objects and complex resting contacts compared to naive impulse application. This is the method used in high-quality engines like NVIDIA PhysX and Bullet.

A specialized technique to prevent tunneling, where fast-moving objects pass through thin obstacles between simulation time steps. CCD predicts collisions within the time step, not just at its end.

• How it Works: Instead of testing static shapes, it tests the swept volume of an object's motion from time t to t+dt. The collision response is then calculated for the exact time of impact within the interval.
• Critical For: Simulating bullets, fast-moving projectiles, or objects in low-framerate simulations. It ensures robust response for high-velocity interactions that discrete detection would miss.

In video games and interactive simulations, collision response provides the immediate, believable physical feedback essential for immersion. Key implementations include:

• Impulse-based resolution for instantaneous bouncing and sliding of rigid bodies.
• Penalty force methods for simpler, spring-like reactions to overlaps.
• Resting contact and friction models to prevent objects from jittering or sliding unrealistically on surfaces. Engines like NVIDIA PhysX, Havok, and Bullet optimize these calculations for performance, often using approximations that favor visual plausibility over absolute physical accuracy.

For robots to interact with the physical world, they must predict and respond to contact forces. Collision response is used in:

• Grasp stability analysis: Simulating contact points and friction to evaluate if a grip will hold.
• Motion planning: Generating trajectories that account for anticipated collisions, such as pushing or sliding objects.
• Force control: Adjusting actuator torque in real-time based on simulated or sensed contact models to achieve delicate tasks like assembly or insertion. This enables training in simulation (Sim-to-Real) and deploying controllers that can handle physical interaction.

In offline rendering and cinematic animation, high-accuracy collision response creates realistic dynamics for complex scenes.

• Cloth and hair simulation: Uses continuous collision detection and response to prevent self-intersection and model fabric draping or braiding.
• Destruction effects: Calculates fracture patterns and the subsequent motion of debris pieces after collisions.
• Fluid-rigid coupling: Simulates how liquids splash off or flow around obstacles. Tools like Houdini and Blender use advanced solvers that prioritize visual fidelity, often employing Position-Based Dynamics (PBD) for its stability and artistic controllability.

In computer-aided engineering (CAE), collision response validates product designs under dynamic conditions.

• Crashworthiness testing: Simulates vehicle collisions to analyze structural integrity and passenger safety using Finite Element Analysis (FEA) solvers like LS-DYNA, which model plastic deformation.
• Drop testing: Predicts damage to consumer electronics from impacts.
• Mechanical assembly: Verifies that parts fit together without interference and that mechanisms operate correctly under load. These simulations require high physical accuracy, using implicit integration methods for stability with large time steps.

For believable AR/VR experiences, virtual objects must interact convincingly with each other and (in AR) with the real world.

• Object persistence: Virtual objects placed on a real surface must respond to collisions and remain stable.
• Haptic feedback: Collision detection triggers force feedback in controllers, with the response model defining the sensation's strength and texture.
• User interaction: Enables users to 'push' virtual objects, pick them up, or knock them over with natural physics. This demands low-latency, robust solvers to maintain immersion and prevent user discomfort.

Researchers use collision response to model phenomena at various scales, from astrophysics to molecular dynamics.

• Granular flow: Simulating the behavior of sand, powders, or pills in industrial processes, which involves millions of short-duration collisions.
• Molecular dynamics: Modeling atomic interactions where repulsive forces act as a continuous collision response.
• Celestial mechanics: Calculating gravitational interactions and simulating cosmic collisions between planetary bodies. These applications often use specialized discrete element method (DEM) or N-body solvers that aggregate collision effects statistically for performance.

The computational process that identifies when two or more simulated objects intersect. This is the prerequisite step for any collision response.

• Broad Phase: Quickly culls obviously non-intersecting object pairs using spatial data structures like Bounding Volume Hierarchies (BVH).
• Narrow Phase: Precisely calculates contact points, penetration depth, and collision normals for intersecting pairs identified in the broad phase.
• Without accurate detection, the response system has no data on which to act.

The branch of mechanics that models the motion of solid, non-deformable objects under forces and torques. Collision response for rigid bodies calculates impulses to change linear and angular velocity.

• Governed by Newton-Euler equations.
• Key properties are mass, center of mass, and moment of inertia.
• Responses include bouncing (restitution), sliding (friction), and resting (contact resolution).

The process of finding a configuration for a system of objects that satisfies defined relationships or limits. Collision response often formulates contacts as constraints.

• Contact Constraints: Prevent inter-penetration and model friction.
• Solver Types: Uses iterative solvers (fast, approximate) or direct solvers (accurate, computationally heavy) to resolve all constraints simultaneously.
• This ensures stable stacking and resting contact, not just instantaneous collisions.

A common method for resolving collisions by applying an instantaneous change in momentum (an impulse) to each colliding body.

• Calculated using the coefficient of restitution (bounciness) and friction coefficients.
• The impulse J is applied at the collision point to alter both linear and angular velocity.
• Efficient and suitable for real-time applications like games, but can struggle with stable stacking.

A collision response method that applies a continuous force proportional to the penetration depth between objects, pushing them apart.

• Simulates a spring-like force at the contact point.
• Conceptually simple but can lead to stiff equations requiring small time steps for stability.
• Often results in visible "jitter" or vibrating objects when deep penetration occurs.

The numerical method used to advance the state (position, velocity) of a simulated system forward in discrete time steps. The choice of integrator critically affects collision stability.

• Explicit Euler: Simple but can become unstable, especially with stiff collision forces.
• Implicit Euler: More stable for stiff systems (like hard constraints) but computationally more expensive.
• Semi-Implicit Euler (Symplectic Euler): Common in games; updates velocity first, then position, offering better energy conservation.