Limit Linear Velocity in Ammo.js

Controlling the speed of moving objects is crucial for maintaining stable and realistic physics simulations in games and interactive 3D applications. This article explains the two most effective methods to limit the maximum linear velocity of a rigid body in Ammo.js: applying a hard limit via manual velocity clamping in your simulation loop, and applying a soft limit using linear damping.

Method 1: The Hard Limit (Velocity Clamping)

The most precise way to enforce a strict speed limit on a rigid body is to manually check and clamp its velocity during each physics step. If the body’s speed exceeds your defined maximum, you scale its velocity vector back down to the maximum allowed limit.

Because Ammo.js is a WebAssembly/C++ wrapper, you must manage memory carefully when creating temporary vectors to avoid memory leaks.

Here is how to implement manual velocity clamping in your update loop:

function limitVelocity(rigidBody, maxSpeed) {
    // Retrieve the current linear velocity
    const velocity = rigidBody.getLinearVelocity();
    const speed = velocity.length();

    // Check if the speed exceeds the maximum limit
    if (speed > maxSpeed) {
        const scale = maxSpeed / speed;
        
        // Create a new vector for the clamped velocity
        const clampedVelocity = new Ammo.btVector3(
            velocity.x() * scale,
            velocity.y() * scale,
            velocity.z() * scale
        );

        // Apply the clamped velocity back to the rigid body
        rigidBody.setLinearVelocity(clampedVelocity);

        // Free the allocated memory to prevent memory leaks
        Ammo.destroy(clampedVelocity);
    }
}

For the best results, execute this function immediately after calling your physics world update (dynamicsWorld.stepSimulation(timeStep)) or inside a pre-tick/post-tick callback.

Method 2: The Soft Limit (Linear Damping)

If you prefer a natural deceleration that resists high speeds—similar to air resistance or drag—you can use linear damping. This method does not set a hard velocity ceiling, but it increasingly resists motion as the object accelerates, naturally capping the terminal velocity based on the forces applied.

You can set the damping values directly on the rigid body during initialization:

// setDamping(linearDamping, angularDamping)
// Values range from 0.0 (no drag) to 1.0 (complete drag)
rigidBody.setDamping(0.2, 0.0);

Using a non-zero linear damping value (e.g., 0.1 to 0.5) will prevent your rigid bodies from accelerating infinitely under constant forces, resulting in smoother and more predictable movement without manual vector manipulation.