angular-three-cannon 2.0.0-beta.25 → 2.0.0-beta.251

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

package/body/lib/types.d.ts

@@ -0,0 +1,49 @@
+import { AtomicName, AtomicProps, BodyProps, BoxProps, CompoundBodyProps, ConvexPolyhedronProps, CylinderProps, HeightfieldProps, ParticleProps, PlaneProps, Quad, SphereProps, TrimeshProps, Triplet, VectorName } from '@pmndrs/cannon-worker-api';
+import { Euler, 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 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,50 @@
+import { BodyProps, BoxProps, CannonWorkerAPI, CompoundBodyProps, ConvexPolyhedronArgs, CylinderArgs, HeightfieldArgs, ParticleProps, PlaneProps, PropValue, SphereArgs, SubscriptionName, SubscriptionTarget, Subscriptions, TrimeshArgs, Triplet } from '@pmndrs/cannon-worker-api';
+import { NgtcCannonEvents, NgtcPhysicsApi } from 'angular-three-cannon';
+import { Object3D } from 'three';
+import { NgtcWorkerApi } from './types';
+export declare function createSubscribe<T extends SubscriptionName>(body: 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(body: Object3D, worker: CannonWorkerAPI, { subscriptions, 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: 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,32 @@
+import { ElementRef, Injector, Signal } from '@angular/core';
+import { ConeTwistConstraintOpts, ConstraintTypes, DistanceConstraintOpts, HingeConstraintOpts, LockConstraintOpts, PointToPointConstraintOpts } from '@pmndrs/cannon-worker-api';
+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 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> | Signal<A | ElementRef<A> | undefined>, bodyB: B | ElementRef<B> | Signal<B | ElementRef<B> | undefined>, options?: NgtcConstraintOptions<"PointToPoint"> | undefined) => Signal<NgtcConstraintApi | null>;
+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> | Signal<A | ElementRef<A> | undefined>, bodyB: B | ElementRef<B> | Signal<B | ElementRef<B> | undefined>, options?: NgtcConstraintOptions<"ConeTwist"> | undefined) => Signal<NgtcConstraintApi | null>;
+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> | Signal<A | ElementRef<A> | undefined>, bodyB: B | ElementRef<B> | Signal<B | ElementRef<B> | undefined>, options?: NgtcConstraintOptions<"Distance"> | undefined) => Signal<NgtcConstraintApi | null>;
+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> | Signal<A | ElementRef<A> | undefined>, bodyB: B | ElementRef<B> | Signal<B | ElementRef<B> | undefined>, options?: NgtcConstraintOptions<"Lock"> | undefined) => Signal<NgtcConstraintApi | null>;
+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> | Signal<A | ElementRef<A> | undefined>, bodyB: B | ElementRef<B> | Signal<B | ElementRef<B> | undefined>, options?: NgtcConstraintOptions<"Hinge"> | undefined) => Signal<NgtcConstraintApi | null>;

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,108 @@
+import { afterNextRender, computed, isSignal, signal, untracked, } from '@angular/core';
+import { resolveRef } 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, ref, options) => injectBody(type, getPropFn, ref, options);
+}
+function injectBody(type, getPropFn, ref, { transformArgs, 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 = isSignal(ref) ? ref : signal(ref);
+        const body = computed(() => resolveRef(bodyRef()));
+        const api = computed(() => {
+            const _body = body();
+            if (!_body)
+                return null;
+            const { worker, ...rest } = physicsApi;
+            if (!worker())
+                return null;
+            return makeBodyApi(_body, worker(), physicsApi);
+        });
+        afterNextRender(() => {
+            autoEffect(() => {
+                const currentWorker = physicsApi.worker();
+                if (!currentWorker)
+                    return;
+                const object = body();
+                if (!isSignal(ref) && !object) {
+                    untracked(() => {
+                        bodyRef.set(resolveRef(ref));
+                    });
+                    return;
+                }
+                if (!object)
+                    return;
+                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 api;
+    });
+}
+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 {\n\tElementRef,\n\tInjector,\n\tSignal,\n\tWritableSignal,\n\tafterNextRender,\n\tcomputed,\n\tisSignal,\n\tsignal,\n\tuntracked,\n} from '@angular/core';\nimport { BodyShapeType } from '@pmndrs/cannon-worker-api';\nimport { resolveRef } 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, NgtcBodyPublicApi, NgtcGetByIndex } from './types';\nimport { defaultTransformArgs, makeBodyApi, prepare, setupCollision } from './utils';\n\nexport interface NgtcBodyOptions<TShape extends BodyShapeType> {\n\ttransformArgs?: NgtcArgFn<NgtcBodyPropsMap[TShape]>;\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\tref: ElementRef<TObject> | TObject | Signal<ElementRef<TObject> | TObject | undefined>,\n\t\toptions?: NgtcBodyOptions<TShape>,\n\t) => injectBody<TShape, TObject>(type, getPropFn, ref, options);\n}\n\nfunction injectBody<TShape extends BodyShapeType, TObject extends Object3D>(\n\ttype: TShape,\n\tgetPropFn: NgtcGetByIndex<NgtcBodyPropsMap[TShape]>,\n\tref: ElementRef<TObject> | TObject | Signal<ElementRef<TObject> | TObject | undefined>,\n\t{ transformArgs, injector }: NgtcBodyOptions<TShape> = {},\n): Signal<NgtcBodyPublicApi | null> {\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 = isSignal(ref) ? ref : signal(ref);\n\t\tconst body = computed(() => resolveRef(bodyRef()));\n\n\t\tconst api = computed(() => {\n\t\t\tconst _body = body();\n\t\t\tif (!_body) return null;\n\t\t\tconst { worker, ...rest } = physicsApi;\n\t\t\tif (!worker()) return null;\n\t\t\treturn makeBodyApi(_body, worker(), physicsApi);\n\t\t});\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\tconst object = body();\n\n\t\t\t\tif (!isSignal(ref) && !object) {\n\t\t\t\t\tuntracked(() => {\n\t\t\t\t\t\t(bodyRef as WritableSignal<TObject | undefined>).set(resolveRef(ref));\n\t\t\t\t\t});\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (!object) return;\n\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 unknown as InstancedMesh).setMatrixAt(index, temp.matrix);\n\t\t\t\t\t\t\t\t(object as unknown 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 api;\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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