angular-three-cannon 2.0.0-beta.230 → 2.0.0-beta.232

package/body/lib/body.d.ts

@@ -1,57 +1,19 @@
 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 { BodyShapeType } from '@pmndrs/cannon-worker-api';
+import { 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;
+import { NgtcArgFn, NgtcBodyPropsMap, NgtcBodyReturn, NgtcGetByIndex } from './types';
+export interface NgtcBodyOptions<TShape extends BodyShapeType> {
+    transformArgs?: NgtcArgFn<NgtcBodyPropsMap[TShape]>;
     ref?: NgtInjectedRef<Object3D>;
-    transformArgs?: NgtcBodyOptions<TType>['transformArgs'];
-}): NgtcBodyResult;
-export {};
+    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

@@ -1,19 +1,20 @@
-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> = {
+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 type NgtcQuaternionApi = {
+}
+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 type NgtcVectorApi = {
+}
+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>;
 } & {
@@ -34,5 +35,20 @@ export type NgtcWorkerApi = {
 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 NgtcTransformArg<T extends unknown[]> = (args: T) => T;
+export type NgtcArgFn<T extends BodyProps> = (args: NonNullable<T['args']>) => typeof args;

package/body/lib/utils.d.ts

@@ -1,11 +1,13 @@
-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';
+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 makeApi(worker: Signal<CannonWorkerAPI>, bodyRef: ElementRef<Object3D>, { subscriptions, bodies, scaleOverrides }: NgtcPhysicsApi): {
+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">;
@@ -38,13 +40,13 @@ export declare function makeApi(worker: Signal<CannonWorkerAPI>, bodyRef: Elemen
     remove: () => void;
 };
 export declare const defaultTransformArgs: {
-    Plane: (args: unknown[]) => never[];
-    Box: (args?: Triplet) => Triplet;
+    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<Triplet>) => (number | number[][] | undefined)[];
-    Particle: (args: unknown[]) => never[];
+    ConvexPolyhedron: ([vertices, faces, normals, axes, boundingSphereRadius]?: ConvexPolyhedronArgs) => (number | number[][] | undefined)[];
+    Particle: (args: ParticleProps['args']) => never[];
     Sphere: (args?: SphereArgs) => number[];
-    Compound: (args: unknown[]) => unknown[];
+    Compound: (args: CompoundBodyProps['args']) => unknown[] | undefined;
 };

package/constraint/lib/constraint.d.ts

@@ -1,11 +1,7 @@
 import { Injector } from '@angular/core';
-import type { ConstraintOptns, ConstraintTypes, HingeConstraintOpts } from '@pmndrs/cannon-worker-api';
-import { type NgtInjectedRef } from 'angular-three';
+import { ConeTwistConstraintOpts, ConstraintTypes, DistanceConstraintOpts, HingeConstraintOpts, LockConstraintOpts, PointToPointConstraintOpts } from '@pmndrs/cannon-worker-api';
+import { 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;
@@ -18,9 +14,24 @@ export interface NgtcHingeConstraintApi extends NgtcConstraintApi {
     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> {
+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 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>;
+export type NgtcConstraintOptionsMap = {
+    ConeTwist: ConeTwistConstraintOpts;
+    PointToPoint: PointToPointConstraintOpts;
+    Distance: DistanceConstraintOpts;
+    Lock: LockConstraintOpts;
+    Hinge: HingeConstraintOpts;
+};
+export type NgtcConstraintOptions<TConstraintType extends 'Hinge' | ConstraintTypes> = {
+    injector?: Injector;
+    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 | NgtInjectedRef<A>, bodyB: B | NgtInjectedRef<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 | NgtInjectedRef<A>, bodyB: B | NgtInjectedRef<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 | NgtInjectedRef<A>, bodyB: B | NgtInjectedRef<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 | NgtInjectedRef<A>, bodyB: B | NgtInjectedRef<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 | NgtInjectedRef<A>, bodyB: B | NgtInjectedRef<B>, options?: NgtcConstraintOptions<"Hinge"> | undefined) => NgtcConstraintReturn<"Hinge", A, B>;

package/debug/lib/debug.d.ts

@@ -1,11 +1,10 @@
-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;
@@ -13,32 +12,35 @@ export declare const injectNgtcDebugApi: {
         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 & {
         injector?: import("@angular/core").Injector | undefined;
     }): {
         add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
-        remove: (id: string) => void;
+        remove: (uuid: string) => void;
     } | null;
 }, provideNgtcDebugApi: () => import("@angular/core").Provider;
+export interface NgtcDebugInputs {
+    enabled: boolean;
+    color: string;
+    impl: typeof CannonDebugger;
+    scale: number;
+}
 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;
+    debug: import("@angular/core").InputSignalWithTransform<NgtcDebugInputs, Partial<NgtcDebugInputs>>;
+    private defaultScene;
+    private scene;
+    private bodies;
+    private bodyMap;
     private cannonDebugger;
     api: {
         add: (uuid: string, props: BodyProps, type: BodyShapeType) => void;
-        remove: (id: string) => void;
+        remove: (uuid: string) => void;
     };
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtcDebug, 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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtcDebug, "ngtc-physics[debug]", never, { "debug": { "alias": "debug"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/esm2022/body/lib/body.mjs

@@ -1,26 +1,29 @@
-import { afterNextRender, effect, inject, Injector } from '@angular/core';
+import { afterNextRender } 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 { injectAutoEffect } from 'ngxtension/auto-effect';
 import { DynamicDrawUsage, InstancedMesh, Object3D } from 'three';
-import { defaultTransformArgs, makeApi, prepare, setupCollision } from './utils';
-export function injectBody(type, getPropFn, { injector, ref, transformArgs, } = {}) {
+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 assertedInjector = inject(Injector);
-        const physicsApi = injectNgtcPhysicsApi();
+        const physicsApi = injectNgtcPhysicsApi({ 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 }, physics, worker] = [
-            debugApi || {},
-            physicsApi.get(),
-            physicsApi.select('worker'),
-        ];
+        const { add: addToDebug, remove: removeFromDebug } = debugApi || {};
         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();
+            Object.assign(bodyResult, { api: makeBodyApi(bodyResult.ref, physicsApi) });
+            autoEffect(() => {
+                const currentWorker = physicsApi.worker();
                 if (!currentWorker)
                     return;
                 if (!bodyResult.ref.nativeElement) {
@@ -51,9 +54,9 @@ export function injectBody(type, getPropFn, { injector, ref, transformArgs, } =
                             else {
                                 prepare(object, props);
                             }
-                            physics.refs[id] = object;
+                            physicsApi.refs[id] = object;
                             addToDebug?.(id, props, type);
-                            setupCollision(physics.events, props, id);
+                            setupCollision(physicsApi.events, props, id);
                             // @ts-expect-error - if args is undefined, there's default
                             return { ...props, args: transform(props.args) };
                         }),
@@ -67,17 +70,26 @@ export function injectBody(type, getPropFn, { injector, ref, transformArgs, } =
                     type,
                     uuid,
                 });
-                onCleanup(() => {
+                return () => {
                     uuid.forEach((id) => {
-                        delete physics.refs[id];
+                        delete physicsApi.refs[id];
                         removeFromDebug?.(id);
-                        delete physics.events[id];
+                        delete physicsApi.events[id];
                     });
-                    currentWorker.removeBodies({ uuid: uuid });
-                });
-            }, { injector: assertedInjector });
+                    currentWorker.removeBodies({ uuid });
+                };
+            });
         });
         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"]}
+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 { Injector, afterNextRender } from '@angular/core';\nimport { BodyShapeType } from '@pmndrs/cannon-worker-api';\nimport { NgtInjectedRef, injectNgtRef } from 'angular-three';\nimport { injectNgtcPhysicsApi } 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?: NgtInjectedRef<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 = injectNgtcPhysicsApi({ 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 bodyResult = { ref: ref ?? injectNgtRef() };\n\n\t\tafterNextRender(() => {\n\t\t\tObject.assign(bodyResult, { api: makeBodyApi(bodyResult.ref, physicsApi) });\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\treturn;\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

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