angular-three-cannon 1.5.2 → 2.0.0-beta.2

package/esm2022/services/spring.mjs

@@ -0,0 +1,34 @@
+import { computed, effect, inject, runInInjectionContext, untracked } from '@angular/core';
+import { assertInjectionContext, injectNgtRef, is, makeId } from 'angular-three';
+import { NGTC_PHYSICS_API } from 'angular-three-cannon';
+export function injectSpring(bodyA, bodyB, { injector, opts = () => ({}), deps = () => ({}), } = {}) {
+    injector = assertInjectionContext(injectSpring, injector);
+    return runInInjectionContext(injector, () => {
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const { worker } = physicsApi();
+        const uuid = makeId();
+        const bodyARef = is.ref(bodyA) ? bodyA : injectNgtRef(bodyA);
+        const bodyBRef = is.ref(bodyB) ? bodyB : injectNgtRef(bodyB);
+        effect((onCleanup) => {
+            deps();
+            if (bodyARef.nativeElement && bodyBRef.nativeElement) {
+                worker.addSpring({
+                    props: [bodyARef.nativeElement.uuid, bodyBRef.nativeElement.uuid, untracked(opts)],
+                    uuid,
+                });
+                onCleanup(() => worker.removeSpring({ uuid }));
+            }
+        });
+        const api = computed(() => {
+            deps();
+            return {
+                setDamping: (value) => worker.setSpringDamping({ props: value, uuid }),
+                setRestLength: (value) => worker.setSpringRestLength({ props: value, uuid }),
+                setStiffness: (value) => worker.setSpringStiffness({ props: value, uuid }),
+                remove: () => worker.removeSpring({ uuid }),
+            };
+        });
+        return { bodyA: bodyARef, bodyB: bodyBRef, api };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/angular-three-cannon-debug.mjs

@@ -0,0 +1,105 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, computed, Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { propsToBody } from '@pmndrs/cannon-worker-api';
+import { injectBeforeRender, NgtArgs } from 'angular-three';
+import { NGTC_PHYSICS_API } from 'angular-three-cannon';
+import CannonDebugger from 'cannon-es-debugger';
+import * as THREE from 'three';
+
+const q = new THREE.Quaternion();
+const s = new THREE.Vector3(1, 1, 1);
+const v = new THREE.Vector3();
+const m = new THREE.Matrix4();
+function getMatrix(o) {
+    if (o instanceof THREE.InstancedMesh) {
+        o.getMatrixAt(parseInt(o.uuid.split('/')[1]), m);
+        return m;
+    }
+    return o.matrix;
+}
+const NGTC_DEBUG_API = new InjectionToken('NgtcDebug API');
+class NgtcDebug {
+    #bodies;
+    #bodyMap;
+    #physicsApi;
+    #cannonDebugger;
+    constructor() {
+        this.color = 'black';
+        this.scale = 1;
+        this.impl = CannonDebugger;
+        this.disabled = false;
+        this.#bodies = [];
+        this.#bodyMap = {};
+        this.scene = new THREE.Scene();
+        this.#physicsApi = inject(NGTC_PHYSICS_API);
+        this.api = computed(() => ({
+            add: (uuid, props, type) => {
+                const body = propsToBody({ uuid, props, type });
+                this.#bodies.push(body);
+                this.#bodyMap[uuid] = body;
+            },
+            remove: (id) => {
+                const debugBodyIndex = this.#bodies.indexOf(this.#bodyMap[id]);
+                if (debugBodyIndex > -1)
+                    this.#bodies.splice(debugBodyIndex, 1);
+                delete this.#bodyMap[id];
+            },
+        }));
+        injectBeforeRender(() => {
+            if (!this.#cannonDebugger)
+                return;
+            const refs = this.#physicsApi().refs;
+            for (const uuid in this.#bodyMap) {
+                getMatrix(refs[uuid]).decompose(v, q, s);
+                this.#bodyMap[uuid].position.copy(v);
+                this.#bodyMap[uuid].quaternion.copy(q);
+            }
+            for (const child of this.scene.children) {
+                child.visible = !this.disabled;
+            }
+            if (!this.disabled) {
+                this.#cannonDebugger.update();
+            }
+        });
+    }
+    ngOnInit() {
+        this.#cannonDebugger = this.impl(this.scene, { bodies: this.#bodies }, {
+            color: this.color,
+            scale: this.scale,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtcDebug, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtcDebug, isStandalone: true, selector: "ngtc-debug", inputs: { color: "color", scale: "scale", impl: "impl", disabled: "disabled" }, providers: [{ provide: NGTC_DEBUG_API, useFactory: (debug) => debug.api, deps: [NgtcDebug] }], ngImport: i0, template: `
+        <ngt-primitive *args="[scene]" />
+        <ng-content />
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtcDebug, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtc-debug',
+                    standalone: true,
+                    template: `
+        <ngt-primitive *args="[scene]" />
+        <ng-content />
+    `,
+                    providers: [{ provide: NGTC_DEBUG_API, useFactory: (debug) => debug.api, deps: [NgtcDebug] }],
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { color: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], impl: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NGTC_DEBUG_API, NgtcDebug };
+//# sourceMappingURL=angular-three-cannon-debug.mjs.map

package/fesm2022/angular-three-cannon-debug.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-three-cannon-debug.mjs","sources":["../../../../libs/cannon/debug/src/debug.ts","../../../../libs/cannon/debug/src/angular-three-cannon-debug.ts"],"sourcesContent":["import {\n    Component,\n    computed,\n    CUSTOM_ELEMENTS_SCHEMA,\n    inject,\n    InjectionToken,\n    Input,\n    OnInit,\n    Signal,\n} from '@angular/core';\nimport { BodyProps, BodyShapeType, propsToBody } from '@pmndrs/cannon-worker-api';\nimport { injectBeforeRender, NgtArgs } from 'angular-three';\nimport { NGTC_PHYSICS_API } from 'angular-three-cannon';\nimport { Body, Quaternion as CQuarternion, Vec3, World } from 'cannon-es';\nimport CannonDebugger from 'cannon-es-debugger';\nimport * as THREE from 'three';\n\nconst q = new THREE.Quaternion();\nconst s = new THREE.Vector3(1, 1, 1);\nconst v = new THREE.Vector3();\nconst m = new THREE.Matrix4();\n\nfunction getMatrix(o: THREE.Object3D): THREE.Matrix4 {\n    if (o instanceof THREE.InstancedMesh) {\n        o.getMatrixAt(parseInt(o.uuid.split('/')[1]), m);\n        return m;\n    }\n    return o.matrix;\n}\n\nexport interface NgtcDebugApi {\n    add(id: string, props: BodyProps, type: BodyShapeType): void;\n    remove(id: string): void;\n}\n\nexport const NGTC_DEBUG_API = new InjectionToken<Signal<NgtcDebugApi>>('NgtcDebug API');\n\n@Component({\n    selector: 'ngtc-debug',\n    standalone: true,\n    template: `\n        <ngt-primitive *args=\"[scene]\" />\n        <ng-content />\n    `,\n    providers: [{ provide: NGTC_DEBUG_API, useFactory: (debug: NgtcDebug) => debug.api, deps: [NgtcDebug] }],\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtcDebug implements OnInit {\n    @Input() color = 'black';\n    @Input() scale = 1;\n    @Input() impl = CannonDebugger;\n    @Input() disabled = false;\n\n    readonly #bodies: Body[] = [];\n    readonly #bodyMap: Record<string, Body> = {};\n    readonly scene = new THREE.Scene();\n\n    readonly #physicsApi = inject(NGTC_PHYSICS_API);\n\n    #cannonDebugger!: ReturnType<typeof CannonDebugger>;\n\n    readonly api = computed(() => ({\n        add: (uuid: string, props: BodyProps, type: BodyShapeType) => {\n            const body = propsToBody({ uuid, props, type });\n            this.#bodies.push(body);\n            this.#bodyMap[uuid] = body;\n        },\n        remove: (id: string) => {\n            const debugBodyIndex = this.#bodies.indexOf(this.#bodyMap[id]);\n            if (debugBodyIndex > -1) this.#bodies.splice(debugBodyIndex, 1);\n            delete this.#bodyMap[id];\n        },\n    }));\n\n    constructor() {\n        injectBeforeRender(() => {\n            if (!this.#cannonDebugger) return;\n            const refs = this.#physicsApi().refs;\n            for (const uuid in this.#bodyMap) {\n                getMatrix(refs[uuid]).decompose(v, q, s);\n                this.#bodyMap[uuid].position.copy(v as unknown as Vec3);\n                this.#bodyMap[uuid].quaternion.copy(q as unknown as CQuarternion);\n            }\n\n            for (const child of this.scene.children) {\n                child.visible = !this.disabled;\n            }\n\n            if (!this.disabled) {\n                this.#cannonDebugger.update();\n            }\n        });\n    }\n\n    ngOnInit() {\n        this.#cannonDebugger = this.impl(this.scene, { bodies: this.#bodies } as World, {\n            color: this.color,\n            scale: this.scale,\n        });\n    }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/fesm2022/angular-three-cannon-services.mjs

@@ -0,0 +1,494 @@
+import { runInInjectionContext, inject, effect, computed, untracked } from '@angular/core';
+import { assertInjectionContext, injectNgtRef, makeId, is } from 'angular-three';
+import { NGTC_PHYSICS_API } from 'angular-three-cannon';
+import { NGTC_DEBUG_API } from 'angular-three-cannon/debug';
+import * as THREE from 'three';
+
+const temp = new THREE.Object3D();
+function capitalize(str) {
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}
+function getUUID(ref, index) {
+    const suffix = index === undefined ? '' : `/${index}`;
+    if (typeof ref === 'function')
+        return null;
+    return ref && ref.nativeElement && `${ref.nativeElement.uuid}${suffix}`;
+}
+const e = new THREE.Euler();
+const q = new THREE.Quaternion();
+const quaternionToRotation = (callback) => {
+    return (v) => callback(e.setFromQuaternion(q.fromArray(v)).toArray());
+};
+let incrementingId = 0;
+function subscribe(ref, worker, subscriptions, type, index, target = 'bodies') {
+    return (callback) => {
+        const id = incrementingId++;
+        subscriptions[id] = { [type]: callback };
+        const uuid = getUUID(ref, index);
+        uuid && worker.subscribe({ props: { id, target, type }, uuid });
+        return () => {
+            delete subscriptions[id];
+            worker.unsubscribe({ props: id });
+        };
+    };
+}
+function prepare(object, { position = [0, 0, 0], rotation = [0, 0, 0], userData = {} }) {
+    object.userData = userData;
+    object.position.set(...position);
+    object.rotation.set(...rotation);
+    object.updateMatrix();
+}
+function setupCollision(events, { onCollide, onCollideBegin, onCollideEnd }, uuid) {
+    events[uuid] = {
+        collide: onCollide,
+        collideBegin: onCollideBegin,
+        collideEnd: onCollideEnd,
+    };
+}
+function makeTriplet(v) {
+    return v instanceof THREE.Vector3 ? [v.x, v.y, v.z] : v;
+}
+function injectPlane(fn, opts) {
+    return injectBody('Plane', fn, () => [], opts);
+}
+function injectBox(fn, opts) {
+    const defaultBoxArgs = [1, 1, 1];
+    return injectBody('Box', fn, (args = defaultBoxArgs) => args, opts);
+}
+function injectCylinder(fn, opts) {
+    return injectBody('Cylinder', fn, (args = []) => args, opts);
+}
+function injectHeightfield(fn, opts) {
+    return injectBody('Heightfield', fn, (args) => args, opts);
+}
+function injectParticle(fn, opts) {
+    return injectBody('Particle', fn, () => [], opts);
+}
+function injectSphere(fn, opts) {
+    return injectBody('Sphere', fn, (args = [1]) => {
+        if (!Array.isArray(args))
+            throw new Error('useSphere args must be an array');
+        return [args[0]];
+    }, opts);
+}
+function injectTrimesh(fn, opts) {
+    return injectBody('Trimesh', fn, (args) => args, opts);
+}
+function injectConvexPolyhedron(fn, opts) {
+    return injectBody('ConvexPolyhedron', fn, ([vertices, faces, normals, axes, boundingSphereRadius] = []) => [
+        vertices && vertices.map(makeTriplet),
+        faces,
+        normals && normals.map(makeTriplet),
+        axes && axes.map(makeTriplet),
+        boundingSphereRadius,
+    ], opts);
+}
+function injectCompoundBody(fn, opts) {
+    return injectBody('Compound', fn, (args) => args, opts);
+}
+function injectBody(type, getPropsFn, argsFn, { ref, injector, deps = () => ({}) } = {}) {
+    injector = assertInjectionContext(injectBody, injector);
+    return runInInjectionContext(injector, () => {
+        let bodyRef = injectNgtRef();
+        if (ref)
+            bodyRef = ref;
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const debugApi = inject(NGTC_DEBUG_API, { optional: true });
+        const { refs, worker, subscriptions, scaleOverrides, events } = physicsApi();
+        const { add: debugAdd, remove: debugRemove } = debugApi?.() || {};
+        effect((onCleanup) => {
+            // register deps
+            deps();
+            if (!bodyRef.untracked) {
+                bodyRef.nativeElement = new THREE.Object3D();
+            }
+            const object = bodyRef.untracked;
+            const currentWorker = worker;
+            const objectCount = object instanceof THREE.InstancedMesh
+                ? (object.instanceMatrix.setUsage(THREE.DynamicDrawUsage), object.count)
+                : 1;
+            const uuid = object instanceof THREE.InstancedMesh
+                ? new Array(objectCount).fill(0).map((_, i) => `${object.uuid}/${i}`)
+                : [object.uuid];
+            const props = object instanceof THREE.InstancedMesh
+                ? uuid.map((id, i) => {
+                    const props = getPropsFn(i);
+                    prepare(temp, props);
+                    object.setMatrixAt(i, temp.matrix);
+                    object.instanceMatrix.needsUpdate = true;
+                    refs[id] = object;
+                    debugAdd?.(id, props, type);
+                    setupCollision(events, props, id);
+                    return { ...props, args: argsFn(props.args) };
+                })
+                : uuid.map((id, i) => {
+                    const props = getPropsFn(i);
+                    prepare(object, props);
+                    refs[id] = object;
+                    debugAdd?.(id, props, type);
+                    setupCollision(events, props, id);
+                    return { ...props, args: argsFn(props.args) };
+                });
+            // Register on mount, unregister on unmount
+            currentWorker.addBodies({
+                props: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => {
+                    return { onCollide: Boolean(onCollide), ...serializableProps };
+                }),
+                type,
+                uuid,
+            });
+            onCleanup(() => {
+                uuid.forEach((id) => {
+                    delete refs[id];
+                    debugRemove?.(id);
+                    delete events[id];
+                });
+                currentWorker.removeBodies({ uuid });
+            });
+        }, { allowSignalWrites: true });
+        const api = computed(() => {
+            const makeAtomic = (type, index) => {
+                const op = `set${capitalize(type)}`;
+                return {
+                    set: (value) => {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid &&
+                            worker[op]({
+                                props: value,
+                                uuid,
+                            });
+                    },
+                    subscribe: subscribe(bodyRef, worker, subscriptions, type, index),
+                };
+            };
+            const makeQuaternion = (index) => {
+                const type = 'quaternion';
+                return {
+                    copy: ({ w, x, y, z }) => {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.setQuaternion({ props: [x, y, z, w], uuid });
+                    },
+                    set: (x, y, z, w) => {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.setQuaternion({ props: [x, y, z, w], uuid });
+                    },
+                    subscribe: subscribe(bodyRef, worker, subscriptions, type, index),
+                };
+            };
+            const makeRotation = (index) => {
+                return {
+                    copy: ({ x, y, z }) => {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.setRotation({ props: [x, y, z], uuid });
+                    },
+                    set: (x, y, z) => {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.setRotation({ props: [x, y, z], uuid });
+                    },
+                    subscribe: (callback) => {
+                        const id = incrementingId++;
+                        const target = 'bodies';
+                        const type = 'quaternion';
+                        const uuid = getUUID(bodyRef, index);
+                        subscriptions[id] = { [type]: quaternionToRotation(callback) };
+                        uuid && worker.subscribe({ props: { id, target, type }, uuid });
+                        return () => {
+                            delete subscriptions[id];
+                            worker.unsubscribe({ props: id });
+                        };
+                    },
+                };
+            };
+            const makeVec = (type, index) => {
+                const op = `set${capitalize(type)}`;
+                return {
+                    copy: ({ x, y, z }) => {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker[op]({ props: [x, y, z], uuid });
+                    },
+                    set: (x, y, z) => {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker[op]({ props: [x, y, z], uuid });
+                    },
+                    subscribe: subscribe(bodyRef, worker, subscriptions, type, index),
+                };
+            };
+            const makeRemove = (index) => {
+                const uuid = getUUID(bodyRef, index);
+                return () => {
+                    if (uuid)
+                        worker.removeBodies({ uuid: [uuid] });
+                };
+            };
+            function makeApi(index) {
+                return {
+                    allowSleep: makeAtomic('allowSleep', index),
+                    angularDamping: makeAtomic('angularDamping', index),
+                    angularFactor: makeVec('angularFactor', index),
+                    angularVelocity: makeVec('angularVelocity', index),
+                    applyForce(force, worldPoint) {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.applyForce({ props: [force, worldPoint], uuid });
+                    },
+                    applyImpulse(impulse, worldPoint) {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.applyImpulse({ props: [impulse, worldPoint], uuid });
+                    },
+                    applyLocalForce(force, localPoint) {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.applyLocalForce({ props: [force, localPoint], uuid });
+                    },
+                    applyLocalImpulse(impulse, localPoint) {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.applyLocalImpulse({ props: [impulse, localPoint], uuid });
+                    },
+                    applyTorque(torque) {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.applyTorque({ props: [torque], uuid });
+                    },
+                    collisionFilterGroup: makeAtomic('collisionFilterGroup', index),
+                    collisionFilterMask: makeAtomic('collisionFilterMask', index),
+                    collisionResponse: makeAtomic('collisionResponse', index),
+                    fixedRotation: makeAtomic('fixedRotation', index),
+                    isTrigger: makeAtomic('isTrigger', index),
+                    linearDamping: makeAtomic('linearDamping', index),
+                    linearFactor: makeVec('linearFactor', index),
+                    mass: makeAtomic('mass', index),
+                    material: makeAtomic('material', index),
+                    position: makeVec('position', index),
+                    quaternion: makeQuaternion(index),
+                    rotation: makeRotation(index),
+                    scaleOverride(scale) {
+                        const uuid = getUUID(bodyRef, index);
+                        if (uuid)
+                            scaleOverrides[uuid] = new THREE.Vector3(...scale);
+                    },
+                    sleep() {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.sleep({ uuid });
+                    },
+                    sleepSpeedLimit: makeAtomic('sleepSpeedLimit', index),
+                    sleepTimeLimit: makeAtomic('sleepTimeLimit', index),
+                    userData: makeAtomic('userData', index),
+                    velocity: makeVec('velocity', index),
+                    remove: makeRemove(index),
+                    wakeUp() {
+                        const uuid = getUUID(bodyRef, index);
+                        uuid && worker.wakeUp({ uuid });
+                    },
+                };
+            }
+            const cache = {};
+            return {
+                ...makeApi(undefined),
+                at: (index) => cache[index] || (cache[index] = makeApi(index)),
+            };
+        });
+        return { ref: bodyRef, api };
+    });
+}
+
+function usePointToPointConstraint(bodyA, bodyB, opts) {
+    return injectConstraint('PointToPoint', bodyA, bodyB, opts);
+}
+function useConeTwistConstraint(bodyA, bodyB, opts) {
+    return injectConstraint('ConeTwist', bodyA, bodyB, opts);
+}
+function useDistanceConstraint(bodyA, bodyB, opts) {
+    return injectConstraint('Distance', bodyA, bodyB, opts);
+}
+function useHingeConstraint(bodyA, bodyB, opts) {
+    return injectConstraint('Hinge', bodyA, bodyB, opts);
+}
+function useLockConstraint(bodyA, bodyB, opts) {
+    return injectConstraint('Lock', bodyA, bodyB, opts);
+}
+function injectConstraint(type, bodyA, bodyB, { injector, deps = () => ({}), opts = () => ({}), } = {}) {
+    injector = assertInjectionContext(injectConstraint, injector);
+    return runInInjectionContext(injector, () => {
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const { worker } = physicsApi();
+        const uuid = makeId();
+        const bodyARef = is.ref(bodyA) ? bodyA : injectNgtRef(bodyA);
+        const bodyBRef = is.ref(bodyB) ? bodyB : injectNgtRef(bodyB);
+        effect((onCleanup) => {
+            deps();
+            if (bodyARef.nativeElement && bodyBRef.nativeElement) {
+                worker.addConstraint({
+                    props: [bodyARef.untracked.uuid, bodyBRef.untracked.uuid, untracked(opts)],
+                    type,
+                    uuid,
+                });
+                onCleanup(() => worker.removeConstraint({ uuid }));
+            }
+        });
+        const api = computed(() => {
+            deps();
+            const enableDisable = {
+                disable: () => worker.disableConstraint({ uuid }),
+                enable: () => worker.enableConstraint({ uuid }),
+                remove: () => worker.removeConstraint({ uuid }),
+            };
+            if (type === 'Hinge') {
+                return {
+                    ...enableDisable,
+                    disableMotor: () => worker.disableConstraintMotor({ uuid }),
+                    enableMotor: () => worker.enableConstraintMotor({ uuid }),
+                    setMotorMaxForce: (value) => worker.setConstraintMotorMaxForce({ props: value, uuid }),
+                    setMotorSpeed: (value) => worker.setConstraintMotorSpeed({ props: value, uuid }),
+                };
+            }
+            return enableDisable;
+        });
+        return { bodyA: bodyARef, bodyB: bodyBRef, api };
+    });
+}
+
+function injectContactMaterial(materialB, materialA, { opts, deps = () => ({}), injector, }) {
+    injector = assertInjectionContext(injectContactMaterial, injector);
+    return runInInjectionContext(injector, () => {
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const { worker } = physicsApi();
+        const uuid = makeId();
+        effect((onCleanup) => {
+            deps();
+            worker.addContactMaterial({
+                props: [materialA, materialB, untracked(opts)],
+                uuid,
+            });
+            onCleanup(() => worker.removeContactMaterial({ uuid }));
+        });
+    });
+}
+
+function injectRaycastClosest(opts) {
+    return injectRay('Closest', opts);
+}
+function injectRaycastAny(opts) {
+    return injectRay('Any', opts);
+}
+function useRaycastAll(opts) {
+    return injectRay('All', opts);
+}
+function injectRay(mode, { options, callback, deps = () => ({}), injector }) {
+    injector = assertInjectionContext(injectRay, injector);
+    return runInInjectionContext(injector, () => {
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const { worker, events } = physicsApi();
+        const uuid = makeId();
+        effect((onCleanup) => {
+            deps();
+            events[uuid] = { rayhit: callback };
+            worker.addRay({ props: { ...untracked(options), mode }, uuid });
+            onCleanup(() => {
+                worker.removeRay({ uuid });
+                delete events[uuid];
+            });
+        });
+    });
+}
+
+function isString(v) {
+    return typeof v === 'string';
+}
+function injectRaycastVehicle(fn, { ref, injector, deps = () => ({}), } = {}) {
+    injector = assertInjectionContext(injectRaycastVehicle, injector);
+    return runInInjectionContext(injector, () => {
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const { worker, subscriptions } = physicsApi();
+        let instanceRef = injectNgtRef();
+        if (ref)
+            instanceRef = ref;
+        effect((onCleanup) => {
+            deps();
+            if (!instanceRef.untracked) {
+                instanceRef.nativeElement = new THREE.Object3D();
+            }
+            const currentWorker = worker;
+            const uuid = instanceRef.nativeElement.uuid;
+            const { chassisBody, indexForwardAxis = 2, indexRightAxis = 0, indexUpAxis = 1, wheelInfos, wheels, } = untracked(fn);
+            const chassisBodyUUID = getUUID(chassisBody);
+            const wheelUUIDs = wheels.map((ref) => getUUID(ref));
+            if (!chassisBodyUUID || !wheelUUIDs.every(isString))
+                return;
+            currentWorker.addRaycastVehicle({
+                props: [chassisBodyUUID, wheelUUIDs, wheelInfos, indexForwardAxis, indexRightAxis, indexUpAxis],
+                uuid,
+            });
+            onCleanup(() => {
+                currentWorker.removeRaycastVehicle({ uuid });
+            });
+        }, { allowSignalWrites: true });
+        const api = computed(() => {
+            deps();
+            return {
+                applyEngineForce(value, wheelIndex) {
+                    const uuid = getUUID(instanceRef);
+                    uuid &&
+                        worker.applyRaycastVehicleEngineForce({
+                            props: [value, wheelIndex],
+                            uuid,
+                        });
+                },
+                setBrake(brake, wheelIndex) {
+                    const uuid = getUUID(instanceRef);
+                    uuid && worker.setRaycastVehicleBrake({ props: [brake, wheelIndex], uuid });
+                },
+                setSteeringValue(value, wheelIndex) {
+                    const uuid = getUUID(instanceRef);
+                    uuid &&
+                        worker.setRaycastVehicleSteeringValue({
+                            props: [value, wheelIndex],
+                            uuid,
+                        });
+                },
+                sliding: {
+                    subscribe: subscribe(instanceRef, worker, subscriptions, 'sliding', undefined, 'vehicles'),
+                },
+                remove: () => {
+                    const uuid = getUUID(instanceRef);
+                    uuid && worker.removeRaycastVehicle({ uuid });
+                },
+            };
+        });
+        return { ref: instanceRef, api };
+    });
+}
+
+function injectSpring(bodyA, bodyB, { injector, opts = () => ({}), deps = () => ({}), } = {}) {
+    injector = assertInjectionContext(injectSpring, injector);
+    return runInInjectionContext(injector, () => {
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const { worker } = physicsApi();
+        const uuid = makeId();
+        const bodyARef = is.ref(bodyA) ? bodyA : injectNgtRef(bodyA);
+        const bodyBRef = is.ref(bodyB) ? bodyB : injectNgtRef(bodyB);
+        effect((onCleanup) => {
+            deps();
+            if (bodyARef.nativeElement && bodyBRef.nativeElement) {
+                worker.addSpring({
+                    props: [bodyARef.nativeElement.uuid, bodyBRef.nativeElement.uuid, untracked(opts)],
+                    uuid,
+                });
+                onCleanup(() => worker.removeSpring({ uuid }));
+            }
+        });
+        const api = computed(() => {
+            deps();
+            return {
+                setDamping: (value) => worker.setSpringDamping({ props: value, uuid }),
+                setRestLength: (value) => worker.setSpringRestLength({ props: value, uuid }),
+                setStiffness: (value) => worker.setSpringStiffness({ props: value, uuid }),
+                remove: () => worker.removeSpring({ uuid }),
+            };
+        });
+        return { bodyA: bodyARef, bodyB: bodyBRef, api };
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { getUUID, injectBox, injectCompoundBody, injectContactMaterial, injectConvexPolyhedron, injectCylinder, injectHeightfield, injectParticle, injectPlane, injectRaycastAny, injectRaycastClosest, injectRaycastVehicle, injectSphere, injectSpring, injectTrimesh, subscribe, useConeTwistConstraint, useDistanceConstraint, useHingeConstraint, useLockConstraint, usePointToPointConstraint, useRaycastAll };
+//# sourceMappingURL=angular-three-cannon-services.mjs.map