angular-three-rapier 2.2.0

package/esm2022/lib/rigid-body.mjs

@@ -0,0 +1,536 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, Directive, effect, ElementRef, inject, input, model, output, untracked, } from '@angular/core';
+import { ActiveEvents, ColliderDesc, RigidBodyDesc } from '@dimforge/rapier3d-compat';
+import { extend, getEmitter, getLocalState, hasListener, pick, } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Object3D, Vector3 } from 'three';
+import { NgtrPhysics } from './physics';
+import { _matrix4, _position, _rotation, _scale, _vector3 } from './shared';
+import { createColliderOptions } from './utils';
+import * as i0 from "@angular/core";
+const colliderDefaultOptions = {
+    contactSkin: 0,
+};
+export class NgtrAnyCollider {
+    position = input([0, 0, 0]);
+    rotation = input([0, 0, 0]);
+    scale = input([1, 1, 1]);
+    quaternion = input([0, 0, 0, 1]);
+    userData = input({});
+    name = input();
+    options = input(colliderDefaultOptions, { transform: mergeInputs(rigidBodyDefaultOptions) });
+    // TODO: change this to input required when Angular allows setting hostDirective input
+    shape = model(undefined, { alias: 'ngtrCollider' });
+    args = model([]);
+    collisionEnter = output();
+    collisionExit = output();
+    intersectionEnter = output();
+    intersectionExit = output();
+    contactForce = output();
+    sensor = pick(this.options, 'sensor');
+    collisionGroups = pick(this.options, 'collisionGroups');
+    solverGroups = pick(this.options, 'solverGroups');
+    friction = pick(this.options, 'friction');
+    frictionCombineRule = pick(this.options, 'frictionCombineRule');
+    restitution = pick(this.options, 'restitution');
+    restitutionCombineRule = pick(this.options, 'restitutionCombineRule');
+    activeCollisionTypes = pick(this.options, 'activeCollisionTypes');
+    contactSkin = pick(this.options, 'contactSkin');
+    mass = pick(this.options, 'mass');
+    massProperties = pick(this.options, 'massProperties');
+    density = pick(this.options, 'density');
+    rigidBody = inject(NgtrRigidBody, { optional: true });
+    physics = inject(NgtrPhysics);
+    objectRef = inject(ElementRef);
+    scaledArgs = computed(() => {
+        const [shape, args] = [
+            this.shape(),
+            this.args(),
+        ];
+        const cloned = args.slice();
+        // Heightfield uses a vector
+        if (shape === 'heightfield') {
+            const s = cloned[3];
+            s.x *= this.worldScale.x;
+            s.y *= this.worldScale.y;
+            s.z *= this.worldScale.z;
+            return cloned;
+        }
+        // Trimesh and convex scale the vertices
+        if (shape === 'trimesh' || shape === 'convexHull') {
+            cloned[0] = this.scaleVertices(cloned[0], this.worldScale);
+            return cloned;
+        }
+        // prefill with some extra
+        const scaleArray = [this.worldScale.x, this.worldScale.y, this.worldScale.z, this.worldScale.x, this.worldScale.x];
+        return cloned.map((arg, index) => scaleArray[index] * arg);
+    });
+    collider = computed(() => {
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return null;
+        const [shape, args, rigidBody] = [this.shape(), this.scaledArgs(), this.rigidBody?.rigidBody()];
+        // @ts-expect-error - we know the type of the data
+        const desc = ColliderDesc[shape](...args);
+        if (!desc)
+            return null;
+        return worldSingleton.proxy.createCollider(desc, rigidBody ?? undefined);
+    });
+    constructor() {
+        extend({ Object3D });
+        effect((onCleanup) => {
+            const cleanup = this.createColliderStateEffect();
+            onCleanup(() => cleanup?.());
+        });
+        effect((onCleanup) => {
+            const cleanup = this.createColliderEventsEffect();
+            onCleanup(() => cleanup?.());
+        });
+        effect(() => {
+            this.updateColliderEffect();
+            this.updateMassPropertiesEffect();
+        });
+    }
+    get worldScale() {
+        return this.objectRef.nativeElement.getWorldScale(new Vector3());
+    }
+    setShape(shape) {
+        this.shape.set(shape);
+    }
+    setArgs(args) {
+        this.args.set(args);
+    }
+    createColliderStateEffect() {
+        const collider = this.collider();
+        if (!collider)
+            return;
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return;
+        const state = this.createColliderState(collider, this.objectRef.nativeElement, this.rigidBody?.objectRef.nativeElement);
+        this.physics.colliderStates.set(collider.handle, state);
+        return () => {
+            this.physics.colliderStates.delete(collider.handle);
+            if (worldSingleton.proxy.getCollider(collider.handle)) {
+                worldSingleton.proxy.removeCollider(collider, true);
+            }
+        };
+    }
+    createColliderEventsEffect() {
+        const collider = this.collider();
+        if (!collider)
+            return;
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return;
+        const collisionEnter = getEmitter(this.collisionEnter);
+        const collisionExit = getEmitter(this.collisionExit);
+        const intersectionEnter = getEmitter(this.intersectionEnter);
+        const intersectionExit = getEmitter(this.intersectionExit);
+        const contactForce = getEmitter(this.contactForce);
+        const hasCollisionEvent = hasListener(this.collisionEnter, this.collisionExit, this.intersectionEnter, this.intersectionExit, this.rigidBody?.collisionEnter, this.rigidBody?.collisionExit, this.rigidBody?.intersectionEnter, this.rigidBody?.intersectionExit);
+        const hasContactForceEvent = hasListener(this.contactForce, this.rigidBody?.contactForce);
+        if (hasCollisionEvent && hasContactForceEvent) {
+            collider.setActiveEvents(ActiveEvents.COLLISION_EVENTS | ActiveEvents.CONTACT_FORCE_EVENTS);
+        }
+        else if (hasCollisionEvent) {
+            collider.setActiveEvents(ActiveEvents.COLLISION_EVENTS);
+        }
+        else if (hasContactForceEvent) {
+            collider.setActiveEvents(ActiveEvents.CONTACT_FORCE_EVENTS);
+        }
+        this.physics.colliderEvents.set(collider.handle, {
+            onCollisionEnter: collisionEnter,
+            onCollisionExit: collisionExit,
+            onIntersectionEnter: intersectionEnter,
+            onIntersectionExit: intersectionExit,
+            onContactForce: contactForce,
+        });
+        return () => {
+            this.physics.colliderEvents.delete(collider.handle);
+        };
+    }
+    updateColliderEffect() {
+        const collider = this.collider();
+        if (!collider)
+            return;
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return;
+        const state = this.physics.colliderStates.get(collider.handle);
+        if (!state)
+            return;
+        // Update collider position based on the object's position
+        const parentWorldScale = state.object.parent.getWorldScale(_vector3);
+        const parentInvertedWorldMatrix = state.worldParent?.matrixWorld.clone().invert();
+        state.object.updateWorldMatrix(true, false);
+        _matrix4.copy(state.object.matrixWorld);
+        if (parentInvertedWorldMatrix) {
+            _matrix4.premultiply(parentInvertedWorldMatrix);
+        }
+        _matrix4.decompose(_position, _rotation, _scale);
+        if (collider.parent()) {
+            collider.setTranslationWrtParent({
+                x: _position.x * parentWorldScale.x,
+                y: _position.y * parentWorldScale.y,
+                z: _position.z * parentWorldScale.z,
+            });
+            collider.setRotationWrtParent(_rotation);
+        }
+        else {
+            collider.setTranslation({
+                x: _position.x * parentWorldScale.x,
+                y: _position.y * parentWorldScale.y,
+                z: _position.z * parentWorldScale.z,
+            });
+            collider.setRotation(_rotation);
+        }
+        const [sensor, collisionGroups, solverGroups, friction, frictionCombineRule, restitution, restitutionCombineRule, activeCollisionTypes, contactSkin,] = [
+            this.sensor(),
+            this.collisionGroups(),
+            this.solverGroups(),
+            this.friction(),
+            this.frictionCombineRule(),
+            this.restitution(),
+            this.restitutionCombineRule(),
+            this.activeCollisionTypes(),
+            this.contactSkin(),
+        ];
+        if (sensor !== undefined)
+            collider.setSensor(sensor);
+        if (collisionGroups !== undefined)
+            collider.setCollisionGroups(collisionGroups);
+        if (solverGroups !== undefined)
+            collider.setSolverGroups(solverGroups);
+        if (friction !== undefined)
+            collider.setFriction(friction);
+        if (frictionCombineRule !== undefined)
+            collider.setFrictionCombineRule(frictionCombineRule);
+        if (restitution !== undefined)
+            collider.setRestitution(restitution);
+        if (restitutionCombineRule !== undefined)
+            collider.setRestitutionCombineRule(restitutionCombineRule);
+        if (activeCollisionTypes !== undefined)
+            collider.setActiveCollisionTypes(activeCollisionTypes);
+        if (contactSkin !== undefined)
+            collider.setContactSkin(contactSkin);
+    }
+    updateMassPropertiesEffect() {
+        const collider = this.collider();
+        if (!collider)
+            return;
+        const [mass, massProperties, density] = [this.mass(), this.massProperties(), this.density()];
+        if (density !== undefined) {
+            if (mass !== undefined || massProperties !== undefined) {
+                throw new Error('[NGT Rapier] Cannot set mass and massProperties along with density');
+            }
+            collider.setDensity(density);
+            return;
+        }
+        if (mass !== undefined) {
+            if (massProperties !== undefined) {
+                throw new Error('[NGT Rapier] Cannot set massProperties along with mass');
+            }
+            collider.setMass(mass);
+            return;
+        }
+        if (massProperties !== undefined) {
+            collider.setMassProperties(massProperties.mass, massProperties.centerOfMass, massProperties.principalAngularInertia, massProperties.angularInertiaLocalFrame);
+            return;
+        }
+    }
+    createColliderState(collider, object, rigidBodyObject) {
+        return { collider, worldParent: rigidBodyObject || undefined, object };
+    }
+    scaleVertices(vertices, scale) {
+        const scaledVerts = Array.from(vertices);
+        for (let i = 0; i < vertices.length / 3; i++) {
+            scaledVerts[i * 3] *= scale.x;
+            scaledVerts[i * 3 + 1] *= scale.y;
+            scaledVerts[i * 3 + 2] *= scale.z;
+        }
+        return scaledVerts;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrAnyCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrAnyCollider, isStandalone: true, selector: "ngt-object3D[ngtrCollider]", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, rotation: { classPropertyName: "rotation", publicName: "rotation", isSignal: true, isRequired: false, transformFunction: null }, scale: { classPropertyName: "scale", publicName: "scale", isSignal: true, isRequired: false, transformFunction: null }, quaternion: { classPropertyName: "quaternion", publicName: "quaternion", isSignal: true, isRequired: false, transformFunction: null }, userData: { classPropertyName: "userData", publicName: "userData", isSignal: true, isRequired: false, transformFunction: null }, name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null }, shape: { classPropertyName: "shape", publicName: "ngtrCollider", isSignal: true, isRequired: false, transformFunction: null }, args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { shape: "ngtrColliderChange", args: "argsChange", collisionEnter: "collisionEnter", collisionExit: "collisionExit", intersectionEnter: "intersectionEnter", intersectionExit: "intersectionExit", contactForce: "contactForce" }, host: { properties: { "position": "position()", "rotation": "rotation()", "scale": "scale()", "quaternion": "quaternion()", "userData": "userData()", "name": "name()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrAnyCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrCollider]',
+                    standalone: true,
+                    host: {
+                        '[position]': 'position()',
+                        '[rotation]': 'rotation()',
+                        '[scale]': 'scale()',
+                        '[quaternion]': 'quaternion()',
+                        '[userData]': 'userData()',
+                        '[name]': 'name()',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+const RIGID_BODY_TYPE_MAP = {
+    fixed: 1,
+    dynamic: 0,
+    kinematicPosition: 2,
+    kinematicVelocity: 3,
+};
+export const rigidBodyDefaultOptions = {
+    canSleep: true,
+    linearVelocity: [0, 0, 0],
+    angularVelocity: [0, 0, 0],
+    gravityScale: 1,
+    dominanceGroup: 0,
+    ccd: false,
+    softCcdPrediction: 0,
+    contactSkin: 0,
+};
+export class NgtrRigidBody {
+    type = input('dynamic', {
+        alias: 'ngtrRigidBody',
+        transform: (value) => {
+            if (value === '' || value === undefined)
+                return 'dynamic';
+            return value;
+        },
+    });
+    position = input([0, 0, 0]);
+    rotation = input([0, 0, 0]);
+    scale = input([1, 1, 1]);
+    quaternion = input([0, 0, 0, 1]);
+    userData = input({});
+    options = input(rigidBodyDefaultOptions, { transform: mergeInputs(rigidBodyDefaultOptions) });
+    wake = output();
+    sleep = output();
+    collisionEnter = output();
+    collisionExit = output();
+    intersectionEnter = output();
+    intersectionExit = output();
+    contactForce = output();
+    canSleep = pick(this.options, 'canSleep');
+    colliders = pick(this.options, 'colliders');
+    transformState = pick(this.options, 'transformState');
+    gravityScale = pick(this.options, 'gravityScale');
+    dominanceGroup = pick(this.options, 'dominanceGroup');
+    ccd = pick(this.options, 'ccd');
+    softCcdPrediction = pick(this.options, 'softCcdPrediction');
+    additionalSolverIterations = pick(this.options, 'additionalSolverIterations');
+    linearDamping = pick(this.options, 'linearDamping');
+    angularDamping = pick(this.options, 'angularDamping');
+    lockRotations = pick(this.options, 'lockRotations');
+    lockTranslations = pick(this.options, 'lockTranslations');
+    enabledRotations = pick(this.options, 'enabledRotations');
+    enabledTranslations = pick(this.options, 'enabledTranslations');
+    angularVelocity = pick(this.options, 'angularVelocity');
+    linearVelocity = pick(this.options, 'linearVelocity');
+    objectRef = inject(ElementRef);
+    physics = inject(NgtrPhysics);
+    bodyType = computed(() => RIGID_BODY_TYPE_MAP[this.type()]);
+    bodyDesc = computed(() => {
+        const [canSleep, bodyType] = [this.canSleep(), untracked(this.bodyType), this.colliders()];
+        return new RigidBodyDesc(bodyType).setCanSleep(canSleep);
+    });
+    rigidBody = computed(() => {
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return null;
+        return worldSingleton.proxy.createRigidBody(this.bodyDesc());
+    });
+    childColliderOptions = computed(() => {
+        const colliders = this.colliders();
+        // if self colliders is false explicitly, disable auto colliders for this object entirely.
+        if (colliders === false)
+            return [];
+        const physicsColliders = this.physics.colliders();
+        // if physics colliders is false explicitly, disable auto colliders for this object entirely.
+        if (physicsColliders === false)
+            return [];
+        const options = this.options();
+        // if colliders on object is not set, use physics colliders
+        if (!options.colliders)
+            options.colliders = physicsColliders;
+        const objectLocalState = getLocalState(this.objectRef.nativeElement);
+        // track object's children
+        objectLocalState?.nonObjects();
+        return createColliderOptions(this.objectRef.nativeElement, options, true);
+    });
+    constructor() {
+        extend({ Object3D });
+        effect((onCleanup) => {
+            const cleanup = this.createRigidBodyStateEffect();
+            onCleanup(() => cleanup?.());
+        });
+        effect((onCleanup) => {
+            const cleanup = this.createRigidBodyEventsEffect();
+            onCleanup(() => cleanup?.());
+        });
+        effect(() => {
+            this.updateRigidBodyEffect();
+        });
+    }
+    createRigidBodyStateEffect() {
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return;
+        const body = this.rigidBody();
+        if (!body)
+            return;
+        const transformState = untracked(this.transformState);
+        const state = this.createRigidBodyState(body, this.objectRef.nativeElement);
+        this.physics.rigidBodyStates.set(body.handle, transformState ? transformState(state) : state);
+        return () => {
+            this.physics.rigidBodyStates.delete(body.handle);
+            if (worldSingleton.proxy.getRigidBody(body.handle)) {
+                worldSingleton.proxy.removeRigidBody(body);
+            }
+        };
+    }
+    createRigidBodyEventsEffect() {
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return;
+        const body = this.rigidBody();
+        if (!body)
+            return;
+        const wake = getEmitter(this.wake);
+        const sleep = getEmitter(this.sleep);
+        const collisionEnter = getEmitter(this.collisionEnter);
+        const collisionExit = getEmitter(this.collisionExit);
+        const intersectionEnter = getEmitter(this.intersectionEnter);
+        const intersectionExit = getEmitter(this.intersectionExit);
+        const contactForce = getEmitter(this.contactForce);
+        this.physics.rigidBodyEvents.set(body.handle, {
+            onWake: wake,
+            onSleep: sleep,
+            onCollisionEnter: collisionEnter,
+            onCollisionExit: collisionExit,
+            onIntersectionEnter: intersectionEnter,
+            onIntersectionExit: intersectionExit,
+            onContactForce: contactForce,
+        });
+        return () => {
+            this.physics.rigidBodyEvents.delete(body.handle);
+        };
+    }
+    updateRigidBodyEffect() {
+        const worldSingleton = this.physics.worldSingleton();
+        if (!worldSingleton)
+            return;
+        const body = this.rigidBody();
+        if (!body)
+            return;
+        const state = this.physics.rigidBodyStates.get(body.handle);
+        if (!state)
+            return;
+        state.object.updateWorldMatrix(true, false);
+        _matrix4.copy(state.object.matrixWorld).decompose(_position, _rotation, _scale);
+        body.setTranslation(_position, true);
+        body.setRotation(_rotation, true);
+        const [gravityScale, additionalSolverIterations, linearDamping, angularDamping, lockRotations, lockTranslations, enabledRotations, enabledTranslations, angularVelocity, linearVelocity, ccd, softCcdPrediction, dominanceGroup, userData, bodyType,] = [
+            this.gravityScale(),
+            this.additionalSolverIterations(),
+            this.linearDamping(),
+            this.angularDamping(),
+            this.lockRotations(),
+            this.lockTranslations(),
+            this.enabledRotations(),
+            this.enabledTranslations(),
+            this.angularVelocity(),
+            this.linearVelocity(),
+            this.ccd(),
+            this.softCcdPrediction(),
+            this.dominanceGroup(),
+            this.userData(),
+            this.bodyType(),
+        ];
+        body.setGravityScale(gravityScale, true);
+        if (additionalSolverIterations !== undefined)
+            body.setAdditionalSolverIterations(additionalSolverIterations);
+        if (linearDamping !== undefined)
+            body.setLinearDamping(linearDamping);
+        if (angularDamping !== undefined)
+            body.setAngularDamping(angularDamping);
+        body.setDominanceGroup(dominanceGroup);
+        if (enabledRotations !== undefined)
+            body.setEnabledRotations(...enabledRotations, true);
+        if (enabledTranslations !== undefined)
+            body.setEnabledTranslations(...enabledTranslations, true);
+        if (lockRotations !== undefined)
+            body.lockRotations(lockRotations, true);
+        if (lockTranslations !== undefined)
+            body.lockTranslations(lockTranslations, true);
+        body.setAngvel({ x: angularVelocity[0], y: angularVelocity[1], z: angularVelocity[2] }, true);
+        body.setLinvel({ x: linearVelocity[0], y: linearVelocity[1], z: linearVelocity[2] }, true);
+        body.enableCcd(ccd);
+        body.setSoftCcdPrediction(softCcdPrediction);
+        if (userData !== undefined)
+            body.userData = userData;
+        if (bodyType !== body.bodyType())
+            body.setBodyType(bodyType, true);
+    }
+    createRigidBodyState(rigidBody, object, setMatrix, getMatrix, worldScale, meshType = 'mesh') {
+        object.updateWorldMatrix(true, false);
+        const invertedWorldMatrix = object.parent.matrixWorld.clone().invert();
+        return {
+            object,
+            rigidBody,
+            invertedWorldMatrix,
+            setMatrix: setMatrix
+                ? setMatrix
+                : (matrix) => {
+                    object.matrix.copy(matrix);
+                },
+            getMatrix: getMatrix ? getMatrix : (matrix) => matrix.copy(object.matrix),
+            scale: worldScale || object.getWorldScale(_scale).clone(),
+            isSleeping: false,
+            meshType,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRigidBody, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtrRigidBody, isStandalone: true, selector: "ngt-object3D[ngtrRigidBody]", inputs: { type: { classPropertyName: "type", publicName: "ngtrRigidBody", isSignal: true, isRequired: false, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, rotation: { classPropertyName: "rotation", publicName: "rotation", isSignal: true, isRequired: false, transformFunction: null }, scale: { classPropertyName: "scale", publicName: "scale", isSignal: true, isRequired: false, transformFunction: null }, quaternion: { classPropertyName: "quaternion", publicName: "quaternion", isSignal: true, isRequired: false, transformFunction: null }, userData: { classPropertyName: "userData", publicName: "userData", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { wake: "wake", sleep: "sleep", collisionEnter: "collisionEnter", collisionExit: "collisionExit", intersectionEnter: "intersectionEnter", intersectionExit: "intersectionExit", contactForce: "contactForce" }, host: { properties: { "position": "position()", "rotation": "rotation()", "scale": "scale()", "quaternion": "quaternion()", "userData": "userData()" } }, exportAs: ["rigidBody"], ngImport: i0, template: `
+		<ng-content />
+		@for (childColliderOption of childColliderOptions(); track $index) {
+			<ngt-object3D
+				[ngtrCollider]="childColliderOption.shape"
+				[args]="childColliderOption.args"
+				[position]="childColliderOption.position"
+				[rotation]="childColliderOption.rotation"
+				[scale]="childColliderOption.scale"
+				[name]="objectRef.nativeElement.name + '-collider-' + $index"
+				[options]="childColliderOption.colliderOptions"
+			/>
+		}
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtrAnyCollider, selector: "ngt-object3D[ngtrCollider]", inputs: ["position", "rotation", "scale", "quaternion", "userData", "name", "options", "ngtrCollider", "args"], outputs: ["ngtrColliderChange", "argsChange", "collisionEnter", "collisionExit", "intersectionEnter", "intersectionExit", "contactForce"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRigidBody, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-object3D[ngtrRigidBody]',
+                    exportAs: 'rigidBody',
+                    standalone: true,
+                    template: `
+		<ng-content />
+		@for (childColliderOption of childColliderOptions(); track $index) {
+			<ngt-object3D
+				[ngtrCollider]="childColliderOption.shape"
+				[args]="childColliderOption.args"
+				[position]="childColliderOption.position"
+				[rotation]="childColliderOption.rotation"
+				[scale]="childColliderOption.scale"
+				[name]="objectRef.nativeElement.name + '-collider-' + $index"
+				[options]="childColliderOption.colliderOptions"
+			/>
+		}
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[position]': 'position()',
+                        '[rotation]': 'rotation()',
+                        '[scale]': 'scale()',
+                        '[quaternion]': 'quaternion()',
+                        '[userData]': 'userData()',
+                    },
+                    imports: [NgtrAnyCollider],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rigid-body.js","sourceRoot":"","sources":["../../../../../libs/rapier/src/lib/rigid-body.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tDirective,\n\teffect,\n\tElementRef,\n\tinject,\n\tinput,\n\tmodel,\n\toutput,\n\tuntracked,\n} from '@angular/core';\nimport { ActiveEvents, Collider, ColliderDesc, RigidBody, RigidBodyDesc } from '@dimforge/rapier3d-compat';\nimport {\n\textend,\n\tgetEmitter,\n\tgetLocalState,\n\thasListener,\n\tNgtEuler,\n\tNgtObject3D,\n\tNgtQuaternion,\n\tNgtVector3,\n\tpick,\n} from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Matrix4, Object3D, Vector3 } from 'three';\nimport { NgtrPhysics } from './physics';\nimport { _matrix4, _position, _rotation, _scale, _vector3 } from './shared';\nimport {\n\tNgtrColliderOptions,\n\tNgtrColliderShape,\n\tNgtrColliderState,\n\tNgtrCollisionEnterPayload,\n\tNgtrCollisionExitPayload,\n\tNgtrContactForcePayload,\n\tNgtrIntersectionEnterPayload,\n\tNgtrIntersectionExitPayload,\n\tNgtrRigidBodyOptions,\n\tNgtrRigidBodyState,\n\tNgtrRigidBodyType,\n} from './types';\nimport { createColliderOptions } from './utils';\n\nconst colliderDefaultOptions: NgtrColliderOptions = {\n\tcontactSkin: 0,\n};\n\n@Directive({\n\tselector: 'ngt-object3D[ngtrCollider]',\n\tstandalone: true,\n\thost: {\n\t\t'[position]': 'position()',\n\t\t'[rotation]': 'rotation()',\n\t\t'[scale]': 'scale()',\n\t\t'[quaternion]': 'quaternion()',\n\t\t'[userData]': 'userData()',\n\t\t'[name]': 'name()',\n\t},\n})\nexport class NgtrAnyCollider {\n\tposition = input<NgtVector3 | undefined>([0, 0, 0]);\n\trotation = input<NgtEuler | undefined>([0, 0, 0]);\n\tscale = input<NgtVector3 | undefined>([1, 1, 1]);\n\tquaternion = input<NgtQuaternion | undefined>([0, 0, 0, 1]);\n\tuserData = input<NgtObject3D['userData'] | undefined>({});\n\tname = input<NgtObject3D['name'] | undefined>();\n\toptions = input(colliderDefaultOptions, { transform: mergeInputs(rigidBodyDefaultOptions) });\n\n\t// TODO: change this to input required when Angular allows setting hostDirective input\n\tshape = model<NgtrColliderShape | undefined>(undefined, { alias: 'ngtrCollider' });\n\targs = model<unknown[]>([]);\n\n\tcollisionEnter = output<NgtrCollisionEnterPayload>();\n\tcollisionExit = output<NgtrCollisionExitPayload>();\n\tintersectionEnter = output<NgtrIntersectionEnterPayload>();\n\tintersectionExit = output<NgtrIntersectionExitPayload>();\n\tcontactForce = output<NgtrContactForcePayload>();\n\n\tprivate sensor = pick(this.options, 'sensor');\n\tprivate collisionGroups = pick(this.options, 'collisionGroups');\n\tprivate solverGroups = pick(this.options, 'solverGroups');\n\tprivate friction = pick(this.options, 'friction');\n\tprivate frictionCombineRule = pick(this.options, 'frictionCombineRule');\n\tprivate restitution = pick(this.options, 'restitution');\n\tprivate restitutionCombineRule = pick(this.options, 'restitutionCombineRule');\n\tprivate activeCollisionTypes = pick(this.options, 'activeCollisionTypes');\n\tprivate contactSkin = pick(this.options, 'contactSkin');\n\tprivate mass = pick(this.options, 'mass');\n\tprivate massProperties = pick(this.options, 'massProperties');\n\tprivate density = pick(this.options, 'density');\n\n\tprivate rigidBody = inject(NgtrRigidBody, { optional: true });\n\tprivate physics = inject(NgtrPhysics);\n\tobjectRef = inject<ElementRef<Object3D>>(ElementRef);\n\n\tprivate scaledArgs = computed(() => {\n\t\tconst [shape, args] = [\n\t\t\tthis.shape(),\n\t\t\tthis.args() as (number | ArrayLike<number> | { x: number; y: number; z: number })[],\n\t\t];\n\n\t\tconst cloned = args.slice();\n\n\t\t// Heightfield uses a vector\n\t\tif (shape === 'heightfield') {\n\t\t\tconst s = cloned[3] as { x: number; y: number; z: number };\n\t\t\ts.x *= this.worldScale.x;\n\t\t\ts.y *= this.worldScale.y;\n\t\t\ts.z *= this.worldScale.z;\n\n\t\t\treturn cloned;\n\t\t}\n\n\t\t// Trimesh and convex scale the vertices\n\t\tif (shape === 'trimesh' || shape === 'convexHull') {\n\t\t\tcloned[0] = this.scaleVertices(cloned[0] as ArrayLike<number>, this.worldScale);\n\t\t\treturn cloned;\n\t\t}\n\n\t\t// prefill with some extra\n\t\tconst scaleArray = [this.worldScale.x, this.worldScale.y, this.worldScale.z, this.worldScale.x, this.worldScale.x];\n\t\treturn cloned.map((arg, index) => scaleArray[index] * (arg as number));\n\t});\n\n\tprivate collider = computed(() => {\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return null;\n\n\t\tconst [shape, args, rigidBody] = [this.shape(), this.scaledArgs(), this.rigidBody?.rigidBody()];\n\n\t\t// @ts-expect-error - we know the type of the data\n\t\tconst desc = ColliderDesc[shape](...args);\n\t\tif (!desc) return null;\n\n\t\treturn worldSingleton.proxy.createCollider(desc, rigidBody ?? undefined);\n\t});\n\n\tconstructor() {\n\t\textend({ Object3D });\n\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.createColliderStateEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.createColliderEventsEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\n\t\teffect(() => {\n\t\t\tthis.updateColliderEffect();\n\t\t\tthis.updateMassPropertiesEffect();\n\t\t});\n\t}\n\n\tget worldScale() {\n\t\treturn this.objectRef.nativeElement.getWorldScale(new Vector3());\n\t}\n\n\tsetShape(shape: NgtrColliderShape) {\n\t\tthis.shape.set(shape);\n\t}\n\n\tsetArgs(args: unknown[]) {\n\t\tthis.args.set(args);\n\t}\n\n\tprivate createColliderStateEffect() {\n\t\tconst collider = this.collider();\n\t\tif (!collider) return;\n\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return;\n\n\t\tconst state = this.createColliderState(\n\t\t\tcollider,\n\t\t\tthis.objectRef.nativeElement,\n\t\t\tthis.rigidBody?.objectRef.nativeElement,\n\t\t);\n\t\tthis.physics.colliderStates.set(collider.handle, state);\n\n\t\treturn () => {\n\t\t\tthis.physics.colliderStates.delete(collider.handle);\n\t\t\tif (worldSingleton.proxy.getCollider(collider.handle)) {\n\t\t\t\tworldSingleton.proxy.removeCollider(collider, true);\n\t\t\t}\n\t\t};\n\t}\n\n\tprivate createColliderEventsEffect() {\n\t\tconst collider = this.collider();\n\t\tif (!collider) return;\n\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return;\n\n\t\tconst collisionEnter = getEmitter(this.collisionEnter);\n\t\tconst collisionExit = getEmitter(this.collisionExit);\n\t\tconst intersectionEnter = getEmitter(this.intersectionEnter);\n\t\tconst intersectionExit = getEmitter(this.intersectionExit);\n\t\tconst contactForce = getEmitter(this.contactForce);\n\n\t\tconst hasCollisionEvent = hasListener(\n\t\t\tthis.collisionEnter,\n\t\t\tthis.collisionExit,\n\t\t\tthis.intersectionEnter,\n\t\t\tthis.intersectionExit,\n\t\t\tthis.rigidBody?.collisionEnter,\n\t\t\tthis.rigidBody?.collisionExit,\n\t\t\tthis.rigidBody?.intersectionEnter,\n\t\t\tthis.rigidBody?.intersectionExit,\n\t\t);\n\t\tconst hasContactForceEvent = hasListener(this.contactForce, this.rigidBody?.contactForce);\n\n\t\tif (hasCollisionEvent && hasContactForceEvent) {\n\t\t\tcollider.setActiveEvents(ActiveEvents.COLLISION_EVENTS | ActiveEvents.CONTACT_FORCE_EVENTS);\n\t\t} else if (hasCollisionEvent) {\n\t\t\tcollider.setActiveEvents(ActiveEvents.COLLISION_EVENTS);\n\t\t} else if (hasContactForceEvent) {\n\t\t\tcollider.setActiveEvents(ActiveEvents.CONTACT_FORCE_EVENTS);\n\t\t}\n\n\t\tthis.physics.colliderEvents.set(collider.handle, {\n\t\t\tonCollisionEnter: collisionEnter,\n\t\t\tonCollisionExit: collisionExit,\n\t\t\tonIntersectionEnter: intersectionEnter,\n\t\t\tonIntersectionExit: intersectionExit,\n\t\t\tonContactForce: contactForce,\n\t\t});\n\t\treturn () => {\n\t\t\tthis.physics.colliderEvents.delete(collider.handle);\n\t\t};\n\t}\n\n\tprivate updateColliderEffect() {\n\t\tconst collider = this.collider();\n\t\tif (!collider) return;\n\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return;\n\n\t\tconst state = this.physics.colliderStates.get(collider.handle);\n\t\tif (!state) return;\n\n\t\t// Update collider position based on the object's position\n\t\tconst parentWorldScale = state.object.parent!.getWorldScale(_vector3);\n\t\tconst parentInvertedWorldMatrix = state.worldParent?.matrixWorld.clone().invert();\n\n\t\tstate.object.updateWorldMatrix(true, false);\n\n\t\t_matrix4.copy(state.object.matrixWorld);\n\n\t\tif (parentInvertedWorldMatrix) {\n\t\t\t_matrix4.premultiply(parentInvertedWorldMatrix);\n\t\t}\n\n\t\t_matrix4.decompose(_position, _rotation, _scale);\n\n\t\tif (collider.parent()) {\n\t\t\tcollider.setTranslationWrtParent({\n\t\t\t\tx: _position.x * parentWorldScale.x,\n\t\t\t\ty: _position.y * parentWorldScale.y,\n\t\t\t\tz: _position.z * parentWorldScale.z,\n\t\t\t});\n\t\t\tcollider.setRotationWrtParent(_rotation);\n\t\t} else {\n\t\t\tcollider.setTranslation({\n\t\t\t\tx: _position.x * parentWorldScale.x,\n\t\t\t\ty: _position.y * parentWorldScale.y,\n\t\t\t\tz: _position.z * parentWorldScale.z,\n\t\t\t});\n\t\t\tcollider.setRotation(_rotation);\n\t\t}\n\n\t\tconst [\n\t\t\tsensor,\n\t\t\tcollisionGroups,\n\t\t\tsolverGroups,\n\t\t\tfriction,\n\t\t\tfrictionCombineRule,\n\t\t\trestitution,\n\t\t\trestitutionCombineRule,\n\t\t\tactiveCollisionTypes,\n\t\t\tcontactSkin,\n\t\t] = [\n\t\t\tthis.sensor(),\n\t\t\tthis.collisionGroups(),\n\t\t\tthis.solverGroups(),\n\t\t\tthis.friction(),\n\t\t\tthis.frictionCombineRule(),\n\t\t\tthis.restitution(),\n\t\t\tthis.restitutionCombineRule(),\n\t\t\tthis.activeCollisionTypes(),\n\t\t\tthis.contactSkin(),\n\t\t];\n\n\t\tif (sensor !== undefined) collider.setSensor(sensor);\n\t\tif (collisionGroups !== undefined) collider.setCollisionGroups(collisionGroups);\n\t\tif (solverGroups !== undefined) collider.setSolverGroups(solverGroups);\n\t\tif (friction !== undefined) collider.setFriction(friction);\n\t\tif (frictionCombineRule !== undefined) collider.setFrictionCombineRule(frictionCombineRule);\n\t\tif (restitution !== undefined) collider.setRestitution(restitution);\n\t\tif (restitutionCombineRule !== undefined) collider.setRestitutionCombineRule(restitutionCombineRule);\n\t\tif (activeCollisionTypes !== undefined) collider.setActiveCollisionTypes(activeCollisionTypes);\n\t\tif (contactSkin !== undefined) collider.setContactSkin(contactSkin);\n\t}\n\n\tprivate updateMassPropertiesEffect() {\n\t\tconst collider = this.collider();\n\t\tif (!collider) return;\n\n\t\tconst [mass, massProperties, density] = [this.mass(), this.massProperties(), this.density()];\n\n\t\tif (density !== undefined) {\n\t\t\tif (mass !== undefined || massProperties !== undefined) {\n\t\t\t\tthrow new Error('[NGT Rapier] Cannot set mass and massProperties along with density');\n\t\t\t}\n\n\t\t\tcollider.setDensity(density);\n\t\t\treturn;\n\t\t}\n\n\t\tif (mass !== undefined) {\n\t\t\tif (massProperties !== undefined) {\n\t\t\t\tthrow new Error('[NGT Rapier] Cannot set massProperties along with mass');\n\t\t\t}\n\t\t\tcollider.setMass(mass);\n\t\t\treturn;\n\t\t}\n\n\t\tif (massProperties !== undefined) {\n\t\t\tcollider.setMassProperties(\n\t\t\t\tmassProperties.mass,\n\t\t\t\tmassProperties.centerOfMass,\n\t\t\t\tmassProperties.principalAngularInertia,\n\t\t\t\tmassProperties.angularInertiaLocalFrame,\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\t}\n\n\tprivate createColliderState(\n\t\tcollider: Collider,\n\t\tobject: Object3D,\n\t\trigidBodyObject?: Object3D | null,\n\t): NgtrColliderState {\n\t\treturn { collider, worldParent: rigidBodyObject || undefined, object };\n\t}\n\n\tprivate scaleVertices(vertices: ArrayLike<number>, scale: Vector3) {\n\t\tconst scaledVerts = Array.from(vertices);\n\n\t\tfor (let i = 0; i < vertices.length / 3; i++) {\n\t\t\tscaledVerts[i * 3] *= scale.x;\n\t\t\tscaledVerts[i * 3 + 1] *= scale.y;\n\t\t\tscaledVerts[i * 3 + 2] *= scale.z;\n\t\t}\n\n\t\treturn scaledVerts;\n\t}\n}\n\nconst RIGID_BODY_TYPE_MAP: Record<NgtrRigidBodyType, number> = {\n\tfixed: 1,\n\tdynamic: 0,\n\tkinematicPosition: 2,\n\tkinematicVelocity: 3,\n};\n\nexport const rigidBodyDefaultOptions: NgtrRigidBodyOptions = {\n\tcanSleep: true,\n\tlinearVelocity: [0, 0, 0],\n\tangularVelocity: [0, 0, 0],\n\tgravityScale: 1,\n\tdominanceGroup: 0,\n\tccd: false,\n\tsoftCcdPrediction: 0,\n\tcontactSkin: 0,\n};\n\n@Component({\n\tselector: 'ngt-object3D[ngtrRigidBody]',\n\texportAs: 'rigidBody',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ng-content />\n\t\t@for (childColliderOption of childColliderOptions(); track $index) {\n\t\t\t<ngt-object3D\n\t\t\t\t[ngtrCollider]=\"childColliderOption.shape\"\n\t\t\t\t[args]=\"childColliderOption.args\"\n\t\t\t\t[position]=\"childColliderOption.position\"\n\t\t\t\t[rotation]=\"childColliderOption.rotation\"\n\t\t\t\t[scale]=\"childColliderOption.scale\"\n\t\t\t\t[name]=\"objectRef.nativeElement.name + '-collider-' + $index\"\n\t\t\t\t[options]=\"childColliderOption.colliderOptions\"\n\t\t\t/>\n\t\t}\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\thost: {\n\t\t'[position]': 'position()',\n\t\t'[rotation]': 'rotation()',\n\t\t'[scale]': 'scale()',\n\t\t'[quaternion]': 'quaternion()',\n\t\t'[userData]': 'userData()',\n\t},\n\timports: [NgtrAnyCollider],\n})\nexport class NgtrRigidBody {\n\ttype = input('dynamic', {\n\t\talias: 'ngtrRigidBody',\n\t\ttransform: (value: NgtrRigidBodyType | '' | undefined) => {\n\t\t\tif (value === '' || value === undefined) return 'dynamic' as NgtrRigidBodyType;\n\t\t\treturn value;\n\t\t},\n\t});\n\tposition = input<NgtVector3 | undefined>([0, 0, 0]);\n\trotation = input<NgtEuler | undefined>([0, 0, 0]);\n\tscale = input<NgtVector3 | undefined>([1, 1, 1]);\n\tquaternion = input<NgtQuaternion | undefined>([0, 0, 0, 1]);\n\tuserData = input<NgtObject3D['userData'] | undefined>({});\n\toptions = input(rigidBodyDefaultOptions, { transform: mergeInputs(rigidBodyDefaultOptions) });\n\n\twake = output<void>();\n\tsleep = output<void>();\n\tcollisionEnter = output<NgtrCollisionEnterPayload>();\n\tcollisionExit = output<NgtrCollisionExitPayload>();\n\tintersectionEnter = output<NgtrIntersectionEnterPayload>();\n\tintersectionExit = output<NgtrIntersectionExitPayload>();\n\tcontactForce = output<NgtrContactForcePayload>();\n\n\tprivate canSleep = pick(this.options, 'canSleep');\n\tprivate colliders = pick(this.options, 'colliders');\n\tprivate transformState = pick(this.options, 'transformState');\n\tprivate gravityScale = pick(this.options, 'gravityScale');\n\tprivate dominanceGroup = pick(this.options, 'dominanceGroup');\n\tprivate ccd = pick(this.options, 'ccd');\n\tprivate softCcdPrediction = pick(this.options, 'softCcdPrediction');\n\tprivate additionalSolverIterations = pick(this.options, 'additionalSolverIterations');\n\tprivate linearDamping = pick(this.options, 'linearDamping');\n\tprivate angularDamping = pick(this.options, 'angularDamping');\n\tprivate lockRotations = pick(this.options, 'lockRotations');\n\tprivate lockTranslations = pick(this.options, 'lockTranslations');\n\tprivate enabledRotations = pick(this.options, 'enabledRotations');\n\tprivate enabledTranslations = pick(this.options, 'enabledTranslations');\n\tprivate angularVelocity = pick(this.options, 'angularVelocity');\n\tprivate linearVelocity = pick(this.options, 'linearVelocity');\n\n\tobjectRef = inject<ElementRef<Object3D>>(ElementRef);\n\tprivate physics = inject(NgtrPhysics);\n\n\tprivate bodyType = computed(() => RIGID_BODY_TYPE_MAP[this.type()]);\n\tprivate bodyDesc = computed(() => {\n\t\tconst [canSleep, bodyType] = [this.canSleep(), untracked(this.bodyType), this.colliders()];\n\t\treturn new RigidBodyDesc(bodyType).setCanSleep(canSleep);\n\t});\n\trigidBody = computed(() => {\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return null;\n\t\treturn worldSingleton.proxy.createRigidBody(this.bodyDesc());\n\t});\n\n\tprotected childColliderOptions = computed(() => {\n\t\tconst colliders = this.colliders();\n\t\t// if self colliders is false explicitly, disable auto colliders for this object entirely.\n\t\tif (colliders === false) return [];\n\n\t\tconst physicsColliders = this.physics.colliders();\n\t\t// if physics colliders is false explicitly, disable auto colliders for this object entirely.\n\t\tif (physicsColliders === false) return [];\n\n\t\tconst options = this.options();\n\t\t// if colliders on object is not set, use physics colliders\n\t\tif (!options.colliders) options.colliders = physicsColliders;\n\n\t\tconst objectLocalState = getLocalState(this.objectRef.nativeElement);\n\t\t// track object's children\n\t\tobjectLocalState?.nonObjects();\n\n\t\treturn createColliderOptions(this.objectRef.nativeElement, options, true);\n\t});\n\n\tconstructor() {\n\t\textend({ Object3D });\n\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.createRigidBodyStateEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\n\t\teffect((onCleanup) => {\n\t\t\tconst cleanup = this.createRigidBodyEventsEffect();\n\t\t\tonCleanup(() => cleanup?.());\n\t\t});\n\n\t\teffect(() => {\n\t\t\tthis.updateRigidBodyEffect();\n\t\t});\n\t}\n\n\tprivate createRigidBodyStateEffect() {\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return;\n\n\t\tconst body = this.rigidBody();\n\t\tif (!body) return;\n\n\t\tconst transformState = untracked(this.transformState);\n\n\t\tconst state = this.createRigidBodyState(body, this.objectRef.nativeElement);\n\t\tthis.physics.rigidBodyStates.set(body.handle, transformState ? transformState(state) : state);\n\n\t\treturn () => {\n\t\t\tthis.physics.rigidBodyStates.delete(body.handle);\n\t\t\tif (worldSingleton.proxy.getRigidBody(body.handle)) {\n\t\t\t\tworldSingleton.proxy.removeRigidBody(body);\n\t\t\t}\n\t\t};\n\t}\n\n\tprivate createRigidBodyEventsEffect() {\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return;\n\n\t\tconst body = this.rigidBody();\n\t\tif (!body) return;\n\n\t\tconst wake = getEmitter(this.wake);\n\t\tconst sleep = getEmitter(this.sleep);\n\t\tconst collisionEnter = getEmitter(this.collisionEnter);\n\t\tconst collisionExit = getEmitter(this.collisionExit);\n\t\tconst intersectionEnter = getEmitter(this.intersectionEnter);\n\t\tconst intersectionExit = getEmitter(this.intersectionExit);\n\t\tconst contactForce = getEmitter(this.contactForce);\n\n\t\tthis.physics.rigidBodyEvents.set(body.handle, {\n\t\t\tonWake: wake,\n\t\t\tonSleep: sleep,\n\t\t\tonCollisionEnter: collisionEnter,\n\t\t\tonCollisionExit: collisionExit,\n\t\t\tonIntersectionEnter: intersectionEnter,\n\t\t\tonIntersectionExit: intersectionExit,\n\t\t\tonContactForce: contactForce,\n\t\t});\n\n\t\treturn () => {\n\t\t\tthis.physics.rigidBodyEvents.delete(body.handle);\n\t\t};\n\t}\n\n\tprivate updateRigidBodyEffect() {\n\t\tconst worldSingleton = this.physics.worldSingleton();\n\t\tif (!worldSingleton) return;\n\n\t\tconst body = this.rigidBody();\n\t\tif (!body) return;\n\n\t\tconst state = this.physics.rigidBodyStates.get(body.handle);\n\t\tif (!state) return;\n\n\t\tstate.object.updateWorldMatrix(true, false);\n\t\t_matrix4.copy(state.object.matrixWorld).decompose(_position, _rotation, _scale);\n\t\tbody.setTranslation(_position, true);\n\t\tbody.setRotation(_rotation, true);\n\n\t\tconst [\n\t\t\tgravityScale,\n\t\t\tadditionalSolverIterations,\n\t\t\tlinearDamping,\n\t\t\tangularDamping,\n\t\t\tlockRotations,\n\t\t\tlockTranslations,\n\t\t\tenabledRotations,\n\t\t\tenabledTranslations,\n\t\t\tangularVelocity,\n\t\t\tlinearVelocity,\n\t\t\tccd,\n\t\t\tsoftCcdPrediction,\n\t\t\tdominanceGroup,\n\t\t\tuserData,\n\t\t\tbodyType,\n\t\t] = [\n\t\t\tthis.gravityScale(),\n\t\t\tthis.additionalSolverIterations(),\n\t\t\tthis.linearDamping(),\n\t\t\tthis.angularDamping(),\n\t\t\tthis.lockRotations(),\n\t\t\tthis.lockTranslations(),\n\t\t\tthis.enabledRotations(),\n\t\t\tthis.enabledTranslations(),\n\t\t\tthis.angularVelocity(),\n\t\t\tthis.linearVelocity(),\n\t\t\tthis.ccd(),\n\t\t\tthis.softCcdPrediction(),\n\t\t\tthis.dominanceGroup(),\n\t\t\tthis.userData(),\n\t\t\tthis.bodyType(),\n\t\t];\n\n\t\tbody.setGravityScale(gravityScale, true);\n\t\tif (additionalSolverIterations !== undefined) body.setAdditionalSolverIterations(additionalSolverIterations);\n\t\tif (linearDamping !== undefined) body.setLinearDamping(linearDamping);\n\t\tif (angularDamping !== undefined) body.setAngularDamping(angularDamping);\n\t\tbody.setDominanceGroup(dominanceGroup);\n\t\tif (enabledRotations !== undefined) body.setEnabledRotations(...enabledRotations, true);\n\t\tif (enabledTranslations !== undefined) body.setEnabledTranslations(...enabledTranslations, true);\n\t\tif (lockRotations !== undefined) body.lockRotations(lockRotations, true);\n\t\tif (lockTranslations !== undefined) body.lockTranslations(lockTranslations, true);\n\t\tbody.setAngvel({ x: angularVelocity[0], y: angularVelocity[1], z: angularVelocity[2] }, true);\n\t\tbody.setLinvel({ x: linearVelocity[0], y: linearVelocity[1], z: linearVelocity[2] }, true);\n\t\tbody.enableCcd(ccd);\n\t\tbody.setSoftCcdPrediction(softCcdPrediction);\n\t\tif (userData !== undefined) body.userData = userData;\n\t\tif (bodyType !== body.bodyType()) body.setBodyType(bodyType, true);\n\t}\n\n\tprivate createRigidBodyState(\n\t\trigidBody: RigidBody,\n\t\tobject: Object3D,\n\t\tsetMatrix?: (matrix: Matrix4) => void,\n\t\tgetMatrix?: (matrix: Matrix4) => Matrix4,\n\t\tworldScale?: Vector3,\n\t\tmeshType: NgtrRigidBodyState['meshType'] = 'mesh',\n\t) {\n\t\tobject.updateWorldMatrix(true, false);\n\t\tconst invertedWorldMatrix = object.parent!.matrixWorld.clone().invert();\n\t\treturn {\n\t\t\tobject,\n\t\t\trigidBody,\n\t\t\tinvertedWorldMatrix,\n\t\t\tsetMatrix: setMatrix\n\t\t\t\t? setMatrix\n\t\t\t\t: (matrix: Matrix4) => {\n\t\t\t\t\t\tobject.matrix.copy(matrix);\n\t\t\t\t\t},\n\t\t\tgetMatrix: getMatrix ? getMatrix : (matrix: Matrix4) => matrix.copy(object.matrix),\n\t\t\tscale: worldScale || object.getWorldScale(_scale).clone(),\n\t\t\tisSleeping: false,\n\t\t\tmeshType,\n\t\t};\n\t}\n}\n"]}