angular-three-cannon 2.0.0-beta.24 → 2.0.0-beta.241

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,18 @@
+import { ElementRef, Injector } from '@angular/core';
+import { BodyShapeType } from '@pmndrs/cannon-worker-api';
+import { Object3D } from 'three';
+import { NgtcArgFn, NgtcBodyPropsMap, NgtcBodyReturn, NgtcGetByIndex } from './types';
+export interface NgtcBodyOptions<TShape extends BodyShapeType> {
+    transformArgs?: NgtcArgFn<NgtcBodyPropsMap[TShape]>;
+    ref?: ElementRef<Object3D>;
+    injector?: Injector;
+}
+export declare const injectBox: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").BoxProps>, options?: NgtcBodyOptions<"Box"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectConvexPolyhedron: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").ConvexPolyhedronProps>, options?: NgtcBodyOptions<"ConvexPolyhedron"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectCylinder: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").CylinderProps>, options?: NgtcBodyOptions<"Cylinder"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectHeightfield: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").HeightfieldProps>, options?: NgtcBodyOptions<"Heightfield"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectParticle: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").ParticleProps>, options?: NgtcBodyOptions<"Particle"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectPlane: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").PlaneProps>, options?: NgtcBodyOptions<"Plane"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectSphere: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").SphereProps>, options?: NgtcBodyOptions<"Sphere"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectTrimesh: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").TrimeshProps>, options?: NgtcBodyOptions<"Trimesh"> | undefined) => NgtcBodyReturn<TObject>;
+export declare const injectCompound: <TObject extends Object3D<import("three").Object3DEventMap>>(getPropFn: NgtcGetByIndex<import("@pmndrs/cannon-worker-api").CompoundBodyProps>, options?: NgtcBodyOptions<"Compound"> | undefined) => NgtcBodyReturn<TObject>;

package/body/lib/types.d.ts

@@ -0,0 +1,54 @@
+import { AtomicName, AtomicProps, BodyProps, BoxProps, CompoundBodyProps, ConvexPolyhedronProps, CylinderProps, HeightfieldProps, ParticleProps, PlaneProps, Quad, SphereProps, TrimeshProps, Triplet, VectorName } from '@pmndrs/cannon-worker-api';
+import { NgtInjectedRef } from 'angular-three';
+import { Euler, Object3D, Quaternion, Vector3 } from 'three';
+export interface NgtcAtomicApi<K extends AtomicName> {
+    set: (value: AtomicProps[K]) => void;
+    subscribe: (callback: (value: AtomicProps[K]) => void) => () => void;
+}
+export interface 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 interface 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 interface NgtcBodyReturn<TObject extends Object3D> {
+    ref: NgtInjectedRef<TObject>;
+    api: NgtcBodyPublicApi;
+}
+export type NgtcBodyPropsMap = {
+    Plane: PlaneProps;
+    Box: BoxProps;
+    Particle: ParticleProps;
+    Cylinder: CylinderProps;
+    Sphere: SphereProps;
+    Trimesh: TrimeshProps;
+    Heightfield: HeightfieldProps;
+    ConvexPolyhedron: ConvexPolyhedronProps;
+    Compound: CompoundBodyProps;
+};
+export type NgtcGetByIndex<T extends BodyProps> = (index: number) => T;
+export type NgtcArgFn<T extends BodyProps> = (args: NonNullable<T['args']>) => typeof args;

package/body/lib/utils.d.ts

@@ -0,0 +1,52 @@
+import { ElementRef } from '@angular/core';
+import { BodyProps, BoxProps, CannonWorkerAPI, CompoundBodyProps, ConvexPolyhedronArgs, CylinderArgs, HeightfieldArgs, ParticleProps, PlaneProps, PropValue, SphereArgs, SubscriptionName, SubscriptionTarget, Subscriptions, TrimeshArgs, Triplet } from '@pmndrs/cannon-worker-api';
+import { NgtInjectedRef } from 'angular-three';
+import { NgtcCannonEvents, NgtcPhysicsApi } from 'angular-three-cannon';
+import { Object3D } from 'three';
+import { NgtcWorkerApi } from './types';
+export declare function createSubscribe<T extends SubscriptionName>(ref: ElementRef<Object3D>, worker: CannonWorkerAPI, subscriptions: Subscriptions, type: T, index?: number, target?: SubscriptionTarget): (callback: (value: PropValue<T>) => void) => () => void;
+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 makeBodyApi(bodyRef: NgtInjectedRef<Object3D>, { subscriptions, bodies, scaleOverrides, worker }: 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: PlaneProps['args']) => never[];
+    Box: (args?: BoxProps['args']) => Triplet;
+    Trimesh: (args: TrimeshArgs) => TrimeshArgs;
+    Cylinder: (args?: CylinderArgs) => never[];
+    Heightfield: (args: HeightfieldArgs) => HeightfieldArgs;
+    ConvexPolyhedron: ([vertices, faces, normals, axes, boundingSphereRadius]?: ConvexPolyhedronArgs) => (number | number[][] | undefined)[];
+    Particle: (args: ParticleProps['args']) => never[];
+    Sphere: (args?: SphereArgs) => number[];
+    Compound: (args: CompoundBodyProps['args']) => unknown[] | undefined;
+};

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,38 @@
+import { ElementRef, Injector } from '@angular/core';
+import { ConeTwistConstraintOpts, ConstraintTypes, DistanceConstraintOpts, HingeConstraintOpts, LockConstraintOpts, PointToPointConstraintOpts } from '@pmndrs/cannon-worker-api';
+import { NgtInjectedRef } from 'angular-three';
+import { Object3D } from 'three';
+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 NgtcConstraintReturn<T extends 'Hinge' | ConstraintTypes, TObjectA extends Object3D = Object3D, TObjectB extends Object3D = Object3D> {
+    bodyA: NgtInjectedRef<TObjectA>;
+    bodyB: NgtInjectedRef<TObjectB>;
+    api: NgtcConstraintORHingeApi<T>;
+}
+export type NgtcConstraintOptionsMap = {
+    ConeTwist: ConeTwistConstraintOpts;
+    PointToPoint: PointToPointConstraintOpts;
+    Distance: DistanceConstraintOpts;
+    Lock: LockConstraintOpts;
+    Hinge: HingeConstraintOpts;
+};
+export type NgtcConstraintOptions<TConstraintType extends 'Hinge' | ConstraintTypes> = {
+    injector?: Injector;
+    disableOnStart?: boolean;
+    options?: NgtcConstraintOptionsMap[TConstraintType];
+};
+export declare const injectPointToPoint: <A extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>, B extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>>(bodyA: A | ElementRef<A>, bodyB: B | ElementRef<B>, options?: NgtcConstraintOptions<"PointToPoint"> | undefined) => NgtcConstraintReturn<"PointToPoint", A, B>;
+export declare const injectConeTwist: <A extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>, B extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>>(bodyA: A | ElementRef<A>, bodyB: B | ElementRef<B>, options?: NgtcConstraintOptions<"ConeTwist"> | undefined) => NgtcConstraintReturn<"ConeTwist", A, B>;
+export declare const injectDistance: <A extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>, B extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>>(bodyA: A | ElementRef<A>, bodyB: B | ElementRef<B>, options?: NgtcConstraintOptions<"Distance"> | undefined) => NgtcConstraintReturn<"Distance", A, B>;
+export declare const injectLock: <A extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>, B extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>>(bodyA: A | ElementRef<A>, bodyB: B | ElementRef<B>, options?: NgtcConstraintOptions<"Lock"> | undefined) => NgtcConstraintReturn<"Lock", A, B>;
+export declare const injectHinge: <A extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>, B extends Object3D<import("three").Object3DEventMap> = Object3D<import("three").Object3DEventMap>>(bodyA: A | ElementRef<A>, bodyB: B | ElementRef<B>, options?: NgtcConstraintOptions<"Hinge"> | undefined) => NgtcConstraintReturn<"Hinge", A, B>;

package/debug/lib/debug.d.ts

@@ -1,43 +1,46 @@
-import { type OnInit } from '@angular/core';
-import { type BodyProps, type BodyShapeType } from '@pmndrs/cannon-worker-api';
+import { BodyProps, 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;
+        remove: (uuid: string) => void;
     };
     (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;
+        remove: (uuid: 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;
+        remove: (uuid: 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 {
+}, provideNgtcDebugApi: () => import("@angular/core").Provider;
+export interface NgtcDebugInputs {
+    enabled: boolean;
     color: string;
-    scale: number;
     impl: typeof CannonDebugger;
-    disabled: boolean;
+    scale: number;
+}
+export declare class NgtcDebug {
+    private store;
+    private physicsApi;
+    debug: import("@angular/core").InputSignalWithTransform<NgtcDebugInputs, "" | Partial<NgtcDebugInputs>>;
+    private defaultScene;
+    private scene;
     private bodies;
     private bodyMap;
-    private physicsApi;
-    scene: THREE.Scene;
     private cannonDebugger;
     api: {
         add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
-        remove: (id: string) => void;
+        remove: (uuid: 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, { "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,94 @@
+import { afterNextRender } from '@angular/core';
+import { injectNgtRef } from 'angular-three';
+import { injectPhysicsApi } from 'angular-three-cannon';
+import { injectNgtcDebugApi } from 'angular-three-cannon/debug';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { DynamicDrawUsage, InstancedMesh, Object3D } from 'three';
+import { defaultTransformArgs, makeBodyApi, prepare, setupCollision } from './utils';
+function createInjectBody(type) {
+    return (getPropFn, options) => injectBody(type, getPropFn, options);
+}
+function injectBody(type, getPropFn, { transformArgs, ref, injector } = {}) {
+    return assertInjector(injectBody, injector, () => {
+        const physicsApi = injectPhysicsApi({ optional: true });
+        if (!physicsApi) {
+            throw new Error(`[NGT Cannon] injectBody was called outside of <ngtc-physics>`);
+        }
+        const autoEffect = injectAutoEffect();
+        const debugApi = injectNgtcDebugApi({ optional: true });
+        const { add: addToDebug, remove: removeFromDebug } = debugApi || {};
+        const transform = transformArgs ?? defaultTransformArgs[type];
+        const bodyRef = injectNgtRef(ref);
+        const bodyResult = { ref: bodyRef, api: makeBodyApi(bodyRef, physicsApi) };
+        afterNextRender(() => {
+            autoEffect(() => {
+                const currentWorker = physicsApi.worker();
+                if (!currentWorker)
+                    return;
+                if (!bodyResult.ref.nativeElement) {
+                    bodyResult.ref.nativeElement = new Object3D();
+                }
+                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);
+                            }
+                            physicsApi.refs[id] = object;
+                            addToDebug?.(id, props, type);
+                            setupCollision(physicsApi.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,
+                });
+                return () => {
+                    uuid.forEach((id) => {
+                        delete physicsApi.refs[id];
+                        removeFromDebug?.(id);
+                        delete physicsApi.events[id];
+                    });
+                    currentWorker.removeBodies({ uuid });
+                };
+            });
+        });
+        return bodyResult;
+    });
+}
+export const injectBox = createInjectBody('Box');
+export const injectConvexPolyhedron = createInjectBody('ConvexPolyhedron');
+export const injectCylinder = createInjectBody('Cylinder');
+export const injectHeightfield = createInjectBody('Heightfield');
+export const injectParticle = createInjectBody('Particle');
+export const injectPlane = createInjectBody('Plane');
+export const injectSphere = createInjectBody('Sphere');
+export const injectTrimesh = createInjectBody('Trimesh');
+export const injectCompound = createInjectBody('Compound');
+//# 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 { ElementRef, Injector, afterNextRender } from '@angular/core';\nimport { BodyShapeType } from '@pmndrs/cannon-worker-api';\nimport { injectNgtRef } from 'angular-three';\nimport { injectPhysicsApi } from 'angular-three-cannon';\nimport { injectNgtcDebugApi } from 'angular-three-cannon/debug';\nimport { assertInjector } from 'ngxtension/assert-injector';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { DynamicDrawUsage, InstancedMesh, Object3D } from 'three';\nimport { NgtcArgFn, NgtcBodyPropsMap, NgtcBodyReturn, NgtcGetByIndex } from './types';\nimport { defaultTransformArgs, makeBodyApi, prepare, setupCollision } from './utils';\n\nexport interface NgtcBodyOptions<TShape extends BodyShapeType> {\n\ttransformArgs?: NgtcArgFn<NgtcBodyPropsMap[TShape]>;\n\tref?: ElementRef<Object3D>;\n\tinjector?: Injector;\n}\n\nfunction createInjectBody<TShape extends BodyShapeType>(type: TShape) {\n\treturn <TObject extends Object3D>(\n\t\tgetPropFn: NgtcGetByIndex<NgtcBodyPropsMap[TShape]>,\n\t\toptions?: NgtcBodyOptions<TShape>,\n\t) => injectBody<TShape, TObject>(type, getPropFn, options);\n}\n\nfunction injectBody<TShape extends BodyShapeType, TObject extends Object3D>(\n\ttype: TShape,\n\tgetPropFn: NgtcGetByIndex<NgtcBodyPropsMap[TShape]>,\n\t{ transformArgs, ref, injector }: NgtcBodyOptions<TShape> = {},\n): NgtcBodyReturn<TObject> {\n\treturn assertInjector(injectBody, injector, () => {\n\t\tconst physicsApi = injectPhysicsApi({ optional: true });\n\n\t\tif (!physicsApi) {\n\t\t\tthrow new Error(`[NGT Cannon] injectBody was called outside of <ngtc-physics>`);\n\t\t}\n\n\t\tconst autoEffect = injectAutoEffect();\n\t\tconst debugApi = injectNgtcDebugApi({ optional: true });\n\n\t\tconst { add: addToDebug, remove: removeFromDebug } = debugApi || {};\n\t\tconst transform = transformArgs ?? defaultTransformArgs[type];\n\t\tconst bodyRef = injectNgtRef(ref);\n\t\tconst bodyResult = { ref: bodyRef, api: makeBodyApi(bodyRef, physicsApi) };\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst currentWorker = physicsApi.worker();\n\t\t\t\tif (!currentWorker) return;\n\n\t\t\t\tif (!bodyResult.ref.nativeElement) {\n\t\t\t\t\tbodyResult.ref.nativeElement = new Object3D();\n\t\t\t\t}\n\n\t\t\t\tconst object = bodyResult.ref.nativeElement;\n\t\t\t\tconst [uuid, props] = (() => {\n\t\t\t\t\tlet uuids: string[] = [];\n\t\t\t\t\tlet temp: Object3D;\n\t\t\t\t\tif (object instanceof InstancedMesh) {\n\t\t\t\t\t\tobject.instanceMatrix.setUsage(DynamicDrawUsage);\n\t\t\t\t\t\tuuids = new Array(object.count).fill(0).map((_, i) => `${object.uuid}/${i}`);\n\t\t\t\t\t\ttemp = new Object3D();\n\t\t\t\t\t} else {\n\t\t\t\t\t\tuuids = [object.uuid];\n\t\t\t\t\t}\n\t\t\t\t\treturn [\n\t\t\t\t\t\tuuids,\n\t\t\t\t\t\tuuids.map((id, index) => {\n\t\t\t\t\t\t\tconst props = getPropFn(index);\n\t\t\t\t\t\t\tif (temp) {\n\t\t\t\t\t\t\t\tprepare(temp, props);\n\t\t\t\t\t\t\t\t(object as InstancedMesh).setMatrixAt(index, temp.matrix);\n\t\t\t\t\t\t\t\t(object as InstancedMesh).instanceMatrix.needsUpdate = true;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tprepare(object, props);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tphysicsApi.refs[id] = object;\n\t\t\t\t\t\t\taddToDebug?.(id, props, type);\n\t\t\t\t\t\t\tsetupCollision(physicsApi.events, props, id);\n\t\t\t\t\t\t\t// @ts-expect-error - if args is undefined, there's default\n\t\t\t\t\t\t\treturn { ...props, args: transform(props.args) };\n\t\t\t\t\t\t}),\n\t\t\t\t\t];\n\t\t\t\t})();\n\t\t\t\t// Register on mount, unregister on unmount\n\t\t\t\tcurrentWorker.addBodies({\n\t\t\t\t\tprops: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => {\n\t\t\t\t\t\treturn { onCollide: Boolean(onCollide), ...serializableProps };\n\t\t\t\t\t}),\n\t\t\t\t\ttype,\n\t\t\t\t\tuuid,\n\t\t\t\t});\n\n\t\t\t\treturn () => {\n\t\t\t\t\tuuid.forEach((id) => {\n\t\t\t\t\t\tdelete physicsApi.refs[id];\n\t\t\t\t\t\tremoveFromDebug?.(id);\n\t\t\t\t\t\tdelete physicsApi.events[id];\n\t\t\t\t\t});\n\t\t\t\t\tcurrentWorker.removeBodies({ uuid });\n\t\t\t\t};\n\t\t\t});\n\t\t});\n\n\t\treturn bodyResult as NgtcBodyReturn<TObject>;\n\t});\n}\n\nexport const injectBox = createInjectBody('Box');\nexport const injectConvexPolyhedron = createInjectBody('ConvexPolyhedron');\nexport const injectCylinder = createInjectBody('Cylinder');\nexport const injectHeightfield = createInjectBody('Heightfield');\nexport const injectParticle = createInjectBody('Particle');\nexport const injectPlane = createInjectBody('Plane');\nexport const injectSphere = createInjectBody('Sphere');\nexport const injectTrimesh = createInjectBody('Trimesh');\nexport const injectCompound = createInjectBody('Compound');\n"]}

package/esm2022/body/lib/types.mjs

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