main repo

node_modules/@dimforge/rapier3d-compat/geometry/broad_phase.d.ts

@@ -0,0 +1,15 @@
+import { RawBroadPhase } from "../raw";
+/**
+ * The broad-phase used for coarse collision-detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `broadPhase.free()`
+ * once you are done using it.
+ */
+export declare class BroadPhase {
+    raw: RawBroadPhase;
+    /**
+     * Release the WASM memory occupied by this broad-phase.
+     */
+    free(): void;
+    constructor(raw?: RawBroadPhase);
+}

node_modules/@dimforge/rapier3d-compat/geometry/collider.d.ts

@@ -0,0 +1,763 @@
+import { Rotation, Vector } from "../math";
+import { CoefficientCombineRule, RigidBody, RigidBodySet } from "../dynamics";
+import { ActiveHooks, ActiveEvents } from "../pipeline";
+import { InteractionGroups } from "./interaction_groups";
+import { Shape, ShapeType } from "./shape";
+import { Ray, RayIntersection } from "./ray";
+import { PointProjection } from "./point";
+import { ShapeColliderTOI, ShapeTOI } from "./toi";
+import { ShapeContact } from "./contact";
+import { ColliderSet } from "./collider_set";
+/**
+ * Flags affecting whether collision-detection happens between two colliders
+ * depending on the type of rigid-bodies they are attached to.
+ */
+export declare enum ActiveCollisionTypes {
+    /**
+     * Enable collision-detection between a collider attached to a dynamic body
+     * and another collider attached to a dynamic body.
+     */
+    DYNAMIC_DYNAMIC = 1,
+    /**
+     * Enable collision-detection between a collider attached to a dynamic body
+     * and another collider attached to a kinematic body.
+     */
+    DYNAMIC_KINEMATIC = 12,
+    /**
+     * Enable collision-detection between a collider attached to a dynamic body
+     * and another collider attached to a fixed body (or not attached to any body).
+     */
+    DYNAMIC_FIXED = 2,
+    /**
+     * Enable collision-detection between a collider attached to a kinematic body
+     * and another collider attached to a kinematic body.
+     */
+    KINEMATIC_KINEMATIC = 52224,
+    /**
+     * Enable collision-detection between a collider attached to a kinematic body
+     * and another collider attached to a fixed body (or not attached to any body).
+     */
+    KINEMATIC_FIXED = 8704,
+    /**
+     * Enable collision-detection between a collider attached to a fixed body (or
+     * not attached to any body) and another collider attached to a fixed body (or
+     * not attached to any body).
+     */
+    FIXED_FIXED = 32,
+    /**
+     * The default active collision types, enabling collisions between a dynamic body
+     * and another body of any type, but not enabling collisions between two non-dynamic bodies.
+     */
+    DEFAULT = 15,
+    /**
+     * Enable collisions between any kind of rigid-bodies (including between two non-dynamic bodies).
+     */
+    ALL = 60943
+}
+/**
+ * The integer identifier of a collider added to a `ColliderSet`.
+ */
+export declare type ColliderHandle = number;
+/**
+ * A geometric entity that can be attached to a body so it can be affected
+ * by contacts and proximity queries.
+ */
+export declare class Collider {
+    private colliderSet;
+    readonly handle: ColliderHandle;
+    private _shape;
+    private _parent;
+    constructor(colliderSet: ColliderSet, handle: ColliderHandle, parent: RigidBody | null, shape?: Shape);
+    /** @internal */
+    finalizeDeserialization(bodies: RigidBodySet): void;
+    private ensureShapeIsCached;
+    /**
+     * The shape of this collider.
+     */
+    get shape(): Shape;
+    /**
+     * Checks if this collider is still valid (i.e. that it has
+     * not been deleted from the collider set yet).
+     */
+    isValid(): boolean;
+    /**
+     * The world-space translation of this rigid-body.
+     */
+    translation(): Vector;
+    /**
+     * The world-space orientation of this rigid-body.
+     */
+    rotation(): Rotation;
+    /**
+     * Is this collider a sensor?
+     */
+    isSensor(): boolean;
+    /**
+     * Sets whether or not this collider is a sensor.
+     * @param isSensor - If `true`, the collider will be a sensor.
+     */
+    setSensor(isSensor: boolean): void;
+    /**
+     * Sets the new shape of the collider.
+     * @param shape - The collider’s new shape.
+     */
+    setShape(shape: Shape): void;
+    /**
+     * Sets whether this collider is enabled or not.
+     *
+     * @param enabled - Set to `false` to disable this collider (its parent rigid-body won’t be disabled automatically by this).
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Is this collider enabled?
+     */
+    isEnabled(): boolean;
+    /**
+     * Sets the restitution coefficient of the collider to be created.
+     *
+     * @param restitution - The restitution coefficient in `[0, 1]`. A value of 0 (the default) means no bouncing behavior
+     *                   while 1 means perfect bouncing (though energy may still be lost due to numerical errors of the
+     *                   constraints solver).
+     */
+    setRestitution(restitution: number): void;
+    /**
+     * Sets the friction coefficient of the collider to be created.
+     *
+     * @param friction - The friction coefficient. Must be greater or equal to 0. This is generally smaller than 1. The
+     *                   higher the coefficient, the stronger friction forces will be for contacts with the collider
+     *                   being built.
+     */
+    setFriction(friction: number): void;
+    /**
+     * Gets the rule used to combine the friction coefficients of two colliders
+     * colliders involved in a contact.
+     */
+    frictionCombineRule(): CoefficientCombineRule;
+    /**
+     * Sets the rule used to combine the friction coefficients of two colliders
+     * colliders involved in a contact.
+     *
+     * @param rule − The combine rule to apply.
+     */
+    setFrictionCombineRule(rule: CoefficientCombineRule): void;
+    /**
+     * Gets the rule used to combine the restitution coefficients of two colliders
+     * colliders involved in a contact.
+     */
+    restitutionCombineRule(): CoefficientCombineRule;
+    /**
+     * Sets the rule used to combine the restitution coefficients of two colliders
+     * colliders involved in a contact.
+     *
+     * @param rule − The combine rule to apply.
+     */
+    setRestitutionCombineRule(rule: CoefficientCombineRule): void;
+    /**
+     * Sets the collision groups used by this collider.
+     *
+     * Two colliders will interact iff. their collision groups are compatible.
+     * See the documentation of `InteractionGroups` for details on teh used bit pattern.
+     *
+     * @param groups - The collision groups used for the collider being built.
+     */
+    setCollisionGroups(groups: InteractionGroups): void;
+    /**
+     * Sets the solver groups used by this collider.
+     *
+     * Forces between two colliders in contact will be computed iff their solver
+     * groups are compatible.
+     * See the documentation of `InteractionGroups` for details on the used bit pattern.
+     *
+     * @param groups - The solver groups used for the collider being built.
+     */
+    setSolverGroups(groups: InteractionGroups): void;
+    /**
+     * Get the physics hooks active for this collider.
+     */
+    activeHooks(): number;
+    /**
+     * Set the physics hooks active for this collider.
+     *
+     * Use this to enable custom filtering rules for contact/intersecstion pairs involving this collider.
+     *
+     * @param activeHooks - The hooks active for contact/intersection pairs involving this collider.
+     */
+    setActiveHooks(activeHooks: ActiveHooks): void;
+    /**
+     * The events active for this collider.
+     */
+    activeEvents(): ActiveEvents;
+    /**
+     * Set the events active for this collider.
+     *
+     * Use this to enable contact and/or intersection event reporting for this collider.
+     *
+     * @param activeEvents - The events active for contact/intersection pairs involving this collider.
+     */
+    setActiveEvents(activeEvents: ActiveEvents): void;
+    /**
+     * Gets the collision types active for this collider.
+     */
+    activeCollisionTypes(): ActiveCollisionTypes;
+    /**
+     * Sets the total force magnitude beyond which a contact force event can be emitted.
+     *
+     * @param threshold - The new force threshold.
+     */
+    setContactForceEventThreshold(threshold: number): void;
+    /**
+     * The total force magnitude beyond which a contact force event can be emitted.
+     */
+    contactForceEventThreshold(): number;
+    /**
+     * Set the collision types active for this collider.
+     *
+     * @param activeCollisionTypes - The hooks active for contact/intersection pairs involving this collider.
+     */
+    setActiveCollisionTypes(activeCollisionTypes: ActiveCollisionTypes): void;
+    /**
+     * Sets the uniform density of this collider.
+     *
+     * This will override any previous mass-properties set by `this.setDensity`,
+     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,
+     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.
+     *
+     * The mass and angular inertia of this collider will be computed automatically based on its
+     * shape.
+     */
+    setDensity(density: number): void;
+    /**
+     * Sets the mass of this collider.
+     *
+     * This will override any previous mass-properties set by `this.setDensity`,
+     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,
+     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.
+     *
+     * The angular inertia of this collider will be computed automatically based on its shape
+     * and this mass value.
+     */
+    setMass(mass: number): void;
+    /**
+     * Sets the mass of this collider.
+     *
+     * This will override any previous mass-properties set by `this.setDensity`,
+     * `this.setMass`, `this.setMassProperties`, `ColliderDesc.density`,
+     * `ColliderDesc.mass`, or `ColliderDesc.massProperties` for this collider.
+     */
+    setMassProperties(mass: number, centerOfMass: Vector, principalAngularInertia: Vector, angularInertiaLocalFrame: Rotation): void;
+    /**
+     * Sets the translation of this collider.
+     *
+     * @param tra - The world-space position of the collider.
+     */
+    setTranslation(tra: Vector): void;
+    /**
+     * Sets the translation of this collider relative to its parent rigid-body.
+     *
+     * Does nothing if this collider isn't attached to a rigid-body.
+     *
+     * @param tra - The new translation of the collider relative to its parent.
+     */
+    setTranslationWrtParent(tra: Vector): void;
+    /**
+     * Sets the rotation quaternion of this collider.
+     *
+     * This does nothing if a zero quaternion is provided.
+     *
+     * @param rotation - The rotation to set.
+     */
+    setRotation(rot: Rotation): void;
+    /**
+     * Sets the rotation quaternion of this collider relative to its parent rigid-body.
+     *
+     * This does nothing if a zero quaternion is provided or if this collider isn't
+     * attached to a rigid-body.
+     *
+     * @param rotation - The rotation to set.
+     */
+    setRotationWrtParent(rot: Rotation): void;
+    /**
+     * The type of the shape of this collider.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    shapeType(): ShapeType;
+    /**
+     * The half-extents of this collider if it is a cuboid shape.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    halfExtents(): Vector;
+    /**
+     * Sets the half-extents of this collider if it is a cuboid shape.
+     *
+     * @param newHalfExtents - desired half extents.
+     */
+    setHalfExtents(newHalfExtents: Vector): void;
+    /**
+     * The radius of this collider if it is a ball, cylinder, capsule, or cone shape.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    radius(): number;
+    /**
+     * Sets the radius of this collider if it is a ball, cylinder, capsule, or cone shape.
+     *
+     * @param newRadius - desired radius.
+     */
+    setRadius(newRadius: number): void;
+    /**
+     * The radius of the round edges of this collider if it is a round cylinder.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    roundRadius(): number;
+    /**
+     * Sets the radius of the round edges of this collider if it has round edges.
+     *
+     * @param newBorderRadius - desired round edge radius.
+     */
+    setRoundRadius(newBorderRadius: number): void;
+    /**
+     * The half height of this collider if it is a cylinder, capsule, or cone shape.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    halfHeight(): number;
+    /**
+     * Sets the half height of this collider if it is a cylinder, capsule, or cone shape.
+     *
+     * @param newHalfheight - desired half height.
+     */
+    setHalfHeight(newHalfheight: number): void;
+    /**
+     * If this collider has a triangle mesh, polyline, convex polygon, or convex polyhedron shape,
+     * this returns the vertex buffer of said shape.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    vertices(): Float32Array;
+    /**
+     * If this collider has a triangle mesh, polyline, or convex polyhedron shape,
+     * this returns the index buffer of said shape.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    indices(): Uint32Array | undefined;
+    /**
+     * If this collider has a heightfield shape, this returns the heights buffer of
+     * the heightfield.
+     * In 3D, the returned height matrix is provided in column-major order.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    heightfieldHeights(): Float32Array;
+    /**
+     * If this collider has a heightfield shape, this returns the scale
+     * applied to it.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    heightfieldScale(): Vector;
+    /**
+     * If this collider has a heightfield shape, this returns the number of
+     * rows of its height matrix.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    heightfieldNRows(): number;
+    /**
+     * If this collider has a heightfield shape, this returns the number of
+     * columns of its height matrix.
+     * @deprecated this field will be removed in the future, please access this field on `shape` member instead.
+     */
+    heightfieldNCols(): number;
+    /**
+     * The rigid-body this collider is attached to.
+     */
+    parent(): RigidBody | null;
+    /**
+     * The friction coefficient of this collider.
+     */
+    friction(): number;
+    /**
+     * The restitution coefficient of this collider.
+     */
+    restitution(): number;
+    /**
+     * The density of this collider.
+     */
+    density(): number;
+    /**
+     * The mass of this collider.
+     */
+    mass(): number;
+    /**
+     * The volume of this collider.
+     */
+    volume(): number;
+    /**
+     * The collision groups of this collider.
+     */
+    collisionGroups(): InteractionGroups;
+    /**
+     * The solver groups of this collider.
+     */
+    solverGroups(): InteractionGroups;
+    /**
+     * Tests if this collider contains a point.
+     *
+     * @param point - The point to test.
+     */
+    containsPoint(point: Vector): boolean;
+    /**
+     * Find the projection of a point on this 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).
+     */
+    projectPoint(point: Vector, solid: boolean): PointProjection | null;
+    /**
+     * Tests if this collider intersects the given ray.
+     *
+     * @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`.
+     */
+    intersectsRay(ray: Ray, maxToi: number): boolean;
+    castShape(collider1Vel: Vector, shape2: Shape, shape2Pos: Vector, shape2Rot: Rotation, shape2Vel: Vector, maxToi: number, stopAtPenetration: boolean): ShapeTOI | null;
+    castCollider(collider1Vel: Vector, collider2: Collider, collider2Vel: Vector, maxToi: number, stopAtPenetration: boolean): ShapeColliderTOI | null;
+    intersectsShape(shape2: Shape, shapePos2: Vector, shapeRot2: Rotation): boolean;
+    /**
+     * Computes one pair of contact points between the shape owned by this collider and the given shape.
+     *
+     * @param shape2 - The second shape.
+     * @param shape2Pos - The initial position of the second shape.
+     * @param shape2Rot - The rotation of the second shape.
+     * @param prediction - The prediction value, if the shapes are separated by a distance greater than this value, test will fail.
+     * @returns `null` if the shapes are separated by a distance greater than prediction, otherwise contact details. The result is given in world-space.
+     */
+    contactShape(shape2: Shape, shape2Pos: Vector, shape2Rot: Rotation, prediction: number): ShapeContact | null;
+    /**
+     * Computes one pair of contact points between the collider and the given collider.
+     *
+     * @param collider2 - The second collider.
+     * @param prediction - The prediction value, if the shapes are separated by a distance greater than this value, test will fail.
+     * @returns `null` if the shapes are separated by a distance greater than prediction, otherwise contact details. The result is given in world-space.
+     */
+    contactCollider(collider2: Collider, prediction: number): ShapeContact | null;
+    castRay(ray: Ray, maxToi: number, solid: boolean): number;
+    /**
+     * Find the closest intersection between a ray and this collider.
+     *
+     * 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.
+     */
+    castRayAndGetNormal(ray: Ray, maxToi: number, solid: boolean): RayIntersection | null;
+}
+export declare enum MassPropsMode {
+    Density = 0,
+    Mass = 1,
+    MassProps = 2
+}
+export declare class ColliderDesc {
+    enabled: boolean;
+    shape: Shape;
+    massPropsMode: MassPropsMode;
+    mass: number;
+    centerOfMass: Vector;
+    principalAngularInertia: Vector;
+    angularInertiaLocalFrame: Rotation;
+    density: number;
+    friction: number;
+    restitution: number;
+    rotation: Rotation;
+    translation: Vector;
+    isSensor: boolean;
+    collisionGroups: InteractionGroups;
+    solverGroups: InteractionGroups;
+    frictionCombineRule: CoefficientCombineRule;
+    restitutionCombineRule: CoefficientCombineRule;
+    activeEvents: ActiveEvents;
+    activeHooks: ActiveHooks;
+    activeCollisionTypes: ActiveCollisionTypes;
+    contactForceEventThreshold: number;
+    /**
+     * Initializes a collider descriptor from the collision shape.
+     *
+     * @param shape - The shape of the collider being built.
+     */
+    constructor(shape: Shape);
+    /**
+     * Create a new collider descriptor with a ball shape.
+     *
+     * @param radius - The radius of the ball.
+     */
+    static ball(radius: number): ColliderDesc;
+    /**
+     * Create a new collider descriptor with a capsule shape.
+     *
+     * @param halfHeight - The half-height of the capsule, along the `y` axis.
+     * @param radius - The radius of the capsule basis.
+     */
+    static capsule(halfHeight: number, radius: number): ColliderDesc;
+    /**
+     * Creates a new segment shape.
+     *
+     * @param a - The first point of the segment.
+     * @param b - The second point of the segment.
+     */
+    static segment(a: Vector, b: Vector): ColliderDesc;
+    /**
+     * Creates a new triangle shape.
+     *
+     * @param a - The first point of the triangle.
+     * @param b - The second point of the triangle.
+     * @param c - The third point of the triangle.
+     */
+    static triangle(a: Vector, b: Vector, c: Vector): ColliderDesc;
+    /**
+     * Creates a new triangle shape with round corners.
+     *
+     * @param a - The first point of the triangle.
+     * @param b - The second point of the triangle.
+     * @param c - The third point of the triangle.
+     * @param borderRadius - The radius of the borders of this triangle. In 3D,
+     *   this is also equal to half the thickness of the triangle.
+     */
+    static roundTriangle(a: Vector, b: Vector, c: Vector, borderRadius: number): ColliderDesc;
+    /**
+     * Creates a new collider descriptor with a polyline shape.
+     *
+     * @param vertices - The coordinates of the polyline's vertices.
+     * @param indices - The indices of the polyline's segments. If this is `undefined` or `null`,
+     *    the vertices are assumed to describe a line strip.
+     */
+    static polyline(vertices: Float32Array, indices?: Uint32Array | null): ColliderDesc;
+    /**
+     * Creates a new collider descriptor with a triangle mesh shape.
+     *
+     * @param vertices - The coordinates of the triangle mesh's vertices.
+     * @param indices - The indices of the triangle mesh's triangles.
+     */
+    static trimesh(vertices: Float32Array, indices: Uint32Array): ColliderDesc;
+    /**
+     * Creates a new collider descriptor with a cuboid shape.
+     *
+     * @param hx - The half-width of the rectangle along its local `x` axis.
+     * @param hy - The half-width of the rectangle along its local `y` axis.
+     * @param hz - The half-width of the rectangle along its local `z` axis.
+     */
+    static cuboid(hx: number, hy: number, hz: number): ColliderDesc;
+    /**
+     * Creates a new collider descriptor with a rectangular shape with round borders.
+     *
+     * @param hx - The half-width of the rectangle along its local `x` axis.
+     * @param hy - The half-width of the rectangle along its local `y` axis.
+     * @param hz - The half-width of the rectangle along its local `z` axis.
+     * @param borderRadius - The radius of the cuboid's borders.
+     */
+    static roundCuboid(hx: number, hy: number, hz: number, borderRadius: number): ColliderDesc;
+    /**
+     * Creates a new collider descriptor with a heightfield shape.
+     *
+     * @param nrows − The number of rows in the heights matrix.
+     * @param ncols - The number of columns in the heights matrix.
+     * @param heights - The heights of the heightfield along its local `y` axis,
+     *                  provided as a matrix stored in column-major order.
+     * @param scale - The scale factor applied to the heightfield.
+     */
+    static heightfield(nrows: number, ncols: number, heights: Float32Array, scale: Vector): ColliderDesc;
+    /**
+     * Create a new collider descriptor with a cylinder shape.
+     *
+     * @param halfHeight - The half-height of the cylinder, along the `y` axis.
+     * @param radius - The radius of the cylinder basis.
+     */
+    static cylinder(halfHeight: number, radius: number): ColliderDesc;
+    /**
+     * Create a new collider descriptor with a cylinder shape with rounded corners.
+     *
+     * @param halfHeight - The half-height of the cylinder, along the `y` axis.
+     * @param radius - The radius of the cylinder basis.
+     * @param borderRadius - The radius of the cylinder's rounded edges and vertices.
+     */
+    static roundCylinder(halfHeight: number, radius: number, borderRadius: number): ColliderDesc;
+    /**
+     * Create a new collider descriptor with a cone shape.
+     *
+     * @param halfHeight - The half-height of the cone, along the `y` axis.
+     * @param radius - The radius of the cone basis.
+     */
+    static cone(halfHeight: number, radius: number): ColliderDesc;
+    /**
+     * Create a new collider descriptor with a cone shape with rounded corners.
+     *
+     * @param halfHeight - The half-height of the cone, along the `y` axis.
+     * @param radius - The radius of the cone basis.
+     * @param borderRadius - The radius of the cone's rounded edges and vertices.
+     */
+    static roundCone(halfHeight: number, radius: number, borderRadius: number): ColliderDesc;
+    /**
+     * Computes the convex-hull of the given points and use the resulting
+     * convex polyhedron as the shape for this new collider descriptor.
+     *
+     * @param points - The point that will be used to compute the convex-hull.
+     */
+    static convexHull(points: Float32Array): ColliderDesc | null;
+    /**
+     * Creates a new collider descriptor that uses the given set of points assumed
+     * to form a convex polyline (no convex-hull computation will be done).
+     *
+     * @param vertices - The vertices of the convex polyline.
+     */
+    static convexMesh(vertices: Float32Array, indices?: Uint32Array | null): ColliderDesc | null;
+    /**
+     * Computes the convex-hull of the given points and use the resulting
+     * convex polyhedron as the shape for this new collider descriptor. A
+     * border is added to that convex polyhedron to give it round corners.
+     *
+     * @param points - The point that will be used to compute the convex-hull.
+     * @param borderRadius - The radius of the round border added to the convex polyhedron.
+     */
+    static roundConvexHull(points: Float32Array, borderRadius: number): ColliderDesc | null;
+    /**
+     * Creates a new collider descriptor that uses the given set of points assumed
+     * to form a round convex polyline (no convex-hull computation will be done).
+     *
+     * @param vertices - The vertices of the convex polyline.
+     * @param borderRadius - The radius of the round border added to the convex polyline.
+     */
+    static roundConvexMesh(vertices: Float32Array, indices: Uint32Array | null, borderRadius: number): ColliderDesc | null;
+    /**
+     * Sets the position of the collider to be created relative to the rigid-body it is attached to.
+     */
+    setTranslation(x: number, y: number, z: number): ColliderDesc;
+    /**
+     * Sets the rotation of the collider to be created relative to the rigid-body it is attached to.
+     *
+     * @param rot - The rotation of the collider to be created relative to the rigid-body it is attached to.
+     */
+    setRotation(rot: Rotation): ColliderDesc;
+    /**
+     * Sets whether or not the collider being created is a sensor.
+     *
+     * A sensor collider does not take part of the physics simulation, but generates
+     * proximity events.
+     *
+     * @param sensor - Set to `true` of the collider built is to be a sensor.
+     */
+    setSensor(sensor: boolean): ColliderDesc;
+    /**
+     * Sets whether the created collider will be enabled or disabled.
+     * @param enabled − If set to `false` the collider will be disabled at creation.
+     */
+    setEnabled(enabled: boolean): ColliderDesc;
+    /**
+     * Sets the density of the collider being built.
+     *
+     * The mass and angular inertia tensor will be computed automatically based on this density and the collider’s shape.
+     *
+     * @param density - The density to set, must be greater or equal to 0. A density of 0 means that this collider
+     *                  will not affect the mass or angular inertia of the rigid-body it is attached to.
+     */
+    setDensity(density: number): ColliderDesc;
+    /**
+     * Sets the mass of the collider being built.
+     *
+     * The angular inertia tensor will be computed automatically based on this mass and the collider’s shape.
+     *
+     * @param mass - The mass to set, must be greater or equal to 0.
+     */
+    setMass(mass: number): ColliderDesc;
+    /**
+     * Sets the mass properties of the collider being built.
+     *
+     * This replaces the mass-properties automatically computed from the collider's density and shape.
+     * These mass-properties will be added to the mass-properties of the rigid-body this collider will be attached to.
+     *
+     * @param mass − The mass of the collider to create.
+     * @param centerOfMass − The center-of-mass of the collider to create.
+     * @param principalAngularInertia − The initial principal angular inertia of the collider to create.
+     *                                  These are the eigenvalues of the angular inertia matrix.
+     * @param angularInertiaLocalFrame − The initial local angular inertia frame of the collider to create.
+     *                                   These are the eigenvectors of the angular inertia matrix.
+     */
+    setMassProperties(mass: number, centerOfMass: Vector, principalAngularInertia: Vector, angularInertiaLocalFrame: Rotation): ColliderDesc;
+    /**
+     * Sets the restitution coefficient of the collider to be created.
+     *
+     * @param restitution - The restitution coefficient in `[0, 1]`. A value of 0 (the default) means no bouncing behavior
+     *                   while 1 means perfect bouncing (though energy may still be lost due to numerical errors of the
+     *                   constraints solver).
+     */
+    setRestitution(restitution: number): ColliderDesc;
+    /**
+     * Sets the friction coefficient of the collider to be created.
+     *
+     * @param friction - The friction coefficient. Must be greater or equal to 0. This is generally smaller than 1. The
+     *                   higher the coefficient, the stronger friction forces will be for contacts with the collider
+     *                   being built.
+     */
+    setFriction(friction: number): ColliderDesc;
+    /**
+     * Sets the rule used to combine the friction coefficients of two colliders
+     * colliders involved in a contact.
+     *
+     * @param rule − The combine rule to apply.
+     */
+    setFrictionCombineRule(rule: CoefficientCombineRule): ColliderDesc;
+    /**
+     * Sets the rule used to combine the restitution coefficients of two colliders
+     * colliders involved in a contact.
+     *
+     * @param rule − The combine rule to apply.
+     */
+    setRestitutionCombineRule(rule: CoefficientCombineRule): ColliderDesc;
+    /**
+     * Sets the collision groups used by this collider.
+     *
+     * Two colliders will interact iff. their collision groups are compatible.
+     * See the documentation of `InteractionGroups` for details on teh used bit pattern.
+     *
+     * @param groups - The collision groups used for the collider being built.
+     */
+    setCollisionGroups(groups: InteractionGroups): ColliderDesc;
+    /**
+     * Sets the solver groups used by this collider.
+     *
+     * Forces between two colliders in contact will be computed iff their solver
+     * groups are compatible.
+     * See the documentation of `InteractionGroups` for details on the used bit pattern.
+     *
+     * @param groups - The solver groups used for the collider being built.
+     */
+    setSolverGroups(groups: InteractionGroups): ColliderDesc;
+    /**
+     * Set the physics hooks active for this collider.
+     *
+     * Use this to enable custom filtering rules for contact/intersecstion pairs involving this collider.
+     *
+     * @param activeHooks - The hooks active for contact/intersection pairs involving this collider.
+     */
+    setActiveHooks(activeHooks: ActiveHooks): ColliderDesc;
+    /**
+     * Set the events active for this collider.
+     *
+     * Use this to enable contact and/or intersection event reporting for this collider.
+     *
+     * @param activeEvents - The events active for contact/intersection pairs involving this collider.
+     */
+    setActiveEvents(activeEvents: ActiveEvents): ColliderDesc;
+    /**
+     * Set the collision types active for this collider.
+     *
+     * @param activeCollisionTypes - The hooks active for contact/intersection pairs involving this collider.
+     */
+    setActiveCollisionTypes(activeCollisionTypes: ActiveCollisionTypes): ColliderDesc;
+    /**
+     * Sets the total force magnitude beyond which a contact force event can be emitted.
+     *
+     * @param threshold - The force threshold to set.
+     */
+    setContactForceEventThreshold(threshold: number): ColliderDesc;
+}

node_modules/@dimforge/rapier3d-compat/geometry/collider_set.d.ts

@@ -0,0 +1,72 @@
+import { RawColliderSet } from "../raw";
+import { Collider, ColliderDesc, ColliderHandle } from "./collider";
+import { ImpulseJointHandle, IslandManager, RigidBodyHandle } from "../dynamics";
+import { RigidBodySet } from "../dynamics";
+/**
+ * A set of rigid bodies that can be handled by a physics pipeline.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `colliderSet.free()`
+ * once you are done using it (and all the rigid-bodies it created).
+ */
+export declare class ColliderSet {
+    raw: RawColliderSet;
+    private map;
+    /**
+     * Release the WASM memory occupied by this collider set.
+     */
+    free(): void;
+    constructor(raw?: RawColliderSet);
+    /** @internal */
+    castClosure<Res>(f?: (collider: Collider) => Res): (handle: ColliderHandle) => Res | undefined;
+    /** @internal */
+    finalizeDeserialization(bodies: RigidBodySet): void;
+    /**
+     * Creates a new collider and return its integer handle.
+     *
+     * @param bodies - The set of bodies where the collider's parent can be found.
+     * @param desc - The collider's description.
+     * @param parentHandle - The integer handle of the rigid-body this collider is attached to.
+     */
+    createCollider(bodies: RigidBodySet, desc: ColliderDesc, parentHandle: RigidBodyHandle): Collider;
+    /**
+     * Remove a collider from this set.
+     *
+     * @param handle - The integer handle of the collider to remove.
+     * @param bodies - The set of rigid-body containing the rigid-body the collider is attached to.
+     * @param wakeUp - If `true`, the rigid-body the removed collider is attached to will be woken-up automatically.
+     */
+    remove(handle: ColliderHandle, islands: IslandManager, bodies: RigidBodySet, wakeUp: boolean): void;
+    /**
+     * Internal function, do not call directly.
+     * @param handle
+     */
+    unmap(handle: ImpulseJointHandle): void;
+    /**
+     * Gets the rigid-body with the given handle.
+     *
+     * @param handle - The handle of the rigid-body to retrieve.
+     */
+    get(handle: ColliderHandle): Collider | null;
+    /**
+     * The number of colliders on this set.
+     */
+    len(): number;
+    /**
+     * Does this set contain a collider with the given handle?
+     *
+     * @param handle - The collider handle to check.
+     */
+    contains(handle: ColliderHandle): boolean;
+    /**
+     * Applies the given closure to each collider contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    forEach(f: (collider: Collider) => void): void;
+    /**
+     * Gets all colliders in the list.
+     *
+     * @returns collider list.
+     */
+    getAll(): Collider[];
+}

node_modules/@dimforge/rapier3d-compat/geometry/contact.d.ts

@@ -0,0 +1,31 @@
+import { Vector } from "../math";
+import { RawShapeContact } from "../raw";
+/**
+ * The contact info between two shapes.
+ */
+export declare class ShapeContact {
+    /**
+     * Distance between the two contact points.
+     * If this is negative, this contact represents a penetration.
+     */
+    distance: number;
+    /**
+     * Position of the contact on the first shape.
+     */
+    point1: Vector;
+    /**
+     * Position of the contact on the second shape.
+     */
+    point2: Vector;
+    /**
+     * Contact normal, pointing towards the exterior of the first shape.
+     */
+    normal1: Vector;
+    /**
+     * Contact normal, pointing towards the exterior of the second shape.
+     * If these contact data are expressed in world-space, this normal is equal to -normal1.
+     */
+    normal2: Vector;
+    constructor(dist: number, point1: Vector, point2: Vector, normal1: Vector, normal2: Vector);
+    static fromRaw(raw: RawShapeContact): ShapeContact;
+}

node_modules/@dimforge/rapier3d-compat/geometry/feature.d.ts

@@ -0,0 +1,6 @@
+export declare enum FeatureType {
+    Vertex = 0,
+    Edge = 1,
+    Face = 2,
+    Unknown = 3
+}

node_modules/@dimforge/rapier3d-compat/geometry/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./broad_phase";
+export * from "./narrow_phase";
+export * from "./shape";
+export * from "./collider";
+export * from "./collider_set";
+export * from "./feature";
+export * from "./ray";
+export * from "./point";
+export * from "./toi";
+export * from "./interaction_groups";
+export * from "./contact";

node_modules/@dimforge/rapier3d-compat/geometry/interaction_groups.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pairwise filtering using bit masks.
+ *
+ * This filtering method is based on two 16-bit values:
+ * - The interaction groups (the 16 left-most bits of `self.0`).
+ * - The interaction mask (the 16 right-most bits of `self.0`).
+ *
+ * An interaction is allowed between two filters `a` and `b` two conditions
+ * are met simultaneously:
+ * - The interaction groups of `a` has at least one bit set to `1` in common with the interaction mask of `b`.
+ * - The interaction groups of `b` has at least one bit set to `1` in common with the interaction mask of `a`.
+ * In other words, interactions are allowed between two filter iff. the following condition is met:
+ *
+ * ```
+ * ((a >> 16) & b) != 0 && ((b >> 16) & a) != 0
+ * ```
+ */
+export declare type InteractionGroups = number;

node_modules/@dimforge/rapier3d-compat/geometry/narrow_phase.d.ts

@@ -0,0 +1,71 @@
+import { RawNarrowPhase, RawContactManifold } from "../raw";
+import { ColliderHandle } from "./collider";
+import { Vector } from "../math";
+/**
+ * The narrow-phase used for precise collision-detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `narrowPhase.free()`
+ * once you are done using it.
+ */
+export declare class NarrowPhase {
+    raw: RawNarrowPhase;
+    tempManifold: TempContactManifold;
+    /**
+     * Release the WASM memory occupied by this narrow-phase.
+     */
+    free(): void;
+    constructor(raw?: RawNarrowPhase);
+    /**
+     * 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: ColliderHandle, f: (collider2: ColliderHandle) => void): void;
+    /**
+     * Enumerates all the colliders intersecting the given colliders, assuming one of them
+     * is a sensor.
+     */
+    intersectionPairsWith(collider1: ColliderHandle, f: (collider2: ColliderHandle) => 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: ColliderHandle, collider2: ColliderHandle, f: (manifold: TempContactManifold, 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: ColliderHandle, collider2: ColliderHandle): boolean;
+}
+export declare class TempContactManifold {
+    raw: RawContactManifold;
+    free(): void;
+    constructor(raw: RawContactManifold);
+    normal(): Vector;
+    localNormal1(): Vector;
+    localNormal2(): Vector;
+    subshape1(): number;
+    subshape2(): number;
+    numContacts(): number;
+    localContactPoint1(i: number): Vector | null;
+    localContactPoint2(i: number): Vector | null;
+    contactDist(i: number): number;
+    contactFid1(i: number): number;
+    contactFid2(i: number): number;
+    contactImpulse(i: number): number;
+    contactTangentImpulseX(i: number): number;
+    contactTangentImpulseY(i: number): number;
+    numSolverContacts(): number;
+    solverContactPoint(i: number): Vector;
+    solverContactDist(i: number): number;
+    solverContactFriction(i: number): number;
+    solverContactRestitution(i: number): number;
+    solverContactTangentVelocity(i: number): Vector;
+}

node_modules/@dimforge/rapier3d-compat/geometry/point.d.ts

@@ -0,0 +1,47 @@
+import { Collider } from "./collider";
+import { Vector } from "../math";
+import { RawPointColliderProjection, RawPointProjection } from "../raw";
+import { FeatureType } from "./feature";
+import { ColliderSet } from "./collider_set";
+/**
+ * The projection of a point on a collider.
+ */
+export declare class PointProjection {
+    /**
+     * The projection of the point on the collider.
+     */
+    point: Vector;
+    /**
+     * Is the point inside of the collider?
+     */
+    isInside: boolean;
+    constructor(point: Vector, isInside: boolean);
+    static fromRaw(raw: RawPointProjection): PointProjection;
+}
+/**
+ * The projection of a point on a collider (includes the collider handle).
+ */
+export declare class PointColliderProjection {
+    /**
+     * The collider hit by the ray.
+     */
+    collider: Collider;
+    /**
+     * The projection of the point on the collider.
+     */
+    point: Vector;
+    /**
+     * Is the point inside of the collider?
+     */
+    isInside: boolean;
+    /**
+     * The type of the geometric feature the point was projected on.
+     */
+    featureType: FeatureType;
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined;
+    constructor(collider: Collider, point: Vector, isInside: boolean, featureType?: FeatureType, featureId?: number);
+    static fromRaw(colliderSet: ColliderSet, raw: RawPointColliderProjection): PointColliderProjection;
+}

node_modules/@dimforge/rapier3d-compat/geometry/ray.d.ts

@@ -0,0 +1,97 @@
+import { Vector } from "../math";
+import { RawRayColliderIntersection, RawRayColliderToi, RawRayIntersection } from "../raw";
+import { Collider } from "./collider";
+import { FeatureType } from "./feature";
+import { ColliderSet } from "./collider_set";
+/**
+ * A ray. This is a directed half-line.
+ */
+export declare class Ray {
+    /**
+     * The starting point of the ray.
+     */
+    origin: Vector;
+    /**
+     * The direction of propagation of the ray.
+     */
+    dir: Vector;
+    /**
+     * Builds a ray from its origin and direction.
+     *
+     * @param origin - The ray's starting point.
+     * @param dir - The ray's direction of propagation.
+     */
+    constructor(origin: Vector, dir: Vector);
+    pointAt(t: number): Vector;
+}
+/**
+ * The intersection between a ray and a collider.
+ */
+export declare class RayIntersection {
+    /**
+     * The time-of-impact of the ray with the collider.
+     *
+     * The hit point is obtained from the ray's origin and direction: `origin + dir * toi`.
+     */
+    toi: number;
+    /**
+     * The normal of the collider at the hit point.
+     */
+    normal: Vector;
+    /**
+     * The type of the geometric feature the point was projected on.
+     */
+    featureType: FeatureType;
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined;
+    constructor(toi: number, normal: Vector, featureType?: FeatureType, featureId?: number);
+    static fromRaw(raw: RawRayIntersection): RayIntersection;
+}
+/**
+ * The intersection between a ray and a collider (includes the collider handle).
+ */
+export declare class RayColliderIntersection {
+    /**
+     * The collider hit by the ray.
+     */
+    collider: Collider;
+    /**
+     * The time-of-impact of the ray with the collider.
+     *
+     * The hit point is obtained from the ray's origin and direction: `origin + dir * toi`.
+     */
+    toi: number;
+    /**
+     * The normal of the collider at the hit point.
+     */
+    normal: Vector;
+    /**
+     * The type of the geometric feature the point was projected on.
+     */
+    featureType: FeatureType;
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined;
+    constructor(collider: Collider, toi: number, normal: Vector, featureType?: FeatureType, featureId?: number);
+    static fromRaw(colliderSet: ColliderSet, raw: RawRayColliderIntersection): RayColliderIntersection;
+}
+/**
+ * The time of impact between a ray and a collider.
+ */
+export declare class RayColliderToi {
+    /**
+     * The handle of the collider hit by the ray.
+     */
+    collider: Collider;
+    /**
+     * The time-of-impact of the ray with the collider.
+     *
+     * The hit point is obtained from the ray's origin and direction: `origin + dir * toi`.
+     */
+    toi: number;
+    constructor(collider: Collider, toi: number);
+    static fromRaw(colliderSet: ColliderSet, raw: RawRayColliderToi): RayColliderToi;
+}

node_modules/@dimforge/rapier3d-compat/geometry/shape.d.ts

@@ -0,0 +1,489 @@
+import { Vector, Rotation } from "../math";
+import { RawColliderSet, RawShape } from "../raw";
+import { ShapeContact } from "./contact";
+import { PointProjection } from "./point";
+import { Ray, RayIntersection } from "./ray";
+import { ShapeTOI } from "./toi";
+import { ColliderHandle } from "./collider";
+export declare abstract class Shape {
+    abstract intoRaw(): RawShape;
+    /**
+     * The concrete type of this shape.
+     */
+    abstract get type(): ShapeType;
+    /**
+     * instant mode without cache
+     */
+    static fromRaw(rawSet: RawColliderSet, handle: ColliderHandle): Shape;
+    /**
+     * Computes the time of impact between two moving shapes.
+     * @param shapePos1 - The initial position of this sahpe.
+     * @param shapeRot1 - The rotation of this shape.
+     * @param shapeVel1 - The velocity of this shape.
+     * @param shape2 - The second moving shape.
+     * @param shapePos2 - The initial position of the second shape.
+     * @param shapeRot2 - The rotation of the second shape.
+     * @param shapeVel2 - The velocity of the second shape.
+     * @param maxToi - The maximum time when the impact can happen.
+     * @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 exist that penetration state.
+     * @returns If the two moving shapes collider at some point along their trajectories, this returns the
+     *  time at which the two shape collider as well as the contact information during the impact. Returns
+     *  `null`if the two shapes never collide along their paths.
+     */
+    castShape(shapePos1: Vector, shapeRot1: Rotation, shapeVel1: Vector, shape2: Shape, shapePos2: Vector, shapeRot2: Rotation, shapeVel2: Vector, maxToi: number, stopAtPenetration: boolean): ShapeTOI | null;
+    /**
+     * Tests if this shape intersects another shape.
+     *
+     * @param shapePos1 - The position of this shape.
+     * @param shapeRot1 - The rotation of this shape.
+     * @param shape2  - The second shape to test.
+     * @param shapePos2 - The position of the second shape.
+     * @param shapeRot2 - The rotation of the second shape.
+     * @returns `true` if the two shapes intersect, `false` if they don’t.
+     */
+    intersectsShape(shapePos1: Vector, shapeRot1: Rotation, shape2: Shape, shapePos2: Vector, shapeRot2: Rotation): boolean;
+    /**
+     * Computes one pair of contact points between two shapes.
+     *
+     * @param shapePos1 - The initial position of this sahpe.
+     * @param shapeRot1 - The rotation of this shape.
+     * @param shape2 - The second shape.
+     * @param shapePos2 - The initial position of the second shape.
+     * @param shapeRot2 - The rotation of the second shape.
+     * @param prediction - The prediction value, if the shapes are separated by a distance greater than this value, test will fail.
+     * @returns `null` if the shapes are separated by a distance greater than prediction, otherwise contact details. The result is given in world-space.
+     */
+    contactShape(shapePos1: Vector, shapeRot1: Rotation, shape2: Shape, shapePos2: Vector, shapeRot2: Rotation, prediction: number): ShapeContact | null;
+    containsPoint(shapePos: Vector, shapeRot: Rotation, point: Vector): boolean;
+    projectPoint(shapePos: Vector, shapeRot: Rotation, point: Vector, solid: boolean): PointProjection;
+    intersectsRay(ray: Ray, shapePos: Vector, shapeRot: Rotation, maxToi: number): boolean;
+    castRay(ray: Ray, shapePos: Vector, shapeRot: Rotation, maxToi: number, solid: boolean): number;
+    castRayAndGetNormal(ray: Ray, shapePos: Vector, shapeRot: Rotation, maxToi: number, solid: boolean): RayIntersection;
+}
+/**
+ * An enumeration representing the type of a shape.
+ */
+export declare enum ShapeType {
+    Ball = 0,
+    Cuboid = 1,
+    Capsule = 2,
+    Segment = 3,
+    Polyline = 4,
+    Triangle = 5,
+    TriMesh = 6,
+    HeightField = 7,
+    ConvexPolyhedron = 9,
+    Cylinder = 10,
+    Cone = 11,
+    RoundCuboid = 12,
+    RoundTriangle = 13,
+    RoundCylinder = 14,
+    RoundCone = 15,
+    RoundConvexPolyhedron = 16,
+    HalfSpace = 17
+}
+/**
+ * A shape that is a sphere in 3D and a circle in 2D.
+ */
+export declare class Ball extends Shape {
+    readonly type = ShapeType.Ball;
+    /**
+     * The balls radius.
+     */
+    radius: number;
+    /**
+     * Creates a new ball with the given radius.
+     * @param radius - The balls radius.
+     */
+    constructor(radius: number);
+    intoRaw(): RawShape;
+}
+export declare class HalfSpace extends Shape {
+    readonly type = ShapeType.HalfSpace;
+    /**
+     * The outward normal of the half-space.
+     */
+    normal: Vector;
+    /**
+     * Creates a new halfspace delimited by an infinite plane.
+     *
+     * @param normal - The outward normal of the plane.
+     */
+    constructor(normal: Vector);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a box in 3D and a rectangle in 2D.
+ */
+export declare class Cuboid extends Shape {
+    readonly type = ShapeType.Cuboid;
+    /**
+     * The half extent of the cuboid along each coordinate axis.
+     */
+    halfExtents: Vector;
+    /**
+     * Creates a new 3D cuboid.
+     * @param hx - The half width of the cuboid.
+     * @param hy - The half height of the cuboid.
+     * @param hz - The half depth of the cuboid.
+     */
+    constructor(hx: number, hy: number, hz: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a box in 3D and a rectangle in 2D, with round corners.
+ */
+export declare class RoundCuboid extends Shape {
+    readonly type = ShapeType.RoundCuboid;
+    /**
+     * The half extent of the cuboid along each coordinate axis.
+     */
+    halfExtents: Vector;
+    /**
+     * The radius of the cuboid's round border.
+     */
+    borderRadius: number;
+    /**
+     * Creates a new 3D cuboid.
+     * @param hx - The half width of the cuboid.
+     * @param hy - The half height of the cuboid.
+     * @param hz - The half depth of the cuboid.
+     * @param borderRadius - The radius of the borders of this cuboid. This will
+     *   effectively increase the half-extents of the cuboid by this radius.
+     */
+    constructor(hx: number, hy: number, hz: number, borderRadius: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a capsule.
+ */
+export declare class Capsule extends Shape {
+    readonly type = ShapeType.Capsule;
+    /**
+     * The radius of the capsule's basis.
+     */
+    radius: number;
+    /**
+     * The capsule's half height, along the `y` axis.
+     */
+    halfHeight: number;
+    /**
+     * Creates a new capsule with the given radius and half-height.
+     * @param halfHeight - The balls half-height along the `y` axis.
+     * @param radius - The balls radius.
+     */
+    constructor(halfHeight: number, radius: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a segment.
+ */
+export declare class Segment extends Shape {
+    readonly type = ShapeType.Segment;
+    /**
+     * The first point of the segment.
+     */
+    a: Vector;
+    /**
+     * The second point of the segment.
+     */
+    b: Vector;
+    /**
+     * Creates a new segment shape.
+     * @param a - The first point of the segment.
+     * @param b - The second point of the segment.
+     */
+    constructor(a: Vector, b: Vector);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a segment.
+ */
+export declare class Triangle extends Shape {
+    readonly type = ShapeType.Triangle;
+    /**
+     * The first point of the triangle.
+     */
+    a: Vector;
+    /**
+     * The second point of the triangle.
+     */
+    b: Vector;
+    /**
+     * The second point of the triangle.
+     */
+    c: Vector;
+    /**
+     * Creates a new triangle shape.
+     *
+     * @param a - The first point of the triangle.
+     * @param b - The second point of the triangle.
+     * @param c - The third point of the triangle.
+     */
+    constructor(a: Vector, b: Vector, c: Vector);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a triangle with round borders and a non-zero thickness.
+ */
+export declare class RoundTriangle extends Shape {
+    readonly type = ShapeType.RoundTriangle;
+    /**
+     * The first point of the triangle.
+     */
+    a: Vector;
+    /**
+     * The second point of the triangle.
+     */
+    b: Vector;
+    /**
+     * The second point of the triangle.
+     */
+    c: Vector;
+    /**
+     * The radius of the triangles's rounded edges and vertices.
+     * In 3D, this is also equal to half the thickness of the round triangle.
+     */
+    borderRadius: number;
+    /**
+     * Creates a new triangle shape with round corners.
+     *
+     * @param a - The first point of the triangle.
+     * @param b - The second point of the triangle.
+     * @param c - The third point of the triangle.
+     * @param borderRadius - The radius of the borders of this triangle. In 3D,
+     *   this is also equal to half the thickness of the triangle.
+     */
+    constructor(a: Vector, b: Vector, c: Vector, borderRadius: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a triangle mesh.
+ */
+export declare class Polyline extends Shape {
+    readonly type = ShapeType.Polyline;
+    /**
+     * The vertices of the polyline.
+     */
+    vertices: Float32Array;
+    /**
+     * The indices of the segments.
+     */
+    indices: Uint32Array;
+    /**
+     * Creates a new polyline shape.
+     *
+     * @param vertices - The coordinates of the polyline's vertices.
+     * @param indices - The indices of the polyline's segments. If this is `null` or not provided, then
+     *    the vertices are assumed to form a line strip.
+     */
+    constructor(vertices: Float32Array, indices?: Uint32Array);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a triangle mesh.
+ */
+export declare class TriMesh extends Shape {
+    readonly type = ShapeType.TriMesh;
+    /**
+     * The vertices of the triangle mesh.
+     */
+    vertices: Float32Array;
+    /**
+     * The indices of the triangles.
+     */
+    indices: Uint32Array;
+    /**
+     * Creates a new triangle mesh shape.
+     *
+     * @param vertices - The coordinates of the triangle mesh's vertices.
+     * @param indices - The indices of the triangle mesh's triangles.
+     */
+    constructor(vertices: Float32Array, indices: Uint32Array);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a convex polygon.
+ */
+export declare class ConvexPolyhedron extends Shape {
+    readonly type = ShapeType.ConvexPolyhedron;
+    /**
+     * The vertices of the convex polygon.
+     */
+    vertices: Float32Array;
+    /**
+     * The indices of the convex polygon.
+     */
+    indices?: Uint32Array | null;
+    /**
+     * Creates a new convex polygon shape.
+     *
+     * @param vertices - The coordinates of the convex polygon's vertices.
+     * @param indices - The index buffer of this convex mesh. If this is `null`
+     *   or `undefined`, the convex-hull of the input vertices will be computed
+     *   automatically. Otherwise, it will be assumed that the mesh you provide
+     *   is already convex.
+     */
+    constructor(vertices: Float32Array, indices?: Uint32Array | null);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a convex polygon.
+ */
+export declare class RoundConvexPolyhedron extends Shape {
+    readonly type = ShapeType.RoundConvexPolyhedron;
+    /**
+     * The vertices of the convex polygon.
+     */
+    vertices: Float32Array;
+    /**
+     * The indices of the convex polygon.
+     */
+    indices?: Uint32Array;
+    /**
+     * The radius of the convex polyhedron's rounded edges and vertices.
+     */
+    borderRadius: number;
+    /**
+     * Creates a new convex polygon shape.
+     *
+     * @param vertices - The coordinates of the convex polygon's vertices.
+     * @param indices - The index buffer of this convex mesh. If this is `null`
+     *   or `undefined`, the convex-hull of the input vertices will be computed
+     *   automatically. Otherwise, it will be assumed that the mesh you provide
+     *   is already convex.
+     * @param borderRadius - The radius of the borders of this convex polyhedron.
+     */
+    constructor(vertices: Float32Array, indices: Uint32Array | null | undefined, borderRadius: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a heightfield.
+ */
+export declare class Heightfield extends Shape {
+    readonly type = ShapeType.HeightField;
+    /**
+     * The number of rows in the heights matrix.
+     */
+    nrows: number;
+    /**
+     * The number of columns in the heights matrix.
+     */
+    ncols: number;
+    /**
+     * The heights of the heightfield along its local `y` axis,
+     * provided as a matrix stored in column-major order.
+     */
+    heights: Float32Array;
+    /**
+     * The dimensions of the heightfield's local `x,z` plane.
+     */
+    scale: Vector;
+    /**
+     * Creates a new heightfield shape.
+     *
+     * @param nrows − The number of rows in the heights matrix.
+     * @param ncols - The number of columns in the heights matrix.
+     * @param heights - The heights of the heightfield along its local `y` axis,
+     *                  provided as a matrix stored in column-major order.
+     * @param scale - The dimensions of the heightfield's local `x,z` plane.
+     */
+    constructor(nrows: number, ncols: number, heights: Float32Array, scale: Vector);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a 3D cylinder.
+ */
+export declare class Cylinder extends Shape {
+    readonly type = ShapeType.Cylinder;
+    /**
+     * The radius of the cylinder's basis.
+     */
+    radius: number;
+    /**
+     * The cylinder's half height, along the `y` axis.
+     */
+    halfHeight: number;
+    /**
+     * Creates a new cylinder with the given radius and half-height.
+     * @param halfHeight - The balls half-height along the `y` axis.
+     * @param radius - The balls radius.
+     */
+    constructor(halfHeight: number, radius: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a 3D cylinder with round corners.
+ */
+export declare class RoundCylinder extends Shape {
+    readonly type = ShapeType.RoundCylinder;
+    /**
+     * The radius of the cylinder's basis.
+     */
+    radius: number;
+    /**
+     * The cylinder's half height, along the `y` axis.
+     */
+    halfHeight: number;
+    /**
+     * The radius of the cylinder's rounded edges and vertices.
+     */
+    borderRadius: number;
+    /**
+     * Creates a new cylinder with the given radius and half-height.
+     * @param halfHeight - The balls half-height along the `y` axis.
+     * @param radius - The balls radius.
+     * @param borderRadius - The radius of the borders of this cylinder.
+     */
+    constructor(halfHeight: number, radius: number, borderRadius: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a 3D cone.
+ */
+export declare class Cone extends Shape {
+    readonly type = ShapeType.Cone;
+    /**
+     * The radius of the cone's basis.
+     */
+    radius: number;
+    /**
+     * The cone's half height, along the `y` axis.
+     */
+    halfHeight: number;
+    /**
+     * Creates a new cone with the given radius and half-height.
+     * @param halfHeight - The balls half-height along the `y` axis.
+     * @param radius - The balls radius.
+     */
+    constructor(halfHeight: number, radius: number);
+    intoRaw(): RawShape;
+}
+/**
+ * A shape that is a 3D cone with round corners.
+ */
+export declare class RoundCone extends Shape {
+    readonly type = ShapeType.RoundCone;
+    /**
+     * The radius of the cone's basis.
+     */
+    radius: number;
+    /**
+     * The cone's half height, along the `y` axis.
+     */
+    halfHeight: number;
+    /**
+     * The radius of the cylinder's rounded edges and vertices.
+     */
+    borderRadius: number;
+    /**
+     * Creates a new cone with the given radius and half-height.
+     * @param halfHeight - The balls half-height along the `y` axis.
+     * @param radius - The balls radius.
+     * @param borderRadius - The radius of the borders of this cone.
+     */
+    constructor(halfHeight: number, radius: number, borderRadius: number);
+    intoRaw(): RawShape;
+}

node_modules/@dimforge/rapier3d-compat/geometry/toi.d.ts

@@ -0,0 +1,46 @@
+import { Collider } from "./collider";
+import { Vector } from "../math";
+import { RawShapeTOI, RawShapeColliderTOI } from "../raw";
+import { ColliderSet } from "./collider_set";
+/**
+ * The intersection between a ray and a collider.
+ */
+export declare class ShapeTOI {
+    /**
+     * The time of impact of the two shapes.
+     */
+    toi: number;
+    /**
+     * The local-space contact point on the first shape, at
+     * the time of impact.
+     */
+    witness1: Vector;
+    /**
+     * The local-space contact point on the second shape, at
+     * the time of impact.
+     */
+    witness2: Vector;
+    /**
+     * The local-space normal on the first shape, at
+     * the time of impact.
+     */
+    normal1: Vector;
+    /**
+     * The local-space normal on the second shape, at
+     * the time of impact.
+     */
+    normal2: Vector;
+    constructor(toi: number, witness1: Vector, witness2: Vector, normal1: Vector, normal2: Vector);
+    static fromRaw(colliderSet: ColliderSet, raw: RawShapeTOI): ShapeTOI;
+}
+/**
+ * The intersection between a ray and a collider.
+ */
+export declare class ShapeColliderTOI extends ShapeTOI {
+    /**
+     * The handle of the collider hit by the ray.
+     */
+    collider: Collider;
+    constructor(collider: Collider, toi: number, witness1: Vector, witness2: Vector, normal1: Vector, normal2: Vector);
+    static fromRaw(colliderSet: ColliderSet, raw: RawShapeColliderTOI): ShapeColliderTOI;
+}