Impulse-Based Dynamics

The core mechanism applies an instantaneous change in momentum (an impulse) at the exact moment of collision, calculated to satisfy physical laws like conservation of momentum and the coefficient of restitution. This is distinct from force-based methods that integrate continuous forces over a timestep. The primary equation is J = -(1 + e) * (v_rel · n) / (1/m_a + 1/m_b + (r_a × n)²/I_a + (r_b × n)²/I_b), where J is the scalar impulse magnitude, e is restitution, v_rel is relative velocity, n is the contact normal, m is mass, r is the vector from center of mass to contact point, and I is moment of inertia.

Impulses are also used to enforce joint constraints (e.g., hinges, sliders) and persistent contacts. A Sequential Impulse solver iteratively applies corrective impulses at all constraints until they are satisfied within a tolerance. This is analogous to solving a Linear Complementarity Problem (LCP) but is often implemented via a projected Gauss-Seidel method. Key advantages include:

• Warm Starting: Using the impulse solution from the previous frame as an initial guess, dramatically improving solver convergence.
• Baumgarte Stabilization: Adding a small bias term to the impulse calculation to correct positional drift in constraints over time, keeping joints from coming apart.

Designed for real-time performance in games and interactive simulations. Its efficiency stems from:

• Low Iteration Count: Often converges in a small, bounded number of iterations (e.g., 4-10) per frame, providing predictable performance.
• Explicit Velocity Update: Directly modifies velocities, avoiding the numerical stiffness issues associated with integrating very large penalty forces.
• Solver Simplicity: The sequential impulse algorithm is relatively straightforward to implement and parallelize compared to full-matrix solvers. This makes it the standard in engines like Box2D and Bullet (for its rigid body solver).

Impulse-based dynamics models surface interactions through specialized impulses:

• Coulomb Friction: A tangential impulse is applied to oppose relative sliding motion. Its magnitude is capped by the product of the normal impulse and the friction coefficient (μ). This is often visualized as a friction cone.
• Coefficient of Restitution (COR): Encoded directly in the normal impulse calculation. A COR of 1 results in a perfectly elastic collision (kinetic energy conserved), 0 is perfectly inelastic (objects stick together), and values in between model real-world energy loss. This provides intuitive, artist-friendly control over material "bounciness."

This method prioritizes robustness and stability over perfect physical accuracy. Characteristics include:

• Iterative Approximation: The sequential solver finds a feasible solution, not necessarily the globally optimal one, which is sufficient for visual plausibility.
• Penetration Allowance: Small overlaps (penetration) between bodies are tolerated and corrected over several frames, avoiding the infinitely stiff forces of a perfectly accurate solution.
• Time Step Dependency: Results can vary with the size of the simulation time step, though this is mitigated by fixed-timestep updates. It is less suited for high-precision engineering analysis than force-based or penalty method simulations with very small timesteps.

Impulse-Based is one of three primary paradigms for contact resolution:

• vs. Penalty Method: Penalty methods use virtual spring-damper forces at penetration points. They are simpler but can cause numerical stiffness and "jitter" with large mass ratios. Impulse-based is generally more stable.
• vs. Force-Based (LCP): Force-based solvers compute all contact forces simultaneously by solving a system of equations (LCP). This is more accurate for complex, tightly-packed stacks but is computationally heavier and less predictable. Impulse-based is faster for the typical number of contacts in real-time applications.
• vs. Position-Based Dynamics (PBD): PBD directly manipulates positions to satisfy constraints, offering great control but less physical accuracy in dynamics. Impulse-based works in the velocity domain, preserving Newtonian momentum principles.

Impulse-based dynamics is the dominant method in real-time game physics engines (e.g., Box2D, Bullet's impulse-based solver) due to its computational efficiency and stability for handling numerous collisions per frame. It excels at simulating:

• Rigid body collisions for objects, debris, and destructible environments.
• Simple joint constraints like hinges and sliders for doors, bridges, and ragdolls.
• Stacking and piles of objects, where iterative impulse resolution can achieve stable, believable results quickly. Its deterministic and tunable nature allows developers to prioritize perceptual correctness and performance over absolute physical accuracy.

In robotic simulation for training and prototyping, impulse-based methods provide a fast, stable baseline for contact-rich tasks. They are particularly useful for:

• Rapid prototyping of manipulation and locomotion policies where exact force profiles are secondary to kinematic feasibility.
• Sim-to-real transfer learning pipelines, where a robust, if simplified, contact model can generate diverse training data for reinforcement learning agents.
• Simulating non-penetration constraints for gripper-object or foot-terrain interactions without the computational cost of a full Linear Complementarity Problem (LCP) solver. This enables faster iteration in early-stage design and policy training.

For VR applications and haptic rendering, impulse-based dynamics provides the low-latency response critical for user immersion. Key uses include:

• Object manipulation: Providing immediate, believable force feedback when a user 'picks up' or collides with a virtual object.
• Environment interaction: Simulating contact with walls, tools, and other props.
• Stability under user input: The method's handling of constraint stabilization helps prevent numerical explosion from unpredictable, high-frequency user inputs, maintaining a stable virtual world essential for preventing simulator sickness.

Impulse-based solvers are foundational in interactive physics educational software and sandbox simulators (e.g., PhET Interactive Simulations, Algodoo). Their advantages include:

• Conceptual clarity: The direct application of an impulse-momentum theorem (Δp = J) maps clearly to introductory physics principles.
• Real-time interactivity: Allows students to manipulate objects and immediately see the consequences.
• Visualizing collisions: Parameters like the coefficient of restitution (COR) can be adjusted in real-time to show the spectrum from perfectly inelastic to perfectly elastic collisions.

Understanding impulse-based dynamics requires contrasting it with force-based methods like the penalty method.

• Impulse-Based: Solves for instantaneous velocity changes. Pros: Guarantees non-penetration, inherently handles resting contact, more stable for stiff constraints. Cons: Can exhibit popping (sudden velocity changes) and requires careful handling of friction cones.
• Force-Based (Penalty): Applies continuous spring-damper forces based on penetration depth. Pros: Simpler to implement for simple cases, provides continuous force output. Cons: Allows temporary penetration, requires very high stiffness (leading to numerical instability) for rigid bodies, poorly handles resting contact. Impulse-based methods are generally preferred for rigid body simulation where non-penetration is a hard constraint.

While fast and stable for many applications, impulse-based dynamics has limitations that necessitate more advanced solvers in high-fidelity contexts:

• Complex Friction: Accurately modeling Coulomb friction with stiction and sliding requires approximating the friction cone, often done iteratively.
• Stacking and Tightly-Constrained Systems: Can require many solver iterations to propagate forces through a stack, leading to jitter or slow convergence.
• Continuous Forces: Not inherently suited for simulating continuous effects like aerodynamics or soft deformation. For high-precision engineering simulation (e.g., vehicle dynamics, detailed robotic contact), LCP-based or Newton-based solvers with warm starting are often used, trading some speed for greater accuracy and robustness.

An alternative constraint enforcement technique where intersecting objects are pushed apart by applying spring-damper forces proportional to the penetration depth and velocity. Unlike impulse-based methods that apply instantaneous velocity changes, penalty methods model contact as a continuous, stiff force field.

• Key Difference: Penalty forces are applied over the simulation timestep, while impulses are instantaneous.
• Trade-off: Penalty methods are simpler to implement but can cause instability ("explosions") if spring constants are too high, and can allow visible penetration if they are too low.
• Use Case: Often used in finite element analysis and some real-time applications where exact non-penetration is less critical than stability.

A core mathematical formulation used to solve contact and friction constraints in many physics engines, including those using impulse-based dynamics. An LCP finds a solution vector z that satisfies specific conditions:

• z ≥ 0 (Impulses must be non-adhesive, i.e., only push objects apart).
• Az + b ≥ 0 (The relative velocity at contacts must be non-penetrating).
• zᵀ(Az + b) = 0 (The complementarity condition: an impulse can be positive only if the relative velocity is zero, meaning bodies are in resting contact).

A is the system matrix encoding masses and contact geometry, and b contains the relative velocities before impact. Solvers like Projected Gauss-Seidel (PGS) iteratively solve this LCP to compute the correct contact impulses.

The algorithmic core of a physics engine responsible for calculating the forces or impulses needed to satisfy all defined constraints within a numerical tolerance. In impulse-based dynamics, the constraint solver's primary job is to resolve non-penetration and friction constraints.

• Iterative Process: Modern solvers use iterative methods like Projected Gauss-Seidel (PGS) to handle multiple, interdependent contacts efficiently.
• Warm Starting: Uses the impulse solution from the previous timestep as an initial guess, dramatically improving convergence speed for stacked or persistent contacts.
• Constraint Types: Beyond contact, it also solves joint constraints (hinges, sliders), ragdoll limits, and motor targets.

A dimensionless scalar value between 0 (perfectly inelastic) and 1 (perfectly elastic) that defines the bounciness of a collision in impulse-based dynamics. It directly scales the magnitude of the normal impulse applied during collision resolution.

• Definition: COR (e) = (Separation Velocity) / (Approach Velocity). An e=0 collision results in objects sticking together (no rebound), while e=1 conserves kinetic energy in the normal direction (perfect bounce).
• Implementation: In the impulse calculation, the desired post-collision relative velocity in the normal direction is set to -e * v_rel_pre. The impulse is computed to achieve this velocity change.
• Real-world Variation: Often modeled as a combined value using the minimum or a specific formula (e.g., Poisson's hypothesis) of the two colliding materials.

The classical model of dry friction implemented in impulse-based solvers. Coulomb's law states that the magnitude of the tangential friction force |f_t| is at most the coefficient of friction (μ) times the normal force |f_n|.

• Static vs. Kinetic: If the relative tangential velocity is zero (sticking), |f_t| ≤ μ_s * |f_n|. If sliding, |f_t| = μ_k * |f_n| and opposes the sliding direction.
• Friction Cone: This law defines a friction cone—the set of allowable total contact forces. The resultant force must lie within a cone whose axis is the contact normal and whose angle is arctan(μ).
• Solver Approximation: Impulse-based solvers often approximate the cone as a pyramid (using 2-4 tangential directions) to fit the problem into a simpler LCP or iterative structure.

A critical stabilization technique used alongside impulse-based methods to combat constraint drift—the numerical accumulation of error that causes joints to loosen or bodies to slowly sink into each other over many timesteps.

• Mechanism: Instead of just enforcing a velocity-level constraint (e.g., relative velocity = 0), Baumgarte adds a corrective term that is proportional to the positional error. The constraint equation becomes: Jv + βC = 0, where C is the positional constraint error and β is a tuning parameter (e.g., 0.1 to 0.3).
• Effect: This acts like a virtual spring that gently pulls the system back to a valid state, preventing drift without causing excessive stiffness.
• Usage: Essential for maintaining stable joints and persistent resting contacts in long-running simulations.