angular-three-rapier 2.2.0

package/esm2022/lib/shared.mjs

@@ -0,0 +1,10 @@
+import { Euler, Matrix4, Object3D, Quaternion, Vector3 } from 'three';
+export const _quaternion = new Quaternion();
+export const _euler = new Euler();
+export const _vector3 = new Vector3();
+export const _object3d = new Object3D();
+export const _matrix4 = new Matrix4();
+export const _position = new Vector3();
+export const _rotation = new Quaternion();
+export const _scale = new Vector3();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9yYXBpZXIvc3JjL2xpYi9zaGFyZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsTUFBTSxPQUFPLENBQUM7QUFFdEUsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLElBQUksVUFBVSxFQUFFLENBQUM7QUFDNUMsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLElBQUksS0FBSyxFQUFFLENBQUM7QUFDbEMsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7QUFDdEMsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLElBQUksUUFBUSxFQUFFLENBQUM7QUFDeEMsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7QUFDdEMsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7QUFDdkMsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLElBQUksVUFBVSxFQUFFLENBQUM7QUFDMUMsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLElBQUksT0FBTyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFdWxlciwgTWF0cml4NCwgT2JqZWN0M0QsIFF1YXRlcm5pb24sIFZlY3RvcjMgfSBmcm9tICd0aHJlZSc7XG5cbmV4cG9ydCBjb25zdCBfcXVhdGVybmlvbiA9IG5ldyBRdWF0ZXJuaW9uKCk7XG5leHBvcnQgY29uc3QgX2V1bGVyID0gbmV3IEV1bGVyKCk7XG5leHBvcnQgY29uc3QgX3ZlY3RvcjMgPSBuZXcgVmVjdG9yMygpO1xuZXhwb3J0IGNvbnN0IF9vYmplY3QzZCA9IG5ldyBPYmplY3QzRCgpO1xuZXhwb3J0IGNvbnN0IF9tYXRyaXg0ID0gbmV3IE1hdHJpeDQoKTtcbmV4cG9ydCBjb25zdCBfcG9zaXRpb24gPSBuZXcgVmVjdG9yMygpO1xuZXhwb3J0IGNvbnN0IF9yb3RhdGlvbiA9IG5ldyBRdWF0ZXJuaW9uKCk7XG5leHBvcnQgY29uc3QgX3NjYWxlID0gbmV3IFZlY3RvcjMoKTtcbiJdfQ==

package/esm2022/lib/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../libs/rapier/src/lib/types.ts"],"names":[],"mappings":"","sourcesContent":["import {\n\tActiveCollisionTypes,\n\tCoefficientCombineRule,\n\tCollider,\n\tColliderHandle,\n\tInteractionGroups,\n\tRigidBody,\n\tRigidBodyHandle,\n\tRotation,\n\tTempContactManifold,\n\tVector,\n\tWorld,\n} from '@dimforge/rapier3d-compat';\nimport { NgtObject3D, NgtQuaternion, NgtVector3 } from 'angular-three';\nimport { Matrix4, Object3D, Vector3, Vector3Tuple } from 'three';\n\nexport type NgtrRigidBodyAutoCollider = 'ball' | 'cuboid' | 'hull' | 'trimesh' | false;\n\nexport interface NgtrPhysicsOptions {\n\t/**\n\t * Set the gravity of the physics world\n\t * @defaultValue [0, -9.81, 0]\n\t */\n\tgravity: Vector3Tuple;\n\n\t/**\n\t * Amount of penetration the engine wont attempt to correct\n\t * @defaultValue 0.001\n\t */\n\tallowedLinearError: number;\n\n\t/**\n\t * The number of solver iterations run by the constraints solver for calculating forces.\n\t * The greater this value is, the most rigid and realistic the physics simulation will be.\n\t * However a greater number of iterations is more computationally intensive.\n\t *\n\t * @defaultValue 4\n\t */\n\tnumSolverIterations: number;\n\n\t/**\n\t * Number of addition friction resolution iteration run during the last solver sub-step.\n\t * The greater this value is, the most realistic friction will be.\n\t * However a greater number of iterations is more computationally intensive.\n\t *\n\t * @defaultValue 4\n\t */\n\tnumAdditionalFrictionIterations: number;\n\n\t/**\n\t * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration.\n\t * Increasing this parameter will improve stability of the simulation. It will have a lesser effect than\n\t * increasing `numSolverIterations` but is also less computationally expensive.\n\t *\n\t * @defaultValue 1\n\t */\n\tnumInternalPgsIterations: number;\n\n\t/**\n\t * The maximal distance separating two objects that will generate predictive contacts\n\t *\n\t * @defaultValue 0.002\n\t *\n\t */\n\tpredictionDistance: number;\n\n\t/**\n\t * Minimum number of dynamic bodies in each active island\n\t *\n\t * @defaultValue 128\n\t */\n\tminIslandSize: number;\n\n\t/**\n\t * Maximum number of substeps performed by the solver\n\t *\n\t * @defaultValue 1\n\t */\n\tmaxCcdSubsteps: number;\n\n\t/**\n\t * The Error Reduction Parameter in between 0 and 1, is the proportion of the positional error to be corrected at each time step.\n\t *\n\t * @defaultValue 0.8\n\t */\n\terp: number;\n\n\t/**\n\t * The approximate size of most dynamic objects in the scene.\n\t *\n\t * This value is used internally to estimate some length-based tolerance.\n\t * This value can be understood as the number of units-per-meter in your physical world compared to a human-sized world in meter.\n\t *\n\t * @defaultValue 1\n\t */\n\tlengthUnit: number;\n\n\t/**\n\t * Set the base automatic colliders for this physics world\n\t * All Meshes inside RigidBodies will generate a collider\n\t * based on this value, if not overridden.\n\t */\n\tcolliders?: NgtrRigidBodyAutoCollider;\n\n\t/**\n\t * Set the timestep for the simulation.\n\t * Setting this to a number (eg. 1/60) will run the\n\t * simulation at that framerate. Alternatively, you can set this to\n\t * \"vary\", which will cause the simulation to always synchronize with\n\t * the current frame delta times.\n\t *\n\t * @defaultValue 1/60\n\t */\n\ttimeStep: number | 'vary';\n\n\t/**\n\t * Pause the physics simulation\n\t *\n\t * @defaultValue false\n\t */\n\tpaused: boolean;\n\n\t/**\n\t * Interpolate the world transform using the frame delta times.\n\t * Has no effect if timeStep is set to \"vary\".\n\t *\n\t * @defaultValue true\n\t **/\n\tinterpolate: boolean;\n\n\t/**\n\t * The update priority at which the physics simulation should run.\n\t * Only used when `updateLoop` is set to \"follow\".\n\t *\n\t * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#taking-over-the-render-loop\n\t * @defaultValue undefined\n\t */\n\tupdatePriority?: number;\n\n\t/**\n\t * Set the update loop strategy for the physics world.\n\t *\n\t * If set to \"follow\", the physics world will be stepped\n\t * in a `useFrame` callback, managed by @react-three/fiber.\n\t * You can use `updatePriority` prop to manage the scheduling.\n\t *\n\t * If set to \"independent\", the physics world will be stepped\n\t * in a separate loop, not tied to the render loop.\n\t * This is useful when using the \"demand\" `frameloop` strategy for the\n\t * @react-three/fiber `<Canvas />`.\n\t *\n\t * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering\n\t * @defaultValue \"follow\"\n\t */\n\tupdateLoop: 'follow' | 'independent';\n\n\t/**\n\t * Enable debug rendering of the physics world.\n\t * @defaultValue false\n\t */\n\tdebug: boolean;\n}\n\nexport interface NgtrRigidBodyState {\n\tmeshType: 'instancedMesh' | 'mesh';\n\trigidBody: RigidBody;\n\tobject: Object3D;\n\tinvertedWorldMatrix: Matrix4;\n\tsetMatrix: (matrix: Matrix4) => void;\n\tgetMatrix: (matrix: Matrix4) => Matrix4;\n\t/**\n\t * Required for instanced rigid bodies.\n\t */\n\tscale: Vector3;\n\tisSleeping: boolean;\n}\nexport type NgtrRigidBodyStateMap = Map<RigidBody['handle'], NgtrRigidBodyState>;\n\nexport interface NgtrColliderState {\n\tcollider: Collider;\n\tobject: Object3D;\n\n\t/**\n\t * The parent of which this collider needs to base its\n\t * world position on, can be empty\n\t */\n\tworldParent?: Object3D;\n}\nexport type NgtrColliderStateMap = Map<Collider['handle'], NgtrColliderState>;\n\nexport interface NgtrCollisionTarget {\n\trigidBody?: RigidBody;\n\tcollider: Collider;\n\trigidBodyObject?: Object3D;\n\tcolliderObject?: Object3D;\n}\n\nexport interface NgtrCollisionPayload {\n\t/** the object firing the event */\n\ttarget: NgtrCollisionTarget;\n\t/** the other object involved in the event */\n\tother: NgtrCollisionTarget;\n}\n\nexport interface NgtrCollisionEnterPayload extends NgtrCollisionPayload {\n\tmanifold: TempContactManifold;\n\tflipped: boolean;\n}\n\nexport interface NgtrCollisionExitPayload extends NgtrCollisionPayload {}\nexport interface NgtrIntersectionEnterPayload extends NgtrCollisionPayload {}\nexport interface NgtrIntersectionExitPayload extends NgtrCollisionPayload {}\nexport interface NgtrContactForcePayload extends NgtrCollisionPayload {\n\ttotalForce: Vector;\n\ttotalForceMagnitude: number;\n\tmaxForceDirection: Vector;\n\tmaxForceMagnitude: number;\n}\n\nexport type NgtrCollisionEnterHandler = (payload: NgtrCollisionEnterPayload) => void;\nexport type NgtrCollisionExitHandler = (payload: NgtrCollisionExitPayload) => void;\nexport type NgtrIntersectionEnterHandler = (payload: NgtrIntersectionEnterPayload) => void;\nexport type NgtrIntersectionExitHandler = (payload: NgtrIntersectionExitPayload) => void;\nexport type NgtrContactForceHandler = (payload: NgtrContactForcePayload) => void;\n\nexport interface NgtrEventMapValue {\n\tonSleep?(): void;\n\tonWake?(): void;\n\tonCollisionEnter?: NgtrCollisionEnterHandler;\n\tonCollisionExit?: NgtrCollisionExitHandler;\n\tonIntersectionEnter?: NgtrIntersectionEnterHandler;\n\tonIntersectionExit?: NgtrIntersectionExitHandler;\n\tonContactForce?: NgtrContactForceHandler;\n}\nexport type NgtrEventMap = Map<ColliderHandle | RigidBodyHandle, NgtrEventMapValue>;\n\nexport type NgtrWorldStepCallback = (world: World) => void;\nexport type NgtrWorldStepCallbackSet = Set<NgtrWorldStepCallback>;\n\nexport interface NgtrCollisionSource {\n\tcollider: {\n\t\tobject: Collider;\n\t\tevents?: NgtrEventMapValue;\n\t\tstate?: NgtrColliderState;\n\t};\n\trigidBody: {\n\t\tobject?: RigidBody;\n\t\tevents?: NgtrEventMapValue;\n\t\tstate?: NgtrRigidBodyState;\n\t};\n}\n\nexport type NgtrColliderShape =\n\t| 'cuboid'\n\t| 'trimesh'\n\t| 'ball'\n\t| 'capsule'\n\t| 'convexHull'\n\t| 'heightfield'\n\t| 'polyline'\n\t| 'roundCuboid'\n\t| 'cylinder'\n\t| 'roundCylinder'\n\t| 'cone'\n\t| 'roundCone'\n\t| 'convexMesh'\n\t| 'roundConvexHull'\n\t| 'roundConvexMesh';\n\nexport interface NgtrColliderOptions {\n\t/**\n\t * The optional name passed to THREE's Object3D\n\t */\n\tname?: string;\n\n\t/**\n\t * Principal angular inertia of this rigid body\n\t */\n\tprincipalAngularInertia?: Vector3Tuple;\n\n\t/**\n\t * Restitution controls how elastic (aka. bouncy) a contact is. Le elasticity of a contact is controlled by the restitution coefficient\n\t */\n\trestitution?: number;\n\n\t/**\n\t * What happens when two bodies meet. See https://rapier.rs/docs/user_guides/javascript/colliders#friction.\n\t */\n\trestitutionCombineRule?: CoefficientCombineRule;\n\n\t/**\n\t * Friction is a force that opposes the relative tangential motion between two rigid-bodies with colliders in contact.\n\t * A friction coefficient of 0 implies no friction at all (completely sliding contact) and a coefficient\n\t * greater or equal to 1 implies a very strong friction. Values greater than 1 are allowed.\n\t */\n\tfriction?: number;\n\n\t/**\n\t * What happens when two bodies meet. See https://rapier.rs/docs/user_guides/javascript/colliders#friction.\n\t */\n\tfrictionCombineRule?: CoefficientCombineRule;\n\n\t/**\n\t * The bit mask configuring the groups and mask for collision handling.\n\t */\n\tcollisionGroups?: InteractionGroups;\n\n\t/**\n\t * The bit mask configuring the groups and mask for solver handling.\n\t */\n\tsolverGroups?: InteractionGroups;\n\n\t/**\n\t * The collision types active for this collider.\n\t *\n\t * Use `ActiveCollisionTypes` to specify which collision types should be active for this collider.\n\t *\n\t * @see https://rapier.rs/javascript3d/classes/Collider.html#setActiveCollisionTypes\n\t * @see https://rapier.rs/javascript3d/enums/ActiveCollisionTypes.html\n\t */\n\tactiveCollisionTypes?: ActiveCollisionTypes;\n\n\t/**\n\t * Sets the uniform density of this collider.\n\t * If this is set, other mass-properties like the angular inertia tensor are computed\n\t * automatically from the collider's shape.\n\t * Cannot be used at the same time as the mass or massProperties values.\n\t * More info https://rapier.rs/docs/user_guides/javascript/colliders#mass-properties\n\t */\n\tdensity?: number;\n\n\t/**\n\t * The mass of this collider.\n\t * Generally, it's not recommended to adjust the mass properties as it could lead to\n\t * unexpected behaviors.\n\t * Cannot be used at the same time as the density or massProperties values.\n\t * More info https://rapier.rs/docs/user_guides/javascript/colliders#mass-properties\n\t */\n\tmass?: number;\n\n\t/**\n\t * The mass properties of this rigid body.\n\t * Cannot be used at the same time as the density or mass values.\n\t */\n\tmassProperties?: {\n\t\tmass: number;\n\t\tcenterOfMass: Vector;\n\t\tprincipalAngularInertia: Vector;\n\t\tangularInertiaLocalFrame: Rotation;\n\t};\n\n\t/**\n\t * The contact skin of the collider.\n\t *\n\t * The contact skin acts as if the collider was enlarged with a skin of width contactSkin around it, keeping objects further apart when colliding.\n\t *\n\t * A non-zero contact skin can increase performance, and in some cases, stability.\n\t * However it creates a small gap between colliding object (equal to the sum of their skin).\n\t * If the skin is sufficiently small, this might not be visually significant or can be hidden by the rendering assets.\n\t *\n\t * @defaultValue 0\n\t */\n\tcontactSkin: number;\n\n\t/**\n\t * Sets whether or not this collider is a sensor.\n\t */\n\tsensor?: boolean;\n}\n\nexport type NgtrRigidBodyType = 'fixed' | 'dynamic' | 'kinematicPosition' | 'kinematicVelocity';\n\nexport interface NgtrRigidBodyOptions extends NgtrColliderOptions {\n\t/**\n\t * Whether or not this body can sleep.\n\t * @defaultValue true\n\t */\n\tcanSleep: boolean;\n\n\t/** The linear damping coefficient of this rigid-body.*/\n\tlinearDamping?: number;\n\n\t/** The angular damping coefficient of this rigid-body.*/\n\tangularDamping?: number;\n\n\t/**\n\t * The initial linear velocity of this body.\n\t * @defaultValue [0,0,0]\n\t */\n\tlinearVelocity: Vector3Tuple;\n\n\t/**\n\t * The initial angular velocity of this body.\n\t * @defaultValue [0,0,0]\n\t */\n\tangularVelocity: Vector3Tuple;\n\n\t/**\n\t * The scaling factor applied to the gravity affecting the rigid-body.\n\t * @defaultValue 1.0\n\t */\n\tgravityScale: number;\n\n\t/**\n\t * The dominance group of this RigidBody. If a rigid body has a higher domiance group,\n\t * on collision it will be immune to forces originating from the other bodies.\n\t * https://rapier.rs/docs/user_guides/javascript/rigid_bodies#dominance\n\t * Default: 0\n\t */\n\tdominanceGroup: number;\n\n\t/**\n\t * Whether or not Continous Collision Detection is enabled for this rigid-body.\n\t * https://rapier.rs/docs/user_guides/javascript/rigid_bodies#continuous-collision-detection\n\t * @defaultValue false\n\t */\n\tccd: boolean;\n\n\t/**\n\t * The maximum prediction distance Soft Continuous Collision-Detection.\n\t *\n\t * When set to 0, soft-CCD is disabled.\n\t *\n\t * Soft-CCD helps prevent tunneling especially of slow-but-thin to moderately fast objects.\n\t * The soft CCD prediction distance indicates how far in the object’s path the CCD algorithm is allowed to inspect.\n\t * Large values can impact performance badly by increasing the work needed from the broad-phase.\n\t *\n\t * It is a generally cheaper variant of regular CCD since it relies on predictive constraints instead of shape-cast and substeps.\n\t *\n\t * @defaultValue 0\n\t */\n\tsoftCcdPrediction: number;\n\n\t/**\n\t * Initial position of the RigidBody\n\t */\n\tposition?: NgtObject3D['position'];\n\n\t/**\n\t * Initial rotation of the RigidBody\n\t */\n\trotation?: NgtObject3D['rotation'];\n\n\t/**\n\t * Automatically generate colliders based on meshes inside this\n\t * rigid body.\n\t *\n\t * You can change the default setting globally by setting the colliders\n\t * prop on the <Physics /> component.\n\t *\n\t * Setting this to false will disable automatic colliders.\n\t */\n\tcolliders?: NgtrRigidBodyAutoCollider | false;\n\n\t/**\n\t * Set the friction of auto-generated colliders.\n\t * This does not affect any non-automatic child collider-components.\n\t */\n\tfriction?: number;\n\n\t/**\n\t * Set the restitution (bounciness) of auto-generated colliders.\n\t * This does not affect any non-automatic child collider-components.\n\t */\n\trestitution?: number;\n\n\t/**\n\t * Sets the number of additional solver iterations that will be run for this\n\t * rigid-body and everything that interacts with it directly or indirectly\n\t * through contacts or joints.\n\t *\n\t * Compared to increasing the global `World.numSolverIteration`, setting this\n\t * value lets you increase accuracy on only a subset of the scene, resulting in reduced\n\t * performance loss.\n\t */\n\tadditionalSolverIterations?: number;\n\n\t/**\n\t * The default collision groups bitmask for all colliders in this rigid body.\n\t * Can be customized per-collider.\n\t */\n\tcollisionGroups?: InteractionGroups;\n\n\t/**\n\t * The default solver groups bitmask for all colliders in this rigid body.\n\t * Can be customized per-collider.\n\t */\n\tsolverGroups?: InteractionGroups;\n\n\t/**\n\t * The default active collision types for all colliders in this rigid body.\n\t * Can be customized per-collider.\n\t *\n\t * Use `ActiveCollisionTypes` to specify which collision types should be active for this collider.\n\t *\n\t * @see https://rapier.rs/javascript3d/classes/Collider.html#setActiveCollisionTypes\n\t * @see https://rapier.rs/javascript3d/enums/ActiveCollisionTypes.html\n\t */\n\tactiveCollisionTypes?: ActiveCollisionTypes;\n\n\t/**\n\t * Locks all rotations that would have resulted from forces on the created rigid-body.\n\t */\n\tlockRotations?: boolean;\n\n\t/**\n\t * Locks all translations that would have resulted from forces on the created rigid-body.\n\t */\n\tlockTranslations?: boolean;\n\n\t/**\n\t * Allow rotation of this rigid-body only along specific axes.\n\t */\n\tenabledRotations?: [x: boolean, y: boolean, z: boolean];\n\n\t/**\n\t * Allow translation of this rigid-body only along specific axes.\n\t */\n\tenabledTranslations?: [x: boolean, y: boolean, z: boolean];\n\n\t/**\n\t * Passed down to the object3d representing this collider.\n\t */\n\tuserData?: NgtObject3D['userData'];\n\n\t/**\n\t * Include invisible objects on the collider creation estimation.\n\t */\n\tincludeInvisible?: boolean;\n\n\t/**\n\t * Transform the RigidBodyState\n\t * @internal Do not use. Used internally by the InstancedRigidBodies to alter the RigidBody State\n\t */\n\ttransformState?: (state: NgtrRigidBodyState) => NgtrRigidBodyState;\n}\n\nexport type NgtrCuboidArgs = [halfWidth: number, halfHeight: number, halfDepth: number];\nexport type NgtrBallArgs = [radius: number];\nexport type NgtrCapsuleArgs = [halfHeight: number, radius: number];\nexport type NgtrConvexHullArgs = [vertices: ArrayLike<number>];\nexport type NgtrHeightfieldArgs = [\n\twidth: number,\n\theight: number,\n\theights: number[],\n\tscale: { x: number; y: number; z: number },\n];\nexport type NgtrTrimeshArgs = [vertices: ArrayLike<number>, indices: ArrayLike<number>];\nexport type NgtrPolylineArgs = [vertices: Float32Array, indices: Uint32Array];\nexport type NgtrRoundCuboidArgs = [halfWidth: number, halfHeight: number, halfDepth: number, borderRadius: number];\nexport type NgtrCylinderArgs = [halfHeight: number, radius: number];\nexport type NgtrRoundCylinderArgs = [halfHeight: number, radius: number, borderRadius: number];\nexport type NgtrConeArgs = [halfHeight: number, radius: number];\nexport type NgtrRoundConeArgs = [halfHeight: number, radius: number, borderRadius: number];\nexport type NgtrConvexMeshArgs = [vertices: ArrayLike<number>, indices: ArrayLike<number>];\nexport type NgtrRoundConvexHullArgs = [vertices: ArrayLike<number>, indices: ArrayLike<number>, borderRadius: number];\nexport type NgtrRoundConvexMeshArgs = [vertices: ArrayLike<number>, indices: ArrayLike<number>, borderRadius: number];\n\n// Joints\nexport interface NgtrSphericalJointParams {\n\tbody1Anchor: NgtVector3;\n\tbody2Anchor: NgtVector3;\n}\n\nexport interface NgtrFixedJointParams {\n\tbody1Anchor: NgtVector3;\n\tbody1LocalFrame: NgtQuaternion;\n\tbody2Anchor: NgtVector3;\n\tbody2LocalFrame: NgtQuaternion;\n}\n\nexport interface NgtrPrismaticJointParams {\n\tbody1Anchor: NgtVector3;\n\tbody2Anchor: NgtVector3;\n\taxis: NgtVector3;\n\tlimits?: [min: number, max: number];\n}\n\nexport interface NgtrRevoluteJointParams {\n\tbody1Anchor: NgtVector3;\n\tbody2Anchor: NgtVector3;\n\taxis: NgtVector3;\n\tlimits?: [min: number, max: number];\n}\n\nexport interface NgtrRopeJointParams {\n\tbody1Anchor: NgtVector3;\n\tbody2Anchor: NgtVector3;\n\tlength: number;\n}\n\nexport interface NgtrSpringJointParams {\n\tbody1Anchor: NgtVector3;\n\tbody2Anchor: NgtVector3;\n\trestLength: number;\n\tstiffness: number;\n\tdamping: number;\n}\n"]}

package/esm2022/lib/utils.mjs

@@ -0,0 +1,151 @@
+import { Quaternion as RapierQuaternion, Vector3 as RapierVector3 } from '@dimforge/rapier3d-compat';
+import { Euler, Vector3 } from 'three';
+import { mergeVertices } from 'three-stdlib';
+import { _matrix4, _position, _quaternion, _rotation, _scale } from './shared';
+/**
+ * Creates a proxy that will create a singleton instance of the given class
+ * when a property is accessed, and not before.
+ *
+ * @returns A proxy and a reset function, so that the instance can created again
+ */
+export const createSingletonProxy = (
+/**
+ * A function that returns a new instance of the class
+ */
+createInstance) => {
+    let instance;
+    const handler = {
+        get(target, prop) {
+            if (!instance) {
+                instance = createInstance();
+            }
+            return Reflect.get(instance, prop);
+        },
+        set(target, prop, value) {
+            if (!instance) {
+                instance = createInstance();
+            }
+            return Reflect.set(instance, prop, value);
+        },
+    };
+    const proxy = new Proxy({}, handler);
+    const reset = () => {
+        instance = undefined;
+    };
+    const set = (newInstance) => {
+        instance = newInstance;
+    };
+    /**
+     * Return the proxy and a reset function
+     */
+    return { proxy, reset, set };
+};
+export function rapierQuaternionToQuaternion({ x, y, z, w }) {
+    return _quaternion.set(x, y, z, w);
+}
+export function vector3ToRapierVector(v) {
+    if (Array.isArray(v)) {
+        return new RapierVector3(v[0], v[1], v[2]);
+    }
+    if (typeof v === 'number') {
+        return new RapierVector3(v, v, v);
+    }
+    const vector = v;
+    return new RapierVector3(vector.x, vector.y, vector.z);
+}
+export function quaternionToRapierQuaternion(v) {
+    if (Array.isArray(v)) {
+        return new RapierQuaternion(v[0], v[1], v[2], v[3]);
+    }
+    return new RapierQuaternion(v.x, v.y, v.z, v.w);
+}
+function isChildOfMeshCollider(child) {
+    let flag = false;
+    child.traverseAncestors((a) => {
+        if (a.userData['ngtRapierType'] === 'MeshCollider')
+            flag = true;
+    });
+    return flag;
+}
+const autoColliderMap = {
+    cuboid: 'cuboid',
+    ball: 'ball',
+    hull: 'convexHull',
+    trimesh: 'trimesh',
+};
+function getColliderArgsFromGeometry(geometry, colliders) {
+    switch (colliders) {
+        case 'cuboid': {
+            geometry.computeBoundingBox();
+            const { boundingBox } = geometry;
+            const size = boundingBox.getSize(new Vector3());
+            return {
+                args: [size.x / 2, size.y / 2, size.z / 2],
+                offset: boundingBox.getCenter(new Vector3()),
+            };
+        }
+        case 'ball': {
+            geometry.computeBoundingSphere();
+            const { boundingSphere } = geometry;
+            const radius = boundingSphere.radius;
+            return {
+                args: [radius],
+                offset: boundingSphere.center,
+            };
+        }
+        case 'trimesh': {
+            const clonedGeometry = geometry.index ? geometry.clone() : mergeVertices(geometry);
+            return {
+                args: [clonedGeometry.attributes['position'].array, clonedGeometry.index?.array],
+                offset: new Vector3(),
+            };
+        }
+        case 'hull': {
+            const clonedGeometry = geometry.clone();
+            return {
+                args: [clonedGeometry.attributes['position'].array],
+                offset: new Vector3(),
+            };
+        }
+    }
+    return { args: [], offset: new Vector3() };
+}
+export function createColliderOptions(object, options, ignoreMeshColliders = true) {
+    const childColliderOptions = [];
+    object.updateWorldMatrix(true, false);
+    const invertedParentMatrixWorld = object.matrixWorld.clone().invert();
+    const colliderFromChild = (child) => {
+        if (child.isMesh) {
+            if (ignoreMeshColliders && isChildOfMeshCollider(child))
+                return;
+            const worldScale = child.getWorldScale(_scale);
+            const shape = autoColliderMap[options.colliders || 'cuboid'];
+            child.updateWorldMatrix(true, false);
+            _matrix4.copy(child.matrixWorld).premultiply(invertedParentMatrixWorld).decompose(_position, _rotation, _scale);
+            const rotationEuler = new Euler().setFromQuaternion(_rotation, 'XYZ');
+            const { geometry } = child;
+            const { args, offset } = getColliderArgsFromGeometry(geometry, options.colliders || 'cuboid');
+            const { mass, linearDamping, angularDamping, canSleep, ccd, gravityScale, softCcdPrediction, ...rest } = options;
+            childColliderOptions.push({
+                colliderOptions: rest,
+                args,
+                shape,
+                rotation: [rotationEuler.x, rotationEuler.y, rotationEuler.z],
+                position: [
+                    _position.x + offset.x * worldScale.x,
+                    _position.y + offset.y * worldScale.y,
+                    _position.z + offset.z * worldScale.z,
+                ],
+                scale: [worldScale.x, worldScale.y, worldScale.z],
+            });
+        }
+    };
+    if (options.includeInvisible) {
+        object.traverse(colliderFromChild);
+    }
+    else {
+        object.traverseVisible(colliderFromChild);
+    }
+    return childColliderOptions;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../libs/rapier/src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Quaternion as RapierQuaternion, Vector3 as RapierVector3 } from '@dimforge/rapier3d-compat';\nimport { NgtEuler, NgtQuaternion, NgtVector3 } from 'angular-three';\nimport { BufferGeometry, Euler, Mesh, Object3D, Vector3 } from 'three';\nimport { mergeVertices } from 'three-stdlib';\nimport { _matrix4, _position, _quaternion, _rotation, _scale } from './shared';\nimport { NgtrColliderOptions, NgtrColliderShape, NgtrRigidBodyAutoCollider, NgtrRigidBodyOptions } from './types';\n\n/**\n * Creates a proxy that will create a singleton instance of the given class\n * when a property is accessed, and not before.\n *\n * @returns A proxy and a reset function, so that the instance can created again\n */\nexport const createSingletonProxy = <\n\tSingletonClass extends object,\n\tCreationFn extends () => SingletonClass = () => SingletonClass,\n>(\n\t/**\n\t * A function that returns a new instance of the class\n\t */\n\tcreateInstance: CreationFn,\n): {\n\tproxy: SingletonClass;\n\treset: () => void;\n\tset: (newInstance: SingletonClass) => void;\n} => {\n\tlet instance: SingletonClass | undefined;\n\n\tconst handler: ProxyHandler<SingletonClass> = {\n\t\tget(target, prop) {\n\t\t\tif (!instance) {\n\t\t\t\tinstance = createInstance();\n\t\t\t}\n\t\t\treturn Reflect.get(instance!, prop);\n\t\t},\n\t\tset(target, prop, value) {\n\t\t\tif (!instance) {\n\t\t\t\tinstance = createInstance();\n\t\t\t}\n\t\t\treturn Reflect.set(instance!, prop, value);\n\t\t},\n\t};\n\n\tconst proxy = new Proxy({} as SingletonClass, handler) as SingletonClass;\n\n\tconst reset = () => {\n\t\tinstance = undefined;\n\t};\n\n\tconst set = (newInstance: SingletonClass) => {\n\t\tinstance = newInstance;\n\t};\n\n\t/**\n\t * Return the proxy and a reset function\n\t */\n\treturn { proxy, reset, set };\n};\n\nexport function rapierQuaternionToQuaternion({ x, y, z, w }: RapierQuaternion) {\n\treturn _quaternion.set(x, y, z, w);\n}\n\nexport function vector3ToRapierVector(v: NgtVector3) {\n\tif (Array.isArray(v)) {\n\t\treturn new RapierVector3(v[0], v[1], v[2]);\n\t}\n\n\tif (typeof v === 'number') {\n\t\treturn new RapierVector3(v, v, v);\n\t}\n\tconst vector = v as Vector3;\n\treturn new RapierVector3(vector.x, vector.y, vector.z);\n}\n\nexport function quaternionToRapierQuaternion(v: NgtQuaternion) {\n\tif (Array.isArray(v)) {\n\t\treturn new RapierQuaternion(v[0], v[1], v[2], v[3]);\n\t}\n\treturn new RapierQuaternion(v.x, v.y, v.z, v.w);\n}\n\nfunction isChildOfMeshCollider(child: Mesh) {\n\tlet flag = false;\n\tchild.traverseAncestors((a) => {\n\t\tif (a.userData['ngtRapierType'] === 'MeshCollider') flag = true;\n\t});\n\treturn flag;\n}\n\nconst autoColliderMap = {\n\tcuboid: 'cuboid',\n\tball: 'ball',\n\thull: 'convexHull',\n\ttrimesh: 'trimesh',\n};\n\nfunction getColliderArgsFromGeometry(\n\tgeometry: BufferGeometry,\n\tcolliders: NgtrRigidBodyAutoCollider,\n): { args: unknown[]; offset: Vector3 } {\n\tswitch (colliders) {\n\t\tcase 'cuboid': {\n\t\t\tgeometry.computeBoundingBox();\n\t\t\tconst { boundingBox } = geometry;\n\t\t\tconst size = boundingBox!.getSize(new Vector3());\n\t\t\treturn {\n\t\t\t\targs: [size.x / 2, size.y / 2, size.z / 2],\n\t\t\t\toffset: boundingBox!.getCenter(new Vector3()),\n\t\t\t};\n\t\t}\n\n\t\tcase 'ball': {\n\t\t\tgeometry.computeBoundingSphere();\n\t\t\tconst { boundingSphere } = geometry;\n\n\t\t\tconst radius = boundingSphere!.radius;\n\n\t\t\treturn {\n\t\t\t\targs: [radius],\n\t\t\t\toffset: boundingSphere!.center,\n\t\t\t};\n\t\t}\n\n\t\tcase 'trimesh': {\n\t\t\tconst clonedGeometry = geometry.index ? geometry.clone() : mergeVertices(geometry);\n\n\t\t\treturn {\n\t\t\t\targs: [clonedGeometry.attributes['position'].array as Float32Array, clonedGeometry.index?.array as Uint32Array],\n\t\t\t\toffset: new Vector3(),\n\t\t\t};\n\t\t}\n\n\t\tcase 'hull': {\n\t\t\tconst clonedGeometry = geometry.clone();\n\t\t\treturn {\n\t\t\t\targs: [clonedGeometry.attributes['position'].array as Float32Array],\n\t\t\t\toffset: new Vector3(),\n\t\t\t};\n\t\t}\n\t}\n\n\treturn { args: [], offset: new Vector3() };\n}\n\nexport function createColliderOptions(object: Object3D, options: NgtrRigidBodyOptions, ignoreMeshColliders = true) {\n\tconst childColliderOptions: {\n\t\tcolliderOptions: NgtrColliderOptions;\n\t\targs: unknown[];\n\t\tshape: NgtrColliderShape;\n\t\trotation: NgtEuler;\n\t\tposition: NgtVector3;\n\t\tscale: NgtVector3;\n\t}[] = [];\n\tobject.updateWorldMatrix(true, false);\n\tconst invertedParentMatrixWorld = object.matrixWorld.clone().invert();\n\n\tconst colliderFromChild = (child: Object3D) => {\n\t\tif ((child as Mesh).isMesh) {\n\t\t\tif (ignoreMeshColliders && isChildOfMeshCollider(child as Mesh)) return;\n\n\t\t\tconst worldScale = child.getWorldScale(_scale);\n\t\t\tconst shape = autoColliderMap[options.colliders || 'cuboid'] as NgtrColliderShape;\n\t\t\tchild.updateWorldMatrix(true, false);\n\t\t\t_matrix4.copy(child.matrixWorld).premultiply(invertedParentMatrixWorld).decompose(_position, _rotation, _scale);\n\n\t\t\tconst rotationEuler = new Euler().setFromQuaternion(_rotation, 'XYZ');\n\n\t\t\tconst { geometry } = child as Mesh;\n\t\t\tconst { args, offset } = getColliderArgsFromGeometry(geometry, options.colliders || 'cuboid');\n\t\t\tconst { mass, linearDamping, angularDamping, canSleep, ccd, gravityScale, softCcdPrediction, ...rest } = options;\n\n\t\t\tchildColliderOptions.push({\n\t\t\t\tcolliderOptions: rest,\n\t\t\t\targs,\n\t\t\t\tshape,\n\t\t\t\trotation: [rotationEuler.x, rotationEuler.y, rotationEuler.z],\n\t\t\t\tposition: [\n\t\t\t\t\t_position.x + offset.x * worldScale.x,\n\t\t\t\t\t_position.y + offset.y * worldScale.y,\n\t\t\t\t\t_position.z + offset.z * worldScale.z,\n\t\t\t\t],\n\t\t\t\tscale: [worldScale.x, worldScale.y, worldScale.z],\n\t\t\t});\n\t\t}\n\t};\n\n\tif (options.includeInvisible) {\n\t\tobject.traverse(colliderFromChild);\n\t} else {\n\t\tobject.traverseVisible(colliderFromChild);\n\t}\n\n\treturn childColliderOptions;\n}\n"]}