angular-three-cannon 2.0.0-beta.7 → 2.0.0

package/README.md

@@ -1,7 +1,74 @@
-# cannon
+# `angular-three-cannon`
 
-This library was generated with [Nx](https://nx.dev).
+This library is a wrapper around the [Cannon.js](https://schteppe.github.io/cannon.js/) physics engine for use with Angular Three.
 
-## Running unit tests
+## Installation
 
-Run `nx test cannon` to execute the unit tests.
+```bash
+npm install angular-three-cannon cannon-es @pmndrs/cannon-worker-api
+# yarn add angular-three-cannon cannon-es @pmndrs/cannon-worker-api
+# pnpm add angular-three-cannon cannon-es @pmndrs/cannon-worker-api
+```
+
+> Make sure to already have `angular-three` installed
+
+## Usage
+
+```typescript
+@Component({
+	template: `
+		<ngt-mesh #mesh>
+			<ngt-box-geometry />
+		</ngt-mesh>
+	`,
+})
+export class Box {
+	mesh = viewChild.required<ElementRef<Mesh>>('mesh');
+
+	constructor() {
+		// Make this mesh a Box body in Physics. Only works within ngtc-physics
+		injectBox(() => ({ mass: 10000, position: [0, 0, 0], args: [1, 1, 1] }), this.mesh);
+	}
+}
+
+@Component({
+	template: `
+		<ngtc-physics>
+			<app-box />
+		</ngtc-physics>
+	`,
+	imports: [NgtcPhysics, Box],
+})
+export class SceneGraph {}
+```
+
+### Inputs
+
+- `allowSleep?: boolean`
+- `axisIndex?: 0 | 1 | 2`
+- `broadphase?: 'Naive' | 'SAP'`
+- `defaultContactMaterial?: ContactMaterialOptions`
+- `frictionGravity?: Vector3 | null`
+- `gravity?: Vector3`
+- `isPaused?: boolean`
+- `iterations?: number`
+- `maxSubSteps?: number`
+- `quatNormalizeFast?: boolean`
+- `quatNormalizeSkip?: number`
+- `shouldInvalidate?: boolean`
+- `size?: number`
+- `solver?: 'GS' | 'Split'`
+- `stepSize?: number`
+- `tolerance?: number`
+
+## Debug
+
+Read the [debug documentation](./debug/README.md) for more information on how to enable debug mode and view debug information.
+
+## Bodies
+
+Read the [body documentation](./body/README.md) for more information on how to create physics bodies and apply forces.
+
+## Constraints
+
+Read the [constraint documentation](./constraint/README.md) for more information on how to create constraints between physics bodies.

package/body/README.md

@@ -0,0 +1,49 @@
+# `angular-three-cannon/body`
+
+This module provides a set of custom injector functions to create physics bodies that link `ngt-*` objects in THREE.js with bodies in the Cannon.js physics world. These functions simplify the process of adding physics behavior to your 3D objects.
+
+### Available `inject*` Functions
+
+| Function                 | Description                                      | `getProps` Arguments                                                     | `object` Type |
+| :----------------------- | :----------------------------------------------- | :----------------------------------------------------------------------- | :------------ |
+| `injectBox`              | Creates a box-shaped physics body.               | `mass`, `position`, `args: [width, height, depth]`                       | `ElementRef`  |
+| `injectConvexPolyhedron` | Creates a convex polyhedron-shaped physics body. | `mass`, `position`, `vertices`, `faces`                                  | `ElementRef`  |
+| `injectCylinder`         | Creates a cylinder-shaped physics body.          | `mass`, `position`, `radiusTop`, `radiusBottom`, `height`, `numSegments` | `ElementRef`  |
+| `injectHeightfield`      | Creates a heightfield-shaped physics body.       | `mass`, `position`, `data`, `elementSize`                                | `ElementRef`  |
+| `injectParticle`         | Creates a particle physics body.                 | `mass`, `position`                                                       | `ElementRef`  |
+| `injectPlane`            | Creates a plane-shaped physics body.             | `mass`, `position`                                                       | `ElementRef`  |
+| `injectSphere`           | Creates a sphere-shaped physics body.            | `mass`, `position`, `radius`                                             | `ElementRef`  |
+| `injectTrimesh`          | Creates a trimesh-shaped physics body.           | `mass`, `position`, `vertices`, `indices`                                | `ElementRef`  |
+| `injectCompound`         | Creates a compound physics body.                 | `mass`, `position`, `shapes`                                             | `ElementRef`  |
+
+**All functions also accept an optional `options` argument for additional customization.**
+
+### Simple Usage of `injectBox()`
+
+```typescript
+@Component({
+	template: `
+		<ngt-mesh #mesh>
+			<ngt-box-geometry />
+		</ngt-mesh>
+	`,
+})
+export class Box {
+	mesh = viewChild.required<ElementRef<Mesh>>('mesh');
+
+	constructor() {
+		// Make this mesh a Box body in Physics. Only works within ngtc-physics
+		injectBox(() => ({ mass: 10000, position: [0, 0, 0], args: [1, 1, 1] }), this.mesh);
+	}
+}
+
+@Component({
+	template: `
+		<ngtc-physics>
+			<app-box />
+		</ngtc-physics>
+	`,
+	imports: [NgtcPhysics, Box],
+})
+export class SceneGraph {}
+```

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>(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>(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>(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>(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>(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>(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>(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>(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>(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 }: Pick<NgtcPhysicsApi, 'subscriptions' | 'scaleOverrides'>): {
+    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: (_: PlaneProps["args"]) => never[];
+    Box: (args?: BoxProps["args"]) => Triplet;
+    Trimesh: (args: TrimeshArgs) => TrimeshArgs;
+    Cylinder: (_?: CylinderArgs) => never[];
+    Heightfield: (args: HeightfieldArgs) => HeightfieldArgs;
+    ConvexPolyhedron: ([vertices, faces, normals, axes, boundingSphereRadius]?: ConvexPolyhedronArgs) => (number | number[][] | undefined)[];
+    Particle: (_: ParticleProps["args"]) => never[];
+    Sphere: (args?: SphereArgs) => number[];
+    Compound: (args: CompoundBodyProps["args"]) => unknown[] | undefined;
+};

package/constraint/README.md

@@ -0,0 +1,47 @@
+# `angular-three-cannon/constraint`
+
+This module provides functions to create physics constraints that link physics bodies in the Cannon.js physics world. These functions simplify the process of adding constraints between your 3D objects.
+
+### Available `inject*` Functions
+
+| Function             | Description                                                                                                                                                  | Arguments                        |
+| :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------- |
+| `injectPointToPoint` | Creates a point-to-point constraint between two bodies. The constraint tries to keep the distance between the anchor points constant.                        | `objectA`, `objectB`, `getProps` |
+| `injectConeTwist`    | Creates a cone-twist constraint between two bodies. The constraint attempts to keep the bodies aligned along a common axis, allowing swing and twist motion. | `objectA`, `objectB`, `getProps` |
+| `injectDistance`     | Creates a distance constraint between two bodies. The constraint tries to keep the distance between the bodies' center of masses constant.                   | `objectA`, `objectB`, `getProps` |
+| `injectLock`         | Creates a lock constraint between two bodies. The constraint completely locks the motion of one body relative to another.                                    | `objectA`, `objectB`, `getProps` |
+| `injectHinge`        | Creates a hinge constraint between two bodies. The constraint allows for rotation around a shared axis, like a door hinge.                                   | `objectA`, `objectB`, `getProps` |
+
+**All functions' `getProps` argument is a function that returns the properties of the constraint.**
+
+### Simple Usage of `injectHinge()`
+
+```typescript
+import { Component, viewChild, ElementRef } from '@angular/core';
+import { injectHinge } from 'angular-three-cannon/constraint';
+
+@Component({
+	template: `
+		<ngt-mesh #mesh1>
+			<ngt-box-geometry />
+		</ngt-mesh>
+		<ngt-mesh #mesh2>
+			<ngt-box-geometry />
+		</ngt-mesh>
+	`,
+})
+export class HingedBoxes {
+	mesh1 = viewChild.required<ElementRef<Mesh>>('mesh1');
+	mesh2 = viewChild.required<ElementRef<Mesh>>('mesh2');
+
+	constructor() {
+		// Create a hinge constraint between mesh1 and mesh2. Only works within <ngtc-physics>
+		injectHinge(this.mesh1, this.mesh2, () => ({
+			pivotA: [0, 0.5, 0], // hinge location on the first body
+			pivotB: [0, -0.5, 0], // hinge location on the second body
+			axisA: [0, 1, 0], // axis of rotation on the first body
+			axisB: [0, 1, 0], // axis of rotation on the second body
+		}));
+	}
+}
+```

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 = Object3D<import("three").Object3DEventMap>, B extends Object3D = 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 = Object3D<import("three").Object3DEventMap>, B extends Object3D = 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 = Object3D<import("three").Object3DEventMap>, B extends Object3D = 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 = Object3D<import("three").Object3DEventMap>, B extends Object3D = 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 = Object3D<import("three").Object3DEventMap>, B extends Object3D = 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/README.md

@@ -1,3 +1,49 @@
-# angular-three-cannon/debug
+# `angular-three-cannon/debug`
 
-Secondary entry point of `angular-three-cannon`. It can be used by importing from `angular-three-cannon/debug`.
+This module provides the `NgtcDebug` directive, which allows you to visualize the physics bodies within your Angular Three Cannon simulations.
+
+| Package              | Description                                    |
+| -------------------- | ---------------------------------------------- |
+| `cannon-es-debugger` | A debug renderer for Cannon.js physics engine. |
+
+This entry point requires the `cannon-es-debugger` package to be installed.
+
+```bash
+npm install cannon-es-debugger
+# yarn add cannon-es-debugger
+# pnpm add cannon-es-debugger
+```
+
+## NgtcDebugApi
+
+The `NgtcDebugApi` interface provides methods to interact with the debug renderer:
+
+- `add(uuid: string, props: BodyProps, type: BodyShapeType)`: Adds a physics body to the debug renderer.
+- `remove(uuid: string)`: Removes a physics body from the debug renderer.
+
+### `injectNgtcDebugApi`
+
+The `injectNgtcDebugApi` function is used to inject the `NgtcDebugApi` into your components, enabling you to control the debug visualization.
+
+## NgtcDebug
+
+The `NgtcDebug` directive is applied to the `ngtc-physics` component to enable physics debugging. It has the following inputs:
+
+- `debug`: An object containing the following properties:
+
+  - `enabled`: (boolean) Whether the debug visualization is enabled (default: true).
+  - `color`: (string) The color of the debug visualization (default: 'black').
+  - `impl`: (typeof CannonDebugger) The implementation of the CannonDebugger to use (default: CannonDebugger).
+  - `scale`: (number) The scale of the debug visualization (default: 1).
+
+## Usage
+
+```html
+<ngtc-physics debug></ngtc-physics>
+```
+
+You can customize the debug visualization by providing input values within the `debug` object:
+
+```html
+<ngtc-physics [debug]="{enabled: true, color: 'red', scale: 0.5}"></ngtc-physics>
+```

package/debug/index.d.ts

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

package/debug/lib/debug.d.ts

@@ -0,0 +1,25 @@
+import { BodyProps, BodyShapeType } from '@pmndrs/cannon-worker-api';
+import CannonDebugger from 'cannon-es-debugger';
+import * as i0 from "@angular/core";
+export interface NgtcDebugInputs {
+    enabled: boolean;
+    color: string;
+    impl: typeof CannonDebugger;
+    scale: number;
+}
+export declare class NgtcDebug {
+    private store;
+    private physics;
+    debug: import("@angular/core").InputSignalWithTransform<NgtcDebugInputs, "" | Partial<NgtcDebugInputs>>;
+    private defaultScene;
+    private scene;
+    private bodies;
+    private bodyMap;
+    private cannonDebugger;
+    api: {};
+    constructor();
+    add(uuid: string, props: BodyProps, type: BodyShapeType): void;
+    remove(uuid: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtcDebug, 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 { computed, effect, inject, isSignal, signal, untracked, } from '@angular/core';
+import { resolveRef } from 'angular-three';
+import { NgtcPhysics } from 'angular-three-cannon';
+import { NgtcDebug } from 'angular-three-cannon/debug';
+import { assertInjector } from 'ngxtension/assert-injector';
+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 physics = inject(NgtcPhysics, { optional: true });
+        if (!physics) {
+            throw new Error(`[NGT Cannon] injectBody was called outside of <ngtc-physics>`);
+        }
+        const debug = inject(NgtcDebug, { optional: true });
+        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 } = physics.api;
+            if (!worker())
+                return null;
+            return makeBodyApi(_body, worker(), rest);
+        });
+        effect((onCleanup) => {
+            const currentWorker = physics.api.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);
+                        }
+                        physics.api.refs[id] = object;
+                        debug?.add(id, props, type);
+                        setupCollision(physics.api.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),
+                        onCollideBegin: Boolean(onCollideBegin),
+                        onCollideEnd: Boolean(onCollideEnd),
+                        ...serializableProps,
+                    };
+                }),
+                type,
+                uuid,
+            });
+            onCleanup(() => {
+                uuid.forEach((id) => {
+                    delete physics.api.refs[id];
+                    debug?.remove(id);
+                    delete physics.api.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\tcomputed,\n\teffect,\n\tinject,\n\tisSignal,\n\tsignal,\n\tuntracked,\n} from '@angular/core';\nimport { BodyShapeType } from '@pmndrs/cannon-worker-api';\nimport { resolveRef } from 'angular-three';\nimport { NgtcPhysics } from 'angular-three-cannon';\nimport { NgtcDebug } from 'angular-three-cannon/debug';\nimport { assertInjector } from 'ngxtension/assert-injector';\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 physics = inject(NgtcPhysics, { optional: true });\n\n\t\tif (!physics) {\n\t\t\tthrow new Error(`[NGT Cannon] injectBody was called outside of <ngtc-physics>`);\n\t\t}\n\n\t\tconst debug = inject(NgtcDebug, { optional: true });\n\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 } = physics.api;\n\t\t\tif (!worker()) return null;\n\t\t\treturn makeBodyApi(_body, worker(), rest);\n\t\t});\n\n\t\teffect((onCleanup) => {\n\t\t\tconst currentWorker = physics.api.worker();\n\t\t\tif (!currentWorker) return;\n\n\t\t\tconst object = body();\n\n\t\t\tif (!isSignal(ref) && !object) {\n\t\t\t\tuntracked(() => {\n\t\t\t\t\t(bodyRef as WritableSignal<TObject | undefined>).set(resolveRef(ref));\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (!object) return;\n\n\t\t\tconst [uuid, props] = (() => {\n\t\t\t\tlet uuids: string[] = [];\n\t\t\t\tlet temp: Object3D;\n\t\t\t\tif (object instanceof InstancedMesh) {\n\t\t\t\t\tobject.instanceMatrix.setUsage(DynamicDrawUsage);\n\t\t\t\t\tuuids = new Array(object.count).fill(0).map((_, i) => `${object.uuid}/${i}`);\n\t\t\t\t\ttemp = new Object3D();\n\t\t\t\t} else {\n\t\t\t\t\tuuids = [object.uuid];\n\t\t\t\t}\n\t\t\t\treturn [\n\t\t\t\t\tuuids,\n\t\t\t\t\tuuids.map((id, index) => {\n\t\t\t\t\t\tconst props = getPropFn(index);\n\t\t\t\t\t\tif (temp) {\n\t\t\t\t\t\t\tprepare(temp, props);\n\t\t\t\t\t\t\t(object as unknown as InstancedMesh).setMatrixAt(index, temp.matrix);\n\t\t\t\t\t\t\t(object as unknown as InstancedMesh).instanceMatrix.needsUpdate = true;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tprepare(object, props);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tphysics.api.refs[id] = object;\n\t\t\t\t\t\tdebug?.add(id, props, type);\n\t\t\t\t\t\tsetupCollision(physics.api.events, props, id);\n\t\t\t\t\t\t// @ts-expect-error - if args is undefined, there's default\n\t\t\t\t\t\treturn { ...props, args: transform(props.args) };\n\t\t\t\t\t}),\n\t\t\t\t];\n\t\t\t})();\n\t\t\t// Register on mount, unregister on unmount\n\t\t\tcurrentWorker.addBodies({\n\t\t\t\tprops: props.map(({ onCollide, onCollideBegin, onCollideEnd, ...serializableProps }) => {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tonCollide: Boolean(onCollide),\n\t\t\t\t\t\tonCollideBegin: Boolean(onCollideBegin),\n\t\t\t\t\t\tonCollideEnd: Boolean(onCollideEnd),\n\t\t\t\t\t\t...serializableProps,\n\t\t\t\t\t};\n\t\t\t\t}),\n\t\t\t\ttype,\n\t\t\t\tuuid,\n\t\t\t});\n\n\t\t\tonCleanup(() => {\n\t\t\t\tuuid.forEach((id) => {\n\t\t\t\t\tdelete physics.api.refs[id];\n\t\t\t\t\tdebug?.remove(id);\n\t\t\t\t\tdelete physics.api.events[id];\n\t\t\t\t});\n\t\t\t\tcurrentWorker.removeBodies({ uuid });\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nhbm5vbi9ib2R5L3NyYy9saWIvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG5cdEF0b21pY05hbWUsXG5cdEF0b21pY1Byb3BzLFxuXHRCb2R5UHJvcHMsXG5cdEJveFByb3BzLFxuXHRDb21wb3VuZEJvZHlQcm9wcyxcblx0Q29udmV4UG9seWhlZHJvblByb3BzLFxuXHRDeWxpbmRlclByb3BzLFxuXHRIZWlnaHRmaWVsZFByb3BzLFxuXHRQYXJ0aWNsZVByb3BzLFxuXHRQbGFuZVByb3BzLFxuXHRRdWFkLFxuXHRTcGhlcmVQcm9wcyxcblx0VHJpbWVzaFByb3BzLFxuXHRUcmlwbGV0LFxuXHRWZWN0b3JOYW1lLFxufSBmcm9tICdAcG1uZHJzL2Nhbm5vbi13b3JrZXItYXBpJztcbmltcG9ydCB7IEV1bGVyLCBRdWF0ZXJuaW9uLCBWZWN0b3IzIH0gZnJvbSAndGhyZWUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIE5ndGNBdG9taWNBcGk8SyBleHRlbmRzIEF0b21pY05hbWU+IHtcblx0c2V0OiAodmFsdWU6IEF0b21pY1Byb3BzW0tdKSA9PiB2b2lkO1xuXHRzdWJzY3JpYmU6IChjYWxsYmFjazogKHZhbHVlOiBBdG9taWNQcm9wc1tLXSkgPT4gdm9pZCkgPT4gKCkgPT4gdm9pZDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBOZ3RjUXVhdGVybmlvbkFwaSB7XG5cdGNvcHk6ICh7IHcsIHgsIHksIHogfTogUXVhdGVybmlvbikgPT4gdm9pZDtcblx0c2V0OiAoeDogbnVtYmVyLCB5OiBudW1iZXIsIHo6IG51bWJlciwgdzogbnVtYmVyKSA9PiB2b2lkO1xuXHRzdWJzY3JpYmU6IChjYWxsYmFjazogKHZhbHVlOiBRdWFkKSA9PiB2b2lkKSA9PiAoKSA9PiB2b2lkO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE5ndGNWZWN0b3JBcGkge1xuXHRjb3B5OiAoeyB4LCB5LCB6IH06IFZlY3RvcjMgfCBFdWxlcikgPT4gdm9pZDtcblx0c2V0OiAoeDogbnVtYmVyLCB5OiBudW1iZXIsIHo6IG51bWJlcikgPT4gdm9pZDtcblx0c3Vic2NyaWJlOiAoY2FsbGJhY2s6ICh2YWx1ZTogVHJpcGxldCkgPT4gdm9pZCkgPT4gKCkgPT4gdm9pZDtcbn1cblxuZXhwb3J0IHR5cGUgTmd0Y1dvcmtlckFwaSA9IHtcblx0W0sgaW4gQXRvbWljTmFtZV06IE5ndGNBdG9taWNBcGk8Sz47XG59ICYge1xuXHRbSyBpbiBWZWN0b3JOYW1lXTogTmd0Y1ZlY3RvckFwaTtcbn0gJiB7XG5cdGFwcGx5Rm9yY2U6IChmb3JjZTogVHJpcGxldCwgd29ybGRQb2ludDogVHJpcGxldCkgPT4gdm9pZDtcblx0YXBwbHlJbXB1bHNlOiAoaW1wdWxzZTogVHJpcGxldCwgd29ybGRQb2ludDogVHJpcGxldCkgPT4gdm9pZDtcblx0YXBwbHlMb2NhbEZvcmNlOiAoZm9yY2U6IFRyaXBsZXQsIGxvY2FsUG9pbnQ6IFRyaXBsZXQpID0+IHZvaWQ7XG5cdGFwcGx5TG9jYWxJbXB1bHNlOiAoaW1wdWxzZTogVHJpcGxldCwgbG9jYWxQb2ludDogVHJpcGxldCkgPT4gdm9pZDtcblx0YXBwbHlUb3JxdWU6ICh0b3JxdWU6IFRyaXBsZXQpID0+IHZvaWQ7XG5cdHF1YXRlcm5pb246IE5ndGNRdWF0ZXJuaW9uQXBpO1xuXHRyb3RhdGlvbjogTmd0Y1ZlY3RvckFwaTtcblx0c2NhbGVPdmVycmlkZTogKHNjYWxlOiBUcmlwbGV0KSA9PiB2b2lkO1xuXHRzbGVlcDogKCkgPT4gdm9pZDtcblx0d2FrZVVwOiAoKSA9PiB2b2lkO1xuXHRyZW1vdmU6ICgpID0+IHZvaWQ7XG59O1xuXG5leHBvcnQgaW50ZXJmYWNlIE5ndGNCb2R5UHVibGljQXBpIGV4dGVuZHMgTmd0Y1dvcmtlckFwaSB7XG5cdGF0OiAoaW5kZXg6IG51bWJlcikgPT4gTmd0Y1dvcmtlckFwaTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBOZ3RjQm9keVByb3BzTWFwIHtcblx0UGxhbmU6IFBsYW5lUHJvcHM7XG5cdEJveDogQm94UHJvcHM7XG5cdFBhcnRpY2xlOiBQYXJ0aWNsZVByb3BzO1xuXHRDeWxpbmRlcjogQ3lsaW5kZXJQcm9wcztcblx0U3BoZXJlOiBTcGhlcmVQcm9wcztcblx0VHJpbWVzaDogVHJpbWVzaFByb3BzO1xuXHRIZWlnaHRmaWVsZDogSGVpZ2h0ZmllbGRQcm9wcztcblx0Q29udmV4UG9seWhlZHJvbjogQ29udmV4UG9seWhlZHJvblByb3BzO1xuXHRDb21wb3VuZDogQ29tcG91bmRCb2R5UHJvcHM7XG59XG5cbmV4cG9ydCB0eXBlIE5ndGNHZXRCeUluZGV4PFQgZXh0ZW5kcyBCb2R5UHJvcHM+ID0gKGluZGV4OiBudW1iZXIpID0+IFQ7XG5leHBvcnQgdHlwZSBOZ3RjQXJnRm48VCBleHRlbmRzIEJvZHlQcm9wcz4gPSAoYXJnczogTm9uTnVsbGFibGU8VFsnYXJncyddPikgPT4gdHlwZW9mIGFyZ3M7XG4iXX0=