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

package/debug/index.d.ts

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

package/debug/lib/debug.d.ts

@@ -0,0 +1,43 @@
+import { type OnInit } from '@angular/core';
+import { type BodyProps, type BodyShapeType } from '@pmndrs/cannon-worker-api';
+import CannonDebugger from 'cannon-es-debugger';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export declare const injectNgtcDebugApi: {
+    (): {
+        add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
+        remove: (id: string) => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    }): {
+        add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
+        remove: (id: string) => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions): {
+        add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
+        remove: (id: string) => void;
+    } | null;
+}, provideNgtcDebugApi: (value?: {
+    add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
+    remove: (id: string) => void;
+} | undefined) => import("@angular/core").Provider;
+export declare class NgtcDebug implements OnInit {
+    color: string;
+    scale: number;
+    impl: typeof CannonDebugger;
+    disabled: boolean;
+    private bodies;
+    private bodyMap;
+    private physicsApi;
+    scene: THREE.Scene;
+    private cannonDebugger;
+    api: {
+        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": { "alias": "color"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "impl": { "alias": "impl"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/esm2022/debug/index.mjs

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

package/esm2022/debug/lib/debug.mjs

@@ -0,0 +1,97 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, forwardRef, Input } from '@angular/core';
+import { propsToBody } from '@pmndrs/cannon-worker-api';
+import { createInjectionToken, injectBeforeRender, NgtArgs } from 'angular-three';
+import { injectNgtcPhysicsApi } 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 [injectNgtcDebugApi, provideNgtcDebugApi] = createInjectionToken((debug) => debug.api, {
+    isRoot: false,
+    deps: [forwardRef(() => NgtcDebug)],
+});
+export class NgtcDebug {
+    constructor() {
+        this.color = 'black';
+        this.scale = 1;
+        this.impl = CannonDebugger;
+        this.disabled = false;
+        this.bodies = [];
+        this.bodyMap = {};
+        this.physicsApi = injectNgtcPhysicsApi();
+        this.scene = new THREE.Scene();
+        this.api = {
+            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.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,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtcDebug, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtcDebug, isStandalone: true, selector: "ngtc-debug", inputs: { color: "color", scale: "scale", impl: "impl", disabled: "disabled" }, providers: [provideNgtcDebugApi()], ngImport: i0, template: `
+		<ngt-primitive *args="[scene]" />
+		<ng-content />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtcDebug, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtc-debug',
+                    standalone: true,
+                    template: `
+		<ngt-primitive *args="[scene]" />
+		<ng-content />
+	`,
+                    providers: [provideNgtcDebugApi()],
+                    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/lib/debug.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, CUSTOM_ELEMENTS_SCHEMA, forwardRef, Input, type OnInit } from '@angular/core';\nimport { propsToBody, type BodyProps, type BodyShapeType } from '@pmndrs/cannon-worker-api';\nimport { createInjectionToken, injectBeforeRender, NgtArgs } from 'angular-three';\nimport { injectNgtcPhysicsApi } from 'angular-three-cannon';\nimport type { 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\tif (o instanceof THREE.InstancedMesh) {\n\t\to.getMatrixAt(parseInt(o.uuid.split('/')[1]), m);\n\t\treturn m;\n\t}\n\treturn o.matrix;\n}\n\nexport const [injectNgtcDebugApi, provideNgtcDebugApi] = createInjectionToken((debug: NgtcDebug) => debug.api, {\n\tisRoot: false,\n\tdeps: [forwardRef(() => NgtcDebug)],\n});\n\n@Component({\n\tselector: 'ngtc-debug',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-primitive *args=\"[scene]\" />\n\t\t<ng-content />\n\t`,\n\tproviders: [provideNgtcDebugApi()],\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtcDebug implements OnInit {\n\t@Input() color = 'black';\n\t@Input() scale = 1;\n\t@Input() impl = CannonDebugger;\n\t@Input() disabled = false;\n\n\tprivate bodies: Body[] = [];\n\tprivate bodyMap: Record<string, Body> = {};\n\n\tprivate physicsApi = injectNgtcPhysicsApi();\n\n\tscene = new THREE.Scene();\n\tprivate cannonDebugger!: ReturnType<typeof CannonDebugger>;\n\n\tapi = {\n\t\tadd: (uuid: string, props: BodyProps, type: BodyShapeType) => {\n\t\t\tconst body = propsToBody({ uuid, props, type });\n\t\t\tthis.bodies.push(body);\n\t\t\tthis.bodyMap[uuid] = body;\n\t\t},\n\t\tremove: (id: string) => {\n\t\t\tconst debugBodyIndex = this.bodies.indexOf(this.bodyMap[id]);\n\t\t\tif (debugBodyIndex > -1) this.bodies.splice(debugBodyIndex, 1);\n\t\t\tdelete this.bodyMap[id];\n\t\t},\n\t};\n\n\tconstructor() {\n\t\tinjectBeforeRender(() => {\n\t\t\tif (!this.cannonDebugger) return;\n\t\t\tconst refs = this.physicsApi.get('refs');\n\t\t\tfor (const uuid in this.bodyMap) {\n\t\t\t\tgetMatrix(refs[uuid]).decompose(v, q, s);\n\t\t\t\tthis.bodyMap[uuid].position.copy(v as unknown as Vec3);\n\t\t\t\tthis.bodyMap[uuid].quaternion.copy(q as unknown as CQuarternion);\n\t\t\t}\n\n\t\t\tfor (const child of this.scene.children) {\n\t\t\t\tchild.visible = !this.disabled;\n\t\t\t}\n\n\t\t\tif (!this.disabled) {\n\t\t\t\tthis.cannonDebugger.update();\n\t\t\t}\n\t\t});\n\t}\n\n\tngOnInit() {\n\t\tthis.cannonDebugger = this.impl(this.scene, { bodies: this.bodies } as World, {\n\t\t\tcolor: this.color,\n\t\t\tscale: this.scale,\n\t\t});\n\t}\n}\n"]}

package/esm2022/index.mjs

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

package/esm2022/lib/physics.mjs

@@ -0,0 +1,293 @@
+import { Component, Injector, Input, NgZone, effect, forwardRef, inject, untracked } from '@angular/core';
+import { CannonWorkerAPI, } from '@pmndrs/cannon-worker-api';
+import { createInjectionToken, injectBeforeRender, injectNgtStore, signalStore } 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();
+}
+const unique = () => {
+    const values = [];
+    return (value) => (values.includes(value) ? false : !!values.push(value));
+};
+export const [injectNgtcPhysicsApi, provideNgtcPhysicsApi] = createInjectionToken((physics) => physics.api, { isRoot: false, deps: [forwardRef(() => NgtcPhysics)] });
+export class NgtcPhysics {
+    constructor() {
+        this.inputs = signalStore({
+            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.zone = inject(NgZone);
+        this.injector = inject(Injector);
+        this.store = injectNgtStore();
+        this.invalidate = this.store.select('invalidate');
+        this.api = signalStore({
+            bodies: {},
+            events: {},
+            refs: {},
+            scaleOverrides: {},
+            subscriptions: {},
+            worker: null,
+        });
+        this.worker = this.api.select('worker');
+    }
+    set _isPaused(isPaused) {
+        this.inputs.set({ isPaused });
+    }
+    set _maxSubSteps(maxSubSteps) {
+        this.inputs.set({ maxSubSteps });
+    }
+    set _shouldInvalidate(shouldInvalidate) {
+        this.inputs.set({ shouldInvalidate });
+    }
+    set _stepSize(stepSize) {
+        this.inputs.set({ stepSize });
+    }
+    set _size(size) {
+        this.inputs.set({ size });
+    }
+    set _allowSleep(allowSleep) {
+        this.inputs.set({ allowSleep });
+    }
+    set _axisIndex(axisIndex) {
+        this.inputs.set({ axisIndex });
+    }
+    set _broadphase(broadphase) {
+        this.inputs.set({ broadphase });
+    }
+    set _defaultContactMaterial(defaultContactMaterial) {
+        this.inputs.set({ defaultContactMaterial });
+    }
+    set _frictionGravity(frictionGravity) {
+        this.inputs.set({ frictionGravity });
+    }
+    set _gravity(gravity) {
+        this.inputs.set({ gravity });
+    }
+    set _iterations(iterations) {
+        this.inputs.set({ iterations });
+    }
+    set _quatNormalizeFast(quatNormalizeFast) {
+        this.inputs.set({ quatNormalizeFast });
+    }
+    set _quatNormalizeSkip(quatNormalizeSkip) {
+        this.inputs.set({ quatNormalizeSkip });
+    }
+    set _solver(solver) {
+        this.inputs.set({ solver });
+    }
+    set _tolerance(tolerance) {
+        this.inputs.set({ tolerance });
+    }
+    ngOnInit() {
+        this.zone.runOutsideAngular(() => {
+            this.api.set({ worker: new CannonWorkerAPI(this.inputs.state()) });
+            this.connectWorker();
+            this.updateWorkerState('axisIndex');
+            this.updateWorkerState('broadphase');
+            this.updateWorkerState('gravity');
+            this.updateWorkerState('iterations');
+            this.updateWorkerState('tolerance');
+            this.beforeRender();
+        });
+    }
+    connectWorker() {
+        effect((onCleanup) => {
+            const worker = this.worker();
+            if (!worker)
+                return;
+            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();
+            });
+        }, { injector: this.injector });
+    }
+    updateWorkerState(key) {
+        const compute = this.inputs.select(key);
+        effect(() => {
+            const [worker, value] = [untracked(this.worker), compute()];
+            // @ts-expect-error
+            worker[key] = value;
+        }, { injector: this.injector });
+    }
+    collideHandler({ body, contact: { bi, bj, ...contactRest }, target, ...rest }) {
+        const { events, refs } = this.api.get();
+        const cb = events[target]?.collide;
+        if (cb) {
+            cb({
+                body: refs[body],
+                contact: { bi: refs[bi], bj: refs[bj], ...contactRest },
+                target: refs[target],
+                ...rest,
+            });
+        }
+    }
+    collideBeginHandler({ bodyA, bodyB }) {
+        const { events, refs } = this.api.get();
+        const cbA = events[bodyA]?.collideBegin;
+        if (cbA)
+            cbA({ body: refs[bodyB], op: 'event', target: refs[bodyA], type: 'collideBegin' });
+        const cbB = events[bodyB]?.collideBegin;
+        if (cbB)
+            cbB({ body: refs[bodyA], op: 'event', target: refs[bodyB], type: 'collideBegin' });
+    }
+    collideEndHandler({ bodyA, bodyB }) {
+        const { events, refs } = this.api.get();
+        const cbA = events[bodyA]?.collideEnd;
+        if (cbA)
+            cbA({ body: refs[bodyB], op: 'event', target: refs[bodyA], type: 'collideEnd' });
+        const cbB = events[bodyB]?.collideEnd;
+        if (cbB)
+            cbB({ body: refs[bodyA], op: 'event', target: refs[bodyB], type: 'collideEnd' });
+    }
+    frameHandler({ active, bodies: uuids = [], observations, positions, quaternions, }) {
+        const [{ shouldInvalidate }, { bodies, subscriptions, refs, scaleOverrides }, invalidate] = [
+            this.inputs.get(),
+            this.api.get(),
+            this.invalidate(),
+        ];
+        for (let i = 0; i < uuids.length; i++) {
+            bodies[uuids[i]] = i;
+        }
+        observations.forEach(([id, value, type]) => {
+            const subscription = 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)
+            return;
+        for (const ref of Object.values(refs).filter(unique())) {
+            if (ref instanceof THREE.InstancedMesh) {
+                for (let i = 0; i < ref.count; i++) {
+                    const uuid = `${ref.uuid}/${i}`;
+                    const index = bodies[uuid];
+                    if (index !== undefined) {
+                        ref.setMatrixAt(i, apply(index, positions, quaternions, scaleOverrides[uuid]));
+                        ref.instanceMatrix.needsUpdate = true;
+                    }
+                }
+            }
+            else {
+                const scale = scaleOverrides[ref.uuid] || ref.scale;
+                apply(bodies[ref.uuid], positions, quaternions, scale, ref);
+            }
+        }
+        if (shouldInvalidate)
+            invalidate();
+    }
+    rayhitHandler({ body, ray: { uuid, ...rayRest }, ...rest }) {
+        const { events, refs } = this.api.get();
+        const cb = events[uuid]?.rayhit;
+        if (cb)
+            cb({ body: body ? refs[body] : null, ray: { uuid, ...rayRest }, ...rest });
+    }
+    beforeRender() {
+        let timeSinceLastCalled = 0;
+        injectBeforeRender(({ delta }) => {
+            const [{ isPaused, maxSubSteps, stepSize }, worker] = [this.inputs.get(), this.worker()];
+            if (isPaused || !worker)
+                return;
+            timeSinceLastCalled += delta;
+            worker.step({ maxSubSteps, stepSize: stepSize, timeSinceLastCalled });
+            timeSinceLastCalled = 0;
+        }, { injector: this.injector });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtcPhysics, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.2", type: NgtcPhysics, isStandalone: true, selector: "ngtc-physics", inputs: { _isPaused: ["isPaused", "_isPaused"], _maxSubSteps: ["maxSubSteps", "_maxSubSteps"], _shouldInvalidate: ["shouldInvalidate", "_shouldInvalidate"], _stepSize: ["stepSize", "_stepSize"], _size: ["size", "_size"], _allowSleep: ["allowSleep", "_allowSleep"], _axisIndex: ["axisIndex", "_axisIndex"], _broadphase: ["broadphase", "_broadphase"], _defaultContactMaterial: ["defaultContactMaterial", "_defaultContactMaterial"], _frictionGravity: ["frictionGravity", "_frictionGravity"], _gravity: ["gravity", "_gravity"], _iterations: ["iterations", "_iterations"], _quatNormalizeFast: ["quatNormalizeFast", "_quatNormalizeFast"], _quatNormalizeSkip: ["quatNormalizeSkip", "_quatNormalizeSkip"], _solver: ["solver", "_solver"], _tolerance: ["tolerance", "_tolerance"] }, providers: [provideNgtcPhysicsApi()], ngImport: i0, template: `
+		<ng-content />
+	`, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.2", ngImport: i0, type: NgtcPhysics, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngtc-physics',
+                    standalone: true,
+                    template: `
+		<ng-content />
+	`,
+                    providers: [provideNgtcPhysicsApi()],
+                }]
+        }], propDecorators: { _isPaused: [{
+                type: Input,
+                args: [{ alias: 'isPaused' }]
+            }], _maxSubSteps: [{
+                type: Input,
+                args: [{ alias: 'maxSubSteps' }]
+            }], _shouldInvalidate: [{
+                type: Input,
+                args: [{ alias: 'shouldInvalidate' }]
+            }], _stepSize: [{
+                type: Input,
+                args: [{ alias: 'stepSize' }]
+            }], _size: [{
+                type: Input,
+                args: [{ alias: 'size' }]
+            }], _allowSleep: [{
+                type: Input,
+                args: [{ alias: 'allowSleep' }]
+            }], _axisIndex: [{
+                type: Input,
+                args: [{ alias: 'axisIndex' }]
+            }], _broadphase: [{
+                type: Input,
+                args: [{ alias: 'broadphase' }]
+            }], _defaultContactMaterial: [{
+                type: Input,
+                args: [{ alias: 'defaultContactMaterial' }]
+            }], _frictionGravity: [{
+                type: Input,
+                args: [{ alias: 'frictionGravity' }]
+            }], _gravity: [{
+                type: Input,
+                args: [{ alias: 'gravity' }]
+            }], _iterations: [{
+                type: Input,
+                args: [{ alias: 'iterations' }]
+            }], _quatNormalizeFast: [{
+                type: Input,
+                args: [{ alias: 'quatNormalizeFast' }]
+            }], _quatNormalizeSkip: [{
+                type: Input,
+                args: [{ alias: 'quatNormalizeSkip' }]
+            }], _solver: [{
+                type: Input,
+                args: [{ alias: 'solver' }]
+            }], _tolerance: [{
+                type: Input,
+                args: [{ alias: 'tolerance' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"physics.js","sourceRoot":"","sources":["../../../../../libs/cannon/src/lib/physics.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Injector, Input, NgZone, effect, forwardRef, inject, untracked, type OnInit } from '@angular/core';\nimport {\n\tCannonWorkerAPI,\n\ttype Broadphase,\n\ttype CannonWorkerProps,\n\ttype CollideBeginEvent,\n\ttype CollideEndEvent,\n\ttype CollideEvent,\n\ttype ContactMaterialOptions,\n\ttype RayhitEvent,\n\ttype Refs,\n\ttype Solver,\n\ttype Subscriptions,\n\ttype Triplet,\n\ttype WorkerCollideBeginEvent,\n\ttype WorkerCollideEndEvent,\n\ttype WorkerCollideEvent,\n\ttype WorkerFrameMessage,\n\ttype WorkerRayhitEvent,\n} from '@pmndrs/cannon-worker-api';\nimport { createInjectionToken, injectBeforeRender, injectNgtStore, signalStore } 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\tif (index !== undefined) {\n\t\tm.compose(v.fromArray(positions, index * 3), q.fromArray(quaternions, index * 4), scale);\n\t\tif (object) {\n\t\t\tobject.matrixAutoUpdate = false;\n\t\t\tobject.matrix.copy(m);\n\t\t}\n\t\treturn m;\n\t}\n\treturn m.identity();\n}\n\nconst unique = () => {\n\tconst values: unknown[] = [];\n\treturn (value: unknown) => (values.includes(value) ? false : !!values.push(value));\n};\n\nexport type NgtcPhysicsState = CannonWorkerProps & {\n\tisPaused?: boolean;\n\tmaxSubSteps?: number;\n\tshouldInvalidate?: boolean;\n\tstepSize?: number;\n};\n\ntype NgtcCannonEvent = CollideBeginEvent | CollideEndEvent | CollideEvent | RayhitEvent;\ntype NgtcCallbackByType<T extends { type: string }> = {\n\t[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 type NgtcPhysicsApi = {\n\tbodies: { [uuid: string]: number };\n\tevents: NgtcCannonEvents;\n\trefs: Refs;\n\tscaleOverrides: ScaleOverrides;\n\tsubscriptions: Subscriptions;\n\tworker: CannonWorkerAPI;\n};\n\nexport const [injectNgtcPhysicsApi, provideNgtcPhysicsApi] = createInjectionToken(\n\t(physics: NgtcPhysics) => physics.api,\n\t{ isRoot: false, deps: [forwardRef(() => NgtcPhysics)] },\n);\n\n@Component({\n\tselector: 'ngtc-physics',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ng-content />\n\t`,\n\tproviders: [provideNgtcPhysicsApi()],\n})\nexport class NgtcPhysics implements OnInit {\n\tprivate inputs = signalStore<NgtcPhysicsState>({\n\t\tallowSleep: false,\n\t\taxisIndex: 0,\n\t\tbroadphase: 'Naive',\n\t\tdefaultContactMaterial: { contactEquationStiffness: 1e6 },\n\t\tfrictionGravity: null,\n\t\tgravity: [0, -9.81, 0],\n\t\tisPaused: false,\n\t\titerations: 5,\n\t\tmaxSubSteps: 10,\n\t\tquatNormalizeFast: false,\n\t\tquatNormalizeSkip: 0,\n\t\tshouldInvalidate: true,\n\t\tsize: 1000,\n\t\tsolver: 'GS',\n\t\tstepSize: 1 / 60,\n\t\ttolerance: 0.001,\n\t});\n\n\t@Input({ alias: 'isPaused' }) set _isPaused(isPaused: boolean) {\n\t\tthis.inputs.set({ isPaused });\n\t}\n\n\t@Input({ alias: 'maxSubSteps' }) set _maxSubSteps(maxSubSteps: number) {\n\t\tthis.inputs.set({ maxSubSteps });\n\t}\n\n\t@Input({ alias: 'shouldInvalidate' }) set _shouldInvalidate(shouldInvalidate: boolean) {\n\t\tthis.inputs.set({ shouldInvalidate });\n\t}\n\n\t@Input({ alias: 'stepSize' }) set _stepSize(stepSize: number) {\n\t\tthis.inputs.set({ stepSize });\n\t}\n\n\t@Input({ alias: 'size' }) set _size(size: number) {\n\t\tthis.inputs.set({ size });\n\t}\n\n\t@Input({ alias: 'allowSleep' }) set _allowSleep(allowSleep: boolean) {\n\t\tthis.inputs.set({ allowSleep });\n\t}\n\n\t@Input({ alias: 'axisIndex' }) set _axisIndex(axisIndex: 0 | 1 | 2) {\n\t\tthis.inputs.set({ axisIndex });\n\t}\n\n\t@Input({ alias: 'broadphase' }) set _broadphase(broadphase: Broadphase) {\n\t\tthis.inputs.set({ broadphase });\n\t}\n\n\t@Input({ alias: 'defaultContactMaterial' }) set _defaultContactMaterial(\n\t\tdefaultContactMaterial: ContactMaterialOptions,\n\t) {\n\t\tthis.inputs.set({ defaultContactMaterial });\n\t}\n\n\t@Input({ alias: 'frictionGravity' }) set _frictionGravity(frictionGravity: Triplet | null) {\n\t\tthis.inputs.set({ frictionGravity });\n\t}\n\n\t@Input({ alias: 'gravity' }) set _gravity(gravity: Triplet) {\n\t\tthis.inputs.set({ gravity });\n\t}\n\n\t@Input({ alias: 'iterations' }) set _iterations(iterations: number) {\n\t\tthis.inputs.set({ iterations });\n\t}\n\n\t@Input({ alias: 'quatNormalizeFast' }) set _quatNormalizeFast(quatNormalizeFast: boolean) {\n\t\tthis.inputs.set({ quatNormalizeFast });\n\t}\n\n\t@Input({ alias: 'quatNormalizeSkip' }) set _quatNormalizeSkip(quatNormalizeSkip: number) {\n\t\tthis.inputs.set({ quatNormalizeSkip });\n\t}\n\n\t@Input({ alias: 'solver' }) set _solver(solver: Solver) {\n\t\tthis.inputs.set({ solver });\n\t}\n\n\t@Input({ alias: 'tolerance' }) set _tolerance(tolerance: number) {\n\t\tthis.inputs.set({ tolerance });\n\t}\n\n\tprivate zone = inject(NgZone);\n\tprivate injector = inject(Injector);\n\n\tprivate store = injectNgtStore();\n\tprivate invalidate = this.store.select('invalidate');\n\n\tapi = signalStore<NgtcPhysicsApi>({\n\t\tbodies: {},\n\t\tevents: {},\n\t\trefs: {},\n\t\tscaleOverrides: {},\n\t\tsubscriptions: {},\n\t\tworker: null!,\n\t});\n\n\tprivate worker = this.api.select('worker');\n\n\tngOnInit() {\n\t\tthis.zone.runOutsideAngular(() => {\n\t\t\tthis.api.set({ worker: new CannonWorkerAPI(this.inputs.state()) });\n\t\t\tthis.connectWorker();\n\t\t\tthis.updateWorkerState('axisIndex');\n\t\t\tthis.updateWorkerState('broadphase');\n\t\t\tthis.updateWorkerState('gravity');\n\t\t\tthis.updateWorkerState('iterations');\n\t\t\tthis.updateWorkerState('tolerance');\n\t\t\tthis.beforeRender();\n\t\t});\n\t}\n\n\tprivate connectWorker() {\n\t\teffect(\n\t\t\t(onCleanup) => {\n\t\t\t\tconst worker = this.worker();\n\t\t\t\tif (!worker) return;\n\n\t\t\t\tworker.connect();\n\t\t\t\tworker.init();\n\n\t\t\t\t(worker as any).on('collide', this.collideHandler.bind(this));\n\t\t\t\t(worker as any).on('collideBegin', this.collideBeginHandler.bind(this));\n\t\t\t\t(worker as any).on('collideEnd', this.collideEndHandler.bind(this));\n\t\t\t\t(worker as any).on('frame', this.frameHandler.bind(this));\n\t\t\t\t(worker as any).on('rayhit', this.rayhitHandler.bind(this));\n\n\t\t\t\tonCleanup(() => {\n\t\t\t\t\tworker.terminate();\n\t\t\t\t\t(worker as any).removeAllListeners();\n\t\t\t\t});\n\t\t\t},\n\t\t\t{ injector: this.injector },\n\t\t);\n\t}\n\n\tprivate updateWorkerState(key: keyof NgtcPhysicsState) {\n\t\tconst compute = this.inputs.select(key);\n\t\teffect(\n\t\t\t() => {\n\t\t\t\tconst [worker, value] = [untracked(this.worker), compute()];\n\t\t\t\t// @ts-expect-error\n\t\t\t\tworker[key] = value;\n\t\t\t},\n\t\t\t{ injector: this.injector },\n\t\t);\n\t}\n\n\tprivate collideHandler({ body, contact: { bi, bj, ...contactRest }, target, ...rest }: WorkerCollideEvent['data']) {\n\t\tconst { events, refs } = this.api.get();\n\t\tconst cb = events[target]?.collide;\n\n\t\tif (cb) {\n\t\t\tcb({\n\t\t\t\tbody: refs[body],\n\t\t\t\tcontact: { bi: refs[bi], bj: refs[bj], ...contactRest },\n\t\t\t\ttarget: refs[target],\n\t\t\t\t...rest,\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate collideBeginHandler({ bodyA, bodyB }: WorkerCollideBeginEvent['data']) {\n\t\tconst { events, refs } = this.api.get();\n\t\tconst cbA = events[bodyA]?.collideBegin;\n\t\tif (cbA) cbA({ body: refs[bodyB], op: 'event', target: refs[bodyA], type: 'collideBegin' });\n\t\tconst cbB = events[bodyB]?.collideBegin;\n\t\tif (cbB) cbB({ body: refs[bodyA], op: 'event', target: refs[bodyB], type: 'collideBegin' });\n\t}\n\n\tprivate collideEndHandler({ bodyA, bodyB }: WorkerCollideEndEvent['data']) {\n\t\tconst { events, refs } = this.api.get();\n\t\tconst cbA = events[bodyA]?.collideEnd;\n\t\tif (cbA) cbA({ body: refs[bodyB], op: 'event', target: refs[bodyA], type: 'collideEnd' });\n\t\tconst cbB = events[bodyB]?.collideEnd;\n\t\tif (cbB) cbB({ body: refs[bodyA], op: 'event', target: refs[bodyB], type: 'collideEnd' });\n\t}\n\n\tprivate frameHandler({\n\t\tactive,\n\t\tbodies: uuids = [],\n\t\tobservations,\n\t\tpositions,\n\t\tquaternions,\n\t}: WorkerFrameMessage['data']) {\n\t\tconst [{ shouldInvalidate }, { bodies, subscriptions, refs, scaleOverrides }, invalidate] = [\n\t\t\tthis.inputs.get(),\n\t\t\tthis.api.get(),\n\t\t\tthis.invalidate(),\n\t\t];\n\n\t\tfor (let i = 0; i < uuids.length; i++) {\n\t\t\tbodies[uuids[i]] = i;\n\t\t}\n\n\t\tobservations.forEach(([id, value, type]) => {\n\t\t\tconst subscription = subscriptions[id] || {};\n\t\t\tconst cb = subscription[type];\n\t\t\t// HELP: We clearly know the type of the callback, but typescript can't deal with it\n\t\t\tcb && cb(value as never);\n\t\t});\n\n\t\tif (!active) return;\n\n\t\tfor (const ref of Object.values(refs).filter(unique())) {\n\t\t\tif (ref instanceof THREE.InstancedMesh) {\n\t\t\t\tfor (let i = 0; i < ref.count; i++) {\n\t\t\t\t\tconst uuid = `${ref.uuid}/${i}`;\n\t\t\t\t\tconst index = bodies[uuid];\n\t\t\t\t\tif (index !== undefined) {\n\t\t\t\t\t\tref.setMatrixAt(i, apply(index, positions, quaternions, scaleOverrides[uuid]));\n\t\t\t\t\t\tref.instanceMatrix.needsUpdate = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst scale = scaleOverrides[ref.uuid] || ref.scale;\n\t\t\t\tapply(bodies[ref.uuid], positions, quaternions, scale, ref);\n\t\t\t}\n\t\t}\n\t\tif (shouldInvalidate) invalidate();\n\t}\n\n\tprivate rayhitHandler({ body, ray: { uuid, ...rayRest }, ...rest }: WorkerRayhitEvent['data']) {\n\t\tconst { events, refs } = this.api.get();\n\t\tconst cb = events[uuid]?.rayhit;\n\t\tif (cb) cb({ body: body ? refs[body] : null, ray: { uuid, ...rayRest }, ...rest });\n\t}\n\n\tprivate beforeRender() {\n\t\tlet timeSinceLastCalled = 0;\n\t\tinjectBeforeRender(\n\t\t\t({ delta }) => {\n\t\t\t\tconst [{ isPaused, maxSubSteps, stepSize }, worker] = [this.inputs.get(), this.worker()];\n\t\t\t\tif (isPaused || !worker) return;\n\t\t\t\ttimeSinceLastCalled += delta;\n\t\t\t\tworker.step({ maxSubSteps, stepSize: stepSize!, timeSinceLastCalled });\n\t\t\t\ttimeSinceLastCalled = 0;\n\t\t\t},\n\t\t\t{ injector: this.injector },\n\t\t);\n\t}\n}\n"]}

package/esm2022/services/index.mjs

@@ -1,7 +1,7 @@
-export * from './body';
-export * from './constraint';
-export * from './contact-material';
-export * from './ray';
-export * from './raycast-vehicle';
-export * from './spring';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9zZXJ2aWNlcy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ib2R5JztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RyYWludCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRhY3QtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9yYXknO1xuZXhwb3J0ICogZnJvbSAnLi9yYXljYXN0LXZlaGljbGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zcHJpbmcnO1xuIl19
+export * from './lib/body';
+export * from './lib/constraints';
+export * from './lib/contact-material';
+export * from './lib/ray';
+export * from './lib/raycast-vehicle';
+export * from './lib/spring';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9zZXJ2aWNlcy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9ib2R5JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbnN0cmFpbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbnRhY3QtbWF0ZXJpYWwnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmF5JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JheWNhc3QtdmVoaWNsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zcHJpbmcnO1xuIl19