Rigid Body Dynamics

The Newton-Euler equations are the fundamental laws of motion for a rigid body. They combine Newton's second law for linear motion (F = ma) with its rotational analogue for angular motion (τ = Iα + ω × Iω).

• Linear Motion: The net force on a body determines the acceleration of its center of mass.
• Rotational Motion: The net torque determines the angular acceleration, which depends on the body's moment of inertia tensor and current angular velocity. These coupled differential equations are solved at each time step to update a body's position and orientation.

This two-stage process handles object interactions.

• Collision Detection: Algorithms like Separating Axis Theorem (SAT) or Gilbert–Johnson–Keerthi (GJK) determine if two bodies intersect. Bounding Volume Hierarchies (BVHs) accelerate these checks by culling distant object pairs.
• Collision Response: Once contact is found, physics engines calculate an impulse or contact force to resolve the penetration. This involves solving for forces that satisfy constraints (e.g., no interpenetration) and applying effects like friction and restitution (bounciness).

Constraints are mathematical rules that limit the relative motion between rigid bodies. Common types implemented as joint constraints include:

• Revolute (Hinge) Joint: Allows rotation around a single axis.
• Prismatic (Slider) Joint: Allows translation along a single axis.
• Spherical (Ball & Socket) Joint: Allows rotation in all three axes but no translation.
• Fixed Joint: Locks all relative motion. Engines solve these constraints using methods like Sequential Impulses or Projected Gauss-Seidel to calculate the forces needed to maintain the joint's limits.

Time integration is the numerical method that advances the simulation state forward in discrete time steps (Δt).

• Explicit Euler: Uses current velocity to update position (p' = p + vΔt). Simple but can be unstable with large steps or stiff constraints.
• Semi-Implicit Euler (Symplectic Euler): Uses updated velocity to update position. More stable and energy-conserving for simple systems; common in game physics.
• Implicit Euler: Solves for future state using future derivatives. Highly stable for stiff systems (e.g., cloth with strong springs) but computationally expensive. Choosing the right integrator is a trade-off between accuracy, stability, and performance.

These two properties define how a body responds to forces.

• Center of Mass (COM): The point where the body's mass is concentrated for linear motion. All external forces are applied at this point to compute linear acceleration.
• Moment of Inertia (MOI): A 3x3 tensor that quantifies how mass is distributed relative to the COM. It determines the rotational acceleration from an applied torque. The MOI depends on the body's shape and orientation; for a simple box, it is (1/12) * mass * (height² + width²).

Spatial vector algebra is a 6D mathematical framework that unifies the treatment of linear and angular motion, making rigid body dynamics algorithms more compact and efficient.

• A spatial velocity combines linear (v) and angular (ω) velocity into one 6D vector.
• A spatial force combines force (f) and torque (τ).
• The spatial inertia matrix combines mass and the moment of inertia tensor. This formalism simplifies the expression of the Newton-Euler equations, joint constraints, and recursive algorithms used in simulating articulated bodies like robot arms.

Creating physically accurate virtual worlds is essential for effective training. Rigid body dynamics enables:

• Haptic feedback: Computing reaction forces for flight yokes, surgical tools, or vehicle controls.
• Object interaction: Providing realistic weight, inertia, and collision behavior for virtual objects.
• Procedural animation: Generating context-specific physical responses (e.g., a tool dropping). These simulations are critical in fields like aviation (flight simulators), medicine (surgical training), and heavy machinery operation.

Collision detection is the algorithmic process of determining if and when two simulated objects intersect. Collision response calculates the forces or impulses to apply post-collision for realistic behavior.

Key techniques include:

• Bounding Volume Hierarchies (BVH) for efficient broad-phase culling
• Signed Distance Fields (SDFs) for precise narrow-phase geometry
• Impulse-based and penalty-based force models for response

This pair of processes is fundamental to preventing interpenetration and simulating bouncing, sliding, or resting contact.

Constraint solving is the computational process of finding a configuration for a system of bodies that satisfies defined kinematic limits or relationships. In rigid body dynamics, it enforces:

• Joint constraints (e.g., hinge, prismatic, ball-and-socket)
• Contact constraints (to prevent interpenetration)
• Motor constraints (to achieve target velocities/positions)

Solvers use methods like the Sequential Impulse technique or Linear Complementarity Problem (LCP) formulations to iteratively resolve these constraints within a time step.

Time integration is the numerical method used to advance the state of a dynamic system (positions, velocities, orientations) forward in discrete time steps (Δt).

Common schemes in simulation:

• Explicit Euler (Forward Euler): Simple but can be unstable for stiff systems.
• Implicit Euler (Backward Euler): More stable, solves for future state using future derivatives.
• Semi-implicit Euler (Symplectic Euler): Popular in game physics; updates velocity first, then position.
• Runge-Kutta methods (e.g., RK4): Higher accuracy for more demanding simulations.

The choice critically affects the numerical stability and energy conservation of the simulation.

These are fundamental physical properties calculated for a rigid body.

• Center of Mass: The point where the body's mass is considered concentrated for linear motion. Applied forces cause linear acceleration through this point.
• Moment of Inertia: A 3x3 tensor that quantifies a body's resistance to rotational acceleration. It depends on the mass distribution relative to the axis of rotation.

In simulation, these properties are precomputed from the object's geometry and density. The equations of motion (Newton-Euler equations) use them to compute linear and angular acceleration from applied forces and torques.

A deterministic simulation produces an identical sequence of states every time it is run from the same initial conditions. This is crucial for:

• Debugging and replicating bugs in robotics or game physics.
• Training reinforcement learning agents where reproducible episodes are needed.
• Scientific validation of models.

Determinism is challenged by floating-point non-associativity, parallel execution order, and variable timesteps. Engines like Unity Physics and Box2D offer deterministic modes by controlling these factors.