@aura3d/engine 1.5.2 → 2.0.1

package/dist/physics/PhysicsWorld.js

@@ -1,19 +1,16 @@
-import { Body as CannonBody, Box as CannonBox, Cylinder as CannonCylinder, Plane as CannonPlane, Quaternion as CannonQuaternion, Sphere as CannonSphere, Vec3 as CannonVec3, World as CannonWorld } from "cannon-es";
+import { createRapierPhysicsSync } from "../physics-rapier/index.js";
 import { Collider } from "./Collider.js";
 import { CollisionEventQueue } from "./CollisionEvents.js";
 import { Constraint } from "./Constraint.js";
-import { buildNativeNarrowPhaseContact } from "./NarrowPhase.js";
 import { raycastCollider, sphereCastCollider } from "./Raycast.js";
 import { RigidBody } from "./RigidBody.js";
-import { cloneVec3, dotVec3, lengthVec3, normalizeVec3, scaleVec3, subVec3 } from "./Shape.js";
+import { cloneVec3, dotVec3, lengthVec3, normalizeVec3, scaleVec3, subVec3, validateFiniteVec3 } from "./Shape.js";
 import { timeOfImpact } from "./TimeOfImpact.js";
 export class PhysicsWorld {
     gravity;
     fixedDelta;
     solverIterations;
     enableSleeping;
-    sleepVelocityThreshold;
-    sleepDelay;
     continuousCollision;
     bodiesById = new Map();
     collidersById = new Map();
@@ -22,8 +19,10 @@ export class PhysicsWorld {
     eventQueue = new CollisionEventQueue();
     requestedBackend;
     backendSelection;
-    cannonWorld;
-    cannonBodiesByAuraId = new Map();
+    rapierWorld;
+    rapierBodiesByAuraId = new Map();
+    rapierCollidersByAuraId = new Map();
+    rapierJointsByConstraint = new Map();
     nextBodyId = 1;
     nextColliderId = 1;
     lastEvents = [];
@@ -35,10 +34,9 @@ export class PhysicsWorld {
         this.requestedBackend = descriptor.backend ?? "auto";
         this.gravity = cloneVec3(descriptor.gravity ?? [0, -9.81, 0]);
         this.fixedDelta = descriptor.fixedDelta ?? 1 / 60;
-        this.solverIterations = descriptor.solverIterations ?? 1;
+        // Keep the established public default while configuring Rapier's native solver.
+        this.solverIterations = descriptor.solverIterations ?? 10;
         this.enableSleeping = descriptor.enableSleeping ?? true;
-        this.sleepVelocityThreshold = descriptor.sleepVelocityThreshold ?? 0.02;
-        this.sleepDelay = descriptor.sleepDelay ?? 0.5;
         this.continuousCollision = normalizeContinuousCollisionDescriptor(descriptor.continuousCollision);
         if (!Number.isFinite(this.fixedDelta) || this.fixedDelta <= 0) {
             throw new Error("fixedDelta must be a finite positive number.");
@@ -46,39 +44,51 @@ export class PhysicsWorld {
         if (!Number.isInteger(this.solverIterations) || this.solverIterations <= 0) {
             throw new Error("solverIterations must be a positive integer.");
         }
-        if (!Number.isFinite(this.sleepVelocityThreshold) || this.sleepVelocityThreshold < 0) {
+        if (descriptor.sleepVelocityThreshold !== undefined && (!Number.isFinite(descriptor.sleepVelocityThreshold) || descriptor.sleepVelocityThreshold < 0)) {
             throw new Error("sleepVelocityThreshold must be finite and non-negative.");
         }
-        if (!Number.isFinite(this.sleepDelay) || this.sleepDelay < 0) {
+        if (descriptor.sleepDelay !== undefined && (!Number.isFinite(descriptor.sleepDelay) || descriptor.sleepDelay < 0)) {
             throw new Error("sleepDelay must be finite and non-negative.");
         }
+        if (this.requestedBackend !== "auto" && this.requestedBackend !== "rapier") {
+            // Reached from JavaScript callers and from code compiled against 1.5.x, where
+            // `"aura-js"` was a selectable backend. Failing loudly is the point: the previous
+            // behaviour of that string was "quietly run a different solver".
+            throw new Error(`Unknown physics backend '${String(this.requestedBackend)}'. Aura3D 2.0 has one ` +
+                "production solver, 'rapier'; the legacy 'aura-js' and 'cannon-es' backends were removed " +
+                "(see docs/architecture/physics-backend-decision.md). Omit `backend` or pass " +
+                "'rapier'.");
+        }
         this.backendSelection = {
             requested: this.requestedBackend,
-            active: this.requestedBackend === "aura-js" ? "aura-js" : "cannon-es",
+            active: "rapier",
             deterministic: true,
-            jsFallbackAvailable: true,
             continuousCollision: this.continuousCollisionSelection(true)
         };
-        if (this.backendSelection.active === "cannon-es") {
-            this.cannonWorld = new CannonWorld({
-                gravity: toCannonVec3(this.gravity),
-                allowSleep: this.enableSleeping
-            });
-            this.cannonWorld.solver.iterations = this.solverIterations;
-            this.cannonWorld.defaultContactMaterial.friction = 0.5;
-            this.cannonWorld.defaultContactMaterial.restitution = 0;
-        }
+        this.rapierWorld = createRapierPhysicsSync({ gravity: this.gravity });
+        this.rapierWorld.unsafeRapierWorld().integrationParameters.numSolverIterations = this.solverIterations;
     }
     createRigidBody(descriptor = {}) {
         const body = new RigidBody(this.nextBodyId, descriptor);
         this.nextBodyId += 1;
         this.bodiesById.set(body.id, body);
         this.bodyColliders.set(body.id, new Set());
-        const cannonBody = this.createCannonBody(body);
-        if (cannonBody) {
-            this.cannonBodiesByAuraId.set(body.id, cannonBody);
-            this.cannonWorld?.addBody(cannonBody);
-        }
+        const rapierBody = this.rapierWorld.createRigidBody({
+            type: body.type === "static" ? "fixed" : body.type === "kinematic" ? "kinematic-position" : "dynamic",
+            position: body.position,
+            rotation: body.rotation,
+            linearVelocity: body.velocity,
+            angularVelocity: body.angularVelocity,
+            linearDamping: body.linearDamping,
+            angularDamping: body.angularDamping,
+            ccd: body.type === "dynamic",
+            canSleep: this.enableSleeping,
+            ...(body.type === "dynamic" ? { mass: body.mass } : {}),
+            ...(body.declaredInertia ? { principalAngularInertia: body.declaredInertia } : {})
+        });
+        if (body.sleeping)
+            rapierBody.sleep();
+        this.rapierBodiesByAuraId.set(body.id, rapierBody);
         return body;
     }
     createCollider(body, descriptor) {
@@ -90,7 +100,18 @@ export class PhysicsWorld {
         this.nextColliderId += 1;
         this.collidersById.set(collider.id, collider);
         this.bodyColliders.get(bodyId)?.add(collider.id);
-        this.addCannonCollider(collider);
+        const rapierBody = this.rapierBodiesByAuraId.get(bodyId);
+        if (!rapierBody)
+            throw new Error(`Missing Rapier body for Aura body ${bodyId}.`);
+        const rapierCollider = this.rapierWorld.createCollider(rapierBody, {
+            shape: collider.shape,
+            density: 0,
+            friction: collider.material.friction,
+            restitution: collider.material.restitution,
+            sensor: collider.sensor,
+            collisionGroups: encodeRapierCollisionGroups(collider.filter.layer, collider.filter.mask)
+        });
+        this.rapierCollidersByAuraId.set(collider.id, rapierCollider);
         return collider;
     }
     createConstraint(descriptor) {
@@ -99,8 +120,23 @@ export class PhysicsWorld {
         }
         const constraint = new Constraint(descriptor);
         this.constraintsList.push(constraint);
+        this.rapierJointsByConstraint.set(constraint, this.createRapierJoint(constraint));
         return constraint;
     }
+    /**
+     * Change world gravity after construction.
+     *
+     * Needed for anything that flips or scales gravity at runtime — a low-gravity level, a
+     * zero-g section, a game that inverts it as a mechanic. Without a setter the only way to
+     * change it was to rebuild the world and lose every body.
+     */
+    setGravity(gravity) {
+        validateFiniteVec3(gravity, "world gravity");
+        this.gravity[0] = gravity[0];
+        this.gravity[1] = gravity[1];
+        this.gravity[2] = gravity[2];
+        this.rapierWorld.setGravity(this.gravity);
+    }
     getBody(id) {
         return this.bodiesById.get(id);
     }
@@ -129,14 +165,18 @@ export class PhysicsWorld {
         }
         this.bodyColliders.delete(id);
         this.bodiesById.delete(id);
-        const cannonBody = this.cannonBodiesByAuraId.get(id);
-        if (cannonBody) {
-            this.cannonWorld?.removeBody(cannonBody);
-            this.cannonBodiesByAuraId.delete(id);
+        const rapierBody = this.rapierBodiesByAuraId.get(id);
+        if (rapierBody) {
+            this.rapierWorld.removeBody(rapierBody);
+            this.rapierBodiesByAuraId.delete(id);
         }
         for (let index = this.constraintsList.length - 1; index >= 0; index -= 1) {
             const constraint = this.constraintsList[index];
             if (constraint.bodyA.id === id || constraint.bodyB.id === id) {
+                const joint = this.rapierJointsByConstraint.get(constraint);
+                if (joint)
+                    joint.remove();
+                this.rapierJointsByConstraint.delete(constraint);
                 this.constraintsList.splice(index, 1);
             }
         }
@@ -148,6 +188,10 @@ export class PhysicsWorld {
         }
         this.bodyColliders.get(collider.bodyId)?.delete(id);
         this.collidersById.delete(id);
+        const rapierCollider = this.rapierCollidersByAuraId.get(id);
+        if (rapierCollider)
+            rapierCollider.remove();
+        this.rapierCollidersByAuraId.delete(id);
         const removalEvents = this.eventQueue.removeCollider(id);
         if (removalEvents.length > 0) {
             this.lastEvents = [...this.lastEvents, ...removalEvents].sort((a, b) => a.pairKey.localeCompare(b.pairKey) || a.type.localeCompare(b.type));
@@ -157,51 +201,7 @@ export class PhysicsWorld {
         if (!Number.isFinite(dt) || dt <= 0) {
             throw new Error("PhysicsWorld.step dt must be finite and positive.");
         }
-        if (this.cannonWorld) {
-            return this.stepCannon(dt);
-        }
-        const continuousStep = this.planContinuousCollisionStep(dt);
-        this.lastContinuousCollisionStep = continuousStep;
-        this.assertContinuousCollisionPlan(continuousStep);
-        const subDelta = dt / continuousStep.subSteps;
-        const outerStepTransforms = new Map(this.bodies().map((body) => [
-            body.id,
-            {
-                position: cloneVec3(body.position),
-                rotation: [...body.rotation]
-            }
-        ]));
-        let contacts = [];
-        for (let subStep = 0; subStep < continuousStep.subSteps; subStep += 1) {
-            for (const body of this.bodyValues()) {
-                body.integrate(subDelta, this.gravity, false);
-            }
-            for (const constraint of this.constraintsList) {
-                constraint.solve();
-            }
-            const contactImpulses = new Map();
-            for (let i = 0; i < this.solverIterations; i += 1) {
-                contacts = this.detectContacts();
-                for (const contact of contacts) {
-                    this.resolveContact(contact, contactImpulses);
-                }
-                for (const constraint of this.constraintsList) {
-                    constraint.solve();
-                }
-            }
-        }
-        for (const body of this.bodyValues()) {
-            body.clearForces();
-            const outerTransform = outerStepTransforms.get(body.id);
-            if (outerTransform) {
-                body.previousPosition = outerTransform.position;
-                body.previousRotation = outerTransform.rotation;
-            }
-        }
-        this.lastEvents = this.eventQueue.update(contacts);
-        this.updateSleeping(dt, contacts);
-        this.steps += 1;
-        return this.lastEvents;
+        return this.stepProduction(dt);
     }
     drainEvents() {
         const events = this.lastEvents;
@@ -220,6 +220,9 @@ export class PhysicsWorld {
             if (!body) {
                 continue;
             }
+            if (options.ignoreColliders?.includes(collider.id) || options.ignoreBodies?.includes(collider.bodyId)) {
+                continue;
+            }
             const hit = raycastCollider(origin, normalized, collider, body, options);
             if (hit) {
                 hits.push(hit);
@@ -239,6 +242,9 @@ export class PhysicsWorld {
             if (!body) {
                 continue;
             }
+            if (options.ignoreColliders?.includes(collider.id) || options.ignoreBodies?.includes(collider.bodyId)) {
+                continue;
+            }
             const hit = sphereCastCollider(origin, radius, normalized, collider, body, options);
             if (hit) {
                 hits.push(hit);
@@ -276,15 +282,61 @@ export class PhysicsWorld {
             }
         };
     }
+    /** Release the selected native solver and every world-owned handle. Idempotent. */
+    dispose() {
+        this.rapierWorld.dispose();
+        this.rapierJointsByConstraint.clear();
+        this.rapierCollidersByAuraId.clear();
+        this.rapierBodiesByAuraId.clear();
+        this.constraintsList.length = 0;
+        this.collidersById.clear();
+        this.bodiesById.clear();
+        this.bodyColliders.clear();
+        this.lastEvents = [];
+    }
     detectContacts() {
         const potentialPairs = this.collectPotentialPairs();
         this.lastBroadphasePairs = potentialPairs.length;
         const contacts = [];
         for (const [a, bodyA, b, bodyB] of potentialPairs) {
-            const contact = buildContact(a, bodyA, b, bodyB);
-            if (contact) {
-                contacts.push(contact);
+            const colliderA = this.rapierCollidersByAuraId.get(a.id)?.unsafeRapierCollider();
+            const colliderB = this.rapierCollidersByAuraId.get(b.id)?.unsafeRapierCollider();
+            if (!colliderA || !colliderB)
+                continue;
+            if (a.sensor || b.sensor) {
+                if (!this.rapierWorld.unsafeRapierWorld().intersectionPair(colliderA, colliderB))
+                    continue;
+                const separation = subVec3(bodyB.position, bodyA.position);
+                const normal = lengthVec3(separation) > 1e-9 ? normalizeVec3(separation) : [0, 1, 0];
+                contacts.push({ colliderA: a.id, colliderB: b.id, bodyA: bodyA.id, bodyB: bodyB.id, normal, penetration: 0, sensor: true });
+                continue;
             }
+            let best;
+            this.rapierWorld.unsafeRapierWorld().contactPair(colliderA, colliderB, (manifold, flipped) => {
+                const normalValue = manifold.normal();
+                const direction = flipped ? -1 : 1;
+                const normal = [normalValue.x * direction, normalValue.y * direction, normalValue.z * direction];
+                const count = Math.max(manifold.numSolverContacts(), manifold.numContacts());
+                for (let index = 0; index < count; index += 1) {
+                    const distance = index < manifold.numSolverContacts() ? manifold.solverContactDist(index) : manifold.contactDist(index);
+                    const penetration = Math.max(0, -distance);
+                    const pointValue = index < manifold.numSolverContacts() ? manifold.solverContactPoint(index) : undefined;
+                    const candidate = {
+                        colliderA: a.id,
+                        colliderB: b.id,
+                        bodyA: bodyA.id,
+                        bodyB: bodyB.id,
+                        normal,
+                        penetration,
+                        ...(pointValue ? { point: [pointValue.x, pointValue.y, pointValue.z] } : {}),
+                        sensor: false
+                    };
+                    if (!best || candidate.penetration > best.penetration)
+                        best = candidate;
+                }
+            });
+            if (best)
+                contacts.push(best);
         }
         contacts.sort((a, b) => a.colliderA - b.colliderA || a.colliderB - b.colliderB);
         return contacts;
@@ -345,203 +397,88 @@ export class PhysicsWorld {
         this.lastBroadphaseProfile = profile;
         return pairs;
     }
-    resolveContact(contact, contactImpulses) {
-        if (contact.sensor) {
-            return;
-        }
-        const bodyA = this.bodiesById.get(contact.bodyA);
-        const bodyB = this.bodiesById.get(contact.bodyB);
-        if (!bodyA || !bodyB) {
-            return;
-        }
-        const invMassSum = bodyA.inverseMass + bodyB.inverseMass;
-        if (invMassSum <= 0) {
-            return;
-        }
-        const correction = scaleVec3(contact.normal, contact.penetration / invMassSum);
-        if (bodyA.inverseMass > 0) {
-            bodyA.position = [bodyA.position[0] - correction[0] * bodyA.inverseMass, bodyA.position[1] - correction[1] * bodyA.inverseMass, bodyA.position[2] - correction[2] * bodyA.inverseMass];
-        }
-        if (bodyB.inverseMass > 0) {
-            bodyB.position = [bodyB.position[0] + correction[0] * bodyB.inverseMass, bodyB.position[1] + correction[1] * bodyB.inverseMass, bodyB.position[2] + correction[2] * bodyB.inverseMass];
-        }
-        const relativeVelocity = relativeContactVelocity(bodyA, bodyB, contact.point);
-        const velocityAlongNormal = dotVec3(relativeVelocity, contact.normal);
-        const materialA = this.effectiveMaterial(bodyA, contact.colliderA);
-        const materialB = this.effectiveMaterial(bodyB, contact.colliderB);
-        const restitution = Math.max(materialA.restitution, materialB.restitution);
-        const pairKey = `${contact.colliderA}:${contact.colliderB}`;
-        const impulseState = contactImpulses.get(pairKey) ?? { normal: 0, tangent: [0, 0, 0] };
-        let normalImpulseMagnitude = 0;
-        if (velocityAlongNormal <= 0) {
-            const normalDenominator = contactImpulseDenominator(bodyA, bodyB, contact.normal, contact.point);
-            normalImpulseMagnitude = normalDenominator > 0 ? -(1 + restitution) * velocityAlongNormal / normalDenominator : 0;
-            impulseState.normal += normalImpulseMagnitude;
-            this.applyImpulsePair(bodyA, bodyB, scaleVec3(contact.normal, normalImpulseMagnitude), contact.point);
-        }
-        const updatedRelativeVelocity = relativeContactVelocity(bodyA, bodyB, contact.point);
-        const updatedNormalVelocity = dotVec3(updatedRelativeVelocity, contact.normal);
-        const tangentVelocity = subVec3(updatedRelativeVelocity, scaleVec3(contact.normal, updatedNormalVelocity));
-        const tangentSpeed = Math.hypot(tangentVelocity[0], tangentVelocity[1], tangentVelocity[2]);
-        if (tangentSpeed > 1e-9) {
-            const friction = Math.sqrt(Math.max(0, materialA.friction) * Math.max(0, materialB.friction));
-            const tangent = scaleVec3(tangentVelocity, 1 / tangentSpeed);
-            const tangentDenominator = contactImpulseDenominator(bodyA, bodyB, tangent, contact.point);
-            const targetImpulse = tangentDenominator > 0 ? scaleVec3(tangentVelocity, -1 / tangentDenominator) : [0, 0, 0];
-            const proposedTangent = [
-                impulseState.tangent[0] + targetImpulse[0],
-                impulseState.tangent[1] + targetImpulse[1],
-                impulseState.tangent[2] + targetImpulse[2]
-            ];
-            const proposedMagnitude = lengthVec3(proposedTangent);
-            const maxFriction = friction * impulseState.normal;
-            const accumulatedTangent = proposedMagnitude > maxFriction && proposedMagnitude > 0
-                ? scaleVec3(proposedTangent, maxFriction / proposedMagnitude)
-                : proposedTangent;
-            const frictionImpulse = subVec3(accumulatedTangent, impulseState.tangent);
-            impulseState.tangent = accumulatedTangent;
-            if (lengthVec3(frictionImpulse) > 0) {
-                this.applyImpulsePair(bodyA, bodyB, frictionImpulse, contact.point);
-            }
-        }
-        contactImpulses.set(pairKey, impulseState);
-    }
-    effectiveMaterial(body, colliderId) {
-        const collider = this.collidersById.get(colliderId);
-        return {
-            restitution: Math.max(body.restitution, collider?.material.restitution ?? 0),
-            friction: Math.max(body.friction, collider?.material.friction ?? 0)
-        };
-    }
-    applyImpulsePair(bodyA, bodyB, impulse, point) {
-        if (bodyA.inverseMass > 0) {
-            if (point)
-                bodyA.applyContactImpulseAtPoint(scaleVec3(impulse, -1), point);
-            else
-                bodyA.velocity = [bodyA.velocity[0] - impulse[0] * bodyA.inverseMass, bodyA.velocity[1] - impulse[1] * bodyA.inverseMass, bodyA.velocity[2] - impulse[2] * bodyA.inverseMass];
-            if (bodyA.sleeping && bodyA.speedSquared() > this.sleepVelocityThreshold * this.sleepVelocityThreshold) {
-                bodyA.wake();
+    createRapierJoint(constraint) {
+        const bodyA = this.rapierBodiesByAuraId.get(constraint.bodyA.id);
+        const bodyB = this.rapierBodiesByAuraId.get(constraint.bodyB.id);
+        if (!bodyA || !bodyB)
+            throw new Error("Cannot create a Rapier joint for missing bodies.");
+        return this.rapierWorld.createJoint({
+            type: constraint.type,
+            localAnchorA: constraint.type === "fixed"
+                && constraint.localAnchorA.every((value) => value === 0)
+                && constraint.localAnchorB.every((value) => value === 0)
+                ? constraint.restOffset
+                : constraint.localAnchorA,
+            localAnchorB: constraint.localAnchorB,
+            axis: constraint.axis,
+            restLength: constraint.restLength,
+            stiffness: constraint.stiffness,
+            damping: constraint.damping,
+            motorSpeed: constraint.motorSpeed(),
+            maxMotorTorque: Number.isFinite(constraint.maxMotorTorque) ? constraint.maxMotorTorque : Number.MAX_VALUE,
+            ...(constraint.limits ? { limits: constraint.limits } : {})
+        }, bodyA, bodyB);
+    }
+    synchronizeRapierJoints() {
+        for (const constraint of this.constraintsList) {
+            const existing = this.rapierJointsByConstraint.get(constraint);
+            if (!constraint.isEnabled()) {
+                if (existing)
+                    existing.remove();
+                this.rapierJointsByConstraint.delete(constraint);
+                continue;
             }
-        }
-        if (bodyB.inverseMass > 0) {
-            if (point)
-                bodyB.applyContactImpulseAtPoint(impulse, point);
-            else
-                bodyB.velocity = [bodyB.velocity[0] + impulse[0] * bodyB.inverseMass, bodyB.velocity[1] + impulse[1] * bodyB.inverseMass, bodyB.velocity[2] + impulse[2] * bodyB.inverseMass];
-            if (bodyB.sleeping && bodyB.speedSquared() > this.sleepVelocityThreshold * this.sleepVelocityThreshold) {
-                bodyB.wake();
+            const joint = existing ?? this.createRapierJoint(constraint);
+            this.rapierJointsByConstraint.set(constraint, joint);
+            if (constraint.type === "motorised-hinge") {
+                joint.configureMotor(constraint.motorSpeed(), Number.isFinite(constraint.maxMotorTorque) ? constraint.maxMotorTorque : Number.MAX_VALUE);
             }
         }
     }
-    updateSleeping(dt, contacts) {
-        if (!this.enableSleeping) {
-            return;
-        }
-        const contactBodyIds = new Set();
-        for (const contact of contacts) {
-            if (!contact.sensor) {
-                contactBodyIds.add(contact.bodyA);
-                contactBodyIds.add(contact.bodyB);
-            }
-        }
-        const gravityMagnitudeSquared = dotVec3(this.gravity, this.gravity);
-        const thresholdSquared = this.sleepVelocityThreshold * this.sleepVelocityThreshold;
+    stepProduction(dt) {
+        this.rapierWorld.setGravity(this.gravity);
+        const stepForces = new Map();
         for (const body of this.bodyValues()) {
-            if (body.type !== "dynamic") {
+            const rapierBody = this.rapierBodiesByAuraId.get(body.id);
+            if (!rapierBody)
                 continue;
+            const force = body.pendingForce();
+            const torque = body.pendingTorque();
+            if (force[0] !== 0 || force[1] !== 0 || force[2] !== 0 || torque[0] !== 0 || torque[1] !== 0 || torque[2] !== 0) {
+                stepForces.set(body.id, { force, torque });
+                body.clearForces();
             }
-            if (body.speedSquared() > thresholdSquared) {
-                body.resetSleepTimer();
-                continue;
-            }
-            const supportedOrUnaccelerated = contactBodyIds.has(body.id) || gravityMagnitudeSquared <= thresholdSquared;
-            if (!supportedOrUnaccelerated) {
-                body.resetSleepTimer();
-                continue;
-            }
-            if (body.accumulateSleepTime(dt) >= this.sleepDelay) {
-                body.sleep();
-            }
-        }
-    }
-    createCannonBody(body) {
-        if (!this.cannonWorld)
-            return undefined;
-        const cannonBody = new CannonBody({
-            type: body.type === "static" ? CannonBody.STATIC : body.type === "kinematic" ? CannonBody.KINEMATIC : CannonBody.DYNAMIC,
-            mass: body.type === "dynamic" ? body.mass : 0,
-            position: toCannonVec3(body.position),
-            velocity: toCannonVec3(body.velocity),
-            quaternion: new CannonQuaternion(body.rotation[0], body.rotation[1], body.rotation[2], body.rotation[3]),
-            angularVelocity: toCannonVec3(body.angularVelocity),
-            linearDamping: body.linearDamping,
-            angularDamping: body.angularDamping,
-            allowSleep: this.enableSleeping,
-            sleepSpeedLimit: this.sleepVelocityThreshold,
-            sleepTimeLimit: this.sleepDelay
-        });
-        if (body.sleeping)
-            cannonBody.sleep();
-        return cannonBody;
-    }
-    addCannonCollider(collider) {
-        if (!this.cannonWorld)
-            return;
-        const body = this.bodiesById.get(collider.bodyId);
-        const cannonBody = this.cannonBodiesByAuraId.get(collider.bodyId);
-        if (!body || !cannonBody)
-            return;
-        const resolved = toCannonShape(collider.shape);
-        if (!resolved) {
-            this.disableCannonBackend(`unsupported shape '${collider.shape.kind}'`);
-            return;
-        }
-        cannonBody.collisionFilterGroup = collider.filter.layer;
-        cannonBody.collisionFilterMask = collider.filter.mask;
-        cannonBody.isTrigger = cannonBody.isTrigger || collider.sensor;
-        cannonBody.addShape(resolved.shape, resolved.offset, resolved.orientation);
-        cannonBody.updateMassProperties();
-        syncCannonFromAura(body, cannonBody);
-    }
-    disableCannonBackend(reason) {
-        if (!this.cannonWorld)
-            return;
-        this.cannonWorld = undefined;
-        this.cannonBodiesByAuraId.clear();
-        this.backendSelection = {
-            requested: this.requestedBackend,
-            active: "aura-js",
-            fallback: reason,
-            deterministic: true,
-            jsFallbackAvailable: true,
-            continuousCollision: this.continuousCollisionSelection(true)
-        };
-    }
-    stepCannon(dt) {
-        if (!this.cannonWorld)
-            return [];
-        this.cannonWorld.gravity.copy(toCannonVec3(this.gravity));
-        for (const body of this.bodyValues()) {
-            const cannonBody = this.cannonBodiesByAuraId.get(body.id);
-            if (cannonBody)
-                syncCannonFromAura(body, cannonBody);
+            syncRapierFromAura(body, rapierBody);
         }
+        this.synchronizeRapierJoints();
         const continuousStep = this.planContinuousCollisionStep(dt);
         this.lastContinuousCollisionStep = continuousStep;
         this.assertContinuousCollisionPlan(continuousStep);
-        const subSteps = continuousStep.subSteps;
-        const subDelta = dt / subSteps;
-        for (let index = 0; index < subSteps; index += 1) {
-            this.cannonWorld.step(subDelta);
+        const subDelta = dt / continuousStep.subSteps;
+        for (let index = 0; index < continuousStep.subSteps; index += 1) {
+            for (const [bodyId, pending] of stepForces) {
+                const raw = this.rapierBodiesByAuraId.get(bodyId)?.unsafeRapierBody();
+                if (!raw)
+                    continue;
+                raw.resetForces(false);
+                raw.resetTorques(false);
+                raw.addForce(toRapierVector(pending.force), true);
+                raw.addTorque(toRapierVector(pending.torque), true);
+            }
+            this.rapierWorld.step(subDelta);
+        }
+        for (const bodyId of stepForces.keys()) {
+            const raw = this.rapierBodiesByAuraId.get(bodyId)?.unsafeRapierBody();
+            raw?.resetForces(false);
+            raw?.resetTorques(false);
         }
         for (const body of this.bodyValues()) {
-            const cannonBody = this.cannonBodiesByAuraId.get(body.id);
-            if (cannonBody)
-                syncAuraFromCannon(cannonBody, body);
+            const rapierBody = this.rapierBodiesByAuraId.get(body.id);
+            if (rapierBody)
+                syncAuraFromRapier(rapierBody, body);
         }
         const contacts = this.detectContacts();
         this.lastEvents = this.eventQueue.update(contacts);
-        this.updateSleeping(dt, contacts);
         this.steps += 1;
         return this.lastEvents;
     }
@@ -638,7 +575,7 @@ export class PhysicsWorld {
         return {
             active,
             mode: active ? "adaptive-substeps" : "disabled",
-            provider: active ? "aura3d-adaptive-substep-wrapper" : "none",
+            provider: active ? "rapier-native-ccd+adaptive-substeps" : "none",
             maxSubSteps: this.continuousCollision.maxSubSteps,
             motionThreshold: this.continuousCollision.motionThreshold,
             onSubstepLimit: this.continuousCollision.onSubstepLimit,
@@ -707,48 +644,40 @@ function colliderBoundingRadius(shape) {
     }
     return 0;
 }
-function toCannonVec3(value) {
-    return new CannonVec3(value[0], value[1], value[2]);
-}
-function fromCannonVec3(value) {
-    return [value.x, value.y, value.z];
-}
-function syncCannonFromAura(body, cannonBody) {
-    cannonBody.position.set(body.position[0], body.position[1], body.position[2]);
-    cannonBody.velocity.set(body.velocity[0], body.velocity[1], body.velocity[2]);
-    cannonBody.quaternion.set(body.rotation[0], body.rotation[1], body.rotation[2], body.rotation[3]);
-    cannonBody.angularVelocity.set(body.angularVelocity[0], body.angularVelocity[1], body.angularVelocity[2]);
+function toRapierVector(value) {
+    return { x: value[0], y: value[1], z: value[2] };
+}
+function encodeRapierCollisionGroups(layer, mask) {
+    return (((layer & 0xffff) << 16) | (mask & 0xffff)) >>> 0;
+}
+/** Mirror the public Aura body state onto its sole physical-simulation owner. */
+function syncRapierFromAura(body, rapierBody) {
+    const raw = rapierBody.unsafeRapierBody();
+    raw.setTranslation(toRapierVector(body.position), false);
+    raw.setRotation({ x: body.rotation[0], y: body.rotation[1], z: body.rotation[2], w: body.rotation[3] }, false);
+    raw.setLinvel(toRapierVector(body.velocity), false);
+    raw.setAngvel(toRapierVector(body.angularVelocity), false);
+    raw.setLinearDamping(body.linearDamping);
+    raw.setAngularDamping(body.angularDamping);
     if (body.sleeping)
-        cannonBody.sleep();
-    else
-        cannonBody.wakeUp();
-}
-function syncAuraFromCannon(cannonBody, body) {
+        raw.sleep();
+    else if (raw.isSleeping())
+        raw.wakeUp();
+}
+/** Publish Rapier's solved transform and velocity through the stable Aura wrapper. */
+function syncAuraFromRapier(rapierBody, body) {
+    const raw = rapierBody.unsafeRapierBody();
+    const position = raw.translation();
+    const rotation = raw.rotation();
+    const velocity = raw.linvel();
+    const angularVelocity = raw.angvel();
     body.previousPosition = cloneVec3(body.position);
     body.previousRotation = [body.rotation[0], body.rotation[1], body.rotation[2], body.rotation[3]];
-    body.position = fromCannonVec3(cannonBody.position);
-    body.velocity = fromCannonVec3(cannonBody.velocity);
-    body.angularVelocity = fromCannonVec3(cannonBody.angularVelocity);
-    body.rotation = [cannonBody.quaternion.x, cannonBody.quaternion.y, cannonBody.quaternion.z, cannonBody.quaternion.w];
-    body.sleeping = cannonBody.sleepState === CannonBody.SLEEPING;
-}
-function toCannonShape(shape) {
-    if (shape.kind === "box")
-        return { shape: new CannonBox(toCannonVec3(shape.halfExtents)) };
-    if (shape.kind === "sphere")
-        return { shape: new CannonSphere(shape.radius) };
-    if (shape.kind === "capsule")
-        return { shape: new CannonCylinder(shape.radius, shape.radius, shape.halfHeight * 2 + shape.radius * 2, 12) };
-    if (shape.kind === "plane") {
-        const orientation = new CannonQuaternion();
-        orientation.setFromVectors(new CannonVec3(0, 0, 1), toCannonVec3(shape.normal));
-        return {
-            shape: new CannonPlane(),
-            offset: toCannonVec3(scaleVec3(shape.normal, shape.constant)),
-            orientation
-        };
-    }
-    return undefined;
+    body.position = [position.x, position.y, position.z];
+    body.rotation = [rotation.x, rotation.y, rotation.z, rotation.w];
+    body.velocity = [velocity.x, velocity.y, velocity.z];
+    body.angularVelocity = [angularVelocity.x, angularVelocity.y, angularVelocity.z];
+    body.sleeping = raw.isSleeping();
 }
 function totalKineticEnergy(bodies) {
     let total = 0;
@@ -765,31 +694,6 @@ function totalKineticEnergy(bodies) {
     }
     return total;
 }
-function relativeContactVelocity(bodyA, bodyB, point) {
-    if (!point)
-        return subVec3(bodyB.velocity, bodyA.velocity);
-    const radiusA = subVec3(point, bodyA.position);
-    const radiusB = subVec3(point, bodyB.position);
-    const velocityA = addVectors(bodyA.velocity, crossVectors(bodyA.angularVelocity, radiusA));
-    const velocityB = addVectors(bodyB.velocity, crossVectors(bodyB.angularVelocity, radiusB));
-    return subVec3(velocityB, velocityA);
-}
-function contactImpulseDenominator(bodyA, bodyB, direction, point) {
-    let denominator = bodyA.inverseMass + bodyB.inverseMass;
-    if (!point)
-        return denominator;
-    if (bodyA.inverseMass > 0) {
-        const radius = subVec3(point, bodyA.position);
-        const angular = bodyA.multiplyInverseInertiaWorld(crossVectors(radius, direction));
-        denominator += dotVec3(direction, crossVectors(angular, radius));
-    }
-    if (bodyB.inverseMass > 0) {
-        const radius = subVec3(point, bodyB.position);
-        const angular = bodyB.multiplyInverseInertiaWorld(crossVectors(radius, direction));
-        denominator += dotVec3(direction, crossVectors(angular, radius));
-    }
-    return denominator;
-}
 function addVectors(a, b) {
     return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
 }
@@ -837,307 +741,4 @@ function pushPotentialPair(pairs, seen, a, b) {
     seen.add(key);
     pairs.push([first.collider, first.body, second.collider, second.body]);
 }
-function buildContact(a, bodyA, b, bodyB) {
-    const ab = subVec3(bodyB.position, bodyA.position);
-    if (a.shape.kind === "plane" || b.shape.kind === "plane") {
-        const planeCollider = a.shape.kind === "plane" ? a : b;
-        const planeBody = a.shape.kind === "plane" ? bodyA : bodyB;
-        const otherCollider = a.shape.kind === "plane" ? b : a;
-        const otherBody = a.shape.kind === "plane" ? bodyB : bodyA;
-        if (planeCollider.shape.kind !== "plane") {
-            return undefined;
-        }
-        const radius = supportRadius(otherCollider);
-        const signedDistance = dotVec3(planeCollider.shape.normal, otherBody.position) + planeCollider.shape.constant + dotVec3(planeCollider.shape.normal, planeBody.position);
-        if (signedDistance > radius) {
-            return undefined;
-        }
-        const normal = a.shape.kind === "plane" ? planeCollider.shape.normal : scaleVec3(planeCollider.shape.normal, -1);
-        return {
-            colliderA: a.id,
-            colliderB: b.id,
-            bodyA: bodyA.id,
-            bodyB: bodyB.id,
-            normal,
-            penetration: radius - signedDistance,
-            sensor: a.sensor || b.sensor
-        };
-    }
-    if (a.shape.kind === "sphere" && b.shape.kind === "sphere") {
-        const distance = Math.hypot(ab[0], ab[1], ab[2]);
-        const radiusSum = a.shape.radius + b.shape.radius;
-        if (distance >= radiusSum) {
-            return undefined;
-        }
-        return {
-            colliderA: a.id,
-            colliderB: b.id,
-            bodyA: bodyA.id,
-            bodyB: bodyB.id,
-            normal: distance > 1e-9 ? [ab[0] / distance, ab[1] / distance, ab[2] / distance] : [1, 0, 0],
-            penetration: radiusSum - distance,
-            sensor: a.sensor || b.sensor
-        };
-    }
-    if ((a.shape.kind === "sphere" && b.shape.kind === "box") || (a.shape.kind === "box" && b.shape.kind === "sphere")) {
-        return buildSphereBoxContact(a, bodyA, b, bodyB);
-    }
-    if ((a.shape.kind === "capsule" && b.shape.kind === "sphere") || (a.shape.kind === "sphere" && b.shape.kind === "capsule")) {
-        return buildCapsuleSphereContact(a, bodyA, b, bodyB);
-    }
-    if ((a.shape.kind === "capsule" && b.shape.kind === "box") || (a.shape.kind === "box" && b.shape.kind === "capsule")) {
-        return buildCapsuleBoxContact(a, bodyA, b, bodyB);
-    }
-    if (a.shape.kind === "capsule" && b.shape.kind === "capsule") {
-        return buildCapsuleCapsuleContact(a, bodyA, b, bodyB);
-    }
-    const nativeContact = buildNativeNarrowPhaseContact(a, bodyA, b, bodyB);
-    if (nativeContact) {
-        return {
-            colliderA: a.id,
-            colliderB: b.id,
-            bodyA: bodyA.id,
-            bodyB: bodyB.id,
-            normal: nativeContact.normal,
-            penetration: nativeContact.penetration,
-            point: nativeContact.point,
-            sensor: a.sensor || b.sensor
-        };
-    }
-    const boundsA = a.bounds(bodyA.position);
-    const boundsB = b.bounds(bodyB.position);
-    const overlapX = Math.min(boundsA.max[0] - boundsB.min[0], boundsB.max[0] - boundsA.min[0]);
-    const overlapY = Math.min(boundsA.max[1] - boundsB.min[1], boundsB.max[1] - boundsA.min[1]);
-    const overlapZ = Math.min(boundsA.max[2] - boundsB.min[2], boundsB.max[2] - boundsA.min[2]);
-    if (overlapX <= 0 || overlapY <= 0 || overlapZ <= 0) {
-        return undefined;
-    }
-    let normal = [Math.sign(ab[0]) || 1, 0, 0];
-    let penetration = overlapX;
-    if (overlapY < penetration) {
-        normal = [0, Math.sign(ab[1]) || 1, 0];
-        penetration = overlapY;
-    }
-    if (overlapZ < penetration) {
-        normal = [0, 0, Math.sign(ab[2]) || 1];
-        penetration = overlapZ;
-    }
-    return {
-        colliderA: a.id,
-        colliderB: b.id,
-        bodyA: bodyA.id,
-        bodyB: bodyB.id,
-        normal,
-        penetration,
-        sensor: a.sensor || b.sensor
-    };
-}
-function buildSphereBoxContact(a, bodyA, b, bodyB) {
-    const sphereCollider = a.shape.kind === "sphere" ? a : b;
-    const sphereBody = a.shape.kind === "sphere" ? bodyA : bodyB;
-    const boxCollider = a.shape.kind === "box" ? a : b;
-    const boxBody = a.shape.kind === "box" ? bodyA : bodyB;
-    if (sphereCollider.shape.kind !== "sphere" || boxCollider.shape.kind !== "box") {
-        return undefined;
-    }
-    const boxBounds = boxCollider.bounds(boxBody.position);
-    const closest = [
-        clamp(sphereBody.position[0], boxBounds.min[0], boxBounds.max[0]),
-        clamp(sphereBody.position[1], boxBounds.min[1], boxBounds.max[1]),
-        clamp(sphereBody.position[2], boxBounds.min[2], boxBounds.max[2])
-    ];
-    const fromBoxToSphere = subVec3(sphereBody.position, closest);
-    const distance = Math.hypot(fromBoxToSphere[0], fromBoxToSphere[1], fromBoxToSphere[2]);
-    if (distance >= sphereCollider.shape.radius) {
-        return undefined;
-    }
-    const normalFromBoxToSphere = distance > 1e-9 ? scaleVec3(fromBoxToSphere, 1 / distance) : axisFromBoxCenter(boxBody.position, sphereBody.position, boxCollider.shape.halfExtents);
-    const normal = a.shape.kind === "box" ? normalFromBoxToSphere : scaleVec3(normalFromBoxToSphere, -1);
-    return {
-        colliderA: a.id,
-        colliderB: b.id,
-        bodyA: bodyA.id,
-        bodyB: bodyB.id,
-        normal,
-        penetration: sphereCollider.shape.radius - distance,
-        sensor: a.sensor || b.sensor
-    };
-}
-function buildCapsuleSphereContact(a, bodyA, b, bodyB) {
-    const capsuleCollider = a.shape.kind === "capsule" ? a : b;
-    const capsuleBody = a.shape.kind === "capsule" ? bodyA : bodyB;
-    const sphereCollider = a.shape.kind === "sphere" ? a : b;
-    const sphereBody = a.shape.kind === "sphere" ? bodyA : bodyB;
-    if (capsuleCollider.shape.kind !== "capsule" || sphereCollider.shape.kind !== "sphere") {
-        return undefined;
-    }
-    const closest = closestPointOnSegment(sphereBody.position, capsuleSegment(capsuleBody.position, capsuleCollider.shape.halfHeight));
-    const delta = subVec3(sphereBody.position, closest);
-    const distance = Math.hypot(delta[0], delta[1], delta[2]);
-    const radiusSum = capsuleCollider.shape.radius + sphereCollider.shape.radius;
-    if (distance >= radiusSum) {
-        return undefined;
-    }
-    const normalFromCapsuleToSphere = distance > 1e-9 ? scaleVec3(delta, 1 / distance) : [1, 0, 0];
-    const normal = a.shape.kind === "capsule" ? normalFromCapsuleToSphere : scaleVec3(normalFromCapsuleToSphere, -1);
-    return {
-        colliderA: a.id,
-        colliderB: b.id,
-        bodyA: bodyA.id,
-        bodyB: bodyB.id,
-        normal,
-        penetration: radiusSum - distance,
-        sensor: a.sensor || b.sensor
-    };
-}
-function buildCapsuleCapsuleContact(a, bodyA, b, bodyB) {
-    if (a.shape.kind !== "capsule" || b.shape.kind !== "capsule") {
-        return undefined;
-    }
-    const closest = closestPointsBetweenSegments(capsuleSegment(bodyA.position, a.shape.halfHeight), capsuleSegment(bodyB.position, b.shape.halfHeight));
-    const delta = subVec3(closest.b, closest.a);
-    const distance = Math.hypot(delta[0], delta[1], delta[2]);
-    const radiusSum = a.shape.radius + b.shape.radius;
-    if (distance >= radiusSum) {
-        return undefined;
-    }
-    return {
-        colliderA: a.id,
-        colliderB: b.id,
-        bodyA: bodyA.id,
-        bodyB: bodyB.id,
-        normal: distance > 1e-9 ? scaleVec3(delta, 1 / distance) : [1, 0, 0],
-        penetration: radiusSum - distance,
-        sensor: a.sensor || b.sensor
-    };
-}
-function buildCapsuleBoxContact(a, bodyA, b, bodyB) {
-    const capsuleCollider = a.shape.kind === "capsule" ? a : b;
-    const capsuleBody = a.shape.kind === "capsule" ? bodyA : bodyB;
-    const boxCollider = a.shape.kind === "box" ? a : b;
-    const boxBody = a.shape.kind === "box" ? bodyA : bodyB;
-    if (capsuleCollider.shape.kind !== "capsule" || boxCollider.shape.kind !== "box") {
-        return undefined;
-    }
-    const bounds = boxCollider.bounds(boxBody.position);
-    const closest = closestVerticalSegmentPointToAabb(capsuleBody.position, capsuleCollider.shape.halfHeight, bounds);
-    const fromBoxToCapsule = subVec3(closest.segmentPoint, closest.boxPoint);
-    const distance = Math.hypot(fromBoxToCapsule[0], fromBoxToCapsule[1], fromBoxToCapsule[2]);
-    if (distance >= capsuleCollider.shape.radius) {
-        return undefined;
-    }
-    const normalFromBoxToCapsule = distance > 1e-9 ? scaleVec3(fromBoxToCapsule, 1 / distance) : axisFromBoxCenter(boxBody.position, closest.segmentPoint, boxCollider.shape.halfExtents);
-    const normal = a.shape.kind === "box" ? normalFromBoxToCapsule : scaleVec3(normalFromBoxToCapsule, -1);
-    return {
-        colliderA: a.id,
-        colliderB: b.id,
-        bodyA: bodyA.id,
-        bodyB: bodyB.id,
-        normal,
-        penetration: capsuleCollider.shape.radius - distance,
-        sensor: a.sensor || b.sensor
-    };
-}
-function capsuleSegment(position, halfHeight) {
-    return {
-        start: [position[0], position[1] - halfHeight, position[2]],
-        end: [position[0], position[1] + halfHeight, position[2]]
-    };
-}
-function closestPointOnSegment(point, segment) {
-    const ab = subVec3(segment.end, segment.start);
-    const lengthSquared = dotVec3(ab, ab);
-    if (lengthSquared <= 1e-9) {
-        return segment.start;
-    }
-    const t = clamp(dotVec3(subVec3(point, segment.start), ab) / lengthSquared, 0, 1);
-    return [
-        segment.start[0] + ab[0] * t,
-        segment.start[1] + ab[1] * t,
-        segment.start[2] + ab[2] * t
-    ];
-}
-function closestPointsBetweenSegments(a, b) {
-    const d1 = subVec3(a.end, a.start);
-    const d2 = subVec3(b.end, b.start);
-    const r = subVec3(a.start, b.start);
-    const aLength = dotVec3(d1, d1);
-    const bLength = dotVec3(d2, d2);
-    const d12 = dotVec3(d1, d2);
-    const d1r = dotVec3(d1, r);
-    const d2r = dotVec3(d2, r);
-    const denominator = aLength * bLength - d12 * d12;
-    let s = denominator <= 1e-9 ? 0 : clamp((d12 * d2r - bLength * d1r) / denominator, 0, 1);
-    let t = bLength <= 1e-9 ? 0 : (d12 * s + d2r) / bLength;
-    if (t < 0) {
-        t = 0;
-        s = aLength <= 1e-9 ? 0 : clamp(-d1r / aLength, 0, 1);
-    }
-    else if (t > 1) {
-        t = 1;
-        s = aLength <= 1e-9 ? 0 : clamp((d12 - d1r) / aLength, 0, 1);
-    }
-    return {
-        a: [a.start[0] + d1[0] * s, a.start[1] + d1[1] * s, a.start[2] + d1[2] * s],
-        b: [b.start[0] + d2[0] * t, b.start[1] + d2[1] * t, b.start[2] + d2[2] * t]
-    };
-}
-function closestVerticalSegmentPointToAabb(position, halfHeight, bounds) {
-    const segmentMinY = position[1] - halfHeight;
-    const segmentMaxY = position[1] + halfHeight;
-    let segmentY;
-    let boxY;
-    if (segmentMaxY < bounds.min[1]) {
-        segmentY = segmentMaxY;
-        boxY = bounds.min[1];
-    }
-    else if (segmentMinY > bounds.max[1]) {
-        segmentY = segmentMinY;
-        boxY = bounds.max[1];
-    }
-    else {
-        segmentY = clamp(position[1], Math.max(segmentMinY, bounds.min[1]), Math.min(segmentMaxY, bounds.max[1]));
-        boxY = segmentY;
-    }
-    const segmentPoint = [position[0], segmentY, position[2]];
-    const boxPoint = [
-        clamp(position[0], bounds.min[0], bounds.max[0]),
-        boxY,
-        clamp(position[2], bounds.min[2], bounds.max[2])
-    ];
-    return { segmentPoint, boxPoint };
-}
-function axisFromBoxCenter(boxPosition, spherePosition, halfExtents) {
-    const local = subVec3(spherePosition, boxPosition);
-    const distances = [
-        [halfExtents[0] - Math.abs(local[0]), [Math.sign(local[0]) || 1, 0, 0]],
-        [halfExtents[1] - Math.abs(local[1]), [0, Math.sign(local[1]) || 1, 0]],
-        [halfExtents[2] - Math.abs(local[2]), [0, 0, Math.sign(local[2]) || 1]]
-    ];
-    return distances.reduce((best, candidate) => candidate[0] < best[0] ? candidate : best)[1];
-}
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-function supportRadius(collider) {
-    switch (collider.shape.kind) {
-        case "box":
-            return collider.shape.halfExtents[1];
-        case "sphere":
-            return collider.shape.radius;
-        case "capsule":
-            return collider.shape.radius + collider.shape.halfHeight;
-        case "plane":
-            return 0;
-        case "mesh": {
-            const bounds = collider.bounds([0, 0, 0]);
-            return Math.max(Math.abs(bounds.min[1]), Math.abs(bounds.max[1]));
-        }
-        case "convex-hull":
-        case "heightfield": {
-            const bounds = collider.bounds([0, 0, 0]);
-            return Math.max(Math.abs(bounds.min[1]), Math.abs(bounds.max[1]));
-        }
-    }
-}
 //# sourceMappingURL=PhysicsWorld.js.map