angular-three-rapier 2.2.0

package/esm2022/lib/instanced-rigid-bodies.mjs

@@ -0,0 +1,185 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, ElementRef, inject, input, untracked, viewChild, viewChildren, } from '@angular/core';
+import { extend, getLocalState, pick } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { DynamicDrawUsage, Object3D } from 'three';
+import { NgtrPhysics } from './physics';
+import { NgtrAnyCollider, NgtrRigidBody, rigidBodyDefaultOptions } from './rigid-body';
+import { createColliderOptions } from './utils';
+import * as i0 from "@angular/core";
+const defaultOptions = rigidBodyDefaultOptions;
+export class NgtrInstancedRigidBodies {
+    position = input([0, 0, 0]);
+    rotation = input([0, 0, 0]);
+    scale = input([1, 1, 1]);
+    quaternion = input([0, 0, 0, 1]);
+    userData = input({});
+    instances = input([], {
+        alias: 'ngtrInstancedRigidBodies',
+        transform: (value) => {
+            if (value === '')
+                return [];
+            return value;
+        },
+    });
+    options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+    instanceWrapperRef = viewChild.required('instanceWrapper');
+    rigidBodyRefs = viewChildren(NgtrRigidBody);
+    physics = inject(NgtrPhysics);
+    objectRef = inject(ElementRef);
+    colliders = pick(this.options, 'colliders');
+    instancedMesh = computed(() => {
+        const instanceWrapper = this.instanceWrapperRef().nativeElement;
+        if (!instanceWrapper)
+            return null;
+        const localState = getLocalState(instanceWrapper);
+        if (!localState)
+            return null;
+        // track object's children
+        localState.objects();
+        const firstChild = instanceWrapper.children[0];
+        if (!firstChild || !firstChild.isInstancedMesh)
+            return null;
+        return firstChild;
+    });
+    instancesOptions = computed(() => {
+        const [instances, options, instancedMesh] = [this.instances(), untracked(this.options), this.instancedMesh()];
+        if (!instancedMesh)
+            return [];
+        return instances.map((instance, index) => ({
+            ...instance,
+            options: {
+                ...options,
+                ...(instance.options || {}),
+                transformState: (state) => {
+                    return {
+                        ...state,
+                        getMatrix: (matrix) => {
+                            instancedMesh.getMatrixAt(index, matrix);
+                            return matrix;
+                        },
+                        setMatrix: (matrix) => {
+                            instancedMesh.setMatrixAt(index, matrix);
+                            instancedMesh.instanceMatrix.needsUpdate = true;
+                        },
+                        meshType: 'instancedMesh',
+                    };
+                },
+            },
+            key: `${instance.key}-${index}` + `${instancedMesh?.uuid || ''}`,
+        }));
+    });
+    childColliderOptions = computed(() => {
+        const colliders = this.colliders();
+        // if self colliders is false explicitly, disable auto colliders for this object entirely.
+        if (colliders === false)
+            return [];
+        const physicsColliders = this.physics.colliders();
+        // if physics colliders is false explicitly, disable auto colliders for this object entirely.
+        if (physicsColliders === false)
+            return [];
+        const options = this.options();
+        // if colliders on object is not set, use physics colliders
+        if (!options.colliders)
+            options.colliders = physicsColliders;
+        const objectLocalState = getLocalState(this.objectRef.nativeElement);
+        // track object's children
+        objectLocalState?.nonObjects();
+        return createColliderOptions(this.objectRef.nativeElement, options);
+    });
+    constructor() {
+        extend({ Object3D });
+        effect(() => {
+            this.setInstancedMeshMatrixEffect();
+        });
+    }
+    setInstancedMeshMatrixEffect() {
+        const instancedMesh = this.instancedMesh();
+        if (!instancedMesh)
+            return;
+        instancedMesh.instanceMatrix.setUsage(DynamicDrawUsage);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrInstancedRigidBodies, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtrInstancedRigidBodies, isStandalone: true, selector: "ngt-object3D[ngtrInstancedRigidBodies]", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, rotation: { classPropertyName: "rotation", publicName: "rotation", isSignal: true, isRequired: false, transformFunction: null }, scale: { classPropertyName: "scale", publicName: "scale", isSignal: true, isRequired: false, transformFunction: null }, quaternion: { classPropertyName: "quaternion", publicName: "quaternion", isSignal: true, isRequired: false, transformFunction: null }, userData: { classPropertyName: "userData", publicName: "userData", isSignal: true, isRequired: false, transformFunction: null }, instances: { classPropertyName: "instances", publicName: "ngtrInstancedRigidBodies", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "position": "position()", "rotation": "rotation()", "scale": "scale()", "quaternion": "quaternion()", "userData": "userData()" } }, viewQueries: [{ propertyName: "instanceWrapperRef", first: true, predicate: ["instanceWrapper"], descendants: true, isSignal: true }, { propertyName: "rigidBodyRefs", predicate: NgtrRigidBody, descendants: true, isSignal: true }], exportAs: ["instancedRigidBodies"], ngImport: i0, template: `
+		<ngt-object3D #instanceWrapper>
+			<ng-content />
+		</ngt-object3D>
+
+		@for (instance of instancesOptions(); track instance.key) {
+			<ngt-object3D
+				[ngtrRigidBody]="instance.type"
+				[options]="instance.options"
+				[position]="instance.position"
+				[rotation]="instance.rotation"
+				[scale]="instance.scale"
+				[quaternion]="instance.quaternion"
+				[userData]="instance.userData"
+				[name]="instance.key + '-instanced-rigid-body-' + $index"
+			>
+				<ng-content select="[data-colliders]" />
+
+				@for (childColliderOption of childColliderOptions(); track $index) {
+					<ngt-object3D
+						[ngtrCollider]="childColliderOption.shape"
+						[args]="childColliderOption.args"
+						[position]="childColliderOption.position"
+						[rotation]="childColliderOption.rotation"
+						[scale]="childColliderOption.scale"
+						[name]="objectRef.nativeElement.name + '-instanced-collider-' + $index"
+						[options]="childColliderOption.colliderOptions"
+					/>
+				}
+			</ngt-object3D>
+		}
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtrRigidBody, selector: "ngt-object3D[ngtrRigidBody]", inputs: ["ngtrRigidBody", "position", "rotation", "scale", "quaternion", "userData", "options"], outputs: ["wake", "sleep", "collisionEnter", "collisionExit", "intersectionEnter", "intersectionExit", "contactForce"], exportAs: ["rigidBody"] }, { kind: "directive", type: NgtrAnyCollider, selector: "ngt-object3D[ngtrCollider]", inputs: ["position", "rotation", "scale", "quaternion", "userData", "name", "options", "ngtrCollider", "args"], outputs: ["ngtrColliderChange", "argsChange", "collisionEnter", "collisionExit", "intersectionEnter", "intersectionExit", "contactForce"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrInstancedRigidBodies, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-object3D[ngtrInstancedRigidBodies]',
+                    exportAs: 'instancedRigidBodies',
+                    standalone: true,
+                    template: `
+		<ngt-object3D #instanceWrapper>
+			<ng-content />
+		</ngt-object3D>
+
+		@for (instance of instancesOptions(); track instance.key) {
+			<ngt-object3D
+				[ngtrRigidBody]="instance.type"
+				[options]="instance.options"
+				[position]="instance.position"
+				[rotation]="instance.rotation"
+				[scale]="instance.scale"
+				[quaternion]="instance.quaternion"
+				[userData]="instance.userData"
+				[name]="instance.key + '-instanced-rigid-body-' + $index"
+			>
+				<ng-content select="[data-colliders]" />
+
+				@for (childColliderOption of childColliderOptions(); track $index) {
+					<ngt-object3D
+						[ngtrCollider]="childColliderOption.shape"
+						[args]="childColliderOption.args"
+						[position]="childColliderOption.position"
+						[rotation]="childColliderOption.rotation"
+						[scale]="childColliderOption.scale"
+						[name]="objectRef.nativeElement.name + '-instanced-collider-' + $index"
+						[options]="childColliderOption.colliderOptions"
+					/>
+				}
+			</ngt-object3D>
+		}
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        '[position]': 'position()',
+                        '[rotation]': 'rotation()',
+                        '[scale]': 'scale()',
+                        '[quaternion]': 'quaternion()',
+                        '[userData]': 'userData()',
+                    },
+                    imports: [NgtrRigidBody, NgtrRigidBody, NgtrAnyCollider],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instanced-rigid-bodies.js","sourceRoot":"","sources":["../../../../../libs/rapier/src/lib/instanced-rigid-bodies.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\teffect,\n\tElementRef,\n\tinject,\n\tinput,\n\tuntracked,\n\tviewChild,\n\tviewChildren,\n} from '@angular/core';\nimport { extend, getLocalState, NgtEuler, NgtObject3D, NgtQuaternion, NgtVector3, pick } from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { DynamicDrawUsage, InstancedMesh, Object3D } from 'three';\nimport { NgtrPhysics } from './physics';\nimport { NgtrAnyCollider, NgtrRigidBody, rigidBodyDefaultOptions } from './rigid-body';\nimport { NgtrRigidBodyOptions, NgtrRigidBodyState, NgtrRigidBodyType } from './types';\nimport { createColliderOptions } from './utils';\n\nexport interface NgtrInstancedRigidBodyOptions {\n\tkey: string | number;\n\ttype?: NgtrRigidBodyType;\n\tposition?: NgtVector3;\n\trotation?: NgtEuler;\n\tscale?: NgtVector3;\n\tquaternion?: NgtQuaternion;\n\tuserData?: NgtObject3D['userData'];\n\toptions?: NgtrRigidBodyOptions;\n}\n\nconst defaultOptions: NgtrRigidBodyOptions = rigidBodyDefaultOptions;\n\n@Component({\n\tselector: 'ngt-object3D[ngtrInstancedRigidBodies]',\n\texportAs: 'instancedRigidBodies',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-object3D #instanceWrapper>\n\t\t\t<ng-content />\n\t\t</ngt-object3D>\n\n\t\t@for (instance of instancesOptions(); track instance.key) {\n\t\t\t<ngt-object3D\n\t\t\t\t[ngtrRigidBody]=\"instance.type\"\n\t\t\t\t[options]=\"instance.options\"\n\t\t\t\t[position]=\"instance.position\"\n\t\t\t\t[rotation]=\"instance.rotation\"\n\t\t\t\t[scale]=\"instance.scale\"\n\t\t\t\t[quaternion]=\"instance.quaternion\"\n\t\t\t\t[userData]=\"instance.userData\"\n\t\t\t\t[name]=\"instance.key + '-instanced-rigid-body-' + $index\"\n\t\t\t>\n\t\t\t\t<ng-content select=\"[data-colliders]\" />\n\n\t\t\t\t@for (childColliderOption of childColliderOptions(); track $index) {\n\t\t\t\t\t<ngt-object3D\n\t\t\t\t\t\t[ngtrCollider]=\"childColliderOption.shape\"\n\t\t\t\t\t\t[args]=\"childColliderOption.args\"\n\t\t\t\t\t\t[position]=\"childColliderOption.position\"\n\t\t\t\t\t\t[rotation]=\"childColliderOption.rotation\"\n\t\t\t\t\t\t[scale]=\"childColliderOption.scale\"\n\t\t\t\t\t\t[name]=\"objectRef.nativeElement.name + '-instanced-collider-' + $index\"\n\t\t\t\t\t\t[options]=\"childColliderOption.colliderOptions\"\n\t\t\t\t\t/>\n\t\t\t\t}\n\t\t\t</ngt-object3D>\n\t\t}\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\thost: {\n\t\t'[position]': 'position()',\n\t\t'[rotation]': 'rotation()',\n\t\t'[scale]': 'scale()',\n\t\t'[quaternion]': 'quaternion()',\n\t\t'[userData]': 'userData()',\n\t},\n\timports: [NgtrRigidBody, NgtrRigidBody, NgtrAnyCollider],\n})\nexport class NgtrInstancedRigidBodies {\n\tposition = input<NgtVector3 | undefined>([0, 0, 0]);\n\trotation = input<NgtEuler | undefined>([0, 0, 0]);\n\tscale = input<NgtVector3 | undefined>([1, 1, 1]);\n\tquaternion = input<NgtQuaternion | undefined>([0, 0, 0, 1]);\n\tuserData = input<NgtObject3D['userData'] | undefined>({});\n\tinstances = input([], {\n\t\talias: 'ngtrInstancedRigidBodies',\n\t\ttransform: (value: Array<NgtrInstancedRigidBodyOptions> | '') => {\n\t\t\tif (value === '') return [];\n\t\t\treturn value;\n\t\t},\n\t});\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\n\tinstanceWrapperRef = viewChild.required<ElementRef<Object3D>>('instanceWrapper');\n\trigidBodyRefs = viewChildren(NgtrRigidBody);\n\n\tprivate physics = inject(NgtrPhysics);\n\tobjectRef = inject<ElementRef<Object3D>>(ElementRef);\n\n\tprivate colliders = pick(this.options, 'colliders');\n\n\tprivate instancedMesh = computed(() => {\n\t\tconst instanceWrapper = this.instanceWrapperRef().nativeElement;\n\t\tif (!instanceWrapper) return null;\n\n\t\tconst localState = getLocalState(instanceWrapper);\n\t\tif (!localState) return null;\n\n\t\t// track object's children\n\t\tlocalState.objects();\n\t\tconst firstChild = instanceWrapper.children[0];\n\t\tif (!firstChild || !(firstChild as InstancedMesh).isInstancedMesh) return null;\n\n\t\treturn firstChild as InstancedMesh;\n\t});\n\n\tprotected instancesOptions = computed(() => {\n\t\tconst [instances, options, instancedMesh] = [this.instances(), untracked(this.options), this.instancedMesh()];\n\t\tif (!instancedMesh) return [];\n\t\treturn instances.map(\n\t\t\t(instance, index) =>\n\t\t\t\t({\n\t\t\t\t\t...instance,\n\t\t\t\t\toptions: {\n\t\t\t\t\t\t...options,\n\t\t\t\t\t\t...(instance.options || {}),\n\t\t\t\t\t\ttransformState: (state) => {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t...state,\n\t\t\t\t\t\t\t\tgetMatrix: (matrix) => {\n\t\t\t\t\t\t\t\t\tinstancedMesh.getMatrixAt(index, matrix);\n\t\t\t\t\t\t\t\t\treturn matrix;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tsetMatrix: (matrix) => {\n\t\t\t\t\t\t\t\t\tinstancedMesh.setMatrixAt(index, matrix);\n\t\t\t\t\t\t\t\t\tinstancedMesh.instanceMatrix.needsUpdate = true;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tmeshType: 'instancedMesh',\n\t\t\t\t\t\t\t} as NgtrRigidBodyState;\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\tkey: `${instance.key}-${index}` + `${instancedMesh?.uuid || ''}`,\n\t\t\t\t}) as Omit<NgtrInstancedRigidBodyOptions, 'options'> & { options: Partial<NgtrRigidBodyOptions> },\n\t\t);\n\t});\n\n\tprotected childColliderOptions = computed(() => {\n\t\tconst colliders = this.colliders();\n\t\t// if self colliders is false explicitly, disable auto colliders for this object entirely.\n\t\tif (colliders === false) return [];\n\n\t\tconst physicsColliders = this.physics.colliders();\n\t\t// if physics colliders is false explicitly, disable auto colliders for this object entirely.\n\t\tif (physicsColliders === false) return [];\n\n\t\tconst options = this.options();\n\t\t// if colliders on object is not set, use physics colliders\n\t\tif (!options.colliders) options.colliders = physicsColliders;\n\n\t\tconst objectLocalState = getLocalState(this.objectRef.nativeElement);\n\t\t// track object's children\n\t\tobjectLocalState?.nonObjects();\n\n\t\treturn createColliderOptions(this.objectRef.nativeElement, options);\n\t});\n\n\tconstructor() {\n\t\textend({ Object3D });\n\t\teffect(() => {\n\t\t\tthis.setInstancedMeshMatrixEffect();\n\t\t});\n\t}\n\n\tprivate setInstancedMeshMatrixEffect() {\n\t\tconst instancedMesh = this.instancedMesh();\n\t\tif (!instancedMesh) return;\n\t\tinstancedMesh.instanceMatrix.setUsage(DynamicDrawUsage);\n\t}\n}\n"]}

package/esm2022/lib/joints.mjs

@@ -0,0 +1,111 @@
+import { computed, effect, inject } from '@angular/core';
+import { resolveRef } from 'angular-three';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { NgtrPhysics } from './physics';
+import { quaternionToRapierQuaternion, vector3ToRapierVector } from './utils';
+function injectImpulseJoint(bodyA, bodyB, { injector, data }) {
+    return assertInjector(injectImpulseJoint, injector, () => {
+        const physics = inject(NgtrPhysics);
+        const newJoint = computed(() => {
+            const worldSingleton = physics.worldSingleton();
+            if (!worldSingleton)
+                return null;
+            const a = typeof bodyA === 'function' ? resolveRef(bodyA()) : resolveRef(bodyA);
+            const b = typeof bodyB === 'function' ? resolveRef(bodyB()) : resolveRef(bodyB);
+            if (!a || !b)
+                return null;
+            const jointData = typeof data === 'function' ? data() : data;
+            if (!jointData)
+                return null;
+            return worldSingleton.proxy.createImpulseJoint(jointData, a, b, true);
+        });
+        effect((onCleanup) => {
+            const worldSingleton = physics.worldSingleton();
+            if (!worldSingleton)
+                return;
+            const joint = newJoint();
+            if (!joint)
+                return;
+            onCleanup(() => {
+                if (worldSingleton.proxy.getImpulseJoint(joint.handle)) {
+                    worldSingleton.proxy.removeImpulseJoint(joint, true);
+                }
+            });
+        });
+        return newJoint;
+    });
+}
+function createJoint(jointDataFn) {
+    return function _injectJoint(bodyA, bodyB, { injector, data }) {
+        return assertInjector(_injectJoint, injector, () => {
+            const physics = inject(NgtrPhysics);
+            const jointData = computed(() => {
+                const rapier = physics.rapier();
+                if (!rapier)
+                    return null;
+                return jointDataFn(rapier, data);
+            });
+            return injectImpulseJoint(bodyA, bodyB, { injector, data: jointData });
+        });
+    };
+}
+/**
+ * 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 const injectFixedJoint = createJoint((rapier, data) => rapier.JointData.fixed(vector3ToRapierVector(data.body1Anchor), quaternionToRapierQuaternion(data.body1LocalFrame), vector3ToRapierVector(data.body2Anchor), quaternionToRapierQuaternion(data.body2LocalFrame)));
+/**
+ * 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 const injectSphericalJoint = createJoint((rapier, data) => rapier.JointData.spherical(vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor)));
+/**
+ * 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 const injectRevoluteJoint = createJoint((rapier, data) => {
+    const jointData = rapier.JointData.revolute(vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor), vector3ToRapierVector(data.axis));
+    if (data.limits) {
+        jointData.limitsEnabled = true;
+        jointData.limits = data.limits;
+    }
+    return jointData;
+});
+/**
+ * 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 const injectPrismaticJoint = createJoint((rapier, data) => {
+    const jointData = rapier.JointData.prismatic(vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor), vector3ToRapierVector(data.axis));
+    if (data.limits) {
+        jointData.limitsEnabled = true;
+        jointData.limits = data.limits;
+    }
+    return jointData;
+});
+/**
+ * The rope joint limits the max distance between two bodies.
+ * @category Hooks - Joints
+ */
+export const injectRopeJoint = createJoint((rapier, data) => rapier.JointData.rope(data.length, vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor)));
+/**
+ * The spring joint applies a force proportional to the distance between two objects.
+ * @category Hooks - Joints
+ */
+export const injectSpringJoint = createJoint((rapier, data) => {
+    return rapier.JointData.spring(data.restLength, data.stiffness, data.damping, vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor));
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"joints.js","sourceRoot":"","sources":["../../../../../libs/rapier/src/lib/joints.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, effect, ElementRef, inject, Injector } from '@angular/core';\nimport {\n\tFixedImpulseJoint,\n\tImpulseJoint,\n\tJointData,\n\tPrismaticImpulseJoint,\n\tRevoluteImpulseJoint,\n\tRigidBody,\n\tRopeImpulseJoint,\n\tSphericalImpulseJoint,\n\tSpringImpulseJoint,\n} from '@dimforge/rapier3d-compat';\nimport { resolveRef } from 'angular-three';\nimport { assertInjector } from 'ngxtension/assert-injector';\nimport { NgtrPhysics } from './physics';\nimport {\n\tNgtrFixedJointParams,\n\tNgtrPrismaticJointParams,\n\tNgtrRevoluteJointParams,\n\tNgtrRopeJointParams,\n\tNgtrSphericalJointParams,\n\tNgtrSpringJointParams,\n} from './types';\nimport { quaternionToRapierQuaternion, vector3ToRapierVector } from './utils';\n\nfunction injectImpulseJoint<TJoinType extends ImpulseJoint>(\n\tbodyA: ElementRef<RigidBody> | RigidBody | (() => ElementRef<RigidBody> | RigidBody | undefined | null),\n\tbodyB: ElementRef<RigidBody> | RigidBody | (() => ElementRef<RigidBody> | RigidBody | undefined | null),\n\t{ injector, data }: { injector?: Injector; data: JointData | (() => JointData | null) },\n) {\n\treturn assertInjector(injectImpulseJoint, injector, () => {\n\t\tconst physics = inject(NgtrPhysics);\n\n\t\tconst newJoint = computed<TJoinType | null>(() => {\n\t\t\tconst worldSingleton = physics.worldSingleton();\n\t\t\tif (!worldSingleton) return null;\n\n\t\t\tconst a = typeof bodyA === 'function' ? resolveRef(bodyA()) : resolveRef(bodyA);\n\t\t\tconst b = typeof bodyB === 'function' ? resolveRef(bodyB()) : resolveRef(bodyB);\n\t\t\tif (!a || !b) return null;\n\n\t\t\tconst jointData = typeof data === 'function' ? data() : data;\n\t\t\tif (!jointData) return null;\n\n\t\t\treturn worldSingleton.proxy.createImpulseJoint(jointData, a, b, true) as TJoinType;\n\t\t});\n\n\t\teffect((onCleanup) => {\n\t\t\tconst worldSingleton = physics.worldSingleton();\n\t\t\tif (!worldSingleton) return;\n\n\t\t\tconst joint = newJoint();\n\t\t\tif (!joint) return;\n\n\t\t\tonCleanup(() => {\n\t\t\t\tif (worldSingleton.proxy.getImpulseJoint(joint.handle)) {\n\t\t\t\t\tworldSingleton.proxy.removeImpulseJoint(joint, true);\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\n\t\treturn newJoint;\n\t});\n}\n\nfunction createJoint<TJointParams, TJoinType extends ImpulseJoint>(\n\tjointDataFn: (rapier: NonNullable<ReturnType<NgtrPhysics['rapier']>>, data: TJointParams) => JointData,\n) {\n\treturn function _injectJoint(\n\t\tbodyA: ElementRef<RigidBody> | RigidBody | (() => ElementRef<RigidBody> | RigidBody | undefined | null),\n\t\tbodyB: ElementRef<RigidBody> | RigidBody | (() => ElementRef<RigidBody> | RigidBody | undefined | null),\n\t\t{ injector, data }: { injector?: Injector; data: TJointParams },\n\t) {\n\t\treturn assertInjector(_injectJoint, injector, () => {\n\t\t\tconst physics = inject(NgtrPhysics);\n\n\t\t\tconst jointData = computed(() => {\n\t\t\t\tconst rapier = physics.rapier();\n\t\t\t\tif (!rapier) return null;\n\t\t\t\treturn jointDataFn(rapier, data);\n\t\t\t});\n\n\t\t\treturn injectImpulseJoint<TJoinType>(bodyA, bodyB, { injector, data: jointData });\n\t\t});\n\t};\n}\n\n/**\n * A fixed joint ensures that two rigid-bodies don't move relative to each other.\n * Fixed joints are characterized by one local frame (represented by an isometry) on each rigid-body.\n * The fixed-joint makes these frames coincide in world-space.\n *\n * @category Hooks - Joints\n */\nexport const injectFixedJoint = createJoint<NgtrFixedJointParams, FixedImpulseJoint>((rapier, data) =>\n\trapier.JointData.fixed(\n\t\tvector3ToRapierVector(data.body1Anchor),\n\t\tquaternionToRapierQuaternion(data.body1LocalFrame),\n\t\tvector3ToRapierVector(data.body2Anchor),\n\t\tquaternionToRapierQuaternion(data.body2LocalFrame),\n\t),\n);\n\n/**\n * The spherical joint ensures that two points on the local-spaces of two rigid-bodies always coincide (it prevents any relative\n * translational motion at this points). This is typically used to simulate ragdolls arms, pendulums, etc.\n * They are characterized by one local anchor on each rigid-body. Each anchor represents the location of the\n * points that need to coincide on the local-space of each rigid-body.\n *\n * @category Hooks - Joints\n */\nexport const injectSphericalJoint = createJoint<NgtrSphericalJointParams, SphericalImpulseJoint>((rapier, data) =>\n\trapier.JointData.spherical(vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor)),\n);\n\n/**\n * The revolute joint prevents any relative movement between two rigid-bodies, except for relative\n * rotations along one axis. This is typically used to simulate wheels, fans, etc.\n * They are characterized by one local anchor as well as one local axis on each rigid-body.\n *\n * @category Hooks - Joints\n */\nexport const injectRevoluteJoint = createJoint<NgtrRevoluteJointParams, RevoluteImpulseJoint>((rapier, data) => {\n\tconst jointData = rapier.JointData.revolute(\n\t\tvector3ToRapierVector(data.body1Anchor),\n\t\tvector3ToRapierVector(data.body2Anchor),\n\t\tvector3ToRapierVector(data.axis),\n\t);\n\n\tif (data.limits) {\n\t\tjointData.limitsEnabled = true;\n\t\tjointData.limits = data.limits;\n\t}\n\n\treturn jointData;\n});\n\n/**\n * The prismatic joint prevents any relative movement between two rigid-bodies, except for relative translations along one axis.\n * It is characterized by one local anchor as well as one local axis on each rigid-body. In 3D, an optional\n * local tangent axis can be specified for each rigid-body.\n *\n * @category Hooks - Joints\n */\nexport const injectPrismaticJoint = createJoint<NgtrPrismaticJointParams, PrismaticImpulseJoint>((rapier, data) => {\n\tconst jointData = rapier.JointData.prismatic(\n\t\tvector3ToRapierVector(data.body1Anchor),\n\t\tvector3ToRapierVector(data.body2Anchor),\n\t\tvector3ToRapierVector(data.axis),\n\t);\n\n\tif (data.limits) {\n\t\tjointData.limitsEnabled = true;\n\t\tjointData.limits = data.limits;\n\t}\n\n\treturn jointData;\n});\n\n/**\n * The rope joint limits the max distance between two bodies.\n * @category Hooks - Joints\n */\nexport const injectRopeJoint = createJoint<NgtrRopeJointParams, RopeImpulseJoint>((rapier, data) =>\n\trapier.JointData.rope(data.length, vector3ToRapierVector(data.body1Anchor), vector3ToRapierVector(data.body2Anchor)),\n);\n\n/**\n * The spring joint applies a force proportional to the distance between two objects.\n * @category Hooks - Joints\n */\nexport const injectSpringJoint = createJoint<NgtrSpringJointParams, SpringImpulseJoint>((rapier, data) => {\n\treturn rapier.JointData.spring(\n\t\tdata.restLength,\n\t\tdata.stiffness,\n\t\tdata.damping,\n\t\tvector3ToRapierVector(data.body1Anchor),\n\t\tvector3ToRapierVector(data.body2Anchor),\n\t);\n});\n"]}

package/esm2022/lib/mesh-collider.mjs

@@ -0,0 +1,69 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, ElementRef, inject, input, } from '@angular/core';
+import { extend, getLocalState } from 'angular-three';
+import { Object3D } from 'three';
+import { NgtrPhysics } from './physics';
+import { NgtrAnyCollider, NgtrRigidBody } from './rigid-body';
+import { createColliderOptions } from './utils';
+import * as i0 from "@angular/core";
+export class NgtrMeshCollider {
+    colliders = input.required({ alias: 'ngtrMeshCollider' });
+    objectRef = inject(ElementRef);
+    rigidBody = inject(NgtrRigidBody);
+    physics = inject(NgtrPhysics);
+    childColliderOptions = computed(() => {
+        const rigidBodyOptions = this.rigidBody.options();
+        rigidBodyOptions.colliders = this.colliders();
+        const objectLocalState = getLocalState(this.objectRef.nativeElement);
+        // track object's children
+        objectLocalState?.nonObjects();
+        objectLocalState?.objects();
+        return createColliderOptions(this.objectRef.nativeElement, rigidBodyOptions, false);
+    });
+    constructor() {
+        extend({ Object3D });
+        if (!this.objectRef.nativeElement.userData) {
+            this.objectRef.nativeElement.userData = {};
+        }
+        this.objectRef.nativeElement.userData['ngtrRapierType'] = 'MeshCollider';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrMeshCollider, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: NgtrMeshCollider, isStandalone: true, selector: "ngt-object3D[ngtrMeshCollider]", inputs: { colliders: { classPropertyName: "colliders", publicName: "ngtrMeshCollider", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+		<ng-content />
+		@for (childColliderOption of childColliderOptions(); track $index) {
+			<ngt-object3D
+				[ngtrCollider]="childColliderOption.shape"
+				[args]="childColliderOption.args"
+				[position]="childColliderOption.position"
+				[rotation]="childColliderOption.rotation"
+				[scale]="childColliderOption.scale"
+				[name]="objectRef.nativeElement.name + '-mesh-collider-' + $index"
+				[options]="childColliderOption.colliderOptions"
+			/>
+		}
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtrAnyCollider, selector: "ngt-object3D[ngtrCollider]", inputs: ["position", "rotation", "scale", "quaternion", "userData", "name", "options", "ngtrCollider", "args"], outputs: ["ngtrColliderChange", "argsChange", "collisionEnter", "collisionExit", "intersectionEnter", "intersectionExit", "contactForce"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtrMeshCollider, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngt-object3D[ngtrMeshCollider]',
+                    standalone: true,
+                    template: `
+		<ng-content />
+		@for (childColliderOption of childColliderOptions(); track $index) {
+			<ngt-object3D
+				[ngtrCollider]="childColliderOption.shape"
+				[args]="childColliderOption.args"
+				[position]="childColliderOption.position"
+				[rotation]="childColliderOption.rotation"
+				[scale]="childColliderOption.scale"
+				[name]="objectRef.nativeElement.name + '-mesh-collider-' + $index"
+				[options]="childColliderOption.colliderOptions"
+			/>
+		}
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtrAnyCollider],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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