angular-three-rapier 2.2.0

package/fesm2022/angular-three-rapier.mjs

@@ -0,0 +1,1831 @@
+import * as i0 from '@angular/core';
+import { input, viewChild, Component, CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, afterNextRender, Directive, inject, DestroyRef, signal, computed, untracked, effect, model, output, ElementRef, viewChildren } from '@angular/core';
+import { Vector3 as Vector3$1, Quaternion as Quaternion$1, EventQueue, ColliderDesc, ActiveEvents, RigidBodyDesc } from '@dimforge/rapier3d-compat';
+import { extend, injectBeforeRender, pick, vector3, injectStore, getEmitter, hasListener, getLocalState, resolveRef } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, LineSegments, LineBasicMaterial, BufferAttribute, Quaternion, Euler, Vector3, Object3D, Matrix4, MathUtils, DynamicDrawUsage } from 'three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeVertices } from 'three-stdlib';
+import { assertInjector } from 'ngxtension/assert-injector';
+
+class NgtrDebug {
+    world = input.required();
+    lineSegmentsRef = viewChild.required('lineSegments');
+    constructor() {
+        extend({ Group, LineSegments, LineBasicMaterial, BufferAttribute });
+        injectBeforeRender(() => {
+            const [world, lineSegments] = [this.world(), this.lineSegmentsRef().nativeElement];
+            if (!world || !lineSegments)
+                return;
+            const buffers = world.debugRender();
+            lineSegments.geometry.setAttribute('position', new BufferAttribute(buffers.vertices, 3));
+            lineSegments.geometry.setAttribute('color', new BufferAttribute(buffers.colors, 4));
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrDebug, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtrDebug, isStandalone: true, selector: "ngtr-debug", inputs: { world: { classPropertyName: "world", publicName: "world", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "lineSegmentsRef", first: true, predicate: ["lineSegments"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group>
+			<ngt-line-segments #lineSegments [frustumCulled]="false">
+				<ngt-line-basic-material color="white" [vertexColors]="true" />
+				<ngt-buffer-geometry />
+			</ngt-line-segments>
+		</ngt-group>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrDebug, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtr-debug',
+                    standalone: true,
+                    template: `
+		<ngt-group>
+			<ngt-line-segments #lineSegments [frustumCulled]="false">
+				<ngt-line-basic-material color="white" [vertexColors]="true" />
+				<ngt-buffer-geometry />
+			</ngt-line-segments>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+
+class NgtrFrameStepper {
+    ready = input(false);
+    updatePriority = input(0);
+    stepFn = input.required();
+    type = input.required();
+    constructor() {
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect((injector) => {
+                const ready = this.ready();
+                if (!ready)
+                    return;
+                const [type, updatePriority, stepFn] = [this.type(), this.updatePriority(), this.stepFn()];
+                if (type === 'follow') {
+                    return injectBeforeRender(({ delta }) => {
+                        stepFn(delta);
+                    }, { priority: updatePriority, injector });
+                }
+                let lastFrame = 0;
+                let raf = 0;
+                const loop = () => {
+                    const now = performance.now();
+                    const delta = now - lastFrame;
+                    raf = requestAnimationFrame(loop);
+                    stepFn(delta);
+                    lastFrame = now;
+                };
+                raf = requestAnimationFrame(loop);
+                return () => {
+                    cancelAnimationFrame(raf);
+                };
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrFrameStepper, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrFrameStepper, isStandalone: true, selector: "ngtr-frame-stepper", inputs: { ready: { classPropertyName: "ready", publicName: "ready", isSignal: true, isRequired: false, transformFunction: null }, updatePriority: { classPropertyName: "updatePriority", publicName: "updatePriority", isSignal: true, isRequired: false, transformFunction: null }, stepFn: { classPropertyName: "stepFn", publicName: "stepFn", isSignal: true, isRequired: true, transformFunction: null }, type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrFrameStepper, decorators: [{
+            type: Directive,
+            args: [{ standalone: true, selector: 'ngtr-frame-stepper' }]
+        }], ctorParameters: () => [] });
+
+const _quaternion = new Quaternion();
+const _euler = new Euler();
+const _vector3 = new Vector3();
+const _object3d = new Object3D();
+const _matrix4 = new Matrix4();
+const _position = new Vector3();
+const _rotation = new Quaternion();
+const _scale = new Vector3();
+
+/**
+ * Creates a proxy that will create a singleton instance of the given class
+ * when a property is accessed, and not before.
+ *
+ * @returns A proxy and a reset function, so that the instance can created again
+ */
+const createSingletonProxy = (
+/**
+ * A function that returns a new instance of the class
+ */
+createInstance) => {
+    let instance;
+    const handler = {
+        get(target, prop) {
+            if (!instance) {
+                instance = createInstance();
+            }
+            return Reflect.get(instance, prop);
+        },
+        set(target, prop, value) {
+            if (!instance) {
+                instance = createInstance();
+            }
+            return Reflect.set(instance, prop, value);
+        },
+    };
+    const proxy = new Proxy({}, handler);
+    const reset = () => {
+        instance = undefined;
+    };
+    const set = (newInstance) => {
+        instance = newInstance;
+    };
+    /**
+     * Return the proxy and a reset function
+     */
+    return { proxy, reset, set };
+};
+function rapierQuaternionToQuaternion({ x, y, z, w }) {
+    return _quaternion.set(x, y, z, w);
+}
+function vector3ToRapierVector(v) {
+    if (Array.isArray(v)) {
+        return new Vector3$1(v[0], v[1], v[2]);
+    }
+    if (typeof v === 'number') {
+        return new Vector3$1(v, v, v);
+    }
+    const vector = v;
+    return new Vector3$1(vector.x, vector.y, vector.z);
+}
+function quaternionToRapierQuaternion(v) {
+    if (Array.isArray(v)) {
+        return new Quaternion$1(v[0], v[1], v[2], v[3]);
+    }
+    return new Quaternion$1(v.x, v.y, v.z, v.w);
+}
+function isChildOfMeshCollider(child) {
+    let flag = false;
+    child.traverseAncestors((a) => {
+        if (a.userData['ngtRapierType'] === 'MeshCollider')
+            flag = true;
+    });
+    return flag;
+}
+const autoColliderMap = {
+    cuboid: 'cuboid',
+    ball: 'ball',
+    hull: 'convexHull',
+    trimesh: 'trimesh',
+};
+function getColliderArgsFromGeometry(geometry, colliders) {
+    switch (colliders) {
+        case 'cuboid': {
+            geometry.computeBoundingBox();
+            const { boundingBox } = geometry;
+            const size = boundingBox.getSize(new Vector3());
+            return {
+                args: [size.x / 2, size.y / 2, size.z / 2],
+                offset: boundingBox.getCenter(new Vector3()),
+            };
+        }
+        case 'ball': {
+            geometry.computeBoundingSphere();
+            const { boundingSphere } = geometry;
+            const radius = boundingSphere.radius;
+            return {
+                args: [radius],
+                offset: boundingSphere.center,
+            };
+        }
+        case 'trimesh': {
+            const clonedGeometry = geometry.index ? geometry.clone() : mergeVertices(geometry);
+            return {
+                args: [clonedGeometry.attributes['position'].array, clonedGeometry.index?.array],
+                offset: new Vector3(),
+            };
+        }
+        case 'hull': {
+            const clonedGeometry = geometry.clone();
+            return {
+                args: [clonedGeometry.attributes['position'].array],
+                offset: new Vector3(),
+            };
+        }
+    }
+    return { args: [], offset: new Vector3() };
+}
+function createColliderOptions(object, options, ignoreMeshColliders = true) {
+    const childColliderOptions = [];
+    object.updateWorldMatrix(true, false);
+    const invertedParentMatrixWorld = object.matrixWorld.clone().invert();
+    const colliderFromChild = (child) => {
+        if (child.isMesh) {
+            if (ignoreMeshColliders && isChildOfMeshCollider(child))
+                return;
+            const worldScale = child.getWorldScale(_scale);
+            const shape = autoColliderMap[options.colliders || 'cuboid'];
+            child.updateWorldMatrix(true, false);
+            _matrix4.copy(child.matrixWorld).premultiply(invertedParentMatrixWorld).decompose(_position, _rotation, _scale);
+            const rotationEuler = new Euler().setFromQuaternion(_rotation, 'XYZ');
+            const { geometry } = child;
+            const { args, offset } = getColliderArgsFromGeometry(geometry, options.colliders || 'cuboid');
+            const { mass, linearDamping, angularDamping, canSleep, ccd, gravityScale, softCcdPrediction, ...rest } = options;
+            childColliderOptions.push({
+                colliderOptions: rest,
+                args,
+                shape,
+                rotation: [rotationEuler.x, rotationEuler.y, rotationEuler.z],
+                position: [
+                    _position.x + offset.x * worldScale.x,
+                    _position.y + offset.y * worldScale.y,
+                    _position.z + offset.z * worldScale.z,
+                ],
+                scale: [worldScale.x, worldScale.y, worldScale.z],
+            });
+        }
+    };
+    if (options.includeInvisible) {
+        object.traverse(colliderFromChild);
+    }
+    else {
+        object.traverseVisible(colliderFromChild);
+    }
+    return childColliderOptions;
+}
+
+const defaultOptions$1 = {
+    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,
+};
+class NgtrPhysics {
+    options = input(defaultOptions$1, { transform: mergeInputs(defaultOptions$1) });
+    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: () => [] });
+
+const colliderDefaultOptions = {
+    contactSkin: 0,
+};
+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,
+};
+const rigidBodyDefaultOptions = {
+    canSleep: true,
+    linearVelocity: [0, 0, 0],
+    angularVelocity: [0, 0, 0],
+    gravityScale: 1,
+    dominanceGroup: 0,
+    ccd: false,
+    softCcdPrediction: 0,
+    contactSkin: 0,
+};
+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: () => [] });
+
+const ANY_COLLIDER_HOST_DIRECTIVE = {
+    directive: NgtrAnyCollider,
+    inputs: ['options', 'name', 'scale', 'position', 'quaternion', 'rotation', 'userData'],
+    outputs: ['collisionEnter', 'collisionExit', 'intersectionEnter', 'intersectionExit', 'contactForce'],
+};
+class NgtrCuboidCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('cuboid');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrCuboidCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrCuboidCollider, isStandalone: true, selector: "ngt-object3D[ngtrCuboidCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrCuboidCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrCuboidCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrCapsuleCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('capsule');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrCapsuleCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrCapsuleCollider, isStandalone: true, selector: "ngt-object3D[ngtrCapsuleCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrCapsuleCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrCapsuleCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrBallCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('ball');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrBallCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrBallCollider, isStandalone: true, selector: "ngt-object3D[ngtrBallCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrBallCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrBallCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrConvexHullCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('roundConvexHull');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrConvexHullCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrConvexHullCollider, isStandalone: true, selector: "ngt-object3D[ngtrConvexHullCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrConvexHullCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrConvexHullCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrHeightfieldCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('heightfield');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrHeightfieldCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrHeightfieldCollider, isStandalone: true, selector: "ngt-object3D[ngtrHeightfieldCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrHeightfieldCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrHeightfieldCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrTrimeshCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('trimesh');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrTrimeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrTrimeshCollider, isStandalone: true, selector: "ngt-object3D[ngtrTrimeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrTrimeshCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrTrimeshCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrPolylineCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('polyline');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrPolylineCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrPolylineCollider, isStandalone: true, selector: "ngt-object3D[ngtrPolylineCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrPolylineCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrPolylineCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrRoundCuboidCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('roundCuboid');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundCuboidCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrRoundCuboidCollider, isStandalone: true, selector: "ngt-object3D[ngtrRoundCuboidCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundCuboidCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrRoundCuboidCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrCylinderCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('cylinder');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrCylinderCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrCylinderCollider, isStandalone: true, selector: "ngt-object3D[ngtrCylinderCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrCylinderCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrCylinderCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrRoundCylinderCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('roundCylinder');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundCylinderCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrRoundCylinderCollider, isStandalone: true, selector: "ngt-object3D[ngtrRoundCylinderCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundCylinderCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrRoundCylinderCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrConeCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('cone');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrConeCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrConeCollider, isStandalone: true, selector: "ngt-object3D[ngtrConeCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrConeCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrConeCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrRoundConeCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('roundCone');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundConeCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrRoundConeCollider, isStandalone: true, selector: "ngt-object3D[ngtrRoundConeCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundConeCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrRoundConeCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrConvexMeshCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('convexMesh');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrConvexMeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrConvexMeshCollider, isStandalone: true, selector: "ngt-object3D[ngtrConvexMeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrConvexMeshCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrConvexMeshCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrRoundConvexHullCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('roundConvexHull');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundConvexHullCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrRoundConvexHullCollider, isStandalone: true, selector: "ngt-object3D[ngtrRoundConvexHullCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundConvexHullCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrRoundConvexHullCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+class NgtrRoundConvexMeshCollider {
+    args = input.required();
+    constructor() {
+        const anyCollider = inject(NgtrAnyCollider, { host: true });
+        anyCollider.setShape('roundConvexMesh');
+        effect(() => {
+            const args = this.args();
+            untracked(() => {
+                anyCollider.setArgs(args);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundConvexMeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.0", type: NgtrRoundConvexMeshCollider, isStandalone: true, selector: "ngt-object3D[ngtrRoundConvexMeshCollider]", inputs: { args: { classPropertyName: "args", publicName: "args", isSignal: true, isRequired: true, transformFunction: null } }, hostDirectives: [{ directive: NgtrAnyCollider, inputs: ["options", "options", "name", "name", "scale", "scale", "position", "position", "quaternion", "quaternion", "rotation", "rotation", "userData", "userData"], outputs: ["collisionEnter", "collisionEnter", "collisionExit", "collisionExit", "intersectionEnter", "intersectionEnter", "intersectionExit", "intersectionExit", "contactForce", "contactForce"] }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrRoundConvexMeshCollider, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ngt-object3D[ngtrRoundConvexMeshCollider]',
+                    standalone: true,
+                    hostDirectives: [ANY_COLLIDER_HOST_DIRECTIVE],
+                }]
+        }], ctorParameters: () => [] });
+
+const defaultOptions = rigidBodyDefaultOptions;
+class NgtrInstancedRigidBodies {
+    position = input([0, 0, 0]);
+    rotation = input([0, 0, 0]);
+    scale = input([1, 1, 1]);
+    quaternion = input([0, 0, 0, 1]);
+    userData = input({});
+    instances = input([], {
+        alias: 'ngtrInstancedRigidBodies',
+        transform: (value) => {
+            if (value === '')
+                return [];
+            return value;
+        },
+    });
+    options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+    instanceWrapperRef = viewChild.required('instanceWrapper');
+    rigidBodyRefs = viewChildren(NgtrRigidBody);
+    physics = inject(NgtrPhysics);
+    objectRef = inject(ElementRef);
+    colliders = pick(this.options, 'colliders');
+    instancedMesh = computed(() => {
+        const instanceWrapper = this.instanceWrapperRef().nativeElement;
+        if (!instanceWrapper)
+            return null;
+        const localState = getLocalState(instanceWrapper);
+        if (!localState)
+            return null;
+        // track object's children
+        localState.objects();
+        const firstChild = instanceWrapper.children[0];
+        if (!firstChild || !firstChild.isInstancedMesh)
+            return null;
+        return firstChild;
+    });
+    instancesOptions = computed(() => {
+        const [instances, options, instancedMesh] = [this.instances(), untracked(this.options), this.instancedMesh()];
+        if (!instancedMesh)
+            return [];
+        return instances.map((instance, index) => ({
+            ...instance,
+            options: {
+                ...options,
+                ...(instance.options || {}),
+                transformState: (state) => {
+                    return {
+                        ...state,
+                        getMatrix: (matrix) => {
+                            instancedMesh.getMatrixAt(index, matrix);
+                            return matrix;
+                        },
+                        setMatrix: (matrix) => {
+                            instancedMesh.setMatrixAt(index, matrix);
+                            instancedMesh.instanceMatrix.needsUpdate = true;
+                        },
+                        meshType: 'instancedMesh',
+                    };
+                },
+            },
+            key: `${instance.key}-${index}` + `${instancedMesh?.uuid || ''}`,
+        }));
+    });
+    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);
+    });
+    constructor() {
+        extend({ Object3D });
+        effect(() => {
+            this.setInstancedMeshMatrixEffect();
+        });
+    }
+    setInstancedMeshMatrixEffect() {
+        const instancedMesh = this.instancedMesh();
+        if (!instancedMesh)
+            return;
+        instancedMesh.instanceMatrix.setUsage(DynamicDrawUsage);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrInstancedRigidBodies, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtrInstancedRigidBodies, isStandalone: true, selector: "ngt-object3D[ngtrInstancedRigidBodies]", 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 }, instances: { classPropertyName: "instances", publicName: "ngtrInstancedRigidBodies", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "position": "position()", "rotation": "rotation()", "scale": "scale()", "quaternion": "quaternion()", "userData": "userData()" } }, viewQueries: [{ propertyName: "instanceWrapperRef", first: true, predicate: ["instanceWrapper"], descendants: true, isSignal: true }, { propertyName: "rigidBodyRefs", predicate: NgtrRigidBody, descendants: true, isSignal: true }], exportAs: ["instancedRigidBodies"], ngImport: i0, template: `
+		<ngt-object3D #instanceWrapper>
+			<ng-content />
+		</ngt-object3D>
+
+		@for (instance of instancesOptions(); track instance.key) {
+			<ngt-object3D
+				[ngtrRigidBody]="instance.type"
+				[options]="instance.options"
+				[position]="instance.position"
+				[rotation]="instance.rotation"
+				[scale]="instance.scale"
+				[quaternion]="instance.quaternion"
+				[userData]="instance.userData"
+				[name]="instance.key + '-instanced-rigid-body-' + $index"
+			>
+				<ng-content select="[data-colliders]" />
+
+				@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 + '-instanced-collider-' + $index"
+						[options]="childColliderOption.colliderOptions"
+					/>
+				}
+			</ngt-object3D>
+		}
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtrRigidBody, selector: "ngt-object3D[ngtrRigidBody]", inputs: ["ngtrRigidBody", "position", "rotation", "scale", "quaternion", "userData", "options"], outputs: ["wake", "sleep", "collisionEnter", "collisionExit", "intersectionEnter", "intersectionExit", "contactForce"], exportAs: ["rigidBody"] }, { 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: NgtrInstancedRigidBodies, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-object3D[ngtrInstancedRigidBodies]',
+                    exportAs: 'instancedRigidBodies',
+                    standalone: true,
+                    template: `
+		<ngt-object3D #instanceWrapper>
+			<ng-content />
+		</ngt-object3D>
+
+		@for (instance of instancesOptions(); track instance.key) {
+			<ngt-object3D
+				[ngtrRigidBody]="instance.type"
+				[options]="instance.options"
+				[position]="instance.position"
+				[rotation]="instance.rotation"
+				[scale]="instance.scale"
+				[quaternion]="instance.quaternion"
+				[userData]="instance.userData"
+				[name]="instance.key + '-instanced-rigid-body-' + $index"
+			>
+				<ng-content select="[data-colliders]" />
+
+				@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 + '-instanced-collider-' + $index"
+						[options]="childColliderOption.colliderOptions"
+					/>
+				}
+			</ngt-object3D>
+		}
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[position]': 'position()',
+                        '[rotation]': 'rotation()',
+                        '[scale]': 'scale()',
+                        '[quaternion]': 'quaternion()',
+                        '[userData]': 'userData()',
+                    },
+                    imports: [NgtrRigidBody, NgtrRigidBody, NgtrAnyCollider],
+                }]
+        }], ctorParameters: () => [] });
+
+function injectImpulseJoint(bodyA, bodyB, { injector, data }) {
+    return assertInjector(injectImpulseJoint, injector, () => {
+        const physics = inject(NgtrPhysics);
+        const newJoint = computed(() => {
+            const worldSingleton = physics.worldSingleton();
+            if (!worldSingleton)
+                return null;
+            const a = typeof bodyA === 'function' ? resolveRef(bodyA()) : resolveRef(bodyA);
+            const b = typeof bodyB === 'function' ? resolveRef(bodyB()) : resolveRef(bodyB);
+            if (!a || !b)
+                return null;
+            const jointData = typeof data === 'function' ? data() : data;
+            if (!jointData)
+                return null;
+            return worldSingleton.proxy.createImpulseJoint(jointData, a, b, true);
+        });
+        effect((onCleanup) => {
+            const worldSingleton = physics.worldSingleton();
+            if (!worldSingleton)
+                return;
+            const joint = newJoint();
+            if (!joint)
+                return;
+            onCleanup(() => {
+                if (worldSingleton.proxy.getImpulseJoint(joint.handle)) {
+                    worldSingleton.proxy.removeImpulseJoint(joint, true);
+                }
+            });
+        });
+        return newJoint;
+    });
+}
+function createJoint(jointDataFn) {
+    return function _injectJoint(bodyA, bodyB, { injector, data }) {
+        return assertInjector(_injectJoint, injector, () => {
+            const physics = inject(NgtrPhysics);
+            const jointData = computed(() => {
+                const rapier = physics.rapier();
+                if (!rapier)
+                    return null;
+                return jointDataFn(rapier, data);
+            });
+            return injectImpulseJoint(bodyA, bodyB, { injector, data: jointData });
+        });
+    };
+}
+/**
+ * A fixed joint ensures that two rigid-bodies don't move relative to each other.
+ * Fixed joints are characterized by one local frame (represented by an isometry) on each rigid-body.
+ * The fixed-joint makes these frames coincide in world-space.
+ *
+ * @category Hooks - Joints
+ */
+const injectFixedJoint = createJoint((rapier, data) => rapier.JointData.fixed(vector3ToRapierVector(data.body1Anchor), quaternionToRapierQuaternion(data.body1LocalFrame), vector3ToRapierVector(data.body2Anchor), quaternionToRapierQuaternion(data.body2LocalFrame)));
+/**
+ * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
+ * translational motion at this points). This is typically used to simulate ragdolls arms, pendulums, etc.
+ * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the
+ * points that need to coincide on the local-space of each rigid-body.
+ *
+ * @category Hooks - Joints
+ */
+const injectSphericalJoint = createJoint((rapier, data) => rapier.JointData.spherical(vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor)));
+/**
+ * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
+ * rotations along one axis. This is typically used to simulate wheels, fans, etc.
+ * They are characterized by one local anchor as well as one local axis on each rigid-body.
+ *
+ * @category Hooks - Joints
+ */
+const injectRevoluteJoint = createJoint((rapier, data) => {
+    const jointData = rapier.JointData.revolute(vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor), vector3ToRapierVector(data.axis));
+    if (data.limits) {
+        jointData.limitsEnabled = true;
+        jointData.limits = data.limits;
+    }
+    return jointData;
+});
+/**
+ * The prismatic joint prevents any relative movement between two rigid-bodies, except for relative translations along one axis.
+ * It is characterized by one local anchor as well as one local axis on each rigid-body. In 3D, an optional
+ * local tangent axis can be specified for each rigid-body.
+ *
+ * @category Hooks - Joints
+ */
+const injectPrismaticJoint = createJoint((rapier, data) => {
+    const jointData = rapier.JointData.prismatic(vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor), vector3ToRapierVector(data.axis));
+    if (data.limits) {
+        jointData.limitsEnabled = true;
+        jointData.limits = data.limits;
+    }
+    return jointData;
+});
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+const injectRopeJoint = createJoint((rapier, data) => rapier.JointData.rope(data.length, vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor)));
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+const injectSpringJoint = createJoint((rapier, data) => {
+    return rapier.JointData.spring(data.restLength, data.stiffness, data.damping, vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor));
+});
+
+class NgtrMeshCollider {
+    colliders = input.required({ alias: 'ngtrMeshCollider' });
+    objectRef = inject(ElementRef);
+    rigidBody = inject(NgtrRigidBody);
+    physics = inject(NgtrPhysics);
+    childColliderOptions = computed(() => {
+        const rigidBodyOptions = this.rigidBody.options();
+        rigidBodyOptions.colliders = this.colliders();
+        const objectLocalState = getLocalState(this.objectRef.nativeElement);
+        // track object's children
+        objectLocalState?.nonObjects();
+        objectLocalState?.objects();
+        return createColliderOptions(this.objectRef.nativeElement, rigidBodyOptions, false);
+    });
+    constructor() {
+        extend({ Object3D });
+        if (!this.objectRef.nativeElement.userData) {
+            this.objectRef.nativeElement.userData = {};
+        }
+        this.objectRef.nativeElement.userData['ngtrRapierType'] = 'MeshCollider';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrMeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtrMeshCollider, isStandalone: true, selector: "ngt-object3D[ngtrMeshCollider]", inputs: { colliders: { classPropertyName: "colliders", publicName: "ngtrMeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, 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 + '-mesh-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: NgtrMeshCollider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-object3D[ngtrMeshCollider]',
+                    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 + '-mesh-collider-' + $index"
+				[options]="childColliderOption.colliderOptions"
+			/>
+		}
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtrAnyCollider],
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NgtrAnyCollider, NgtrBallCollider, NgtrCapsuleCollider, NgtrConeCollider, NgtrConvexHullCollider, NgtrConvexMeshCollider, NgtrCuboidCollider, NgtrCylinderCollider, NgtrHeightfieldCollider, NgtrInstancedRigidBodies, NgtrMeshCollider, NgtrPhysics, NgtrPolylineCollider, NgtrRigidBody, NgtrRoundConeCollider, NgtrRoundConvexHullCollider, NgtrRoundConvexMeshCollider, NgtrRoundCuboidCollider, NgtrRoundCylinderCollider, NgtrTrimeshCollider, injectFixedJoint, injectPrismaticJoint, injectRevoluteJoint, injectRopeJoint, injectSphericalJoint, injectSpringJoint, rigidBodyDefaultOptions };
+//# sourceMappingURL=angular-three-rapier.mjs.map