Managing Consistent Game Physics: The Case For Fixed Time Steps

Avoiding Variable Time Steps for Consistent Game Physics

In video games, the physics engine calculates positions, velocities, collisions, and other physical interactions to simulate real-world behavior. However, most games do not run at a perfectly consistent frame rate due to complex scenes and hardware limitations. If the time delta between frames is variable, physics will be calculated inconsistently, leading to visual artifacts like tunneling, juddering motions, and clipping.

For example, at low frame rates, fast-moving objects can tunnel through walls as the physics engine fails to detect collisions. At high frame rates, tiny time steps cause low stiffness and damping, making objects and characters behave unnaturally floaty and jittery.

Using a fixed timestep for the physics update loop is the most common solution for this problem. With this approach, game logic and rendering may happen at the variable frame rate, but the physics engine updates at regular intervals like 0.01 seconds. This smooths out the calculation of positions over time, avoiding variable physics behavior.

How Fixed Timesteps Enable Consistent Physics

A fixed timestep works by accumulating time deltas between variable frames, then doing integral physics update steps. For example, if the fixed dt = 0.01 sec:

• Frame 1: delta t = 0.016 sec
• Frame 2: delta t = 0.008 sec
• Accumulated delta t = 0.024 sec
• Do 2 physics steps at dt=0.01 to “catch up” with accumulated time
• Frame 3: delta t = 0.012 sec
• Accumulated delta t = 0.012 sec
• Do 1 physics step at dt = 0.01

This “catches up” physics to match real elapsed time, drastically reducing variability in physics calculations versushaving them match the frame rate.

Fixed timesteps enforce physics updates at precisely incremented intervals irrespective of frame rate. The key advantage is that updates over time are granular and smooth instead of frame rate dependent. This prevents visual artifacts from low frame rates and physics instability from very high frame rates.

Furthermore, deterministic locked steps allow reproducible physics, greatly aiding debugging. Slow motion effects can also be achieved by modifying the fixed timestep. Overall, fixed timesteps are essential for consistent, stable physics.

Implementing a Fixed Timestep Loop

A game engine’s fixed timestep loop accumulates time deltas and triggers integral physics update steps every fixed interval. This decouples the core physics simulation from the frame rate for stability.

Basic structure of a fixed timestep loop:

1. Calculate delta time elapsed since last frame
2. Accumulate delta time to see if physics update threshold reached
3. If time elapsed >= fixed dt, do a physics sim step
4. Repeat physics steps until caught up with accumulated delta time
5. Interpolate between last two physics steps for rendering

Sample Fixed Timestep Game Loop Code

Here is C++ sample code demonstrating the structure of a game loop with fixed physics timesteps:

double accumulatedTime;
double fixedTimestep = 0.01; 

while (gameIsRunning)
{
  double newTime = getSystemTime(); 
  double frameTime = newTime - currentTime; 
  currentTime = newTime;
   
  accumulatedTime += frameTime;

  while(accumulatedTime >= fixedTimestep)
  {
     // Do physics simulation step at fixed dt   
     DoPhysicsStep(fixedTimestep);
 
     accumulatedTime -= fixedTimestep;
  } 

  // Interpolate between current and previous state
  LerpPhysicsResults();
  
  // Render scene with interpolated physics
  DrawScene();
}

This accumulator pattern ensures physics steps happen at regular intervals regardless of render frame rate or frame times. The key aspects are:

• Accumulating delta time over multiple frames
• Stepping simulation at fixed timesteps
• Interpolating state for smooth animation

With this structure, the physics engine operates independently of variable frame timing for consistent updates.

Optimizing Physics Updates Inside Fixed Timesteps

While fixed timesteps provide major stability benefits, optimizing what happens inside those physics update blocks can further enhance realism, performance and smoothness.

Strategies like physics sub-stepping divide fixed steps into smaller intervals for finer granularity on fast-moving objects. Interpolation between sub-steps reduces perceived jittering from the limits of fixed dt resolution.

Prioritizing updates by active, visible, or player-controlled objects skips unnecessary simulation for distant entities. Ragdolls, vehicles, and characters may also use variable iteration counts per fixed step for quality versus performance.

Some physics engines like Havok support multi-threading inner simulations. This parallelizes internal calculations to better utilize CPU cores for faster fixed timestep performance.

Reducing per-step iteration counts while upholding stability guarantees also minimizes computation. Simple tweaks like reusing the broad-phase collision detection cache between fixed steps is another easy optimization.

There are many low-level changes that can maximize accuracy and realism within the consistent context of a fixed timestep physics update loop.

Multi-threading Physics in Fixed Timesteps

By parallelizing physics calculations across CPU cores, multi-threading can dramatically speed up fixed timestep performance to allow shorter intervals or higher entity counts.

Both major CPU physics engines – PhysX and Havok – provide APIs for distributing simulations across threads. This includes options for thread-safe partitions, job workers, resource management, and memory sharing.

Key multi-threading techniques include:

• Task-based parallelism – distribute physics steps across threads
• Spatial partitioning – subdivide world into distinct regions
• Job workers – custom threads for simulation tasks
• Dedicated threads – isolate specific physics systems

Multi-threading works well for expensive simulations like cloth, destruction, and vehicles which can be isolated. However, pairing with a good thread scheduler is vital to balance work properly.

Often hybrid approaches mixing single-threaded, multi-threaded, and GPU accelerated solvers achieve peak performance. When tuned well, multi-core physics enables faster, shorter fixed timesteps to push realism and dynamism while maintaining essential consistency.

Alternatives to Fixed Timestep for Some Game Types

While fixed timesteps are the standard for smooth physics, some game genres are less sensitive to variable behavior or even require it by design.

For example, 2D pixel-art platformers often embrace variable physics tied to frame rate as part of their retro aesthetic. Likewise, turn-based and real-time strategy games without continuous physics can operate entirely event-driven.

However, the majority of modern 3D games use time-critical physics that benefits massively from fixed timestep management of updates over time.

Shooters, racers, RPGs, action-adventure games, and simulations rely on realistic physical reactions and collisions. The hyper-responsiveness of virtual worlds demands locked physics steps for robustness.

So while fixed timesteps are not universally mandated, they represent the most common and practical approach for smooth continuous simulations in real-time games.