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

package/README.md

@@ -1,15 +1,7 @@
-# Physics utilities for Angular Three using CannonJS
+# cannon
 
-## Installation
+This library was generated with [Nx](https://nx.dev).
 
-```shell
-ng add angular-three-cannon
-```
+## Running unit tests
 
-## Documentations
-
-Read more about Angular Three Cannon usages in [TBD: Documentations](#)
-
-## Contributions
-
-Contributions are welcomed
+Run `nx test cannon` to execute the unit tests.

package/debug/{lib/debug.d.ts → debug.d.ts}

@@ -1,26 +1,26 @@
-import { InjectionToken, OnInit } from '@angular/core';
+import { InjectionToken, OnInit, Signal } from '@angular/core';
 import { BodyProps, BodyShapeType } from '@pmndrs/cannon-worker-api';
-import { Body } from 'cannon-es';
 import CannonDebugger from 'cannon-es-debugger';
 import * as THREE from 'three';
 import * as i0 from "@angular/core";
-export type NgtcDebugApi = {
+export interface NgtcDebugApi {
     add(id: string, props: BodyProps, type: BodyShapeType): void;
     remove(id: string): void;
-};
-export declare const NGTC_DEBUG_API: InjectionToken<NgtcDebugApi>;
+}
+export declare const NGTC_DEBUG_API: InjectionToken<Signal<NgtcDebugApi>>;
 export declare class NgtcDebug implements OnInit {
+    #private;
     color: string;
     scale: number;
     impl: typeof CannonDebugger;
     disabled: boolean;
-    readonly bodies: Body[];
-    readonly bodyMap: Record<string, Body>;
     readonly scene: THREE.Scene;
-    private readonly physicsStore;
-    private cannonDebugger;
+    readonly api: Signal<{
+        add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
+        remove: (id: string) => void;
+    }>;
     constructor();
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtcDebug, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtcDebug, "ngtc-debug", never, { "color": "color"; "scale": "scale"; "impl": "impl"; "disabled": "disabled"; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtcDebug, "ngtc-debug", never, { "color": { "alias": "color"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "impl": { "alias": "impl"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/debug/index.d.ts

@@ -1 +1 @@
-export * from './lib/debug';
+export * from './debug';

package/esm2022/angular-three-cannon.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1jYW5ub24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9zcmMvYW5ndWxhci10aHJlZS1jYW5ub24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

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

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1jYW5ub24tZGVidWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9kZWJ1Zy9zcmMvYW5ndWxhci10aHJlZS1jYW5ub24tZGVidWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/debug/debug.mjs

@@ -0,0 +1,99 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, inject, InjectionToken, 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';
+import * as i0 from "@angular/core";
+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;
+}
+export 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"] }] }); }
+}
+export { NgtcDebug };
+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
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug.js","sourceRoot":"","sources":["../../../../../libs/cannon/debug/src/debug.ts"],"names":[],"mappings":"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","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"]}

package/esm2022/debug/index.mjs

@@ -0,0 +1,2 @@
+export * from './debug';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9kZWJ1Zy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RlYnVnJztcbiJdfQ==

package/esm2022/index.mjs

@@ -0,0 +1,2 @@
+export * from './physics';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BoeXNpY3MnO1xuIl19

package/esm2022/physics.mjs

@@ -0,0 +1,297 @@
+import { Component, InjectionToken, Input, computed, effect, inject, untracked } from '@angular/core';
+import { CannonWorkerAPI, } from '@pmndrs/cannon-worker-api';
+import { NgtSignalStore, NgtStore, injectBeforeRender, requestAnimationInInjectionContext, } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+const v = new THREE.Vector3();
+const s = new THREE.Vector3(1, 1, 1);
+const q = new THREE.Quaternion();
+const m = new THREE.Matrix4();
+function apply(index, positions, quaternions, scale = s, object) {
+    if (index !== undefined) {
+        m.compose(v.fromArray(positions, index * 3), q.fromArray(quaternions, index * 4), scale);
+        if (object) {
+            object.matrixAutoUpdate = false;
+            object.matrix.copy(m);
+        }
+        return m;
+    }
+    return m.identity();
+}
+export const NGTC_PHYSICS_API = new InjectionToken('NgtcPhysics API');
+class NgtcPhysics extends NgtSignalStore {
+    set isPaused(isPaused) {
+        this.set({ isPaused });
+    }
+    set maxSubSteps(maxSubSteps) {
+        this.set({ maxSubSteps });
+    }
+    set shouldInvalidate(shouldInvalidate) {
+        this.set({ shouldInvalidate });
+    }
+    set stepSize(stepSize) {
+        this.set({ stepSize });
+    }
+    set size(size) {
+        this.set({ size });
+    }
+    set allowSleep(allowSleep) {
+        this.set({ allowSleep });
+    }
+    set axisIndex(axisIndex) {
+        this.set({ axisIndex });
+    }
+    set broadphase(broadphase) {
+        this.set({ broadphase });
+    }
+    set defaultContactMaterial(defaultContactMaterial) {
+        this.set({ defaultContactMaterial });
+    }
+    set frictionGravity(frictionGravity) {
+        this.set({ frictionGravity });
+    }
+    set gravity(gravity) {
+        this.set({ gravity });
+    }
+    set iterations(iterations) {
+        this.set({ iterations });
+    }
+    set quatNormalizeFast(quatNormalizeFast) {
+        this.set({ quatNormalizeFast });
+    }
+    set quatNormalizeSkip(quatNormalizeSkip) {
+        this.set({ quatNormalizeSkip });
+    }
+    set solver(solver) {
+        this.set({ solver });
+    }
+    set tolerance(tolerance) {
+        this.set({ tolerance });
+    }
+    #store;
+    #bodies;
+    #events;
+    #refs;
+    #scaleOverrides;
+    #subscriptions;
+    #allowSleep;
+    #defaultContactMaterial;
+    #frictionGravity;
+    #quatNormalizeFast;
+    #quatNormalizeSkip;
+    #size;
+    #solver;
+    #workerProps;
+    constructor() {
+        super({
+            allowSleep: false,
+            axisIndex: 0,
+            broadphase: 'Naive',
+            defaultContactMaterial: { contactEquationStiffness: 1e6 },
+            frictionGravity: null,
+            gravity: [0, -9.81, 0],
+            isPaused: false,
+            iterations: 5,
+            maxSubSteps: 10,
+            quatNormalizeFast: false,
+            quatNormalizeSkip: 0,
+            shouldInvalidate: true,
+            size: 1000,
+            solver: 'GS',
+            stepSize: 1 / 60,
+            tolerance: 0.001,
+        });
+        this.#store = inject(NgtStore);
+        this.#bodies = {};
+        this.#events = {};
+        this.#refs = {};
+        this.#scaleOverrides = {};
+        this.#subscriptions = {};
+        this.#allowSleep = this.select('allowSleep');
+        this.#defaultContactMaterial = this.select('defaultContactMaterial');
+        this.#frictionGravity = this.select('frictionGravity');
+        this.#quatNormalizeFast = this.select('quatNormalizeFast');
+        this.#quatNormalizeSkip = this.select('quatNormalizeSkip');
+        this.#size = this.select('size');
+        this.#solver = this.select('solver');
+        this.#workerProps = computed(() => ({
+            allowSleep: this.#allowSleep(),
+            axisIndex: this.get('axisIndex'),
+            broadphase: this.get('broadphase'),
+            defaultContactMaterial: this.#defaultContactMaterial(),
+            frictionGravity: this.#frictionGravity(),
+            gravity: this.get('gravity'),
+            iterations: this.get('iterations'),
+            quatNormalizeFast: this.#quatNormalizeFast(),
+            quatNormalizeSkip: this.#quatNormalizeSkip(),
+            size: this.#size(),
+            solver: this.#solver(),
+            tolerance: this.get('tolerance'),
+        }));
+        this.worker = computed(() => {
+            const workerProps = this.#workerProps();
+            return new CannonWorkerAPI(workerProps);
+        });
+        this.api = computed(() => ({
+            bodies: this.#bodies,
+            events: this.#events,
+            refs: this.#refs,
+            scaleOverrides: this.#scaleOverrides,
+            subscriptions: this.#subscriptions,
+            worker: this.worker(),
+        }));
+        requestAnimationInInjectionContext(() => {
+            this.#connectWorker();
+            this.#updateWorkerProp('axisIndex');
+            this.#updateWorkerProp('broadphase');
+            this.#updateWorkerProp('gravity');
+            this.#updateWorkerProp('iterations');
+            this.#updateWorkerProp('tolerance');
+            injectBeforeRender(this.#onBeforeRender.bind(this, 0));
+        });
+    }
+    #updateWorkerProp(key) {
+        const compute = this.select(key);
+        effect(() => {
+            const worker = untracked(this.worker);
+            const value = compute();
+            // @ts-expect-error
+            worker[key] = value;
+        });
+    }
+    #connectWorker() {
+        effect((onCleanup) => {
+            const worker = this.worker();
+            worker.connect();
+            worker.init();
+            worker.on('collide', this.#collideHandler.bind(this));
+            worker.on('collideBegin', this.#collideBeginHandler.bind(this));
+            worker.on('collideEnd', this.#collideEndHandler.bind(this));
+            worker.on('frame', this.#frameHandler.bind(this));
+            worker.on('rayhit', this.#rayhitHandler.bind(this));
+            onCleanup(() => {
+                worker.terminate();
+                worker.removeAllListeners();
+            });
+        });
+    }
+    #onBeforeRender(timeSinceLastCalled, { delta }) {
+        const { isPaused, maxSubSteps, stepSize } = this.get();
+        const worker = this.worker();
+        if (isPaused)
+            return;
+        timeSinceLastCalled += delta;
+        worker.step({ maxSubSteps, stepSize: stepSize, timeSinceLastCalled });
+        timeSinceLastCalled = 0;
+    }
+    #collideHandler({ body, contact: { bi, bj, ...contactRest }, target, ...rest }) {
+        const cb = this.#events[target]?.collide;
+        if (cb) {
+            cb({
+                body: this.#refs[body],
+                contact: { bi: this.#refs[bi], bj: this.#refs[bj], ...contactRest },
+                target: this.#refs[target],
+                ...rest,
+            });
+        }
+    }
+    #collideBeginHandler({ bodyA, bodyB }) {
+        const cbA = this.#events[bodyA]?.collideBegin;
+        if (cbA)
+            cbA({ body: this.#refs[bodyB], op: 'event', target: this.#refs[bodyA], type: 'collideBegin' });
+        const cbB = this.#events[bodyB]?.collideBegin;
+        if (cbB)
+            cbB({ body: this.#refs[bodyA], op: 'event', target: this.#refs[bodyB], type: 'collideBegin' });
+    }
+    #collideEndHandler({ bodyA, bodyB }) {
+        const cbA = this.#events[bodyA]?.collideEnd;
+        if (cbA)
+            cbA({ body: this.#refs[bodyB], op: 'event', target: this.#refs[bodyA], type: 'collideEnd' });
+        const cbB = this.#events[bodyB]?.collideEnd;
+        if (cbB)
+            cbB({ body: this.#refs[bodyA], op: 'event', target: this.#refs[bodyB], type: 'collideEnd' });
+    }
+    #frameHandler({ active, bodies: uuids = [], observations, positions, quaternions }) {
+        const invalidate = this.#store.get('invalidate');
+        const shouldInvalidate = this.get('shouldInvalidate');
+        for (let i = 0; i < uuids.length; i++) {
+            this.#bodies[uuids[i]] = i;
+        }
+        observations.forEach(([id, value, type]) => {
+            const subscription = this.#subscriptions[id] || {};
+            const cb = subscription[type];
+            // HELP: We clearly know the type of the callback, but typescript can't deal with it
+            cb && cb(value);
+        });
+        if (active) {
+            for (const ref of Object.values(this.#refs)) {
+                if (ref instanceof THREE.InstancedMesh) {
+                    for (let i = 0; i < ref.count; i++) {
+                        const uuid = `${ref.uuid}/${i}`;
+                        const index = this.#bodies[uuid];
+                        if (index !== undefined) {
+                            ref.setMatrixAt(i, apply(index, positions, quaternions, this.#scaleOverrides[uuid]));
+                            ref.instanceMatrix.needsUpdate = true;
+                        }
+                    }
+                }
+                else {
+                    const scale = this.#scaleOverrides[ref.uuid] || ref.scale;
+                    apply(this.#bodies[ref.uuid], positions, quaternions, scale, ref);
+                }
+            }
+            if (shouldInvalidate)
+                invalidate();
+        }
+    }
+    #rayhitHandler({ body, ray: { uuid, ...rayRest }, ...rest }) {
+        const cb = this.#events[uuid]?.rayhit;
+        if (cb)
+            cb({ body: body ? this.#refs[body] : null, ray: { uuid, ...rayRest }, ...rest });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtcPhysics, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtcPhysics, isStandalone: true, selector: "ngtc-physics", inputs: { isPaused: "isPaused", maxSubSteps: "maxSubSteps", shouldInvalidate: "shouldInvalidate", stepSize: "stepSize", size: "size", allowSleep: "allowSleep", axisIndex: "axisIndex", broadphase: "broadphase", defaultContactMaterial: "defaultContactMaterial", frictionGravity: "frictionGravity", gravity: "gravity", iterations: "iterations", quatNormalizeFast: "quatNormalizeFast", quatNormalizeSkip: "quatNormalizeSkip", solver: "solver", tolerance: "tolerance" }, providers: [{ provide: NGTC_PHYSICS_API, useFactory: (physics) => physics.api, deps: [NgtcPhysics] }], usesInheritance: true, ngImport: i0, template: `<ng-content />`, isInline: true }); }
+}
+export { NgtcPhysics };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtcPhysics, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtc-physics',
+                    standalone: true,
+                    template: `<ng-content />`,
+                    providers: [{ provide: NGTC_PHYSICS_API, useFactory: (physics) => physics.api, deps: [NgtcPhysics] }],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { isPaused: [{
+                type: Input
+            }], maxSubSteps: [{
+                type: Input
+            }], shouldInvalidate: [{
+                type: Input
+            }], stepSize: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], allowSleep: [{
+                type: Input
+            }], axisIndex: [{
+                type: Input
+            }], broadphase: [{
+                type: Input
+            }], defaultContactMaterial: [{
+                type: Input
+            }], frictionGravity: [{
+                type: Input
+            }], gravity: [{
+                type: Input
+            }], iterations: [{
+                type: Input
+            }], quatNormalizeFast: [{
+                type: Input
+            }], quatNormalizeSkip: [{
+                type: Input
+            }], solver: [{
+                type: Input
+            }], tolerance: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"physics.js","sourceRoot":"","sources":["../../../../libs/cannon/src/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAe,MAAM,eAAe,CAAC;AACnH,OAAO,EACH,eAAe,GAiBlB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACH,cAAc,EACd,QAAQ,EACR,kBAAkB,EAClB,kCAAkC,GAErC,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;;AAE/B,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;AAC9B,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AACrC,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;AACjC,MAAM,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;AAE9B,SAAS,KAAK,CAAC,KAAa,EAAE,SAAuB,EAAE,WAAyB,EAAE,KAAK,GAAG,CAAC,EAAE,MAAuB;IAChH,IAAI,KAAK,KAAK,SAAS,EAAE;QACrB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACzF,IAAI,MAAM,EAAE;YACR,MAAM,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAChC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACzB;QACD,OAAO,CAAC,CAAC;KACZ;IACD,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;AACxB,CAAC;AA2BD,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,cAAc,CAAyB,iBAAiB,CAAC,CAAC;AAE9F,MAMa,WAAY,SAAQ,cAAgC;IAC7D,IAAa,QAAQ,CAAC,QAAiB;QACnC,IAAI,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED,IAAa,WAAW,CAAC,WAAmB;QACxC,IAAI,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED,IAAa,gBAAgB,CAAC,gBAAyB;QACnD,IAAI,CAAC,GAAG,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,IAAa,QAAQ,CAAC,QAAgB;QAClC,IAAI,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED,IAAa,IAAI,CAAC,IAAY;QAC1B,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IACvB,CAAC;IAED,IAAa,UAAU,CAAC,UAAmB;QACvC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,IAAa,SAAS,CAAC,SAAoB;QACvC,IAAI,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,IAAa,UAAU,CAAC,UAAsB;QAC1C,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,IAAa,sBAAsB,CAAC,sBAA8C;QAC9E,IAAI,CAAC,GAAG,CAAC,EAAE,sBAAsB,EAAE,CAAC,CAAC;IACzC,CAAC;IAED,IAAa,eAAe,CAAC,eAA+B;QACxD,IAAI,CAAC,GAAG,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC;IAClC,CAAC;IAED,IAAa,OAAO,CAAC,OAAgB;QACjC,IAAI,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1B,CAAC;IAED,IAAa,UAAU,CAAC,UAAkB;QACtC,IAAI,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,IAAa,iBAAiB,CAAC,iBAA0B;QACrD,IAAI,CAAC,GAAG,CAAC,EAAE,iBAAiB,EAAE,CAAC,CAAC;IACpC,CAAC;IAED,IAAa,iBAAiB,CAAC,iBAAyB;QACpD,IAAI,CAAC,GAAG,CAAC,EAAE,iBAAiB,EAAE,CAAC,CAAC;IACpC,CAAC;IAED,IAAa,MAAM,CAAC,MAAc;QAC9B,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzB,CAAC;IAED,IAAa,SAAS,CAAC,SAAiB;QACpC,IAAI,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;IAC5B,CAAC;IAEQ,MAAM,CAAoB;IAE1B,OAAO,CAAkC;IACzC,OAAO,CAAwB;IAC/B,KAAK,CAAY;IACjB,eAAe,CAAsB;IACrC,cAAc,CAAqB;IAEnC,WAAW,CAA6B;IACxC,uBAAuB,CAAyC;IAChE,gBAAgB,CAAkC;IAClD,kBAAkB,CAAoC;IACtD,kBAAkB,CAAoC;IACtD,KAAK,CAAuB;IAC5B,OAAO,CAAyB;IAEhC,YAAY,CAajB;IAgBJ;QACI,KAAK,CAAC;YACF,UAAU,EAAE,KAAK;YACjB,SAAS,EAAE,CAAC;YACZ,UAAU,EAAE,OAAO;YACnB,sBAAsB,EAAE,EAAE,wBAAwB,EAAE,GAAG,EAAE;YACzD,eAAe,EAAE,IAAI;YACrB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;YACtB,QAAQ,EAAE,KAAK;YACf,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,EAAE;YACf,iBAAiB,EAAE,KAAK;YACxB,iBAAiB,EAAE,CAAC;YACpB,gBAAgB,EAAE,IAAI;YACtB,IAAI,EAAE,IAAI;YACV,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,CAAC,GAAG,EAAE;YAChB,SAAS,EAAE,KAAK;SACnB,CAAC,CAAC;QA/DE,WAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAE1B,YAAO,GAA+B,EAAE,CAAC;QACzC,YAAO,GAAqB,EAAE,CAAC;QAC/B,UAAK,GAAS,EAAE,CAAC;QACjB,oBAAe,GAAmB,EAAE,CAAC;QACrC,mBAAc,GAAkB,EAAE,CAAC;QAEnC,gBAAW,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACxC,4BAAuB,GAAG,IAAI,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;QAChE,qBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAClD,uBAAkB,GAAG,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;QACtD,uBAAkB,GAAG,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;QACtD,UAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5B,YAAO,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEhC,iBAAY,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YACpC,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE;YAC9B,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC;YAChC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC;YAClC,sBAAsB,EAAE,IAAI,CAAC,uBAAuB,EAAE;YACtD,eAAe,EAAE,IAAI,CAAC,gBAAgB,EAAE;YACxC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;YAC5B,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC;YAClC,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE;YAC5C,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE;YAC5C,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE;YAClB,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE;YACtB,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC;SACnC,CAAC,CAAC,CAAC;QAEK,WAAM,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC5B,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YACxC,OAAO,IAAI,eAAe,CAAC,WAAW,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEM,QAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAC3B,MAAM,EAAE,IAAI,CAAC,OAAO;YACpB,MAAM,EAAE,IAAI,CAAC,OAAO;YACpB,IAAI,EAAE,IAAI,CAAC,KAAK;YAChB,cAAc,EAAE,IAAI,CAAC,eAAe;YACpC,aAAa,EAAE,IAAI,CAAC,cAAc;YAClC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE;SACxB,CAAC,CAAC,CAAC;QAqBA,kCAAkC,CAAC,GAAG,EAAE;YACpC,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;YACpC,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;YACrC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;YAClC,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;YACrC,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;YACpC,kBAAkB,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;IACP,CAAC;IAED,iBAAiB,CAAC,GAA2B;QACzC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,EAAE;YACR,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACtC,MAAM,KAAK,GAAG,OAAO,EAAE,CAAC;YACxB,mBAAmB;YACnB,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACxB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,cAAc;QACV,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE;YACjB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAE7B,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,IAAI,EAAE,CAAC;YAEb,MAAc,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAC9D,MAAc,CAAC,EAAE,CAAC,cAAc,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YACxE,MAAc,CAAC,EAAE,CAAC,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YACpE,MAAc,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAC1D,MAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAE7D,SAAS,CAAC,GAAG,EAAE;gBACX,MAAM,CAAC,SAAS,EAAE,CAAC;gBAClB,MAAc,CAAC,kBAAkB,EAAE,CAAC;YACzC,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAED,eAAe,CAAC,mBAA2B,EAAE,EAAE,KAAK,EAAkB;QAClE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC7B,IAAI,QAAQ;YAAE,OAAO;QACrB,mBAAmB,IAAI,KAAK,CAAC;QAC7B,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAS,EAAE,mBAAmB,EAAE,CAAC,CAAC;QACvE,mBAAmB,GAAG,CAAC,CAAC;IAC5B,CAAC;IAED,eAAe,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,WAAW,EAAE,EAAE,MAAM,EAAE,GAAG,IAAI,EAA8B;QACtG,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;QAEzC,IAAI,EAAE,EAAE;YACJ,EAAE,CAAC;gBACC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;gBACtB,OAAO,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,GAAG,WAAW,EAAE;gBACnE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;gBAC1B,GAAG,IAAI;aACV,CAAC,CAAC;SACN;IACL,CAAC;IAED,oBAAoB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAmC;QAClE,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;QAC9C,IAAI,GAAG;YAAE,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;QACxG,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;QAC9C,IAAI,GAAG;YAAE,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;IAC5G,CAAC;IAED,kBAAkB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAiC;QAC9D,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;QAC5C,IAAI,GAAG;YAAE,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;QACtG,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;QAC5C,IAAI,GAAG;YAAE,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;IAC1G,CAAC;IAED,aAAa,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAA8B;QAC1G,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACjD,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAEtD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;SAC9B;QAED,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;YACvC,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;YACnD,MAAM,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;YAC9B,oFAAoF;YACpF,EAAE,IAAI,EAAE,CAAC,KAAc,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QAEH,IAAI,MAAM,EAAE;YACR,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;gBACzC,IAAI,GAAG,YAAY,KAAK,CAAC,aAAa,EAAE;oBACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;wBAChC,MAAM,IAAI,GAAG,GAAG,GAAG,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC;wBAChC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;wBACjC,IAAI,KAAK,KAAK,SAAS,EAAE;4BACrB,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;4BACrF,GAAG,CAAC,cAAc,CAAC,WAAW,GAAG,IAAI,CAAC;yBACzC;qBACJ;iBACJ;qBAAM;oBACH,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC;oBAC1D,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;iBACrE;aACJ;YACD,IAAI,gBAAgB;gBAAE,UAAU,EAAE,CAAC;SACtC;IACL,CAAC;IAED,cAAc,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,EAAE,GAAG,IAAI,EAA6B;QAClF,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACtC,IAAI,EAAE;YAAE,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;IAC7F,CAAC;8GApPQ,WAAW;kGAAX,WAAW,6gBAFT,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,OAAoB,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,iDADxG,gBAAgB;;SAGjB,WAAW;2FAAX,WAAW;kBANvB,SAAS;mBAAC;oBACP,QAAQ,EAAE,cAAc;oBACxB,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,gBAAgB;oBAC1B,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,OAAoB,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;iBACrH;0EAEgB,QAAQ;sBAApB,KAAK;gBAIO,WAAW;sBAAvB,KAAK;gBAIO,gBAAgB;sBAA5B,KAAK;gBAIO,QAAQ;sBAApB,KAAK;gBAIO,IAAI;sBAAhB,KAAK;gBAIO,UAAU;sBAAtB,KAAK;gBAIO,SAAS;sBAArB,KAAK;gBAIO,UAAU;sBAAtB,KAAK;gBAIO,sBAAsB;sBAAlC,KAAK;gBAIO,eAAe;sBAA3B,KAAK;gBAIO,OAAO;sBAAnB,KAAK;gBAIO,UAAU;sBAAtB,KAAK;gBAIO,iBAAiB;sBAA7B,KAAK;gBAIO,iBAAiB;sBAA7B,KAAK;gBAIO,MAAM;sBAAlB,KAAK;gBAIO,SAAS;sBAArB,KAAK","sourcesContent":["import { Component, InjectionToken, Input, computed, effect, inject, untracked, type Signal } from '@angular/core';\nimport {\n    CannonWorkerAPI,\n    type Broadphase,\n    type CannonWorkerProps,\n    type CollideBeginEvent,\n    type CollideEndEvent,\n    type CollideEvent,\n    type ContactMaterialOptions,\n    type RayhitEvent,\n    type Refs,\n    type Solver,\n    type Subscriptions,\n    type Triplet,\n    type WorkerCollideBeginEvent,\n    type WorkerCollideEndEvent,\n    type WorkerCollideEvent,\n    type WorkerFrameMessage,\n    type WorkerRayhitEvent,\n} from '@pmndrs/cannon-worker-api';\nimport {\n    NgtSignalStore,\n    NgtStore,\n    injectBeforeRender,\n    requestAnimationInInjectionContext,\n    type NgtRenderState,\n} from 'angular-three';\nimport * as THREE from 'three';\n\nconst v = new THREE.Vector3();\nconst s = new THREE.Vector3(1, 1, 1);\nconst q = new THREE.Quaternion();\nconst m = new THREE.Matrix4();\n\nfunction apply(index: number, positions: Float32Array, quaternions: Float32Array, scale = s, object?: THREE.Object3D) {\n    if (index !== undefined) {\n        m.compose(v.fromArray(positions, index * 3), q.fromArray(quaternions, index * 4), scale);\n        if (object) {\n            object.matrixAutoUpdate = false;\n            object.matrix.copy(m);\n        }\n        return m;\n    }\n    return m.identity();\n}\n\nexport type NgtcPhysicsState = CannonWorkerProps & {\n    isPaused?: boolean;\n    maxSubSteps?: number;\n    shouldInvalidate?: boolean;\n    stepSize?: number;\n};\n\ntype NgtcCannonEvent = CollideBeginEvent | CollideEndEvent | CollideEvent | RayhitEvent;\ntype NgtcCallbackByType<T extends { type: string }> = {\n    [K in T['type']]?: T extends { type: K } ? (e: T) => void : never;\n};\n\nexport type NgtcCannonEvents = { [uuid: string]: Partial<NgtcCallbackByType<NgtcCannonEvent>> };\n\nexport type ScaleOverrides = { [uuid: string]: THREE.Vector3 };\n\nexport interface NgtcPhysicsApi {\n    bodies: { [uuid: string]: number };\n    events: NgtcCannonEvents;\n    refs: Refs;\n    scaleOverrides: ScaleOverrides;\n    subscriptions: Subscriptions;\n    worker: CannonWorkerAPI;\n}\n\nexport const NGTC_PHYSICS_API = new InjectionToken<Signal<NgtcPhysicsApi>>('NgtcPhysics API');\n\n@Component({\n    selector: 'ngtc-physics',\n    standalone: true,\n    template: `<ng-content />`,\n    providers: [{ provide: NGTC_PHYSICS_API, useFactory: (physics: NgtcPhysics) => physics.api, deps: [NgtcPhysics] }],\n})\nexport class NgtcPhysics extends NgtSignalStore<NgtcPhysicsState> {\n    @Input() set isPaused(isPaused: boolean) {\n        this.set({ isPaused });\n    }\n\n    @Input() set maxSubSteps(maxSubSteps: number) {\n        this.set({ maxSubSteps });\n    }\n\n    @Input() set shouldInvalidate(shouldInvalidate: boolean) {\n        this.set({ shouldInvalidate });\n    }\n\n    @Input() set stepSize(stepSize: number) {\n        this.set({ stepSize });\n    }\n\n    @Input() set size(size: number) {\n        this.set({ size });\n    }\n\n    @Input() set allowSleep(allowSleep: boolean) {\n        this.set({ allowSleep });\n    }\n\n    @Input() set axisIndex(axisIndex: 0 | 1 | 2) {\n        this.set({ axisIndex });\n    }\n\n    @Input() set broadphase(broadphase: Broadphase) {\n        this.set({ broadphase });\n    }\n\n    @Input() set defaultContactMaterial(defaultContactMaterial: ContactMaterialOptions) {\n        this.set({ defaultContactMaterial });\n    }\n\n    @Input() set frictionGravity(frictionGravity: Triplet | null) {\n        this.set({ frictionGravity });\n    }\n\n    @Input() set gravity(gravity: Triplet) {\n        this.set({ gravity });\n    }\n\n    @Input() set iterations(iterations: number) {\n        this.set({ iterations });\n    }\n\n    @Input() set quatNormalizeFast(quatNormalizeFast: boolean) {\n        this.set({ quatNormalizeFast });\n    }\n\n    @Input() set quatNormalizeSkip(quatNormalizeSkip: number) {\n        this.set({ quatNormalizeSkip });\n    }\n\n    @Input() set solver(solver: Solver) {\n        this.set({ solver });\n    }\n\n    @Input() set tolerance(tolerance: number) {\n        this.set({ tolerance });\n    }\n\n    readonly #store = inject(NgtStore);\n\n    readonly #bodies: { [uuid: string]: number } = {};\n    readonly #events: NgtcCannonEvents = {};\n    readonly #refs: Refs = {};\n    readonly #scaleOverrides: ScaleOverrides = {};\n    readonly #subscriptions: Subscriptions = {};\n\n    readonly #allowSleep = this.select('allowSleep');\n    readonly #defaultContactMaterial = this.select('defaultContactMaterial');\n    readonly #frictionGravity = this.select('frictionGravity');\n    readonly #quatNormalizeFast = this.select('quatNormalizeFast');\n    readonly #quatNormalizeSkip = this.select('quatNormalizeSkip');\n    readonly #size = this.select('size');\n    readonly #solver = this.select('solver');\n\n    readonly #workerProps = computed(() => ({\n        allowSleep: this.#allowSleep(),\n        axisIndex: this.get('axisIndex'),\n        broadphase: this.get('broadphase'),\n        defaultContactMaterial: this.#defaultContactMaterial(),\n        frictionGravity: this.#frictionGravity(),\n        gravity: this.get('gravity'),\n        iterations: this.get('iterations'),\n        quatNormalizeFast: this.#quatNormalizeFast(),\n        quatNormalizeSkip: this.#quatNormalizeSkip(),\n        size: this.#size(),\n        solver: this.#solver(),\n        tolerance: this.get('tolerance'),\n    }));\n\n    readonly worker = computed(() => {\n        const workerProps = this.#workerProps();\n        return new CannonWorkerAPI(workerProps);\n    });\n\n    readonly api = computed(() => ({\n        bodies: this.#bodies,\n        events: this.#events,\n        refs: this.#refs,\n        scaleOverrides: this.#scaleOverrides,\n        subscriptions: this.#subscriptions,\n        worker: this.worker(),\n    }));\n\n    constructor() {\n        super({\n            allowSleep: false,\n            axisIndex: 0,\n            broadphase: 'Naive',\n            defaultContactMaterial: { contactEquationStiffness: 1e6 },\n            frictionGravity: null,\n            gravity: [0, -9.81, 0],\n            isPaused: false,\n            iterations: 5,\n            maxSubSteps: 10,\n            quatNormalizeFast: false,\n            quatNormalizeSkip: 0,\n            shouldInvalidate: true,\n            size: 1000,\n            solver: 'GS',\n            stepSize: 1 / 60,\n            tolerance: 0.001,\n        });\n        requestAnimationInInjectionContext(() => {\n            this.#connectWorker();\n            this.#updateWorkerProp('axisIndex');\n            this.#updateWorkerProp('broadphase');\n            this.#updateWorkerProp('gravity');\n            this.#updateWorkerProp('iterations');\n            this.#updateWorkerProp('tolerance');\n            injectBeforeRender(this.#onBeforeRender.bind(this, 0));\n        });\n    }\n\n    #updateWorkerProp(key: keyof NgtcPhysicsState) {\n        const compute = this.select(key);\n        effect(() => {\n            const worker = untracked(this.worker);\n            const value = compute();\n            // @ts-expect-error\n            worker[key] = value;\n        });\n    }\n\n    #connectWorker() {\n        effect((onCleanup) => {\n            const worker = this.worker();\n\n            worker.connect();\n            worker.init();\n\n            (worker as any).on('collide', this.#collideHandler.bind(this));\n            (worker as any).on('collideBegin', this.#collideBeginHandler.bind(this));\n            (worker as any).on('collideEnd', this.#collideEndHandler.bind(this));\n            (worker as any).on('frame', this.#frameHandler.bind(this));\n            (worker as any).on('rayhit', this.#rayhitHandler.bind(this));\n\n            onCleanup(() => {\n                worker.terminate();\n                (worker as any).removeAllListeners();\n            });\n        });\n    }\n\n    #onBeforeRender(timeSinceLastCalled: number, { delta }: NgtRenderState) {\n        const { isPaused, maxSubSteps, stepSize } = this.get();\n        const worker = this.worker();\n        if (isPaused) return;\n        timeSinceLastCalled += delta;\n        worker.step({ maxSubSteps, stepSize: stepSize!, timeSinceLastCalled });\n        timeSinceLastCalled = 0;\n    }\n\n    #collideHandler({ body, contact: { bi, bj, ...contactRest }, target, ...rest }: WorkerCollideEvent['data']) {\n        const cb = this.#events[target]?.collide;\n\n        if (cb) {\n            cb({\n                body: this.#refs[body],\n                contact: { bi: this.#refs[bi], bj: this.#refs[bj], ...contactRest },\n                target: this.#refs[target],\n                ...rest,\n            });\n        }\n    }\n\n    #collideBeginHandler({ bodyA, bodyB }: WorkerCollideBeginEvent['data']) {\n        const cbA = this.#events[bodyA]?.collideBegin;\n        if (cbA) cbA({ body: this.#refs[bodyB], op: 'event', target: this.#refs[bodyA], type: 'collideBegin' });\n        const cbB = this.#events[bodyB]?.collideBegin;\n        if (cbB) cbB({ body: this.#refs[bodyA], op: 'event', target: this.#refs[bodyB], type: 'collideBegin' });\n    }\n\n    #collideEndHandler({ bodyA, bodyB }: WorkerCollideEndEvent['data']) {\n        const cbA = this.#events[bodyA]?.collideEnd;\n        if (cbA) cbA({ body: this.#refs[bodyB], op: 'event', target: this.#refs[bodyA], type: 'collideEnd' });\n        const cbB = this.#events[bodyB]?.collideEnd;\n        if (cbB) cbB({ body: this.#refs[bodyA], op: 'event', target: this.#refs[bodyB], type: 'collideEnd' });\n    }\n\n    #frameHandler({ active, bodies: uuids = [], observations, positions, quaternions }: WorkerFrameMessage['data']) {\n        const invalidate = this.#store.get('invalidate');\n        const shouldInvalidate = this.get('shouldInvalidate');\n\n        for (let i = 0; i < uuids.length; i++) {\n            this.#bodies[uuids[i]] = i;\n        }\n\n        observations.forEach(([id, value, type]) => {\n            const subscription = this.#subscriptions[id] || {};\n            const cb = subscription[type];\n            // HELP: We clearly know the type of the callback, but typescript can't deal with it\n            cb && cb(value as never);\n        });\n\n        if (active) {\n            for (const ref of Object.values(this.#refs)) {\n                if (ref instanceof THREE.InstancedMesh) {\n                    for (let i = 0; i < ref.count; i++) {\n                        const uuid = `${ref.uuid}/${i}`;\n                        const index = this.#bodies[uuid];\n                        if (index !== undefined) {\n                            ref.setMatrixAt(i, apply(index, positions, quaternions, this.#scaleOverrides[uuid]));\n                            ref.instanceMatrix.needsUpdate = true;\n                        }\n                    }\n                } else {\n                    const scale = this.#scaleOverrides[ref.uuid] || ref.scale;\n                    apply(this.#bodies[ref.uuid], positions, quaternions, scale, ref);\n                }\n            }\n            if (shouldInvalidate) invalidate();\n        }\n    }\n\n    #rayhitHandler({ body, ray: { uuid, ...rayRest }, ...rest }: WorkerRayhitEvent['data']) {\n        const cb = this.#events[uuid]?.rayhit;\n        if (cb) cb({ body: body ? this.#refs[body] : null, ray: { uuid, ...rayRest }, ...rest });\n    }\n}\n"]}

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

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1jYW5ub24tc2VydmljZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9zZXJ2aWNlcy9zcmMvYW5ndWxhci10aHJlZS1jYW5ub24tc2VydmljZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=