angular-three-cannon 2.0.0-beta.21 → 2.0.0-beta.227

package/body/README.md

@@ -0,0 +1,3 @@
+# angular-three-cannon/body
+
+Secondary entry point of `angular-three-cannon`. It can be used by importing from `angular-three-cannon/body`.

package/body/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/body';
+export type * from './lib/types';

package/body/lib/body.d.ts

@@ -0,0 +1,57 @@
+import { Injector } from '@angular/core';
+import type { BodyShapeType, BoxProps, CompoundBodyProps, ConvexPolyhedronArgs, ConvexPolyhedronProps, CylinderArgs, CylinderProps, HeightfieldArgs, HeightfieldProps, ParticleProps, PlaneProps, SphereArgs, SphereProps, TrimeshArgs, TrimeshProps, Triplet } from '@pmndrs/cannon-worker-api';
+import { type NgtInjectedRef } from 'angular-three';
+import { Object3D } from 'three';
+import type { NgtcBodyPublicApi, NgtcGetByIndex, NgtcTransformArg } from './types';
+interface NgtcBodyProps {
+    Plane: {
+        props: PlaneProps;
+        args: unknown[];
+    };
+    Box: {
+        props: BoxProps;
+        args: Triplet;
+    };
+    Trimesh: {
+        props: TrimeshProps;
+        args: TrimeshArgs;
+    };
+    Cylinder: {
+        props: CylinderProps;
+        args: CylinderArgs;
+    };
+    Heightfield: {
+        props: HeightfieldProps;
+        args: HeightfieldArgs;
+    };
+    ConvexPolyhedron: {
+        props: ConvexPolyhedronProps;
+        args: ConvexPolyhedronArgs<Triplet>;
+    };
+    Particle: {
+        props: ParticleProps;
+        args: unknown[];
+    };
+    Sphere: {
+        props: SphereProps;
+        args: SphereArgs;
+    };
+    Compound: {
+        props: CompoundBodyProps;
+        args: unknown[];
+    };
+}
+export interface NgtcBodyResult {
+    ref: NgtInjectedRef<Object3D>;
+    api: NgtcBodyPublicApi;
+}
+interface NgtcBodyOptions<TType extends BodyShapeType = BodyShapeType> {
+    getPropFn: NgtcGetByIndex<NgtcBodyProps[TType]['props']>;
+    transformArgs?: NgtcTransformArg<NgtcBodyProps[TType]['args']>;
+}
+export declare function injectBody<TType extends BodyShapeType>(type: TType, getPropFn: NgtcBodyOptions<TType>['getPropFn'], { injector, ref, transformArgs, }?: {
+    injector?: Injector;
+    ref?: NgtInjectedRef<Object3D>;
+    transformArgs?: NgtcBodyOptions<TType>['transformArgs'];
+}): NgtcBodyResult;
+export {};

package/body/lib/types.d.ts

@@ -0,0 +1,38 @@
+import type { AtomicName, AtomicProps, BodyProps, Quad, Triplet, VectorName } from '@pmndrs/cannon-worker-api';
+import type { Euler, Quaternion, Vector3 } from 'three';
+export type NgtcAtomicApi<K extends AtomicName> = {
+    set: (value: AtomicProps[K]) => void;
+    subscribe: (callback: (value: AtomicProps[K]) => void) => () => void;
+};
+export type NgtcQuaternionApi = {
+    copy: ({ w, x, y, z }: Quaternion) => void;
+    set: (x: number, y: number, z: number, w: number) => void;
+    subscribe: (callback: (value: Quad) => void) => () => void;
+};
+export type NgtcVectorApi = {
+    copy: ({ x, y, z }: Vector3 | Euler) => void;
+    set: (x: number, y: number, z: number) => void;
+    subscribe: (callback: (value: Triplet) => void) => () => void;
+};
+export type NgtcWorkerApi = {
+    [K in AtomicName]: NgtcAtomicApi<K>;
+} & {
+    [K in VectorName]: NgtcVectorApi;
+} & {
+    applyForce: (force: Triplet, worldPoint: Triplet) => void;
+    applyImpulse: (impulse: Triplet, worldPoint: Triplet) => void;
+    applyLocalForce: (force: Triplet, localPoint: Triplet) => void;
+    applyLocalImpulse: (impulse: Triplet, localPoint: Triplet) => void;
+    applyTorque: (torque: Triplet) => void;
+    quaternion: NgtcQuaternionApi;
+    rotation: NgtcVectorApi;
+    scaleOverride: (scale: Triplet) => void;
+    sleep: () => void;
+    wakeUp: () => void;
+    remove: () => void;
+};
+export interface NgtcBodyPublicApi extends NgtcWorkerApi {
+    at: (index: number) => NgtcWorkerApi;
+}
+export type NgtcGetByIndex<T extends BodyProps> = (index: number) => T;
+export type NgtcTransformArg<T extends unknown[]> = (args: T) => T;

package/body/lib/utils.d.ts

@@ -0,0 +1,50 @@
+import { type ElementRef, type Signal } from '@angular/core';
+import type { BodyProps, CannonWorkerAPI, ConvexPolyhedronArgs, CylinderArgs, HeightfieldArgs, SphereArgs, TrimeshArgs, Triplet } from '@pmndrs/cannon-worker-api';
+import type { NgtcCannonEvents, NgtcPhysicsApi } from 'angular-three-cannon';
+import { type Object3D } from 'three';
+import type { NgtcWorkerApi } from './types';
+export declare function prepare(object: Object3D, { position, rotation, userData }: BodyProps): void;
+export declare function setupCollision(events: NgtcCannonEvents, { onCollide, onCollideBegin, onCollideEnd }: Partial<BodyProps>, uuid: string): void;
+export declare function makeApi(worker: Signal<CannonWorkerAPI>, bodyRef: ElementRef<Object3D>, { subscriptions, bodies, scaleOverrides }: NgtcPhysicsApi): {
+    at: (index: number) => NgtcWorkerApi;
+    allowSleep: import("./types").NgtcAtomicApi<"allowSleep">;
+    angularDamping: import("./types").NgtcAtomicApi<"angularDamping">;
+    collisionFilterGroup: import("./types").NgtcAtomicApi<"collisionFilterGroup">;
+    collisionFilterMask: import("./types").NgtcAtomicApi<"collisionFilterMask">;
+    collisionResponse: import("./types").NgtcAtomicApi<"collisionResponse">;
+    fixedRotation: import("./types").NgtcAtomicApi<"fixedRotation">;
+    isTrigger: import("./types").NgtcAtomicApi<"isTrigger">;
+    linearDamping: import("./types").NgtcAtomicApi<"linearDamping">;
+    mass: import("./types").NgtcAtomicApi<"mass">;
+    material: import("./types").NgtcAtomicApi<"material">;
+    sleepSpeedLimit: import("./types").NgtcAtomicApi<"sleepSpeedLimit">;
+    sleepTimeLimit: import("./types").NgtcAtomicApi<"sleepTimeLimit">;
+    userData: import("./types").NgtcAtomicApi<"userData">;
+    angularFactor: import("./types").NgtcVectorApi;
+    angularVelocity: import("./types").NgtcVectorApi;
+    linearFactor: import("./types").NgtcVectorApi;
+    position: import("./types").NgtcVectorApi;
+    velocity: import("./types").NgtcVectorApi;
+    applyForce: (force: Triplet, worldPoint: Triplet) => void;
+    applyImpulse: (impulse: Triplet, worldPoint: Triplet) => void;
+    applyLocalForce: (force: Triplet, localPoint: Triplet) => void;
+    applyLocalImpulse: (impulse: Triplet, localPoint: Triplet) => void;
+    applyTorque: (torque: Triplet) => void;
+    quaternion: import("./types").NgtcQuaternionApi;
+    rotation: import("./types").NgtcVectorApi;
+    scaleOverride: (scale: Triplet) => void;
+    sleep: () => void;
+    wakeUp: () => void;
+    remove: () => void;
+};
+export declare const defaultTransformArgs: {
+    Plane: (args: unknown[]) => never[];
+    Box: (args?: Triplet) => Triplet;
+    Trimesh: (args: TrimeshArgs) => TrimeshArgs;
+    Cylinder: (args?: CylinderArgs) => never[];
+    Heightfield: (args: HeightfieldArgs) => HeightfieldArgs;
+    ConvexPolyhedron: ([vertices, faces, normals, axes, boundingSphereRadius]?: ConvexPolyhedronArgs<Triplet>) => (number | number[][] | undefined)[];
+    Particle: (args: unknown[]) => never[];
+    Sphere: (args?: SphereArgs) => number[];
+    Compound: (args: unknown[]) => unknown[];
+};

package/constraint/README.md

@@ -0,0 +1,3 @@
+# angular-three-cannon/constraint
+
+Secondary entry point of `angular-three-cannon`. It can be used by importing from `angular-three-cannon/constraint`.

package/constraint/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/constraint';

package/constraint/lib/constraint.d.ts

@@ -0,0 +1,26 @@
+import { Injector } from '@angular/core';
+import type { ConstraintOptns, ConstraintTypes, HingeConstraintOpts } from '@pmndrs/cannon-worker-api';
+import { type NgtInjectedRef } from 'angular-three';
+import { Object3D } from 'three';
+export interface NgtcConstraintOptions<TConstraintType extends 'Hinge' | ConstraintTypes, TOptions extends HingeConstraintOpts | ConstraintOptns = TConstraintType extends 'Hinge' ? HingeConstraintOpts : ConstraintOptns> {
+    injector?: Injector;
+    options?: TOptions;
+}
+export interface NgtcConstraintApi {
+    disable: () => void;
+    enable: () => void;
+    remove: () => void;
+}
+export interface NgtcHingeConstraintApi extends NgtcConstraintApi {
+    disableMotor: () => void;
+    enableMotor: () => void;
+    setMotorMaxForce: (value: number) => void;
+    setMotorSpeed: (value: number) => void;
+}
+export type NgtcConstraintORHingeApi<T extends 'Hinge' | ConstraintTypes> = T extends ConstraintTypes ? NgtcConstraintApi : NgtcHingeConstraintApi;
+export interface NgtcConstraintResult<T extends 'Hinge' | ConstraintTypes, TObjectA extends Object3D = Object3D, TObjectB extends Object3D = Object3D> {
+    bodyA: NgtInjectedRef<TObjectA>;
+    bodyB: NgtInjectedRef<TObjectB>;
+    api: NgtcConstraintORHingeApi<T>;
+}
+export declare function injectConstraint<TType extends ConstraintTypes | 'Hinge', TBodyA extends Object3D = Object3D, TBodyB extends Object3D = Object3D>(type: TType, bodyA: TBodyA | NgtInjectedRef<TBodyA>, bodyB: TBodyB | NgtInjectedRef<TBodyB>, { injector, options }?: NgtcConstraintOptions<TType>): NgtcConstraintResult<TType, TBodyA, TBodyB>;

package/debug/lib/debug.d.ts

@@ -1,4 +1,3 @@
-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';
@@ -10,34 +9,36 @@ export declare const injectNgtcDebugApi: {
     };
     (injectOptions: import("@angular/core").InjectOptions & {
         optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
     }): {
         add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
         remove: (id: string) => void;
     };
-    (injectOptions: import("@angular/core").InjectOptions): {
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): {
         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;
+}, provideNgtcDebugApi: () => import("@angular/core").Provider;
+export declare class NgtcDebug {
+    color: import("@angular/core").InputSignal<string>;
+    scale: import("@angular/core").InputSignal<number>;
+    impl: import("@angular/core").InputSignal<typeof CannonDebugger>;
+    debug: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    protected scene: THREE.Scene;
     private bodies;
     private bodyMap;
+    private store;
+    private defaultScene;
     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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtcDebug, "ngtc-physics[debug]", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "impl": { "alias": "impl"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

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

package/esm2022/body/index.mjs

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

package/esm2022/body/lib/body.mjs

@@ -0,0 +1,83 @@
+import { afterNextRender, effect, inject, Injector } from '@angular/core';
+import { injectNgtRef } from 'angular-three';
+import { injectNgtcPhysicsApi } from 'angular-three-cannon';
+import { injectNgtcDebugApi } from 'angular-three-cannon/debug';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { DynamicDrawUsage, InstancedMesh, Object3D } from 'three';
+import { defaultTransformArgs, makeApi, prepare, setupCollision } from './utils';
+export function injectBody(type, getPropFn, { injector, ref, transformArgs, } = {}) {
+    return assertInjector(injectBody, injector, () => {
+        const assertedInjector = inject(Injector);
+        const physicsApi = injectNgtcPhysicsApi();
+        const debugApi = injectNgtcDebugApi({ optional: true });
+        const [{ add: addToDebug, remove: removeFromDebug }, physics, worker] = [
+            debugApi || {},
+            physicsApi.get(),
+            physicsApi.select('worker'),
+        ];
+        const transform = transformArgs ?? defaultTransformArgs[type];
+        const bodyResult = { ref: ref ?? injectNgtRef() };
+        afterNextRender(() => {
+            Object.assign(bodyResult, { api: makeApi(worker, bodyResult.ref, physics) });
+            effect((onCleanup) => {
+                const currentWorker = worker();
+                if (!currentWorker)
+                    return;
+                if (!bodyResult.ref.nativeElement) {
+                    bodyResult.ref.nativeElement = new Object3D();
+                    return;
+                }
+                const object = bodyResult.ref.nativeElement;
+                const [uuid, props] = (() => {
+                    let uuids = [];
+                    let temp;
+                    if (object instanceof InstancedMesh) {
+                        object.instanceMatrix.setUsage(DynamicDrawUsage);
+                        uuids = new Array(object.count).fill(0).map((_, i) => `${object.uuid}/${i}`);
+                        temp = new Object3D();
+                    }
+                    else {
+                        uuids = [object.uuid];
+                    }
+                    return [
+                        uuids,
+                        uuids.map((id, index) => {
+                            const props = getPropFn(index);
+                            if (temp) {
+                                prepare(temp, props);
+                                object.setMatrixAt(index, temp.matrix);
+                                object.instanceMatrix.needsUpdate = true;
+                            }
+                            else {
+                                prepare(object, props);
+                            }
+                            physics.refs[id] = object;
+                            addToDebug?.(id, props, type);
+                            setupCollision(physics.events, props, id);
+                            // @ts-expect-error - if args is undefined, there's default
+                            return { ...props, args: transform(props.args) };
+                        }),
+                    ];
+                })();
+                // Register on mount, unregister on unmount
+                currentWorker.addBodies({
+                    props: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => {
+                        return { onCollide: Boolean(onCollide), ...serializableProps };
+                    }),
+                    type,
+                    uuid,
+                });
+                onCleanup(() => {
+                    uuid.forEach((id) => {
+                        delete physics.refs[id];
+                        removeFromDebug?.(id);
+                        delete physics.events[id];
+                    });
+                    currentWorker.removeBodies({ uuid: uuid });
+                });
+            }, { injector: assertedInjector });
+        });
+        return bodyResult;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"body.js","sourceRoot":"","sources":["../../../../../../libs/cannon/body/src/lib/body.ts"],"names":[],"mappings":"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","sourcesContent":["import { afterNextRender, effect, inject, Injector } from '@angular/core';\nimport type {\n\tBodyShapeType,\n\tBoxProps,\n\tCompoundBodyProps,\n\tConvexPolyhedronArgs,\n\tConvexPolyhedronProps,\n\tCylinderArgs,\n\tCylinderProps,\n\tHeightfieldArgs,\n\tHeightfieldProps,\n\tParticleProps,\n\tPlaneProps,\n\tSphereArgs,\n\tSphereProps,\n\tTrimeshArgs,\n\tTrimeshProps,\n\tTriplet,\n} from '@pmndrs/cannon-worker-api';\nimport { injectNgtRef, type NgtInjectedRef } from 'angular-three';\nimport { injectNgtcPhysicsApi } from 'angular-three-cannon';\nimport { injectNgtcDebugApi } from 'angular-three-cannon/debug';\nimport { assertInjector } from 'ngxtension/assert-injector';\nimport { DynamicDrawUsage, InstancedMesh, Object3D } from 'three';\nimport type { NgtcBodyPublicApi, NgtcGetByIndex, NgtcTransformArg } from './types';\nimport { defaultTransformArgs, makeApi, prepare, setupCollision } from './utils';\n\ninterface NgtcBodyProps {\n\tPlane: { props: PlaneProps; args: unknown[] };\n\tBox: { props: BoxProps; args: Triplet };\n\tTrimesh: { props: TrimeshProps; args: TrimeshArgs };\n\tCylinder: { props: CylinderProps; args: CylinderArgs };\n\tHeightfield: { props: HeightfieldProps; args: HeightfieldArgs };\n\tConvexPolyhedron: { props: ConvexPolyhedronProps; args: ConvexPolyhedronArgs<Triplet> };\n\tParticle: { props: ParticleProps; args: unknown[] };\n\tSphere: { props: SphereProps; args: SphereArgs };\n\tCompound: { props: CompoundBodyProps; args: unknown[] };\n}\n\nexport interface NgtcBodyResult {\n\tref: NgtInjectedRef<Object3D>;\n\tapi: NgtcBodyPublicApi;\n}\n\ninterface NgtcBodyOptions<TType extends BodyShapeType = BodyShapeType> {\n\tgetPropFn: NgtcGetByIndex<NgtcBodyProps[TType]['props']>;\n\ttransformArgs?: NgtcTransformArg<NgtcBodyProps[TType]['args']>;\n}\n\nexport function injectBody<TType extends BodyShapeType>(\n\ttype: TType,\n\tgetPropFn: NgtcBodyOptions<TType>['getPropFn'],\n\t{\n\t\tinjector,\n\t\tref,\n\t\ttransformArgs,\n\t}: {\n\t\tinjector?: Injector;\n\t\tref?: NgtInjectedRef<Object3D>;\n\t\ttransformArgs?: NgtcBodyOptions<TType>['transformArgs'];\n\t} = {},\n): NgtcBodyResult {\n\treturn assertInjector(injectBody, injector, () => {\n\t\tconst assertedInjector = inject(Injector);\n\n\t\tconst physicsApi = injectNgtcPhysicsApi();\n\t\tconst debugApi = injectNgtcDebugApi({ optional: true });\n\n\t\tconst [{ add: addToDebug, remove: removeFromDebug }, physics, worker] = [\n\t\t\tdebugApi || {},\n\t\t\tphysicsApi.get(),\n\t\t\tphysicsApi.select('worker'),\n\t\t];\n\t\tconst transform = transformArgs ?? defaultTransformArgs[type];\n\n\t\tconst bodyResult = { ref: ref ?? injectNgtRef() } as NgtcBodyResult;\n\n\t\tafterNextRender(() => {\n\t\t\tObject.assign(bodyResult, { api: makeApi(worker, bodyResult.ref, physics) });\n\n\t\t\teffect(\n\t\t\t\t(onCleanup) => {\n\t\t\t\t\tconst currentWorker = worker();\n\t\t\t\t\tif (!currentWorker) return;\n\n\t\t\t\t\tif (!bodyResult.ref.nativeElement) {\n\t\t\t\t\t\tbodyResult.ref.nativeElement = new Object3D();\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tconst object = bodyResult.ref.nativeElement;\n\n\t\t\t\t\tconst [uuid, props] = (() => {\n\t\t\t\t\t\tlet uuids: string[] = [];\n\t\t\t\t\t\tlet temp: Object3D;\n\n\t\t\t\t\t\tif (object instanceof InstancedMesh) {\n\t\t\t\t\t\t\tobject.instanceMatrix.setUsage(DynamicDrawUsage);\n\t\t\t\t\t\t\tuuids = new Array(object.count).fill(0).map((_, i) => `${object.uuid}/${i}`);\n\t\t\t\t\t\t\ttemp = new Object3D();\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tuuids = [object.uuid];\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treturn [\n\t\t\t\t\t\t\tuuids,\n\t\t\t\t\t\t\tuuids.map((id, index) => {\n\t\t\t\t\t\t\t\tconst props = getPropFn(index);\n\t\t\t\t\t\t\t\tif (temp) {\n\t\t\t\t\t\t\t\t\tprepare(temp, props);\n\t\t\t\t\t\t\t\t\t(object as InstancedMesh).setMatrixAt(index, temp.matrix);\n\t\t\t\t\t\t\t\t\t(object as InstancedMesh).instanceMatrix.needsUpdate = true;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tprepare(object, props);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tphysics.refs[id] = object;\n\t\t\t\t\t\t\t\taddToDebug?.(id, props, type);\n\t\t\t\t\t\t\t\tsetupCollision(physics.events, props, id);\n\t\t\t\t\t\t\t\t// @ts-expect-error - if args is undefined, there's default\n\t\t\t\t\t\t\t\treturn { ...props, args: transform(props.args) };\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t] as const;\n\t\t\t\t\t})();\n\n\t\t\t\t\t// Register on mount, unregister on unmount\n\t\t\t\t\tcurrentWorker.addBodies({\n\t\t\t\t\t\tprops: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => {\n\t\t\t\t\t\t\treturn { onCollide: Boolean(onCollide), ...serializableProps };\n\t\t\t\t\t\t}),\n\t\t\t\t\t\ttype,\n\t\t\t\t\t\tuuid,\n\t\t\t\t\t});\n\n\t\t\t\t\tonCleanup(() => {\n\t\t\t\t\t\tuuid.forEach((id) => {\n\t\t\t\t\t\t\tdelete physics.refs[id];\n\t\t\t\t\t\t\tremoveFromDebug?.(id);\n\t\t\t\t\t\t\tdelete physics.events[id];\n\t\t\t\t\t\t});\n\t\t\t\t\t\tcurrentWorker.removeBodies({ uuid: uuid });\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t\t{ injector: assertedInjector },\n\t\t\t);\n\t\t});\n\n\t\treturn bodyResult;\n\t});\n}\n"]}

package/esm2022/body/lib/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/body/lib/utils.mjs

@@ -0,0 +1,205 @@
+import {} from '@angular/core';
+import { Euler, Quaternion, Vector3 } from 'three';
+function capitalize(str) {
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}
+function getUUID(ref, index) {
+    const suffix = index === undefined ? '' : `/${index}`;
+    if (typeof ref === 'function')
+        return null;
+    return ref && ref.nativeElement && `${ref.nativeElement.uuid}${suffix}`;
+}
+const e = new Euler();
+const q = new Quaternion();
+function quaternionToRotation(callback) {
+    return (v) => callback(e.setFromQuaternion(q.fromArray(v)).toArray());
+}
+let incrementingId = 0;
+function createSubscribe(ref, worker, subscriptions, type, index, target = 'bodies') {
+    return (callback) => {
+        const id = incrementingId++;
+        subscriptions[id] = { [type]: callback };
+        const uuid = getUUID(ref, index);
+        uuid && worker.subscribe({ props: { id, target, type }, uuid });
+        return () => {
+            delete subscriptions[id];
+            worker.unsubscribe({ props: id });
+        };
+    };
+}
+function makeTriplet(v) {
+    return v instanceof Vector3 ? [v.x, v.y, v.z] : v;
+}
+export function prepare(object, { position = [0, 0, 0], rotation = [0, 0, 0], userData = {} }) {
+    object.userData = userData;
+    object.position.set(...position);
+    object.rotation.set(...rotation);
+    object.updateMatrix();
+}
+export function setupCollision(events, { onCollide, onCollideBegin, onCollideEnd }, uuid) {
+    events[uuid] = {
+        collide: onCollide,
+        collideBegin: onCollideBegin,
+        collideEnd: onCollideEnd,
+    };
+}
+export function makeApi(worker, bodyRef, { subscriptions, bodies, scaleOverrides }) {
+    const makeAtomic = (type, index) => {
+        const op = `set${capitalize(type)}`;
+        return {
+            set: (value) => {
+                const uuid = getUUID(bodyRef, index);
+                uuid &&
+                    worker()[op]({
+                        props: value,
+                        uuid,
+                    });
+            },
+            subscribe: createSubscribe(bodyRef, worker(), subscriptions, type, index),
+        };
+    };
+    const makeQuaternion = (index) => {
+        const type = 'quaternion';
+        return {
+            copy: ({ w, x, y, z }) => {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().setQuaternion({ props: [x, y, z, w], uuid });
+            },
+            set: (x, y, z, w) => {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().setQuaternion({ props: [x, y, z, w], uuid });
+            },
+            subscribe: createSubscribe(bodyRef, worker(), subscriptions, type, index),
+        };
+    };
+    const makeRotation = (index) => {
+        return {
+            copy: ({ x, y, z }) => {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().setRotation({ props: [x, y, z], uuid });
+            },
+            set: (x, y, z) => {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().setRotation({ props: [x, y, z], uuid });
+            },
+            subscribe: (callback) => {
+                const id = incrementingId++;
+                const target = 'bodies';
+                const type = 'quaternion';
+                const uuid = getUUID(bodyRef, index);
+                subscriptions[id] = { [type]: quaternionToRotation(callback) };
+                uuid && bodies[uuid] != null && worker().subscribe({ props: { id, target, type }, uuid });
+                return () => {
+                    delete subscriptions[id];
+                    worker().unsubscribe({ props: id });
+                };
+            },
+        };
+    };
+    const makeVec = (type, index) => {
+        const op = `set${capitalize(type)}`;
+        return {
+            copy: ({ x, y, z }) => {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker()[op]({ props: [x, y, z], uuid });
+            },
+            set: (x, y, z) => {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker()[op]({ props: [x, y, z], uuid });
+            },
+            subscribe: createSubscribe(bodyRef, worker(), subscriptions, type, index),
+        };
+    };
+    const makeRemove = (index) => {
+        const uuid = getUUID(bodyRef, index);
+        return () => {
+            if (uuid)
+                worker().removeBodies({ uuid: [uuid] });
+        };
+    };
+    function makeApi(index) {
+        return {
+            allowSleep: makeAtomic('allowSleep', index),
+            angularDamping: makeAtomic('angularDamping', index),
+            angularFactor: makeVec('angularFactor', index),
+            angularVelocity: makeVec('angularVelocity', index),
+            applyForce(force, worldPoint) {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().applyForce({ props: [force, worldPoint], uuid });
+            },
+            applyImpulse(impulse, worldPoint) {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().applyImpulse({ props: [impulse, worldPoint], uuid });
+            },
+            applyLocalForce(force, localPoint) {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().applyLocalForce({ props: [force, localPoint], uuid });
+            },
+            applyLocalImpulse(impulse, localPoint) {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().applyLocalImpulse({ props: [impulse, localPoint], uuid });
+            },
+            applyTorque(torque) {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().applyTorque({ props: [torque], uuid });
+            },
+            collisionFilterGroup: makeAtomic('collisionFilterGroup', index),
+            collisionFilterMask: makeAtomic('collisionFilterMask', index),
+            collisionResponse: makeAtomic('collisionResponse', index),
+            fixedRotation: makeAtomic('fixedRotation', index),
+            isTrigger: makeAtomic('isTrigger', index),
+            linearDamping: makeAtomic('linearDamping', index),
+            linearFactor: makeVec('linearFactor', index),
+            mass: makeAtomic('mass', index),
+            material: makeAtomic('material', index),
+            position: makeVec('position', index),
+            quaternion: makeQuaternion(index),
+            rotation: makeRotation(index),
+            scaleOverride(scale) {
+                const uuid = getUUID(bodyRef, index);
+                if (uuid)
+                    scaleOverrides[uuid] = new Vector3(...scale);
+            },
+            sleep() {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().sleep({ uuid });
+            },
+            sleepSpeedLimit: makeAtomic('sleepSpeedLimit', index),
+            sleepTimeLimit: makeAtomic('sleepTimeLimit', index),
+            userData: makeAtomic('userData', index),
+            velocity: makeVec('velocity', index),
+            remove: makeRemove(index),
+            wakeUp() {
+                const uuid = getUUID(bodyRef, index);
+                uuid && bodies[uuid] != null && worker().wakeUp({ uuid });
+            },
+        };
+    }
+    const cache = {};
+    return {
+        ...makeApi(undefined),
+        at: (index) => cache[index] || (cache[index] = makeApi(index)),
+    };
+}
+export const defaultTransformArgs = {
+    Plane: (args) => [],
+    Box: (args = [1, 1, 1]) => args,
+    Trimesh: (args) => args,
+    Cylinder: (args = []) => [],
+    Heightfield: (args) => args,
+    ConvexPolyhedron: ([vertices, faces, normals, axes, boundingSphereRadius] = []) => [
+        vertices && vertices.map(makeTriplet),
+        faces,
+        normals && normals.map(makeTriplet),
+        axes && axes.map(makeTriplet),
+        boundingSphereRadius,
+    ],
+    Particle: (args) => [],
+    Sphere: (args = [1]) => {
+        if (!Array.isArray(args))
+            throw new Error('Sphere body args must be an array');
+        return [args[0]];
+    },
+    Compound: (args) => args,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../libs/cannon/body/src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { type ElementRef, type Signal } from '@angular/core';\nimport type {\n\tAtomicName,\n\tBodyProps,\n\tCannonWorkerAPI,\n\tConvexPolyhedronArgs,\n\tCylinderArgs,\n\tHeightfieldArgs,\n\tPropValue,\n\tQuad,\n\tSetOpName,\n\tSphereArgs,\n\tSubscriptionName,\n\tSubscriptionTarget,\n\tSubscriptions,\n\tTrimeshArgs,\n\tTriplet,\n\tVectorName,\n} from '@pmndrs/cannon-worker-api';\nimport type { NgtcCannonEvents, NgtcPhysicsApi } from 'angular-three-cannon';\nimport { Euler, Quaternion, Vector3, type Object3D } from 'three';\nimport type { NgtcWorkerApi } from './types';\n\nfunction capitalize<T extends string>(str: T): Capitalize<T> {\n\treturn (str.charAt(0).toUpperCase() + str.slice(1)) as Capitalize<T>;\n}\n\nfunction getUUID(ref: ElementRef<Object3D>, index?: number): string | null {\n\tconst suffix = index === undefined ? '' : `/${index}`;\n\tif (typeof ref === 'function') return null;\n\treturn ref && ref.nativeElement && `${ref.nativeElement.uuid}${suffix}`;\n}\n\nconst e = new Euler();\nconst q = new Quaternion();\n\nfunction quaternionToRotation(callback: (v: Triplet) => void) {\n\treturn (v: Quad) => callback(e.setFromQuaternion(q.fromArray(v)).toArray() as Triplet);\n}\n\nlet incrementingId = 0;\nfunction createSubscribe<T extends SubscriptionName>(\n\tref: ElementRef<Object3D>,\n\tworker: CannonWorkerAPI,\n\tsubscriptions: Subscriptions,\n\ttype: T,\n\tindex?: number,\n\ttarget: SubscriptionTarget = 'bodies',\n) {\n\treturn (callback: (value: PropValue<T>) => void) => {\n\t\tconst id = incrementingId++;\n\t\tsubscriptions[id] = { [type]: callback };\n\t\tconst uuid = getUUID(ref, index);\n\t\tuuid && worker.subscribe({ props: { id, target, type }, uuid });\n\t\treturn () => {\n\t\t\tdelete subscriptions[id];\n\t\t\tworker.unsubscribe({ props: id });\n\t\t};\n\t};\n}\n\nfunction makeTriplet(v: Vector3 | Triplet): Triplet {\n\treturn v instanceof Vector3 ? [v.x, v.y, v.z] : v;\n}\n\nexport function prepare(object: Object3D, { position = [0, 0, 0], rotation = [0, 0, 0], userData = {} }: BodyProps) {\n\tobject.userData = userData;\n\tobject.position.set(...position);\n\tobject.rotation.set(...rotation);\n\tobject.updateMatrix();\n}\n\nexport function setupCollision(\n\tevents: NgtcCannonEvents,\n\t{ onCollide, onCollideBegin, onCollideEnd }: Partial<BodyProps>,\n\tuuid: string,\n) {\n\tevents[uuid] = {\n\t\tcollide: onCollide,\n\t\tcollideBegin: onCollideBegin,\n\t\tcollideEnd: onCollideEnd,\n\t};\n}\n\nexport function makeApi(\n\tworker: Signal<CannonWorkerAPI>,\n\tbodyRef: ElementRef<Object3D>,\n\t{ subscriptions, bodies, scaleOverrides }: NgtcPhysicsApi,\n) {\n\tconst makeAtomic = <T extends AtomicName>(type: T, index?: number) => {\n\t\tconst op: SetOpName<T> = `set${capitalize(type)}`;\n\n\t\treturn {\n\t\t\tset: (value: PropValue<T>) => {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid &&\n\t\t\t\t\tworker()[op]({\n\t\t\t\t\t\tprops: value,\n\t\t\t\t\t\tuuid,\n\t\t\t\t\t} as never);\n\t\t\t},\n\t\t\tsubscribe: createSubscribe(bodyRef, worker(), subscriptions, type, index),\n\t\t};\n\t};\n\n\tconst makeQuaternion = (index?: number) => {\n\t\tconst type = 'quaternion';\n\t\treturn {\n\t\t\tcopy: ({ w, x, y, z }: Quaternion) => {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().setQuaternion({ props: [x, y, z, w], uuid });\n\t\t\t},\n\t\t\tset: (x: number, y: number, z: number, w: number) => {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().setQuaternion({ props: [x, y, z, w], uuid });\n\t\t\t},\n\t\t\tsubscribe: createSubscribe(bodyRef, worker(), subscriptions, type, index),\n\t\t};\n\t};\n\n\tconst makeRotation = (index?: number) => {\n\t\treturn {\n\t\t\tcopy: ({ x, y, z }: Vector3 | Euler) => {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().setRotation({ props: [x, y, z], uuid });\n\t\t\t},\n\t\t\tset: (x: number, y: number, z: number) => {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().setRotation({ props: [x, y, z], uuid });\n\t\t\t},\n\t\t\tsubscribe: (callback: (value: Triplet) => void) => {\n\t\t\t\tconst id = incrementingId++;\n\t\t\t\tconst target = 'bodies';\n\t\t\t\tconst type = 'quaternion';\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\n\t\t\t\tsubscriptions[id] = { [type]: quaternionToRotation(callback) };\n\t\t\t\tuuid && bodies[uuid] != null && worker().subscribe({ props: { id, target, type }, uuid });\n\t\t\t\treturn () => {\n\t\t\t\t\tdelete subscriptions[id];\n\t\t\t\t\tworker().unsubscribe({ props: id });\n\t\t\t\t};\n\t\t\t},\n\t\t};\n\t};\n\n\tconst makeVec = (type: VectorName, index?: number) => {\n\t\tconst op: SetOpName<VectorName> = `set${capitalize(type)}`;\n\t\treturn {\n\t\t\tcopy: ({ x, y, z }: Vector3 | Euler) => {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker()[op]({ props: [x, y, z], uuid });\n\t\t\t},\n\t\t\tset: (x: number, y: number, z: number) => {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker()[op]({ props: [x, y, z], uuid });\n\t\t\t},\n\t\t\tsubscribe: createSubscribe(bodyRef, worker(), subscriptions, type, index),\n\t\t};\n\t};\n\n\tconst makeRemove = (index?: number) => {\n\t\tconst uuid = getUUID(bodyRef, index);\n\t\treturn () => {\n\t\t\tif (uuid) worker().removeBodies({ uuid: [uuid] });\n\t\t};\n\t};\n\n\tfunction makeApi(index?: number): NgtcWorkerApi {\n\t\treturn {\n\t\t\tallowSleep: makeAtomic('allowSleep', index),\n\t\t\tangularDamping: makeAtomic('angularDamping', index),\n\t\t\tangularFactor: makeVec('angularFactor', index),\n\t\t\tangularVelocity: makeVec('angularVelocity', index),\n\t\t\tapplyForce(force: Triplet, worldPoint: Triplet) {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().applyForce({ props: [force, worldPoint], uuid });\n\t\t\t},\n\t\t\tapplyImpulse(impulse: Triplet, worldPoint: Triplet) {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().applyImpulse({ props: [impulse, worldPoint], uuid });\n\t\t\t},\n\t\t\tapplyLocalForce(force: Triplet, localPoint: Triplet) {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().applyLocalForce({ props: [force, localPoint], uuid });\n\t\t\t},\n\t\t\tapplyLocalImpulse(impulse: Triplet, localPoint: Triplet) {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().applyLocalImpulse({ props: [impulse, localPoint], uuid });\n\t\t\t},\n\t\t\tapplyTorque(torque: Triplet) {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().applyTorque({ props: [torque], uuid });\n\t\t\t},\n\t\t\tcollisionFilterGroup: makeAtomic('collisionFilterGroup', index),\n\t\t\tcollisionFilterMask: makeAtomic('collisionFilterMask', index),\n\t\t\tcollisionResponse: makeAtomic('collisionResponse', index),\n\t\t\tfixedRotation: makeAtomic('fixedRotation', index),\n\t\t\tisTrigger: makeAtomic('isTrigger', index),\n\t\t\tlinearDamping: makeAtomic('linearDamping', index),\n\t\t\tlinearFactor: makeVec('linearFactor', index),\n\t\t\tmass: makeAtomic('mass', index),\n\t\t\tmaterial: makeAtomic('material', index),\n\t\t\tposition: makeVec('position', index),\n\t\t\tquaternion: makeQuaternion(index),\n\t\t\trotation: makeRotation(index),\n\t\t\tscaleOverride(scale) {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tif (uuid) scaleOverrides[uuid] = new Vector3(...scale);\n\t\t\t},\n\t\t\tsleep() {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().sleep({ uuid });\n\t\t\t},\n\t\t\tsleepSpeedLimit: makeAtomic('sleepSpeedLimit', index),\n\t\t\tsleepTimeLimit: makeAtomic('sleepTimeLimit', index),\n\t\t\tuserData: makeAtomic('userData', index),\n\t\t\tvelocity: makeVec('velocity', index),\n\t\t\tremove: makeRemove(index),\n\t\t\twakeUp() {\n\t\t\t\tconst uuid = getUUID(bodyRef, index);\n\t\t\t\tuuid && bodies[uuid] != null && worker().wakeUp({ uuid });\n\t\t\t},\n\t\t};\n\t}\n\n\tconst cache: { [index: number]: NgtcWorkerApi } = {};\n\treturn {\n\t\t...makeApi(undefined),\n\t\tat: (index: number) => cache[index] || (cache[index] = makeApi(index)),\n\t};\n}\n\nexport const defaultTransformArgs = {\n\tPlane: (args: unknown[]) => [],\n\tBox: (args: Triplet = [1, 1, 1]) => args,\n\tTrimesh: (args: TrimeshArgs) => args,\n\tCylinder: (args: CylinderArgs = []) => [],\n\tHeightfield: (args: HeightfieldArgs) => args,\n\tConvexPolyhedron: ([vertices, faces, normals, axes, boundingSphereRadius]: ConvexPolyhedronArgs<Triplet> = []) => [\n\t\tvertices && vertices.map(makeTriplet),\n\t\tfaces,\n\t\tnormals && normals.map(makeTriplet),\n\t\taxes && axes.map(makeTriplet),\n\t\tboundingSphereRadius,\n\t],\n\tParticle: (args: unknown[]) => [],\n\tSphere: (args: SphereArgs = [1]) => {\n\t\tif (!Array.isArray(args)) throw new Error('Sphere body args must be an array');\n\t\treturn [args[0]];\n\t},\n\tCompound: (args: unknown[]) => args,\n};\n"]}

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

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