@absolutejs/rapier3d 0.0.0-stage → 0.1.0

package/dist/types/geometry/toi.d.ts

@@ -0,0 +1,59 @@
+import { Collider } from "./collider";
+import { Vector } from "../math";
+/**
+ * The result of a shape-cast between two shapes, returned by the pairwise casts
+ * `Shape.castShape` and `Collider.castShape`.
+ *
+ * The first shape is the one the cast is called on (the shape or collider `this`), and the
+ * second shape is the `shape2` argument. Each witness point and normal is expressed in the
+ * local-space of its own shape, i.e., relative to that shape's pose (it does not depend on
+ * the shape's translation along the cast).
+ */
+export declare class ShapeCastHit {
+    /**
+     * The time of impact of the two shapes.
+     */
+    time_of_impact: number;
+    /**
+     * The contact point on the first shape at the time of impact, expressed in the
+     * local-space of the first shape.
+     */
+    witness1: Vector;
+    /**
+     * The contact point on the second shape at the time of impact, expressed in the
+     * local-space of the second shape.
+     */
+    witness2: Vector;
+    /**
+     * The outward normal on the first shape at the time of impact, expressed in the
+     * local-space of the first shape.
+     */
+    normal1: Vector;
+    /**
+     * The outward normal on the second shape at the time of impact, expressed in the
+     * local-space of the second shape.
+     */
+    normal2: Vector;
+    constructor(time_of_impact: number, witness1: Vector, witness2: Vector, normal1: Vector, normal2: Vector);
+    static fromBuffer(collider: Collider, buffer: Float32Array, target?: ShapeCastHit): ShapeCastHit;
+}
+/**
+ * The result of a shape-cast that hit a collider.
+ *
+ * The frames of the witness points and normals depend on the query that returned it:
+ * - `World.castShape` (and `BroadPhase.castShape`): `witness1` and `normal1` lie on the hit
+ *   `collider` and are expressed in world-space; `witness2` and `normal2` lie on the cast
+ *   shape and are expressed in its local-space (relative to its pose, so they do not depend
+ *   on its translation along the cast).
+ * - `Collider.castCollider`: `witness1` and `normal1` lie on the collider the cast is called
+ *   on and are expressed in its local-space; `witness2` and `normal2` lie on the hit
+ *   `collider` (the `collider2` argument) and are expressed in its local-space.
+ */
+export declare class ColliderShapeCastHit extends ShapeCastHit {
+    /**
+     * The collider hit by the shape-cast.
+     */
+    collider: Collider;
+    constructor(collider: Collider, time_of_impact: number, witness1: Vector, witness2: Vector, normal1: Vector, normal2: Vector);
+    static fromBuffer(collider: Collider, buffer: Float32Array, target?: ColliderShapeCastHit): ColliderShapeCastHit;
+}

package/dist/types/init.d.ts

@@ -0,0 +1,3 @@
+import { type InitInput } from './rapier_wasm3d.js';
+/** Initialize once; concurrent callers share the same initialization. */
+export declare function init(input?: InitInput | Promise<InitInput>): Promise<void>;

package/dist/types/math.d.ts

@@ -0,0 +1,98 @@
+import { RawVector, RawRotation } from "./raw";
+import { RawSdpMatrix3 } from "./raw";
+export declare const scratchBuffer: Float32Array<ArrayBuffer>;
+export interface Vector {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * A 3D vector.
+ */
+export declare class Vector3 implements Vector {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number);
+}
+export declare class VectorOps {
+    static new(x: number, y: number, z: number): Vector;
+    static intoRaw(v: Vector): RawVector;
+    static zeros(): Vector;
+    static fromBuffer(buffer: Float32Array, target?: Vector): Vector;
+    static fromRaw(raw: RawVector): Vector;
+    static copy(out: Vector, input: Vector): void;
+}
+export interface Rotation {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+/**
+ * A quaternion.
+ */
+export declare class Quaternion implements Rotation {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x: number, y: number, z: number, w: number);
+}
+export declare class RotationOps {
+    static identity(): Rotation;
+    static fromBuffer(buffer: Float32Array, target?: Rotation): Rotation;
+    static fromRaw(raw: RawRotation): Rotation;
+    static intoRaw(rot: Rotation): RawRotation;
+    static copy(out: Rotation, input: Rotation): void;
+}
+/**
+ * A 3D symmetric-positive-definite matrix.
+ */
+export declare class SdpMatrix3 {
+    /**
+     * Row major list of the upper-triangular part of the symmetric matrix.
+     */
+    elements: Float32Array;
+    /**
+     * Matrix element at row 1, column 1.
+     */
+    get m11(): number;
+    /**
+     * Matrix element at row 1, column 2.
+     */
+    get m12(): number;
+    /**
+     * Matrix element at row 2, column 1.
+     */
+    get m21(): number;
+    /**
+     * Matrix element at row 1, column 3.
+     */
+    get m13(): number;
+    /**
+     * Matrix element at row 3, column 1.
+     */
+    get m31(): number;
+    /**
+     * Matrix element at row 2, column 2.
+     */
+    get m22(): number;
+    /**
+     * Matrix element at row 2, column 3.
+     */
+    get m23(): number;
+    /**
+     * Matrix element at row 3, column 2.
+     */
+    get m32(): number;
+    /**
+     * Matrix element at row 3, column 3.
+     */
+    get m33(): number;
+    constructor(elements: Float32Array);
+}
+export declare class SdpMatrix3Ops {
+    static fromBuffer(buffer: Float32Array, target?: SdpMatrix3): SdpMatrix3;
+    static fromRaw(raw: RawSdpMatrix3): SdpMatrix3;
+}

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

@@ -0,0 +1,40 @@
+import { RawDebugRenderPipeline } from "../raw";
+import { ImpulseJointSet, MultibodyJointSet, RigidBodySet, SoftBodySet } from "../dynamics";
+import { Collider, ColliderSet, NarrowPhase } from "../geometry";
+import { QueryFilterFlags } from "./query_pipeline";
+/**
+ * The vertex and color buffers for debug-rendering the physics scene.
+ */
+export declare class DebugRenderBuffers {
+    /**
+     * The lines to render. This is a flat array containing all the lines
+     * to render. Each line is described as two consecutive point. Each
+     * point is described as two (in 2D) or three (in 3D) consecutive
+     * floats. For example, in 2D, the array: `[1, 2, 3, 4, 5, 6, 7, 8]`
+     * describes the two segments `[[1, 2], [3, 4]]` and `[[5, 6], [7, 8]]`.
+     */
+    vertices: Float32Array;
+    /**
+     * The color buffer. There is one color per vertex, and each color
+     * has four consecutive components (in RGBA format).
+     */
+    colors: Float32Array;
+    constructor(vertices: Float32Array, colors: Float32Array);
+}
+/**
+ * A pipeline for rendering the physics scene.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `debugRenderPipeline.free()`
+ * once you are done using it (and all the rigid-bodies it created).
+ */
+export declare class DebugRenderPipeline {
+    raw: RawDebugRenderPipeline;
+    vertices: Float32Array;
+    colors: Float32Array;
+    /**
+     * Release the WASM memory occupied by this serialization pipeline.
+     */
+    free(): void;
+    constructor(raw?: RawDebugRenderPipeline);
+    render(bodies: RigidBodySet, colliders: ColliderSet, soft_bodies: SoftBodySet, impulse_joints: ImpulseJointSet, multibody_joints: MultibodyJointSet, narrow_phase: NarrowPhase, filterFlags?: QueryFilterFlags, filterPredicate?: (collider: Collider) => boolean): void;
+}

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

@@ -0,0 +1,113 @@
+import { RawContactForceEvent, RawEventQueue } from "../raw";
+import { SoftBodyTearEvent } from "../dynamics";
+import { ColliderHandle } from "../geometry";
+import { Vector } from "../math";
+/**
+ * Flags indicating what events are enabled for colliders.
+ */
+export declare enum ActiveEvents {
+    NONE = 0,
+    /**
+     * Enable collision events.
+     */
+    COLLISION_EVENTS = 1,
+    /**
+     * Enable contact force events.
+     */
+    CONTACT_FORCE_EVENTS = 2
+}
+/**
+ * Event occurring when the sum of the magnitudes of the
+ * contact forces between two colliders exceed a threshold.
+ *
+ * This object should **not** be stored anywhere. Its properties can only be
+ * read from within the closure given to `EventHandler.drainContactForceEvents`.
+ */
+export declare class TempContactForceEvent {
+    raw: RawContactForceEvent;
+    free(): void;
+    /**
+     * The first collider involved in the contact.
+     */
+    collider1(): ColliderHandle;
+    /**
+     * The second collider involved in the contact.
+     */
+    collider2(): ColliderHandle;
+    /**
+     * The sum of all the forces between the two colliders.
+     */
+    totalForce(target?: Vector): Vector;
+    /**
+     * The sum of the magnitudes of each force between the two colliders.
+     *
+     * Note that this is **not** the same as the magnitude of `self.total_force`.
+     * Here we are summing the magnitude of all the forces, instead of taking
+     * the magnitude of their sum.
+     */
+    totalForceMagnitude(): number;
+    /**
+     * The world-space (unit) direction of the force with strongest magnitude.
+     */
+    maxForceDirection(target?: Vector): Vector;
+    /**
+     * The magnitude of the largest force at a contact point of this contact pair.
+     */
+    maxForceMagnitude(): number;
+}
+/**
+ * A structure responsible for collecting events generated
+ * by the physics engine.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `eventQueue.free()`
+ * once you are done using it.
+ */
+export declare class EventQueue {
+    raw: RawEventQueue;
+    /**
+     * Creates a new event collector.
+     *
+     * @param autoDrain -setting this to `true` is strongly recommended. If true, the collector will
+     * be automatically drained before each `world.step(collector)`. If false, the collector will
+     * keep all events in memory unless it is manually drained/cleared; this may lead to unbounded use of
+     * RAM if no drain is performed.
+     */
+    constructor(autoDrain: boolean, raw?: RawEventQueue);
+    /**
+     * Release the WASM memory occupied by this event-queue.
+     */
+    free(): void;
+    /**
+     * Applies the given javascript closure on each collision event of this collector, then clear
+     * the internal collision event buffer.
+     *
+     * @param f - JavaScript closure applied to each collision event. The
+     * closure must take three arguments: two integers representing the handles of the colliders
+     * involved in the collision, and a boolean indicating if the collision started (true) or stopped
+     * (false).
+     */
+    drainCollisionEvents(f: (handle1: ColliderHandle, handle2: ColliderHandle, started: boolean) => void): void;
+    /**
+     * Applies the given javascript closure on each contact force event of this collector, then clear
+     * the internal collision event buffer.
+     *
+     * @param f - JavaScript closure applied to each collision event. The
+     *            closure must take one `TempContactForceEvent` argument.
+     */
+    drainContactForceEvents(f: (event: TempContactForceEvent) => void): void;
+    /**
+     * Applies the given javascript closure on each soft-body tear event of this collector,
+     * then clears the internal tear event buffer.
+     *
+     * The pieces a tear split off are only wrapped once `World.mapNewSoftBodies` (called by
+     * `World.step` after draining) ran; the event itself is only valid inside the closure.
+     *
+     * @param f - JavaScript closure applied to each tear event. The closure must take one
+     *            `SoftBodyTearEvent` argument.
+     */
+    drainSoftBodyTearEvents(f: (event: SoftBodyTearEvent) => void): void;
+    /**
+     * Removes all events contained by this collector
+     */
+    clear(): void;
+}

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

@@ -0,0 +1,7 @@
+export * from "./world";
+export * from "./physics_pipeline";
+export * from "./serialization_pipeline";
+export * from "./event_queue";
+export * from "./physics_hooks";
+export * from "./debug_render_pipeline";
+export * from "./query_pipeline";

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

@@ -0,0 +1,39 @@
+import { RigidBodyHandle } from "../dynamics";
+import { ColliderHandle } from "../geometry";
+export declare enum ActiveHooks {
+    NONE = 0,
+    FILTER_CONTACT_PAIRS = 1,
+    FILTER_INTERSECTION_PAIRS = 2
+}
+export declare enum SolverFlags {
+    EMPTY = 0,
+    COMPUTE_IMPULSE = 1
+}
+export interface PhysicsHooks {
+    /**
+     * Function that determines if contacts computation should happen between two colliders, and how the
+     * constraints solver should behave for these contacts.
+     *
+     * This will only be executed and taken into account if at least one of the involved colliders contains the
+     * `ActiveHooks.FILTER_CONTACT_PAIR` flag in its active hooks.
+     *
+     * @param collider1 − Handle of the first collider involved in the potential contact.
+     * @param collider2 − Handle of the second collider involved in the potential contact.
+     * @param body1 − Handle of the first body involved in the potential contact.
+     * @param body2 − Handle of the second body involved in the potential contact.
+     */
+    filterContactPair(collider1: ColliderHandle, collider2: ColliderHandle, body1: RigidBodyHandle, body2: RigidBodyHandle): SolverFlags | null;
+    /**
+     * Function that determines if intersection computation should happen between two colliders (where at least
+     * one is a sensor).
+     *
+     * This will only be executed and taken into account if `one of the involved colliders contains the
+     * `ActiveHooks.FILTER_INTERSECTION_PAIR` flag in its active hooks.
+     *
+     * @param collider1 − Handle of the first collider involved in the potential contact.
+     * @param collider2 − Handle of the second collider involved in the potential contact.
+     * @param body1 − Handle of the first body involved in the potential contact.
+     * @param body2 − Handle of the second body involved in the potential contact.
+     */
+    filterIntersectionPair(collider1: ColliderHandle, collider2: ColliderHandle, body1: RigidBodyHandle, body2: RigidBodyHandle): boolean;
+}

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

@@ -0,0 +1,12 @@
+import { RawPhysicsPipeline } from "../raw";
+import { Vector } from "../math";
+import { IntegrationParameters, ImpulseJointSet, MultibodyJointSet, RigidBodySet, CCDSolver, IslandManager, SoftBodySet } from "../dynamics";
+import { BroadPhase, ColliderSet, NarrowPhase } from "../geometry";
+import { EventQueue } from "./event_queue";
+import { PhysicsHooks } from "./physics_hooks";
+export declare class PhysicsPipeline {
+    raw: RawPhysicsPipeline;
+    free(): void;
+    constructor(raw?: RawPhysicsPipeline);
+    step(gravity: Vector, integrationParameters: IntegrationParameters, islands: IslandManager, broadPhase: BroadPhase, narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, softBodies: SoftBodySet, impulseJoints: ImpulseJointSet, multibodyJoints: MultibodyJointSet, ccdSolver: CCDSolver, eventQueue?: EventQueue, hooks?: PhysicsHooks): void;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Flags for excluding whole sets of colliders from a scene query.
+ */
+export declare enum QueryFilterFlags {
+    /**
+     * Exclude from the query any collider attached to a fixed rigid-body and colliders with no rigid-body attached.
+     */
+    EXCLUDE_FIXED = 1,
+    /**
+     * Exclude from the query any collider attached to a dynamic rigid-body.
+     */
+    EXCLUDE_KINEMATIC = 2,
+    /**
+     * Exclude from the query any collider attached to a kinematic rigid-body.
+     */
+    EXCLUDE_DYNAMIC = 4,
+    /**
+     * Exclude from the query any collider that is a sensor.
+     */
+    EXCLUDE_SENSORS = 8,
+    /**
+     * Exclude from the query any collider that is not a sensor.
+     */
+    EXCLUDE_SOLIDS = 16,
+    /**
+     * Excludes all colliders not attached to a dynamic rigid-body.
+     */
+    ONLY_DYNAMIC = 3,
+    /**
+     * Excludes all colliders not attached to a kinematic rigid-body.
+     */
+    ONLY_KINEMATIC = 5,
+    /**
+     * Exclude all colliders attached to a non-fixed rigid-body
+     * (this will not exclude colliders not attached to any rigid-body).
+     */
+    ONLY_FIXED = 6
+}

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

@@ -0,0 +1,37 @@
+import { RawSerializationPipeline } from "../raw";
+import { Vector } from "../math";
+import { IntegrationParameters, IslandManager, ImpulseJointSet, MultibodyJointSet, RigidBodySet, SoftBodySet } from "../dynamics";
+import { BroadPhase, ColliderSet, NarrowPhase } from "../geometry";
+import { World } from "./world";
+/**
+ * A pipeline for serializing the physics scene.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `serializationPipeline.free()`
+ * once you are done using it (and all the rigid-bodies it created).
+ */
+export declare class SerializationPipeline {
+    raw: RawSerializationPipeline;
+    /**
+     * Release the WASM memory occupied by this serialization pipeline.
+     */
+    free(): void;
+    constructor(raw?: RawSerializationPipeline);
+    /**
+     * Serialize a complete physics state into a single byte array.
+     * @param gravity - The current gravity affecting the simulation.
+     * @param integrationParameters - The integration parameters of the simulation.
+     * @param broadPhase - The broad-phase of the simulation.
+     * @param narrowPhase - The narrow-phase of the simulation.
+     * @param bodies - The rigid-bodies taking part into the simulation.
+     * @param colliders - The colliders taking part into the simulation.
+     * @param impulseJoints - The impulse joints taking part into the simulation.
+     * @param multibodyJoints - The multibody joints taking part into the simulation.
+     */
+    serializeAll(gravity: Vector, integrationParameters: IntegrationParameters, islands: IslandManager, broadPhase: BroadPhase, narrowPhase: NarrowPhase, bodies: RigidBodySet, colliders: ColliderSet, softBodies: SoftBodySet, impulseJoints: ImpulseJointSet, multibodyJoints: MultibodyJointSet): Uint8Array;
+    /**
+     * Deserialize the complete physics state from a single byte array.
+     *
+     * @param data - The byte array to deserialize.
+     */
+    deserializeAll(data: Uint8Array): World;
+}