@absolutejs/rapier3d 0.0.0-stage → 0.1.0

package/dist/types/pipeline/world.d.ts

@@ -0,0 +1,674 @@
+import { RawBroadPhase, RawCCDSolver, RawColliderSet, RawDeserializedWorld, RawIntegrationParameters, RawIslandManager, RawImpulseJointSet, RawMultibodyJointSet, RawNarrowPhase, RawPhysicsPipeline, RawRigidBodySet, RawSerializationPipeline, RawDebugRenderPipeline, RawSoftBodySet } from "../raw";
+import { BroadPhase, Collider, ColliderDesc, ColliderHandle, ColliderSet, InteractionGroups, NarrowPhase, PointColliderProjection, Ray, RayColliderIntersection, RayColliderHit, Shape, ColliderShapeCastHit, TempContactManifold, SolverContactManifold } from "../geometry";
+import { CCDSolver, IntegrationParameters, IslandManager, ImpulseJoint, ImpulseJointHandle, MultibodyJoint, MultibodyJointHandle, JointData, ImpulseJointSet, MultibodyJointSet, RigidBody, RigidBodyDesc, RigidBodyHandle, RigidBodySet, SoftBody, SoftBodyDesc, SoftBodyHandle, SoftBodySet, SoftBodyTearEvent, SoftMeshBinding } from "../dynamics";
+import { Rotation, Vector } from "../math";
+import { PhysicsPipeline } from "./physics_pipeline";
+import { QueryFilterFlags } from "./query_pipeline";
+import { SerializationPipeline } from "./serialization_pipeline";
+import { EventQueue } from "./event_queue";
+import { PhysicsHooks } from "./physics_hooks";
+import { DebugRenderBuffers, DebugRenderPipeline } from "./debug_render_pipeline";
+import { KinematicCharacterController, PidAxesMask, PidController } from "../control";
+import { DynamicRayCastVehicleController } from "../control";
+/**
+ * The physics world.
+ *
+ * This contains all the data-structures necessary for creating and simulating
+ * bodies with contacts, joints, and external forces.
+ */
+export declare class World {
+    gravity: Vector;
+    integrationParameters: IntegrationParameters;
+    islands: IslandManager;
+    broadPhase: BroadPhase;
+    narrowPhase: NarrowPhase;
+    bodies: RigidBodySet;
+    colliders: ColliderSet;
+    impulseJoints: ImpulseJointSet;
+    multibodyJoints: MultibodyJointSet;
+    softBodies: SoftBodySet;
+    ccdSolver: CCDSolver;
+    physicsPipeline: PhysicsPipeline;
+    serializationPipeline: SerializationPipeline;
+    debugRenderPipeline: DebugRenderPipeline;
+    characterControllers: Set<KinematicCharacterController>;
+    pidControllers: Set<PidController>;
+    vehicleControllers: Set<DynamicRayCastVehicleController>;
+    /**
+     * Release the WASM memory occupied by this physics world.
+     *
+     * All the fields of this physics world will be freed as well,
+     * so there is no need to call their `.free()` methods individually.
+     */
+    free(): void;
+    constructor(gravity: Vector, rawIntegrationParameters?: RawIntegrationParameters, rawIslands?: RawIslandManager, rawBroadPhase?: RawBroadPhase, rawNarrowPhase?: RawNarrowPhase, rawBodies?: RawRigidBodySet, rawColliders?: RawColliderSet, rawSoftBodies?: RawSoftBodySet, rawImpulseJoints?: RawImpulseJointSet, rawMultibodyJoints?: RawMultibodyJointSet, rawCCDSolver?: RawCCDSolver, rawPhysicsPipeline?: RawPhysicsPipeline, rawSerializationPipeline?: RawSerializationPipeline, rawDebugRenderPipeline?: RawDebugRenderPipeline);
+    static fromRaw(raw: RawDeserializedWorld): World;
+    /**
+     * Takes a snapshot of this world.
+     *
+     * Use `World.restoreSnapshot` to create a new physics world with a state identical to
+     * the state when `.takeSnapshot()` is called.
+     */
+    takeSnapshot(): Uint8Array;
+    /**
+     * Creates a new physics world from a snapshot.
+     *
+     * This new physics world will be an identical copy of the snapshoted physics world.
+     */
+    static restoreSnapshot(data: Uint8Array): World;
+    /**
+     * Computes all the lines (and their colors) needed to render the scene.
+     *
+     * @param filterFlags - Flags for excluding whole subsets of colliders from rendering.
+     * @param filterPredicate - Any collider for which this closure returns `false` will be excluded from the
+     *                          debug rendering.
+     */
+    debugRender(filterFlags?: QueryFilterFlags, filterPredicate?: (collider: Collider) => boolean): DebugRenderBuffers;
+    /**
+     * Advance the simulation by one time step.
+     *
+     * All events generated by the physics engine are ignored.
+     *
+     * @param EventQueue - (optional) structure responsible for collecting
+     *   events generated by the physics engine.
+     */
+    step(eventQueue?: EventQueue, hooks?: PhysicsHooks): void;
+    /**
+     * Wraps the soft bodies, rigid-body proxies and colliders the engine created on its own
+     * during the last step (the pieces tears split off), and drops the wrappers of what it
+     * removed. Called by `World.step`.
+     */
+    mapNewSoftBodies(): void;
+    /**
+     * Update colliders positions after rigid-bodies moved.
+     *
+     * When a rigid-body moves, the positions of the colliders attached to it need to be updated. This update is
+     * generally automatically done at the beginning and the end of each simulation step with World.step.
+     * If the positions need to be updated without running a simulation step this method can be called manually.
+     */
+    propagateModifiedBodyPositionsToColliders(): void;
+    /**
+     * The current simulation timestep.
+     */
+    get timestep(): number;
+    /**
+     * Sets the new simulation timestep.
+     *
+     * The simulation timestep governs by how much the physics state of the world will
+     * be integrated. A simulation timestep should:
+     * - be as small as possible. Typical values evolve around 0.016 (assuming the chosen unit is milliseconds,
+     * corresponds to the time between two frames of a game running at 60FPS).
+     * - not vary too much during the course of the simulation. A timestep with large variations may
+     * cause instabilities in the simulation.
+     *
+     * @param dt - The timestep length, in seconds.
+     */
+    set timestep(dt: number);
+    /**
+     * The approximate size of most dynamic objects in the scene.
+     *
+     * See the documentation of the `World.lengthUnit` setter for further details.
+     */
+    get lengthUnit(): number;
+    /**
+     * The approximate size of most dynamic objects in the scene.
+     *
+     * This value is used internally to estimate some length-based tolerance. In particular, the
+     * values `IntegrationParameters.allowedLinearError`,
+     * `IntegrationParameters.maxPenetrationCorrection`,
+     * `IntegrationParameters.predictionDistance`, `RigidBodyActivation.linearThreshold`
+     * are scaled by this value implicitly.
+     *
+     * This value can be understood as the number of units-per-meter in your physical world compared
+     * to a human-sized world in meter. For example, in a 2d game, if your typical object size is 100
+     * pixels, set the `[`Self::length_unit`]` parameter to 100.0. The physics engine will interpret
+     * it as if 100 pixels is equivalent to 1 meter in its various internal threshold.
+     * (default `1.0`).
+     */
+    set lengthUnit(unitsPerMeter: number);
+    /**
+     * The number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+     */
+    get numSolverIterations(): number;
+    /**
+     * Sets the number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+     *
+     * The greater this value is, the most rigid and realistic the physics simulation will be.
+     * However a greater number of iterations is more computationally intensive.
+     *
+     * @param niter - The new number of solver iterations.
+     */
+    set numSolverIterations(niter: number);
+    /**
+     * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+     */
+    get numInternalPgsIterations(): number;
+    /**
+     * Sets the Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+     *
+     * Increasing this parameter will improve stability of the simulation. It will have a lesser effect than
+     * increasing `numSolverIterations` but is also less computationally expensive.
+     *
+     * @param niter - The new number of internal PGS iterations.
+     */
+    set numInternalPgsIterations(niter: number);
+    /**
+     * The number of substeps continuous collision-detection can run (default: `1`).
+     */
+    get maxCcdSubsteps(): number;
+    /**
+     * Sets the number of substeps continuous collision-detection can run (default: `1`).
+     *
+     * CCD operates using a "motion clamping" mechanism where all fast-moving object trajectories will
+     * be truncated to their first impact on their path. The number of CCD substeps beyond 1 indicate how
+     * many times that trajectory will be updated and continued after a hit. This can results in smoother
+     * paths, but at a significant computational cost.
+     *
+     * @param niter - The new maximum number of CCD substeps. Setting to `0` disables CCD entirely.
+     */
+    set maxCcdSubsteps(substeps: number);
+    /**
+     * Creates a new rigid-body from the given rigid-body descriptor.
+     *
+     * @param body - The description of the rigid-body to create.
+     */
+    createRigidBody(body: RigidBodyDesc): RigidBody;
+    /**
+     * Creates a new character controller.
+     *
+     * @param offset - The artificial gap added between the character’s chape and its environment.
+     */
+    createCharacterController(offset: number): KinematicCharacterController;
+    /**
+     * Removes a character controller from this world.
+     *
+     * @param controller - The character controller to remove.
+     */
+    removeCharacterController(controller: KinematicCharacterController): void;
+    /**
+     * Creates a new PID (Proportional-Integral-Derivative) controller.
+     *
+     * @param kp - The Proportional gain applied to the instantaneous linear position errors.
+     *             This is usually set to a multiple of the inverse of simulation step time
+     *             (e.g. `60` if the delta-time is `1.0 / 60.0`).
+     * @param ki - The linear gain applied to the Integral part of the PID controller.
+     * @param kd - The Derivative gain applied to the instantaneous linear velocity errors.
+     *             This is usually set to a value in `[0.0, 1.0]` where `0.0` implies no damping
+     *             (no correction of velocity errors) and `1.0` implies complete damping (velocity errors
+     *             are corrected in a single simulation step).
+     * @param axes - The axes affected by this controller.
+     *               Only coordinate axes with a bit flags set to `true` will be taken into
+     *               account when calculating the errors and corrections.
+     */
+    createPidController(kp: number, ki: number, kd: number, axes: PidAxesMask): PidController;
+    /**
+     * Removes a PID controller from this world.
+     *
+     * @param controller - The PID controller to remove.
+     */
+    removePidController(controller: PidController): void;
+    /**
+     * Creates a new vehicle controller.
+     *
+     * @param chassis - The rigid-body used as the chassis of the vehicle controller. When the vehicle
+     *                  controller is updated, it will change directly the rigid-body’s velocity. This
+     *                  rigid-body must be a dynamic or kinematic-velocity-based rigid-body.
+     */
+    createVehicleController(chassis: RigidBody): DynamicRayCastVehicleController;
+    /**
+     * Removes a vehicle controller from this world.
+     *
+     * @param controller - The vehicle controller to remove.
+     */
+    removeVehicleController(controller: DynamicRayCastVehicleController): void;
+    /**
+     * Creates a new collider.
+     *
+     * @param desc - The description of the collider.
+     * @param parent - The rigid-body this collider is attached to.
+     */
+    createCollider(desc: ColliderDesc, parent?: RigidBody): Collider;
+    /**
+     * Creates a new soft body from the given description, with its hidden root rigid body
+     * and the colliders of its collision meshes.
+     *
+     * @param desc - The description of the soft body to create.
+     */
+    createSoftBody(desc: SoftBodyDesc): SoftBody;
+    /**
+     * Creates a collider holding a soft body's deformable collision mesh (a polyline in 2D or
+     * a triangle mesh in 3D built with the `DEFORMABLE` flag), bound to the cluster whose
+     * proxy is `parent` (see `SoftBody.rootBody` and `SoftBody.clusterProxy`).
+     *
+     * Returns `null` when the binding fails.
+     *
+     * @param desc - The description of the collider; its shape's vertices are given in the
+     *               collider's local frame relative to the proxy.
+     * @param binding - How the mesh's vertices follow the cluster's particles.
+     * @param parent - The cluster proxy the collider is attached to.
+     */
+    createDeformableCollider(desc: ColliderDesc, binding: SoftMeshBinding, parent: RigidBody): Collider | null;
+    /**
+     * Adds a cluster to a soft body: a rigid proxy over the given particles that joints and
+     * colliders can attach to. Returns the cluster's index, or `null` if no particle was
+     * valid.
+     */
+    addSoftBodyCluster(body: SoftBody, particles: Uint32Array | number[]): number | null;
+    /**
+     * Removes a cluster of a soft body, with its proxy, colliders and joints.
+     */
+    removeSoftBodyCluster(body: SoftBody, cluster: number): boolean;
+    /**
+     * Tears a soft body at once along the given edges and through the given cells (indices
+     * into `SoftBody.edges` and `SoftBody.cells`), without removing material. Pieces
+     * disconnected by the tear become soft bodies of their own.
+     *
+     * Returns the tear event (to be freed with `.free()`), or `null` when nothing changed.
+     */
+    tearSoftBody(body: SoftBody, edges: Uint32Array | number[], cells: Uint32Array | number[]): SoftBodyTearEvent | null;
+    /**
+     * Cuts a soft body along a blade: a segment (two points) in 2D, a triangle (three points)
+     * in 3D. Pieces disconnected by the cut become soft bodies of their own.
+     *
+     * Returns the tear event (to be freed with `.free()`), or `null` when nothing changed.
+     */
+    cutSoftBody(body: SoftBody, blade: Vector[]): SoftBodyTearEvent | null;
+    /**
+     * Wakes a soft body and everything it touches up.
+     */
+    wakeUpSoftBody(body: SoftBody, strong: boolean): void;
+    /**
+     * Creates a new impulse joint from the given joint descriptor.
+     *
+     * @param params - The description of the joint to create.
+     * @param parent1 - The first rigid-body attached to this joint.
+     * @param parent2 - The second rigid-body attached to this joint.
+     * @param wakeUp - Should the attached rigid-bodies be awakened?
+     */
+    createImpulseJoint(params: JointData, parent1: RigidBody, parent2: RigidBody, wakeUp: boolean): ImpulseJoint;
+    /**
+     * Creates a new multibody joint from the given joint descriptor.
+     *
+     * @param params - The description of the joint to create.
+     * @param parent1 - The first rigid-body attached to this joint.
+     * @param parent2 - The second rigid-body attached to this joint.
+     * @param wakeUp - Should the attached rigid-bodies be awakened?
+     */
+    createMultibodyJoint(params: JointData, parent1: RigidBody, parent2: RigidBody, wakeUp: boolean): MultibodyJoint;
+    /**
+     * Retrieves a rigid-body from its handle.
+     *
+     * @param handle - The integer handle of the rigid-body to retrieve.
+     */
+    getRigidBody(handle: RigidBodyHandle): RigidBody;
+    /**
+     * Retrieves a collider from its handle.
+     *
+     * @param handle - The integer handle of the collider to retrieve.
+     */
+    getCollider(handle: ColliderHandle): Collider;
+    /**
+     * Retrieves an impulse joint from its handle.
+     *
+     * @param handle - The integer handle of the impulse joint to retrieve.
+     */
+    getImpulseJoint(handle: ImpulseJointHandle): ImpulseJoint;
+    /**
+     * Retrieves an multibody joint from its handle.
+     *
+     * @param handle - The integer handle of the multibody joint to retrieve.
+     */
+    getMultibodyJoint(handle: MultibodyJointHandle): MultibodyJoint;
+    /**
+     * Retrieves a soft body from its handle.
+     *
+     * @param handle - The integer handle of the soft body to retrieve.
+     */
+    getSoftBody(handle: SoftBodyHandle): SoftBody;
+    /**
+     * Removes the given rigid-body from this physics world.
+     *
+     * This will remove this rigid-body as well as all its attached colliders and joints.
+     * Every other bodies touching or attached by joints to this rigid-body will be woken-up.
+     *
+     * @param body - The rigid-body to remove.
+     */
+    removeRigidBody(body: RigidBody): void;
+    /**
+     * Removes the given soft body from this physics world, with its proxies, colliders and
+     * attached joints.
+     *
+     * @param body - The soft body to remove.
+     */
+    removeSoftBody(body: SoftBody): void;
+    /**
+     * Removes the given collider from this physics world.
+     *
+     * @param collider - The collider to remove.
+     * @param wakeUp - If set to `true`, the rigid-body this collider is attached to will be awaken.
+     */
+    removeCollider(collider: Collider, wakeUp: boolean): void;
+    /**
+     * Removes the given impulse joint from this physics world.
+     *
+     * @param joint - The impulse joint to remove.
+     * @param wakeUp - If set to `true`, the rigid-bodies attached by this joint will be awaken.
+     */
+    removeImpulseJoint(joint: ImpulseJoint, wakeUp: boolean): void;
+    /**
+     * Removes the given multibody joint from this physics world.
+     *
+     * @param joint - The multibody joint to remove.
+     * @param wakeUp - If set to `true`, the rigid-bodies attached by this joint will be awaken.
+     */
+    removeMultibodyJoint(joint: MultibodyJoint, wakeUp: boolean): void;
+    /**
+     * Applies the given closure to each collider managed by this physics world.
+     *
+     * @param f(collider) - The function to apply to each collider managed by this physics world. Called as `f(collider)`.
+     */
+    forEachCollider(f: (collider: Collider) => void): void;
+    /**
+     * Applies the given closure to each rigid-body managed by this physics world.
+     *
+     * @param f(body) - The function to apply to each rigid-body managed by this physics world. Called as `f(collider)`.
+     */
+    forEachRigidBody(f: (body: RigidBody) => void): void;
+    /**
+     * Applies the given closure to each active rigid-body managed by this physics world.
+     *
+     * After a short time of inactivity, a rigid-body is automatically deactivated ("asleep") by
+     * the physics engine in order to save computational power. A sleeping rigid-body never moves
+     * unless it is moved manually by the user.
+     *
+     * @param f - The function to apply to each active rigid-body managed by this physics world. Called as `f(collider)`.
+     */
+    forEachActiveRigidBody(f: (body: RigidBody) => void): void;
+    /**
+     * Applies the given closure to each soft body managed by this physics world.
+     *
+     * @param f(body) - The function to apply to each soft body managed by this physics world.
+     */
+    forEachSoftBody(f: (body: SoftBody) => void): void;
+    /**
+     * Find the closest intersection between a ray and the physics world.
+     *
+     * @param ray - The ray to cast.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the length of the ray to `ray.dir.norm() * maxToi`.
+     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its
+     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,
+     *   whereas `false` implies that all shapes are hollow for this ray-cast.
+     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.
+     * @param filter - The callback to filter out which collider will be hit.
+     */
+    castRay(ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): RayColliderHit | null;
+    /**
+     * Find the closest intersection between a ray and the physics world.
+     *
+     * This also computes the normal at the hit point.
+     * @param ray - The ray to cast.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the length of the ray to `ray.dir.norm() * maxToi`.
+     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its
+     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,
+     *   whereas `false` implies that all shapes are hollow for this ray-cast.
+     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.
+     */
+    castRayAndGetNormal(ray: Ray, maxToi: number, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): RayColliderIntersection | null;
+    /**
+     * Cast a ray and collects all the intersections between a ray and the scene.
+     *
+     * @param ray - The ray to cast.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the length of the ray to `ray.dir.norm() * maxToi`.
+     * @param solid - If `false` then the ray will attempt to hit the boundary of a shape, even if its
+     *   origin already lies inside of a shape. In other terms, `true` implies that all shapes are plain,
+     *   whereas `false` implies that all shapes are hollow for this ray-cast.
+     * @param groups - Used to filter the colliders that can or cannot be hit by the ray.
+     * @param callback - The callback called once per hit (in no particular order) between a ray and a collider.
+     *   If this callback returns `false`, then the cast will stop and no further hits will be detected/reported.
+     */
+    intersectionsWithRay(ray: Ray, maxToi: number, solid: boolean, callback: (intersect: RayColliderIntersection) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): void;
+    /**
+     * Gets the handle of up to one collider intersecting the given shape.
+     *
+     * @param shapePos - The position of the shape used for the intersection test.
+     * @param shapeRot - The orientation of the shape used for the intersection test.
+     * @param shape - The shape used for the intersection test.
+     * @param groups - The bit groups and filter associated to the ray, in order to only
+     *   hit the colliders with collision groups compatible with the ray's group.
+     */
+    intersectionWithShape(shapePos: Vector, shapeRot: Rotation, shape: Shape, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): Collider | null;
+    /**
+     * Find the projection of a point on the closest collider.
+     *
+     * @param point - The point to project.
+     * @param solid - If this is set to `true` then the collider shapes are considered to
+     *   be plain (if the point is located inside of a plain shape, its projection is the point
+     *   itself). If it is set to `false` the collider shapes are considered to be hollow
+     *   (if the point is located inside of an hollow shape, it is projected on the shape's
+     *   boundary).
+     * @param groups - The bit groups and filter associated to the point to project, in order to only
+     *   project on colliders with collision groups compatible with the ray's group.
+     */
+    projectPoint(point: Vector, solid: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): PointColliderProjection | null;
+    /**
+     * Find the projection of a point on the closest collider.
+     *
+     * @param point - The point to project.
+     * @param groups - The bit groups and filter associated to the point to project, in order to only
+     *   project on colliders with collision groups compatible with the ray's group.
+     */
+    projectPointAndGetFeature(point: Vector, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): PointColliderProjection | null;
+    /**
+     * Find all the colliders containing the given point.
+     *
+     * @param point - The point used for the containment test.
+     * @param groups - The bit groups and filter associated to the point to test, in order to only
+     *   test on colliders with collision groups compatible with the ray's group.
+     * @param callback - A function called with the handles of each collider with a shape
+     *   containing the `point`.
+     */
+    intersectionsWithPoint(point: Vector, callback: (handle: Collider) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): void;
+    /**
+     * Casts a shape at a constant linear velocity and retrieve the first collider it hits.
+     * This is similar to ray-casting except that we are casting a whole shape instead of
+     * just a point (the ray origin).
+     *
+     * In the returned hit, `witness1` and `normal1` lie on the hit collider and are expressed in
+     * world-space, while `witness2` and `normal2` lie on the cast shape and are expressed in its
+     * local-space (relative to `shapePos` and `shapeRot`).
+     *
+     * @param shapePos - The initial position of the shape to cast.
+     * @param shapeRot - The initial rotation of the shape to cast.
+     * @param shapeVel - The constant velocity of the shape to cast (i.e. the cast direction).
+     * @param shape - The shape to cast.
+     * @param targetDistance − If the shape moves closer to this distance from a collider, a hit
+     *                         will be returned.
+     * @param maxToi - The maximum time-of-impact that can be reported by this cast. This effectively
+     *   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.
+     * @param stopAtPenetration - If set to `false`, the linear shape-cast won’t immediately stop if
+     *   the shape is penetrating another shape at its starting point **and** its trajectory is such
+     *   that it’s on a path to exit that penetration state.
+     * @param groups - The bit groups and filter associated to the shape to cast, in order to only
+     *   test on colliders with collision groups compatible with this group.
+     */
+    castShape(shapePos: Vector, shapeRot: Rotation, shapeVel: Vector, shape: Shape, targetDistance: number, maxToi: number, stopAtPenetration: boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): ColliderShapeCastHit | null;
+    /**
+     * Retrieve all the colliders intersecting the given shape.
+     *
+     * @param shapePos - The position of the shape to test.
+     * @param shapeRot - The orientation of the shape to test.
+     * @param shape - The shape to test.
+     * @param groups - The bit groups and filter associated to the shape to test, in order to only
+     *   test on colliders with collision groups compatible with this group.
+     * @param callback - A function called with the handles of each collider intersecting the `shape`.
+     */
+    intersectionsWithShape(shapePos: Vector, shapeRot: Rotation, shape: Shape, callback: (collider: Collider) => boolean, filterFlags?: QueryFilterFlags, filterGroups?: InteractionGroups, filterExcludeCollider?: Collider, filterExcludeRigidBody?: RigidBody, filterPredicate?: (collider: Collider) => boolean): void;
+    /**
+     * Finds the handles of all the colliders with an AABB intersecting the given AABB.
+     *
+     * @param aabbCenter - The center of the AABB to test.
+     * @param aabbHalfExtents - The half-extents of the AABB to test.
+     * @param callback - The callback that will be called with the handles of all the colliders
+     *                   currently intersecting the given AABB.
+     */
+    collidersWithAabbIntersectingAabb(aabbCenter: Vector, aabbHalfExtents: Vector, callback: (handle: Collider) => boolean): void;
+    /**
+     * Enumerates all the colliders potentially in contact with the given collider.
+     *
+     * @param collider1 - The second collider involved in the contact.
+     * @param f - Closure that will be called on each collider that is in contact with `collider1`.
+     */
+    contactPairsWith(collider1: Collider, f: (collider2: Collider) => void): void;
+    /**
+     * Enumerates all the colliders intersecting the given colliders, assuming one of them
+     * is a sensor.
+     */
+    intersectionPairsWith(collider1: Collider, f: (collider2: Collider) => void): void;
+    /**
+     * Iterates through all the contact manifolds between the given pair of colliders.
+     *
+     * @param collider1 - The first collider involved in the contact.
+     * @param collider2 - The second collider involved in the contact.
+     * @param f - Closure that will be called on each contact manifold between the two colliders. If the second argument
+     *            passed to this closure is `true`, then the contact manifold data is flipped, i.e., methods like `localNormal1`
+     *            actually apply to the `collider2` and fields like `localNormal2` apply to the `collider1`.
+     */
+    contactPair(collider1: Collider, collider2: Collider, f: (manifold: TempContactManifold, flipped: boolean) => void): void;
+    /**
+     * Visits solver manifolds, including contact clusters not exposed by contactPair().
+     * The callback view is temporary. Do not mutate, step or free this world inside it.
+     */
+    solverContactPair(collider1: Collider, collider2: Collider, f: (manifold: SolverContactManifold, flipped: boolean) => void): void;
+    /**
+     * Returns `true` if `collider1` and `collider2` intersect and at least one of them is a sensor.
+     * @param collider1 − The first collider involved in the intersection.
+     * @param collider2 − The second collider involved in the intersection.
+     */
+    intersectionPair(collider1: Collider, collider2: Collider): boolean;
+    /**
+     * Sets whether internal performance profiling is enabled (default: false).
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    set profilerEnabled(enabled: boolean);
+    /**
+     * Indicates if the internal performance profiling is enabled.
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    get profilerEnabled(): boolean;
+    /**
+     * The time spent in milliseconds by the last step to run the entire simulation step.
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingStep(): number;
+    /**
+     * The time spent in milliseconds by the last step to run the collision-detection
+     * (broad-phase + narrow-phase).
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingCollisionDetection(): number;
+    /**
+     * The time spent in milliseconds by the last step to run the broad-phase.
+     *
+     * This timing is included in `timingCollisionDetection`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingBroadPhase(): number;
+    /**
+     * The time spent in milliseconds by the last step to run the narrow-phase.
+     *
+     * This timing is included in `timingCollisionDetection`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingNarrowPhase(): number;
+    /**
+     * The time spent in milliseconds by the last step to run the constraint solver.
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingSolver(): number;
+    /**
+     * The time spent in milliseconds by the last step to run the constraint
+     * initialization.
+     *
+     * This timing is included in `timingSolver`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingVelocityAssembly(): number;
+    /**
+     * The time spent in milliseconds by the last step to run the constraint
+     * resolution.
+     *
+     * This timing is included in `timingSolver`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingVelocityResolution(): number;
+    /**
+     * The time spent in milliseconds by the last step to run the rigid-body
+     * velocity update.
+     *
+     * This timing is included in `timingSolver`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingVelocityUpdate(): number;
+    /**
+     * The time spent in milliseconds by writing rigid-body velocities
+     * calculated by the solver back into the rigid-bodies.
+     *
+     * This timing is included in `timingSolver`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingVelocityWriteback(): number;
+    /**
+     * The total time spent in CCD detection and resolution.
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingCcd(): number;
+    /**
+     * The total time spent searching for the continuous hits during CCD.
+     *
+     * This timing is included in `timingCcd`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingCcdToiComputation(): number;
+    /**
+     * The total time spent in the broad-phase during CCD.
+     *
+     * This timing is included in `timingCcd`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingCcdBroadPhase(): number;
+    /**
+     * The total time spent in the narrow-phase during CCD.
+     *
+     * This timing is included in `timingCcd`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingCcdNarrowPhase(): number;
+    /**
+     * The total time spent in the constraints resolution during CCD.
+     *
+     * This timing is included in `timingCcd`.
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingCcdSolver(): number;
+    /**
+     * The total time spent in the islands calculation during CCD.
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingIslandConstruction(): number;
+    /**
+     * The total time spent propagating detected user changes.
+     *
+     * Only works if the internal profiler is enabled with `World.profilerEnabled = true`.
+     */
+    timingUserChanges(): number;
+}

package/dist/types/rapier.d.ts

@@ -0,0 +1,3 @@
+import * as RAPIER from "./exports";
+export * from "./exports";
+export default RAPIER;