Introduction to Physics Engines

Physics Engines Overview What Is a Physics Engine? A physics engine is specialized software that simulates the laws of physics to make virtual objects behave realistically. When you push a ball in a video game and it rolls across the floor, accelerates down a hill, and bounces off walls, a physics engine is computing all of that motion behind the scenes. Physics engines appear in many applications: video games and virtual reality environments use them for character movement and object interactions; engineering and architectural software uses them for stress testing and simulations; and scientific tools use them to model everything from molecular dynamics to planetary motion. The core goal is always the same—produce motion that looks and feels natural to human observers while running fast enough for real-time applications. The Fundamental Equation At its heart, every physics engine solves Newton's second law: $$\mathbf{F} = m\mathbf{a}$$ where $\mathbf{F}$ is the total force acting on an object, $m$ is its mass, and $\mathbf{a}$ is its acceleration. Here's how this equation drives a physics engine: Accumulate forces: The engine identifies all forces acting on an object in the current time step—gravity pulling it downward, a spring pulling it back toward rest, friction opposing its motion, or even a player pushing it. Calculate acceleration: Once all forces are summed, the engine divides by mass to find acceleration: $\mathbf{a} = \mathbf{F}/m$. Update motion: The engine uses this acceleration to update the object's velocity and position, which we discuss in detail in the next section. This cycle repeats dozens or hundreds of times per second, creating smooth, realistic motion from simple mathematical principles. The Four Building Blocks A complete physics engine consists of four interconnected systems. Understanding how they work together is essential: 1. Forces and Dynamics — Calculating what forces exist and how they affect objects. Examples include constant forces like gravity, velocity-dependent forces like air resistance, and interaction-dependent forces like springs or collisions. 2. Numerical Integration — Converting acceleration into velocity and position changes across small discrete time steps. This is necessary because we can't solve the motion equations analytically in complex scenarios. 3. Collision Detection and Response — Identifying when objects touch and computing forces to prevent them from passing through each other while simulating bouncing and friction. 4. Constraints and Joints — Enforcing restrictions on how objects can move relative to each other, enabling structures like hinged doors, connected chains, or ragdoll characters. The rest of this guide explores each system in depth. Forces and Dynamics Types of Forces A physics engine must handle different categories of forces, each computed in different ways. Gravity is the simplest: a constant downward force applied equally to all objects. In most 3D environments, this is simply a force of $-9.8 \text{ m/s}^2$ (or -32 ft/s²) in the vertical direction. Spring forces are more complex—they depend on how much the spring is stretched or compressed. If a spring's rest length is $L0$ and its current length is $L$, the spring force is proportional to the difference: $$\mathbf{F}{\text{spring}} = -k(L - L0)\hat{\mathbf{n}}$$ where $k$ is the spring stiffness and $\hat{\mathbf{n}}$ is the direction along the spring. Stiffer springs (larger $k$) exert stronger restoring forces. User-applied forces represent intentional interactions—a player pushing a character forward, a rocket engine firing, or a wind effect. These are typically provided by game logic or user input rather than computed automatically. Contact forces (including friction and normal forces) arise when objects collide. These are computed by the collision response system and are critical for realistic interactions. Numerical Integration Methods Why Integration Matters In the real world, forces act continuously, and motion is smooth. In a physics engine running on a computer, time is divided into discrete time steps (often called the time step or delta time, typically 1/60th of a second or smaller). We know acceleration at each moment, but we need to compute how velocity and position change across that entire time step. Numerical integration is the mathematical technique for doing this—it approximates continuous motion using discrete steps. The challenge: more accurate methods are slower, while faster methods can become unstable. We must choose an integration method that balances accuracy, stability, and speed for our application. Euler Integration The simplest method is Euler integration. At each time step with duration $\Delta t$, it updates velocity and position assuming acceleration is constant: $$\mathbf{v}{\text{new}} = \mathbf{v}{\text{old}} + \mathbf{a} \cdot \Delta t$$ $$\mathbf{x}{\text{new}} = \mathbf{x}{\text{old}} + \mathbf{v}{\text{old}} \cdot \Delta t$$ Euler integration is intuitive: the change in velocity equals acceleration times time, and the change in position equals velocity times time. However, it has a drawback—it uses the old velocity to compute the new position. With large time steps, this can produce noticeable errors and instability. Semi-Implicit Euler Integration A small but important modification improves stability significantly. Semi-implicit Euler (also called symplectic Euler) updates velocity first, then uses the new velocity for position: $$\mathbf{v}{\text{new}} = \mathbf{v}{\text{old}} + \mathbf{a} \cdot \Delta t$$ $$\mathbf{x}{\text{new}} = \mathbf{x}{\text{old}} + \mathbf{v}{\text{new}} \cdot \Delta t$$ The difference seems minor, but it has a profound effect: energy is conserved better, and the method remains stable with larger time steps. For this reason, semi-implicit Euler is the most popular choice in real-time games. Verlet Integration Verlet integration takes a different approach entirely. Instead of explicitly tracking velocity, it computes new positions directly from current and previous positions: $$\mathbf{x}{\text{new}} = 2\mathbf{x}{\text{current}} - \mathbf{x}{\text{previous}} + \mathbf{a} \cdot \Delta t^2$$ This method implicitly represents velocity (as the difference between consecutive positions) and offers excellent stability. Verlet is particularly popular for cloth simulation and particle systems because it naturally handles constraints by simply moving particles to satisfy them. Collision Detection and Response The Two Phases of Collision Detection Checking whether every pair of objects collides is expensive. With hundreds of objects, there could be tens of thousands of pairs to test. Physics engines use a two-phase approach to be efficient. Broad-phase collision detection quickly eliminates pairs that cannot possibly be colliding. It uses simple, fast tests like checking whether the bounding boxes (axis-aligned rectangles) around two objects overlap. Only pairs that pass this test move to the next phase. Narrow-phase collision detection takes the remaining candidate pairs and performs precise tests using the actual object shapes. It determines whether the objects truly intersect and, if they do, computes important information about the contact. Contact Information When two objects collide, the narrow-phase detector computes two critical pieces of information: Contact normal: A unit vector $\hat{\mathbf{n}}$ pointing perpendicular to the collision surface, indicating the direction the objects should separate. Penetration depth: A scalar $d$ measuring how deeply one object overlaps the other—how far they would need to move along the normal to stop overlapping. For example, if a ball falls through the floor, the contact normal points upward, and the penetration depth is the distance the ball has sunk below the floor surface. Collision Response Using Impulses Once a collision is detected, the physics engine must prevent interpenetration (objects passing through each other). One effective approach uses impulses—instantaneous changes in velocity. When two objects collide, an impulse is computed and applied to each object along the contact normal. For a ball bouncing off a wall, the impulse reverses the ball's velocity component perpendicular to the wall. The magnitude of this impulse depends on the coefficient of restitution, a value between 0 and 1 that determines bounciness: A restitution of 0 means the object sticks (perfectly inelastic collision) A restitution of 1 means the object bounces with the same speed (perfectly elastic) Values in between produce realistic bouncing Friction is also handled during collision response. Friction impulses act along the contact surface (perpendicular to the normal), opposing the sliding motion between objects. Multiple Simultaneous Collisions In complex scenes, multiple collisions may occur in a single time step. A single collision response might affect other collisions, creating an interdependent system. Constraint solvers handle this by iteratively applying impulses until all collisions are resolved. One popular technique is sequential impulse, which goes through each contact repeatedly, applying impulses until the system stabilizes. Constraints and Joints What Are Constraints? A constraint is a restriction on how objects can move relative to each other. Rather than letting objects move freely, constraints enforce relationships like "these two points must always be the same distance apart" or "this object can only rotate around this axis." Constraints are the key to building articulated structures—characters with limbs, vehicles with wheels, machinery with moving parts. Common Types of Joints Different joint types enforce different constraints: Hinge joints allow rotation around a single axis while preventing translation. A door hinge is the real-world example: the door rotates around the hinge pin but doesn't move forward or backward. Slider joints allow translation along a single axis while preventing rotation. A window sliding in its frame is an example. Distance constraints (or rope constraints) restrict the maximum distance between two points. A rope connecting two objects will go taut but never stretch, limiting how far apart they can be. More complex joints combine these restrictions. A ball-and-socket joint, for instance, allows free rotation in all directions but maintains a fixed distance between the two connection points. Implementation in the Solver Constraints are implemented as mathematical equations that must be satisfied. During the simulation, the constraint solver checks whether each constraint is violated and applies forces (or impulses) to restore them. Because constraints can interact with each other and with collisions, the same iterative solvers used for collision response (like sequential impulse) are also used for constraints. Summary Physics engines combine four essential systems: Forces and dynamics — identifying and computing all forces acting on objects Numerical integration — converting those forces into motion across time steps Collision detection and response — preventing objects from overlapping and simulating bouncing and friction Constraints and joints — enforcing relationships between bodies to create complex structures Each system builds on the others. Integration requires knowing the forces. Collision response adds forces to the system. Constraints become additional forces to be integrated. This cycle, repeated dozens of times per second, creates the rich, interactive physics we experience in modern simulations and games.