angular-three-cannon 1.0.0

package/esm2020/services/lib/body.mjs

@@ -0,0 +1,293 @@
+import { inject } from '@angular/core';
+import { injectNgtDestroy, injectNgtRef, tapEffect } from 'angular-three';
+import { NgtcStore, NgtcUtils } from 'angular-three-cannon';
+import { NGTC_DEBUG_API } from 'angular-three-cannon/debug';
+import { combineLatest, isObservable, of, ReplaySubject, switchMap } from 'rxjs';
+import * as THREE from 'three';
+export function injectPlane(fn, opts) {
+    return injectBody('Plane', fn, () => [], opts);
+}
+export function injectBox(fn, opts) {
+    const defaultBoxArgs = [1, 1, 1];
+    return injectBody('Box', fn, (args = defaultBoxArgs) => args, opts);
+}
+export function injectCylinder(fn, opts) {
+    return injectBody('Cylinder', fn, (args = []) => args, opts);
+}
+export function injectHeightfield(fn, opts) {
+    return injectBody('Heightfield', fn, (args) => args, opts);
+}
+export function injectParticle(fn, opts) {
+    return injectBody('Particle', fn, () => [], opts);
+}
+export function injectSphere(fn, opts) {
+    return injectBody('Sphere', fn, (args = [1]) => {
+        if (!Array.isArray(args))
+            throw new Error('injectSphere args must be an array');
+        return [args[0]];
+    }, opts);
+}
+export function injectTrimesh(fn, opts) {
+    return injectBody('Trimesh', fn, (args) => args, opts);
+}
+export function injectConvexPolyhedron(fn, opts) {
+    return injectBody('ConvexPolyhedron', fn, ([vertices, faces, normals, axes, boundingSphereRadius] = []) => [
+        vertices && vertices.map(NgtcUtils.makeTriplet),
+        faces,
+        normals && normals.map(NgtcUtils.makeTriplet),
+        axes && axes.map(NgtcUtils.makeTriplet),
+        boundingSphereRadius,
+    ], opts);
+}
+export function injectCompoundBody(fn, opts) {
+    return injectBody('Compound', fn, (args) => args, opts);
+}
+const temp = new THREE.Object3D();
+function injectBody(type, getPropsFn, argsFn, { ref, waitFor } = {}) {
+    let subscription = undefined;
+    // a ReplaySubject that would emit once in queueMicrotask call
+    const microQueue$ = new ReplaySubject(1);
+    // a ReplaySubject that would emit whenever our props emits. This is done so that the consumers can pass in
+    // Observable to injectBody if they have reactive props (eg: Input)
+    const propsSubject$ = new ReplaySubject(1);
+    // an array of streams we want to wait to emit until we decide to give the bodyRef an empty Object3D
+    const waits$ = [microQueue$];
+    const debugApi = inject(NGTC_DEBUG_API, { skipSelf: true, optional: true });
+    const physicsStore = inject(NgtcStore, { skipSelf: true });
+    // clean up our streams on destroy
+    injectNgtDestroy(() => {
+        microQueue$.complete();
+        propsSubject$.complete();
+        subscription?.unsubscribe();
+    });
+    // give our bodyRef an NgtInjectedRef
+    let bodyRef = injectNgtRef();
+    // add waitFor if the consumers pass it in
+    if (waitFor)
+        waits$.push(waitFor);
+    // re-assign bodyRef if the consumers pass a ref in
+    if (ref)
+        bodyRef = ref;
+    // fire microQueue$
+    queueMicrotask(() => microQueue$.next());
+    // when all waits$ emit, we give bodyRef an empty Object3D if it doesn't have one. Physic Object can still be affected
+    // by Physics without a visual representation
+    combineLatest(waits$).subscribe(() => (bodyRef.nativeElement || (bodyRef.nativeElement = new THREE.Object3D())));
+    // start the pipeline as soon as bodyRef has a truthy value
+    subscription = bodyRef.$.pipe(switchMap((object) => {
+        const { events, refs, worker } = physicsStore.get();
+        const currentWorker = worker;
+        let objectCount = 1;
+        if (object instanceof THREE.InstancedMesh) {
+            object.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+            objectCount = object.count;
+        }
+        // consolidate our uuids into an Array so we can handle them in a more consistent way
+        const uuids = object instanceof THREE.InstancedMesh
+            ? new Array(objectCount).fill(0).map((_, i) => `${object.uuid}/${i}`)
+            : [object.uuid];
+        // construct an Array<Observable> from getPropsFn
+        // so we can react to props changed
+        const propsList$ = uuids.map((uuid, index) => {
+            const propsResult = getPropsFn(index);
+            // TODO  we use a propsSubject$ because we want to ensure this propsResult stream is HOT
+            // otherwise, tapEffect will remove everything from currentWorker#bodies because the stream completes
+            (isObservable(propsResult) ? propsResult : of(propsResult)).subscribe({
+                next: (props) => {
+                    NgtcUtils.prepare(temp, props);
+                    if (object instanceof THREE.InstancedMesh) {
+                        object.setMatrixAt(index, temp.matrix);
+                        object.instanceMatrix.needsUpdate = true;
+                    }
+                    refs[uuid] = object;
+                    debugApi?.add(uuid, props, type);
+                    NgtcUtils.setupCollision(events, props, uuid);
+                    propsSubject$.next({ ...props, args: argsFn(props.args) });
+                },
+                error: (error) => {
+                    console.error(`[NGT Cannon] Error with processing props: ${error}`);
+                    propsSubject$.error(error);
+                },
+            });
+            return propsSubject$;
+        });
+        return combineLatest(propsList$).pipe(tapEffect((props) => {
+            currentWorker.addBodies({
+                props: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => ({
+                    onCollide: Boolean(onCollide),
+                    onCollideBegin: Boolean(onCollideBegin),
+                    onCollideEnd: Boolean(onCollideEnd),
+                    ...serializableProps,
+                })),
+                type,
+                uuid: uuids,
+            });
+            // clean up CannonWorker whenever props changes/completes
+            return () => {
+                uuids.forEach((uuid) => {
+                    delete refs[uuid];
+                    debugApi?.remove(uuid);
+                    delete events[uuid];
+                });
+                currentWorker.removeBodies({ uuid: uuids });
+            };
+        }));
+    })).subscribe();
+    const makeAtomic = (type, index) => {
+        const op = `set${NgtcUtils.capitalize(type)}`;
+        return {
+            set: (value) => {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker[op]({ props: value, uuid });
+            },
+            get subscribe() {
+                const { subscriptions, worker } = physicsStore.get();
+                return NgtcUtils.subscribe(bodyRef, worker, subscriptions, type, index);
+            },
+        };
+    };
+    const makeQuaternion = (index) => {
+        const type = 'quaternion';
+        return {
+            copy: ({ w, x, y, z }) => {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.setQuaternion({ props: [x, y, z, w], uuid });
+            },
+            set: (x, y, z, w) => {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.setQuaternion({ props: [x, y, z, w], uuid });
+            },
+            get subscribe() {
+                const { subscriptions, worker } = physicsStore.get();
+                return NgtcUtils.subscribe(bodyRef, worker, subscriptions, type, index);
+            },
+        };
+    };
+    const makeRotation = (index) => {
+        return {
+            copy: ({ x, y, z }) => {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.setRotation({ props: [x, y, z], uuid });
+            },
+            set: (x, y, z) => {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.setRotation({ props: [x, y, z], uuid });
+            },
+            subscribe: (callback) => {
+                const { subscriptions, worker } = physicsStore.get();
+                const id = NgtcUtils.incrementingId++;
+                const target = 'bodies';
+                const type = 'quaternion';
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                subscriptions[id] = { [type]: NgtcUtils.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${NgtcUtils.capitalize(type)}`;
+        return {
+            copy: ({ x, y, z }) => {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker[op]({ props: [x, y, z], uuid });
+            },
+            set: (x, y, z) => {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker[op]({ props: [x, y, z], uuid });
+            },
+            get subscribe() {
+                const { subscriptions, worker } = physicsStore.get();
+                return NgtcUtils.subscribe(bodyRef, worker, subscriptions, type, index);
+            },
+        };
+    };
+    const makeRemove = (index) => {
+        const { worker } = physicsStore.get();
+        const uuid = NgtcUtils.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 { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.applyForce({ props: [force, worldPoint], uuid });
+            },
+            applyImpulse(impulse, worldPoint) {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.applyImpulse({ props: [impulse, worldPoint], uuid });
+            },
+            applyLocalForce(force, localPoint) {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.applyLocalForce({ props: [force, localPoint], uuid });
+            },
+            applyLocalImpulse(impulse, localPoint) {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.applyLocalImpulse({ props: [impulse, localPoint], uuid });
+            },
+            applyTorque(torque) {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.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),
+            remove: makeRemove(index),
+            rotation: makeRotation(index),
+            scaleOverride(scale) {
+                const { scaleOverrides } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                if (uuid)
+                    scaleOverrides[uuid] = new THREE.Vector3(...scale);
+            },
+            sleep() {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.sleep({ uuid });
+            },
+            sleepSpeedLimit: makeAtomic('sleepSpeedLimit', index),
+            sleepTimeLimit: makeAtomic('sleepTimeLimit', index),
+            userData: makeAtomic('userData', index),
+            velocity: makeVec('velocity', index),
+            wakeUp() {
+                const { worker } = physicsStore.get();
+                const uuid = NgtcUtils.getUUID(bodyRef, index);
+                uuid && worker.wakeUp({ uuid });
+            },
+        };
+    }
+    const cache = {};
+    const api = { ...makeApi(undefined), at: (index) => cache[index] || (cache[index] = makeApi(index)) };
+    return { ref: bodyRef, api };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"body.js","sourceRoot":"","sources":["../../../../../../libs/angular-three-cannon/services/src/lib/body.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from '@angular/core';\nimport {\n    AtomicName,\n    AtomicProps,\n    BodyProps,\n    BodyShapeType,\n    BoxProps,\n    CompoundBodyProps,\n    ConvexPolyhedronArgs,\n    ConvexPolyhedronProps,\n    CylinderProps,\n    HeightfieldProps,\n    ParticleProps,\n    PlaneProps,\n    PropValue,\n    Quad,\n    SetOpName,\n    SphereArgs,\n    SphereProps,\n    TrimeshProps,\n    Triplet,\n    VectorName,\n} from '@pmndrs/cannon-worker-api';\nimport { injectNgtDestroy, injectNgtRef, NgtInjectedRef, tapEffect } from 'angular-three';\nimport { NgtcStore, NgtcUtils } from 'angular-three-cannon';\nimport { NGTC_DEBUG_API } from 'angular-three-cannon/debug';\nimport { combineLatest, isObservable, Observable, of, ReplaySubject, Subscription, switchMap } from 'rxjs';\nimport * as THREE from 'three';\n\nexport type NgtcAtomicApi<K extends AtomicName> = {\n    set: (value: AtomicProps[K]) => void;\n    subscribe: (callback: (value: AtomicProps[K]) => void) => () => void;\n};\n\nexport type NgtcQuaternionApi = {\n    copy: ({ w, x, y, z }: THREE.Quaternion) => void;\n    set: (x: number, y: number, z: number, w: number) => void;\n    subscribe: (callback: (value: Quad) => void) => () => void;\n};\n\nexport type NgtcVectorApi = {\n    copy: ({ x, y, z }: THREE.Vector3 | THREE.Euler) => void;\n    set: (x: number, y: number, z: number) => void;\n    subscribe: (callback: (value: Triplet) => void) => () => void;\n};\n\nexport type NgtcWorkerApi = {\n    [K in AtomicName]: NgtcAtomicApi<K>;\n} & {\n    [K in VectorName]: NgtcVectorApi;\n} & {\n    applyForce: (force: Triplet, worldPoint: Triplet) => void;\n    applyImpulse: (impulse: Triplet, worldPoint: Triplet) => void;\n    applyLocalForce: (force: Triplet, localPoint: Triplet) => void;\n    applyLocalImpulse: (impulse: Triplet, localPoint: Triplet) => void;\n    applyTorque: (torque: Triplet) => void;\n    quaternion: NgtcQuaternionApi;\n    rotation: NgtcVectorApi;\n    scaleOverride: (scale: Triplet) => void;\n    sleep: () => void;\n    wakeUp: () => void;\n    remove: () => void;\n};\n\nexport interface NgtcBodyPublicApi extends NgtcWorkerApi {\n    at: (index: number) => NgtcWorkerApi;\n}\n\nexport interface NgtcBodyReturn<TObject extends THREE.Object3D> {\n    ref: NgtInjectedRef<TObject>;\n    api: NgtcBodyPublicApi;\n}\n\nexport type NgtcGetByIndex<T extends BodyProps> = (index: number) => T | Observable<T>;\nexport type NgtcArgFn<T> = (args: T) => unknown[];\n\nexport function injectPlane<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<PlaneProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<PlaneProps, TObject>('Plane', fn, () => [], opts);\n}\n\nexport function injectBox<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<BoxProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    const defaultBoxArgs: Triplet = [1, 1, 1];\n    return injectBody<BoxProps, TObject>('Box', fn, (args = defaultBoxArgs): Triplet => args, opts);\n}\n\nexport function injectCylinder<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<CylinderProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<CylinderProps, TObject>('Cylinder', fn, (args = [] as []) => args, opts);\n}\n\nexport function injectHeightfield<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<HeightfieldProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<HeightfieldProps, TObject>('Heightfield', fn, (args) => args, opts);\n}\n\nexport function injectParticle<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<ParticleProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<ParticleProps, TObject>('Particle', fn, () => [], opts);\n}\n\nexport function injectSphere<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<SphereProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<SphereProps, TObject>(\n        'Sphere',\n        fn,\n        (args: SphereArgs = [1]): SphereArgs => {\n            if (!Array.isArray(args)) throw new Error('injectSphere args must be an array');\n            return [args[0]];\n        },\n        opts\n    );\n}\n\nexport function injectTrimesh<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<TrimeshProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<TrimeshProps, TObject>('Trimesh', fn, (args) => args, opts);\n}\n\nexport function injectConvexPolyhedron<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<ConvexPolyhedronProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<ConvexPolyhedronProps, TObject>(\n        'ConvexPolyhedron',\n        fn,\n        ([vertices, faces, normals, axes, boundingSphereRadius] = []): ConvexPolyhedronArgs<Triplet> => [\n            vertices && vertices.map(NgtcUtils.makeTriplet),\n            faces,\n            normals && normals.map(NgtcUtils.makeTriplet),\n            axes && axes.map(NgtcUtils.makeTriplet),\n            boundingSphereRadius,\n        ],\n        opts\n    );\n}\n\nexport function injectCompoundBody<TObject extends THREE.Object3D>(\n    fn: NgtcGetByIndex<CompoundBodyProps>,\n    opts?: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> }\n) {\n    return injectBody<CompoundBodyProps, TObject>('Compound', fn, (args) => args as unknown[], opts);\n}\n\nconst temp = new THREE.Object3D();\n\nfunction injectBody<TBodyProps extends BodyProps, TObject extends THREE.Object3D>(\n    type: BodyShapeType,\n    getPropsFn: NgtcGetByIndex<TBodyProps>,\n    argsFn: NgtcArgFn<TBodyProps['args']>,\n    { ref, waitFor }: { ref?: NgtInjectedRef<TObject>; waitFor?: Observable<unknown> } = {}\n): NgtcBodyReturn<TObject> {\n    let subscription: Subscription | undefined = undefined;\n\n    // a ReplaySubject that would emit once in queueMicrotask call\n    const microQueue$ = new ReplaySubject<void>(1);\n    // a ReplaySubject that would emit whenever our props emits. This is done so that the consumers can pass in\n    // Observable to injectBody if they have reactive props (eg: Input)\n    const propsSubject$ = new ReplaySubject<TBodyProps>(1);\n\n    // an array of streams we want to wait to emit until we decide to give the bodyRef an empty Object3D\n    const waits$ = [microQueue$] as Observable<unknown>[];\n\n    const debugApi = inject(NGTC_DEBUG_API, { skipSelf: true, optional: true });\n    const physicsStore = inject(NgtcStore, { skipSelf: true });\n\n    // clean up our streams on destroy\n    injectNgtDestroy(() => {\n        microQueue$.complete();\n        propsSubject$.complete();\n        subscription?.unsubscribe();\n    });\n\n    // give our bodyRef an NgtInjectedRef\n    let bodyRef = injectNgtRef<TObject>();\n\n    // add waitFor if the consumers pass it in\n    if (waitFor) waits$.push(waitFor);\n    // re-assign bodyRef if the consumers pass a ref in\n    if (ref) bodyRef = ref;\n\n    // fire microQueue$\n    queueMicrotask(() => microQueue$.next());\n\n    // when all waits$ emit, we give bodyRef an empty Object3D if it doesn't have one. Physic Object can still be affected\n    // by Physics without a visual representation\n    combineLatest(waits$).subscribe(() => (bodyRef.nativeElement ||= new THREE.Object3D() as TObject));\n\n    // start the pipeline as soon as bodyRef has a truthy value\n    subscription = bodyRef.$.pipe(\n        switchMap((object) => {\n            const { events, refs, worker } = physicsStore.get();\n\n            const currentWorker = worker;\n            let objectCount = 1;\n\n            if (object instanceof THREE.InstancedMesh) {\n                object.instanceMatrix.setUsage(THREE.DynamicDrawUsage);\n                objectCount = object.count;\n            }\n\n            // consolidate our uuids into an Array so we can handle them in a more consistent way\n            const uuids =\n                object instanceof THREE.InstancedMesh\n                    ? new Array(objectCount).fill(0).map((_, i) => `${object.uuid}/${i}`)\n                    : [object.uuid];\n\n            // construct an Array<Observable> from getPropsFn\n            // so we can react to props changed\n            const propsList$ = uuids.map((uuid, index) => {\n                const propsResult = getPropsFn(index);\n                // TODO  we use a propsSubject$ because we want to ensure this propsResult stream is HOT\n                // otherwise, tapEffect will remove everything from currentWorker#bodies because the stream completes\n                (isObservable(propsResult) ? propsResult : of(propsResult)).subscribe({\n                    next: (props) => {\n                        NgtcUtils.prepare(temp, props);\n                        if (object instanceof THREE.InstancedMesh) {\n                            object.setMatrixAt(index, temp.matrix);\n                            object.instanceMatrix.needsUpdate = true;\n                        }\n                        refs[uuid] = object;\n                        debugApi?.add(uuid, props, type);\n                        NgtcUtils.setupCollision(events, props, uuid);\n                        propsSubject$.next({ ...props, args: argsFn(props.args) });\n                    },\n                    error: (error) => {\n                        console.error(`[NGT Cannon] Error with processing props: ${error}`);\n                        propsSubject$.error(error);\n                    },\n                });\n\n                return propsSubject$;\n            });\n\n            return combineLatest(propsList$).pipe(\n                tapEffect((props) => {\n                    currentWorker.addBodies({\n                        props: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => ({\n                            onCollide: Boolean(onCollide),\n                            onCollideBegin: Boolean(onCollideBegin),\n                            onCollideEnd: Boolean(onCollideEnd),\n                            ...serializableProps,\n                        })),\n                        type,\n                        uuid: uuids,\n                    });\n                    // clean up CannonWorker whenever props changes/completes\n                    return () => {\n                        uuids.forEach((uuid) => {\n                            delete refs[uuid];\n                            debugApi?.remove(uuid);\n                            delete events[uuid];\n                        });\n                        currentWorker.removeBodies({ uuid: uuids });\n                    };\n                })\n            );\n        })\n    ).subscribe();\n\n    const makeAtomic = <T extends AtomicName>(type: T, index?: number) => {\n        const op: SetOpName<T> = `set${NgtcUtils.capitalize(type)}`;\n\n        return {\n            set: (value: PropValue<T>) => {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker[op]({ props: value, uuid } as never);\n            },\n            get subscribe() {\n                const { subscriptions, worker } = physicsStore.get();\n                return NgtcUtils.subscribe(bodyRef, worker, subscriptions, type, index);\n            },\n        };\n    };\n\n    const makeQuaternion = (index?: number) => {\n        const type = 'quaternion';\n        return {\n            copy: ({ w, x, y, z }: THREE.Quaternion) => {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.setQuaternion({ props: [x, y, z, w], uuid });\n            },\n            set: (x: number, y: number, z: number, w: number) => {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.setQuaternion({ props: [x, y, z, w], uuid });\n            },\n            get subscribe() {\n                const { subscriptions, worker } = physicsStore.get();\n                return NgtcUtils.subscribe(bodyRef, worker, subscriptions, type, index);\n            },\n        };\n    };\n\n    const makeRotation = (index?: number) => {\n        return {\n            copy: ({ x, y, z }: THREE.Vector3 | THREE.Euler) => {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.setRotation({ props: [x, y, z], uuid });\n            },\n            set: (x: number, y: number, z: number) => {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.setRotation({ props: [x, y, z], uuid });\n            },\n            subscribe: (callback: (value: Triplet) => void) => {\n                const { subscriptions, worker } = physicsStore.get();\n                const id = NgtcUtils.incrementingId++;\n                const target = 'bodies';\n                const type = 'quaternion';\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n\n                subscriptions[id] = { [type]: NgtcUtils.quaternionToRotation(callback) };\n                uuid && worker.subscribe({ props: { id, target, type }, uuid });\n                return () => {\n                    delete subscriptions[id];\n                    worker.unsubscribe({ props: id });\n                };\n            },\n        };\n    };\n\n    const makeVec = (type: VectorName, index?: number) => {\n        const op: SetOpName<VectorName> = `set${NgtcUtils.capitalize(type)}`;\n        return {\n            copy: ({ x, y, z }: THREE.Vector3 | THREE.Euler) => {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker[op]({ props: [x, y, z], uuid });\n            },\n            set: (x: number, y: number, z: number) => {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker[op]({ props: [x, y, z], uuid });\n            },\n            get subscribe() {\n                const { subscriptions, worker } = physicsStore.get();\n                return NgtcUtils.subscribe(bodyRef, worker, subscriptions, type, index);\n            },\n        };\n    };\n\n    const makeRemove = (index?: number) => {\n        const { worker } = physicsStore.get();\n        const uuid = NgtcUtils.getUUID(bodyRef, index);\n        return () => {\n            if (uuid) worker.removeBodies({ uuid: [uuid] });\n        };\n    };\n\n    function makeApi(index?: number): NgtcWorkerApi {\n        return {\n            allowSleep: makeAtomic('allowSleep', index),\n            angularDamping: makeAtomic('angularDamping', index),\n            angularFactor: makeVec('angularFactor', index),\n            angularVelocity: makeVec('angularVelocity', index),\n            applyForce(force: Triplet, worldPoint: Triplet) {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.applyForce({ props: [force, worldPoint], uuid });\n            },\n            applyImpulse(impulse: Triplet, worldPoint: Triplet) {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.applyImpulse({ props: [impulse, worldPoint], uuid });\n            },\n            applyLocalForce(force: Triplet, localPoint: Triplet) {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.applyLocalForce({ props: [force, localPoint], uuid });\n            },\n            applyLocalImpulse(impulse: Triplet, localPoint: Triplet) {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.applyLocalImpulse({ props: [impulse, localPoint], uuid });\n            },\n            applyTorque(torque: Triplet) {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.applyTorque({ props: [torque], uuid });\n            },\n            collisionFilterGroup: makeAtomic('collisionFilterGroup', index),\n            collisionFilterMask: makeAtomic('collisionFilterMask', index),\n            collisionResponse: makeAtomic('collisionResponse', index),\n            fixedRotation: makeAtomic('fixedRotation', index),\n            isTrigger: makeAtomic('isTrigger', index),\n            linearDamping: makeAtomic('linearDamping', index),\n            linearFactor: makeVec('linearFactor', index),\n            mass: makeAtomic('mass', index),\n            material: makeAtomic('material', index),\n            position: makeVec('position', index),\n            quaternion: makeQuaternion(index),\n            remove: makeRemove(index),\n            rotation: makeRotation(index),\n            scaleOverride(scale) {\n                const { scaleOverrides } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                if (uuid) scaleOverrides[uuid] = new THREE.Vector3(...scale);\n            },\n            sleep() {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.sleep({ uuid });\n            },\n            sleepSpeedLimit: makeAtomic('sleepSpeedLimit', index),\n            sleepTimeLimit: makeAtomic('sleepTimeLimit', index),\n            userData: makeAtomic('userData', index),\n            velocity: makeVec('velocity', index),\n            wakeUp() {\n                const { worker } = physicsStore.get();\n                const uuid = NgtcUtils.getUUID(bodyRef, index);\n                uuid && worker.wakeUp({ uuid });\n            },\n        };\n    }\n\n    const cache: { [index: number]: NgtcWorkerApi } = {};\n    const api = { ...makeApi(undefined), at: (index: number) => cache[index] || (cache[index] = makeApi(index)) };\n    return { ref: bodyRef, api };\n}\n"]}

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

@@ -0,0 +1,124 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Component, CUSTOM_ELEMENTS_SCHEMA, Input } from '@angular/core';
+import { propsToBody } from '@pmndrs/cannon-worker-api';
+import { injectBeforeRender, NgtArgs } from 'angular-three';
+import { NgtcStore } 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 {
+    constructor() {
+        this.color = 'black';
+        this.scale = 1;
+        this.impl = CannonDebugger;
+        this.disabled = false;
+        this.bodies = [];
+        this.bodyMap = {};
+        this.scene = new THREE.Scene();
+        this.physicsStore = inject(NgtcStore, { skipSelf: true });
+        injectBeforeRender(() => {
+            if (!this.cannonDebugger)
+                return;
+            const refs = this.physicsStore.get('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,
+        });
+    }
+}
+NgtcDebug.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.1", ngImport: i0, type: NgtcDebug, deps: [], target: i0.ɵɵFactoryTarget.Component });
+NgtcDebug.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.1.1", type: NgtcDebug, isStandalone: true, selector: "ngtc-debug", inputs: { color: "color", scale: "scale", impl: "impl", disabled: "disabled" }, providers: [
+        {
+            provide: NGTC_DEBUG_API,
+            useFactory: (debug) => ({
+                add: (uuid, props, type) => {
+                    const body = propsToBody({ uuid, props, type });
+                    debug.bodies.push(body);
+                    debug.bodyMap[uuid] = body;
+                },
+                remove: (id) => {
+                    const debugBodyIndex = debug.bodies.indexOf(debug.bodyMap[id]);
+                    if (debugBodyIndex > -1)
+                        debug.bodies.splice(debugBodyIndex, 1);
+                    delete debug.bodyMap[id];
+                },
+            }),
+            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: "15.1.1", 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) => ({
+                                add: (uuid, props, type) => {
+                                    const body = propsToBody({ uuid, props, type });
+                                    debug.bodies.push(body);
+                                    debug.bodyMap[uuid] = body;
+                                },
+                                remove: (id) => {
+                                    const debugBodyIndex = debug.bodies.indexOf(debug.bodyMap[id]);
+                                    if (debugBodyIndex > -1)
+                                        debug.bodies.splice(debugBodyIndex, 1);
+                                    delete debug.bodyMap[id];
+                                },
+                            }),
+                            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/fesm2015/angular-three-cannon-debug.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-three-cannon-debug.mjs","sources":["../../../../libs/angular-three-cannon/debug/src/lib/debug.ts","../../../../libs/angular-three-cannon/debug/src/angular-three-cannon-debug.ts"],"sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, InjectionToken, Input, OnInit } from '@angular/core';\nimport { BodyProps, BodyShapeType, propsToBody } from '@pmndrs/cannon-worker-api';\nimport { injectBeforeRender, NgtArgs } from 'angular-three';\nimport { NgtcStore } 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 type NgtcDebugApi = {\n    add(id: string, props: BodyProps, type: BodyShapeType): void;\n    remove(id: string): void;\n};\n\nexport const NGTC_DEBUG_API = new InjectionToken<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: [\n        {\n            provide: NGTC_DEBUG_API,\n            useFactory: (debug: NgtcDebug) => ({\n                add: (uuid: string, props: BodyProps, type: BodyShapeType) => {\n                    const body = propsToBody({ uuid, props, type });\n                    debug.bodies.push(body);\n                    debug.bodyMap[uuid] = body;\n                },\n                remove: (id: string) => {\n                    const debugBodyIndex = debug.bodies.indexOf(debug.bodyMap[id]);\n                    if (debugBodyIndex > -1) debug.bodies.splice(debugBodyIndex, 1);\n                    delete debug.bodyMap[id];\n                },\n            }),\n            deps: [NgtcDebug],\n        },\n    ],\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    private readonly physicsStore = inject(NgtcStore, { skipSelf: true });\n\n    private cannonDebugger!: ReturnType<typeof CannonDebugger>;\n\n    constructor() {\n        injectBeforeRender(() => {\n            if (!this.cannonDebugger) return;\n            const refs = this.physicsStore.get('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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"}