Just a quick tip on how to convert usual damping code to something framerate-independent.

Most of us have probably, at some point, written code resembling this:

// Perform velocity damping velocity -= velocity * 0.01f;

… or probably the more correct:

// Per-second damping coefficient float const D = 10.0f; // Damp velocity according to timestep velocity -= velocity * D * delta_time;

Yet this is not fully framerate-independent; results are slightly different at 30fps and 60fps, and more importantly, spikes in the framerate cause lots of weird artifacts, causing developers to attempt to fix the situation by clamping `delta_time`, which is not ideal.

## The exponentiation method

Here is one way to fix it: assume that the code works correctly at 60 fps. This means that each frame, `velocity` is effectively multiplied by `1 - D / 60`.

After one second, *i.e.* 60 frames, `velocity` has been multiplied by `(1 - D / 60) ^ 60`.

After two seconds, it has been multiplied by `(1 - D / 60) ^ (60 * 2)`.

After `N` seconds, it has been multiplied by `(1 - D / 60) ^ (60 * N)`.

So, there, we have a formula that tells us what happens after `N` seconds, and it’s a continuous function. We can therefore choose `N` as we like, and especially `N = delta_time`:

// Per-second damping coefficient float const D = 10.0f; // Damp velocity (framerate-independent) velocity *= pow(1.f - D / 60.f, 60.f * delta_time);

Which can be conveniently rewritten as:

// Per-second damping coefficient float const D = 10.0f; // Exponentiation base for velocity damping float const D2 = pow(1.f - D / 60.f, 60.f); // Damp velocity (framerate-independent) velocity *= pow(D2, delta_time);