angular-three-rapier 2.2.0

package/lib/joints.d.ts

@@ -0,0 +1,64 @@
+import { ElementRef, Injector } from '@angular/core';
+import { FixedImpulseJoint, PrismaticImpulseJoint, RevoluteImpulseJoint, RigidBody, RopeImpulseJoint, SphericalImpulseJoint, SpringImpulseJoint } from '@dimforge/rapier3d-compat';
+import { NgtrFixedJointParams, NgtrPrismaticJointParams, NgtrRevoluteJointParams, NgtrRopeJointParams, NgtrSphericalJointParams, NgtrSpringJointParams } from './types';
+/**
+ * A fixed joint ensures that two rigid-bodies don't move relative to each other.
+ * Fixed joints are characterized by one local frame (represented by an isometry) on each rigid-body.
+ * The fixed-joint makes these frames coincide in world-space.
+ *
+ * @category Hooks - Joints
+ */
+export declare const injectFixedJoint: (bodyA: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), bodyB: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), { injector, data }: {
+    injector?: Injector;
+    data: NgtrFixedJointParams;
+}) => import("@angular/core").Signal<FixedImpulseJoint | null>;
+/**
+ * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative
+ * translational motion at this points). This is typically used to simulate ragdolls arms, pendulums, etc.
+ * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the
+ * points that need to coincide on the local-space of each rigid-body.
+ *
+ * @category Hooks - Joints
+ */
+export declare const injectSphericalJoint: (bodyA: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), bodyB: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), { injector, data }: {
+    injector?: Injector;
+    data: NgtrSphericalJointParams;
+}) => import("@angular/core").Signal<SphericalImpulseJoint | null>;
+/**
+ * The revolute joint prevents any relative movement between two rigid-bodies, except for relative
+ * rotations along one axis. This is typically used to simulate wheels, fans, etc.
+ * They are characterized by one local anchor as well as one local axis on each rigid-body.
+ *
+ * @category Hooks - Joints
+ */
+export declare const injectRevoluteJoint: (bodyA: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), bodyB: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), { injector, data }: {
+    injector?: Injector;
+    data: NgtrRevoluteJointParams;
+}) => import("@angular/core").Signal<RevoluteImpulseJoint | null>;
+/**
+ * The prismatic joint prevents any relative movement between two rigid-bodies, except for relative translations along one axis.
+ * It is characterized by one local anchor as well as one local axis on each rigid-body. In 3D, an optional
+ * local tangent axis can be specified for each rigid-body.
+ *
+ * @category Hooks - Joints
+ */
+export declare const injectPrismaticJoint: (bodyA: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), bodyB: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), { injector, data }: {
+    injector?: Injector;
+    data: NgtrPrismaticJointParams;
+}) => import("@angular/core").Signal<PrismaticImpulseJoint | null>;
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+export declare const injectRopeJoint: (bodyA: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), bodyB: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), { injector, data }: {
+    injector?: Injector;
+    data: NgtrRopeJointParams;
+}) => import("@angular/core").Signal<RopeImpulseJoint | null>;
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+export declare const injectSpringJoint: (bodyA: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), bodyB: RigidBody | ElementRef<RigidBody> | (() => ElementRef<RigidBody> | RigidBody | undefined | null), { injector, data }: {
+    injector?: Injector;
+    data: NgtrSpringJointParams;
+}) => import("@angular/core").Signal<SpringImpulseJoint | null>;

package/lib/mesh-collider.d.ts

@@ -0,0 +1,23 @@
+import { ElementRef } from '@angular/core';
+import { Object3D } from 'three';
+import { NgtrPhysics } from './physics';
+import { NgtrRigidBody } from './rigid-body';
+import { NgtrRigidBodyAutoCollider } from './types';
+import * as i0 from "@angular/core";
+export declare class NgtrMeshCollider {
+    colliders: import("@angular/core").InputSignal<NgtrRigidBodyAutoCollider>;
+    objectRef: ElementRef<Object3D<import("three").Object3DEventMap>>;
+    rigidBody: NgtrRigidBody;
+    physics: NgtrPhysics;
+    protected childColliderOptions: import("@angular/core").Signal<{
+        colliderOptions: import("./types").NgtrColliderOptions;
+        args: unknown[];
+        shape: import("./types").NgtrColliderShape;
+        rotation: import("angular-three").NgtEuler;
+        position: import("angular-three").NgtVector3;
+        scale: import("angular-three").NgtVector3;
+    }[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtrMeshCollider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtrMeshCollider, "ngt-object3D[ngtrMeshCollider]", never, { "colliders": { "alias": "ngtrMeshCollider"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/physics.d.ts

@@ -0,0 +1,50 @@
+import RAPIER from '@dimforge/rapier3d-compat';
+import { Vector3 } from 'three';
+import { NgtrColliderStateMap, NgtrEventMap, NgtrPhysicsOptions, NgtrRigidBodyStateMap, NgtrWorldStepCallbackSet } from './types';
+import * as i0 from "@angular/core";
+export declare class NgtrPhysics {
+    options: import("@angular/core").InputSignalWithTransform<NgtrPhysicsOptions, "" | Partial<NgtrPhysicsOptions>>;
+    protected updatePriority: import("@angular/core").Signal<number | undefined>;
+    protected updateLoop: import("@angular/core").Signal<"follow" | "independent">;
+    private numSolverIterations;
+    private numAdditionalFrictionIterations;
+    private numInternalPgsIterations;
+    private allowedLinearError;
+    private minIslandSize;
+    private maxCcdSubsteps;
+    private predictionDistance;
+    private erp;
+    private lengthUnit;
+    private timeStep;
+    private interpolate;
+    paused: import("@angular/core").Signal<boolean>;
+    debug: import("@angular/core").Signal<boolean>;
+    colliders: import("@angular/core").Signal<import("./types").NgtrRigidBodyAutoCollider | undefined>;
+    gravity: import("@angular/core").Signal<Vector3>;
+    private store;
+    private destroyRef;
+    private rapierConstruct;
+    rapier: import("@angular/core").Signal<typeof RAPIER | null>;
+    ready: import("@angular/core").Signal<boolean>;
+    worldSingleton: import("@angular/core").Signal<{
+        proxy: RAPIER.World;
+        reset: () => void;
+        set: (newInstance: RAPIER.World) => void;
+    } | null>;
+    rigidBodyStates: NgtrRigidBodyStateMap;
+    colliderStates: NgtrColliderStateMap;
+    rigidBodyEvents: NgtrEventMap;
+    colliderEvents: NgtrEventMap;
+    beforeStepCallbacks: NgtrWorldStepCallbackSet;
+    afterStepCallbacks: NgtrWorldStepCallbackSet;
+    private eventQueue;
+    private steppingState;
+    constructor();
+    step(delta: number): void;
+    private updateWorldEffect;
+    private internalStep;
+    private getSourceFromColliderHandle;
+    private getCollisionPayloadFromSource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtrPhysics, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtrPhysics, "ngtr-physics", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/rigid-body.d.ts

@@ -0,0 +1,104 @@
+import { ElementRef } from '@angular/core';
+import { RigidBody } from '@dimforge/rapier3d-compat';
+import { NgtEuler, NgtQuaternion, NgtVector3 } from 'angular-three';
+import { Object3D, Vector3 } from 'three';
+import { NgtrColliderOptions, NgtrColliderShape, NgtrCollisionEnterPayload, NgtrCollisionExitPayload, NgtrContactForcePayload, NgtrIntersectionEnterPayload, NgtrIntersectionExitPayload, NgtrRigidBodyOptions, NgtrRigidBodyType } from './types';
+import * as i0 from "@angular/core";
+export declare class NgtrAnyCollider {
+    position: import("@angular/core").InputSignal<NgtVector3 | undefined>;
+    rotation: import("@angular/core").InputSignal<NgtEuler | undefined>;
+    scale: import("@angular/core").InputSignal<NgtVector3 | undefined>;
+    quaternion: import("@angular/core").InputSignal<NgtQuaternion | undefined>;
+    userData: import("@angular/core").InputSignal<Record<string, any> | undefined>;
+    name: import("@angular/core").InputSignal<string | undefined>;
+    options: import("@angular/core").InputSignalWithTransform<NgtrColliderOptions, "" | Partial<NgtrRigidBodyOptions>>;
+    shape: import("@angular/core").ModelSignal<NgtrColliderShape | undefined>;
+    args: import("@angular/core").ModelSignal<unknown[]>;
+    collisionEnter: import("@angular/core").OutputEmitterRef<NgtrCollisionEnterPayload>;
+    collisionExit: import("@angular/core").OutputEmitterRef<NgtrCollisionExitPayload>;
+    intersectionEnter: import("@angular/core").OutputEmitterRef<NgtrIntersectionEnterPayload>;
+    intersectionExit: import("@angular/core").OutputEmitterRef<NgtrIntersectionExitPayload>;
+    contactForce: import("@angular/core").OutputEmitterRef<NgtrContactForcePayload>;
+    private sensor;
+    private collisionGroups;
+    private solverGroups;
+    private friction;
+    private frictionCombineRule;
+    private restitution;
+    private restitutionCombineRule;
+    private activeCollisionTypes;
+    private contactSkin;
+    private mass;
+    private massProperties;
+    private density;
+    private rigidBody;
+    private physics;
+    objectRef: ElementRef<Object3D<import("three").Object3DEventMap>>;
+    private scaledArgs;
+    private collider;
+    constructor();
+    get worldScale(): Vector3;
+    setShape(shape: NgtrColliderShape): void;
+    setArgs(args: unknown[]): void;
+    private createColliderStateEffect;
+    private createColliderEventsEffect;
+    private updateColliderEffect;
+    private updateMassPropertiesEffect;
+    private createColliderState;
+    private scaleVertices;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtrAnyCollider, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtrAnyCollider, "ngt-object3D[ngtrCollider]", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "rotation": { "alias": "rotation"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "quaternion": { "alias": "quaternion"; "required": false; "isSignal": true; }; "userData": { "alias": "userData"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "shape": { "alias": "ngtrCollider"; "required": false; "isSignal": true; }; "args": { "alias": "args"; "required": false; "isSignal": true; }; }, { "shape": "ngtrColliderChange"; "args": "argsChange"; "collisionEnter": "collisionEnter"; "collisionExit": "collisionExit"; "intersectionEnter": "intersectionEnter"; "intersectionExit": "intersectionExit"; "contactForce": "contactForce"; }, never, never, true, never>;
+}
+export declare const rigidBodyDefaultOptions: NgtrRigidBodyOptions;
+export declare class NgtrRigidBody {
+    type: import("@angular/core").InputSignalWithTransform<NgtrRigidBodyType, "" | NgtrRigidBodyType | undefined>;
+    position: import("@angular/core").InputSignal<NgtVector3 | undefined>;
+    rotation: import("@angular/core").InputSignal<NgtEuler | undefined>;
+    scale: import("@angular/core").InputSignal<NgtVector3 | undefined>;
+    quaternion: import("@angular/core").InputSignal<NgtQuaternion | undefined>;
+    userData: import("@angular/core").InputSignal<Record<string, any> | undefined>;
+    options: import("@angular/core").InputSignalWithTransform<NgtrRigidBodyOptions, "" | Partial<NgtrRigidBodyOptions>>;
+    wake: import("@angular/core").OutputEmitterRef<void>;
+    sleep: import("@angular/core").OutputEmitterRef<void>;
+    collisionEnter: import("@angular/core").OutputEmitterRef<NgtrCollisionEnterPayload>;
+    collisionExit: import("@angular/core").OutputEmitterRef<NgtrCollisionExitPayload>;
+    intersectionEnter: import("@angular/core").OutputEmitterRef<NgtrIntersectionEnterPayload>;
+    intersectionExit: import("@angular/core").OutputEmitterRef<NgtrIntersectionExitPayload>;
+    contactForce: import("@angular/core").OutputEmitterRef<NgtrContactForcePayload>;
+    private canSleep;
+    private colliders;
+    private transformState;
+    private gravityScale;
+    private dominanceGroup;
+    private ccd;
+    private softCcdPrediction;
+    private additionalSolverIterations;
+    private linearDamping;
+    private angularDamping;
+    private lockRotations;
+    private lockTranslations;
+    private enabledRotations;
+    private enabledTranslations;
+    private angularVelocity;
+    private linearVelocity;
+    objectRef: ElementRef<Object3D<import("three").Object3DEventMap>>;
+    private physics;
+    private bodyType;
+    private bodyDesc;
+    rigidBody: import("@angular/core").Signal<RigidBody | null>;
+    protected childColliderOptions: import("@angular/core").Signal<{
+        colliderOptions: NgtrColliderOptions;
+        args: unknown[];
+        shape: NgtrColliderShape;
+        rotation: NgtEuler;
+        position: NgtVector3;
+        scale: NgtVector3;
+    }[]>;
+    constructor();
+    private createRigidBodyStateEffect;
+    private createRigidBodyEventsEffect;
+    private updateRigidBodyEffect;
+    private createRigidBodyState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtrRigidBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtrRigidBody, "ngt-object3D[ngtrRigidBody]", ["rigidBody"], { "type": { "alias": "ngtrRigidBody"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "rotation": { "alias": "rotation"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "quaternion": { "alias": "quaternion"; "required": false; "isSignal": true; }; "userData": { "alias": "userData"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "wake": "wake"; "sleep": "sleep"; "collisionEnter": "collisionEnter"; "collisionExit": "collisionExit"; "intersectionEnter": "intersectionEnter"; "intersectionExit": "intersectionExit"; "contactForce": "contactForce"; }, never, ["*"], true, never>;
+}

package/lib/shared.d.ts

@@ -0,0 +1,9 @@
+import { Euler, Matrix4, Object3D, Quaternion, Vector3 } from 'three';
+export declare const _quaternion: Quaternion;
+export declare const _euler: Euler;
+export declare const _vector3: Vector3;
+export declare const _object3d: Object3D<import("three").Object3DEventMap>;
+export declare const _matrix4: Matrix4;
+export declare const _position: Vector3;
+export declare const _rotation: Quaternion;
+export declare const _scale: Vector3;