Contact Force

The normal force is the component perpendicular to the contact surface, arising to prevent interpenetration of rigid bodies. It is calculated based on the penetration depth, material stiffness, and damping.

• Primary Role: Enforces the non-penetration constraint.
• Calculation: Often modeled via a spring-damper system in penalty methods or as an inequality constraint in LCP solvers.
• Direction: Always acts along the contact normal, pushing bodies apart.

The tangential friction force acts parallel to the contact surface, opposing relative sliding motion. It is governed by the Coulomb friction model.

• Static Friction: Prevents motion initiation. Force magnitude is ≤ μₛ * |Fₙ|, where μₛ is the static friction coefficient.
• Kinetic Friction: Opposes ongoing sliding. Force magnitude = μₖ * |Fₙ|, where μₖ is the kinetic (dynamic) coefficient.
• Friction Cone: The set of all allowable friction forces forms a cone around the contact normal; the resultant force must lie within it.

The contact point is the location (or manifold) where force is applied, and the contact normal is the unit vector defining the direction of the normal force.

• Computation: Determined by the narrow phase of collision detection (e.g., GJK/EPA for convex shapes).
• Significance: The contact normal defines the local coordinate frame for decomposing the total contact force. An inaccurate normal leads to unrealistic sliding or bouncing.
• Manifold: For extended contact, multiple points or a contact patch are used to approximate the interaction area.

Restitution models the elasticity of a collision, generating an impulsive force that causes bodies to bounce apart. It is characterized by the coefficient of restitution (COR).

• COR Definition: A scalar 0 ≤ e ≤ 1, where e=0 is perfectly inelastic (no bounce) and e=1 is perfectly elastic (maximum bounce).
• Formula: e = - (v_sep / v_app), the ratio of separation velocity to approach velocity post- and pre-impact.
• Implementation: Applied as an instantaneous velocity change (impulse) at the moment of collision, separate from continuous contact forces.

In high-fidelity simulators, contact is formulated as a Linear Complementarity Problem (LCP). This method enforces constraints exactly, unlike penalty methods.

• Core Principle: The solver finds non-penetrating forces where either the penetration is zero or the normal force is zero (complementarity condition).
• Friction Cone Approximation: The nonlinear friction cone is often approximated as a polyhedral pyramid for integration into the LCP.
• Advantage: Produces stable, non-penetrating results without requiring infinitely stiff springs, but is computationally more intensive.

The penalty method models contact forces as those from a stiff, damped spring at the penetration point.

• Spring Force: Proportional to penetration depth (Fₙ = -k * d).
• Damping Force: Proportional to penetration velocity, providing energy loss (F_damp = -c * v).
• Trade-offs: Simpler to implement but can cause unrealistic oscillations or require very small time steps for stability if stiffness (k) is high. Allows small, temporary penetrations.

The penalty method models contact as a stiff, damped spring. When two bodies penetrate, a restorative force is applied proportional to the penetration depth (the spring) and the rate of penetration (the damper).

• Mechanism: Force = -(stiffness * penetration_depth) - (damping * penetration_velocity)
• Advantage: Simple to implement and parallelize; computationally inexpensive.
• Disadvantage: Can cause unrealistic bouncing and requires very high stiffness for realism, leading to numerical instability unless sub-stepping is used.
• Use Case: Best for non-critical contacts or in real-time applications where absolute physical accuracy is secondary to stability and speed.

Impulse-based dynamics resolves collisions by applying instantaneous changes in velocity (impulses) rather than continuous forces. It directly computes an impulse that satisfies Newton's restitution law and friction at the moment of impact.

• Mechanism: Solves for an impulse J such that relative velocity post-collision = -COR * relative velocity pre-collision.
• Advantage: Naturally handles simultaneous collisions and stacking; good for games and interactive simulations.
• Disadvantage: Can be challenging to stabilize for persistent contact (like resting objects) and may jitter.
• Example: Used in early physics engines like ODE (Open Dynamics Engine) and many game physics SDKs for fast, plausible collisions.

The constraint-based method formulates contact as a set of hard constraints to be solved simultaneously. It prevents penetration (non-interpenetration constraint) and models friction (friction cone constraint), typically framed as a Linear Complementarity Problem (LCP).

• Mechanism: Solves for contact forces such that: J*v >= 0, f >= 0, f^T * (J*v) = 0. This ensures forces only act when bodies are separating (complementarity).
• Advantage: Highly accurate and stable for persistent contact and complex stacking scenarios.
• Disadvantage: Computationally expensive, requiring iterative solvers (e.g., Projected Gauss-Seidel).
• Use Case: The standard for high-fidelity robotics simulation in engines like Bullet, MuJoCo, and Drake.

Position-Based Dynamics is a geometric method that directly manipulates the positions of particles or vertices to satisfy constraints, including collision and non-penetration.

• Mechanism: After an initial unconstrained integration step, positions are iteratively projected onto the manifold of valid states defined by constraints (e.g., |p1 - p2| >= radius1 + radius2).
• Advantage: Unconditionally stable, highly controllable, and free from overshooting issues common in force-based methods.
• Disadvantage: Not strictly physically accurate in terms of energy conservation; more of a kinematic solver.
• Example: Extensively used in real-time cloth, soft body, and fluid simulation, and in some robotic simulators for its robustness.

Smooth contact models approximate the discontinuous nature of contact (which makes a binary on/off state) with a continuous, differentiable function. This is crucial for gradient-based optimization and reinforcement learning.

• Mechanism: Uses a smoothed force function like a sigmoid or spring that activates gradually as distance approaches zero, e.g., force = (k / (d + ε)) for small distances d.
• Advantage: Enables the use of efficient gradient-based optimizers and allows backpropagation through physics for training.
• Disadvantage: Introduces physical inaccuracy at the moment of "true" contact; forces act before geometries actually touch.
• Use Case: Found in differentiable physics engines like Nimble, Brax, and JAX-based simulators used for policy learning.

Many modern high-performance physics engines use hybrid methods that combine techniques to leverage their respective strengths, often using different solvers for different types of constraints.

• Common Pattern: Use a fast impulse-based or PBD solver for broad-phase collision and simple contacts, and a more accurate iterative LCP solver (like Sequential Impulses) for precise, stable resolution of persistent contact and friction.
• Warm Starting: A key hybrid technique where the solver initializes its solution for the current time step with the forces/impulses from the previous step, dramatically improving convergence.
• Example: Bullet Physics uses a Projected Gauss-Seidel (PGS) solver, which is an iterative method for solving the LCP, effectively blending constraint and impulse-based concepts for robust performance.

The computational process of identifying when two or more simulated objects intersect. It is a prerequisite for calculating contact forces.

• Broad Phase: Quickly filters non-colliding object pairs using spatial data structures like a Bounding Volume Hierarchy (BVH).
• Narrow Phase: Computes precise contact details (points, normals, penetration depth) for colliding pairs, often using algorithms like GJK/EPA for convex shapes.

The classical dry friction model used to calculate the tangential component of a contact force. It defines two regimes:

• Static Friction: The force that resists the initiation of sliding. Its maximum magnitude is μ_s * |F_n|, where μ_s is the static friction coefficient.
• Kinetic Friction: The constant force opposing motion once sliding begins, with magnitude μ_k * |F_n|, where μ_k is the kinetic (dynamic) friction coefficient.

The set of all allowable friction forces at a point is geometrically represented by a friction cone.

The algorithmic core of a physics engine that calculates the forces or impulses needed to satisfy constraints like contact non-penetration and friction. It typically solves a Linear Complementarity Problem (LCP) formulation each time step.

• Iterative Methods: Solve for contact forces across multiple solver iterations for stability.
• Warm Starting: Uses the solution from the previous time step as an initial guess to accelerate convergence.
• Baumgarte Stabilization: Adds corrective terms to reduce numerical constraint drift over time.

A simulation method that resolves collisions by applying instantaneous changes in velocity (impulses) rather than continuous forces. It directly computes the impulse J to apply at a contact point.

• Formula: J = -(1 + e) * (v_rel · n) / (1/m_a + 1/m_b + ...) where e is the coefficient of restitution, v_rel is relative velocity, and n is the contact normal.
• Application: Commonly used in real-time interactive applications and game physics for its simplicity and direct effect on velocity.

A mathematical framework used to model contact and friction constraints in rigid body solvers. It finds a solution vector x (forces/impulses) that satisfies three conditions:

1. Ax + b >= 0 (The system constraints)
2. x >= 0 (Forces are non-adhesive)
3. x^T (Ax + b) = 0 (Complementarity: force is only applied if there is a constraint violation)

This elegantly encodes the fact that a normal contact force is zero if bodies are separating, and positive only if they are in contact.

A dimensionless scalar (typically between 0 and 1) that characterizes the elasticity of a collision and determines the normal impulse during resolution.

• Definition: e = - (v_sep / v_app), where v_app is the relative approach velocity before impact and v_sep is the relative separation velocity after impact.
• Perfectly Elastic: e = 1 (kinetic energy is conserved).
• Perfectly Inelastic: e = 0 (objects stick together post-collision). It directly scales the magnitude of the normal contact impulse in collision response.