Physics Engine Tutorial: Positional Correction for Collision Resolution

Continuous collision detection (CCD) prevents fast-moving objects from tunneling through walls by checking the entire path between previous and current positions. A capsule is constructed by connecting two points (previous and current bullet positions) with a radius equal to the bullet's collision radius. This creates a swept volume representing all space the bullet occupied during movement. The challenge is that while CCD prevents tunneling, it doesn't solve the problem of bullets grazing corners or passing through thin walls due to the capsule's rectangular middle section. This demonstrates the trade-offs between different collision detection approaches.

Tunneling occurs when fast-moving objects pass through other objects without detection because discrete position checks miss collisions. The solution involves the Minkowski sum: create an expanded rectangle by adding the moving rectangle's dimensions to the static rectangle, then perform a ray cast against this expanded shape. The slab test algorithm determines ray-AABB intersection by calculating entry and exit intervals along each axis. If the farthest entry exceeds the nearest exit across all axes, no intersection exists. This approach enables continuous collision detection regardless of object speed.

Tunneling occurs when fast-moving objects pass through other objects without triggering collisions because they move too far between physics updates. Solutions include: (1) Reducing the fixed time step (increasing physics update rate)—Unity defaults to 0.02 seconds (50 updates/second), but increasing to 120 updates/second can solve tunneling problems at the cost of CPU usage; (2) Enabling continuous collision detection, which checks for collisions along an object's entire path rather than just at discrete points. Note that Unity has a known bug where continuous collision detection cannot be disabled in 2D physics mode.

Discrete collision detection checks for collisions at frame boundaries, which can miss fast-moving objects passing through between frames (tunneling). Continuous collision detection solves this by parameterizing particle trajectories over time using linear interpolation and solving for exact collision times. This mathematical approach involves combining interpolation equations with collision constraints to find precise collision moments.

This segment addresses the tunneling problem, where fast-moving objects pass through thin barriers because the physics engine only checks for collisions at discrete update intervals. The instructor demonstrates this by making walls very thin, causing bullets to pass through. The solution is to enable continuous collision detection on the Rigidbody, which checks for collisions at multiple points along the object's path. The instructor explains that this is more computationally expensive but necessary for fast-moving objects or thin barriers.

The physics engine uses a broad phase approach to efficiently determine potential collisions before detailed computation. Unity's default sweep and prune approach can generate false positive collision pairs in generally flat worlds with many colliders. To reduce false positives, switch the broad phase type from sweep and prune to automatic box pruning. Automatic box pruning automatically determines world boundaries and grid cell count, providing better performance for scenes with numerous colliders while maintaining accurate collision detection.

Naive collision detection between N particles requires O(N²) operations per frame, becoming computationally prohibitive for large simulations. The three-phase framework (broad phase, narrow phase, resolution) addresses this. The sweep and prune algorithm dramatically reduces collision checks by sorting particles along axes and maintaining active intervals of potentially colliding particles, reducing checks from thousands to just a few candidates.

Separating collision detection into a broad phase (which identifies pairs of objects that are close enough to potentially collide using axis-aligned bounding boxes) and a narrow phase (which performs precise collision resolution on those candidate pairs) improves both code readability and performance; this separation reduces the complexity from O(n²) to a more efficient approach where the broad phase quickly filters out non-colliding pairs before the narrow phase processes only likely candidates, resulting in approximately 1.34x performance improvement when handling 100 physics bodies.

The broad phase is the first stage of collision detection that identifies potential collisions efficiently. It uses bounding volume hierarchies (BVHs) with simple shapes like AABBs, OBBs, spheres, and capsules. Acceleration structures such as BBHs, quadtrees, and octrees enable fast collision queries with logarithmic complexity. The system maintains separate BVH sets for dynamic objects, static objects, and terrain. Two distinct tests are required: internal collision tests against inner volumes of dynamic trees, and external collision tests against roots of dynamic trees against static and terrain trees. This hierarchical approach dramatically reduces the number of pairwise collision checks needed.

When checking many potential collision candidates, first perform a broad phase pass to quickly eliminate obviously non-colliding pairs before detailed narrow-phase checks. This optimization is essential when dealing with large numbers of objects (like thousands of tiles), as checking every possible pair would be computationally prohibitive. The broad phase uses spatial partitioning or bounding volume hierarchies to identify only likely collision candidates.

The Sequential Impulse Method (SIM) handles resting contacts (objects in permanent contact) by iteratively applying impulses to maintain constraints. Unlike collision resolution which applies impulses once, SIM repeatedly applies impulses over multiple iterations to achieve stable equilibrium. This is essential for stacking objects, as simple impulse application would cause objects to jitter or penetrate each other. SIM is widely used in game physics engines for stable object stacking.

Most game physics engines use the projected Gauss-Seidel or sequential impulse method for constraint solving. This method sequentially satisfies each constraint by computing an impulse and applying it to the involved bodies. The order matters significantly because solving one constraint affects the solution of subsequent constraints. After solving all constraints once, the process repeats iteratively (typically 4-8 times) to improve convergence toward the correct solution. Each iteration requires re-solving all constraints because earlier solutions become disturbed by later ones.

The presenter demonstrates creating a sequential impulse solver for Bullet physics. They show how to create a SequentialImpulseSolver object, which is responsible for resolving collisions and constraints. The presenter explains that the solver iterates through constraints to find a stable solution, and that different solver algorithms can be used depending on the simulation requirements.

GJK and EPA can only generate one contact at a time, but stable physics simulations can be achieved by accumulating contacts over multiple frames. When a collision is detected, one contact is generated, which pushes objects apart. This causes other corners to intersect the surface, generating additional contacts in subsequent frames. This iterative process continues until enough contacts exist for stable object placement.

Advanced constraint techniques include stacking constraints for complex object manipulation, such as characters picking up and passing objects between hands. Constraints can be transitioned between targets by setting different constraints to 100% while others remain at 0%. Releasing constraints involves setting them back to 0%, returning objects to their parent relationships. These techniques enable efficient animation workflows for character interactions and object manipulation.

Constrained hinges provide a predetermined static axis of rotation for joint movement, allowing the limb segment to rotate around the hinge axis rather than the anatomical joint axis. To address the multiplanar nature of joint rotation axes, distraction creates sufficient gap between articulating surfaces—approximately 7-12 millimeters for ankle joints—to prevent compression during correction. Distraction must be applied proximally to maintain the axis of rotation in place. This approach enables protective joint motion by preserving articulated surfaces while correcting contractures.

Hinge Joint connects objects at anchor points, allowing rotation around a fixed axis with angle limits and motor properties. Spring Joint creates elastic connections with minimum distance settings and stiffness ratios. Distance Joint maintains fixed distances without elastic behavior. All joints require collision detection between connected objects to prevent overlap. These joints enable creating mechanisms like trapdoors, springs, and fixed-distance connections.

To replicate joint behavior without using actual joint elements, create constraint equations between reference and mobile remote points. Apply coefficients of +1 and -1 to tie together corresponding displacements (X, Y, Z) and rotations (RX, RY, RZ). For revolute joint behavior, suppress the constraint equation for one rotational degree of freedom (typically Y-axis), allowing rotation about that axis while constraining all other movements.

The DistanceJoint constraint in the Processing physics library maintains a fixed distance between two objects, enabling the creation of pendulums and other constrained motion systems; the joint automatically preserves the distance between objects at the moment of creation, and this distance can be dynamically modified using the setLength() method.

Achieving stable distance joint behavior requires projecting velocity onto the connection vector rather than directly setting positions. The process involves calculating target velocity, projecting it onto the connection to maintain distance constraints, and setting the rigidbody's velocity to this projected value. Adding spring and damper systems improves stability: spring increases velocity based on distance discrepancy to create tension, while damper decreases velocity over time to prevent oscillation. Formulas are: velocity += gravity × spring and velocity /= (1 + damper × Time.fixedDeltaTime). These parameters allow fine-tuning of response speed and settling behavior, creating controlled, predictable distance constraints suitable for complex simulations like ropes and cloth.