angular-three-rapier 2.2.0

package/esm2022/lib/physics.mjs

@@ -0,0 +1,362 @@
+import { ChangeDetectionStrategy, Component, computed, DestroyRef, effect, inject, input, signal, untracked, } from '@angular/core';
+import { EventQueue } from '@dimforge/rapier3d-compat';
+import { injectStore, pick, vector3 } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { MathUtils } from 'three';
+import { NgtrDebug } from './debug';
+import { NgtrFrameStepper } from './frame-stepper';
+import { _matrix4, _position, _rotation, _scale } from './shared';
+import { createSingletonProxy, rapierQuaternionToQuaternion } from './utils';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    gravity: [0, -9.81, 0],
+    allowedLinearError: 0.001,
+    numSolverIterations: 4,
+    numAdditionalFrictionIterations: 4,
+    numInternalPgsIterations: 1,
+    predictionDistance: 0.002,
+    minIslandSize: 128,
+    maxCcdSubsteps: 1,
+    erp: 0.8,
+    lengthUnit: 1,
+    colliders: 'cuboid',
+    updateLoop: 'follow',
+    interpolate: true,
+    paused: false,
+    timeStep: 1 / 60,
+    debug: false,
+};
+export class NgtrPhysics {
+    options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+    updatePriority = pick(this.options, 'updatePriority');
+    updateLoop = pick(this.options, 'updateLoop');
+    numSolverIterations = pick(this.options, 'numSolverIterations');
+    numAdditionalFrictionIterations = pick(this.options, 'numAdditionalFrictionIterations');
+    numInternalPgsIterations = pick(this.options, 'numInternalPgsIterations');
+    allowedLinearError = pick(this.options, 'allowedLinearError');
+    minIslandSize = pick(this.options, 'minIslandSize');
+    maxCcdSubsteps = pick(this.options, 'maxCcdSubsteps');
+    predictionDistance = pick(this.options, 'predictionDistance');
+    erp = pick(this.options, 'erp');
+    lengthUnit = pick(this.options, 'lengthUnit');
+    timeStep = pick(this.options, 'timeStep');
+    interpolate = pick(this.options, 'interpolate');
+    paused = pick(this.options, 'paused');
+    debug = pick(this.options, 'debug');
+    colliders = pick(this.options, 'colliders');
+    gravity = vector3(this.options, 'gravity');
+    store = injectStore();
+    destroyRef = inject(DestroyRef);
+    rapierConstruct = signal(null);
+    rapier = this.rapierConstruct.asReadonly();
+    ready = computed(() => !!this.rapier());
+    worldSingleton = computed(() => {
+        const rapier = this.rapier();
+        if (!rapier)
+            return null;
+        return createSingletonProxy(() => new rapier.World(untracked(this.gravity)));
+    });
+    rigidBodyStates = new Map();
+    colliderStates = new Map();
+    rigidBodyEvents = new Map();
+    colliderEvents = new Map();
+    beforeStepCallbacks = new Set();
+    afterStepCallbacks = new Set();
+    eventQueue = computed(() => {
+        const rapier = this.rapier();
+        if (!rapier)
+            return null;
+        return new EventQueue(false);
+    });
+    steppingState = { accumulator: 0, previousState: {} };
+    constructor() {
+        import('@dimforge/rapier3d-compat')
+            .then((rapier) => rapier.init().then(() => rapier))
+            .then(this.rapierConstruct.set.bind(this.rapierConstruct))
+            .catch((err) => {
+            console.error(`[NGT] Failed to load rapier3d-compat`, err);
+            return Promise.reject(err);
+        });
+        effect(() => {
+            this.updateWorldEffect();
+        });
+        this.destroyRef.onDestroy(() => {
+            const world = this.worldSingleton();
+            if (world) {
+                world.proxy.free();
+                world.reset();
+            }
+        });
+    }
+    step(delta) {
+        if (!this.paused()) {
+            this.internalStep(delta);
+        }
+    }
+    updateWorldEffect() {
+        const world = this.worldSingleton();
+        if (!world)
+            return;
+        world.proxy.gravity = this.gravity();
+        world.proxy.integrationParameters.numSolverIterations = this.numSolverIterations();
+        world.proxy.integrationParameters.numAdditionalFrictionIterations = this.numAdditionalFrictionIterations();
+        world.proxy.integrationParameters.numInternalPgsIterations = this.numInternalPgsIterations();
+        world.proxy.integrationParameters.normalizedAllowedLinearError = this.allowedLinearError();
+        world.proxy.integrationParameters.minIslandSize = this.minIslandSize();
+        world.proxy.integrationParameters.maxCcdSubsteps = this.maxCcdSubsteps();
+        world.proxy.integrationParameters.normalizedPredictionDistance = this.predictionDistance();
+        /**
+         * NOTE: we don't know if this is the correct way to set for contact_natural_frequency or not.
+         * but at least, it gets the `contact_erp` value to be very close with setting `erp`
+         */
+        world.proxy.integrationParameters.contact_natural_frequency = this.erp() * 1_000;
+        world.proxy.lengthUnit = this.lengthUnit();
+    }
+    internalStep(delta) {
+        const worldSingleton = this.worldSingleton();
+        if (!worldSingleton)
+            return;
+        const eventQueue = this.eventQueue();
+        if (!eventQueue)
+            return;
+        const world = worldSingleton.proxy;
+        const [timeStep, interpolate, paused] = [this.timeStep(), this.interpolate(), this.paused()];
+        /* Check if the timestep is supposed to be variable. We'll do this here
+      once so we don't have to string-check every frame. */
+        const timeStepVariable = timeStep === 'vary';
+        /**
+         * Fixed timeStep simulation progression
+         * @see https://gafferongames.com/post/fix_your_timestep/
+         */
+        const clampedDelta = MathUtils.clamp(delta, 0, 0.5);
+        const stepWorld = (innerDelta) => {
+            // Trigger beforeStep callbacks
+            this.beforeStepCallbacks.forEach((callback) => {
+                callback(world);
+            });
+            world.timestep = innerDelta;
+            world.step(eventQueue);
+            // Trigger afterStep callbacks
+            this.afterStepCallbacks.forEach((callback) => {
+                callback(world);
+            });
+        };
+        if (timeStepVariable) {
+            stepWorld(clampedDelta);
+        }
+        else {
+            // don't step time forwards if paused
+            // Increase accumulator
+            this.steppingState.accumulator += clampedDelta;
+            while (this.steppingState.accumulator >= timeStep) {
+                // Set up previous state
+                // needed for accurate interpolations if the world steps more than once
+                if (interpolate) {
+                    this.steppingState.previousState = {};
+                    world.forEachRigidBody((body) => {
+                        this.steppingState.previousState[body.handle] = {
+                            position: body.translation(),
+                            rotation: body.rotation(),
+                        };
+                    });
+                }
+                stepWorld(timeStep);
+                this.steppingState.accumulator -= timeStep;
+            }
+        }
+        const interpolationAlpha = timeStepVariable || !interpolate || paused ? 1 : this.steppingState.accumulator / timeStep;
+        // Update meshes
+        this.rigidBodyStates.forEach((state, handle) => {
+            const rigidBody = world.getRigidBody(handle);
+            const events = this.rigidBodyEvents.get(handle);
+            if (events?.onSleep || events?.onWake) {
+                if (rigidBody.isSleeping() && !state.isSleeping)
+                    events?.onSleep?.();
+                if (!rigidBody.isSleeping() && state.isSleeping)
+                    events?.onWake?.();
+                state.isSleeping = rigidBody.isSleeping();
+            }
+            if (!rigidBody || (rigidBody.isSleeping() && !('isInstancedMesh' in state.object)) || !state.setMatrix) {
+                return;
+            }
+            // New states
+            let t = rigidBody.translation();
+            let r = rigidBody.rotation();
+            let previousState = this.steppingState.previousState[handle];
+            if (previousState) {
+                // Get previous simulated world position
+                _matrix4
+                    .compose(previousState.position, rapierQuaternionToQuaternion(previousState.rotation), state.scale)
+                    .premultiply(state.invertedWorldMatrix)
+                    .decompose(_position, _rotation, _scale);
+                // Apply previous tick position
+                if (state.meshType == 'mesh') {
+                    state.object.position.copy(_position);
+                    state.object.quaternion.copy(_rotation);
+                }
+            }
+            // Get new position
+            _matrix4
+                .compose(t, rapierQuaternionToQuaternion(r), state.scale)
+                .premultiply(state.invertedWorldMatrix)
+                .decompose(_position, _rotation, _scale);
+            if (state.meshType == 'instancedMesh') {
+                state.setMatrix(_matrix4);
+            }
+            else {
+                // Interpolate to new position
+                state.object.position.lerp(_position, interpolationAlpha);
+                state.object.quaternion.slerp(_rotation, interpolationAlpha);
+            }
+        });
+        eventQueue.drainCollisionEvents((handle1, handle2, started) => {
+            const source1 = this.getSourceFromColliderHandle(handle1);
+            const source2 = this.getSourceFromColliderHandle(handle2);
+            // Collision Events
+            if (!source1?.collider.object || !source2?.collider.object) {
+                return;
+            }
+            const collisionPayload1 = this.getCollisionPayloadFromSource(source1, source2);
+            const collisionPayload2 = this.getCollisionPayloadFromSource(source2, source1);
+            if (started) {
+                world.contactPair(source1.collider.object, source2.collider.object, (manifold, flipped) => {
+                    /* RigidBody events */
+                    source1.rigidBody.events?.onCollisionEnter?.({ ...collisionPayload1, manifold, flipped });
+                    source2.rigidBody.events?.onCollisionEnter?.({ ...collisionPayload2, manifold, flipped });
+                    /* Collider events */
+                    source1.collider.events?.onCollisionEnter?.({ ...collisionPayload1, manifold, flipped });
+                    source2.collider.events?.onCollisionEnter?.({ ...collisionPayload2, manifold, flipped });
+                });
+            }
+            else {
+                source1.rigidBody.events?.onCollisionExit?.(collisionPayload1);
+                source2.rigidBody.events?.onCollisionExit?.(collisionPayload2);
+                source1.collider.events?.onCollisionExit?.(collisionPayload1);
+                source2.collider.events?.onCollisionExit?.(collisionPayload2);
+            }
+            // Sensor Intersections
+            if (started) {
+                if (world.intersectionPair(source1.collider.object, source2.collider.object)) {
+                    source1.rigidBody.events?.onIntersectionEnter?.(collisionPayload1);
+                    source2.rigidBody.events?.onIntersectionEnter?.(collisionPayload2);
+                    source1.collider.events?.onIntersectionEnter?.(collisionPayload1);
+                    source2.collider.events?.onIntersectionEnter?.(collisionPayload2);
+                }
+            }
+            else {
+                source1.rigidBody.events?.onIntersectionExit?.(collisionPayload1);
+                source2.rigidBody.events?.onIntersectionExit?.(collisionPayload2);
+                source1.collider.events?.onIntersectionExit?.(collisionPayload1);
+                source2.collider.events?.onIntersectionExit?.(collisionPayload2);
+            }
+        });
+        eventQueue.drainContactForceEvents((event) => {
+            const source1 = this.getSourceFromColliderHandle(event.collider1());
+            const source2 = this.getSourceFromColliderHandle(event.collider2());
+            // Collision Events
+            if (!source1?.collider.object || !source2?.collider.object) {
+                return;
+            }
+            const collisionPayload1 = this.getCollisionPayloadFromSource(source1, source2);
+            const collisionPayload2 = this.getCollisionPayloadFromSource(source2, source1);
+            source1.rigidBody.events?.onContactForce?.({
+                ...collisionPayload1,
+                totalForce: event.totalForce(),
+                totalForceMagnitude: event.totalForceMagnitude(),
+                maxForceDirection: event.maxForceDirection(),
+                maxForceMagnitude: event.maxForceMagnitude(),
+            });
+            source2.rigidBody.events?.onContactForce?.({
+                ...collisionPayload2,
+                totalForce: event.totalForce(),
+                totalForceMagnitude: event.totalForceMagnitude(),
+                maxForceDirection: event.maxForceDirection(),
+                maxForceMagnitude: event.maxForceMagnitude(),
+            });
+            source1.collider.events?.onContactForce?.({
+                ...collisionPayload1,
+                totalForce: event.totalForce(),
+                totalForceMagnitude: event.totalForceMagnitude(),
+                maxForceDirection: event.maxForceDirection(),
+                maxForceMagnitude: event.maxForceMagnitude(),
+            });
+            source2.collider.events?.onContactForce?.({
+                ...collisionPayload2,
+                totalForce: event.totalForce(),
+                totalForceMagnitude: event.totalForceMagnitude(),
+                maxForceDirection: event.maxForceDirection(),
+                maxForceMagnitude: event.maxForceMagnitude(),
+            });
+        });
+        world.forEachActiveRigidBody(() => {
+            this.store.snapshot.invalidate();
+        });
+    }
+    getSourceFromColliderHandle(handle) {
+        const world = this.worldSingleton();
+        if (!world)
+            return;
+        const collider = world.proxy.getCollider(handle);
+        const colEvents = this.colliderEvents.get(handle);
+        const colliderState = this.colliderStates.get(handle);
+        const rigidBodyHandle = collider.parent()?.handle;
+        const rigidBody = rigidBodyHandle !== undefined ? world.proxy.getRigidBody(rigidBodyHandle) : undefined;
+        const rigidBodyEvents = rigidBody && rigidBodyHandle !== undefined ? this.rigidBodyEvents.get(rigidBodyHandle) : undefined;
+        const rigidBodyState = rigidBodyHandle !== undefined ? this.rigidBodyStates.get(rigidBodyHandle) : undefined;
+        return {
+            collider: { object: collider, events: colEvents, state: colliderState },
+            rigidBody: { object: rigidBody, events: rigidBodyEvents, state: rigidBodyState },
+        };
+    }
+    getCollisionPayloadFromSource(target, other) {
+        return {
+            target: {
+                rigidBody: target.rigidBody.object,
+                collider: target.collider.object,
+                colliderObject: target.collider.state?.object,
+                rigidBodyObject: target.rigidBody.state?.object,
+            },
+            other: {
+                rigidBody: other.rigidBody.object,
+                collider: other.collider.object,
+                colliderObject: other.collider.state?.object,
+                rigidBodyObject: other.rigidBody.state?.object,
+            },
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrPhysics, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtrPhysics, isStandalone: true, selector: "ngtr-physics", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		@if (debug()) {
+			<ngtr-debug [world]="worldSingleton()?.proxy" />
+		}
+		<ngtr-frame-stepper
+			[ready]="ready()"
+			[stepFn]="step.bind(this)"
+			[type]="updateLoop()"
+			[updatePriority]="updatePriority()"
+		/>
+		<ng-content />
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtrDebug, selector: "ngtr-debug", inputs: ["world"] }, { kind: "directive", type: NgtrFrameStepper, selector: "ngtr-frame-stepper", inputs: ["ready", "updatePriority", "stepFn", "type"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrPhysics, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtr-physics',
+                    standalone: true,
+                    template: `
+		@if (debug()) {
+			<ngtr-debug [world]="worldSingleton()?.proxy" />
+		}
+		<ngtr-frame-stepper
+			[ready]="ready()"
+			[stepFn]="step.bind(this)"
+			[type]="updateLoop()"
+			[updatePriority]="updatePriority()"
+		/>
+		<ng-content />
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtrDebug, NgtrFrameStepper],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"physics.js","sourceRoot":"","sources":["../../../../../libs/rapier/src/lib/physics.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tDestroyRef,\n\teffect,\n\tinject,\n\tinput,\n\tsignal,\n\tuntracked,\n} from '@angular/core';\nimport RAPIER, { ColliderHandle, EventQueue, Rotation, Vector, World } from '@dimforge/rapier3d-compat';\nimport { injectStore, pick, vector3 } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { MathUtils, Quaternion, Vector3 } from 'three';\nimport { NgtrDebug } from './debug';\nimport { NgtrFrameStepper } from './frame-stepper';\nimport { _matrix4, _position, _rotation, _scale } from './shared';\nimport {\n\tNgtrColliderStateMap,\n\tNgtrCollisionPayload,\n\tNgtrCollisionSource,\n\tNgtrEventMap,\n\tNgtrPhysicsOptions,\n\tNgtrRigidBodyStateMap,\n\tNgtrWorldStepCallbackSet,\n} from './types';\nimport { createSingletonProxy, rapierQuaternionToQuaternion } from './utils';\n\nconst defaultOptions: NgtrPhysicsOptions = {\n\tgravity: [0, -9.81, 0],\n\tallowedLinearError: 0.001,\n\tnumSolverIterations: 4,\n\tnumAdditionalFrictionIterations: 4,\n\tnumInternalPgsIterations: 1,\n\tpredictionDistance: 0.002,\n\tminIslandSize: 128,\n\tmaxCcdSubsteps: 1,\n\terp: 0.8,\n\tlengthUnit: 1,\n\tcolliders: 'cuboid',\n\tupdateLoop: 'follow',\n\tinterpolate: true,\n\tpaused: false,\n\ttimeStep: 1 / 60,\n\tdebug: false,\n};\n\n@Component({\n\tselector: 'ngtr-physics',\n\tstandalone: true,\n\ttemplate: `\n\t\t@if (debug()) {\n\t\t\t<ngtr-debug [world]=\"worldSingleton()?.proxy\" />\n\t\t}\n\t\t<ngtr-frame-stepper\n\t\t\t[ready]=\"ready()\"\n\t\t\t[stepFn]=\"step.bind(this)\"\n\t\t\t[type]=\"updateLoop()\"\n\t\t\t[updatePriority]=\"updatePriority()\"\n\t\t/>\n\t\t<ng-content />\n\t`,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtrDebug, NgtrFrameStepper],\n})\nexport class NgtrPhysics {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\n\tprotected updatePriority = pick(this.options, 'updatePriority');\n\tprotected updateLoop = pick(this.options, 'updateLoop');\n\n\tprivate numSolverIterations = pick(this.options, 'numSolverIterations');\n\tprivate numAdditionalFrictionIterations = pick(this.options, 'numAdditionalFrictionIterations');\n\tprivate numInternalPgsIterations = pick(this.options, 'numInternalPgsIterations');\n\tprivate allowedLinearError = pick(this.options, 'allowedLinearError');\n\tprivate minIslandSize = pick(this.options, 'minIslandSize');\n\tprivate maxCcdSubsteps = pick(this.options, 'maxCcdSubsteps');\n\tprivate predictionDistance = pick(this.options, 'predictionDistance');\n\tprivate erp = pick(this.options, 'erp');\n\tprivate lengthUnit = pick(this.options, 'lengthUnit');\n\tprivate timeStep = pick(this.options, 'timeStep');\n\tprivate interpolate = pick(this.options, 'interpolate');\n\n\tpaused = pick(this.options, 'paused');\n\tdebug = pick(this.options, 'debug');\n\tcolliders = pick(this.options, 'colliders');\n\tgravity = vector3(this.options, 'gravity');\n\n\tprivate store = injectStore();\n\tprivate destroyRef = inject(DestroyRef);\n\n\tprivate rapierConstruct = signal<typeof RAPIER | null>(null);\n\trapier = this.rapierConstruct.asReadonly();\n\n\tready = computed(() => !!this.rapier());\n\tworldSingleton = computed(() => {\n\t\tconst rapier = this.rapier();\n\t\tif (!rapier) return null;\n\t\treturn createSingletonProxy<World>(() => new rapier.World(untracked(this.gravity)));\n\t});\n\n\trigidBodyStates: NgtrRigidBodyStateMap = new Map();\n\tcolliderStates: NgtrColliderStateMap = new Map();\n\trigidBodyEvents: NgtrEventMap = new Map();\n\tcolliderEvents: NgtrEventMap = new Map();\n\tbeforeStepCallbacks: NgtrWorldStepCallbackSet = new Set();\n\tafterStepCallbacks: NgtrWorldStepCallbackSet = new Set();\n\n\tprivate eventQueue = computed(() => {\n\t\tconst rapier = this.rapier();\n\t\tif (!rapier) return null;\n\t\treturn new EventQueue(false);\n\t});\n\n\tprivate steppingState: {\n\t\taccumulator: number;\n\t\tpreviousState: Record<number, { position: Vector; rotation: Rotation }>;\n\t} = { accumulator: 0, previousState: {} };\n\n\tconstructor() {\n\t\timport('@dimforge/rapier3d-compat')\n\t\t\t.then((rapier) => rapier.init().then(() => rapier))\n\t\t\t.then(this.rapierConstruct.set.bind(this.rapierConstruct))\n\t\t\t.catch((err) => {\n\t\t\t\tconsole.error(`[NGT] Failed to load rapier3d-compat`, err);\n\t\t\t\treturn Promise.reject(err);\n\t\t\t});\n\n\t\teffect(() => {\n\t\t\tthis.updateWorldEffect();\n\t\t});\n\n\t\tthis.destroyRef.onDestroy(() => {\n\t\t\tconst world = this.worldSingleton();\n\t\t\tif (world) {\n\t\t\t\tworld.proxy.free();\n\t\t\t\tworld.reset();\n\t\t\t}\n\t\t});\n\t}\n\n\tstep(delta: number) {\n\t\tif (!this.paused()) {\n\t\t\tthis.internalStep(delta);\n\t\t}\n\t}\n\n\tprivate updateWorldEffect() {\n\t\tconst world = this.worldSingleton();\n\t\tif (!world) return;\n\n\t\tworld.proxy.gravity = this.gravity();\n\t\tworld.proxy.integrationParameters.numSolverIterations = this.numSolverIterations();\n\t\tworld.proxy.integrationParameters.numAdditionalFrictionIterations = this.numAdditionalFrictionIterations();\n\t\tworld.proxy.integrationParameters.numInternalPgsIterations = this.numInternalPgsIterations();\n\t\tworld.proxy.integrationParameters.normalizedAllowedLinearError = this.allowedLinearError();\n\t\tworld.proxy.integrationParameters.minIslandSize = this.minIslandSize();\n\t\tworld.proxy.integrationParameters.maxCcdSubsteps = this.maxCcdSubsteps();\n\t\tworld.proxy.integrationParameters.normalizedPredictionDistance = this.predictionDistance();\n\t\t/**\n\t\t * NOTE: we don't know if this is the correct way to set for contact_natural_frequency or not.\n\t\t * but at least, it gets the `contact_erp` value to be very close with setting `erp`\n\t\t */\n\t\tworld.proxy.integrationParameters.contact_natural_frequency = this.erp() * 1_000;\n\t\tworld.proxy.lengthUnit = this.lengthUnit();\n\t}\n\n\tprivate internalStep(delta: number) {\n\t\tconst worldSingleton = this.worldSingleton();\n\t\tif (!worldSingleton) return;\n\n\t\tconst eventQueue = this.eventQueue();\n\t\tif (!eventQueue) return;\n\n\t\tconst world = worldSingleton.proxy;\n\t\tconst [timeStep, interpolate, paused] = [this.timeStep(), this.interpolate(), this.paused()];\n\n\t\t/* Check if the timestep is supposed to be variable. We'll do this here\n      once so we don't have to string-check every frame. */\n\t\tconst timeStepVariable = timeStep === 'vary';\n\n\t\t/**\n\t\t * Fixed timeStep simulation progression\n\t\t * @see https://gafferongames.com/post/fix_your_timestep/\n\t\t */\n\t\tconst clampedDelta = MathUtils.clamp(delta, 0, 0.5);\n\n\t\tconst stepWorld = (innerDelta: number) => {\n\t\t\t// Trigger beforeStep callbacks\n\t\t\tthis.beforeStepCallbacks.forEach((callback) => {\n\t\t\t\tcallback(world);\n\t\t\t});\n\n\t\t\tworld.timestep = innerDelta;\n\t\t\tworld.step(eventQueue);\n\n\t\t\t// Trigger afterStep callbacks\n\t\t\tthis.afterStepCallbacks.forEach((callback) => {\n\t\t\t\tcallback(world);\n\t\t\t});\n\t\t};\n\n\t\tif (timeStepVariable) {\n\t\t\tstepWorld(clampedDelta);\n\t\t} else {\n\t\t\t// don't step time forwards if paused\n\t\t\t// Increase accumulator\n\t\t\tthis.steppingState.accumulator += clampedDelta;\n\n\t\t\twhile (this.steppingState.accumulator >= timeStep) {\n\t\t\t\t// Set up previous state\n\t\t\t\t// needed for accurate interpolations if the world steps more than once\n\t\t\t\tif (interpolate) {\n\t\t\t\t\tthis.steppingState.previousState = {};\n\t\t\t\t\tworld.forEachRigidBody((body) => {\n\t\t\t\t\t\tthis.steppingState.previousState[body.handle] = {\n\t\t\t\t\t\t\tposition: body.translation(),\n\t\t\t\t\t\t\trotation: body.rotation(),\n\t\t\t\t\t\t};\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\tstepWorld(timeStep);\n\t\t\t\tthis.steppingState.accumulator -= timeStep;\n\t\t\t}\n\t\t}\n\n\t\tconst interpolationAlpha =\n\t\t\ttimeStepVariable || !interpolate || paused ? 1 : this.steppingState.accumulator / timeStep;\n\n\t\t// Update meshes\n\t\tthis.rigidBodyStates.forEach((state, handle) => {\n\t\t\tconst rigidBody = world.getRigidBody(handle);\n\n\t\t\tconst events = this.rigidBodyEvents.get(handle);\n\t\t\tif (events?.onSleep || events?.onWake) {\n\t\t\t\tif (rigidBody.isSleeping() && !state.isSleeping) events?.onSleep?.();\n\t\t\t\tif (!rigidBody.isSleeping() && state.isSleeping) events?.onWake?.();\n\t\t\t\tstate.isSleeping = rigidBody.isSleeping();\n\t\t\t}\n\n\t\t\tif (!rigidBody || (rigidBody.isSleeping() && !('isInstancedMesh' in state.object)) || !state.setMatrix) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// New states\n\t\t\tlet t = rigidBody.translation() as Vector3;\n\t\t\tlet r = rigidBody.rotation() as Quaternion;\n\n\t\t\tlet previousState = this.steppingState.previousState[handle];\n\n\t\t\tif (previousState) {\n\t\t\t\t// Get previous simulated world position\n\t\t\t\t_matrix4\n\t\t\t\t\t.compose(previousState.position as Vector3, rapierQuaternionToQuaternion(previousState.rotation), state.scale)\n\t\t\t\t\t.premultiply(state.invertedWorldMatrix)\n\t\t\t\t\t.decompose(_position, _rotation, _scale);\n\n\t\t\t\t// Apply previous tick position\n\t\t\t\tif (state.meshType == 'mesh') {\n\t\t\t\t\tstate.object.position.copy(_position);\n\t\t\t\t\tstate.object.quaternion.copy(_rotation);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Get new position\n\t\t\t_matrix4\n\t\t\t\t.compose(t, rapierQuaternionToQuaternion(r), state.scale)\n\t\t\t\t.premultiply(state.invertedWorldMatrix)\n\t\t\t\t.decompose(_position, _rotation, _scale);\n\n\t\t\tif (state.meshType == 'instancedMesh') {\n\t\t\t\tstate.setMatrix(_matrix4);\n\t\t\t} else {\n\t\t\t\t// Interpolate to new position\n\t\t\t\tstate.object.position.lerp(_position, interpolationAlpha);\n\t\t\t\tstate.object.quaternion.slerp(_rotation, interpolationAlpha);\n\t\t\t}\n\t\t});\n\n\t\teventQueue.drainCollisionEvents((handle1, handle2, started) => {\n\t\t\tconst source1 = this.getSourceFromColliderHandle(handle1);\n\t\t\tconst source2 = this.getSourceFromColliderHandle(handle2);\n\n\t\t\t// Collision Events\n\t\t\tif (!source1?.collider.object || !source2?.collider.object) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst collisionPayload1 = this.getCollisionPayloadFromSource(source1, source2);\n\t\t\tconst collisionPayload2 = this.getCollisionPayloadFromSource(source2, source1);\n\n\t\t\tif (started) {\n\t\t\t\tworld.contactPair(source1.collider.object, source2.collider.object, (manifold, flipped) => {\n\t\t\t\t\t/* RigidBody events */\n\t\t\t\t\tsource1.rigidBody.events?.onCollisionEnter?.({ ...collisionPayload1, manifold, flipped });\n\t\t\t\t\tsource2.rigidBody.events?.onCollisionEnter?.({ ...collisionPayload2, manifold, flipped });\n\n\t\t\t\t\t/* Collider events */\n\t\t\t\t\tsource1.collider.events?.onCollisionEnter?.({ ...collisionPayload1, manifold, flipped });\n\t\t\t\t\tsource2.collider.events?.onCollisionEnter?.({ ...collisionPayload2, manifold, flipped });\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tsource1.rigidBody.events?.onCollisionExit?.(collisionPayload1);\n\t\t\t\tsource2.rigidBody.events?.onCollisionExit?.(collisionPayload2);\n\t\t\t\tsource1.collider.events?.onCollisionExit?.(collisionPayload1);\n\t\t\t\tsource2.collider.events?.onCollisionExit?.(collisionPayload2);\n\t\t\t}\n\n\t\t\t// Sensor Intersections\n\t\t\tif (started) {\n\t\t\t\tif (world.intersectionPair(source1.collider.object, source2.collider.object)) {\n\t\t\t\t\tsource1.rigidBody.events?.onIntersectionEnter?.(collisionPayload1);\n\t\t\t\t\tsource2.rigidBody.events?.onIntersectionEnter?.(collisionPayload2);\n\t\t\t\t\tsource1.collider.events?.onIntersectionEnter?.(collisionPayload1);\n\t\t\t\t\tsource2.collider.events?.onIntersectionEnter?.(collisionPayload2);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tsource1.rigidBody.events?.onIntersectionExit?.(collisionPayload1);\n\t\t\t\tsource2.rigidBody.events?.onIntersectionExit?.(collisionPayload2);\n\t\t\t\tsource1.collider.events?.onIntersectionExit?.(collisionPayload1);\n\t\t\t\tsource2.collider.events?.onIntersectionExit?.(collisionPayload2);\n\t\t\t}\n\t\t});\n\n\t\teventQueue.drainContactForceEvents((event) => {\n\t\t\tconst source1 = this.getSourceFromColliderHandle(event.collider1());\n\t\t\tconst source2 = this.getSourceFromColliderHandle(event.collider2());\n\n\t\t\t// Collision Events\n\t\t\tif (!source1?.collider.object || !source2?.collider.object) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst collisionPayload1 = this.getCollisionPayloadFromSource(source1, source2);\n\t\t\tconst collisionPayload2 = this.getCollisionPayloadFromSource(source2, source1);\n\n\t\t\tsource1.rigidBody.events?.onContactForce?.({\n\t\t\t\t...collisionPayload1,\n\t\t\t\ttotalForce: event.totalForce(),\n\t\t\t\ttotalForceMagnitude: event.totalForceMagnitude(),\n\t\t\t\tmaxForceDirection: event.maxForceDirection(),\n\t\t\t\tmaxForceMagnitude: event.maxForceMagnitude(),\n\t\t\t});\n\n\t\t\tsource2.rigidBody.events?.onContactForce?.({\n\t\t\t\t...collisionPayload2,\n\t\t\t\ttotalForce: event.totalForce(),\n\t\t\t\ttotalForceMagnitude: event.totalForceMagnitude(),\n\t\t\t\tmaxForceDirection: event.maxForceDirection(),\n\t\t\t\tmaxForceMagnitude: event.maxForceMagnitude(),\n\t\t\t});\n\n\t\t\tsource1.collider.events?.onContactForce?.({\n\t\t\t\t...collisionPayload1,\n\t\t\t\ttotalForce: event.totalForce(),\n\t\t\t\ttotalForceMagnitude: event.totalForceMagnitude(),\n\t\t\t\tmaxForceDirection: event.maxForceDirection(),\n\t\t\t\tmaxForceMagnitude: event.maxForceMagnitude(),\n\t\t\t});\n\n\t\t\tsource2.collider.events?.onContactForce?.({\n\t\t\t\t...collisionPayload2,\n\t\t\t\ttotalForce: event.totalForce(),\n\t\t\t\ttotalForceMagnitude: event.totalForceMagnitude(),\n\t\t\t\tmaxForceDirection: event.maxForceDirection(),\n\t\t\t\tmaxForceMagnitude: event.maxForceMagnitude(),\n\t\t\t});\n\t\t});\n\n\t\tworld.forEachActiveRigidBody(() => {\n\t\t\tthis.store.snapshot.invalidate();\n\t\t});\n\t}\n\n\tprivate getSourceFromColliderHandle(handle: ColliderHandle) {\n\t\tconst world = this.worldSingleton();\n\t\tif (!world) return;\n\n\t\tconst collider = world.proxy.getCollider(handle);\n\t\tconst colEvents = this.colliderEvents.get(handle);\n\t\tconst colliderState = this.colliderStates.get(handle);\n\n\t\tconst rigidBodyHandle = collider.parent()?.handle;\n\t\tconst rigidBody = rigidBodyHandle !== undefined ? world.proxy.getRigidBody(rigidBodyHandle) : undefined;\n\t\tconst rigidBodyEvents =\n\t\t\trigidBody && rigidBodyHandle !== undefined ? this.rigidBodyEvents.get(rigidBodyHandle) : undefined;\n\t\tconst rigidBodyState = rigidBodyHandle !== undefined ? this.rigidBodyStates.get(rigidBodyHandle) : undefined;\n\n\t\treturn {\n\t\t\tcollider: { object: collider, events: colEvents, state: colliderState },\n\t\t\trigidBody: { object: rigidBody, events: rigidBodyEvents, state: rigidBodyState },\n\t\t} as NgtrCollisionSource;\n\t}\n\n\tprivate getCollisionPayloadFromSource(target: NgtrCollisionSource, other: NgtrCollisionSource): NgtrCollisionPayload {\n\t\treturn {\n\t\t\ttarget: {\n\t\t\t\trigidBody: target.rigidBody.object,\n\t\t\t\tcollider: target.collider.object,\n\t\t\t\tcolliderObject: target.collider.state?.object,\n\t\t\t\trigidBodyObject: target.rigidBody.state?.object,\n\t\t\t},\n\t\t\tother: {\n\t\t\t\trigidBody: other.rigidBody.object,\n\t\t\t\tcollider: other.collider.object,\n\t\t\t\tcolliderObject: other.collider.state?.object,\n\t\t\t\trigidBodyObject: other.rigidBody.state?.object,\n\t\t\t},\n\t\t};\n\t}\n}\n"]}