@hellpig/anarchy-engine 21.3.0 → 21.4.1

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/dynamics/rigid_body.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rigid_body.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/rigid_body.js"],"sourcesContent":["import { RotationOps, VectorOps } from \"../math\";\n// #if DIM3\nimport { SdpMatrix3Ops } from \"../math\";\n/**\n * The simulation status of a rigid-body.\n */\n// TODO: rename this to RigidBodyType\nexport var RigidBodyType;\n(function (RigidBodyType) {\n    /**\n     * A `RigidBodyType::Dynamic` body can be affected by all external forces.\n     */\n    RigidBodyType[RigidBodyType[\"Dynamic\"] = 0] = \"Dynamic\";\n    /**\n     * A `RigidBodyType::Fixed` body cannot be affected by external forces.\n     */\n    RigidBodyType[RigidBodyType[\"Fixed\"] = 1] = \"Fixed\";\n    /**\n     * A `RigidBodyType::KinematicPositionBased` body cannot be affected by any external forces but can be controlled\n     * by the user at the position level while keeping realistic one-way interaction with dynamic bodies.\n     *\n     * One-way interaction means that a kinematic body can push a dynamic body, but a kinematic body\n     * cannot be pushed by anything. In other words, the trajectory of a kinematic body can only be\n     * modified by the user and is independent from any contact or joint it is involved in.\n     */\n    RigidBodyType[RigidBodyType[\"KinematicPositionBased\"] = 2] = \"KinematicPositionBased\";\n    /**\n     * A `RigidBodyType::KinematicVelocityBased` body cannot be affected by any external forces but can be controlled\n     * by the user at the velocity level while keeping realistic one-way interaction with dynamic bodies.\n     *\n     * One-way interaction means that a kinematic body can push a dynamic body, but a kinematic body\n     * cannot be pushed by anything. In other words, the trajectory of a kinematic body can only be\n     * modified by the user and is independent from any contact or joint it is involved in.\n     */\n    RigidBodyType[RigidBodyType[\"KinematicVelocityBased\"] = 3] = \"KinematicVelocityBased\";\n})(RigidBodyType || (RigidBodyType = {}));\n/**\n * A rigid-body.\n */\nexport class RigidBody {\n    constructor(rawSet, colliderSet, handle) {\n        this.rawSet = rawSet;\n        this.colliderSet = colliderSet;\n        this.handle = handle;\n    }\n    /** @internal */\n    finalizeDeserialization(colliderSet) {\n        this.colliderSet = colliderSet;\n    }\n    /**\n     * Checks if this rigid-body is still valid (i.e. that it has\n     * not been deleted from the rigid-body set yet.\n     */\n    isValid() {\n        return this.rawSet.contains(this.handle);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to translate.\n     *\n     * @param locked - If `true`, this rigid-body will no longer translate due to forces and impulses.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    lockTranslations(locked, wakeUp) {\n        return this.rawSet.rbLockTranslations(this.handle, locked, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to rotate.\n     *\n     * @param locked - If `true`, this rigid-body will no longer rotate due to torques and impulses.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    lockRotations(locked, wakeUp) {\n        return this.rawSet.rbLockRotations(this.handle, locked, wakeUp);\n    }\n    // #if DIM3\n    /**\n     * Locks or unlocks the ability of this rigid-body to translate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer translate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    setEnabledTranslations(enableX, enableY, enableZ, wakeUp) {\n        return this.rawSet.rbSetEnabledTranslations(this.handle, enableX, enableY, enableZ, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to translate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer translate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer translate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     * @deprecated use `this.setEnabledTranslations` with the same arguments instead.\n     */\n    restrictTranslations(enableX, enableY, enableZ, wakeUp) {\n        this.setEnabledTranslations(enableX, enableY, enableZ, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to rotate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     */\n    setEnabledRotations(enableX, enableY, enableZ, wakeUp) {\n        return this.rawSet.rbSetEnabledRotations(this.handle, enableX, enableY, enableZ, wakeUp);\n    }\n    /**\n     * Locks or unlocks the ability of this rigid-body to rotate along individual coordinate axes.\n     *\n     * @param enableX - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the X coordinate axis.\n     * @param enableY - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Y coordinate axis.\n     * @param enableZ - If `false`, this rigid-body will no longer rotate due to torques and impulses, along the Z coordinate axis.\n     * @param wakeUp - If `true`, this rigid-body will be automatically awaken if it is currently asleep.\n     * @deprecated use `this.setEnabledRotations` with the same arguments instead.\n     */\n    restrictRotations(enableX, enableY, enableZ, wakeUp) {\n        this.setEnabledRotations(enableX, enableY, enableZ, wakeUp);\n    }\n    // #endif\n    /**\n     * The dominance group, in [-127, +127] this rigid-body is part of.\n     */\n    dominanceGroup() {\n        return this.rawSet.rbDominanceGroup(this.handle);\n    }\n    /**\n     * Sets the dominance group of this rigid-body.\n     *\n     * @param group - The dominance group of this rigid-body. Must be a signed integer in the range [-127, +127].\n     */\n    setDominanceGroup(group) {\n        this.rawSet.rbSetDominanceGroup(this.handle, group);\n    }\n    /**\n     * The number of additional solver iterations that will be run for this\n     * rigid-body and everything that interacts with it directly or indirectly\n     * through contacts or joints.\n     */\n    additionalSolverIterations() {\n        return this.rawSet.rbAdditionalSolverIterations(this.handle);\n    }\n    /**\n     * Sets the number of additional solver iterations that will be run for this\n     * rigid-body and everything that interacts with it directly or indirectly\n     * through contacts or joints.\n     *\n     * Compared to increasing the global `World.numSolverIteration`, setting this\n     * value lets you increase accuracy on only a subset of the scene, resulting in reduced\n     * performance loss.\n     *\n     * @param iters - The new number of additional solver iterations (default: 0).\n     */\n    setAdditionalSolverIterations(iters) {\n        this.rawSet.rbSetAdditionalSolverIterations(this.handle, iters);\n    }\n    /**\n     * Enable or disable CCD (Continuous Collision Detection) for this rigid-body.\n     *\n     * @param enabled - If `true`, CCD will be enabled for this rigid-body.\n     */\n    enableCcd(enabled) {\n        this.rawSet.rbEnableCcd(this.handle, enabled);\n    }\n    /**\n     * Sets the soft-CCD prediction distance for this rigid-body.\n     *\n     * See the documentation of `RigidBodyDesc.setSoftCcdPrediction` for\n     * additional details.\n     */\n    setSoftCcdPrediction(distance) {\n        this.rawSet.rbSetSoftCcdPrediction(this.handle, distance);\n    }\n    /**\n     * Gets the soft-CCD prediction distance for this rigid-body.\n     *\n     * See the documentation of `RigidBodyDesc.setSoftCcdPrediction` for\n     * additional details.\n     */\n    softCcdPrediction() {\n        return this.rawSet.rbSoftCcdPrediction(this.handle);\n    }\n    /**\n     * The world-space translation of this rigid-body.\n     */\n    translation() {\n        let res = this.rawSet.rbTranslation(this.handle);\n        return VectorOps.fromRaw(res);\n    }\n    /**\n     * The world-space orientation of this rigid-body.\n     */\n    rotation() {\n        let res = this.rawSet.rbRotation(this.handle);\n        return RotationOps.fromRaw(res);\n    }\n    /**\n     * The world-space next translation of this rigid-body.\n     *\n     * If this rigid-body is kinematic this value is set by the `setNextKinematicTranslation`\n     * method and is used for estimating the kinematic body velocity at the next timestep.\n     * For non-kinematic bodies, this value is currently unspecified.\n     */\n    nextTranslation() {\n        let res = this.rawSet.rbNextTranslation(this.handle);\n        return VectorOps.fromRaw(res);\n    }\n    /**\n     * The world-space next orientation of this rigid-body.\n     *\n     * If this rigid-body is kinematic this value is set by the `setNextKinematicRotation`\n     * method and is used for estimating the kinematic body velocity at the next timestep.\n     * For non-kinematic bodies, this value is currently unspecified.\n     */\n    nextRotation() {\n        let res = this.rawSet.rbNextRotation(this.handle);\n        return RotationOps.fromRaw(res);\n    }\n    /**\n     * Sets the translation of this rigid-body.\n     *\n     * @param tra - The world-space position of the rigid-body.\n     * @param wakeUp - Forces the rigid-body to wake-up so it is properly affected by forces if it\n     *                 wasn't moving before modifying its position.\n     */\n    setTranslation(tra, wakeUp) {\n        // #if DIM3\n        this.rawSet.rbSetTranslation(this.handle, tra.x, tra.y, tra.z, wakeUp);\n        // #endif\n    }\n    /**\n     * Sets the linear velocity of this rigid-body.\n     *\n     * @param vel - The linear velocity to set.\n     * @param wakeUp - Forces the rigid-body to wake-up if it was asleep.\n     */\n    setLinvel(vel, wakeUp) {\n        let rawVel = VectorOps.intoRaw(vel);\n        this.rawSet.rbSetLinvel(this.handle, rawVel, wakeUp);\n        rawVel.free();\n    }\n    /**\n     * The scale factor applied to the gravity affecting\n     * this rigid-body.\n     */\n    gravityScale() {\n        return this.rawSet.rbGravityScale(this.handle);\n    }\n    /**\n     * Sets the scale factor applied to the gravity affecting\n     * this rigid-body.\n     *\n     * @param factor - The scale factor to set. A value of 0.0 means\n     *   that this rigid-body will on longer be affected by gravity.\n     * @param wakeUp - Forces the rigid-body to wake-up if it was asleep.\n     */\n    setGravityScale(factor, wakeUp) {\n        this.rawSet.rbSetGravityScale(this.handle, factor, wakeUp);\n    }\n    // #if DIM3\n    /**\n     * Sets the rotation quaternion of this rigid-body.\n     *\n     * This does nothing if a zero quaternion is provided.\n     *\n     * @param rotation - The rotation to set.\n     * @param wakeUp - Forces the rigid-body to wake-up so it is properly affected by forces if it\n     * wasn't moving before modifying its position.\n     */\n    setRotation(rot, wakeUp) {\n        this.rawSet.rbSetRotation(this.handle, rot.x, rot.y, rot.z, rot.w, wakeUp);\n    }\n    /**\n     * Sets the angular velocity fo this rigid-body.\n     *\n     * @param vel - The angular velocity to set.\n     * @param wakeUp - Forces the rigid-body to wake-up if it was asleep.\n     */\n    setAngvel(vel, wakeUp) {\n        let rawVel = VectorOps.intoRaw(vel);\n        this.rawSet.rbSetAngvel(this.handle, rawVel, wakeUp);\n        rawVel.free();\n    }\n    // #endif\n    /**\n     * If this rigid body is kinematic, sets its future translation after the next timestep integration.\n     *\n     * This should be used instead of `rigidBody.setTranslation` to make the dynamic object\n     * interacting with this kinematic body behave as expected. Internally, Rapier will compute\n     * an artificial velocity for this rigid-body from its current position and its next kinematic\n     * position. This velocity will be used to compute forces on dynamic bodies interacting with\n     * this body.\n     *\n     * @param t - The kinematic translation to set.\n     */\n    setNextKinematicTranslation(t) {\n        // #if DIM3\n        this.rawSet.rbSetNextKinematicTranslation(this.handle, t.x, t.y, t.z);\n        // #endif\n    }\n    // #if DIM3\n    /**\n     * If this rigid body is kinematic, sets its future rotation after the next timestep integration.\n     *\n     * This should be used instead of `rigidBody.setRotation` to make the dynamic object\n     * interacting with this kinematic body behave as expected. Internally, Rapier will compute\n     * an artificial velocity for this rigid-body from its current position and its next kinematic\n     * position. This velocity will be used to compute forces on dynamic bodies interacting with\n     * this body.\n     *\n     * @param rot - The kinematic rotation to set.\n     */\n    setNextKinematicRotation(rot) {\n        this.rawSet.rbSetNextKinematicRotation(this.handle, rot.x, rot.y, rot.z, rot.w);\n    }\n    // #endif\n    /**\n     * The linear velocity of this rigid-body.\n     */\n    linvel() {\n        return VectorOps.fromRaw(this.rawSet.rbLinvel(this.handle));\n    }\n    /**\n     * The velocity of the given world-space point on this rigid-body.\n     */\n    velocityAtPoint(point) {\n        const rawPoint = VectorOps.intoRaw(point);\n        let result = VectorOps.fromRaw(this.rawSet.rbVelocityAtPoint(this.handle, rawPoint));\n        rawPoint.free();\n        return result;\n    }\n    // #if DIM3\n    /**\n     * The angular velocity of this rigid-body.\n     */\n    angvel() {\n        return VectorOps.fromRaw(this.rawSet.rbAngvel(this.handle));\n    }\n    // #endif\n    /**\n     * The mass of this rigid-body.\n     */\n    mass() {\n        return this.rawSet.rbMass(this.handle);\n    }\n    /**\n     * The inverse mass taking into account translation locking.\n     */\n    effectiveInvMass() {\n        return VectorOps.fromRaw(this.rawSet.rbEffectiveInvMass(this.handle));\n    }\n    /**\n     * The inverse of the mass of a rigid-body.\n     *\n     * If this is zero, the rigid-body is assumed to have infinite mass.\n     */\n    invMass() {\n        return this.rawSet.rbInvMass(this.handle);\n    }\n    /**\n     * The center of mass of a rigid-body expressed in its local-space.\n     */\n    localCom() {\n        return VectorOps.fromRaw(this.rawSet.rbLocalCom(this.handle));\n    }\n    /**\n     * The world-space center of mass of the rigid-body.\n     */\n    worldCom() {\n        return VectorOps.fromRaw(this.rawSet.rbWorldCom(this.handle));\n    }\n    // #if DIM3\n    /**\n     * The inverse of the principal angular inertia of the rigid-body.\n     *\n     * Components set to zero are assumed to be infinite along the corresponding principal axis.\n     */\n    invPrincipalInertia() {\n        return VectorOps.fromRaw(this.rawSet.rbInvPrincipalInertia(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The angular inertia along the principal inertia axes of the rigid-body.\n     */\n    principalInertia() {\n        return VectorOps.fromRaw(this.rawSet.rbPrincipalInertia(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The principal vectors of the local angular inertia tensor of the rigid-body.\n     */\n    principalInertiaLocalFrame() {\n        return RotationOps.fromRaw(this.rawSet.rbPrincipalInertiaLocalFrame(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The world-space inverse angular inertia tensor of the rigid-body,\n     * taking into account rotation locking.\n     */\n    effectiveWorldInvInertia() {\n        return SdpMatrix3Ops.fromRaw(this.rawSet.rbEffectiveWorldInvInertia(this.handle));\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * The effective world-space angular inertia (that takes the potential rotation locking into account) of\n     * this rigid-body.\n     */\n    effectiveAngularInertia() {\n        return SdpMatrix3Ops.fromRaw(this.rawSet.rbEffectiveAngularInertia(this.handle));\n    }\n    // #endif\n    /**\n     * Put this rigid body to sleep.\n     *\n     * A sleeping body no longer moves and is no longer simulated by the physics engine unless\n     * it is waken up. It can be woken manually with `this.wakeUp()` or automatically due to\n     * external forces like contacts.\n     */\n    sleep() {\n        this.rawSet.rbSleep(this.handle);\n    }\n    /**\n     * Wakes this rigid-body up.\n     *\n     * A dynamic rigid-body that does not move during several consecutive frames will\n     * be put to sleep by the physics engine, i.e., it will stop being simulated in order\n     * to avoid useless computations.\n     * This methods forces a sleeping rigid-body to wake-up. This is useful, e.g., before modifying\n     * the position of a dynamic body so that it is properly simulated afterwards.\n     */\n    wakeUp() {\n        this.rawSet.rbWakeUp(this.handle);\n    }\n    /**\n     * Is CCD enabled for this rigid-body?\n     */\n    isCcdEnabled() {\n        return this.rawSet.rbIsCcdEnabled(this.handle);\n    }\n    /**\n     * The number of colliders attached to this rigid-body.\n     */\n    numColliders() {\n        return this.rawSet.rbNumColliders(this.handle);\n    }\n    /**\n     * Retrieves the `i-th` collider attached to this rigid-body.\n     *\n     * @param i - The index of the collider to retrieve. Must be a number in `[0, this.numColliders()[`.\n     *         This index is **not** the same as the unique identifier of the collider.\n     */\n    collider(i) {\n        return this.colliderSet.get(this.rawSet.rbCollider(this.handle, i));\n    }\n    /**\n     * Sets whether this rigid-body is enabled or not.\n     *\n     * @param enabled - Set to `false` to disable this rigid-body and all its attached colliders.\n     */\n    setEnabled(enabled) {\n        this.rawSet.rbSetEnabled(this.handle, enabled);\n    }\n    /**\n     * Is this rigid-body enabled?\n     */\n    isEnabled() {\n        return this.rawSet.rbIsEnabled(this.handle);\n    }\n    /**\n     * The status of this rigid-body: static, dynamic, or kinematic.\n     */\n    bodyType() {\n        return this.rawSet.rbBodyType(this.handle);\n    }\n    /**\n     * Set a new status for this rigid-body: static, dynamic, or kinematic.\n     */\n    setBodyType(type, wakeUp) {\n        return this.rawSet.rbSetBodyType(this.handle, type, wakeUp);\n    }\n    /**\n     * Is this rigid-body sleeping?\n     */\n    isSleeping() {\n        return this.rawSet.rbIsSleeping(this.handle);\n    }\n    /**\n     * Is the velocity of this rigid-body not zero?\n     */\n    isMoving() {\n        return this.rawSet.rbIsMoving(this.handle);\n    }\n    /**\n     * Is this rigid-body static?\n     */\n    isFixed() {\n        return this.rawSet.rbIsFixed(this.handle);\n    }\n    /**\n     * Is this rigid-body kinematic?\n     */\n    isKinematic() {\n        return this.rawSet.rbIsKinematic(this.handle);\n    }\n    /**\n     * Is this rigid-body dynamic?\n     */\n    isDynamic() {\n        return this.rawSet.rbIsDynamic(this.handle);\n    }\n    /**\n     * The linear damping coefficient of this rigid-body.\n     */\n    linearDamping() {\n        return this.rawSet.rbLinearDamping(this.handle);\n    }\n    /**\n     * The angular damping coefficient of this rigid-body.\n     */\n    angularDamping() {\n        return this.rawSet.rbAngularDamping(this.handle);\n    }\n    /**\n     * Sets the linear damping factor applied to this rigid-body.\n     *\n     * @param factor - The damping factor to set.\n     */\n    setLinearDamping(factor) {\n        this.rawSet.rbSetLinearDamping(this.handle, factor);\n    }\n    /**\n     * Recompute the mass-properties of this rigid-bodies based on its currently attached colliders.\n     */\n    recomputeMassPropertiesFromColliders() {\n        this.rawSet.rbRecomputeMassPropertiesFromColliders(this.handle, this.colliderSet.raw);\n    }\n    /**\n     * Sets the rigid-body's additional mass.\n     *\n     * The total angular inertia of the rigid-body will be scaled automatically based on this additional mass. If this\n     * scaling effect isn’t desired, use Self::additional_mass_properties instead of this method.\n     *\n     * This is only the \"additional\" mass because the total mass of the rigid-body is equal to the sum of this\n     * additional mass and the mass computed from the colliders (with non-zero densities) attached to this rigid-body.\n     *\n     * That total mass (which includes the attached colliders’ contributions) will be updated at the name physics step,\n     * or can be updated manually with `this.recomputeMassPropertiesFromColliders`.\n     *\n     * This will override any previous additional mass-properties set by `this.setAdditionalMass`,\n     * `this.setAdditionalMassProperties`, `RigidBodyDesc::setAdditionalMass`, or\n     * `RigidBodyDesc.setAdditionalMassfProperties` for this rigid-body.\n     *\n     * @param mass - The additional mass to set.\n     * @param wakeUp - If `true` then the rigid-body will be woken up if it was put to sleep because it did not move for a while.\n     */\n    setAdditionalMass(mass, wakeUp) {\n        this.rawSet.rbSetAdditionalMass(this.handle, mass, wakeUp);\n    }\n    // #if DIM3\n    /**\n     * Sets the rigid-body's additional mass-properties.\n     *\n     * This is only the \"additional\" mass-properties because the total mass-properties of the rigid-body is equal to the\n     * sum of this additional mass-properties and the mass computed from the colliders (with non-zero densities) attached\n     * to this rigid-body.\n     *\n     * That total mass-properties (which include the attached colliders’ contributions) will be updated at the name\n     * physics step, or can be updated manually with `this.recomputeMassPropertiesFromColliders`.\n     *\n     * This will override any previous mass-properties set by `this.setAdditionalMass`,\n     * `this.setAdditionalMassProperties`, `RigidBodyDesc.setAdditionalMass`, or `RigidBodyDesc.setAdditionalMassProperties`\n     * for this rigid-body.\n     *\n     * If `wake_up` is true then the rigid-body will be woken up if it was put to sleep because it did not move for a while.\n     */\n    setAdditionalMassProperties(mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame, wakeUp) {\n        let rawCom = VectorOps.intoRaw(centerOfMass);\n        let rawPrincipalInertia = VectorOps.intoRaw(principalAngularInertia);\n        let rawInertiaFrame = RotationOps.intoRaw(angularInertiaLocalFrame);\n        this.rawSet.rbSetAdditionalMassProperties(this.handle, mass, rawCom, rawPrincipalInertia, rawInertiaFrame, wakeUp);\n        rawCom.free();\n        rawPrincipalInertia.free();\n        rawInertiaFrame.free();\n    }\n    // #endif\n    /**\n     * Sets the linear damping factor applied to this rigid-body.\n     *\n     * @param factor - The damping factor to set.\n     */\n    setAngularDamping(factor) {\n        this.rawSet.rbSetAngularDamping(this.handle, factor);\n    }\n    /**\n     * Resets to zero the user forces (but not torques) applied to this rigid-body.\n     *\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    resetForces(wakeUp) {\n        this.rawSet.rbResetForces(this.handle, wakeUp);\n    }\n    /**\n     * Resets to zero the user torques applied to this rigid-body.\n     *\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    resetTorques(wakeUp) {\n        this.rawSet.rbResetTorques(this.handle, wakeUp);\n    }\n    /**\n     * Adds a force at the center-of-mass of this rigid-body.\n     *\n     * @param force - the world-space force to add to the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    addForce(force, wakeUp) {\n        const rawForce = VectorOps.intoRaw(force);\n        this.rawSet.rbAddForce(this.handle, rawForce, wakeUp);\n        rawForce.free();\n    }\n    /**\n     * Applies an impulse at the center-of-mass of this rigid-body.\n     *\n     * @param impulse - the world-space impulse to apply on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    applyImpulse(impulse, wakeUp) {\n        const rawImpulse = VectorOps.intoRaw(impulse);\n        this.rawSet.rbApplyImpulse(this.handle, rawImpulse, wakeUp);\n        rawImpulse.free();\n    }\n    // #if DIM3\n    /**\n     * Adds a torque at the center-of-mass of this rigid-body.\n     *\n     * @param torque - the world-space torque to add to the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    addTorque(torque, wakeUp) {\n        const rawTorque = VectorOps.intoRaw(torque);\n        this.rawSet.rbAddTorque(this.handle, rawTorque, wakeUp);\n        rawTorque.free();\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * Applies an impulsive torque at the center-of-mass of this rigid-body.\n     *\n     * @param torqueImpulse - the world-space torque impulse to apply on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    applyTorqueImpulse(torqueImpulse, wakeUp) {\n        const rawTorqueImpulse = VectorOps.intoRaw(torqueImpulse);\n        this.rawSet.rbApplyTorqueImpulse(this.handle, rawTorqueImpulse, wakeUp);\n        rawTorqueImpulse.free();\n    }\n    // #endif\n    /**\n     * Adds a force at the given world-space point of this rigid-body.\n     *\n     * @param force - the world-space force to add to the rigid-body.\n     * @param point - the world-space point where the impulse is to be applied on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    addForceAtPoint(force, point, wakeUp) {\n        const rawForce = VectorOps.intoRaw(force);\n        const rawPoint = VectorOps.intoRaw(point);\n        this.rawSet.rbAddForceAtPoint(this.handle, rawForce, rawPoint, wakeUp);\n        rawForce.free();\n        rawPoint.free();\n    }\n    /**\n     * Applies an impulse at the given world-space point of this rigid-body.\n     *\n     * @param impulse - the world-space impulse to apply on the rigid-body.\n     * @param point - the world-space point where the impulse is to be applied on the rigid-body.\n     * @param wakeUp - should the rigid-body be automatically woken-up?\n     */\n    applyImpulseAtPoint(impulse, point, wakeUp) {\n        const rawImpulse = VectorOps.intoRaw(impulse);\n        const rawPoint = VectorOps.intoRaw(point);\n        this.rawSet.rbApplyImpulseAtPoint(this.handle, rawImpulse, rawPoint, wakeUp);\n        rawImpulse.free();\n        rawPoint.free();\n    }\n    /**\n     * Retrieves the constant force(s) the user added to this rigid-body\n     * Returns zero if the rigid-body is not dynamic.\n     */\n    userForce() {\n        return VectorOps.fromRaw(this.rawSet.rbUserForce(this.handle));\n    }\n    // #if DIM3\n    /**\n     * Retrieves the constant torque(s) the user added to this rigid-body\n     * Returns zero if the rigid-body is not dynamic.\n     */\n    userTorque() {\n        return VectorOps.fromRaw(this.rawSet.rbUserTorque(this.handle));\n    }\n}\nexport class RigidBodyDesc {\n    constructor(status) {\n        this.enabled = true;\n        this.status = status;\n        this.translation = VectorOps.zeros();\n        this.rotation = RotationOps.identity();\n        this.gravityScale = 1.0;\n        this.linvel = VectorOps.zeros();\n        this.mass = 0.0;\n        this.massOnly = false;\n        this.centerOfMass = VectorOps.zeros();\n        this.translationsEnabledX = true;\n        this.translationsEnabledY = true;\n        // #if DIM3\n        this.angvel = VectorOps.zeros();\n        this.principalAngularInertia = VectorOps.zeros();\n        this.angularInertiaLocalFrame = RotationOps.identity();\n        this.translationsEnabledZ = true;\n        this.rotationsEnabledX = true;\n        this.rotationsEnabledY = true;\n        this.rotationsEnabledZ = true;\n        // #endif\n        this.linearDamping = 0.0;\n        this.angularDamping = 0.0;\n        this.canSleep = true;\n        this.sleeping = false;\n        this.ccdEnabled = false;\n        this.softCcdPrediction = 0.0;\n        this.dominanceGroup = 0;\n        this.additionalSolverIterations = 0;\n    }\n    /**\n     * A rigid-body descriptor used to build a dynamic rigid-body.\n     */\n    static dynamic() {\n        return new RigidBodyDesc(RigidBodyType.Dynamic);\n    }\n    /**\n     * A rigid-body descriptor used to build a position-based kinematic rigid-body.\n     */\n    static kinematicPositionBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicPositionBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a velocity-based kinematic rigid-body.\n     */\n    static kinematicVelocityBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicVelocityBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a fixed rigid-body.\n     */\n    static fixed() {\n        return new RigidBodyDesc(RigidBodyType.Fixed);\n    }\n    /**\n     * A rigid-body descriptor used to build a dynamic rigid-body.\n     *\n     * @deprecated The method has been renamed to `.dynamic()`.\n     */\n    static newDynamic() {\n        return new RigidBodyDesc(RigidBodyType.Dynamic);\n    }\n    /**\n     * A rigid-body descriptor used to build a position-based kinematic rigid-body.\n     *\n     * @deprecated The method has been renamed to `.kinematicPositionBased()`.\n     */\n    static newKinematicPositionBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicPositionBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a velocity-based kinematic rigid-body.\n     *\n     * @deprecated The method has been renamed to `.kinematicVelocityBased()`.\n     */\n    static newKinematicVelocityBased() {\n        return new RigidBodyDesc(RigidBodyType.KinematicVelocityBased);\n    }\n    /**\n     * A rigid-body descriptor used to build a fixed rigid-body.\n     *\n     * @deprecated The method has been renamed to `.fixed()`.\n     */\n    static newStatic() {\n        return new RigidBodyDesc(RigidBodyType.Fixed);\n    }\n    setDominanceGroup(group) {\n        this.dominanceGroup = group;\n        return this;\n    }\n    /**\n     * Sets the number of additional solver iterations that will be run for this\n     * rigid-body and everything that interacts with it directly or indirectly\n     * through contacts or joints.\n     *\n     * Compared to increasing the global `World.numSolverIteration`, setting this\n     * value lets you increase accuracy on only a subset of the scene, resulting in reduced\n     * performance loss.\n     *\n     * @param iters - The new number of additional solver iterations (default: 0).\n     */\n    setAdditionalSolverIterations(iters) {\n        this.additionalSolverIterations = iters;\n        return this;\n    }\n    /**\n     * Sets whether the created rigid-body will be enabled or disabled.\n     * @param enabled − If set to `false` the rigid-body will be disabled at creation.\n     */\n    setEnabled(enabled) {\n        this.enabled = enabled;\n        return this;\n    }\n    // #if DIM3\n    /**\n     * Sets the initial translation of the rigid-body to create.\n     *\n     * @param tra - The translation to set.\n     */\n    setTranslation(x, y, z) {\n        if (typeof x != \"number\" ||\n            typeof y != \"number\" ||\n            typeof z != \"number\")\n            throw TypeError(\"The translation components must be numbers.\");\n        this.translation = { x: x, y: y, z: z };\n        return this;\n    }\n    // #endif\n    /**\n     * Sets the initial rotation of the rigid-body to create.\n     *\n     * @param rot - The rotation to set.\n     */\n    setRotation(rot) {\n        // #if DIM3\n        RotationOps.copy(this.rotation, rot);\n        // #endif\n        return this;\n    }\n    /**\n     * Sets the scale factor applied to the gravity affecting\n     * the rigid-body being built.\n     *\n     * @param scale - The scale factor. Set this to `0.0` if the rigid-body\n     *   needs to ignore gravity.\n     */\n    setGravityScale(scale) {\n        this.gravityScale = scale;\n        return this;\n    }\n    /**\n     * Sets the initial mass of the rigid-body being built, before adding colliders' contributions.\n     *\n     * @param mass − The initial mass of the rigid-body to create.\n     */\n    setAdditionalMass(mass) {\n        this.mass = mass;\n        this.massOnly = true;\n        return this;\n    }\n    // #if DIM3\n    /**\n     * Sets the initial linear velocity of the rigid-body to create.\n     *\n     * @param x - The linear velocity to set along the `x` axis.\n     * @param y - The linear velocity to set along the `y` axis.\n     * @param z - The linear velocity to set along the `z` axis.\n     */\n    setLinvel(x, y, z) {\n        if (typeof x != \"number\" ||\n            typeof y != \"number\" ||\n            typeof z != \"number\")\n            throw TypeError(\"The linvel components must be numbers.\");\n        this.linvel = { x: x, y: y, z: z };\n        return this;\n    }\n    /**\n     * Sets the initial angular velocity of the rigid-body to create.\n     *\n     * @param vel - The angular velocity to set.\n     */\n    setAngvel(vel) {\n        VectorOps.copy(this.angvel, vel);\n        return this;\n    }\n    /**\n     * Sets the mass properties of the rigid-body being built.\n     *\n     * Note that the final mass properties of the rigid-bodies depends\n     * on the initial mass-properties of the rigid-body (set by this method)\n     * to which is added the contributions of all the colliders with non-zero density\n     * attached to this rigid-body.\n     *\n     * Therefore, if you want your provided mass properties to be the final\n     * mass properties of your rigid-body, don't attach colliders to it, or\n     * only attach colliders with densities equal to zero.\n     *\n     * @param mass − The initial mass of the rigid-body to create.\n     * @param centerOfMass − The initial center-of-mass of the rigid-body to create.\n     * @param principalAngularInertia − The initial principal angular inertia of the rigid-body to create.\n     *                                  These are the eigenvalues of the angular inertia matrix.\n     * @param angularInertiaLocalFrame − The initial local angular inertia frame of the rigid-body to create.\n     *                                   These are the eigenvectors of the angular inertia matrix.\n     */\n    setAdditionalMassProperties(mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame) {\n        this.mass = mass;\n        VectorOps.copy(this.centerOfMass, centerOfMass);\n        VectorOps.copy(this.principalAngularInertia, principalAngularInertia);\n        RotationOps.copy(this.angularInertiaLocalFrame, angularInertiaLocalFrame);\n        this.massOnly = false;\n        return this;\n    }\n    /**\n     * Allow translation of this rigid-body only along specific axes.\n     * @param translationsEnabledX - Are translations along the X axis enabled?\n     * @param translationsEnabledY - Are translations along the y axis enabled?\n     * @param translationsEnabledZ - Are translations along the Z axis enabled?\n     */\n    enabledTranslations(translationsEnabledX, translationsEnabledY, translationsEnabledZ) {\n        this.translationsEnabledX = translationsEnabledX;\n        this.translationsEnabledY = translationsEnabledY;\n        this.translationsEnabledZ = translationsEnabledZ;\n        return this;\n    }\n    /**\n     * Allow translation of this rigid-body only along specific axes.\n     * @param translationsEnabledX - Are translations along the X axis enabled?\n     * @param translationsEnabledY - Are translations along the y axis enabled?\n     * @param translationsEnabledZ - Are translations along the Z axis enabled?\n     * @deprecated use `this.enabledTranslations` with the same arguments instead.\n     */\n    restrictTranslations(translationsEnabledX, translationsEnabledY, translationsEnabledZ) {\n        return this.enabledTranslations(translationsEnabledX, translationsEnabledY, translationsEnabledZ);\n    }\n    /**\n     * Locks all translations that would have resulted from forces on\n     * the created rigid-body.\n     */\n    lockTranslations() {\n        return this.enabledTranslations(false, false, false);\n    }\n    /**\n     * Allow rotation of this rigid-body only along specific axes.\n     * @param rotationsEnabledX - Are rotations along the X axis enabled?\n     * @param rotationsEnabledY - Are rotations along the y axis enabled?\n     * @param rotationsEnabledZ - Are rotations along the Z axis enabled?\n     */\n    enabledRotations(rotationsEnabledX, rotationsEnabledY, rotationsEnabledZ) {\n        this.rotationsEnabledX = rotationsEnabledX;\n        this.rotationsEnabledY = rotationsEnabledY;\n        this.rotationsEnabledZ = rotationsEnabledZ;\n        return this;\n    }\n    /**\n     * Allow rotation of this rigid-body only along specific axes.\n     * @param rotationsEnabledX - Are rotations along the X axis enabled?\n     * @param rotationsEnabledY - Are rotations along the y axis enabled?\n     * @param rotationsEnabledZ - Are rotations along the Z axis enabled?\n     * @deprecated use `this.enabledRotations` with the same arguments instead.\n     */\n    restrictRotations(rotationsEnabledX, rotationsEnabledY, rotationsEnabledZ) {\n        return this.enabledRotations(rotationsEnabledX, rotationsEnabledY, rotationsEnabledZ);\n    }\n    /**\n     * Locks all rotations that would have resulted from forces on\n     * the created rigid-body.\n     */\n    lockRotations() {\n        return this.restrictRotations(false, false, false);\n    }\n    // #endif\n    /**\n     * Sets the linear damping of the rigid-body to create.\n     *\n     * This will progressively slowdown the translational movement of the rigid-body.\n     *\n     * @param damping - The angular damping coefficient. Should be >= 0. The higher this\n     *                  value is, the stronger the translational slowdown will be.\n     */\n    setLinearDamping(damping) {\n        this.linearDamping = damping;\n        return this;\n    }\n    /**\n     * Sets the angular damping of the rigid-body to create.\n     *\n     * This will progressively slowdown the rotational movement of the rigid-body.\n     *\n     * @param damping - The angular damping coefficient. Should be >= 0. The higher this\n     *                  value is, the stronger the rotational slowdown will be.\n     */\n    setAngularDamping(damping) {\n        this.angularDamping = damping;\n        return this;\n    }\n    /**\n     * Sets whether or not the rigid-body to create can sleep.\n     *\n     * @param can - true if the rigid-body can sleep, false if it can't.\n     */\n    setCanSleep(can) {\n        this.canSleep = can;\n        return this;\n    }\n    /**\n     * Sets whether or not the rigid-body is to be created asleep.\n     *\n     * @param can - true if the rigid-body should be in sleep, default false.\n     */\n    setSleeping(sleeping) {\n        this.sleeping = sleeping;\n        return this;\n    }\n    /**\n     * Sets whether Continuous Collision Detection (CCD) is enabled for this rigid-body.\n     *\n     * @param enabled - true if the rigid-body has CCD enabled.\n     */\n    setCcdEnabled(enabled) {\n        this.ccdEnabled = enabled;\n        return this;\n    }\n    /**\n     * Sets the maximum prediction distance Soft Continuous Collision-Detection.\n     *\n     * When set to 0, soft-CCD is disabled. Soft-CCD helps prevent tunneling especially of\n     * slow-but-thin to moderately fast objects. The soft CCD prediction distance indicates how\n     * far in the object’s path the CCD algorithm is allowed to inspect. Large values can impact\n     * performance badly by increasing the work needed from the broad-phase.\n     *\n     * It is a generally cheaper variant of regular CCD (that can be enabled with\n     * `RigidBodyDesc::setCcdEnabled` since it relies on predictive constraints instead of\n     * shape-cast and substeps.\n     */\n    setSoftCcdPrediction(distance) {\n        this.softCcdPrediction = distance;\n        return this;\n    }\n    /**\n     * Sets the user-defined object of this rigid-body.\n     *\n     * @param userData - The user-defined object to set.\n     */\n    setUserData(data) {\n        this.userData = data;\n        return this;\n    }\n}\n//# sourceMappingURL=rigid_body.js.map"],"names":["RigidBodyType","RigidBody","constructor","rawSet","colliderSet","handle","this","finalizeDeserialization","isValid","contains","lockTranslations","locked","wakeUp","rbLockTranslations","lockRotations","rbLockRotations","setEnabledTranslations","enableX","enableY","enableZ","rbSetEnabledTranslations","restrictTranslations","setEnabledRotations","rbSetEnabledRotations","restrictRotations","dominanceGroup","rbDominanceGroup","setDominanceGroup","group","rbSetDominanceGroup","additionalSolverIterations","rbAdditionalSolverIterations","setAdditionalSolverIterations","iters","rbSetAdditionalSolverIterations","enableCcd","enabled","rbEnableCcd","setSoftCcdPrediction","distance","rbSetSoftCcdPrediction","softCcdPrediction","rbSoftCcdPrediction","translation","res","rbTranslation","VectorOps","fromRaw","rotation","rbRotation","RotationOps","nextTranslation","rbNextTranslation","nextRotation","rbNextRotation","setTranslation","tra","rbSetTranslation","x","y","z","setLinvel","vel","rawVel","intoRaw","rbSetLinvel","free","gravityScale","rbGravityScale","setGravityScale","factor","rbSetGravityScale","setRotation","rot","rbSetRotation","w","setAngvel","rbSetAngvel","setNextKinematicTranslation","t","rbSetNextKinematicTranslation","setNextKinematicRotation","rbSetNextKinematicRotation","linvel","rbLinvel","velocityAtPoint","point","rawPoint","result","rbVelocityAtPoint","angvel","rbAngvel","mass","rbMass","effectiveInvMass","rbEffectiveInvMass","invMass","rbInvMass","localCom","rbLocalCom","worldCom","rbWorldCom","invPrincipalInertia","rbInvPrincipalInertia","principalInertia","rbPrincipalInertia","principalInertiaLocalFrame","rbPrincipalInertiaLocalFrame","effectiveWorldInvInertia","SdpMatrix3Ops","rbEffectiveWorldInvInertia","effectiveAngularInertia","rbEffectiveAngularInertia","sleep","rbSleep","rbWakeUp","isCcdEnabled","rbIsCcdEnabled","numColliders","rbNumColliders","collider","i","get","rbCollider","setEnabled","rbSetEnabled","isEnabled","rbIsEnabled","bodyType","rbBodyType","setBodyType","type","rbSetBodyType","isSleeping","rbIsSleeping","isMoving","rbIsMoving","isFixed","rbIsFixed","isKinematic","rbIsKinematic","isDynamic","rbIsDynamic","linearDamping","rbLinearDamping","angularDamping","rbAngularDamping","setLinearDamping","rbSetLinearDamping","recomputeMassPropertiesFromColliders","rbRecomputeMassPropertiesFromColliders","raw","setAdditionalMass","rbSetAdditionalMass","setAdditionalMassProperties","centerOfMass","principalAngularInertia","angularInertiaLocalFrame","rawCom","rawPrincipalInertia","rawInertiaFrame","rbSetAdditionalMassProperties","setAngularDamping","rbSetAngularDamping","resetForces","rbResetForces","resetTorques","rbResetTorques","addForce","force","rawForce","rbAddForce","applyImpulse","impulse","rawImpulse","rbApplyImpulse","addTorque","torque","rawTorque","rbAddTorque","applyTorqueImpulse","torqueImpulse","rawTorqueImpulse","rbApplyTorqueImpulse","addForceAtPoint","rbAddForceAtPoint","applyImpulseAtPoint","rbApplyImpulseAtPoint","userForce","rbUserForce","userTorque","rbUserTorque","RigidBodyDesc","status","zeros","identity","massOnly","translationsEnabledX","translationsEnabledY","translationsEnabledZ","rotationsEnabledX","rotationsEnabledY","rotationsEnabledZ","canSleep","sleeping","ccdEnabled","dynamic","Dynamic","kinematicPositionBased","KinematicPositionBased","kinematicVelocityBased","KinematicVelocityBased","fixed","Fixed","newDynamic","newKinematicPositionBased","newKinematicVelocityBased","newStatic","TypeError","copy","scale","enabledTranslations","enabledRotations","damping","setCanSleep","can","setSleeping","setCcdEnabled","setUserData","data","userData"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/dynamics/rigid_body_set.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";import{Coarena}from"../coarena.js";import{VectorOps,RotationOps}from"../math.js";import{RigidBody}from"./rigid_body.js";import{RawRigidBodySet}from"../rapier_wasm3d_bg.js";class RigidBodySet{free(){this.raw&&this.raw.free(),this.raw=void 0,this.map&&this.map.clear(),this.map=void 0}constructor(raw){this.raw=raw||new RawRigidBodySet,this.map=new Coarena,raw&&raw.forEachRigidBodyHandle(handle=>{this.map.set(handle,new RigidBody(raw,null,handle))})}finalizeDeserialization(colliderSet){this.map.forEach(rb=>rb.finalizeDeserialization(colliderSet))}createRigidBody(colliderSet,desc){let rawTra=VectorOps.intoRaw(desc.translation),rawRot=RotationOps.intoRaw(desc.rotation),rawLv=VectorOps.intoRaw(desc.linvel),rawCom=VectorOps.intoRaw(desc.centerOfMass),rawAv=VectorOps.intoRaw(desc.angvel),rawPrincipalInertia=VectorOps.intoRaw(desc.principalAngularInertia),rawInertiaFrame=RotationOps.intoRaw(desc.angularInertiaLocalFrame),handle=this.raw.createRigidBody(desc.enabled,rawTra,rawRot,desc.gravityScale,desc.mass,desc.massOnly,rawCom,rawLv,rawAv,rawPrincipalInertia,rawInertiaFrame,desc.translationsEnabledX,desc.translationsEnabledY,desc.translationsEnabledZ,desc.rotationsEnabledX,desc.rotationsEnabledY,desc.rotationsEnabledZ,desc.linearDamping,desc.angularDamping,desc.status,desc.canSleep,desc.sleeping,desc.softCcdPrediction,desc.ccdEnabled,desc.dominanceGroup,desc.additionalSolverIterations);rawTra.free(),rawRot.free(),rawLv.free(),rawCom.free(),rawAv.free(),rawPrincipalInertia.free(),rawInertiaFrame.free();const body=new RigidBody(this.raw,colliderSet,handle);return body.userData=desc.userData,this.map.set(handle,body),body}remove(handle,islands,colliders,impulseJoints,multibodyJoints){for(let i=0;i<this.raw.rbNumColliders(handle);i+=1)colliders.unmap(this.raw.rbCollider(handle,i));impulseJoints.forEachJointHandleAttachedToRigidBody(handle,handle=>impulseJoints.unmap(handle)),multibodyJoints.forEachJointHandleAttachedToRigidBody(handle,handle=>multibodyJoints.unmap(handle)),this.raw.remove(handle,islands.raw,colliders.raw,impulseJoints.raw,multibodyJoints.raw),this.map.delete(handle)}len(){return this.map.len()}contains(handle){return null!=this.get(handle)}get(handle){return this.map.get(handle)}forEach(f){this.map.forEach(f)}forEachActiveRigidBody(islands,f){islands.forEachActiveRigidBodyHandle(handle=>{f(this.get(handle))})}getAll(){return this.map.getAll()}}export{RigidBodySet};
+//# sourceMappingURL=rigid_body_set.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/dynamics/rigid_body_set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rigid_body_set.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/dynamics/rigid_body_set.js"],"sourcesContent":["import { RawRigidBodySet } from \"../raw\";\nimport { Coarena } from \"../coarena\";\nimport { VectorOps, RotationOps } from \"../math\";\nimport { RigidBody, } from \"./rigid_body\";\n/**\n * A set of rigid bodies that can be handled by a physics pipeline.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `rigidBodySet.free()`\n * once you are done using it (and all the rigid-bodies it created).\n */\nexport class RigidBodySet {\n    /**\n     * Release the WASM memory occupied by this rigid-body set.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n        if (!!this.map) {\n            this.map.clear();\n        }\n        this.map = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawRigidBodySet();\n        this.map = new Coarena();\n        // deserialize\n        if (raw) {\n            raw.forEachRigidBodyHandle((handle) => {\n                this.map.set(handle, new RigidBody(raw, null, handle));\n            });\n        }\n    }\n    /**\n     * Internal method, do not call this explicitly.\n     */\n    finalizeDeserialization(colliderSet) {\n        this.map.forEach((rb) => rb.finalizeDeserialization(colliderSet));\n    }\n    /**\n     * Creates a new rigid-body and return its integer handle.\n     *\n     * @param desc - The description of the rigid-body to create.\n     */\n    createRigidBody(colliderSet, desc) {\n        let rawTra = VectorOps.intoRaw(desc.translation);\n        let rawRot = RotationOps.intoRaw(desc.rotation);\n        let rawLv = VectorOps.intoRaw(desc.linvel);\n        let rawCom = VectorOps.intoRaw(desc.centerOfMass);\n        // #if DIM3\n        let rawAv = VectorOps.intoRaw(desc.angvel);\n        let rawPrincipalInertia = VectorOps.intoRaw(desc.principalAngularInertia);\n        let rawInertiaFrame = RotationOps.intoRaw(desc.angularInertiaLocalFrame);\n        // #endif\n        let handle = this.raw.createRigidBody(desc.enabled, rawTra, rawRot, desc.gravityScale, desc.mass, desc.massOnly, rawCom, rawLv, \n        // #if DIM3\n        rawAv, rawPrincipalInertia, rawInertiaFrame, desc.translationsEnabledX, desc.translationsEnabledY, desc.translationsEnabledZ, desc.rotationsEnabledX, desc.rotationsEnabledY, desc.rotationsEnabledZ, \n        // #endif\n        desc.linearDamping, desc.angularDamping, desc.status, desc.canSleep, desc.sleeping, desc.softCcdPrediction, desc.ccdEnabled, desc.dominanceGroup, desc.additionalSolverIterations);\n        rawTra.free();\n        rawRot.free();\n        rawLv.free();\n        rawCom.free();\n        // #if DIM3\n        rawAv.free();\n        rawPrincipalInertia.free();\n        rawInertiaFrame.free();\n        // #endif\n        const body = new RigidBody(this.raw, colliderSet, handle);\n        body.userData = desc.userData;\n        this.map.set(handle, body);\n        return body;\n    }\n    /**\n     * Removes a rigid-body from this set.\n     *\n     * This will also remove all the colliders and joints attached to the rigid-body.\n     *\n     * @param handle - The integer handle of the rigid-body to remove.\n     * @param colliders - The set of colliders that may contain colliders attached to the removed rigid-body.\n     * @param impulseJoints - The set of impulse joints that may contain joints attached to the removed rigid-body.\n     * @param multibodyJoints - The set of multibody joints that may contain joints attached to the removed rigid-body.\n     */\n    remove(handle, islands, colliders, impulseJoints, multibodyJoints) {\n        // Unmap the entities that will be removed automatically because of the rigid-body removals.\n        for (let i = 0; i < this.raw.rbNumColliders(handle); i += 1) {\n            colliders.unmap(this.raw.rbCollider(handle, i));\n        }\n        impulseJoints.forEachJointHandleAttachedToRigidBody(handle, (handle) => impulseJoints.unmap(handle));\n        multibodyJoints.forEachJointHandleAttachedToRigidBody(handle, (handle) => multibodyJoints.unmap(handle));\n        // Remove the rigid-body.\n        this.raw.remove(handle, islands.raw, colliders.raw, impulseJoints.raw, multibodyJoints.raw);\n        this.map.delete(handle);\n    }\n    /**\n     * The number of rigid-bodies on this set.\n     */\n    len() {\n        return this.map.len();\n    }\n    /**\n     * Does this set contain a rigid-body with the given handle?\n     *\n     * @param handle - The rigid-body handle to check.\n     */\n    contains(handle) {\n        return this.get(handle) != null;\n    }\n    /**\n     * Gets the rigid-body with the given handle.\n     *\n     * @param handle - The handle of the rigid-body to retrieve.\n     */\n    get(handle) {\n        return this.map.get(handle);\n    }\n    /**\n     * Applies the given closure to each rigid-body contained by this set.\n     *\n     * @param f - The closure to apply.\n     */\n    forEach(f) {\n        this.map.forEach(f);\n    }\n    /**\n     * Applies the given closure to each active rigid-bodies contained by this set.\n     *\n     * A rigid-body is active if it is not sleeping, i.e., if it moved recently.\n     *\n     * @param f - The closure to apply.\n     */\n    forEachActiveRigidBody(islands, f) {\n        islands.forEachActiveRigidBodyHandle((handle) => {\n            f(this.get(handle));\n        });\n    }\n    /**\n     * Gets all rigid-bodies in the list.\n     *\n     * @returns rigid-bodies list.\n     */\n    getAll() {\n        return this.map.getAll();\n    }\n}\n//# sourceMappingURL=rigid_body_set.js.map"],"names":["RigidBodySet","free","this","raw","undefined","map","clear","constructor","RawRigidBodySet","Coarena","forEachRigidBodyHandle","handle","set","RigidBody","finalizeDeserialization","colliderSet","forEach","rb","createRigidBody","desc","rawTra","VectorOps","intoRaw","translation","rawRot","RotationOps","rotation","rawLv","linvel","rawCom","centerOfMass","rawAv","angvel","rawPrincipalInertia","principalAngularInertia","rawInertiaFrame","angularInertiaLocalFrame","enabled","gravityScale","mass","massOnly","translationsEnabledX","translationsEnabledY","translationsEnabledZ","rotationsEnabledX","rotationsEnabledY","rotationsEnabledZ","linearDamping","angularDamping","status","canSleep","sleeping","softCcdPrediction","ccdEnabled","dominanceGroup","additionalSolverIterations","body","userData","remove","islands","colliders","impulseJoints","multibodyJoints","i","rbNumColliders","unmap","rbCollider","forEachJointHandleAttachedToRigidBody","delete","len","contains","get","f","forEachActiveRigidBody","forEachActiveRigidBodyHandle","getAll"],"mappings":"wMAUO,MAAMA,aAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,EACLF,KAAKG,KACPH,KAAKG,IAAIC,QAEbJ,KAAKG,SAAMD,CACf,CACA,WAAAG,CAAYJ,KACRD,KAAKC,IAAMA,KAAO,IAAIK,gBACtBN,KAAKG,IAAM,IAAII,QAEXN,KACAA,IAAIO,uBAAwBC,SACxBT,KAAKG,IAAIO,IAAID,OAAQ,IAAIE,UAAUV,IAAK,KAAMQ,UAG1D,CAIA,uBAAAG,CAAwBC,aACpBb,KAAKG,IAAIW,QAASC,IAAOA,GAAGH,wBAAwBC,aACxD,CAMA,eAAAG,CAAgBH,YAAaI,MACzB,IAAIC,OAASC,UAAUC,QAAQH,KAAKI,aAChCC,OAASC,YAAYH,QAAQH,KAAKO,UAClCC,MAAQN,UAAUC,QAAQH,KAAKS,QAC/BC,OAASR,UAAUC,QAAQH,KAAKW,cAEhCC,MAAQV,UAAUC,QAAQH,KAAKa,QAC/BC,oBAAsBZ,UAAUC,QAAQH,KAAKe,yBAC7CC,gBAAkBV,YAAYH,QAAQH,KAAKiB,0BAE3CzB,OAAST,KAAKC,IAAIe,gBAAgBC,KAAKkB,QAASjB,OAAQI,OAAQL,KAAKmB,aAAcnB,KAAKoB,KAAMpB,KAAKqB,SAAUX,OAAQF,MAEzHI,MAAOE,oBAAqBE,gBAAiBhB,KAAKsB,qBAAsBtB,KAAKuB,qBAAsBvB,KAAKwB,qBAAsBxB,KAAKyB,kBAAmBzB,KAAK0B,kBAAmB1B,KAAK2B,kBAEnL3B,KAAK4B,cAAe5B,KAAK6B,eAAgB7B,KAAK8B,OAAQ9B,KAAK+B,SAAU/B,KAAKgC,SAAUhC,KAAKiC,kBAAmBjC,KAAKkC,WAAYlC,KAAKmC,eAAgBnC,KAAKoC,4BACvJnC,OAAOnB,OACPuB,OAAOvB,OACP0B,MAAM1B,OACN4B,OAAO5B,OAEP8B,MAAM9B,OACNgC,oBAAoBhC,OACpBkC,gBAAgBlC,OAEhB,MAAMuD,KAAO,IAAI3C,UAAUX,KAAKC,IAAKY,YAAaJ,QAGlD,OAFA6C,KAAKC,SAAWtC,KAAKsC,SACrBvD,KAAKG,IAAIO,IAAID,OAAQ6C,MACdA,IACX,CAWA,MAAAE,CAAO/C,OAAQgD,QAASC,UAAWC,cAAeC,iBAE9C,IAAK,IAAIC,EAAI,EAAGA,EAAI7D,KAAKC,IAAI6D,eAAerD,QAASoD,GAAK,EACtDH,UAAUK,MAAM/D,KAAKC,IAAI+D,WAAWvD,OAAQoD,IAEhDF,cAAcM,sCAAsCxD,OAASA,QAAWkD,cAAcI,MAAMtD,SAC5FmD,gBAAgBK,sCAAsCxD,OAASA,QAAWmD,gBAAgBG,MAAMtD,SAEhGT,KAAKC,IAAIuD,OAAO/C,OAAQgD,QAAQxD,IAAKyD,UAAUzD,IAAK0D,cAAc1D,IAAK2D,gBAAgB3D,KACvFD,KAAKG,IAAI+D,OAAOzD,OACpB,CAIA,GAAA0D,GACI,OAAOnE,KAAKG,IAAIgE,KACpB,CAMA,QAAAC,CAAS3D,QACL,OAA2B,MAApBT,KAAKqE,IAAI5D,OACpB,CAMA,GAAA4D,CAAI5D,QACA,OAAOT,KAAKG,IAAIkE,IAAI5D,OACxB,CAMA,OAAAK,CAAQwD,GACJtE,KAAKG,IAAIW,QAAQwD,EACrB,CAQA,sBAAAC,CAAuBd,QAASa,GAC5Bb,QAAQe,6BAA8B/D,SAClC6D,EAAEtE,KAAKqE,IAAI5D,UAEnB,CAMA,MAAAgE,GACI,OAAOzE,KAAKG,IAAIsE,QACpB","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/broad_phase.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";import{RayColliderHit,RayColliderIntersection}from"./ray.js";import{VectorOps,RotationOps}from"../math.js";import{PointColliderProjection}from"./point.js";import{ColliderShapeCastHit}from"./toi.js";import{RawBroadPhase}from"../rapier_wasm3d_bg.js";class BroadPhase{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw||new RawBroadPhase}castRay(narrowPhase,bodies,colliders,ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir),result=RayColliderHit.fromRaw(colliders,this.raw.castRay(narrowPhase.raw,bodies.raw,colliders.raw,rawOrig,rawDir,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawOrig.free(),rawDir.free(),result}castRayAndGetNormal(narrowPhase,bodies,colliders,ray,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir),result=RayColliderIntersection.fromRaw(colliders,this.raw.castRayAndGetNormal(narrowPhase.raw,bodies.raw,colliders.raw,rawOrig,rawDir,maxToi,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawOrig.free(),rawDir.free(),result}intersectionsWithRay(narrowPhase,bodies,colliders,ray,maxToi,solid,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir);this.raw.intersectionsWithRay(narrowPhase.raw,bodies.raw,colliders.raw,rawOrig,rawDir,maxToi,solid,rawInter=>callback(RayColliderIntersection.fromRaw(colliders,rawInter)),filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate),rawOrig.free(),rawDir.free()}intersectionWithShape(narrowPhase,bodies,colliders,shapePos,shapeRot,shape,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawShape=shape.intoRaw(),result=this.raw.intersectionWithShape(narrowPhase.raw,bodies.raw,colliders.raw,rawPos,rawRot,rawShape,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate);return rawPos.free(),rawRot.free(),rawShape.free(),result}projectPoint(narrowPhase,bodies,colliders,point,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPoint=VectorOps.intoRaw(point),result=PointColliderProjection.fromRaw(colliders,this.raw.projectPoint(narrowPhase.raw,bodies.raw,colliders.raw,rawPoint,solid,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawPoint.free(),result}projectPointAndGetFeature(narrowPhase,bodies,colliders,point,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPoint=VectorOps.intoRaw(point),result=PointColliderProjection.fromRaw(colliders,this.raw.projectPointAndGetFeature(narrowPhase.raw,bodies.raw,colliders.raw,rawPoint,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawPoint.free(),result}intersectionsWithPoint(narrowPhase,bodies,colliders,point,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPoint=VectorOps.intoRaw(point);this.raw.intersectionsWithPoint(narrowPhase.raw,bodies.raw,colliders.raw,rawPoint,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate),rawPoint.free()}castShape(narrowPhase,bodies,colliders,shapePos,shapeRot,shapeVel,shape,targetDistance,maxToi,stopAtPenetration,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawVel=VectorOps.intoRaw(shapeVel),rawShape=shape.intoRaw(),result=ColliderShapeCastHit.fromRaw(colliders,this.raw.castShape(narrowPhase.raw,bodies.raw,colliders.raw,rawPos,rawRot,rawVel,rawShape,targetDistance,maxToi,stopAtPenetration,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate));return rawPos.free(),rawRot.free(),rawVel.free(),rawShape.free(),result}intersectionsWithShape(narrowPhase,bodies,colliders,shapePos,shapeRot,shape,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate){let rawPos=VectorOps.intoRaw(shapePos),rawRot=RotationOps.intoRaw(shapeRot),rawShape=shape.intoRaw();this.raw.intersectionsWithShape(narrowPhase.raw,bodies.raw,colliders.raw,rawPos,rawRot,rawShape,callback,filterFlags,filterGroups,filterExcludeCollider,filterExcludeRigidBody,filterPredicate),rawPos.free(),rawRot.free(),rawShape.free()}collidersWithAabbIntersectingAabb(narrowPhase,bodies,colliders,aabbCenter,aabbHalfExtents,callback){let rawCenter=VectorOps.intoRaw(aabbCenter),rawHalfExtents=VectorOps.intoRaw(aabbHalfExtents);this.raw.collidersWithAabbIntersectingAabb(narrowPhase.raw,bodies.raw,colliders.raw,rawCenter,rawHalfExtents,callback),rawCenter.free(),rawHalfExtents.free()}}export{BroadPhase};
+//# sourceMappingURL=broad_phase.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/broad_phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"broad_phase.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/broad_phase.js"],"sourcesContent":["import { RawBroadPhase } from \"../raw\";\nimport { RayColliderHit, RayColliderIntersection } from \"./ray\";\nimport { RotationOps, VectorOps } from \"../math\";\nimport { PointColliderProjection } from \"./point\";\nimport { ColliderShapeCastHit } from \"./toi\";\n/**\n * The broad-phase used for coarse collision-detection.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `broadPhase.free()`\n * once you are done using it.\n */\nexport class BroadPhase {\n    /**\n     * Release the WASM memory occupied by this broad-phase.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawBroadPhase();\n    }\n    /**\n     * Find the closest intersection between a ray and a set of collider.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.\n     * @param filter - The callback to filter out which collider will be hit.\n     */\n    castRay(narrowPhase, bodies, colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let result = RayColliderHit.fromRaw(colliders, this.raw.castRay(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawOrig.free();\n        rawDir.free();\n        return result;\n    }\n    /**\n     * Find the closest intersection between a ray and a set of collider.\n     *\n     * This also computes the normal at the hit point.\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.\n     */\n    castRayAndGetNormal(narrowPhase, bodies, colliders, ray, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let result = RayColliderIntersection.fromRaw(colliders, this.raw.castRayAndGetNormal(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawOrig.free();\n        rawDir.free();\n        return result;\n    }\n    /**\n     * Cast a ray and collects all the intersections between a ray and the scene.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.\n     * @param callback - The callback called once per hit (in no particular order) between a ray and a collider.\n     *   If this callback returns `false`, then the cast will stop and no further hits will be detected/reported.\n     */\n    intersectionsWithRay(narrowPhase, bodies, colliders, ray, maxToi, solid, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let rawCallback = (rawInter) => {\n            return callback(RayColliderIntersection.fromRaw(colliders, rawInter));\n        };\n        this.raw.intersectionsWithRay(narrowPhase.raw, bodies.raw, colliders.raw, rawOrig, rawDir, maxToi, solid, rawCallback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawOrig.free();\n        rawDir.free();\n    }\n    /**\n     * Gets the handle of up to one collider intersecting the given shape.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param shapePos - The position of the shape used for the intersection test.\n     * @param shapeRot - The orientation of the shape used for the intersection test.\n     * @param shape - The shape used for the intersection test.\n     * @param groups - The bit groups and filter associated to the ray, in order to only\n     *   hit the colliders with collision groups compatible with the ray's group.\n     */\n    intersectionWithShape(narrowPhase, bodies, colliders, shapePos, shapeRot, shape, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawShape = shape.intoRaw();\n        let result = this.raw.intersectionWithShape(narrowPhase.raw, bodies.raw, colliders.raw, rawPos, rawRot, rawShape, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawPos.free();\n        rawRot.free();\n        rawShape.free();\n        return result;\n    }\n    /**\n     * Find the projection of a point on the closest collider.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param point - The point to project.\n     * @param solid - If this is set to `true` then the collider shapes are considered to\n     *   be plain (if the point is located inside of a plain shape, its projection is the point\n     *   itself). If it is set to `false` the collider shapes are considered to be hollow\n     *   (if the point is located inside of an hollow shape, it is projected on the shape's\n     *   boundary).\n     * @param groups - The bit groups and filter associated to the point to project, in order to only\n     *   project on colliders with collision groups compatible with the ray's group.\n     */\n    projectPoint(narrowPhase, bodies, colliders, point, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPoint = VectorOps.intoRaw(point);\n        let result = PointColliderProjection.fromRaw(colliders, this.raw.projectPoint(narrowPhase.raw, bodies.raw, colliders.raw, rawPoint, solid, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawPoint.free();\n        return result;\n    }\n    /**\n     * Find the projection of a point on the closest collider.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param point - The point to project.\n     * @param groups - The bit groups and filter associated to the point to project, in order to only\n     *   project on colliders with collision groups compatible with the ray's group.\n     */\n    projectPointAndGetFeature(narrowPhase, bodies, colliders, point, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPoint = VectorOps.intoRaw(point);\n        let result = PointColliderProjection.fromRaw(colliders, this.raw.projectPointAndGetFeature(narrowPhase.raw, bodies.raw, colliders.raw, rawPoint, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawPoint.free();\n        return result;\n    }\n    /**\n     * Find all the colliders containing the given point.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param point - The point used for the containment test.\n     * @param groups - The bit groups and filter associated to the point to test, in order to only\n     *   test on colliders with collision groups compatible with the ray's group.\n     * @param callback - A function called with the handles of each collider with a shape\n     *   containing the `point`.\n     */\n    intersectionsWithPoint(narrowPhase, bodies, colliders, point, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPoint = VectorOps.intoRaw(point);\n        this.raw.intersectionsWithPoint(narrowPhase.raw, bodies.raw, colliders.raw, rawPoint, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawPoint.free();\n    }\n    /**\n     * Casts a shape at a constant linear velocity and retrieve the first collider it hits.\n     * This is similar to ray-casting except that we are casting a whole shape instead of\n     * just a point (the ray origin).\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param shapePos - The initial position of the shape to cast.\n     * @param shapeRot - The initial rotation of the shape to cast.\n     * @param shapeVel - The constant velocity of the shape to cast (i.e. the cast direction).\n     * @param shape - The shape to cast.\n     * @param targetDistance − If the shape moves closer to this distance from a collider, a hit\n     *                       will be returned.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.\n     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if\n     *   the shape is penetrating another shape at its starting point **and** its trajectory is such\n     *   that it’s on a path to exit that penetration state.\n     * @param groups - The bit groups and filter associated to the shape to cast, in order to only\n     *   test on colliders with collision groups compatible with this group.\n     */\n    castShape(narrowPhase, bodies, colliders, shapePos, shapeRot, shapeVel, shape, targetDistance, maxToi, stopAtPenetration, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawVel = VectorOps.intoRaw(shapeVel);\n        let rawShape = shape.intoRaw();\n        let result = ColliderShapeCastHit.fromRaw(colliders, this.raw.castShape(narrowPhase.raw, bodies.raw, colliders.raw, rawPos, rawRot, rawVel, rawShape, targetDistance, maxToi, stopAtPenetration, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate));\n        rawPos.free();\n        rawRot.free();\n        rawVel.free();\n        rawShape.free();\n        return result;\n    }\n    /**\n     * Retrieve all the colliders intersecting the given shape.\n     *\n     * @param colliders - The set of colliders taking part in this pipeline.\n     * @param shapePos - The position of the shape to test.\n     * @param shapeRot - The orientation of the shape to test.\n     * @param shape - The shape to test.\n     * @param groups - The bit groups and filter associated to the shape to test, in order to only\n     *   test on colliders with collision groups compatible with this group.\n     * @param callback - A function called with the handles of each collider intersecting the `shape`.\n     */\n    intersectionsWithShape(narrowPhase, bodies, colliders, shapePos, shapeRot, shape, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate) {\n        let rawPos = VectorOps.intoRaw(shapePos);\n        let rawRot = RotationOps.intoRaw(shapeRot);\n        let rawShape = shape.intoRaw();\n        this.raw.intersectionsWithShape(narrowPhase.raw, bodies.raw, colliders.raw, rawPos, rawRot, rawShape, callback, filterFlags, filterGroups, filterExcludeCollider, filterExcludeRigidBody, filterPredicate);\n        rawPos.free();\n        rawRot.free();\n        rawShape.free();\n    }\n    /**\n     * Finds the handles of all the colliders with an AABB intersecting the given AABB.\n     *\n     * @param aabbCenter - The center of the AABB to test.\n     * @param aabbHalfExtents - The half-extents of the AABB to test.\n     * @param callback - The callback that will be called with the handles of all the colliders\n     *                   currently intersecting the given AABB.\n     */\n    collidersWithAabbIntersectingAabb(narrowPhase, bodies, colliders, aabbCenter, aabbHalfExtents, callback) {\n        let rawCenter = VectorOps.intoRaw(aabbCenter);\n        let rawHalfExtents = VectorOps.intoRaw(aabbHalfExtents);\n        this.raw.collidersWithAabbIntersectingAabb(narrowPhase.raw, bodies.raw, colliders.raw, rawCenter, rawHalfExtents, callback);\n        rawCenter.free();\n        rawHalfExtents.free();\n    }\n}\n//# sourceMappingURL=broad_phase.js.map"],"names":["BroadPhase","free","this","raw","undefined","constructor","RawBroadPhase","castRay","narrowPhase","bodies","colliders","ray","maxToi","solid","filterFlags","filterGroups","filterExcludeCollider","filterExcludeRigidBody","filterPredicate","rawOrig","VectorOps","intoRaw","origin","rawDir","dir","result","RayColliderHit","fromRaw","castRayAndGetNormal","RayColliderIntersection","intersectionsWithRay","callback","rawInter","intersectionWithShape","shapePos","shapeRot","shape","rawPos","rawRot","RotationOps","rawShape","projectPoint","point","rawPoint","PointColliderProjection","projectPointAndGetFeature","intersectionsWithPoint","castShape","shapeVel","targetDistance","stopAtPenetration","rawVel","ColliderShapeCastHit","intersectionsWithShape","collidersWithAabbIntersectingAabb","aabbCenter","aabbHalfExtents","rawCenter","rawHalfExtents"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/collider.js

@@ -0,0 +1,2 @@
+import{RotationOps,VectorOps}from"../math.js";import{Ball,Capsule,Segment,Triangle,RoundTriangle,Polyline,Voxels,TriMesh,Cuboid,RoundCuboid,Heightfield,Cylinder,RoundCylinder,Cone,RoundCone,ConvexPolyhedron,RoundConvexPolyhedron,Shape}from"./shape.js";import{RayIntersection}from"./ray.js";import{PointProjection}from"./point.js";import{ShapeCastHit,ColliderShapeCastHit}from"./toi.js";import{ShapeContact}from"./contact.js";import{CoefficientCombineRule}from"../dynamics/coefficient_combine_rule.js";import{ActiveEvents}from"../pipeline/event_queue.js";import{ActiveHooks}from"../pipeline/physics_hooks.js";var ActiveCollisionTypes,MassPropsMode;!function(ActiveCollisionTypes){ActiveCollisionTypes[ActiveCollisionTypes.DYNAMIC_DYNAMIC=1]="DYNAMIC_DYNAMIC",ActiveCollisionTypes[ActiveCollisionTypes.DYNAMIC_KINEMATIC=12]="DYNAMIC_KINEMATIC",ActiveCollisionTypes[ActiveCollisionTypes.DYNAMIC_FIXED=2]="DYNAMIC_FIXED",ActiveCollisionTypes[ActiveCollisionTypes.KINEMATIC_KINEMATIC=52224]="KINEMATIC_KINEMATIC",ActiveCollisionTypes[ActiveCollisionTypes.KINEMATIC_FIXED=8704]="KINEMATIC_FIXED",ActiveCollisionTypes[ActiveCollisionTypes.FIXED_FIXED=32]="FIXED_FIXED",ActiveCollisionTypes[ActiveCollisionTypes.DEFAULT=15]="DEFAULT",ActiveCollisionTypes[ActiveCollisionTypes.ALL=60943]="ALL"}(ActiveCollisionTypes||(ActiveCollisionTypes={}));class Collider{constructor(colliderSet,handle,parent,shape){this.colliderSet=colliderSet,this.handle=handle,this._parent=parent,this._shape=shape}finalizeDeserialization(bodies){null!=this.handle&&(this._parent=bodies.get(this.colliderSet.raw.coParent(this.handle)))}ensureShapeIsCached(){this._shape||(this._shape=Shape.fromRaw(this.colliderSet.raw,this.handle))}get shape(){return this.ensureShapeIsCached(),this._shape}clearShapeCache(){this._shape=null}isValid(){return this.colliderSet.raw.contains(this.handle)}translation(){return VectorOps.fromRaw(this.colliderSet.raw.coTranslation(this.handle))}translationWrtParent(){return VectorOps.fromRaw(this.colliderSet.raw.coTranslationWrtParent(this.handle))}rotation(){return RotationOps.fromRaw(this.colliderSet.raw.coRotation(this.handle))}rotationWrtParent(){return RotationOps.fromRaw(this.colliderSet.raw.coRotationWrtParent(this.handle))}isSensor(){return this.colliderSet.raw.coIsSensor(this.handle)}setSensor(isSensor){this.colliderSet.raw.coSetSensor(this.handle,isSensor)}setShape(shape){let rawShape=shape.intoRaw();this.colliderSet.raw.coSetShape(this.handle,rawShape),rawShape.free(),this._shape=shape}setEnabled(enabled){this.colliderSet.raw.coSetEnabled(this.handle,enabled)}isEnabled(){return this.colliderSet.raw.coIsEnabled(this.handle)}setRestitution(restitution){this.colliderSet.raw.coSetRestitution(this.handle,restitution)}setFriction(friction){this.colliderSet.raw.coSetFriction(this.handle,friction)}frictionCombineRule(){return this.colliderSet.raw.coFrictionCombineRule(this.handle)}setFrictionCombineRule(rule){this.colliderSet.raw.coSetFrictionCombineRule(this.handle,rule)}restitutionCombineRule(){return this.colliderSet.raw.coRestitutionCombineRule(this.handle)}setRestitutionCombineRule(rule){this.colliderSet.raw.coSetRestitutionCombineRule(this.handle,rule)}setCollisionGroups(groups){this.colliderSet.raw.coSetCollisionGroups(this.handle,groups)}setSolverGroups(groups){this.colliderSet.raw.coSetSolverGroups(this.handle,groups)}contactSkin(){return this.colliderSet.raw.coContactSkin(this.handle)}setContactSkin(thickness){return this.colliderSet.raw.coSetContactSkin(this.handle,thickness)}activeHooks(){return this.colliderSet.raw.coActiveHooks(this.handle)}setActiveHooks(activeHooks){this.colliderSet.raw.coSetActiveHooks(this.handle,activeHooks)}activeEvents(){return this.colliderSet.raw.coActiveEvents(this.handle)}setActiveEvents(activeEvents){this.colliderSet.raw.coSetActiveEvents(this.handle,activeEvents)}activeCollisionTypes(){return this.colliderSet.raw.coActiveCollisionTypes(this.handle)}setContactForceEventThreshold(threshold){return this.colliderSet.raw.coSetContactForceEventThreshold(this.handle,threshold)}contactForceEventThreshold(){return this.colliderSet.raw.coContactForceEventThreshold(this.handle)}setActiveCollisionTypes(activeCollisionTypes){this.colliderSet.raw.coSetActiveCollisionTypes(this.handle,activeCollisionTypes)}setDensity(density){this.colliderSet.raw.coSetDensity(this.handle,density)}setMass(mass){this.colliderSet.raw.coSetMass(this.handle,mass)}setMassProperties(mass,centerOfMass,principalAngularInertia,angularInertiaLocalFrame){let rawCom=VectorOps.intoRaw(centerOfMass),rawPrincipalInertia=VectorOps.intoRaw(principalAngularInertia),rawInertiaFrame=RotationOps.intoRaw(angularInertiaLocalFrame);this.colliderSet.raw.coSetMassProperties(this.handle,mass,rawCom,rawPrincipalInertia,rawInertiaFrame),rawCom.free(),rawPrincipalInertia.free(),rawInertiaFrame.free()}setTranslation(tra){this.colliderSet.raw.coSetTranslation(this.handle,tra.x,tra.y,tra.z)}setTranslationWrtParent(tra){this.colliderSet.raw.coSetTranslationWrtParent(this.handle,tra.x,tra.y,tra.z)}setRotation(rot){this.colliderSet.raw.coSetRotation(this.handle,rot.x,rot.y,rot.z,rot.w)}setRotationWrtParent(rot){this.colliderSet.raw.coSetRotationWrtParent(this.handle,rot.x,rot.y,rot.z,rot.w)}shapeType(){return this.colliderSet.raw.coShapeType(this.handle)}halfExtents(){return VectorOps.fromRaw(this.colliderSet.raw.coHalfExtents(this.handle))}setHalfExtents(newHalfExtents){const rawPoint=VectorOps.intoRaw(newHalfExtents);this.colliderSet.raw.coSetHalfExtents(this.handle,rawPoint)}radius(){return this.colliderSet.raw.coRadius(this.handle)}setRadius(newRadius){this.colliderSet.raw.coSetRadius(this.handle,newRadius)}roundRadius(){return this.colliderSet.raw.coRoundRadius(this.handle)}setRoundRadius(newBorderRadius){this.colliderSet.raw.coSetRoundRadius(this.handle,newBorderRadius)}halfHeight(){return this.colliderSet.raw.coHalfHeight(this.handle)}setHalfHeight(newHalfheight){this.colliderSet.raw.coSetHalfHeight(this.handle,newHalfheight)}setVoxel(ix,iy,iz,filled){this.colliderSet.raw.coSetVoxel(this.handle,ix,iy,iz,filled),this._shape=null}propagateVoxelChange(voxels2,ix,iy,iz,shift_x,shift_y,shift_z){this.colliderSet.raw.coPropagateVoxelChange(this.handle,voxels2.handle,ix,iy,iz,shift_x,shift_y,shift_z),this._shape=null}combineVoxelStates(voxels2,shift_x,shift_y,shift_z){this.colliderSet.raw.coCombineVoxelStates(this.handle,voxels2.handle,shift_x,shift_y,shift_z),this._shape=null}vertices(){return this.colliderSet.raw.coVertices(this.handle)}indices(){return this.colliderSet.raw.coIndices(this.handle)}heightfieldHeights(){return this.colliderSet.raw.coHeightfieldHeights(this.handle)}heightfieldScale(){let scale=this.colliderSet.raw.coHeightfieldScale(this.handle);return VectorOps.fromRaw(scale)}heightfieldNRows(){return this.colliderSet.raw.coHeightfieldNRows(this.handle)}heightfieldNCols(){return this.colliderSet.raw.coHeightfieldNCols(this.handle)}parent(){return this._parent}friction(){return this.colliderSet.raw.coFriction(this.handle)}restitution(){return this.colliderSet.raw.coRestitution(this.handle)}density(){return this.colliderSet.raw.coDensity(this.handle)}mass(){return this.colliderSet.raw.coMass(this.handle)}volume(){return this.colliderSet.raw.coVolume(this.handle)}collisionGroups(){return this.colliderSet.raw.coCollisionGroups(this.handle)}solverGroups(){return this.colliderSet.raw.coSolverGroups(this.handle)}containsPoint(point){let rawPoint=VectorOps.intoRaw(point),result=this.colliderSet.raw.coContainsPoint(this.handle,rawPoint);return rawPoint.free(),result}projectPoint(point,solid){let rawPoint=VectorOps.intoRaw(point),result=PointProjection.fromRaw(this.colliderSet.raw.coProjectPoint(this.handle,rawPoint,solid));return rawPoint.free(),result}intersectsRay(ray,maxToi){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir),result=this.colliderSet.raw.coIntersectsRay(this.handle,rawOrig,rawDir,maxToi);return rawOrig.free(),rawDir.free(),result}castShape(collider1Vel,shape2,shape2Pos,shape2Rot,shape2Vel,targetDistance,maxToi,stopAtPenetration){let rawCollider1Vel=VectorOps.intoRaw(collider1Vel),rawShape2Pos=VectorOps.intoRaw(shape2Pos),rawShape2Rot=RotationOps.intoRaw(shape2Rot),rawShape2Vel=VectorOps.intoRaw(shape2Vel),rawShape2=shape2.intoRaw(),result=ShapeCastHit.fromRaw(this.colliderSet,this.colliderSet.raw.coCastShape(this.handle,rawCollider1Vel,rawShape2,rawShape2Pos,rawShape2Rot,rawShape2Vel,targetDistance,maxToi,stopAtPenetration));return rawCollider1Vel.free(),rawShape2Pos.free(),rawShape2Rot.free(),rawShape2Vel.free(),rawShape2.free(),result}castCollider(collider1Vel,collider2,collider2Vel,targetDistance,maxToi,stopAtPenetration){let rawCollider1Vel=VectorOps.intoRaw(collider1Vel),rawCollider2Vel=VectorOps.intoRaw(collider2Vel),result=ColliderShapeCastHit.fromRaw(this.colliderSet,this.colliderSet.raw.coCastCollider(this.handle,rawCollider1Vel,collider2.handle,rawCollider2Vel,targetDistance,maxToi,stopAtPenetration));return rawCollider1Vel.free(),rawCollider2Vel.free(),result}intersectsShape(shape2,shapePos2,shapeRot2){let rawPos2=VectorOps.intoRaw(shapePos2),rawRot2=RotationOps.intoRaw(shapeRot2),rawShape2=shape2.intoRaw(),result=this.colliderSet.raw.coIntersectsShape(this.handle,rawShape2,rawPos2,rawRot2);return rawPos2.free(),rawRot2.free(),rawShape2.free(),result}contactShape(shape2,shape2Pos,shape2Rot,prediction){let rawPos2=VectorOps.intoRaw(shape2Pos),rawRot2=RotationOps.intoRaw(shape2Rot),rawShape2=shape2.intoRaw(),result=ShapeContact.fromRaw(this.colliderSet.raw.coContactShape(this.handle,rawShape2,rawPos2,rawRot2,prediction));return rawPos2.free(),rawRot2.free(),rawShape2.free(),result}contactCollider(collider2,prediction){return ShapeContact.fromRaw(this.colliderSet.raw.coContactCollider(this.handle,collider2.handle,prediction))}castRay(ray,maxToi,solid){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir),result=this.colliderSet.raw.coCastRay(this.handle,rawOrig,rawDir,maxToi,solid);return rawOrig.free(),rawDir.free(),result}castRayAndGetNormal(ray,maxToi,solid){let rawOrig=VectorOps.intoRaw(ray.origin),rawDir=VectorOps.intoRaw(ray.dir),result=RayIntersection.fromRaw(this.colliderSet.raw.coCastRayAndGetNormal(this.handle,rawOrig,rawDir,maxToi,solid));return rawOrig.free(),rawDir.free(),result}}!function(MassPropsMode){MassPropsMode[MassPropsMode.Density=0]="Density",MassPropsMode[MassPropsMode.Mass=1]="Mass",MassPropsMode[MassPropsMode.MassProps=2]="MassProps"}(MassPropsMode||(MassPropsMode={}));class ColliderDesc{constructor(shape){this.enabled=!0,this.shape=shape,this.massPropsMode=MassPropsMode.Density,this.density=1,this.friction=.5,this.restitution=0,this.rotation=RotationOps.identity(),this.translation=VectorOps.zeros(),this.isSensor=!1,this.collisionGroups=4294967295,this.solverGroups=4294967295,this.frictionCombineRule=CoefficientCombineRule.Average,this.restitutionCombineRule=CoefficientCombineRule.Average,this.activeCollisionTypes=ActiveCollisionTypes.DEFAULT,this.activeEvents=ActiveEvents.NONE,this.activeHooks=ActiveHooks.NONE,this.mass=0,this.centerOfMass=VectorOps.zeros(),this.contactForceEventThreshold=0,this.contactSkin=0,this.principalAngularInertia=VectorOps.zeros(),this.angularInertiaLocalFrame=RotationOps.identity()}static ball(radius){const shape=new Ball(radius);return new ColliderDesc(shape)}static capsule(halfHeight,radius){const shape=new Capsule(halfHeight,radius);return new ColliderDesc(shape)}static segment(a,b){const shape=new Segment(a,b);return new ColliderDesc(shape)}static triangle(a,b,c){const shape=new Triangle(a,b,c);return new ColliderDesc(shape)}static roundTriangle(a,b,c,borderRadius){const shape=new RoundTriangle(a,b,c,borderRadius);return new ColliderDesc(shape)}static polyline(vertices,indices){const shape=new Polyline(vertices,indices);return new ColliderDesc(shape)}static voxels(voxels,voxelSize){const shape=new Voxels(voxels,voxelSize);return new ColliderDesc(shape)}static trimesh(vertices,indices,flags){const shape=new TriMesh(vertices,indices,flags);return new ColliderDesc(shape)}static cuboid(hx,hy,hz){const shape=new Cuboid(hx,hy,hz);return new ColliderDesc(shape)}static roundCuboid(hx,hy,hz,borderRadius){const shape=new RoundCuboid(hx,hy,hz,borderRadius);return new ColliderDesc(shape)}static heightfield(nrows,ncols,heights,scale,flags){const shape=new Heightfield(nrows,ncols,heights,scale,flags);return new ColliderDesc(shape)}static cylinder(halfHeight,radius){const shape=new Cylinder(halfHeight,radius);return new ColliderDesc(shape)}static roundCylinder(halfHeight,radius,borderRadius){const shape=new RoundCylinder(halfHeight,radius,borderRadius);return new ColliderDesc(shape)}static cone(halfHeight,radius){const shape=new Cone(halfHeight,radius);return new ColliderDesc(shape)}static roundCone(halfHeight,radius,borderRadius){const shape=new RoundCone(halfHeight,radius,borderRadius);return new ColliderDesc(shape)}static convexHull(points){const shape=new ConvexPolyhedron(points,null);return new ColliderDesc(shape)}static convexMesh(vertices,indices){const shape=new ConvexPolyhedron(vertices,indices);return new ColliderDesc(shape)}static roundConvexHull(points,borderRadius){const shape=new RoundConvexPolyhedron(points,null,borderRadius);return new ColliderDesc(shape)}static roundConvexMesh(vertices,indices,borderRadius){const shape=new RoundConvexPolyhedron(vertices,indices,borderRadius);return new ColliderDesc(shape)}setTranslation(x,y,z){if("number"!=typeof x||"number"!=typeof y||"number"!=typeof z)throw TypeError("The translation components must be numbers.");return this.translation={x:x,y:y,z:z},this}setRotation(rot){return RotationOps.copy(this.rotation,rot),this}setSensor(sensor){return this.isSensor=sensor,this}setEnabled(enabled){return this.enabled=enabled,this}setContactSkin(thickness){return this.contactSkin=thickness,this}setDensity(density){return this.massPropsMode=MassPropsMode.Density,this.density=density,this}setMass(mass){return this.massPropsMode=MassPropsMode.Mass,this.mass=mass,this}setMassProperties(mass,centerOfMass,principalAngularInertia,angularInertiaLocalFrame){return this.massPropsMode=MassPropsMode.MassProps,this.mass=mass,VectorOps.copy(this.centerOfMass,centerOfMass),VectorOps.copy(this.principalAngularInertia,principalAngularInertia),RotationOps.copy(this.angularInertiaLocalFrame,angularInertiaLocalFrame),this}setRestitution(restitution){return this.restitution=restitution,this}setFriction(friction){return this.friction=friction,this}setFrictionCombineRule(rule){return this.frictionCombineRule=rule,this}setRestitutionCombineRule(rule){return this.restitutionCombineRule=rule,this}setCollisionGroups(groups){return this.collisionGroups=groups,this}setSolverGroups(groups){return this.solverGroups=groups,this}setActiveHooks(activeHooks){return this.activeHooks=activeHooks,this}setActiveEvents(activeEvents){return this.activeEvents=activeEvents,this}setActiveCollisionTypes(activeCollisionTypes){return this.activeCollisionTypes=activeCollisionTypes,this}setContactForceEventThreshold(threshold){return this.contactForceEventThreshold=threshold,this}}export{ActiveCollisionTypes,Collider,ColliderDesc,MassPropsMode};
+//# sourceMappingURL=collider.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/collider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collider.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/collider.js"],"sourcesContent":["import { RotationOps, VectorOps } from \"../math\";\nimport { CoefficientCombineRule, } from \"../dynamics\";\nimport { ActiveHooks, ActiveEvents } from \"../pipeline\";\nimport { Shape, Cuboid, Ball, Capsule, Voxels, TriMesh, Polyline, Heightfield, Segment, Triangle, RoundTriangle, RoundCuboid, \n// #if DIM3\nCylinder, RoundCylinder, Cone, RoundCone, ConvexPolyhedron, RoundConvexPolyhedron,\n// #endif\n } from \"./shape\";\nimport { RayIntersection } from \"./ray\";\nimport { PointProjection } from \"./point\";\nimport { ColliderShapeCastHit, ShapeCastHit } from \"./toi\";\nimport { ShapeContact } from \"./contact\";\n/**\n * Flags affecting whether collision-detection happens between two colliders\n * depending on the type of rigid-bodies they are attached to.\n */\nexport var ActiveCollisionTypes;\n(function (ActiveCollisionTypes) {\n    /**\n     * Enable collision-detection between a collider attached to a dynamic body\n     * and another collider attached to a dynamic body.\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"DYNAMIC_DYNAMIC\"] = 1] = \"DYNAMIC_DYNAMIC\";\n    /**\n     * Enable collision-detection between a collider attached to a dynamic body\n     * and another collider attached to a kinematic body.\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"DYNAMIC_KINEMATIC\"] = 12] = \"DYNAMIC_KINEMATIC\";\n    /**\n     * Enable collision-detection between a collider attached to a dynamic body\n     * and another collider attached to a fixed body (or not attached to any body).\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"DYNAMIC_FIXED\"] = 2] = \"DYNAMIC_FIXED\";\n    /**\n     * Enable collision-detection between a collider attached to a kinematic body\n     * and another collider attached to a kinematic body.\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"KINEMATIC_KINEMATIC\"] = 52224] = \"KINEMATIC_KINEMATIC\";\n    /**\n     * Enable collision-detection between a collider attached to a kinematic body\n     * and another collider attached to a fixed body (or not attached to any body).\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"KINEMATIC_FIXED\"] = 8704] = \"KINEMATIC_FIXED\";\n    /**\n     * Enable collision-detection between a collider attached to a fixed body (or\n     * not attached to any body) and another collider attached to a fixed body (or\n     * not attached to any body).\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"FIXED_FIXED\"] = 32] = \"FIXED_FIXED\";\n    /**\n     * The default active collision types, enabling collisions between a dynamic body\n     * and another body of any type, but not enabling collisions between two non-dynamic bodies.\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"DEFAULT\"] = 15] = \"DEFAULT\";\n    /**\n     * Enable collisions between any kind of rigid-bodies (including between two non-dynamic bodies).\n     */\n    ActiveCollisionTypes[ActiveCollisionTypes[\"ALL\"] = 60943] = \"ALL\";\n})(ActiveCollisionTypes || (ActiveCollisionTypes = {}));\n/**\n * A geometric entity that can be attached to a body so it can be affected\n * by contacts and proximity queries.\n */\nexport class Collider {\n    constructor(colliderSet, handle, parent, shape) {\n        this.colliderSet = colliderSet;\n        this.handle = handle;\n        this._parent = parent;\n        this._shape = shape;\n    }\n    /** @internal */\n    finalizeDeserialization(bodies) {\n        if (this.handle != null) {\n            this._parent = bodies.get(this.colliderSet.raw.coParent(this.handle));\n        }\n    }\n    ensureShapeIsCached() {\n        if (!this._shape)\n            this._shape = Shape.fromRaw(this.colliderSet.raw, this.handle);\n    }\n    /**\n     * The shape of this collider.\n     */\n    get shape() {\n        this.ensureShapeIsCached();\n        return this._shape;\n    }\n    /**\n     * Set the internal cached JS shape to null.\n     *\n     * This can be useful if you want to free some memory (assuming you are not\n     * holding any other references to the shape object), or in order to force\n     * the recalculation of the JS shape (the next time the `shape` getter is\n     * accessed) from the WASM source of truth.\n     */\n    clearShapeCache() {\n        this._shape = null;\n    }\n    /**\n     * Checks if this collider is still valid (i.e. that it has\n     * not been deleted from the collider set yet).\n     */\n    isValid() {\n        return this.colliderSet.raw.contains(this.handle);\n    }\n    /**\n     * The world-space translation of this collider.\n     */\n    translation() {\n        return VectorOps.fromRaw(this.colliderSet.raw.coTranslation(this.handle));\n    }\n    /**\n     * The translation of this collider relative to its parent rigid-body.\n     *\n     * Returns `null` if the collider doesn’t have a parent rigid-body.\n     */\n    translationWrtParent() {\n        return VectorOps.fromRaw(this.colliderSet.raw.coTranslationWrtParent(this.handle));\n    }\n    /**\n     * The world-space orientation of this collider.\n     */\n    rotation() {\n        return RotationOps.fromRaw(this.colliderSet.raw.coRotation(this.handle));\n    }\n    /**\n     * The orientation of this collider relative to its parent rigid-body.\n     *\n     * Returns `null` if the collider doesn’t have a parent rigid-body.\n     */\n    rotationWrtParent() {\n        return RotationOps.fromRaw(this.colliderSet.raw.coRotationWrtParent(this.handle));\n    }\n    /**\n     * Is this collider a sensor?\n     */\n    isSensor() {\n        return this.colliderSet.raw.coIsSensor(this.handle);\n    }\n    /**\n     * Sets whether this collider is a sensor.\n     * @param isSensor - If `true`, the collider will be a sensor.\n     */\n    setSensor(isSensor) {\n        this.colliderSet.raw.coSetSensor(this.handle, isSensor);\n    }\n    /**\n     * Sets the new shape of the collider.\n     * @param shape - The collider’s new shape.\n     */\n    setShape(shape) {\n        let rawShape = shape.intoRaw();\n        this.colliderSet.raw.coSetShape(this.handle, rawShape);\n        rawShape.free();\n        this._shape = shape;\n    }\n    /**\n     * Sets whether this collider is enabled or not.\n     *\n     * @param enabled - Set to `false` to disable this collider (its parent rigid-body won’t be disabled automatically by this).\n     */\n    setEnabled(enabled) {\n        this.colliderSet.raw.coSetEnabled(this.handle, enabled);\n    }\n    /**\n     * Is this collider enabled?\n     */\n    isEnabled() {\n        return this.colliderSet.raw.coIsEnabled(this.handle);\n    }\n    /**\n     * Sets the restitution coefficient of the collider to be created.\n     *\n     * @param restitution - The restitution coefficient in `[0, 1]`. A value of 0 (the default) means no bouncing behavior\n     *                   while 1 means perfect bouncing (though energy may still be lost due to numerical errors of the\n     *                   constraints solver).\n     */\n    setRestitution(restitution) {\n        this.colliderSet.raw.coSetRestitution(this.handle, restitution);\n    }\n    /**\n     * Sets the friction coefficient of the collider to be created.\n     *\n     * @param friction - The friction coefficient. Must be greater or equal to 0. This is generally smaller than 1. The\n     *                   higher the coefficient, the stronger friction forces will be for contacts with the collider\n     *                   being built.\n     */\n    setFriction(friction) {\n        this.colliderSet.raw.coSetFriction(this.handle, friction);\n    }\n    /**\n     * Gets the rule used to combine the friction coefficients of two colliders\n     * colliders involved in a contact.\n     */\n    frictionCombineRule() {\n        return this.colliderSet.raw.coFrictionCombineRule(this.handle);\n    }\n    /**\n     * Sets the rule used to combine the friction coefficients of two colliders\n     * colliders involved in a contact.\n     *\n     * @param rule − The combine rule to apply.\n     */\n    setFrictionCombineRule(rule) {\n        this.colliderSet.raw.coSetFrictionCombineRule(this.handle, rule);\n    }\n    /**\n     * Gets the rule used to combine the restitution coefficients of two colliders\n     * colliders involved in a contact.\n     */\n    restitutionCombineRule() {\n        return this.colliderSet.raw.coRestitutionCombineRule(this.handle);\n    }\n    /**\n     * Sets the rule used to combine the restitution coefficients of two colliders\n     * colliders involved in a contact.\n     *\n     * @param rule − The combine rule to apply.\n     */\n    setRestitutionCombineRule(rule) {\n        this.colliderSet.raw.coSetRestitutionCombineRule(this.handle, rule);\n    }\n    /**\n     * Sets the collision groups used by this collider.\n     *\n     * Two colliders will interact iff. their collision groups are compatible.\n     * See the documentation of `InteractionGroups` for details on teh used bit pattern.\n     *\n     * @param groups - The collision groups used for the collider being built.\n     */\n    setCollisionGroups(groups) {\n        this.colliderSet.raw.coSetCollisionGroups(this.handle, groups);\n    }\n    /**\n     * Sets the solver groups used by this collider.\n     *\n     * Forces between two colliders in contact will be computed iff their solver\n     * groups are compatible.\n     * See the documentation of `InteractionGroups` for details on the used bit pattern.\n     *\n     * @param groups - The solver groups used for the collider being built.\n     */\n    setSolverGroups(groups) {\n        this.colliderSet.raw.coSetSolverGroups(this.handle, groups);\n    }\n    /**\n     * Sets the contact skin for this collider.\n     *\n     * See the documentation of `ColliderDesc.setContactSkin` for additional details.\n     */\n    contactSkin() {\n        return this.colliderSet.raw.coContactSkin(this.handle);\n    }\n    /**\n     * Sets the contact skin for this collider.\n     *\n     * See the documentation of `ColliderDesc.setContactSkin` for additional details.\n     *\n     * @param thickness - The contact skin thickness.\n     */\n    setContactSkin(thickness) {\n        return this.colliderSet.raw.coSetContactSkin(this.handle, thickness);\n    }\n    /**\n     * Get the physics hooks active for this collider.\n     */\n    activeHooks() {\n        return this.colliderSet.raw.coActiveHooks(this.handle);\n    }\n    /**\n     * Set the physics hooks active for this collider.\n     *\n     * Use this to enable custom filtering rules for contact/intersecstion pairs involving this collider.\n     *\n     * @param activeHooks - The hooks active for contact/intersection pairs involving this collider.\n     */\n    setActiveHooks(activeHooks) {\n        this.colliderSet.raw.coSetActiveHooks(this.handle, activeHooks);\n    }\n    /**\n     * The events active for this collider.\n     */\n    activeEvents() {\n        return this.colliderSet.raw.coActiveEvents(this.handle);\n    }\n    /**\n     * Set the events active for this collider.\n     *\n     * Use this to enable contact and/or intersection event reporting for this collider.\n     *\n     * @param activeEvents - The events active for contact/intersection pairs involving this collider.\n     */\n    setActiveEvents(activeEvents) {\n        this.colliderSet.raw.coSetActiveEvents(this.handle, activeEvents);\n    }\n    /**\n     * Gets the collision types active for this collider.\n     */\n    activeCollisionTypes() {\n        return this.colliderSet.raw.coActiveCollisionTypes(this.handle);\n    }\n    /**\n     * Sets the total force magnitude beyond which a contact force event can be emitted.\n     *\n     * @param threshold - The new force threshold.\n     */\n    setContactForceEventThreshold(threshold) {\n        return this.colliderSet.raw.coSetContactForceEventThreshold(this.handle, threshold);\n    }\n    /**\n     * The total force magnitude beyond which a contact force event can be emitted.\n     */\n    contactForceEventThreshold() {\n        return this.colliderSet.raw.coContactForceEventThreshold(this.handle);\n    }\n    /**\n     * Set the collision types active for this collider.\n     *\n     * @param activeCollisionTypes - The hooks active for contact/intersection pairs involving this collider.\n     */\n    setActiveCollisionTypes(activeCollisionTypes) {\n        this.colliderSet.raw.coSetActiveCollisionTypes(this.handle, activeCollisionTypes);\n    }\n    /**\n     * Sets the uniform density of this collider.\n     *\n     * This will override any previous mass-properties set by `this.setDensity`,\n     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,\n     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.\n     *\n     * The mass and angular inertia of this collider will be computed automatically based on its\n     * shape.\n     */\n    setDensity(density) {\n        this.colliderSet.raw.coSetDensity(this.handle, density);\n    }\n    /**\n     * Sets the mass of this collider.\n     *\n     * This will override any previous mass-properties set by `this.setDensity`,\n     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,\n     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.\n     *\n     * The angular inertia of this collider will be computed automatically based on its shape\n     * and this mass value.\n     */\n    setMass(mass) {\n        this.colliderSet.raw.coSetMass(this.handle, mass);\n    }\n    // #if DIM3\n    /**\n     * Sets the mass of this collider.\n     *\n     * This will override any previous mass-properties set by `this.setDensity`,\n     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,\n     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.\n     */\n    setMassProperties(mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame) {\n        let rawCom = VectorOps.intoRaw(centerOfMass);\n        let rawPrincipalInertia = VectorOps.intoRaw(principalAngularInertia);\n        let rawInertiaFrame = RotationOps.intoRaw(angularInertiaLocalFrame);\n        this.colliderSet.raw.coSetMassProperties(this.handle, mass, rawCom, rawPrincipalInertia, rawInertiaFrame);\n        rawCom.free();\n        rawPrincipalInertia.free();\n        rawInertiaFrame.free();\n    }\n    // #endif\n    /**\n     * Sets the translation of this collider.\n     *\n     * @param tra - The world-space position of the collider.\n     */\n    setTranslation(tra) {\n        // #if DIM3\n        this.colliderSet.raw.coSetTranslation(this.handle, tra.x, tra.y, tra.z);\n        // #endif\n    }\n    /**\n     * Sets the translation of this collider relative to its parent rigid-body.\n     *\n     * Does nothing if this collider isn't attached to a rigid-body.\n     *\n     * @param tra - The new translation of the collider relative to its parent.\n     */\n    setTranslationWrtParent(tra) {\n        // #if DIM3\n        this.colliderSet.raw.coSetTranslationWrtParent(this.handle, tra.x, tra.y, tra.z);\n        // #endif\n    }\n    // #if DIM3\n    /**\n     * Sets the rotation quaternion of this collider.\n     *\n     * This does nothing if a zero quaternion is provided.\n     *\n     * @param rotation - The rotation to set.\n     */\n    setRotation(rot) {\n        this.colliderSet.raw.coSetRotation(this.handle, rot.x, rot.y, rot.z, rot.w);\n    }\n    /**\n     * Sets the rotation quaternion of this collider relative to its parent rigid-body.\n     *\n     * This does nothing if a zero quaternion is provided or if this collider isn't\n     * attached to a rigid-body.\n     *\n     * @param rotation - The rotation to set.\n     */\n    setRotationWrtParent(rot) {\n        this.colliderSet.raw.coSetRotationWrtParent(this.handle, rot.x, rot.y, rot.z, rot.w);\n    }\n    // #endif\n    /**\n     * The type of the shape of this collider.\n     */\n    shapeType() {\n        return this.colliderSet.raw.coShapeType(this.handle);\n    }\n    /**\n     * The half-extents of this collider if it is a cuboid shape.\n     */\n    halfExtents() {\n        return VectorOps.fromRaw(this.colliderSet.raw.coHalfExtents(this.handle));\n    }\n    /**\n     * Sets the half-extents of this collider if it is a cuboid shape.\n     *\n     * @param newHalfExtents - desired half extents.\n     */\n    setHalfExtents(newHalfExtents) {\n        const rawPoint = VectorOps.intoRaw(newHalfExtents);\n        this.colliderSet.raw.coSetHalfExtents(this.handle, rawPoint);\n    }\n    /**\n     * The radius of this collider if it is a ball, cylinder, capsule, or cone shape.\n     */\n    radius() {\n        return this.colliderSet.raw.coRadius(this.handle);\n    }\n    /**\n     * Sets the radius of this collider if it is a ball, cylinder, capsule, or cone shape.\n     *\n     * @param newRadius - desired radius.\n     */\n    setRadius(newRadius) {\n        this.colliderSet.raw.coSetRadius(this.handle, newRadius);\n    }\n    /**\n     * The radius of the round edges of this collider if it is a round cylinder.\n     */\n    roundRadius() {\n        return this.colliderSet.raw.coRoundRadius(this.handle);\n    }\n    /**\n     * Sets the radius of the round edges of this collider if it has round edges.\n     *\n     * @param newBorderRadius - desired round edge radius.\n     */\n    setRoundRadius(newBorderRadius) {\n        this.colliderSet.raw.coSetRoundRadius(this.handle, newBorderRadius);\n    }\n    /**\n     * The half height of this collider if it is a cylinder, capsule, or cone shape.\n     */\n    halfHeight() {\n        return this.colliderSet.raw.coHalfHeight(this.handle);\n    }\n    /**\n     * Sets the half height of this collider if it is a cylinder, capsule, or cone shape.\n     *\n     * @param newHalfheight - desired half height.\n     */\n    setHalfHeight(newHalfheight) {\n        this.colliderSet.raw.coSetHalfHeight(this.handle, newHalfheight);\n    }\n    /**\n     * If this collider has a Voxels shape, this will mark the voxel at the\n     * given grid coordinates as filled or empty (depending on the `filled`\n     * argument).\n     *\n     * Each input value is assumed to be an integer.\n     *\n     * The operation is O(1), unless the provided coordinates are out of the\n     * bounds of the currently allocated internal grid in which case the grid\n     * will be grown automatically.\n     */\n    setVoxel(ix, iy, \n    // #if DIM3\n    iz, \n    // #endif\n    filled) {\n        this.colliderSet.raw.coSetVoxel(this.handle, ix, iy, \n        // #if DIM3\n        iz, \n        // #endif\n        filled);\n        // We modified the shape, invalidate it to keep our cache\n        // up-to-date the next time the user requests the shape data.\n        // PERF: this isn’t ideal for performances as this adds a\n        //       hidden, non-constant, cost.\n        this._shape = null;\n    }\n    /**\n     * If this and `voxels2` are voxel colliders, and a voxel from `this` was\n     * modified with `setVoxel`, this will ensure that a\n     * moving object transitioning across the boundaries of these colliders\n     * won’t suffer from the \"internal edges\" artifact.\n     *\n     * The indices `ix, iy, iz` indicate the integer coordinates of the voxel in\n     * the local coordinate frame of `this`.\n     *\n     * If the voxels in `voxels2` live in a different coordinate space from `this`,\n     * then the `shift_*` argument indicate the distance, in voxel units, between\n     * the origin of `this` to the origin of `voxels2`.\n     *\n     * This method is intended to be called between `this` and all the other\n     * voxels colliders with a domain intersecting `this` or sharing a domain\n     * boundary. This is an incremental maintenance of the effect of\n     * `combineVoxelStates`.\n     */\n    propagateVoxelChange(voxels2, ix, iy, \n    // #if DIM3\n    iz, \n    // #endif\n    shift_x, shift_y, \n    // #if DIM3\n    shift_z) {\n        this.colliderSet.raw.coPropagateVoxelChange(this.handle, voxels2.handle, ix, iy, \n        // #if DIM3\n        iz, \n        // #endif\n        shift_x, shift_y, \n        // #if DIM3\n        shift_z);\n        // We modified the shape, invalidate it to keep our cache\n        // up-to-date the next time the user requests the shape data.\n        // PERF: this isn’t ideal for performances as this adds a\n        //       hidden, non-constant, cost.\n        this._shape = null;\n    }\n    /**\n     * If this and `voxels2` are voxel colliders, this will ensure that a\n     * moving object transitioning across the boundaries of these colliders\n     * won’t suffer from the \"internal edges\" artifact.\n     *\n     * If the voxels in `voxels2` live in a different coordinate space from `this`,\n     * then the `shift_*` argument indicate the distance, in voxel units, between\n     * the origin of `this` to the origin of `voxels2`.\n     *\n     * This method is intended to be called once between all pairs of voxels\n     * colliders with intersecting domains or shared boundaries.\n     *\n     * If either voxels collider is then modified with `setVoxel`, the\n     * `propagateVoxelChange` method must be called to maintain the coupling\n     * between the voxels shapes after the modification.\n     */\n    combineVoxelStates(voxels2, shift_x, shift_y, \n    // #if DIM3\n    shift_z) {\n        this.colliderSet.raw.coCombineVoxelStates(this.handle, voxels2.handle, shift_x, shift_y, \n        // #if DIM3\n        shift_z);\n        // We modified the shape, invalidate it to keep our cache\n        // up-to-date the next time the user requests the shape data.\n        // PERF: this isn’t ideal for performances as this adds a\n        //       hidden, non-constant, cost.\n        this._shape = null;\n    }\n    /**\n     * If this collider has a triangle mesh, polyline, convex polygon, or convex polyhedron shape,\n     * this returns the vertex buffer of said shape.\n     */\n    vertices() {\n        return this.colliderSet.raw.coVertices(this.handle);\n    }\n    /**\n     * If this collider has a triangle mesh, polyline, or convex polyhedron shape,\n     * this returns the index buffer of said shape.\n     */\n    indices() {\n        return this.colliderSet.raw.coIndices(this.handle);\n    }\n    /**\n     * If this collider has a heightfield shape, this returns the heights buffer of\n     * the heightfield.\n     * In 3D, the returned height matrix is provided in column-major order.\n     */\n    heightfieldHeights() {\n        return this.colliderSet.raw.coHeightfieldHeights(this.handle);\n    }\n    /**\n     * If this collider has a heightfield shape, this returns the scale\n     * applied to it.\n     */\n    heightfieldScale() {\n        let scale = this.colliderSet.raw.coHeightfieldScale(this.handle);\n        return VectorOps.fromRaw(scale);\n    }\n    // #if DIM3\n    /**\n     * If this collider has a heightfield shape, this returns the number of\n     * rows of its height matrix.\n     */\n    heightfieldNRows() {\n        return this.colliderSet.raw.coHeightfieldNRows(this.handle);\n    }\n    /**\n     * If this collider has a heightfield shape, this returns the number of\n     * columns of its height matrix.\n     */\n    heightfieldNCols() {\n        return this.colliderSet.raw.coHeightfieldNCols(this.handle);\n    }\n    // #endif\n    /**\n     * The rigid-body this collider is attached to.\n     */\n    parent() {\n        return this._parent;\n    }\n    /**\n     * The friction coefficient of this collider.\n     */\n    friction() {\n        return this.colliderSet.raw.coFriction(this.handle);\n    }\n    /**\n     * The restitution coefficient of this collider.\n     */\n    restitution() {\n        return this.colliderSet.raw.coRestitution(this.handle);\n    }\n    /**\n     * The density of this collider.\n     */\n    density() {\n        return this.colliderSet.raw.coDensity(this.handle);\n    }\n    /**\n     * The mass of this collider.\n     */\n    mass() {\n        return this.colliderSet.raw.coMass(this.handle);\n    }\n    /**\n     * The volume of this collider.\n     */\n    volume() {\n        return this.colliderSet.raw.coVolume(this.handle);\n    }\n    /**\n     * The collision groups of this collider.\n     */\n    collisionGroups() {\n        return this.colliderSet.raw.coCollisionGroups(this.handle);\n    }\n    /**\n     * The solver groups of this collider.\n     */\n    solverGroups() {\n        return this.colliderSet.raw.coSolverGroups(this.handle);\n    }\n    /**\n     * Tests if this collider contains a point.\n     *\n     * @param point - The point to test.\n     */\n    containsPoint(point) {\n        let rawPoint = VectorOps.intoRaw(point);\n        let result = this.colliderSet.raw.coContainsPoint(this.handle, rawPoint);\n        rawPoint.free();\n        return result;\n    }\n    /**\n     * Find the projection of a point on this collider.\n     *\n     * @param point - The point to project.\n     * @param solid - If this is set to `true` then the collider shapes are considered to\n     *   be plain (if the point is located inside of a plain shape, its projection is the point\n     *   itself). If it is set to `false` the collider shapes are considered to be hollow\n     *   (if the point is located inside of an hollow shape, it is projected on the shape's\n     *   boundary).\n     */\n    projectPoint(point, solid) {\n        let rawPoint = VectorOps.intoRaw(point);\n        let result = PointProjection.fromRaw(this.colliderSet.raw.coProjectPoint(this.handle, rawPoint, solid));\n        rawPoint.free();\n        return result;\n    }\n    /**\n     * Tests if this collider intersects the given ray.\n     *\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     */\n    intersectsRay(ray, maxToi) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let result = this.colliderSet.raw.coIntersectsRay(this.handle, rawOrig, rawDir, maxToi);\n        rawOrig.free();\n        rawDir.free();\n        return result;\n    }\n    /*\n     * Computes the smallest time between this and the given shape under translational movement are separated by a distance smaller or equal to distance.\n     *\n     * @param collider1Vel - The constant velocity of the current shape to cast (i.e. the cast direction).\n     * @param shape2 - The shape to cast against.\n     * @param shape2Pos - The position of the second shape.\n     * @param shape2Rot - The rotation of the second shape.\n     * @param shape2Vel - The constant velocity of the second shape.\n     * @param targetDistance − If the shape moves closer to this distance from a collider, a hit\n     *                         will be returned.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the distance traveled by the shape to `collider1Vel.norm() * maxToi`.\n     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if\n     *   the shape is penetrating another shape at its starting point **and** its trajectory is such\n     *   that it’s on a path to exit that penetration state.\n     */\n    castShape(collider1Vel, shape2, shape2Pos, shape2Rot, shape2Vel, targetDistance, maxToi, stopAtPenetration) {\n        let rawCollider1Vel = VectorOps.intoRaw(collider1Vel);\n        let rawShape2Pos = VectorOps.intoRaw(shape2Pos);\n        let rawShape2Rot = RotationOps.intoRaw(shape2Rot);\n        let rawShape2Vel = VectorOps.intoRaw(shape2Vel);\n        let rawShape2 = shape2.intoRaw();\n        let result = ShapeCastHit.fromRaw(this.colliderSet, this.colliderSet.raw.coCastShape(this.handle, rawCollider1Vel, rawShape2, rawShape2Pos, rawShape2Rot, rawShape2Vel, targetDistance, maxToi, stopAtPenetration));\n        rawCollider1Vel.free();\n        rawShape2Pos.free();\n        rawShape2Rot.free();\n        rawShape2Vel.free();\n        rawShape2.free();\n        return result;\n    }\n    /*\n     * Computes the smallest time between this and the given collider under translational movement are separated by a distance smaller or equal to distance.\n     *\n     * @param collider1Vel - The constant velocity of the current collider to cast (i.e. the cast direction).\n     * @param collider2 - The collider to cast against.\n     * @param collider2Vel - The constant velocity of the second collider.\n     * @param targetDistance − If the shape moves closer to this distance from a collider, a hit\n     *                         will be returned.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.\n     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if\n     *   the shape is penetrating another shape at its starting point **and** its trajectory is such\n     *   that it’s on a path to exit that penetration state.\n     */\n    castCollider(collider1Vel, collider2, collider2Vel, targetDistance, maxToi, stopAtPenetration) {\n        let rawCollider1Vel = VectorOps.intoRaw(collider1Vel);\n        let rawCollider2Vel = VectorOps.intoRaw(collider2Vel);\n        let result = ColliderShapeCastHit.fromRaw(this.colliderSet, this.colliderSet.raw.coCastCollider(this.handle, rawCollider1Vel, collider2.handle, rawCollider2Vel, targetDistance, maxToi, stopAtPenetration));\n        rawCollider1Vel.free();\n        rawCollider2Vel.free();\n        return result;\n    }\n    intersectsShape(shape2, shapePos2, shapeRot2) {\n        let rawPos2 = VectorOps.intoRaw(shapePos2);\n        let rawRot2 = RotationOps.intoRaw(shapeRot2);\n        let rawShape2 = shape2.intoRaw();\n        let result = this.colliderSet.raw.coIntersectsShape(this.handle, rawShape2, rawPos2, rawRot2);\n        rawPos2.free();\n        rawRot2.free();\n        rawShape2.free();\n        return result;\n    }\n    /**\n     * Computes one pair of contact points between the shape owned by this collider and the given shape.\n     *\n     * @param shape2 - The second shape.\n     * @param shape2Pos - The initial position of the second shape.\n     * @param shape2Rot - The rotation of the second shape.\n     * @param prediction - The prediction value, if the shapes are separated by a distance greater than this value, test will fail.\n     * @returns `null` if the shapes are separated by a distance greater than prediction, otherwise contact details. The result is given in world-space.\n     */\n    contactShape(shape2, shape2Pos, shape2Rot, prediction) {\n        let rawPos2 = VectorOps.intoRaw(shape2Pos);\n        let rawRot2 = RotationOps.intoRaw(shape2Rot);\n        let rawShape2 = shape2.intoRaw();\n        let result = ShapeContact.fromRaw(this.colliderSet.raw.coContactShape(this.handle, rawShape2, rawPos2, rawRot2, prediction));\n        rawPos2.free();\n        rawRot2.free();\n        rawShape2.free();\n        return result;\n    }\n    /**\n     * Computes one pair of contact points between the collider and the given collider.\n     *\n     * @param collider2 - The second collider.\n     * @param prediction - The prediction value, if the shapes are separated by a distance greater than this value, test will fail.\n     * @returns `null` if the shapes are separated by a distance greater than prediction, otherwise contact details. The result is given in world-space.\n     */\n    contactCollider(collider2, prediction) {\n        let result = ShapeContact.fromRaw(this.colliderSet.raw.coContactCollider(this.handle, collider2.handle, prediction));\n        return result;\n    }\n    /**\n     * Find the closest intersection between a ray and this collider.\n     *\n     * This also computes the normal at the hit point.\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     * @returns The time-of-impact between this collider and the ray, or `-1` if there is no intersection.\n     */\n    castRay(ray, maxToi, solid) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let result = this.colliderSet.raw.coCastRay(this.handle, rawOrig, rawDir, maxToi, solid);\n        rawOrig.free();\n        rawDir.free();\n        return result;\n    }\n    /**\n     * Find the closest intersection between a ray and this collider.\n     *\n     * This also computes the normal at the hit point.\n     * @param ray - The ray to cast.\n     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively\n     *   limits the length of the ray to `ray.dir.norm() * maxToi`.\n     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its\n     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,\n     *   whereas `false` implies that all shapes are hollow for this ray-cast.\n     */\n    castRayAndGetNormal(ray, maxToi, solid) {\n        let rawOrig = VectorOps.intoRaw(ray.origin);\n        let rawDir = VectorOps.intoRaw(ray.dir);\n        let result = RayIntersection.fromRaw(this.colliderSet.raw.coCastRayAndGetNormal(this.handle, rawOrig, rawDir, maxToi, solid));\n        rawOrig.free();\n        rawDir.free();\n        return result;\n    }\n}\nexport var MassPropsMode;\n(function (MassPropsMode) {\n    MassPropsMode[MassPropsMode[\"Density\"] = 0] = \"Density\";\n    MassPropsMode[MassPropsMode[\"Mass\"] = 1] = \"Mass\";\n    MassPropsMode[MassPropsMode[\"MassProps\"] = 2] = \"MassProps\";\n})(MassPropsMode || (MassPropsMode = {}));\nexport class ColliderDesc {\n    /**\n     * Initializes a collider descriptor from the collision shape.\n     *\n     * @param shape - The shape of the collider being built.\n     */\n    constructor(shape) {\n        this.enabled = true;\n        this.shape = shape;\n        this.massPropsMode = MassPropsMode.Density;\n        this.density = 1.0;\n        this.friction = 0.5;\n        this.restitution = 0.0;\n        this.rotation = RotationOps.identity();\n        this.translation = VectorOps.zeros();\n        this.isSensor = false;\n        this.collisionGroups = 4294967295;\n        this.solverGroups = 4294967295;\n        this.frictionCombineRule = CoefficientCombineRule.Average;\n        this.restitutionCombineRule = CoefficientCombineRule.Average;\n        this.activeCollisionTypes = ActiveCollisionTypes.DEFAULT;\n        this.activeEvents = ActiveEvents.NONE;\n        this.activeHooks = ActiveHooks.NONE;\n        this.mass = 0.0;\n        this.centerOfMass = VectorOps.zeros();\n        this.contactForceEventThreshold = 0.0;\n        this.contactSkin = 0.0;\n        // #if DIM3\n        this.principalAngularInertia = VectorOps.zeros();\n        this.angularInertiaLocalFrame = RotationOps.identity();\n        // #endif\n    }\n    /**\n     * Create a new collider descriptor with a ball shape.\n     *\n     * @param radius - The radius of the ball.\n     */\n    static ball(radius) {\n        const shape = new Ball(radius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Create a new collider descriptor with a capsule shape.\n     *\n     * @param halfHeight - The half-height of the capsule, along the `y` axis.\n     * @param radius - The radius of the capsule basis.\n     */\n    static capsule(halfHeight, radius) {\n        const shape = new Capsule(halfHeight, radius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new segment shape.\n     *\n     * @param a - The first point of the segment.\n     * @param b - The second point of the segment.\n     */\n    static segment(a, b) {\n        const shape = new Segment(a, b);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new triangle shape.\n     *\n     * @param a - The first point of the triangle.\n     * @param b - The second point of the triangle.\n     * @param c - The third point of the triangle.\n     */\n    static triangle(a, b, c) {\n        const shape = new Triangle(a, b, c);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new triangle shape with round corners.\n     *\n     * @param a - The first point of the triangle.\n     * @param b - The second point of the triangle.\n     * @param c - The third point of the triangle.\n     * @param borderRadius - The radius of the borders of this triangle. In 3D,\n     *   this is also equal to half the thickness of the triangle.\n     */\n    static roundTriangle(a, b, c, borderRadius) {\n        const shape = new RoundTriangle(a, b, c, borderRadius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new collider descriptor with a polyline shape.\n     *\n     * @param vertices - The coordinates of the polyline's vertices.\n     * @param indices - The indices of the polyline's segments. If this is `undefined` or `null`,\n     *    the vertices are assumed to describe a line strip.\n     */\n    static polyline(vertices, indices) {\n        const shape = new Polyline(vertices, indices);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new collider descriptor with a shape made of voxels.\n     *\n     * @param data - Defines the set of voxels. If this is a `Int32Array` then\n     *               each voxel is defined from its (signed) grid coordinates,\n     *               with 3 (resp 2) contiguous integers per voxel in 3D (resp 2D).\n     *               If this is a `Float32Array`, each voxel will be such that\n     *               they contain at least one point from this array (where each\n     *               point is defined from 3 (resp 2) contiguous numbers per point\n     *               in 3D (resp 2D).\n     * @param voxelSize - The size of each voxel.\n     */\n    static voxels(voxels, voxelSize) {\n        const shape = new Voxels(voxels, voxelSize);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new collider descriptor with a triangle mesh shape.\n     *\n     * @param vertices - The coordinates of the triangle mesh's vertices.\n     * @param indices - The indices of the triangle mesh's triangles.\n     */\n    static trimesh(vertices, indices, flags) {\n        const shape = new TriMesh(vertices, indices, flags);\n        return new ColliderDesc(shape);\n    }\n    // #if DIM3\n    /**\n     * Creates a new collider descriptor with a cuboid shape.\n     *\n     * @param hx - The half-width of the rectangle along its local `x` axis.\n     * @param hy - The half-width of the rectangle along its local `y` axis.\n     * @param hz - The half-width of the rectangle along its local `z` axis.\n     */\n    static cuboid(hx, hy, hz) {\n        const shape = new Cuboid(hx, hy, hz);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new collider descriptor with a rectangular shape with round borders.\n     *\n     * @param hx - The half-width of the rectangle along its local `x` axis.\n     * @param hy - The half-width of the rectangle along its local `y` axis.\n     * @param hz - The half-width of the rectangle along its local `z` axis.\n     * @param borderRadius - The radius of the cuboid's borders.\n     */\n    static roundCuboid(hx, hy, hz, borderRadius) {\n        const shape = new RoundCuboid(hx, hy, hz, borderRadius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new collider descriptor with a heightfield shape.\n     *\n     * @param nrows − The number of rows in the heights matrix.\n     * @param ncols - The number of columns in the heights matrix.\n     * @param heights - The heights of the heightfield along its local `y` axis,\n     *                  provided as a matrix stored in column-major order.\n     * @param scale - The scale factor applied to the heightfield.\n     */\n    static heightfield(nrows, ncols, heights, scale, flags) {\n        const shape = new Heightfield(nrows, ncols, heights, scale, flags);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Create a new collider descriptor with a cylinder shape.\n     *\n     * @param halfHeight - The half-height of the cylinder, along the `y` axis.\n     * @param radius - The radius of the cylinder basis.\n     */\n    static cylinder(halfHeight, radius) {\n        const shape = new Cylinder(halfHeight, radius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Create a new collider descriptor with a cylinder shape with rounded corners.\n     *\n     * @param halfHeight - The half-height of the cylinder, along the `y` axis.\n     * @param radius - The radius of the cylinder basis.\n     * @param borderRadius - The radius of the cylinder's rounded edges and vertices.\n     */\n    static roundCylinder(halfHeight, radius, borderRadius) {\n        const shape = new RoundCylinder(halfHeight, radius, borderRadius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Create a new collider descriptor with a cone shape.\n     *\n     * @param halfHeight - The half-height of the cone, along the `y` axis.\n     * @param radius - The radius of the cone basis.\n     */\n    static cone(halfHeight, radius) {\n        const shape = new Cone(halfHeight, radius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Create a new collider descriptor with a cone shape with rounded corners.\n     *\n     * @param halfHeight - The half-height of the cone, along the `y` axis.\n     * @param radius - The radius of the cone basis.\n     * @param borderRadius - The radius of the cone's rounded edges and vertices.\n     */\n    static roundCone(halfHeight, radius, borderRadius) {\n        const shape = new RoundCone(halfHeight, radius, borderRadius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Computes the convex-hull of the given points and use the resulting\n     * convex polyhedron as the shape for this new collider descriptor.\n     *\n     * @param points - The point that will be used to compute the convex-hull.\n     */\n    static convexHull(points) {\n        const shape = new ConvexPolyhedron(points, null);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new collider descriptor that uses the given set of points assumed\n     * to form a convex polyline (no convex-hull computation will be done).\n     *\n     * @param vertices - The vertices of the convex polyline.\n     */\n    static convexMesh(vertices, indices) {\n        const shape = new ConvexPolyhedron(vertices, indices);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Computes the convex-hull of the given points and use the resulting\n     * convex polyhedron as the shape for this new collider descriptor. A\n     * border is added to that convex polyhedron to give it round corners.\n     *\n     * @param points - The point that will be used to compute the convex-hull.\n     * @param borderRadius - The radius of the round border added to the convex polyhedron.\n     */\n    static roundConvexHull(points, borderRadius) {\n        const shape = new RoundConvexPolyhedron(points, null, borderRadius);\n        return new ColliderDesc(shape);\n    }\n    /**\n     * Creates a new collider descriptor that uses the given set of points assumed\n     * to form a round convex polyline (no convex-hull computation will be done).\n     *\n     * @param vertices - The vertices of the convex polyline.\n     * @param borderRadius - The radius of the round border added to the convex polyline.\n     */\n    static roundConvexMesh(vertices, indices, borderRadius) {\n        const shape = new RoundConvexPolyhedron(vertices, indices, borderRadius);\n        return new ColliderDesc(shape);\n    }\n    // #endif\n    // #if DIM3\n    /**\n     * Sets the position of the collider to be created relative to the rigid-body it is attached to.\n     */\n    setTranslation(x, y, z) {\n        if (typeof x != \"number\" ||\n            typeof y != \"number\" ||\n            typeof z != \"number\")\n            throw TypeError(\"The translation components must be numbers.\");\n        this.translation = { x: x, y: y, z: z };\n        return this;\n    }\n    // #endif\n    /**\n     * Sets the rotation of the collider to be created relative to the rigid-body it is attached to.\n     *\n     * @param rot - The rotation of the collider to be created relative to the rigid-body it is attached to.\n     */\n    setRotation(rot) {\n        // #if DIM3\n        RotationOps.copy(this.rotation, rot);\n        // #endif\n        return this;\n    }\n    /**\n     * Sets whether or not the collider being created is a sensor.\n     *\n     * A sensor collider does not take part of the physics simulation, but generates\n     * proximity events.\n     *\n     * @param sensor - Set to `true` of the collider built is to be a sensor.\n     */\n    setSensor(sensor) {\n        this.isSensor = sensor;\n        return this;\n    }\n    /**\n     * Sets whether the created collider will be enabled or disabled.\n     * @param enabled − If set to `false` the collider will be disabled at creation.\n     */\n    setEnabled(enabled) {\n        this.enabled = enabled;\n        return this;\n    }\n    /**\n     * Sets the contact skin of the collider.\n     *\n     * The contact skin acts as if the collider was enlarged with a skin of width `skin_thickness`\n     * around it, keeping objects further apart when colliding.\n     *\n     * A non-zero contact skin can increase performance, and in some cases, stability. However\n     * it creates a small gap between colliding object (equal to the sum of their skin). If the\n     * skin is sufficiently small, this might not be visually significant or can be hidden by the\n     * rendering assets.\n     */\n    setContactSkin(thickness) {\n        this.contactSkin = thickness;\n        return this;\n    }\n    /**\n     * Sets the density of the collider being built.\n     *\n     * The mass and angular inertia tensor will be computed automatically based on this density and the collider’s shape.\n     *\n     * @param density - The density to set, must be greater or equal to 0. A density of 0 means that this collider\n     *                  will not affect the mass or angular inertia of the rigid-body it is attached to.\n     */\n    setDensity(density) {\n        this.massPropsMode = MassPropsMode.Density;\n        this.density = density;\n        return this;\n    }\n    /**\n     * Sets the mass of the collider being built.\n     *\n     * The angular inertia tensor will be computed automatically based on this mass and the collider’s shape.\n     *\n     * @param mass - The mass to set, must be greater or equal to 0.\n     */\n    setMass(mass) {\n        this.massPropsMode = MassPropsMode.Mass;\n        this.mass = mass;\n        return this;\n    }\n    // #if DIM3\n    /**\n     * Sets the mass properties of the collider being built.\n     *\n     * This replaces the mass-properties automatically computed from the collider's density and shape.\n     * These mass-properties will be added to the mass-properties of the rigid-body this collider will be attached to.\n     *\n     * @param mass − The mass of the collider to create.\n     * @param centerOfMass − The center-of-mass of the collider to create.\n     * @param principalAngularInertia − The initial principal angular inertia of the collider to create.\n     *                                  These are the eigenvalues of the angular inertia matrix.\n     * @param angularInertiaLocalFrame − The initial local angular inertia frame of the collider to create.\n     *                                   These are the eigenvectors of the angular inertia matrix.\n     */\n    setMassProperties(mass, centerOfMass, principalAngularInertia, angularInertiaLocalFrame) {\n        this.massPropsMode = MassPropsMode.MassProps;\n        this.mass = mass;\n        VectorOps.copy(this.centerOfMass, centerOfMass);\n        VectorOps.copy(this.principalAngularInertia, principalAngularInertia);\n        RotationOps.copy(this.angularInertiaLocalFrame, angularInertiaLocalFrame);\n        return this;\n    }\n    // #endif\n    /**\n     * Sets the restitution coefficient of the collider to be created.\n     *\n     * @param restitution - The restitution coefficient in `[0, 1]`. A value of 0 (the default) means no bouncing behavior\n     *                   while 1 means perfect bouncing (though energy may still be lost due to numerical errors of the\n     *                   constraints solver).\n     */\n    setRestitution(restitution) {\n        this.restitution = restitution;\n        return this;\n    }\n    /**\n     * Sets the friction coefficient of the collider to be created.\n     *\n     * @param friction - The friction coefficient. Must be greater or equal to 0. This is generally smaller than 1. The\n     *                   higher the coefficient, the stronger friction forces will be for contacts with the collider\n     *                   being built.\n     */\n    setFriction(friction) {\n        this.friction = friction;\n        return this;\n    }\n    /**\n     * Sets the rule used to combine the friction coefficients of two colliders\n     * colliders involved in a contact.\n     *\n     * @param rule − The combine rule to apply.\n     */\n    setFrictionCombineRule(rule) {\n        this.frictionCombineRule = rule;\n        return this;\n    }\n    /**\n     * Sets the rule used to combine the restitution coefficients of two colliders\n     * colliders involved in a contact.\n     *\n     * @param rule − The combine rule to apply.\n     */\n    setRestitutionCombineRule(rule) {\n        this.restitutionCombineRule = rule;\n        return this;\n    }\n    /**\n     * Sets the collision groups used by this collider.\n     *\n     * Two colliders will interact iff. their collision groups are compatible.\n     * See the documentation of `InteractionGroups` for details on teh used bit pattern.\n     *\n     * @param groups - The collision groups used for the collider being built.\n     */\n    setCollisionGroups(groups) {\n        this.collisionGroups = groups;\n        return this;\n    }\n    /**\n     * Sets the solver groups used by this collider.\n     *\n     * Forces between two colliders in contact will be computed iff their solver\n     * groups are compatible.\n     * See the documentation of `InteractionGroups` for details on the used bit pattern.\n     *\n     * @param groups - The solver groups used for the collider being built.\n     */\n    setSolverGroups(groups) {\n        this.solverGroups = groups;\n        return this;\n    }\n    /**\n     * Set the physics hooks active for this collider.\n     *\n     * Use this to enable custom filtering rules for contact/intersecstion pairs involving this collider.\n     *\n     * @param activeHooks - The hooks active for contact/intersection pairs involving this collider.\n     */\n    setActiveHooks(activeHooks) {\n        this.activeHooks = activeHooks;\n        return this;\n    }\n    /**\n     * Set the events active for this collider.\n     *\n     * Use this to enable contact and/or intersection event reporting for this collider.\n     *\n     * @param activeEvents - The events active for contact/intersection pairs involving this collider.\n     */\n    setActiveEvents(activeEvents) {\n        this.activeEvents = activeEvents;\n        return this;\n    }\n    /**\n     * Set the collision types active for this collider.\n     *\n     * @param activeCollisionTypes - The hooks active for contact/intersection pairs involving this collider.\n     */\n    setActiveCollisionTypes(activeCollisionTypes) {\n        this.activeCollisionTypes = activeCollisionTypes;\n        return this;\n    }\n    /**\n     * Sets the total force magnitude beyond which a contact force event can be emitted.\n     *\n     * @param threshold - The force threshold to set.\n     */\n    setContactForceEventThreshold(threshold) {\n        this.contactForceEventThreshold = threshold;\n        return this;\n    }\n}\n//# sourceMappingURL=collider.js.map"],"names":["ActiveCollisionTypes","MassPropsMode","Collider","constructor","colliderSet","handle","parent","shape","this","_parent","_shape","finalizeDeserialization","bodies","get","raw","coParent","ensureShapeIsCached","Shape","fromRaw","clearShapeCache","isValid","contains","translation","VectorOps","coTranslation","translationWrtParent","coTranslationWrtParent","rotation","RotationOps","coRotation","rotationWrtParent","coRotationWrtParent","isSensor","coIsSensor","setSensor","coSetSensor","setShape","rawShape","intoRaw","coSetShape","free","setEnabled","enabled","coSetEnabled","isEnabled","coIsEnabled","setRestitution","restitution","coSetRestitution","setFriction","friction","coSetFriction","frictionCombineRule","coFrictionCombineRule","setFrictionCombineRule","rule","coSetFrictionCombineRule","restitutionCombineRule","coRestitutionCombineRule","setRestitutionCombineRule","coSetRestitutionCombineRule","setCollisionGroups","groups","coSetCollisionGroups","setSolverGroups","coSetSolverGroups","contactSkin","coContactSkin","setContactSkin","thickness","coSetContactSkin","activeHooks","coActiveHooks","setActiveHooks","coSetActiveHooks","activeEvents","coActiveEvents","setActiveEvents","coSetActiveEvents","activeCollisionTypes","coActiveCollisionTypes","setContactForceEventThreshold","threshold","coSetContactForceEventThreshold","contactForceEventThreshold","coContactForceEventThreshold","setActiveCollisionTypes","coSetActiveCollisionTypes","setDensity","density","coSetDensity","setMass","mass","coSetMass","setMassProperties","centerOfMass","principalAngularInertia","angularInertiaLocalFrame","rawCom","rawPrincipalInertia","rawInertiaFrame","coSetMassProperties","setTranslation","tra","coSetTranslation","x","y","z","setTranslationWrtParent","coSetTranslationWrtParent","setRotation","rot","coSetRotation","w","setRotationWrtParent","coSetRotationWrtParent","shapeType","coShapeType","halfExtents","coHalfExtents","setHalfExtents","newHalfExtents","rawPoint","coSetHalfExtents","radius","coRadius","setRadius","newRadius","coSetRadius","roundRadius","coRoundRadius","setRoundRadius","newBorderRadius","coSetRoundRadius","halfHeight","coHalfHeight","setHalfHeight","newHalfheight","coSetHalfHeight","setVoxel","ix","iy","iz","filled","coSetVoxel","propagateVoxelChange","voxels2","shift_x","shift_y","shift_z","coPropagateVoxelChange","combineVoxelStates","coCombineVoxelStates","vertices","coVertices","indices","coIndices","heightfieldHeights","coHeightfieldHeights","heightfieldScale","scale","coHeightfieldScale","heightfieldNRows","coHeightfieldNRows","heightfieldNCols","coHeightfieldNCols","coFriction","coRestitution","coDensity","coMass","volume","coVolume","collisionGroups","coCollisionGroups","solverGroups","coSolverGroups","containsPoint","point","result","coContainsPoint","projectPoint","solid","PointProjection","coProjectPoint","intersectsRay","ray","maxToi","rawOrig","origin","rawDir","dir","coIntersectsRay","castShape","collider1Vel","shape2","shape2Pos","shape2Rot","shape2Vel","targetDistance","stopAtPenetration","rawCollider1Vel","rawShape2Pos","rawShape2Rot","rawShape2Vel","rawShape2","ShapeCastHit","coCastShape","castCollider","collider2","collider2Vel","rawCollider2Vel","ColliderShapeCastHit","coCastCollider","intersectsShape","shapePos2","shapeRot2","rawPos2","rawRot2","coIntersectsShape","contactShape","prediction","ShapeContact","coContactShape","contactCollider","coContactCollider","castRay","coCastRay","castRayAndGetNormal","RayIntersection","coCastRayAndGetNormal","ColliderDesc","massPropsMode","Density","identity","zeros","CoefficientCombineRule","Average","DEFAULT","ActiveEvents","NONE","ActiveHooks","ball","Ball","capsule","Capsule","segment","a","b","Segment","triangle","c","Triangle","roundTriangle","borderRadius","RoundTriangle","polyline","Polyline","voxels","voxelSize","Voxels","trimesh","flags","TriMesh","cuboid","hx","hy","hz","Cuboid","roundCuboid","RoundCuboid","heightfield","nrows","ncols","heights","Heightfield","cylinder","Cylinder","roundCylinder","RoundCylinder","cone","Cone","roundCone","RoundCone","convexHull","points","ConvexPolyhedron","convexMesh","roundConvexHull","RoundConvexPolyhedron","roundConvexMesh","TypeError","copy","sensor","Mass","MassProps"],"mappings":"gmBAgBU,IAACA,qBAozBAC,eAnzBX,SAAWD,sBAKPA,qBAAqBA,qBAAsC,gBAAI,GAAK,kBAKpEA,qBAAqBA,qBAAwC,kBAAI,IAAM,oBAKvEA,qBAAqBA,qBAAoC,cAAI,GAAK,gBAKlEA,qBAAqBA,qBAA0C,oBAAI,OAAS,sBAK5EA,qBAAqBA,qBAAsC,gBAAI,MAAQ,kBAMvEA,qBAAqBA,qBAAkC,YAAI,IAAM,cAKjEA,qBAAqBA,qBAA8B,QAAI,IAAM,UAI7DA,qBAAqBA,qBAA0B,IAAI,OAAS,KAC/D,CAzCD,CAyCGA,uBAAyBA,qBAAuB,CAAA,IAK5C,MAAME,SACT,WAAAC,CAAYC,YAAaC,OAAQC,OAAQC,OACrCC,KAAKJ,YAAcA,YACnBI,KAAKH,OAASA,OACdG,KAAKC,QAAUH,OACfE,KAAKE,OAASH,KAClB,CAEA,uBAAAI,CAAwBC,QACD,MAAfJ,KAAKH,SACLG,KAAKC,QAAUG,OAAOC,IAAIL,KAAKJ,YAAYU,IAAIC,SAASP,KAAKH,SAErE,CACA,mBAAAW,GACSR,KAAKE,SACNF,KAAKE,OAASO,MAAMC,QAAQV,KAAKJ,YAAYU,IAAKN,KAAKH,QAC/D,CAIA,SAAIE,GAEA,OADAC,KAAKQ,sBACER,KAAKE,MAChB,CASA,eAAAS,GACIX,KAAKE,OAAS,IAClB,CAKA,OAAAU,GACI,OAAOZ,KAAKJ,YAAYU,IAAIO,SAASb,KAAKH,OAC9C,CAIA,WAAAiB,GACI,OAAOC,UAAUL,QAAQV,KAAKJ,YAAYU,IAAIU,cAAchB,KAAKH,QACrE,CAMA,oBAAAoB,GACI,OAAOF,UAAUL,QAAQV,KAAKJ,YAAYU,IAAIY,uBAAuBlB,KAAKH,QAC9E,CAIA,QAAAsB,GACI,OAAOC,YAAYV,QAAQV,KAAKJ,YAAYU,IAAIe,WAAWrB,KAAKH,QACpE,CAMA,iBAAAyB,GACI,OAAOF,YAAYV,QAAQV,KAAKJ,YAAYU,IAAIiB,oBAAoBvB,KAAKH,QAC7E,CAIA,QAAA2B,GACI,OAAOxB,KAAKJ,YAAYU,IAAImB,WAAWzB,KAAKH,OAChD,CAKA,SAAA6B,CAAUF,UACNxB,KAAKJ,YAAYU,IAAIqB,YAAY3B,KAAKH,OAAQ2B,SAClD,CAKA,QAAAI,CAAS7B,OACL,IAAI8B,SAAW9B,MAAM+B,UACrB9B,KAAKJ,YAAYU,IAAIyB,WAAW/B,KAAKH,OAAQgC,UAC7CA,SAASG,OACThC,KAAKE,OAASH,KAClB,CAMA,UAAAkC,CAAWC,SACPlC,KAAKJ,YAAYU,IAAI6B,aAAanC,KAAKH,OAAQqC,QACnD,CAIA,SAAAE,GACI,OAAOpC,KAAKJ,YAAYU,IAAI+B,YAAYrC,KAAKH,OACjD,CAQA,cAAAyC,CAAeC,aACXvC,KAAKJ,YAAYU,IAAIkC,iBAAiBxC,KAAKH,OAAQ0C,YACvD,CAQA,WAAAE,CAAYC,UACR1C,KAAKJ,YAAYU,IAAIqC,cAAc3C,KAAKH,OAAQ6C,SACpD,CAKA,mBAAAE,GACI,OAAO5C,KAAKJ,YAAYU,IAAIuC,sBAAsB7C,KAAKH,OAC3D,CAOA,sBAAAiD,CAAuBC,MACnB/C,KAAKJ,YAAYU,IAAI0C,yBAAyBhD,KAAKH,OAAQkD,KAC/D,CAKA,sBAAAE,GACI,OAAOjD,KAAKJ,YAAYU,IAAI4C,yBAAyBlD,KAAKH,OAC9D,CAOA,yBAAAsD,CAA0BJ,MACtB/C,KAAKJ,YAAYU,IAAI8C,4BAA4BpD,KAAKH,OAAQkD,KAClE,CASA,kBAAAM,CAAmBC,QACftD,KAAKJ,YAAYU,IAAIiD,qBAAqBvD,KAAKH,OAAQyD,OAC3D,CAUA,eAAAE,CAAgBF,QACZtD,KAAKJ,YAAYU,IAAImD,kBAAkBzD,KAAKH,OAAQyD,OACxD,CAMA,WAAAI,GACI,OAAO1D,KAAKJ,YAAYU,IAAIqD,cAAc3D,KAAKH,OACnD,CAQA,cAAA+D,CAAeC,WACX,OAAO7D,KAAKJ,YAAYU,IAAIwD,iBAAiB9D,KAAKH,OAAQgE,UAC9D,CAIA,WAAAE,GACI,OAAO/D,KAAKJ,YAAYU,IAAI0D,cAAchE,KAAKH,OACnD,CAQA,cAAAoE,CAAeF,aACX/D,KAAKJ,YAAYU,IAAI4D,iBAAiBlE,KAAKH,OAAQkE,YACvD,CAIA,YAAAI,GACI,OAAOnE,KAAKJ,YAAYU,IAAI8D,eAAepE,KAAKH,OACpD,CAQA,eAAAwE,CAAgBF,cACZnE,KAAKJ,YAAYU,IAAIgE,kBAAkBtE,KAAKH,OAAQsE,aACxD,CAIA,oBAAAI,GACI,OAAOvE,KAAKJ,YAAYU,IAAIkE,uBAAuBxE,KAAKH,OAC5D,CAMA,6BAAA4E,CAA8BC,WAC1B,OAAO1E,KAAKJ,YAAYU,IAAIqE,gCAAgC3E,KAAKH,OAAQ6E,UAC7E,CAIA,0BAAAE,GACI,OAAO5E,KAAKJ,YAAYU,IAAIuE,6BAA6B7E,KAAKH,OAClE,CAMA,uBAAAiF,CAAwBP,sBACpBvE,KAAKJ,YAAYU,IAAIyE,0BAA0B/E,KAAKH,OAAQ0E,qBAChE,CAWA,UAAAS,CAAWC,SACPjF,KAAKJ,YAAYU,IAAI4E,aAAalF,KAAKH,OAAQoF,QACnD,CAWA,OAAAE,CAAQC,MACJpF,KAAKJ,YAAYU,IAAI+E,UAAUrF,KAAKH,OAAQuF,KAChD,CASA,iBAAAE,CAAkBF,KAAMG,aAAcC,wBAAyBC,0BAC3D,IAAIC,OAAS3E,UAAUe,QAAQyD,cAC3BI,oBAAsB5E,UAAUe,QAAQ0D,yBACxCI,gBAAkBxE,YAAYU,QAAQ2D,0BAC1CzF,KAAKJ,YAAYU,IAAIuF,oBAAoB7F,KAAKH,OAAQuF,KAAMM,OAAQC,oBAAqBC,iBACzFF,OAAO1D,OACP2D,oBAAoB3D,OACpB4D,gBAAgB5D,MACpB,CAOA,cAAA8D,CAAeC,KAEX/F,KAAKJ,YAAYU,IAAI0F,iBAAiBhG,KAAKH,OAAQkG,IAAIE,EAAGF,IAAIG,EAAGH,IAAII,EAEzE,CAQA,uBAAAC,CAAwBL,KAEpB/F,KAAKJ,YAAYU,IAAI+F,0BAA0BrG,KAAKH,OAAQkG,IAAIE,EAAGF,IAAIG,EAAGH,IAAII,EAElF,CASA,WAAAG,CAAYC,KACRvG,KAAKJ,YAAYU,IAAIkG,cAAcxG,KAAKH,OAAQ0G,IAAIN,EAAGM,IAAIL,EAAGK,IAAIJ,EAAGI,IAAIE,EAC7E,CASA,oBAAAC,CAAqBH,KACjBvG,KAAKJ,YAAYU,IAAIqG,uBAAuB3G,KAAKH,OAAQ0G,IAAIN,EAAGM,IAAIL,EAAGK,IAAIJ,EAAGI,IAAIE,EACtF,CAKA,SAAAG,GACI,OAAO5G,KAAKJ,YAAYU,IAAIuG,YAAY7G,KAAKH,OACjD,CAIA,WAAAiH,GACI,OAAO/F,UAAUL,QAAQV,KAAKJ,YAAYU,IAAIyG,cAAc/G,KAAKH,QACrE,CAMA,cAAAmH,CAAeC,gBACX,MAAMC,SAAWnG,UAAUe,QAAQmF,gBACnCjH,KAAKJ,YAAYU,IAAI6G,iBAAiBnH,KAAKH,OAAQqH,SACvD,CAIA,MAAAE,GACI,OAAOpH,KAAKJ,YAAYU,IAAI+G,SAASrH,KAAKH,OAC9C,CAMA,SAAAyH,CAAUC,WACNvH,KAAKJ,YAAYU,IAAIkH,YAAYxH,KAAKH,OAAQ0H,UAClD,CAIA,WAAAE,GACI,OAAOzH,KAAKJ,YAAYU,IAAIoH,cAAc1H,KAAKH,OACnD,CAMA,cAAA8H,CAAeC,iBACX5H,KAAKJ,YAAYU,IAAIuH,iBAAiB7H,KAAKH,OAAQ+H,gBACvD,CAIA,UAAAE,GACI,OAAO9H,KAAKJ,YAAYU,IAAIyH,aAAa/H,KAAKH,OAClD,CAMA,aAAAmI,CAAcC,eACVjI,KAAKJ,YAAYU,IAAI4H,gBAAgBlI,KAAKH,OAAQoI,cACtD,CAYA,QAAAE,CAASC,GAAIC,GAEbC,GAEAC,QACIvI,KAAKJ,YAAYU,IAAIkI,WAAWxI,KAAKH,OAAQuI,GAAIC,GAEjDC,GAEAC,QAKAvI,KAAKE,OAAS,IAClB,CAmBA,oBAAAuI,CAAqBC,QAASN,GAAIC,GAElCC,GAEAK,QAASC,QAETC,SACI7I,KAAKJ,YAAYU,IAAIwI,uBAAuB9I,KAAKH,OAAQ6I,QAAQ7I,OAAQuI,GAAIC,GAE7EC,GAEAK,QAASC,QAETC,SAKA7I,KAAKE,OAAS,IAClB,CAiBA,kBAAA6I,CAAmBL,QAASC,QAASC,QAErCC,SACI7I,KAAKJ,YAAYU,IAAI0I,qBAAqBhJ,KAAKH,OAAQ6I,QAAQ7I,OAAQ8I,QAASC,QAEhFC,SAKA7I,KAAKE,OAAS,IAClB,CAKA,QAAA+I,GACI,OAAOjJ,KAAKJ,YAAYU,IAAI4I,WAAWlJ,KAAKH,OAChD,CAKA,OAAAsJ,GACI,OAAOnJ,KAAKJ,YAAYU,IAAI8I,UAAUpJ,KAAKH,OAC/C,CAMA,kBAAAwJ,GACI,OAAOrJ,KAAKJ,YAAYU,IAAIgJ,qBAAqBtJ,KAAKH,OAC1D,CAKA,gBAAA0J,GACI,IAAIC,MAAQxJ,KAAKJ,YAAYU,IAAImJ,mBAAmBzJ,KAAKH,QACzD,OAAOkB,UAAUL,QAAQ8I,MAC7B,CAMA,gBAAAE,GACI,OAAO1J,KAAKJ,YAAYU,IAAIqJ,mBAAmB3J,KAAKH,OACxD,CAKA,gBAAA+J,GACI,OAAO5J,KAAKJ,YAAYU,IAAIuJ,mBAAmB7J,KAAKH,OACxD,CAKA,MAAAC,GACI,OAAOE,KAAKC,OAChB,CAIA,QAAAyC,GACI,OAAO1C,KAAKJ,YAAYU,IAAIwJ,WAAW9J,KAAKH,OAChD,CAIA,WAAA0C,GACI,OAAOvC,KAAKJ,YAAYU,IAAIyJ,cAAc/J,KAAKH,OACnD,CAIA,OAAAoF,GACI,OAAOjF,KAAKJ,YAAYU,IAAI0J,UAAUhK,KAAKH,OAC/C,CAIA,IAAAuF,GACI,OAAOpF,KAAKJ,YAAYU,IAAI2J,OAAOjK,KAAKH,OAC5C,CAIA,MAAAqK,GACI,OAAOlK,KAAKJ,YAAYU,IAAI6J,SAASnK,KAAKH,OAC9C,CAIA,eAAAuK,GACI,OAAOpK,KAAKJ,YAAYU,IAAI+J,kBAAkBrK,KAAKH,OACvD,CAIA,YAAAyK,GACI,OAAOtK,KAAKJ,YAAYU,IAAIiK,eAAevK,KAAKH,OACpD,CAMA,aAAA2K,CAAcC,OACV,IAAIvD,SAAWnG,UAAUe,QAAQ2I,OAC7BC,OAAS1K,KAAKJ,YAAYU,IAAIqK,gBAAgB3K,KAAKH,OAAQqH,UAE/D,OADAA,SAASlF,OACF0I,MACX,CAWA,YAAAE,CAAaH,MAAOI,OAChB,IAAI3D,SAAWnG,UAAUe,QAAQ2I,OAC7BC,OAASI,gBAAgBpK,QAAQV,KAAKJ,YAAYU,IAAIyK,eAAe/K,KAAKH,OAAQqH,SAAU2D,QAEhG,OADA3D,SAASlF,OACF0I,MACX,CAQA,aAAAM,CAAcC,IAAKC,QACf,IAAIC,QAAUpK,UAAUe,QAAQmJ,IAAIG,QAChCC,OAAStK,UAAUe,QAAQmJ,IAAIK,KAC/BZ,OAAS1K,KAAKJ,YAAYU,IAAIiL,gBAAgBvL,KAAKH,OAAQsL,QAASE,OAAQH,QAGhF,OAFAC,QAAQnJ,OACRqJ,OAAOrJ,OACA0I,MACX,CAiBA,SAAAc,CAAUC,aAAcC,OAAQC,UAAWC,UAAWC,UAAWC,eAAgBZ,OAAQa,mBACrF,IAAIC,gBAAkBjL,UAAUe,QAAQ2J,cACpCQ,aAAelL,UAAUe,QAAQ6J,WACjCO,aAAe9K,YAAYU,QAAQ8J,WACnCO,aAAepL,UAAUe,QAAQ+J,WACjCO,UAAYV,OAAO5J,UACnB4I,OAAS2B,aAAa3L,QAAQV,KAAKJ,YAAaI,KAAKJ,YAAYU,IAAIgM,YAAYtM,KAAKH,OAAQmM,gBAAiBI,UAAWH,aAAcC,aAAcC,aAAcL,eAAgBZ,OAAQa,oBAMhM,OALAC,gBAAgBhK,OAChBiK,aAAajK,OACbkK,aAAalK,OACbmK,aAAanK,OACboK,UAAUpK,OACH0I,MACX,CAeA,YAAA6B,CAAad,aAAce,UAAWC,aAAcX,eAAgBZ,OAAQa,mBACxE,IAAIC,gBAAkBjL,UAAUe,QAAQ2J,cACpCiB,gBAAkB3L,UAAUe,QAAQ2K,cACpC/B,OAASiC,qBAAqBjM,QAAQV,KAAKJ,YAAaI,KAAKJ,YAAYU,IAAIsM,eAAe5M,KAAKH,OAAQmM,gBAAiBQ,UAAU3M,OAAQ6M,gBAAiBZ,eAAgBZ,OAAQa,oBAGzL,OAFAC,gBAAgBhK,OAChB0K,gBAAgB1K,OACT0I,MACX,CACA,eAAAmC,CAAgBnB,OAAQoB,UAAWC,WAC/B,IAAIC,QAAUjM,UAAUe,QAAQgL,WAC5BG,QAAU7L,YAAYU,QAAQiL,WAC9BX,UAAYV,OAAO5J,UACnB4I,OAAS1K,KAAKJ,YAAYU,IAAI4M,kBAAkBlN,KAAKH,OAAQuM,UAAWY,QAASC,SAIrF,OAHAD,QAAQhL,OACRiL,QAAQjL,OACRoK,UAAUpK,OACH0I,MACX,CAUA,YAAAyC,CAAazB,OAAQC,UAAWC,UAAWwB,YACvC,IAAIJ,QAAUjM,UAAUe,QAAQ6J,WAC5BsB,QAAU7L,YAAYU,QAAQ8J,WAC9BQ,UAAYV,OAAO5J,UACnB4I,OAAS2C,aAAa3M,QAAQV,KAAKJ,YAAYU,IAAIgN,eAAetN,KAAKH,OAAQuM,UAAWY,QAASC,QAASG,aAIhH,OAHAJ,QAAQhL,OACRiL,QAAQjL,OACRoK,UAAUpK,OACH0I,MACX,CAQA,eAAA6C,CAAgBf,UAAWY,YAEvB,OADaC,aAAa3M,QAAQV,KAAKJ,YAAYU,IAAIkN,kBAAkBxN,KAAKH,OAAQ2M,UAAU3M,OAAQuN,YAE5G,CAaA,OAAAK,CAAQxC,IAAKC,OAAQL,OACjB,IAAIM,QAAUpK,UAAUe,QAAQmJ,IAAIG,QAChCC,OAAStK,UAAUe,QAAQmJ,IAAIK,KAC/BZ,OAAS1K,KAAKJ,YAAYU,IAAIoN,UAAU1N,KAAKH,OAAQsL,QAASE,OAAQH,OAAQL,OAGlF,OAFAM,QAAQnJ,OACRqJ,OAAOrJ,OACA0I,MACX,CAYA,mBAAAiD,CAAoB1C,IAAKC,OAAQL,OAC7B,IAAIM,QAAUpK,UAAUe,QAAQmJ,IAAIG,QAChCC,OAAStK,UAAUe,QAAQmJ,IAAIK,KAC/BZ,OAASkD,gBAAgBlN,QAAQV,KAAKJ,YAAYU,IAAIuN,sBAAsB7N,KAAKH,OAAQsL,QAASE,OAAQH,OAAQL,QAGtH,OAFAM,QAAQnJ,OACRqJ,OAAOrJ,OACA0I,MACX,GAGJ,SAAWjL,eACPA,cAAcA,cAAuB,QAAI,GAAK,UAC9CA,cAAcA,cAAoB,KAAI,GAAK,OAC3CA,cAAcA,cAAyB,UAAI,GAAK,WACnD,CAJD,CAIGA,gBAAkBA,cAAgB,CAAA,IAC9B,MAAMqO,aAMT,WAAAnO,CAAYI,OACRC,KAAKkC,SAAU,EACflC,KAAKD,MAAQA,MACbC,KAAK+N,cAAgBtO,cAAcuO,QACnChO,KAAKiF,QAAU,EACfjF,KAAK0C,SAAW,GAChB1C,KAAKuC,YAAc,EACnBvC,KAAKmB,SAAWC,YAAY6M,WAC5BjO,KAAKc,YAAcC,UAAUmN,QAC7BlO,KAAKwB,UAAW,EAChBxB,KAAKoK,gBAAkB,WACvBpK,KAAKsK,aAAe,WACpBtK,KAAK4C,oBAAsBuL,uBAAuBC,QAClDpO,KAAKiD,uBAAyBkL,uBAAuBC,QACrDpO,KAAKuE,qBAAuB/E,qBAAqB6O,QACjDrO,KAAKmE,aAAemK,aAAaC,KACjCvO,KAAK+D,YAAcyK,YAAYD,KAC/BvO,KAAKoF,KAAO,EACZpF,KAAKuF,aAAexE,UAAUmN,QAC9BlO,KAAK4E,2BAA6B,EAClC5E,KAAK0D,YAAc,EAEnB1D,KAAKwF,wBAA0BzE,UAAUmN,QACzClO,KAAKyF,yBAA2BrE,YAAY6M,UAEhD,CAMA,WAAOQ,CAAKrH,QACR,MAAMrH,MAAQ,IAAI2O,KAAKtH,QACvB,OAAO,IAAI0G,aAAa/N,MAC5B,CAOA,cAAO4O,CAAQ7G,WAAYV,QACvB,MAAMrH,MAAQ,IAAI6O,QAAQ9G,WAAYV,QACtC,OAAO,IAAI0G,aAAa/N,MAC5B,CAOA,cAAO8O,CAAQC,EAAGC,GACd,MAAMhP,MAAQ,IAAIiP,QAAQF,EAAGC,GAC7B,OAAO,IAAIjB,aAAa/N,MAC5B,CAQA,eAAOkP,CAASH,EAAGC,EAAGG,GAClB,MAAMnP,MAAQ,IAAIoP,SAASL,EAAGC,EAAGG,GACjC,OAAO,IAAIpB,aAAa/N,MAC5B,CAUA,oBAAOqP,CAAcN,EAAGC,EAAGG,EAAGG,cAC1B,MAAMtP,MAAQ,IAAIuP,cAAcR,EAAGC,EAAGG,EAAGG,cACzC,OAAO,IAAIvB,aAAa/N,MAC5B,CAQA,eAAOwP,CAAStG,SAAUE,SACtB,MAAMpJ,MAAQ,IAAIyP,SAASvG,SAAUE,SACrC,OAAO,IAAI2E,aAAa/N,MAC5B,CAaA,aAAO0P,CAAOA,OAAQC,WAClB,MAAM3P,MAAQ,IAAI4P,OAAOF,OAAQC,WACjC,OAAO,IAAI5B,aAAa/N,MAC5B,CAOA,cAAO6P,CAAQ3G,SAAUE,QAAS0G,OAC9B,MAAM9P,MAAQ,IAAI+P,QAAQ7G,SAAUE,QAAS0G,OAC7C,OAAO,IAAI/B,aAAa/N,MAC5B,CASA,aAAOgQ,CAAOC,GAAIC,GAAIC,IAClB,MAAMnQ,MAAQ,IAAIoQ,OAAOH,GAAIC,GAAIC,IACjC,OAAO,IAAIpC,aAAa/N,MAC5B,CASA,kBAAOqQ,CAAYJ,GAAIC,GAAIC,GAAIb,cAC3B,MAAMtP,MAAQ,IAAIsQ,YAAYL,GAAIC,GAAIC,GAAIb,cAC1C,OAAO,IAAIvB,aAAa/N,MAC5B,CAUA,kBAAOuQ,CAAYC,MAAOC,MAAOC,QAASjH,MAAOqG,OAC7C,MAAM9P,MAAQ,IAAI2Q,YAAYH,MAAOC,MAAOC,QAASjH,MAAOqG,OAC5D,OAAO,IAAI/B,aAAa/N,MAC5B,CAOA,eAAO4Q,CAAS7I,WAAYV,QACxB,MAAMrH,MAAQ,IAAI6Q,SAAS9I,WAAYV,QACvC,OAAO,IAAI0G,aAAa/N,MAC5B,CAQA,oBAAO8Q,CAAc/I,WAAYV,OAAQiI,cACrC,MAAMtP,MAAQ,IAAI+Q,cAAchJ,WAAYV,OAAQiI,cACpD,OAAO,IAAIvB,aAAa/N,MAC5B,CAOA,WAAOgR,CAAKjJ,WAAYV,QACpB,MAAMrH,MAAQ,IAAIiR,KAAKlJ,WAAYV,QACnC,OAAO,IAAI0G,aAAa/N,MAC5B,CAQA,gBAAOkR,CAAUnJ,WAAYV,OAAQiI,cACjC,MAAMtP,MAAQ,IAAImR,UAAUpJ,WAAYV,OAAQiI,cAChD,OAAO,IAAIvB,aAAa/N,MAC5B,CAOA,iBAAOoR,CAAWC,QACd,MAAMrR,MAAQ,IAAIsR,iBAAiBD,OAAQ,MAC3C,OAAO,IAAItD,aAAa/N,MAC5B,CAOA,iBAAOuR,CAAWrI,SAAUE,SACxB,MAAMpJ,MAAQ,IAAIsR,iBAAiBpI,SAAUE,SAC7C,OAAO,IAAI2E,aAAa/N,MAC5B,CASA,sBAAOwR,CAAgBH,OAAQ/B,cAC3B,MAAMtP,MAAQ,IAAIyR,sBAAsBJ,OAAQ,KAAM/B,cACtD,OAAO,IAAIvB,aAAa/N,MAC5B,CAQA,sBAAO0R,CAAgBxI,SAAUE,QAASkG,cACtC,MAAMtP,MAAQ,IAAIyR,sBAAsBvI,SAAUE,QAASkG,cAC3D,OAAO,IAAIvB,aAAa/N,MAC5B,CAMA,cAAA+F,CAAeG,EAAGC,EAAGC,GACjB,GAAgB,iBAALF,GACK,iBAALC,GACK,iBAALC,EACP,MAAMuL,UAAU,+CAEpB,OADA1R,KAAKc,YAAc,CAAEmF,EAAGA,EAAGC,EAAGA,EAAGC,EAAGA,GAC7BnG,IACX,CAOA,WAAAsG,CAAYC,KAIR,OAFAnF,YAAYuQ,KAAK3R,KAAKmB,SAAUoF,KAEzBvG,IACX,CASA,SAAA0B,CAAUkQ,QAEN,OADA5R,KAAKwB,SAAWoQ,OACT5R,IACX,CAKA,UAAAiC,CAAWC,SAEP,OADAlC,KAAKkC,QAAUA,QACRlC,IACX,CAYA,cAAA4D,CAAeC,WAEX,OADA7D,KAAK0D,YAAcG,UACZ7D,IACX,CASA,UAAAgF,CAAWC,SAGP,OAFAjF,KAAK+N,cAAgBtO,cAAcuO,QACnChO,KAAKiF,QAAUA,QACRjF,IACX,CAQA,OAAAmF,CAAQC,MAGJ,OAFApF,KAAK+N,cAAgBtO,cAAcoS,KACnC7R,KAAKoF,KAAOA,KACLpF,IACX,CAeA,iBAAAsF,CAAkBF,KAAMG,aAAcC,wBAAyBC,0BAM3D,OALAzF,KAAK+N,cAAgBtO,cAAcqS,UACnC9R,KAAKoF,KAAOA,KACZrE,UAAU4Q,KAAK3R,KAAKuF,aAAcA,cAClCxE,UAAU4Q,KAAK3R,KAAKwF,wBAAyBA,yBAC7CpE,YAAYuQ,KAAK3R,KAAKyF,yBAA0BA,0BACzCzF,IACX,CASA,cAAAsC,CAAeC,aAEX,OADAvC,KAAKuC,YAAcA,YACZvC,IACX,CAQA,WAAAyC,CAAYC,UAER,OADA1C,KAAK0C,SAAWA,SACT1C,IACX,CAOA,sBAAA8C,CAAuBC,MAEnB,OADA/C,KAAK4C,oBAAsBG,KACpB/C,IACX,CAOA,yBAAAmD,CAA0BJ,MAEtB,OADA/C,KAAKiD,uBAAyBF,KACvB/C,IACX,CASA,kBAAAqD,CAAmBC,QAEf,OADAtD,KAAKoK,gBAAkB9G,OAChBtD,IACX,CAUA,eAAAwD,CAAgBF,QAEZ,OADAtD,KAAKsK,aAAehH,OACbtD,IACX,CAQA,cAAAiE,CAAeF,aAEX,OADA/D,KAAK+D,YAAcA,YACZ/D,IACX,CAQA,eAAAqE,CAAgBF,cAEZ,OADAnE,KAAKmE,aAAeA,aACbnE,IACX,CAMA,uBAAA8E,CAAwBP,sBAEpB,OADAvE,KAAKuE,qBAAuBA,qBACrBvE,IACX,CAMA,6BAAAyE,CAA8BC,WAE1B,OADA1E,KAAK4E,2BAA6BF,UAC3B1E,IACX","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/collider_set.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";import{Coarena}from"../coarena.js";import{VectorOps,RotationOps}from"../math.js";import{Collider}from"./collider.js";import{RawColliderSet}from"../rapier_wasm3d_bg.js";class ColliderSet{free(){this.raw&&this.raw.free(),this.raw=void 0,this.map&&this.map.clear(),this.map=void 0}constructor(raw){this.raw=raw||new RawColliderSet,this.map=new Coarena,raw&&raw.forEachColliderHandle(handle=>{this.map.set(handle,new Collider(this,handle,null))})}castClosure(f){return handle=>f?f(this.get(handle)):void 0}finalizeDeserialization(bodies){this.map.forEach(collider=>collider.finalizeDeserialization(bodies))}createCollider(bodies,desc,parentHandle){let hasParent=null!=parentHandle&&null!=parentHandle;if(hasParent&&isNaN(parentHandle))throw Error("Cannot create a collider with a parent rigid-body handle that is not a number.");let rawShape=desc.shape.intoRaw(),rawTra=VectorOps.intoRaw(desc.translation),rawRot=RotationOps.intoRaw(desc.rotation),rawCom=VectorOps.intoRaw(desc.centerOfMass),rawPrincipalInertia=VectorOps.intoRaw(desc.principalAngularInertia),rawInertiaFrame=RotationOps.intoRaw(desc.angularInertiaLocalFrame),handle=this.raw.createCollider(desc.enabled,rawShape,rawTra,rawRot,desc.massPropsMode,desc.mass,rawCom,rawPrincipalInertia,rawInertiaFrame,desc.density,desc.friction,desc.restitution,desc.frictionCombineRule,desc.restitutionCombineRule,desc.isSensor,desc.collisionGroups,desc.solverGroups,desc.activeCollisionTypes,desc.activeHooks,desc.activeEvents,desc.contactForceEventThreshold,desc.contactSkin,hasParent,hasParent?parentHandle:0,bodies.raw);rawShape.free(),rawTra.free(),rawRot.free(),rawCom.free(),rawPrincipalInertia.free(),rawInertiaFrame.free();let parent=hasParent?bodies.get(parentHandle):null,collider=new Collider(this,handle,parent,desc.shape);return this.map.set(handle,collider),collider}remove(handle,islands,bodies,wakeUp){this.raw.remove(handle,islands.raw,bodies.raw,wakeUp),this.unmap(handle)}unmap(handle){this.map.delete(handle)}get(handle){return this.map.get(handle)}len(){return this.map.len()}contains(handle){return null!=this.get(handle)}forEach(f){this.map.forEach(f)}getAll(){return this.map.getAll()}}export{ColliderSet};
+//# sourceMappingURL=collider_set.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/collider_set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collider_set.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/collider_set.js"],"sourcesContent":["import { RawColliderSet } from \"../raw\";\nimport { Coarena } from \"../coarena\";\nimport { RotationOps, VectorOps } from \"../math\";\nimport { Collider } from \"./collider\";\n/**\n * A set of rigid bodies that can be handled by a physics pipeline.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `colliderSet.free()`\n * once you are done using it (and all the rigid-bodies it created).\n */\nexport class ColliderSet {\n    /**\n     * Release the WASM memory occupied by this collider set.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n        if (!!this.map) {\n            this.map.clear();\n        }\n        this.map = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawColliderSet();\n        this.map = new Coarena();\n        // Initialize the map with the existing elements, if any.\n        if (raw) {\n            raw.forEachColliderHandle((handle) => {\n                this.map.set(handle, new Collider(this, handle, null));\n            });\n        }\n    }\n    /** @internal */\n    castClosure(f) {\n        return (handle) => {\n            if (!!f) {\n                return f(this.get(handle));\n            }\n            else {\n                return undefined;\n            }\n        };\n    }\n    /** @internal */\n    finalizeDeserialization(bodies) {\n        this.map.forEach((collider) => collider.finalizeDeserialization(bodies));\n    }\n    /**\n     * Creates a new collider and return its integer handle.\n     *\n     * @param bodies - The set of bodies where the collider's parent can be found.\n     * @param desc - The collider's description.\n     * @param parentHandle - The integer handle of the rigid-body this collider is attached to.\n     */\n    createCollider(bodies, desc, parentHandle) {\n        let hasParent = parentHandle != undefined && parentHandle != null;\n        if (hasParent && isNaN(parentHandle))\n            throw Error(\"Cannot create a collider with a parent rigid-body handle that is not a number.\");\n        let rawShape = desc.shape.intoRaw();\n        let rawTra = VectorOps.intoRaw(desc.translation);\n        let rawRot = RotationOps.intoRaw(desc.rotation);\n        let rawCom = VectorOps.intoRaw(desc.centerOfMass);\n        // #if DIM3\n        let rawPrincipalInertia = VectorOps.intoRaw(desc.principalAngularInertia);\n        let rawInertiaFrame = RotationOps.intoRaw(desc.angularInertiaLocalFrame);\n        // #endif\n        let handle = this.raw.createCollider(desc.enabled, rawShape, rawTra, rawRot, desc.massPropsMode, desc.mass, rawCom, \n        // #if DIM3\n        rawPrincipalInertia, rawInertiaFrame, \n        // #endif\n        desc.density, desc.friction, desc.restitution, desc.frictionCombineRule, desc.restitutionCombineRule, desc.isSensor, desc.collisionGroups, desc.solverGroups, desc.activeCollisionTypes, desc.activeHooks, desc.activeEvents, desc.contactForceEventThreshold, desc.contactSkin, hasParent, hasParent ? parentHandle : 0, bodies.raw);\n        rawShape.free();\n        rawTra.free();\n        rawRot.free();\n        rawCom.free();\n        // #if DIM3\n        rawPrincipalInertia.free();\n        rawInertiaFrame.free();\n        // #endif\n        let parent = hasParent ? bodies.get(parentHandle) : null;\n        let collider = new Collider(this, handle, parent, desc.shape);\n        this.map.set(handle, collider);\n        return collider;\n    }\n    /**\n     * Remove a collider from this set.\n     *\n     * @param handle - The integer handle of the collider to remove.\n     * @param bodies - The set of rigid-body containing the rigid-body the collider is attached to.\n     * @param wakeUp - If `true`, the rigid-body the removed collider is attached to will be woken-up automatically.\n     */\n    remove(handle, islands, bodies, wakeUp) {\n        this.raw.remove(handle, islands.raw, bodies.raw, wakeUp);\n        this.unmap(handle);\n    }\n    /**\n     * Internal function, do not call directly.\n     * @param handle\n     */\n    unmap(handle) {\n        this.map.delete(handle);\n    }\n    /**\n     * Gets the rigid-body with the given handle.\n     *\n     * @param handle - The handle of the rigid-body to retrieve.\n     */\n    get(handle) {\n        return this.map.get(handle);\n    }\n    /**\n     * The number of colliders on this set.\n     */\n    len() {\n        return this.map.len();\n    }\n    /**\n     * Does this set contain a collider with the given handle?\n     *\n     * @param handle - The collider handle to check.\n     */\n    contains(handle) {\n        return this.get(handle) != null;\n    }\n    /**\n     * Applies the given closure to each collider contained by this set.\n     *\n     * @param f - The closure to apply.\n     */\n    forEach(f) {\n        this.map.forEach(f);\n    }\n    /**\n     * Gets all colliders in the list.\n     *\n     * @returns collider list.\n     */\n    getAll() {\n        return this.map.getAll();\n    }\n}\n//# sourceMappingURL=collider_set.js.map"],"names":["ColliderSet","free","this","raw","undefined","map","clear","constructor","RawColliderSet","Coarena","forEachColliderHandle","handle","set","Collider","castClosure","f","get","finalizeDeserialization","bodies","forEach","collider","createCollider","desc","parentHandle","hasParent","isNaN","Error","rawShape","shape","intoRaw","rawTra","VectorOps","translation","rawRot","RotationOps","rotation","rawCom","centerOfMass","rawPrincipalInertia","principalAngularInertia","rawInertiaFrame","angularInertiaLocalFrame","enabled","massPropsMode","mass","density","friction","restitution","frictionCombineRule","restitutionCombineRule","isSensor","collisionGroups","solverGroups","activeCollisionTypes","activeHooks","activeEvents","contactForceEventThreshold","contactSkin","parent","remove","islands","wakeUp","unmap","delete","len","contains","getAll"],"mappings":"oMAUO,MAAMA,YAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,EACLF,KAAKG,KACPH,KAAKG,IAAIC,QAEbJ,KAAKG,SAAMD,CACf,CACA,WAAAG,CAAYJ,KACRD,KAAKC,IAAMA,KAAO,IAAIK,eACtBN,KAAKG,IAAM,IAAII,QAEXN,KACAA,IAAIO,sBAAuBC,SACvBT,KAAKG,IAAIO,IAAID,OAAQ,IAAIE,SAASX,KAAMS,OAAQ,QAG5D,CAEA,WAAAG,CAAYC,GACR,OAAQJ,QACEI,EACKA,EAAEb,KAAKc,IAAIL,cAGlB,CAGZ,CAEA,uBAAAM,CAAwBC,QACpBhB,KAAKG,IAAIc,QAASC,UAAaA,SAASH,wBAAwBC,QACpE,CAQA,cAAAG,CAAeH,OAAQI,KAAMC,cACzB,IAAIC,UAA4BpB,MAAhBmB,cAA6C,MAAhBA,aAC7C,GAAIC,WAAaC,MAAMF,cACnB,MAAMG,MAAM,kFAChB,IAAIC,SAAWL,KAAKM,MAAMC,UACtBC,OAASC,UAAUF,QAAQP,KAAKU,aAChCC,OAASC,YAAYL,QAAQP,KAAKa,UAClCC,OAASL,UAAUF,QAAQP,KAAKe,cAEhCC,oBAAsBP,UAAUF,QAAQP,KAAKiB,yBAC7CC,gBAAkBN,YAAYL,QAAQP,KAAKmB,0BAE3C9B,OAAST,KAAKC,IAAIkB,eAAeC,KAAKoB,QAASf,SAAUG,OAAQG,OAAQX,KAAKqB,cAAerB,KAAKsB,KAAMR,OAE5GE,oBAAqBE,gBAErBlB,KAAKuB,QAASvB,KAAKwB,SAAUxB,KAAKyB,YAAazB,KAAK0B,oBAAqB1B,KAAK2B,uBAAwB3B,KAAK4B,SAAU5B,KAAK6B,gBAAiB7B,KAAK8B,aAAc9B,KAAK+B,qBAAsB/B,KAAKgC,YAAahC,KAAKiC,aAAcjC,KAAKkC,2BAA4BlC,KAAKmC,YAAajC,UAAWA,UAAYD,aAAe,EAAGL,OAAOf,KACjUwB,SAAS1B,OACT6B,OAAO7B,OACPgC,OAAOhC,OACPmC,OAAOnC,OAEPqC,oBAAoBrC,OACpBuC,gBAAgBvC,OAEhB,IAAIyD,OAASlC,UAAYN,OAAOF,IAAIO,cAAgB,KAChDH,SAAW,IAAIP,SAASX,KAAMS,OAAQ+C,OAAQpC,KAAKM,OAEvD,OADA1B,KAAKG,IAAIO,IAAID,OAAQS,UACdA,QACX,CAQA,MAAAuC,CAAOhD,OAAQiD,QAAS1C,OAAQ2C,QAC5B3D,KAAKC,IAAIwD,OAAOhD,OAAQiD,QAAQzD,IAAKe,OAAOf,IAAK0D,QACjD3D,KAAK4D,MAAMnD,OACf,CAKA,KAAAmD,CAAMnD,QACFT,KAAKG,IAAI0D,OAAOpD,OACpB,CAMA,GAAAK,CAAIL,QACA,OAAOT,KAAKG,IAAIW,IAAIL,OACxB,CAIA,GAAAqD,GACI,OAAO9D,KAAKG,IAAI2D,KACpB,CAMA,QAAAC,CAAStD,QACL,OAA2B,MAApBT,KAAKc,IAAIL,OACpB,CAMA,OAAAQ,CAAQJ,GACJb,KAAKG,IAAIc,QAAQJ,EACrB,CAMA,MAAAmD,GACI,OAAOhE,KAAKG,IAAI6D,QACpB","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/contact.js

@@ -0,0 +1,2 @@
+import{VectorOps}from"../math.js";class ShapeContact{constructor(dist,point1,point2,normal1,normal2){this.distance=dist,this.point1=point1,this.point2=point2,this.normal1=normal1,this.normal2=normal2}static fromRaw(raw){if(!raw)return null;const result=new ShapeContact(raw.distance(),VectorOps.fromRaw(raw.point1()),VectorOps.fromRaw(raw.point2()),VectorOps.fromRaw(raw.normal1()),VectorOps.fromRaw(raw.normal2()));return raw.free(),result}}export{ShapeContact};
+//# sourceMappingURL=contact.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/contact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/contact.js"],"sourcesContent":["import { VectorOps } from \"../math\";\n/**\n * The contact info between two shapes.\n */\nexport class ShapeContact {\n    constructor(dist, point1, point2, normal1, normal2) {\n        this.distance = dist;\n        this.point1 = point1;\n        this.point2 = point2;\n        this.normal1 = normal1;\n        this.normal2 = normal2;\n    }\n    static fromRaw(raw) {\n        if (!raw)\n            return null;\n        const result = new ShapeContact(raw.distance(), VectorOps.fromRaw(raw.point1()), VectorOps.fromRaw(raw.point2()), VectorOps.fromRaw(raw.normal1()), VectorOps.fromRaw(raw.normal2()));\n        raw.free();\n        return result;\n    }\n}\n//# sourceMappingURL=contact.js.map"],"names":["ShapeContact","constructor","dist","point1","point2","normal1","normal2","this","distance","fromRaw","raw","result","VectorOps","free"],"mappings":"kCAIO,MAAMA,aACT,WAAAC,CAAYC,KAAMC,OAAQC,OAAQC,QAASC,SACvCC,KAAKC,SAAWN,KAChBK,KAAKJ,OAASA,OACdI,KAAKH,OAASA,OACdG,KAAKF,QAAUA,QACfE,KAAKD,QAAUA,OACnB,CACA,cAAOG,CAAQC,KACX,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAIX,aAAaU,IAAIF,WAAYI,UAAUH,QAAQC,IAAIP,UAAWS,UAAUH,QAAQC,IAAIN,UAAWQ,UAAUH,QAAQC,IAAIL,WAAYO,UAAUH,QAAQC,IAAIJ,YAE1K,OADAI,IAAIG,OACGF,MACX","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/feature.js

@@ -0,0 +1,2 @@
+var FeatureType;!function(FeatureType){FeatureType[FeatureType.Vertex=0]="Vertex",FeatureType[FeatureType.Edge=1]="Edge",FeatureType[FeatureType.Face=2]="Face",FeatureType[FeatureType.Unknown=3]="Unknown"}(FeatureType||(FeatureType={}));export{FeatureType};
+//# sourceMappingURL=feature.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/feature.js"],"sourcesContent":["// #if DIM3\nexport var FeatureType;\n(function (FeatureType) {\n    FeatureType[FeatureType[\"Vertex\"] = 0] = \"Vertex\";\n    FeatureType[FeatureType[\"Edge\"] = 1] = \"Edge\";\n    FeatureType[FeatureType[\"Face\"] = 2] = \"Face\";\n    FeatureType[FeatureType[\"Unknown\"] = 3] = \"Unknown\";\n})(FeatureType || (FeatureType = {}));\n// #endif\n//# sourceMappingURL=feature.js.map"],"names":["FeatureType"],"mappings":"AACU,IAACA,aACX,SAAWA,aACPA,YAAYA,YAAoB,OAAI,GAAK,SACzCA,YAAYA,YAAkB,KAAI,GAAK,OACvCA,YAAYA,YAAkB,KAAI,GAAK,OACvCA,YAAYA,YAAqB,QAAI,GAAK,SAC7C,CALD,CAKGA,cAAgBA,YAAc,CAAA","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/narrow_phase.js

@@ -0,0 +1,2 @@
+import"../rapier_wasm3d.js";import{VectorOps}from"../math.js";import{RawNarrowPhase}from"../rapier_wasm3d_bg.js";class NarrowPhase{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw||new RawNarrowPhase,this.tempManifold=new TempContactManifold(null)}contactPairsWith(collider1,f){this.raw.contact_pairs_with(collider1,f)}intersectionPairsWith(collider1,f){this.raw.intersection_pairs_with(collider1,f)}contactPair(collider1,collider2,f){const rawPair=this.raw.contact_pair(collider1,collider2);if(rawPair){const flipped=rawPair.collider1()!=collider1;let i;for(i=0;i<rawPair.numContactManifolds();++i)this.tempManifold.raw=rawPair.contactManifold(i),this.tempManifold.raw&&f(this.tempManifold,flipped),this.tempManifold.free();rawPair.free()}}intersectionPair(collider1,collider2){return this.raw.intersection_pair(collider1,collider2)}}class TempContactManifold{free(){this.raw&&this.raw.free(),this.raw=void 0}constructor(raw){this.raw=raw}normal(){return VectorOps.fromRaw(this.raw.normal())}localNormal1(){return VectorOps.fromRaw(this.raw.local_n1())}localNormal2(){return VectorOps.fromRaw(this.raw.local_n2())}subshape1(){return this.raw.subshape1()}subshape2(){return this.raw.subshape2()}numContacts(){return this.raw.num_contacts()}localContactPoint1(i){return VectorOps.fromRaw(this.raw.contact_local_p1(i))}localContactPoint2(i){return VectorOps.fromRaw(this.raw.contact_local_p2(i))}contactDist(i){return this.raw.contact_dist(i)}contactFid1(i){return this.raw.contact_fid1(i)}contactFid2(i){return this.raw.contact_fid2(i)}contactImpulse(i){return this.raw.contact_impulse(i)}contactTangentImpulseX(i){return this.raw.contact_tangent_impulse_x(i)}contactTangentImpulseY(i){return this.raw.contact_tangent_impulse_y(i)}numSolverContacts(){return this.raw.num_solver_contacts()}solverContactPoint(i){return VectorOps.fromRaw(this.raw.solver_contact_point(i))}solverContactDist(i){return this.raw.solver_contact_dist(i)}solverContactFriction(i){return this.raw.solver_contact_friction(i)}solverContactRestitution(i){return this.raw.solver_contact_restitution(i)}solverContactTangentVelocity(i){return VectorOps.fromRaw(this.raw.solver_contact_tangent_velocity(i))}}export{NarrowPhase,TempContactManifold};
+//# sourceMappingURL=narrow_phase.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/narrow_phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrow_phase.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/narrow_phase.js"],"sourcesContent":["import { RawNarrowPhase } from \"../raw\";\nimport { VectorOps } from \"../math\";\n/**\n * The narrow-phase used for precise collision-detection.\n *\n * To avoid leaking WASM resources, this MUST be freed manually with `narrowPhase.free()`\n * once you are done using it.\n */\nexport class NarrowPhase {\n    /**\n     * Release the WASM memory occupied by this narrow-phase.\n     */\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw || new RawNarrowPhase();\n        this.tempManifold = new TempContactManifold(null);\n    }\n    /**\n     * Enumerates all the colliders potentially in contact with the given collider.\n     *\n     * @param collider1 - The second collider involved in the contact.\n     * @param f - Closure that will be called on each collider that is in contact with `collider1`.\n     */\n    contactPairsWith(collider1, f) {\n        this.raw.contact_pairs_with(collider1, f);\n    }\n    /**\n     * Enumerates all the colliders intersecting the given colliders, assuming one of them\n     * is a sensor.\n     */\n    intersectionPairsWith(collider1, f) {\n        this.raw.intersection_pairs_with(collider1, f);\n    }\n    /**\n     * Iterates through all the contact manifolds between the given pair of colliders.\n     *\n     * @param collider1 - The first collider involved in the contact.\n     * @param collider2 - The second collider involved in the contact.\n     * @param f - Closure that will be called on each contact manifold between the two colliders. If the second argument\n     *            passed to this closure is `true`, then the contact manifold data is flipped, i.e., methods like `localNormal1`\n     *            actually apply to the `collider2` and fields like `localNormal2` apply to the `collider1`.\n     */\n    contactPair(collider1, collider2, f) {\n        const rawPair = this.raw.contact_pair(collider1, collider2);\n        if (!!rawPair) {\n            const flipped = rawPair.collider1() != collider1;\n            let i;\n            for (i = 0; i < rawPair.numContactManifolds(); ++i) {\n                this.tempManifold.raw = rawPair.contactManifold(i);\n                if (!!this.tempManifold.raw) {\n                    f(this.tempManifold, flipped);\n                }\n                // SAFETY: The RawContactManifold stores a raw pointer that will be invalidated\n                //         at the next timestep. So we must be sure to free the pair here\n                //         to avoid unsoundness in the Rust code.\n                this.tempManifold.free();\n            }\n            rawPair.free();\n        }\n    }\n    /**\n     * Returns `true` if `collider1` and `collider2` intersect and at least one of them is a sensor.\n     * @param collider1 − The first collider involved in the intersection.\n     * @param collider2 − The second collider involved in the intersection.\n     */\n    intersectionPair(collider1, collider2) {\n        return this.raw.intersection_pair(collider1, collider2);\n    }\n}\nexport class TempContactManifold {\n    free() {\n        if (!!this.raw) {\n            this.raw.free();\n        }\n        this.raw = undefined;\n    }\n    constructor(raw) {\n        this.raw = raw;\n    }\n    normal() {\n        return VectorOps.fromRaw(this.raw.normal());\n    }\n    localNormal1() {\n        return VectorOps.fromRaw(this.raw.local_n1());\n    }\n    localNormal2() {\n        return VectorOps.fromRaw(this.raw.local_n2());\n    }\n    subshape1() {\n        return this.raw.subshape1();\n    }\n    subshape2() {\n        return this.raw.subshape2();\n    }\n    numContacts() {\n        return this.raw.num_contacts();\n    }\n    localContactPoint1(i) {\n        return VectorOps.fromRaw(this.raw.contact_local_p1(i));\n    }\n    localContactPoint2(i) {\n        return VectorOps.fromRaw(this.raw.contact_local_p2(i));\n    }\n    contactDist(i) {\n        return this.raw.contact_dist(i);\n    }\n    contactFid1(i) {\n        return this.raw.contact_fid1(i);\n    }\n    contactFid2(i) {\n        return this.raw.contact_fid2(i);\n    }\n    contactImpulse(i) {\n        return this.raw.contact_impulse(i);\n    }\n    // #if DIM3\n    contactTangentImpulseX(i) {\n        return this.raw.contact_tangent_impulse_x(i);\n    }\n    contactTangentImpulseY(i) {\n        return this.raw.contact_tangent_impulse_y(i);\n    }\n    // #endif\n    numSolverContacts() {\n        return this.raw.num_solver_contacts();\n    }\n    solverContactPoint(i) {\n        return VectorOps.fromRaw(this.raw.solver_contact_point(i));\n    }\n    solverContactDist(i) {\n        return this.raw.solver_contact_dist(i);\n    }\n    solverContactFriction(i) {\n        return this.raw.solver_contact_friction(i);\n    }\n    solverContactRestitution(i) {\n        return this.raw.solver_contact_restitution(i);\n    }\n    solverContactTangentVelocity(i) {\n        return VectorOps.fromRaw(this.raw.solver_contact_tangent_velocity(i));\n    }\n}\n//# sourceMappingURL=narrow_phase.js.map"],"names":["NarrowPhase","free","this","raw","undefined","constructor","RawNarrowPhase","tempManifold","TempContactManifold","contactPairsWith","collider1","f","contact_pairs_with","intersectionPairsWith","intersection_pairs_with","contactPair","collider2","rawPair","contact_pair","flipped","i","numContactManifolds","contactManifold","intersectionPair","intersection_pair","normal","VectorOps","fromRaw","localNormal1","local_n1","localNormal2","local_n2","subshape1","subshape2","numContacts","num_contacts","localContactPoint1","contact_local_p1","localContactPoint2","contact_local_p2","contactDist","contact_dist","contactFid1","contact_fid1","contactFid2","contact_fid2","contactImpulse","contact_impulse","contactTangentImpulseX","contact_tangent_impulse_x","contactTangentImpulseY","contact_tangent_impulse_y","numSolverContacts","num_solver_contacts","solverContactPoint","solver_contact_point","solverContactDist","solver_contact_dist","solverContactFriction","solver_contact_friction","solverContactRestitution","solver_contact_restitution","solverContactTangentVelocity","solver_contact_tangent_velocity"],"mappings":"iHAQO,MAAMA,YAIT,IAAAC,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,CACf,CACA,WAAAC,CAAYF,KACRD,KAAKC,IAAMA,KAAO,IAAIG,eACtBJ,KAAKK,aAAe,IAAIC,oBAAoB,KAChD,CAOA,gBAAAC,CAAiBC,UAAWC,GACxBT,KAAKC,IAAIS,mBAAmBF,UAAWC,EAC3C,CAKA,qBAAAE,CAAsBH,UAAWC,GAC7BT,KAAKC,IAAIW,wBAAwBJ,UAAWC,EAChD,CAUA,WAAAI,CAAYL,UAAWM,UAAWL,GAC9B,MAAMM,QAAUf,KAAKC,IAAIe,aAAaR,UAAWM,WACjD,GAAMC,QAAS,CACX,MAAME,QAAUF,QAAQP,aAAeA,UACvC,IAAIU,EACJ,IAAKA,EAAI,EAAGA,EAAIH,QAAQI,wBAAyBD,EAC7ClB,KAAKK,aAAaJ,IAAMc,QAAQK,gBAAgBF,GAC1ClB,KAAKK,aAAaJ,KACpBQ,EAAET,KAAKK,aAAcY,SAKzBjB,KAAKK,aAAaN,OAEtBgB,QAAQhB,MACZ,CACJ,CAMA,gBAAAsB,CAAiBb,UAAWM,WACxB,OAAOd,KAAKC,IAAIqB,kBAAkBd,UAAWM,UACjD,EAEG,MAAMR,oBACT,IAAAP,GACUC,KAAKC,KACPD,KAAKC,IAAIF,OAEbC,KAAKC,SAAMC,CACf,CACA,WAAAC,CAAYF,KACRD,KAAKC,IAAMA,GACf,CACA,MAAAsB,GACI,OAAOC,UAAUC,QAAQzB,KAAKC,IAAIsB,SACtC,CACA,YAAAG,GACI,OAAOF,UAAUC,QAAQzB,KAAKC,IAAI0B,WACtC,CACA,YAAAC,GACI,OAAOJ,UAAUC,QAAQzB,KAAKC,IAAI4B,WACtC,CACA,SAAAC,GACI,OAAO9B,KAAKC,IAAI6B,WACpB,CACA,SAAAC,GACI,OAAO/B,KAAKC,IAAI8B,WACpB,CACA,WAAAC,GACI,OAAOhC,KAAKC,IAAIgC,cACpB,CACA,kBAAAC,CAAmBhB,GACf,OAAOM,UAAUC,QAAQzB,KAAKC,IAAIkC,iBAAiBjB,GACvD,CACA,kBAAAkB,CAAmBlB,GACf,OAAOM,UAAUC,QAAQzB,KAAKC,IAAIoC,iBAAiBnB,GACvD,CACA,WAAAoB,CAAYpB,GACR,OAAOlB,KAAKC,IAAIsC,aAAarB,EACjC,CACA,WAAAsB,CAAYtB,GACR,OAAOlB,KAAKC,IAAIwC,aAAavB,EACjC,CACA,WAAAwB,CAAYxB,GACR,OAAOlB,KAAKC,IAAI0C,aAAazB,EACjC,CACA,cAAA0B,CAAe1B,GACX,OAAOlB,KAAKC,IAAI4C,gBAAgB3B,EACpC,CAEA,sBAAA4B,CAAuB5B,GACnB,OAAOlB,KAAKC,IAAI8C,0BAA0B7B,EAC9C,CACA,sBAAA8B,CAAuB9B,GACnB,OAAOlB,KAAKC,IAAIgD,0BAA0B/B,EAC9C,CAEA,iBAAAgC,GACI,OAAOlD,KAAKC,IAAIkD,qBACpB,CACA,kBAAAC,CAAmBlC,GACf,OAAOM,UAAUC,QAAQzB,KAAKC,IAAIoD,qBAAqBnC,GAC3D,CACA,iBAAAoC,CAAkBpC,GACd,OAAOlB,KAAKC,IAAIsD,oBAAoBrC,EACxC,CACA,qBAAAsC,CAAsBtC,GAClB,OAAOlB,KAAKC,IAAIwD,wBAAwBvC,EAC5C,CACA,wBAAAwC,CAAyBxC,GACrB,OAAOlB,KAAKC,IAAI0D,2BAA2BzC,EAC/C,CACA,4BAAA0C,CAA6B1C,GACzB,OAAOM,UAAUC,QAAQzB,KAAKC,IAAI4D,gCAAgC3C,GACtE","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/point.js

@@ -0,0 +1,2 @@
+import{VectorOps}from"../math.js";import{FeatureType}from"./feature.js";class PointProjection{constructor(point,isInside){this.point=point,this.isInside=isInside}static fromRaw(raw){if(!raw)return null;const result=new PointProjection(VectorOps.fromRaw(raw.point()),raw.isInside());return raw.free(),result}}class PointColliderProjection{constructor(collider,point,isInside,featureType,featureId){this.featureType=FeatureType.Unknown,this.featureId=void 0,this.collider=collider,this.point=point,this.isInside=isInside,void 0!==featureId&&(this.featureId=featureId),void 0!==featureType&&(this.featureType=featureType)}static fromRaw(colliderSet,raw){if(!raw)return null;const result=new PointColliderProjection(colliderSet.get(raw.colliderHandle()),VectorOps.fromRaw(raw.point()),raw.isInside(),raw.featureType(),raw.featureId());return raw.free(),result}}export{PointColliderProjection,PointProjection};
+//# sourceMappingURL=point.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"point.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/point.js"],"sourcesContent":["import { VectorOps } from \"../math\";\nimport { FeatureType } from \"./feature\";\n/**\n * The projection of a point on a collider.\n */\nexport class PointProjection {\n    constructor(point, isInside) {\n        this.point = point;\n        this.isInside = isInside;\n    }\n    static fromRaw(raw) {\n        if (!raw)\n            return null;\n        const result = new PointProjection(VectorOps.fromRaw(raw.point()), raw.isInside());\n        raw.free();\n        return result;\n    }\n}\n/**\n * The projection of a point on a collider (includes the collider handle).\n */\nexport class PointColliderProjection {\n    constructor(collider, point, isInside, featureType, featureId) {\n        /**\n         * The type of the geometric feature the point was projected on.\n         */\n        this.featureType = FeatureType.Unknown;\n        /**\n         * The id of the geometric feature the point was projected on.\n         */\n        this.featureId = undefined;\n        this.collider = collider;\n        this.point = point;\n        this.isInside = isInside;\n        if (featureId !== undefined)\n            this.featureId = featureId;\n        if (featureType !== undefined)\n            this.featureType = featureType;\n    }\n    static fromRaw(colliderSet, raw) {\n        if (!raw)\n            return null;\n        const result = new PointColliderProjection(colliderSet.get(raw.colliderHandle()), VectorOps.fromRaw(raw.point()), raw.isInside(), raw.featureType(), raw.featureId());\n        raw.free();\n        return result;\n    }\n}\n//# sourceMappingURL=point.js.map"],"names":["PointProjection","constructor","point","isInside","this","fromRaw","raw","result","VectorOps","free","PointColliderProjection","collider","featureType","featureId","FeatureType","Unknown","undefined","colliderSet","get","colliderHandle"],"mappings":"wEAKO,MAAMA,gBACT,WAAAC,CAAYC,MAAOC,UACfC,KAAKF,MAAQA,MACbE,KAAKD,SAAWA,QACpB,CACA,cAAOE,CAAQC,KACX,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAIP,gBAAgBQ,UAAUH,QAAQC,IAAIJ,SAAUI,IAAIH,YAEvE,OADAG,IAAIG,OACGF,MACX,EAKG,MAAMG,wBACT,WAAAT,CAAYU,SAAUT,MAAOC,SAAUS,YAAaC,WAIhDT,KAAKQ,YAAcE,YAAYC,QAI/BX,KAAKS,eAAYG,EACjBZ,KAAKO,SAAWA,SAChBP,KAAKF,MAAQA,MACbE,KAAKD,SAAWA,cACEa,IAAdH,YACAT,KAAKS,UAAYA,gBACDG,IAAhBJ,cACAR,KAAKQ,YAAcA,YAC3B,CACA,cAAOP,CAAQY,YAAaX,KACxB,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAIG,wBAAwBO,YAAYC,IAAIZ,IAAIa,kBAAmBX,UAAUH,QAAQC,IAAIJ,SAAUI,IAAIH,WAAYG,IAAIM,cAAeN,IAAIO,aAEzJ,OADAP,IAAIG,OACGF,MACX","x_google_ignoreList":[0]}

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/ray.js

@@ -0,0 +1,2 @@
+import{VectorOps}from"../math.js";import{FeatureType}from"./feature.js";class RayIntersection{constructor(timeOfImpact,normal,featureType,featureId){this.featureType=FeatureType.Unknown,this.featureId=void 0,this.timeOfImpact=timeOfImpact,this.normal=normal,void 0!==featureId&&(this.featureId=featureId),void 0!==featureType&&(this.featureType=featureType)}static fromRaw(raw){if(!raw)return null;const result=new RayIntersection(raw.time_of_impact(),VectorOps.fromRaw(raw.normal()),raw.featureType(),raw.featureId());return raw.free(),result}}class RayColliderIntersection{constructor(collider,timeOfImpact,normal,featureType,featureId){this.featureType=FeatureType.Unknown,this.featureId=void 0,this.collider=collider,this.timeOfImpact=timeOfImpact,this.normal=normal,void 0!==featureId&&(this.featureId=featureId),void 0!==featureType&&(this.featureType=featureType)}static fromRaw(colliderSet,raw){if(!raw)return null;const result=new RayColliderIntersection(colliderSet.get(raw.colliderHandle()),raw.time_of_impact(),VectorOps.fromRaw(raw.normal()),raw.featureType(),raw.featureId());return raw.free(),result}}class RayColliderHit{constructor(collider,timeOfImpact){this.collider=collider,this.timeOfImpact=timeOfImpact}static fromRaw(colliderSet,raw){if(!raw)return null;const result=new RayColliderHit(colliderSet.get(raw.colliderHandle()),raw.timeOfImpact());return raw.free(),result}}export{RayColliderHit,RayColliderIntersection,RayIntersection};
+//# sourceMappingURL=ray.js.map

package/dist/home/runner/work/anarchy-engine/anarchy-engine/node_modules/@dimforge/rapier3d/geometry/ray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ray.js","sources":["../../../../../../../../../../../../node_modules/@dimforge/rapier3d/geometry/ray.js"],"sourcesContent":["import { VectorOps } from \"../math\";\nimport { FeatureType } from \"./feature\";\n/**\n * A ray. This is a directed half-line.\n */\nexport class Ray {\n    /**\n     * Builds a ray from its origin and direction.\n     *\n     * @param origin - The ray's starting point.\n     * @param dir - The ray's direction of propagation.\n     */\n    constructor(origin, dir) {\n        this.origin = origin;\n        this.dir = dir;\n    }\n    pointAt(t) {\n        return {\n            x: this.origin.x + this.dir.x * t,\n            y: this.origin.y + this.dir.y * t,\n            // #if DIM3\n            z: this.origin.z + this.dir.z * t,\n            // #endif\n        };\n    }\n}\n/**\n * The intersection between a ray and a collider.\n */\nexport class RayIntersection {\n    constructor(timeOfImpact, normal, featureType, featureId) {\n        /**\n         * The type of the geometric feature the point was projected on.\n         */\n        this.featureType = FeatureType.Unknown;\n        /**\n         * The id of the geometric feature the point was projected on.\n         */\n        this.featureId = undefined;\n        this.timeOfImpact = timeOfImpact;\n        this.normal = normal;\n        if (featureId !== undefined)\n            this.featureId = featureId;\n        if (featureType !== undefined)\n            this.featureType = featureType;\n    }\n    static fromRaw(raw) {\n        if (!raw)\n            return null;\n        const result = new RayIntersection(raw.time_of_impact(), VectorOps.fromRaw(raw.normal()), raw.featureType(), raw.featureId());\n        raw.free();\n        return result;\n    }\n}\n/**\n * The intersection between a ray and a collider (includes the collider handle).\n */\nexport class RayColliderIntersection {\n    constructor(collider, timeOfImpact, normal, featureType, featureId) {\n        /**\n         * The type of the geometric feature the point was projected on.\n         */\n        this.featureType = FeatureType.Unknown;\n        /**\n         * The id of the geometric feature the point was projected on.\n         */\n        this.featureId = undefined;\n        this.collider = collider;\n        this.timeOfImpact = timeOfImpact;\n        this.normal = normal;\n        if (featureId !== undefined)\n            this.featureId = featureId;\n        if (featureType !== undefined)\n            this.featureType = featureType;\n    }\n    static fromRaw(colliderSet, raw) {\n        if (!raw)\n            return null;\n        const result = new RayColliderIntersection(colliderSet.get(raw.colliderHandle()), raw.time_of_impact(), VectorOps.fromRaw(raw.normal()), raw.featureType(), raw.featureId());\n        raw.free();\n        return result;\n    }\n}\n/**\n * The time of impact between a ray and a collider.\n */\nexport class RayColliderHit {\n    constructor(collider, timeOfImpact) {\n        this.collider = collider;\n        this.timeOfImpact = timeOfImpact;\n    }\n    static fromRaw(colliderSet, raw) {\n        if (!raw)\n            return null;\n        const result = new RayColliderHit(colliderSet.get(raw.colliderHandle()), raw.timeOfImpact());\n        raw.free();\n        return result;\n    }\n}\n//# sourceMappingURL=ray.js.map"],"names":["RayIntersection","constructor","timeOfImpact","normal","featureType","featureId","this","FeatureType","Unknown","undefined","fromRaw","raw","result","time_of_impact","VectorOps","free","RayColliderIntersection","collider","colliderSet","get","colliderHandle","RayColliderHit"],"mappings":"wEA6BO,MAAMA,gBACT,WAAAC,CAAYC,aAAcC,OAAQC,YAAaC,WAI3CC,KAAKF,YAAcG,YAAYC,QAI/BF,KAAKD,eAAYI,EACjBH,KAAKJ,aAAeA,aACpBI,KAAKH,OAASA,YACIM,IAAdJ,YACAC,KAAKD,UAAYA,gBACDI,IAAhBL,cACAE,KAAKF,YAAcA,YAC3B,CACA,cAAOM,CAAQC,KACX,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAIZ,gBAAgBW,IAAIE,iBAAkBC,UAAUJ,QAAQC,IAAIR,UAAWQ,IAAIP,cAAeO,IAAIN,aAEjH,OADAM,IAAII,OACGH,MACX,EAKG,MAAMI,wBACT,WAAAf,CAAYgB,SAAUf,aAAcC,OAAQC,YAAaC,WAIrDC,KAAKF,YAAcG,YAAYC,QAI/BF,KAAKD,eAAYI,EACjBH,KAAKW,SAAWA,SAChBX,KAAKJ,aAAeA,aACpBI,KAAKH,OAASA,YACIM,IAAdJ,YACAC,KAAKD,UAAYA,gBACDI,IAAhBL,cACAE,KAAKF,YAAcA,YAC3B,CACA,cAAOM,CAAQQ,YAAaP,KACxB,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAII,wBAAwBE,YAAYC,IAAIR,IAAIS,kBAAmBT,IAAIE,iBAAkBC,UAAUJ,QAAQC,IAAIR,UAAWQ,IAAIP,cAAeO,IAAIN,aAEhK,OADAM,IAAII,OACGH,MACX,EAKG,MAAMS,eACT,WAAApB,CAAYgB,SAAUf,cAClBI,KAAKW,SAAWA,SAChBX,KAAKJ,aAAeA,YACxB,CACA,cAAOQ,CAAQQ,YAAaP,KACxB,IAAKA,IACD,OAAO,KACX,MAAMC,OAAS,IAAIS,eAAeH,YAAYC,IAAIR,IAAIS,kBAAmBT,IAAIT,gBAE7E,OADAS,IAAII,OACGH,MACX","x_google_ignoreList":[0]}