feat(rapier2d): 新增Rapier2D WASM绑定包

packages/rapier2d/module.json

@@ -0,0 +1,32 @@
+{
+  "id": "rapier2d",
+  "name": "@esengine/rapier2d",
+  "displayName": "Rapier2D",
+  "description": "Rapier2D physics engine WASM bindings | Rapier2D 物理引擎 WASM 绑定",
+  "version": "0.14.0",
+  "category": "Physics",
+  "icon": "Atom",
+  "tags": [
+    "physics",
+    "wasm",
+    "rapier"
+  ],
+  "isCore": false,
+  "defaultEnabled": false,
+  "isEngineModule": true,
+  "canContainContent": false,
+  "platforms": [
+    "web",
+    "desktop"
+  ],
+  "dependencies": [],
+  "exports": {
+    "other": ["RAPIER"]
+  },
+  "requiresWasm": true,
+  "wasmPaths": [
+    "pkg/rapier_wasm2d_bg.wasm"
+  ],
+  "outputPath": "dist/index.js",
+  "isExternalDependency": true
+}

packages/rapier2d/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@esengine/rapier2d",
+  "version": "0.14.0",
+  "description": "Rapier2D physics engine with dynamic WASM loading support",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./pkg/*": "./pkg/*"
+  },
+  "files": [
+    "dist",
+    "pkg/*.wasm"
+  ],
+  "scripts": {
+    "gen:src": "node scripts/gen-src.mjs",
+    "build": "pnpm gen:src && tsup",
+    "clean": "rimraf dist src"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "rimraf": "^5.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}

packages/rapier2d/scripts/gen-src.mjs

@@ -0,0 +1,125 @@
+/**
+ * Generate 2D-specific source code from rapier.js source.
+ * 从 rapier.js 源码生成 2D 专用代码。
+ *
+ * This script:
+ * 1. Copies TypeScript source from rapier.js/src.ts
+ * 2. Removes #if DIM3 ... #endif blocks (keeps only 2D code)
+ * 3. Overwrites raw.ts and init.ts with 2D-specific versions
+ */
+
+import { readFileSync, writeFileSync, readdirSync, mkdirSync, cpSync, existsSync, renameSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, '..');
+const rapierRoot = join(packageRoot, '..', '..', 'thirdparty', 'rapier.js');
+const srcTsDir = join(rapierRoot, 'src.ts');
+const src2dDir = join(rapierRoot, 'rapier-compat', 'src2d');
+const outputDir = join(packageRoot, 'src');
+
+// Check if rapier.js exists
+if (!existsSync(srcTsDir)) {
+    console.error(`Error: rapier.js source not found at ${rapierRoot}`);
+    console.error('Please clone https://github.com/esengine/rapier.js.git to thirdparty/rapier.js');
+    process.exit(1);
+}
+
+/**
+ * Remove #if DIM3 ... #endif blocks from source code
+ */
+function removeDim3Blocks(content) {
+    // Remove lines between #if DIM3 and #endif (inclusive)
+    const lines = content.split('\n');
+    const result = [];
+    let skipDepth = 0;
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+
+        if (trimmed.startsWith('//#if DIM3') || trimmed.startsWith('// #if DIM3')) {
+            skipDepth++;
+            continue;
+        }
+
+        if (skipDepth > 0 && (trimmed.startsWith('//#endif') || trimmed.startsWith('// #endif'))) {
+            skipDepth--;
+            continue;
+        }
+
+        if (skipDepth === 0) {
+            // Also remove #if DIM2 and its #endif (but keep the content)
+            if (trimmed.startsWith('//#if DIM2') || trimmed.startsWith('// #if DIM2')) {
+                continue;
+            }
+            if (trimmed.startsWith('//#endif') || trimmed.startsWith('// #endif')) {
+                continue;
+            }
+            result.push(line);
+        }
+    }
+
+    return result.join('\n');
+}
+
+/**
+ * Process a single TypeScript file
+ */
+function processFile(srcPath, destPath) {
+    const content = readFileSync(srcPath, 'utf-8');
+    const processed = removeDim3Blocks(content);
+    writeFileSync(destPath, processed);
+}
+
+/**
+ * Recursively copy and process directory
+ */
+function processDirectory(srcDir, destDir) {
+    mkdirSync(destDir, { recursive: true });
+
+    const entries = readdirSync(srcDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const srcPath = join(srcDir, entry.name);
+        const destPath = join(destDir, entry.name);
+
+        if (entry.isDirectory()) {
+            processDirectory(srcPath, destPath);
+        } else if (entry.name.endsWith('.ts')) {
+            processFile(srcPath, destPath);
+            console.log(`Processed: ${entry.name}`);
+        }
+    }
+}
+
+// Main
+console.log('Generating 2D source code...');
+console.log(`Source: ${srcTsDir}`);
+console.log(`Output: ${outputDir}`);
+
+// Step 1: Copy and process src.ts directory
+processDirectory(srcTsDir, outputDir);
+
+// Step 2: Overwrite with 2D-specific files (raw.ts, init.ts)
+if (existsSync(src2dDir)) {
+    const entries = readdirSync(src2dDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.ts')) {
+            const srcPath = join(src2dDir, entry.name);
+            const destPath = join(outputDir, entry.name);
+            cpSync(srcPath, destPath);
+            console.log(`Overwrote: ${entry.name} (2D-specific)`);
+        }
+    }
+}
+
+// Step 3: Rename rapier.ts to index.ts
+const rapierTs = join(outputDir, 'rapier.ts');
+const indexTs = join(outputDir, 'index.ts');
+if (existsSync(rapierTs)) {
+    renameSync(rapierTs, indexTs);
+    console.log('Renamed: rapier.ts -> index.ts');
+}
+
+console.log('Done!');

packages/rapier2d/src/coarena.ts

@@ -0,0 +1,70 @@
+export class Coarena<T> {
+    fconv: Float64Array;
+    uconv: Uint32Array;
+    data: Array<T>;
+    size: number;
+
+    public constructor() {
+        this.fconv = new Float64Array(1);
+        this.uconv = new Uint32Array(this.fconv.buffer);
+        this.data = new Array<T>();
+        this.size = 0;
+    }
+
+    public set(handle: number, data: T) {
+        let i = this.index(handle);
+        while (this.data.length <= i) {
+            this.data.push(null);
+        }
+
+        if (this.data[i] == null) this.size += 1;
+        this.data[i] = data;
+    }
+
+    public len(): number {
+        return this.size;
+    }
+
+    public delete(handle: number) {
+        let i = this.index(handle);
+        if (i < this.data.length) {
+            if (this.data[i] != null) this.size -= 1;
+            this.data[i] = null;
+        }
+    }
+
+    public clear() {
+        this.data = new Array<T>();
+    }
+
+    public get(handle: number): T | null {
+        let i = this.index(handle);
+        if (i < this.data.length) {
+            return this.data[i];
+        } else {
+            return null;
+        }
+    }
+
+    public forEach(f: (elt: T) => void) {
+        for (const elt of this.data) {
+            if (elt != null) f(elt);
+        }
+    }
+
+    public getAll(): Array<T> {
+        return this.data.filter((elt) => elt != null);
+    }
+
+    private index(handle: number): number {
+        /// Extracts the index part of a handle (the lower 32 bits).
+        /// This is done by first injecting the handle into an Float64Array
+        /// which is itself injected into an Uint32Array (at construction time).
+        /// The 0-th value of the Uint32Array will become the `number` integer
+        /// representation of the lower 32 bits.
+        /// Also `this.uconv[1]` then contains the generation number as a `number`,
+        /// which we don’t really need.
+        this.fconv[0] = handle;
+        return this.uconv[0];
+    }
+}

packages/rapier2d/src/control/character_controller.ts

@@ -0,0 +1,386 @@
+import {RawKinematicCharacterController, RawCharacterCollision} from "../raw";
+import {Rotation, Vector, VectorOps} from "../math";
+import {
+    BroadPhase,
+    Collider,
+    ColliderSet,
+    InteractionGroups,
+    NarrowPhase,
+    Shape,
+} from "../geometry";
+import {QueryFilterFlags, World} from "../pipeline";
+import {IntegrationParameters, RigidBody, RigidBodySet} from "../dynamics";
+
+/**
+ * A collision between the character and an obstacle hit on its path.
+ */
+export class CharacterCollision {
+    /** The collider involved in the collision. Null if the collider no longer exists in the physics world. */
+    public collider: Collider | null;
+    /** The translation delta applied to the character before this collision took place. */
+    public translationDeltaApplied: Vector;
+    /** The translation delta the character would move after this collision if there is no other obstacles. */
+    public translationDeltaRemaining: Vector;
+    /** The time-of-impact between the character and the obstacles. */
+    public toi: number;
+    /** The world-space contact point on the collider when the collision happens. */
+    public witness1: Vector;
+    /** The local-space contact point on the character when the collision happens. */
+    public witness2: Vector;
+    /** The world-space outward contact normal on the collider when the collision happens. */
+    public normal1: Vector;
+    /** The local-space outward contact normal on the character when the collision happens. */
+    public normal2: Vector;
+}
+
+/**
+ * A character controller for controlling kinematic bodies and parentless colliders by hitting
+ * and sliding against obstacles.
+ */
+export class KinematicCharacterController {
+    private raw: RawKinematicCharacterController;
+    private rawCharacterCollision: RawCharacterCollision;
+
+    private params: IntegrationParameters;
+    private broadPhase: BroadPhase;
+    private narrowPhase: NarrowPhase;
+    private bodies: RigidBodySet;
+    private colliders: ColliderSet;
+    private _applyImpulsesToDynamicBodies: boolean;
+    private _characterMass: number | null;
+
+    constructor(
+        offset: number,
+        params: IntegrationParameters,
+        broadPhase: BroadPhase,
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+    ) {
+        this.params = params;
+        this.bodies = bodies;
+        this.colliders = colliders;
+        this.broadPhase = broadPhase;
+        this.narrowPhase = narrowPhase;
+        this.raw = new RawKinematicCharacterController(offset);
+        this.rawCharacterCollision = new RawCharacterCollision();
+        this._applyImpulsesToDynamicBodies = false;
+        this._characterMass = null;
+    }
+
+    /** @internal */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+            this.rawCharacterCollision.free();
+        }
+
+        this.raw = undefined;
+        this.rawCharacterCollision = undefined;
+    }
+
+    /**
+     * The direction that goes "up". Used to determine where the floor is, and the floor’s angle.
+     */
+    public up(): Vector {
+        return this.raw.up();
+    }
+
+    /**
+     * Sets the direction that goes "up". Used to determine where the floor is, and the floor’s angle.
+     */
+    public setUp(vector: Vector) {
+        let rawVect = VectorOps.intoRaw(vector);
+        return this.raw.setUp(rawVect);
+        rawVect.free();
+    }
+
+    public applyImpulsesToDynamicBodies(): boolean {
+        return this._applyImpulsesToDynamicBodies;
+    }
+
+    public setApplyImpulsesToDynamicBodies(enabled: boolean) {
+        this._applyImpulsesToDynamicBodies = enabled;
+    }
+
+    /**
+     * Returns the custom value of the character mass, if it was set by `this.setCharacterMass`.
+     */
+    public characterMass(): number | null {
+        return this._characterMass;
+    }
+
+    /**
+     * Set the mass of the character to be used for impulse resolution if `self.applyImpulsesToDynamicBodies`
+     * is set to `true`.
+     *
+     * If no character mass is set explicitly (or if it is set to `null`) it is automatically assumed to be equal
+     * to the mass of the rigid-body the character collider is attached to; or equal to 0 if the character collider
+     * isn’t attached to any rigid-body.
+     *
+     * @param mass - The mass to set.
+     */
+    public setCharacterMass(mass: number | null) {
+        this._characterMass = mass;
+    }
+
+    /**
+     * A small gap to preserve between the character and its surroundings.
+     *
+     * This value should not be too large to avoid visual artifacts, but shouldn’t be too small
+     * (must not be zero) to improve numerical stability of the character controller.
+     */
+    public offset(): number {
+        return this.raw.offset();
+    }
+
+    /**
+     * Sets a small gap to preserve between the character and its surroundings.
+     *
+     * This value should not be too large to avoid visual artifacts, but shouldn’t be too small
+     * (must not be zero) to improve numerical stability of the character controller.
+     */
+    public setOffset(value: number) {
+        this.raw.setOffset(value);
+    }
+
+    /// Increase this number if your character appears to get stuck when sliding against surfaces.
+    ///
+    /// This is a small distance applied to the movement toward the contact normals of shapes hit
+    /// by the character controller. This helps shape-casting not getting stuck in an always-penetrating
+    /// state during the sliding calculation.
+    ///
+    /// This value should remain fairly small since it can introduce artificial "bumps" when sliding
+    /// along a flat surface.
+    public normalNudgeFactor(): number {
+        return this.raw.normalNudgeFactor();
+    }
+
+    /// Increase this number if your character appears to get stuck when sliding against surfaces.
+    ///
+    /// This is a small distance applied to the movement toward the contact normals of shapes hit
+    /// by the character controller. This helps shape-casting not getting stuck in an always-penetrating
+    /// state during the sliding calculation.
+    ///
+    /// This value should remain fairly small since it can introduce artificial "bumps" when sliding
+    /// along a flat surface.
+    public setNormalNudgeFactor(value: number) {
+        this.raw.setNormalNudgeFactor(value);
+    }
+
+    /**
+     * Is sliding against obstacles enabled?
+     */
+    public slideEnabled(): boolean {
+        return this.raw.slideEnabled();
+    }
+
+    /**
+     * Enable or disable sliding against obstacles.
+     */
+    public setSlideEnabled(enabled: boolean) {
+        this.raw.setSlideEnabled(enabled);
+    }
+
+    /**
+     * The maximum step height a character can automatically step over.
+     */
+    public autostepMaxHeight(): number | null {
+        return this.raw.autostepMaxHeight();
+    }
+
+    /**
+     * The minimum width of free space that must be available after stepping on a stair.
+     */
+    public autostepMinWidth(): number | null {
+        return this.raw.autostepMinWidth();
+    }
+
+    /**
+     * Can the character automatically step over dynamic bodies too?
+     */
+    public autostepIncludesDynamicBodies(): boolean | null {
+        return this.raw.autostepIncludesDynamicBodies();
+    }
+
+    /**
+     * Is automatically stepping over small objects enabled?
+     */
+    public autostepEnabled(): boolean {
+        return this.raw.autostepEnabled();
+    }
+
+    /**
+     * Enabled automatically stepping over small objects.
+     *
+     * @param maxHeight - The maximum step height a character can automatically step over.
+     * @param minWidth - The minimum width of free space that must be available after stepping on a stair.
+     * @param includeDynamicBodies - Can the character automatically step over dynamic bodies too?
+     */
+    public enableAutostep(
+        maxHeight: number,
+        minWidth: number,
+        includeDynamicBodies: boolean,
+    ) {
+        this.raw.enableAutostep(maxHeight, minWidth, includeDynamicBodies);
+    }
+
+    /**
+     * Disable automatically stepping over small objects.
+     */
+    public disableAutostep() {
+        return this.raw.disableAutostep();
+    }
+
+    /**
+     * The maximum angle (radians) between the floor’s normal and the `up` vector that the
+     * character is able to climb.
+     */
+    public maxSlopeClimbAngle(): number {
+        return this.raw.maxSlopeClimbAngle();
+    }
+
+    /**
+     * Sets the maximum angle (radians) between the floor’s normal and the `up` vector that the
+     * character is able to climb.
+     */
+    public setMaxSlopeClimbAngle(angle: number) {
+        this.raw.setMaxSlopeClimbAngle(angle);
+    }
+
+    /**
+     * The minimum angle (radians) between the floor’s normal and the `up` vector before the
+     * character starts to slide down automatically.
+     */
+    public minSlopeSlideAngle(): number {
+        return this.raw.minSlopeSlideAngle();
+    }
+
+    /**
+     * Sets the minimum angle (radians) between the floor’s normal and the `up` vector before the
+     * character starts to slide down automatically.
+     */
+    public setMinSlopeSlideAngle(angle: number) {
+        this.raw.setMinSlopeSlideAngle(angle);
+    }
+
+    /**
+     * If snap-to-ground is enabled, should the character be automatically snapped to the ground if
+     * the distance between the ground and its feet are smaller than the specified threshold?
+     */
+    public snapToGroundDistance(): number | null {
+        return this.raw.snapToGroundDistance();
+    }
+
+    /**
+     * Enables automatically snapping the character to the ground if the distance between
+     * the ground and its feet are smaller than the specified threshold.
+     */
+    public enableSnapToGround(distance: number) {
+        this.raw.enableSnapToGround(distance);
+    }
+
+    /**
+     * Disables automatically snapping the character to the ground.
+     */
+    public disableSnapToGround() {
+        this.raw.disableSnapToGround();
+    }
+
+    /**
+     * Is automatically snapping the character to the ground enabled?
+     */
+    public snapToGroundEnabled(): boolean {
+        return this.raw.snapToGroundEnabled();
+    }
+
+    /**
+     * Computes the movement the given collider is able to execute after hitting and sliding on obstacles.
+     *
+     * @param collider - The collider to move.
+     * @param desiredTranslationDelta - The desired collider movement.
+     * @param filterFlags - Flags for excluding whole subsets of colliders from the obstacles taken into account.
+     * @param filterGroups - Groups for excluding colliders with incompatible collision groups from the obstacles
+     *                       taken into account.
+     * @param filterPredicate - Any collider for which this closure returns `false` will be excluded from the
+     *                          obstacles taken into account.
+     */
+    public computeColliderMovement(
+        collider: Collider,
+        desiredTranslationDelta: Vector,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterPredicate?: (collider: Collider) => boolean,
+    ) {
+        let rawTranslationDelta = VectorOps.intoRaw(desiredTranslationDelta);
+        this.raw.computeColliderMovement(
+            this.params.dt,
+            this.broadPhase.raw,
+            this.narrowPhase.raw,
+            this.bodies.raw,
+            this.colliders.raw,
+            collider.handle,
+            rawTranslationDelta,
+            this._applyImpulsesToDynamicBodies,
+            this._characterMass,
+            filterFlags,
+            filterGroups,
+            this.colliders.castClosure(filterPredicate),
+        );
+        rawTranslationDelta.free();
+    }
+
+    /**
+     * The movement computed by the last call to `this.computeColliderMovement`.
+     */
+    public computedMovement(): Vector {
+        return VectorOps.fromRaw(this.raw.computedMovement());
+    }
+
+    /**
+     * The result of ground detection computed by the last call to `this.computeColliderMovement`.
+     */
+    public computedGrounded(): boolean {
+        return this.raw.computedGrounded();
+    }
+
+    /**
+     * The number of collisions against obstacles detected along the path of the last call
+     * to `this.computeColliderMovement`.
+     */
+    public numComputedCollisions(): number {
+        return this.raw.numComputedCollisions();
+    }
+
+    /**
+     * Returns the collision against one of the obstacles detected along the path of the last
+     * call to `this.computeColliderMovement`.
+     *
+     * @param i - The i-th collision will be returned.
+     * @param out - If this argument is set, it will be filled with the collision information.
+     */
+    public computedCollision(
+        i: number,
+        out?: CharacterCollision,
+    ): CharacterCollision | null {
+        if (!this.raw.computedCollision(i, this.rawCharacterCollision)) {
+            return null;
+        } else {
+            let c = this.rawCharacterCollision;
+            out = out ?? new CharacterCollision();
+            out.translationDeltaApplied = VectorOps.fromRaw(
+                c.translationDeltaApplied(),
+            );
+            out.translationDeltaRemaining = VectorOps.fromRaw(
+                c.translationDeltaRemaining(),
+            );
+            out.toi = c.toi();
+            out.witness1 = VectorOps.fromRaw(c.worldWitness1());
+            out.witness2 = VectorOps.fromRaw(c.worldWitness2());
+            out.normal1 = VectorOps.fromRaw(c.worldNormal1());
+            out.normal2 = VectorOps.fromRaw(c.worldNormal2());
+            out.collider = this.colliders.get(c.handle());
+            return out;
+        }
+    }
+}

packages/rapier2d/src/control/index.ts

@@ -0,0 +1,3 @@
+export * from "./character_controller";
+export * from "./pid_controller";
+

packages/rapier2d/src/control/pid_controller.ts

@@ -0,0 +1,153 @@
+import {RawPidController} from "../raw";
+import {Rotation, RotationOps, Vector, VectorOps} from "../math";
+import {Collider, ColliderSet, InteractionGroups, Shape} from "../geometry";
+import {QueryFilterFlags, World} from "../pipeline";
+import {IntegrationParameters, RigidBody, RigidBodySet} from "../dynamics";
+
+// TODO: unify with the JointAxesMask
+/**
+ * An enum representing the possible joint axes controlled by a PidController.
+ * They can be ORed together, like:
+ * PidAxesMask.LinX || PidAxesMask.LinY
+ * to get a pid controller that only constraints the translational X and Y axes.
+ *
+ * Possible axes are:
+ *
+ * - `X`: X translation axis
+ * - `Y`: Y translation axis
+ * - `Z`: Z translation axis
+ * - `AngX`: X angular rotation axis (3D only)
+ * - `AngY`: Y angular rotation axis (3D only)
+ * - `AngZ`: Z angular rotation axis
+ */
+export enum PidAxesMask {
+    None = 0,
+    LinX = 1 << 0,
+    LinY = 1 << 1,
+    LinZ = 1 << 2,
+    AngZ = 1 << 5,
+    AllLin = PidAxesMask.LinX | PidAxesMask.LinY,
+    AllAng = PidAxesMask.AngZ,
+    All = PidAxesMask.AllLin | PidAxesMask.AllAng,
+}
+
+/**
+ * A controller for controlling dynamic bodies using the
+ * Proportional-Integral-Derivative correction model.
+ */
+export class PidController {
+    private raw: RawPidController;
+
+    private params: IntegrationParameters;
+    private bodies: RigidBodySet;
+
+    constructor(
+        params: IntegrationParameters,
+        bodies: RigidBodySet,
+        kp: number,
+        ki: number,
+        kd: number,
+        axes: PidAxesMask,
+    ) {
+        this.params = params;
+        this.bodies = bodies;
+        this.raw = new RawPidController(kp, ki, kd, axes);
+    }
+
+    /** @internal */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+
+        this.raw = undefined;
+    }
+
+    public setKp(kp: number, axes: PidAxesMask) {
+        this.raw.set_kp(kp, axes);
+    }
+
+    public setKi(ki: number, axes: PidAxesMask) {
+        this.raw.set_kp(ki, axes);
+    }
+
+    public setKd(kd: number, axes: PidAxesMask) {
+        this.raw.set_kp(kd, axes);
+    }
+
+    public setAxes(axes: PidAxesMask) {
+        this.raw.set_axes_mask(axes);
+    }
+
+    public resetIntegrals() {
+        this.raw.reset_integrals();
+    }
+
+    public applyLinearCorrection(
+        body: RigidBody,
+        targetPosition: Vector,
+        targetLinvel: Vector,
+    ) {
+        let rawPos = VectorOps.intoRaw(targetPosition);
+        let rawVel = VectorOps.intoRaw(targetLinvel);
+        this.raw.apply_linear_correction(
+            this.params.dt,
+            this.bodies.raw,
+            body.handle,
+            rawPos,
+            rawVel,
+        );
+        rawPos.free();
+        rawVel.free();
+    }
+
+    public applyAngularCorrection(
+        body: RigidBody,
+        targetRotation: number,
+        targetAngVel: number,
+    ) {
+        this.raw.apply_angular_correction(
+            this.params.dt,
+            this.bodies.raw,
+            body.handle,
+            targetRotation,
+            targetAngVel,
+        );
+    }
+
+
+    public linearCorrection(
+        body: RigidBody,
+        targetPosition: Vector,
+        targetLinvel: Vector,
+    ): Vector {
+        let rawPos = VectorOps.intoRaw(targetPosition);
+        let rawVel = VectorOps.intoRaw(targetLinvel);
+        let correction = this.raw.linear_correction(
+            this.params.dt,
+            this.bodies.raw,
+            body.handle,
+            rawPos,
+            rawVel,
+        );
+        rawPos.free();
+        rawVel.free();
+
+        return VectorOps.fromRaw(correction);
+    }
+
+    public angularCorrection(
+        body: RigidBody,
+        targetRotation: number,
+        targetAngVel: number,
+    ): number {
+        return this.raw.angular_correction(
+            this.params.dt,
+            this.bodies.raw,
+            body.handle,
+            targetRotation,
+            targetAngVel,
+        );
+    }
+
+}

packages/rapier2d/src/control/ray_cast_vehicle_controller.ts

@@ -0,0 +1,481 @@
+import {RawDynamicRayCastVehicleController} from "../raw";
+import {Vector, VectorOps} from "../math";
+import {
+    BroadPhase,
+    Collider,
+    ColliderSet,
+    InteractionGroups,
+    NarrowPhase,
+} from "../geometry";
+import {QueryFilterFlags} from "../pipeline";
+import {RigidBody, RigidBodyHandle, RigidBodySet} from "../dynamics";
+
+/**
+ * A character controller to simulate vehicles using ray-casting for the wheels.
+ */
+export class DynamicRayCastVehicleController {
+    private raw: RawDynamicRayCastVehicleController;
+    private broadPhase: BroadPhase;
+    private narrowPhase: NarrowPhase;
+    private bodies: RigidBodySet;
+    private colliders: ColliderSet;
+    private _chassis: RigidBody;
+
+    constructor(
+        chassis: RigidBody,
+        broadPhase: BroadPhase,
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+    ) {
+        this.raw = new RawDynamicRayCastVehicleController(chassis.handle);
+        this.broadPhase = broadPhase;
+        this.narrowPhase = narrowPhase;
+        this.bodies = bodies;
+        this.colliders = colliders;
+        this._chassis = chassis;
+    }
+
+    /** @internal */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+
+        this.raw = undefined;
+    }
+
+    /**
+     * Updates the vehicle’s velocity based on its suspension, engine force, and brake.
+     *
+     * This directly updates the velocity of its chassis rigid-body.
+     *
+     * @param dt - Time increment used to integrate forces.
+     * @param filterFlags - Flag to exclude categories of objects from the wheels’ ray-cast.
+     * @param filterGroups - Only colliders compatible with these groups will be hit by the wheels’ ray-casts.
+     * @param filterPredicate - Callback to filter out which collider will be hit by the wheels’ ray-casts.
+     */
+    public updateVehicle(
+        dt: number,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterPredicate?: (collider: Collider) => boolean,
+    ) {
+        this.raw.update_vehicle(
+            dt,
+            this.broadPhase.raw,
+            this.narrowPhase.raw,
+            this.bodies.raw,
+            this.colliders.raw,
+            filterFlags,
+            filterGroups,
+            this.colliders.castClosure(filterPredicate),
+        );
+    }
+
+    /**
+     * The current forward speed of the vehicle.
+     */
+    public currentVehicleSpeed(): number {
+        return this.raw.current_vehicle_speed();
+    }
+
+    /**
+     * The rigid-body used as the chassis.
+     */
+    public chassis(): RigidBody {
+        return this._chassis;
+    }
+
+    /**
+     * The chassis’ local _up_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    get indexUpAxis(): number {
+        return this.raw.index_up_axis();
+    }
+
+    /**
+     * Sets the chassis’ local _up_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    set indexUpAxis(axis: number) {
+        this.raw.set_index_up_axis(axis);
+    }
+
+    /**
+     * The chassis’ local _forward_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    get indexForwardAxis(): number {
+        return this.raw.index_forward_axis();
+    }
+
+    /**
+     * Sets the chassis’ local _forward_ direction (`0 = x, 1 = y, 2 = z`).
+     */
+    set setIndexForwardAxis(axis: number) {
+        this.raw.set_index_forward_axis(axis);
+    }
+
+    /**
+     * Adds a new wheel attached to this vehicle.
+     * @param chassisConnectionCs  - The position of the wheel relative to the chassis.
+     * @param directionCs - The direction of the wheel’s suspension, relative to the chassis. The ray-casting will
+     *                      happen following this direction to detect the ground.
+     * @param axleCs - The wheel’s axle axis, relative to the chassis.
+     * @param suspensionRestLength - The rest length of the wheel’s suspension spring.
+     * @param radius - The wheel’s radius.
+     */
+    public addWheel(
+        chassisConnectionCs: Vector,
+        directionCs: Vector,
+        axleCs: Vector,
+        suspensionRestLength: number,
+        radius: number,
+    ) {
+        let rawChassisConnectionCs = VectorOps.intoRaw(chassisConnectionCs);
+        let rawDirectionCs = VectorOps.intoRaw(directionCs);
+        let rawAxleCs = VectorOps.intoRaw(axleCs);
+
+        this.raw.add_wheel(
+            rawChassisConnectionCs,
+            rawDirectionCs,
+            rawAxleCs,
+            suspensionRestLength,
+            radius,
+        );
+
+        rawChassisConnectionCs.free();
+        rawDirectionCs.free();
+        rawAxleCs.free();
+    }
+
+    /**
+     * The number of wheels attached to this vehicle.
+     */
+    public numWheels(): number {
+        return this.raw.num_wheels();
+    }
+
+    /*
+     *
+     * Access to wheel properties.
+     *
+     */
+    /*
+     * Getters + setters
+     */
+    /**
+     * The position of the i-th wheel, relative to the chassis.
+     */
+    public wheelChassisConnectionPointCs(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.wheel_chassis_connection_point_cs(i));
+    }
+
+    /**
+     * Sets the position of the i-th wheel, relative to the chassis.
+     */
+    public setWheelChassisConnectionPointCs(i: number, value: Vector) {
+        let rawValue = VectorOps.intoRaw(value);
+        this.raw.set_wheel_chassis_connection_point_cs(i, rawValue);
+        rawValue.free();
+    }
+
+    /**
+     * The rest length of the i-th wheel’s suspension spring.
+     */
+    public wheelSuspensionRestLength(i: number): number | null {
+        return this.raw.wheel_suspension_rest_length(i);
+    }
+
+    /**
+     * Sets the rest length of the i-th wheel’s suspension spring.
+     */
+    public setWheelSuspensionRestLength(i: number, value: number) {
+        this.raw.set_wheel_suspension_rest_length(i, value);
+    }
+
+    /**
+     * The maximum distance the i-th wheel suspension can travel before and after its resting length.
+     */
+    public wheelMaxSuspensionTravel(i: number): number | null {
+        return this.raw.wheel_max_suspension_travel(i);
+    }
+
+    /**
+     * Sets the maximum distance the i-th wheel suspension can travel before and after its resting length.
+     */
+    public setWheelMaxSuspensionTravel(i: number, value: number) {
+        this.raw.set_wheel_max_suspension_travel(i, value);
+    }
+
+    /**
+     * The i-th wheel’s radius.
+     */
+    public wheelRadius(i: number): number | null {
+        return this.raw.wheel_radius(i);
+    }
+
+    /**
+     * Sets the i-th wheel’s radius.
+     */
+    public setWheelRadius(i: number, value: number) {
+        this.raw.set_wheel_radius(i, value);
+    }
+
+    /**
+     * The i-th wheel’s suspension stiffness.
+     *
+     * Increase this value if the suspension appears to not push the vehicle strong enough.
+     */
+    public wheelSuspensionStiffness(i: number): number | null {
+        return this.raw.wheel_suspension_stiffness(i);
+    }
+
+    /**
+     * Sets the i-th wheel’s suspension stiffness.
+     *
+     * Increase this value if the suspension appears to not push the vehicle strong enough.
+     */
+    public setWheelSuspensionStiffness(i: number, value: number) {
+        this.raw.set_wheel_suspension_stiffness(i, value);
+    }
+
+    /**
+     * The i-th wheel’s suspension’s damping when it is being compressed.
+     */
+    public wheelSuspensionCompression(i: number): number | null {
+        return this.raw.wheel_suspension_compression(i);
+    }
+
+    /**
+     * The i-th wheel’s suspension’s damping when it is being compressed.
+     */
+    public setWheelSuspensionCompression(i: number, value: number) {
+        this.raw.set_wheel_suspension_compression(i, value);
+    }
+
+    /**
+     * The i-th wheel’s suspension’s damping when it is being released.
+     *
+     * Increase this value if the suspension appears to overshoot.
+     */
+    public wheelSuspensionRelaxation(i: number): number | null {
+        return this.raw.wheel_suspension_relaxation(i);
+    }
+
+    /**
+     * Sets the i-th wheel’s suspension’s damping when it is being released.
+     *
+     * Increase this value if the suspension appears to overshoot.
+     */
+    public setWheelSuspensionRelaxation(i: number, value: number) {
+        this.raw.set_wheel_suspension_relaxation(i, value);
+    }
+
+    /**
+     * The maximum force applied by the i-th wheel’s suspension.
+     */
+    public wheelMaxSuspensionForce(i: number): number | null {
+        return this.raw.wheel_max_suspension_force(i);
+    }
+
+    /**
+     * Sets the maximum force applied by the i-th wheel’s suspension.
+     */
+    public setWheelMaxSuspensionForce(i: number, value: number) {
+        this.raw.set_wheel_max_suspension_force(i, value);
+    }
+
+    /**
+     * The maximum amount of braking impulse applied on the i-th wheel to slow down the vehicle.
+     */
+    public wheelBrake(i: number): number | null {
+        return this.raw.wheel_brake(i);
+    }
+
+    /**
+     * Set the maximum amount of braking impulse applied on the i-th wheel to slow down the vehicle.
+     */
+    public setWheelBrake(i: number, value: number) {
+        this.raw.set_wheel_brake(i, value);
+    }
+
+    /**
+     * The steering angle (radians) for the i-th wheel.
+     */
+    public wheelSteering(i: number): number | null {
+        return this.raw.wheel_steering(i);
+    }
+
+    /**
+     * Sets the steering angle (radians) for the i-th wheel.
+     */
+    public setWheelSteering(i: number, value: number) {
+        this.raw.set_wheel_steering(i, value);
+    }
+
+    /**
+     * The forward force applied by the i-th wheel on the chassis.
+     */
+    public wheelEngineForce(i: number): number | null {
+        return this.raw.wheel_engine_force(i);
+    }
+
+    /**
+     * Sets the forward force applied by the i-th wheel on the chassis.
+     */
+    public setWheelEngineForce(i: number, value: number) {
+        this.raw.set_wheel_engine_force(i, value);
+    }
+
+    /**
+     * The direction of the i-th wheel’s suspension, relative to the chassis.
+     *
+     * The ray-casting will happen following this direction to detect the ground.
+     */
+    public wheelDirectionCs(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.wheel_direction_cs(i));
+    }
+
+    /**
+     * Sets the direction of the i-th wheel’s suspension, relative to the chassis.
+     *
+     * The ray-casting will happen following this direction to detect the ground.
+     */
+    public setWheelDirectionCs(i: number, value: Vector) {
+        let rawValue = VectorOps.intoRaw(value);
+        this.raw.set_wheel_direction_cs(i, rawValue);
+        rawValue.free();
+    }
+
+    /**
+     * The i-th wheel’s axle axis, relative to the chassis.
+     *
+     * The axis index defined as 0 = X, 1 = Y, 2 = Z.
+     */
+    public wheelAxleCs(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.wheel_axle_cs(i));
+    }
+
+    /**
+     * Sets the i-th wheel’s axle axis, relative to the chassis.
+     *
+     * The axis index defined as 0 = X, 1 = Y, 2 = Z.
+     */
+    public setWheelAxleCs(i: number, value: Vector) {
+        let rawValue = VectorOps.intoRaw(value);
+        this.raw.set_wheel_axle_cs(i, rawValue);
+        rawValue.free();
+    }
+
+    /**
+     * Parameter controlling how much traction the tire has.
+     *
+     * The larger the value, the more instantaneous braking will happen (with the risk of
+     * causing the vehicle to flip if it’s too strong).
+     */
+    public wheelFrictionSlip(i: number): number | null {
+        return this.raw.wheel_friction_slip(i);
+    }
+
+    /**
+     * Sets the parameter controlling how much traction the tire has.
+     *
+     * The larger the value, the more instantaneous braking will happen (with the risk of
+     * causing the vehicle to flip if it’s too strong).
+     */
+    public setWheelFrictionSlip(i: number, value: number) {
+        this.raw.set_wheel_friction_slip(i, value);
+    }
+
+    /**
+     * The multiplier of friction between a tire and the collider it’s on top of.
+     *
+     * The larger the value, the stronger side friction will be.
+     */
+    public wheelSideFrictionStiffness(i: number): number | null {
+        return this.raw.wheel_side_friction_stiffness(i);
+    }
+
+    /**
+     * The multiplier of friction between a tire and the collider it’s on top of.
+     *
+     * The larger the value, the stronger side friction will be.
+     */
+    public setWheelSideFrictionStiffness(i: number, value: number) {
+        this.raw.set_wheel_side_friction_stiffness(i, value);
+    }
+
+    /*
+     * Getters only.
+     */
+
+    /**
+     *  The i-th wheel’s current rotation angle (radians) on its axle.
+     */
+    public wheelRotation(i: number): number | null {
+        return this.raw.wheel_rotation(i);
+    }
+
+    /**
+     *  The forward impulses applied by the i-th wheel on the chassis.
+     */
+    public wheelForwardImpulse(i: number): number | null {
+        return this.raw.wheel_forward_impulse(i);
+    }
+
+    /**
+     *  The side impulses applied by the i-th wheel on the chassis.
+     */
+    public wheelSideImpulse(i: number): number | null {
+        return this.raw.wheel_side_impulse(i);
+    }
+
+    /**
+     *  The force applied by the i-th wheel suspension.
+     */
+    public wheelSuspensionForce(i: number): number | null {
+        return this.raw.wheel_suspension_force(i);
+    }
+
+    /**
+     *  The (world-space) contact normal between the i-th wheel and the floor.
+     */
+    public wheelContactNormal(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.wheel_contact_normal_ws(i));
+    }
+
+    /**
+     *  The (world-space) point hit by the wheel’s ray-cast for the i-th wheel.
+     */
+    public wheelContactPoint(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.wheel_contact_point_ws(i));
+    }
+
+    /**
+     *  The suspension length for the i-th wheel.
+     */
+    public wheelSuspensionLength(i: number): number | null {
+        return this.raw.wheel_suspension_length(i);
+    }
+
+    /**
+     *  The (world-space) starting point of the ray-cast for the i-th wheel.
+     */
+    public wheelHardPoint(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.wheel_hard_point_ws(i));
+    }
+
+    /**
+     *  Is the i-th wheel in contact with the ground?
+     */
+    public wheelIsInContact(i: number): boolean {
+        return this.raw.wheel_is_in_contact(i);
+    }
+
+    /**
+     *  The collider hit by the ray-cast for the i-th wheel.
+     */
+    public wheelGroundObject(i: number): Collider | null {
+        return this.colliders.get(this.raw.wheel_ground_object(i));
+    }
+}

packages/rapier2d/src/dynamics/ccd_solver.ts

@@ -0,0 +1,25 @@
+import {RawCCDSolver} from "../raw";
+
+/**
+ * The CCD solver responsible for resolving Continuous Collision Detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `ccdSolver.free()`
+ * once you are done using it.
+ */
+export class CCDSolver {
+    raw: RawCCDSolver;
+
+    /**
+     * Release the WASM memory occupied by this narrow-phase.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    constructor(raw?: RawCCDSolver) {
+        this.raw = raw || new RawCCDSolver();
+    }
+}

packages/rapier2d/src/dynamics/coefficient_combine_rule.ts

@@ -0,0 +1,13 @@
+/**
+ * A rule applied to combine coefficients.
+ *
+ * Use this when configuring the `ColliderDesc` to specify
+ * how friction and restitution coefficient should be combined
+ * in a contact.
+ */
+export enum CoefficientCombineRule {
+    Average = 0,
+    Min = 1,
+    Multiply = 2,
+    Max = 3,
+}

packages/rapier2d/src/dynamics/impulse_joint.ts

@@ -0,0 +1,485 @@
+import {Rotation, Vector, VectorOps, RotationOps} from "../math";
+import {
+    RawGenericJoint,
+    RawImpulseJointSet,
+    RawRigidBodySet,
+    RawJointAxis,
+    RawJointType,
+    RawMotorModel,
+} from "../raw";
+import {RigidBody, RigidBodyHandle} from "./rigid_body";
+import {RigidBodySet} from "./rigid_body_set";
+
+/**
+ * The integer identifier of a collider added to a `ColliderSet`.
+ */
+export type ImpulseJointHandle = number;
+
+/**
+ * An enum grouping all possible types of joints:
+ *
+ * - `Revolute`: A revolute joint that removes all degrees of freedom between the affected
+ *               bodies except for the rotation along one axis.
+ * - `Fixed`: A fixed joint that removes all relative degrees of freedom between the affected bodies.
+ * - `Prismatic`: A prismatic joint that removes all degrees of freedom between the affected
+ *                bodies except for the translation along one axis.
+ * - `Spherical`: (3D only) A spherical joint that removes all relative linear degrees of freedom between the affected bodies.
+ * - `Generic`: (3D only) A joint with customizable degrees of freedom, allowing any of the 6 axes to be locked.
+ */
+export enum JointType {
+    Revolute,
+    Fixed,
+    Prismatic,
+    Rope,
+    Spring,
+}
+
+export enum MotorModel {
+    AccelerationBased,
+    ForceBased,
+}
+
+/**
+ * An enum representing the possible joint axes of a generic joint.
+ * They can be ORed together, like:
+ * JointAxesMask.LinX || JointAxesMask.LinY
+ * to get a joint that is only free in the X and Y translational (positional) axes.
+ *
+ * Possible free axes are:
+ *
+ * - `X`: X translation axis
+ * - `Y`: Y translation axis
+ * - `Z`: Z translation axis
+ * - `AngX`: X angular rotation axis
+ * - `AngY`: Y angular rotations axis
+ * - `AngZ`: Z angular rotation axis
+ */
+export enum JointAxesMask {
+    LinX = 1 << 0,
+    LinY = 1 << 1,
+    LinZ = 1 << 2,
+    AngX = 1 << 3,
+    AngY = 1 << 4,
+    AngZ = 1 << 5,
+}
+
+export class ImpulseJoint {
+    protected rawSet: RawImpulseJointSet; // The ImpulseJoint won't need to free this.
+    protected bodySet: RigidBodySet; // The ImpulseJoint won’t need to free this.
+    handle: ImpulseJointHandle;
+
+    constructor(
+        rawSet: RawImpulseJointSet,
+        bodySet: RigidBodySet,
+        handle: ImpulseJointHandle,
+    ) {
+        this.rawSet = rawSet;
+        this.bodySet = bodySet;
+        this.handle = handle;
+    }
+
+    public static newTyped(
+        rawSet: RawImpulseJointSet,
+        bodySet: RigidBodySet,
+        handle: ImpulseJointHandle,
+    ): ImpulseJoint {
+        switch (rawSet.jointType(handle)) {
+            case RawJointType.Revolute:
+                return new RevoluteImpulseJoint(rawSet, bodySet, handle);
+            case RawJointType.Prismatic:
+                return new PrismaticImpulseJoint(rawSet, bodySet, handle);
+            case RawJointType.Fixed:
+                return new FixedImpulseJoint(rawSet, bodySet, handle);
+            case RawJointType.Spring:
+                return new SpringImpulseJoint(rawSet, bodySet, handle);
+            case RawJointType.Rope:
+                return new RopeImpulseJoint(rawSet, bodySet, handle);
+            default:
+                return new ImpulseJoint(rawSet, bodySet, handle);
+        }
+    }
+
+    /** @internal */
+    public finalizeDeserialization(bodySet: RigidBodySet) {
+        this.bodySet = bodySet;
+    }
+
+    /**
+     * Checks if this joint is still valid (i.e. that it has
+     * not been deleted from the joint set yet).
+     */
+    public isValid(): boolean {
+        return this.rawSet.contains(this.handle);
+    }
+
+    /**
+     * The first rigid-body this joint it attached to.
+     */
+    public body1(): RigidBody {
+        return this.bodySet.get(this.rawSet.jointBodyHandle1(this.handle));
+    }
+
+    /**
+     * The second rigid-body this joint is attached to.
+     */
+    public body2(): RigidBody {
+        return this.bodySet.get(this.rawSet.jointBodyHandle2(this.handle));
+    }
+
+    /**
+     * The type of this joint given as a string.
+     */
+    public type(): JointType {
+        return this.rawSet.jointType(this.handle) as number as JointType;
+    }
+
+
+
+    /**
+     * The position of the first anchor of this joint.
+     *
+     * The first anchor gives the position of the application point on the
+     * local frame of the first rigid-body it is attached to.
+     */
+    public anchor1(): Vector {
+        return VectorOps.fromRaw(this.rawSet.jointAnchor1(this.handle));
+    }
+
+    /**
+     * The position of the second anchor of this joint.
+     *
+     * The second anchor gives the position of the application point on the
+     * local frame of the second rigid-body it is attached to.
+     */
+    public anchor2(): Vector {
+        return VectorOps.fromRaw(this.rawSet.jointAnchor2(this.handle));
+    }
+
+    /**
+     * Sets the position of the first anchor of this joint.
+     *
+     * The first anchor gives the position of the application point on the
+     * local frame of the first rigid-body it is attached to.
+     */
+    public setAnchor1(newPos: Vector) {
+        const rawPoint = VectorOps.intoRaw(newPos);
+        this.rawSet.jointSetAnchor1(this.handle, rawPoint);
+        rawPoint.free();
+    }
+
+    /**
+     * Sets the position of the second anchor of this joint.
+     *
+     * The second anchor gives the position of the application point on the
+     * local frame of the second rigid-body it is attached to.
+     */
+    public setAnchor2(newPos: Vector) {
+        const rawPoint = VectorOps.intoRaw(newPos);
+        this.rawSet.jointSetAnchor2(this.handle, rawPoint);
+        rawPoint.free();
+    }
+
+    /**
+     * Controls whether contacts are computed between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    public setContactsEnabled(enabled: boolean) {
+        this.rawSet.jointSetContactsEnabled(this.handle, enabled);
+    }
+
+    /**
+     * Indicates if contacts are enabled between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    public contactsEnabled(): boolean {
+        return this.rawSet.jointContactsEnabled(this.handle);
+    }
+}
+
+export class UnitImpulseJoint extends ImpulseJoint {
+    /**
+     * The axis left free by this joint.
+     */
+    protected rawAxis?(): RawJointAxis;
+
+    /**
+     * Are the limits enabled for this joint?
+     */
+    public limitsEnabled(): boolean {
+        return this.rawSet.jointLimitsEnabled(this.handle, this.rawAxis());
+    }
+
+    /**
+     * The min limit of this joint.
+     */
+    public limitsMin(): number {
+        return this.rawSet.jointLimitsMin(this.handle, this.rawAxis());
+    }
+
+    /**
+     * The max limit of this joint.
+     */
+    public limitsMax(): number {
+        return this.rawSet.jointLimitsMax(this.handle, this.rawAxis());
+    }
+
+    /**
+     * Sets the limits of this joint.
+     *
+     * @param min - The minimum bound of this joint’s free coordinate.
+     * @param max - The maximum bound of this joint’s free coordinate.
+     */
+    public setLimits(min: number, max: number) {
+        this.rawSet.jointSetLimits(this.handle, this.rawAxis(), min, max);
+    }
+
+    public configureMotorModel(model: MotorModel) {
+        this.rawSet.jointConfigureMotorModel(
+            this.handle,
+            this.rawAxis(),
+            model as number as RawMotorModel,
+        );
+    }
+
+    public configureMotorVelocity(targetVel: number, factor: number) {
+        this.rawSet.jointConfigureMotorVelocity(
+            this.handle,
+            this.rawAxis(),
+            targetVel,
+            factor,
+        );
+    }
+
+    public configureMotorPosition(
+        targetPos: number,
+        stiffness: number,
+        damping: number,
+    ) {
+        this.rawSet.jointConfigureMotorPosition(
+            this.handle,
+            this.rawAxis(),
+            targetPos,
+            stiffness,
+            damping,
+        );
+    }
+
+    public configureMotor(
+        targetPos: number,
+        targetVel: number,
+        stiffness: number,
+        damping: number,
+    ) {
+        this.rawSet.jointConfigureMotor(
+            this.handle,
+            this.rawAxis(),
+            targetPos,
+            targetVel,
+            stiffness,
+            damping,
+        );
+    }
+}
+
+export class FixedImpulseJoint extends ImpulseJoint {}
+
+export class RopeImpulseJoint extends ImpulseJoint {}
+
+export class SpringImpulseJoint extends ImpulseJoint {}
+
+export class PrismaticImpulseJoint extends UnitImpulseJoint {
+    public rawAxis(): RawJointAxis {
+        return RawJointAxis.LinX;
+    }
+}
+
+export class RevoluteImpulseJoint extends UnitImpulseJoint {
+    public rawAxis(): RawJointAxis {
+        return RawJointAxis.AngX;
+    }
+}
+
+
+export class JointData {
+    anchor1: Vector;
+    anchor2: Vector;
+    axis: Vector;
+    frame1: Rotation;
+    frame2: Rotation;
+    jointType: JointType;
+    limitsEnabled: boolean;
+    limits: Array<number>;
+    axesMask: JointAxesMask;
+    stiffness: number;
+    damping: number;
+    length: number;
+
+    private constructor() {}
+
+    /**
+     * Creates a new joint descriptor that builds a Fixed joint.
+     *
+     * A fixed joint removes all the degrees of freedom between the affected bodies, ensuring their
+     * anchor and local frames coincide in world-space.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param frame1 - The reference orientation of the joint wrt. the first rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param frame2 - The reference orientation of the joint wrt. the second rigid-body.
+     */
+    public static fixed(
+        anchor1: Vector,
+        frame1: Rotation,
+        anchor2: Vector,
+        frame2: Rotation,
+    ): JointData {
+        let res = new JointData();
+        res.anchor1 = anchor1;
+        res.anchor2 = anchor2;
+        res.frame1 = frame1;
+        res.frame2 = frame2;
+        res.jointType = JointType.Fixed;
+        return res;
+    }
+
+    public static spring(
+        rest_length: number,
+        stiffness: number,
+        damping: number,
+        anchor1: Vector,
+        anchor2: Vector,
+    ): JointData {
+        let res = new JointData();
+        res.anchor1 = anchor1;
+        res.anchor2 = anchor2;
+        res.length = rest_length;
+        res.stiffness = stiffness;
+        res.damping = damping;
+        res.jointType = JointType.Spring;
+        return res;
+    }
+
+    public static rope(
+        length: number,
+        anchor1: Vector,
+        anchor2: Vector,
+    ): JointData {
+        let res = new JointData();
+        res.anchor1 = anchor1;
+        res.anchor2 = anchor2;
+        res.length = length;
+        res.jointType = JointType.Rope;
+        return res;
+    }
+
+
+    /**
+     * Create a new joint descriptor that builds revolute joints.
+     *
+     * A revolute joint allows three relative rotational degrees of freedom
+     * by preventing any relative translation between the anchors of the
+     * two attached rigid-bodies.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     */
+    public static revolute(anchor1: Vector, anchor2: Vector): JointData {
+        let res = new JointData();
+        res.anchor1 = anchor1;
+        res.anchor2 = anchor2;
+        res.jointType = JointType.Revolute;
+        return res;
+    }
+
+    /**
+     * Creates a new joint descriptor that builds a Prismatic joint.
+     *
+     * A prismatic joint removes all the degrees of freedom between the
+     * affected bodies, except for the translation along one axis.
+     *
+     * @param anchor1 - Point where the joint is attached on the first rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param anchor2 - Point where the joint is attached on the second rigid-body affected by this joint. Expressed in the
+     *                  local-space of the rigid-body.
+     * @param axis - Axis of the joint, expressed in the local-space of the rigid-bodies it is attached to.
+     */
+    public static prismatic(
+        anchor1: Vector,
+        anchor2: Vector,
+        axis: Vector,
+    ): JointData {
+        let res = new JointData();
+        res.anchor1 = anchor1;
+        res.anchor2 = anchor2;
+        res.axis = axis;
+        res.jointType = JointType.Prismatic;
+        return res;
+    }
+
+
+
+    public intoRaw(): RawGenericJoint {
+        let rawA1 = VectorOps.intoRaw(this.anchor1);
+        let rawA2 = VectorOps.intoRaw(this.anchor2);
+        let rawAx;
+        let result;
+        let limitsEnabled = false;
+        let limitsMin = 0.0;
+        let limitsMax = 0.0;
+
+        switch (this.jointType) {
+            case JointType.Fixed:
+                let rawFra1 = RotationOps.intoRaw(this.frame1);
+                let rawFra2 = RotationOps.intoRaw(this.frame2);
+                result = RawGenericJoint.fixed(rawA1, rawFra1, rawA2, rawFra2);
+                rawFra1.free();
+                rawFra2.free();
+                break;
+            case JointType.Spring:
+                result = RawGenericJoint.spring(
+                    this.length,
+                    this.stiffness,
+                    this.damping,
+                    rawA1,
+                    rawA2,
+                );
+                break;
+            case JointType.Rope:
+                result = RawGenericJoint.rope(this.length, rawA1, rawA2);
+                break;
+            case JointType.Prismatic:
+                rawAx = VectorOps.intoRaw(this.axis);
+
+                if (!!this.limitsEnabled) {
+                    limitsEnabled = true;
+                    limitsMin = this.limits[0];
+                    limitsMax = this.limits[1];
+                }
+
+                result = RawGenericJoint.prismatic(
+                    rawA1,
+                    rawA2,
+                    rawAx,
+                    limitsEnabled,
+                    limitsMin,
+                    limitsMax,
+                );
+
+
+                rawAx.free();
+                break;
+            case JointType.Revolute:
+                result = RawGenericJoint.revolute(rawA1, rawA2);
+                break;
+        }
+
+        rawA1.free();
+        rawA2.free();
+
+        return result;
+    }
+}

packages/rapier2d/src/dynamics/impulse_joint_set.ts

@@ -0,0 +1,162 @@
+import {RawImpulseJointSet} from "../raw";
+import {Coarena} from "../coarena";
+import {RigidBodySet} from "./rigid_body_set";
+import {
+    RevoluteImpulseJoint,
+    FixedImpulseJoint,
+    ImpulseJoint,
+    ImpulseJointHandle,
+    JointData,
+    JointType,
+    PrismaticImpulseJoint,
+} from "./impulse_joint";
+import {IslandManager} from "./island_manager";
+import {RigidBodyHandle} from "./rigid_body";
+import {Collider, ColliderHandle} from "../geometry";
+
+/**
+ * A set of joints.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `jointSet.free()`
+ * once you are done using it (and all the joints it created).
+ */
+export class ImpulseJointSet {
+    raw: RawImpulseJointSet;
+    private map: Coarena<ImpulseJoint>;
+
+    /**
+     * Release the WASM memory occupied by this joint set.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+
+        if (!!this.map) {
+            this.map.clear();
+        }
+        this.map = undefined;
+    }
+
+    constructor(raw?: RawImpulseJointSet) {
+        this.raw = raw || new RawImpulseJointSet();
+        this.map = new Coarena<ImpulseJoint>();
+        // Initialize the map with the existing elements, if any.
+        if (raw) {
+            raw.forEachJointHandle((handle: ImpulseJointHandle) => {
+                this.map.set(handle, ImpulseJoint.newTyped(raw, null, handle));
+            });
+        }
+    }
+
+    /** @internal */
+    public finalizeDeserialization(bodies: RigidBodySet) {
+        this.map.forEach((joint) => joint.finalizeDeserialization(bodies));
+    }
+
+    /**
+     * Creates a new joint and return its integer handle.
+     *
+     * @param bodies - The set of rigid-bodies containing the bodies the joint is attached to.
+     * @param desc - The joint's parameters.
+     * @param parent1 - The handle of the first rigid-body this joint is attached to.
+     * @param parent2 - The handle of the second rigid-body this joint is attached to.
+     * @param wakeUp - Should the attached rigid-bodies be awakened?
+     */
+    public createJoint(
+        bodies: RigidBodySet,
+        desc: JointData,
+        parent1: RigidBodyHandle,
+        parent2: RigidBodyHandle,
+        wakeUp: boolean,
+    ): ImpulseJoint {
+        const rawParams = desc.intoRaw();
+        const handle = this.raw.createJoint(
+            rawParams,
+            parent1,
+            parent2,
+            wakeUp,
+        );
+        rawParams.free();
+        let joint = ImpulseJoint.newTyped(this.raw, bodies, handle);
+        this.map.set(handle, joint);
+        return joint;
+    }
+
+    /**
+     * Remove a joint from this set.
+     *
+     * @param handle - The integer handle of the joint.
+     * @param wakeUp - If `true`, the rigid-bodies attached by the removed joint will be woken-up automatically.
+     */
+    public remove(handle: ImpulseJointHandle, wakeUp: boolean) {
+        this.raw.remove(handle, wakeUp);
+        this.unmap(handle);
+    }
+
+    /**
+     * Calls the given closure with the integer handle of each impulse joint attached to this rigid-body.
+     *
+     * @param f - The closure called with the integer handle of each impulse joint attached to the rigid-body.
+     */
+    public forEachJointHandleAttachedToRigidBody(
+        handle: RigidBodyHandle,
+        f: (handle: ImpulseJointHandle) => void,
+    ) {
+        this.raw.forEachJointAttachedToRigidBody(handle, f);
+    }
+
+    /**
+     * Internal function, do not call directly.
+     * @param handle
+     */
+    public unmap(handle: ImpulseJointHandle) {
+        this.map.delete(handle);
+    }
+
+    /**
+     * The number of joints on this set.
+     */
+    public len(): number {
+        return this.map.len();
+    }
+
+    /**
+     * Does this set contain a joint with the given handle?
+     *
+     * @param handle - The joint handle to check.
+     */
+    public contains(handle: ImpulseJointHandle): boolean {
+        return this.get(handle) != null;
+    }
+
+    /**
+     * Gets the joint with the given handle.
+     *
+     * Returns `null` if no joint with the specified handle exists.
+     *
+     * @param handle - The integer handle of the joint to retrieve.
+     */
+    public get(handle: ImpulseJointHandle): ImpulseJoint | null {
+        return this.map.get(handle);
+    }
+
+    /**
+     * Applies the given closure to each joint contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    public forEach(f: (joint: ImpulseJoint) => void) {
+        this.map.forEach(f);
+    }
+
+    /**
+     * Gets all joints in the list.
+     *
+     * @returns joint list.
+     */
+    public getAll(): ImpulseJoint[] {
+        return this.map.getAll();
+    }
+}

packages/rapier2d/src/dynamics/index.ts

@@ -0,0 +1,10 @@
+export * from "./rigid_body";
+export * from "./rigid_body_set";
+export * from "./integration_parameters";
+export * from "./impulse_joint";
+export * from "./impulse_joint_set";
+export * from "./multibody_joint";
+export * from "./multibody_joint_set";
+export * from "./coefficient_combine_rule";
+export * from "./ccd_solver";
+export * from "./island_manager";

packages/rapier2d/src/dynamics/integration_parameters.ts

@@ -0,0 +1,126 @@
+import {RawIntegrationParameters} from "../raw";
+
+export class IntegrationParameters {
+    raw: RawIntegrationParameters;
+
+    constructor(raw?: RawIntegrationParameters) {
+        this.raw = raw || new RawIntegrationParameters();
+    }
+
+    /**
+     * Free the WASM memory used by these integration parameters.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    /**
+     * The timestep length (default: `1.0 / 60.0`)
+     */
+    get dt(): number {
+        return this.raw.dt;
+    }
+
+    /**
+     * The Error Reduction Parameter in `[0, 1]` is the proportion of
+     * the positional error to be corrected at each time step (default: `0.2`).
+     */
+    get contact_erp(): number {
+        return this.raw.contact_erp;
+    }
+
+    get lengthUnit(): number {
+        return this.raw.lengthUnit;
+    }
+
+    /**
+     * Normalized amount of penetration the engine won’t attempt to correct (default: `0.001m`).
+     *
+     * This threshold considered by the physics engine is this value multiplied by the `lengthUnit`.
+     */
+    get normalizedAllowedLinearError(): number {
+        return this.raw.normalizedAllowedLinearError;
+    }
+
+    /**
+     * The maximal normalized distance separating two objects that will generate predictive contacts (default: `0.002`).
+     *
+     * This threshold considered by the physics engine is this value multiplied by the `lengthUnit`.
+     */
+    get normalizedPredictionDistance(): number {
+        return this.raw.normalizedPredictionDistance;
+    }
+
+    /**
+     * The number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+     */
+    get numSolverIterations(): number {
+        return this.raw.numSolverIterations;
+    }
+
+    /**
+     * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+     */
+    get numInternalPgsIterations(): number {
+        return this.raw.numInternalPgsIterations;
+    }
+
+    /**
+     * Minimum number of dynamic bodies in each active island (default: `128`).
+     */
+    get minIslandSize(): number {
+        return this.raw.minIslandSize;
+    }
+
+    /**
+     * Maximum number of substeps performed by the  solver (default: `1`).
+     */
+    get maxCcdSubsteps(): number {
+        return this.raw.maxCcdSubsteps;
+    }
+
+    set dt(value: number) {
+        this.raw.dt = value;
+    }
+
+    set contact_natural_frequency(value: number) {
+        this.raw.contact_natural_frequency = value;
+    }
+
+    set lengthUnit(value: number) {
+        this.raw.lengthUnit = value;
+    }
+
+    set normalizedAllowedLinearError(value: number) {
+        this.raw.normalizedAllowedLinearError = value;
+    }
+
+    set normalizedPredictionDistance(value: number) {
+        this.raw.normalizedPredictionDistance = value;
+    }
+
+    /**
+     * Sets the number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+     */
+    set numSolverIterations(value: number) {
+        this.raw.numSolverIterations = value;
+    }
+
+    /**
+     * Sets the number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+     */
+    set numInternalPgsIterations(value: number) {
+        this.raw.numInternalPgsIterations = value;
+    }
+
+    set minIslandSize(value: number) {
+        this.raw.minIslandSize = value;
+    }
+
+    set maxCcdSubsteps(value: number) {
+        this.raw.maxCcdSubsteps = value;
+    }
+}

packages/rapier2d/src/dynamics/island_manager.ts

@@ -0,0 +1,37 @@
+import {RawIslandManager} from "../raw";
+import {RigidBodyHandle} from "./rigid_body";
+
+/**
+ * The CCD solver responsible for resolving Continuous Collision Detection.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `ccdSolver.free()`
+ * once you are done using it.
+ */
+export class IslandManager {
+    raw: RawIslandManager;
+
+    /**
+     * Release the WASM memory occupied by this narrow-phase.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    constructor(raw?: RawIslandManager) {
+        this.raw = raw || new RawIslandManager();
+    }
+
+    /**
+     * Applies the given closure to the handle of each active rigid-bodies contained by this set.
+     *
+     * A rigid-body is active if it is not sleeping, i.e., if it moved recently.
+     *
+     * @param f - The closure to apply.
+     */
+    public forEachActiveRigidBodyHandle(f: (handle: RigidBodyHandle) => void) {
+        this.raw.forEachActiveRigidBodyHandle(f);
+    }
+}

packages/rapier2d/src/dynamics/multibody_joint.ts

@@ -0,0 +1,190 @@
+import {
+    RawImpulseJointSet,
+    RawJointAxis,
+    RawJointType,
+    RawMultibodyJointSet,
+} from "../raw";
+import {
+    FixedImpulseJoint,
+    ImpulseJointHandle,
+    JointType,
+    MotorModel,
+    PrismaticImpulseJoint,
+    RevoluteImpulseJoint,
+} from "./impulse_joint";
+
+
+/**
+ * The integer identifier of a collider added to a `ColliderSet`.
+ */
+export type MultibodyJointHandle = number;
+
+export class MultibodyJoint {
+    protected rawSet: RawMultibodyJointSet; // The MultibodyJoint won't need to free this.
+    handle: MultibodyJointHandle;
+
+    constructor(rawSet: RawMultibodyJointSet, handle: MultibodyJointHandle) {
+        this.rawSet = rawSet;
+        this.handle = handle;
+    }
+
+    public static newTyped(
+        rawSet: RawMultibodyJointSet,
+        handle: MultibodyJointHandle,
+    ): MultibodyJoint {
+        switch (rawSet.jointType(handle)) {
+            case RawJointType.Revolute:
+                return new RevoluteMultibodyJoint(rawSet, handle);
+            case RawJointType.Prismatic:
+                return new PrismaticMultibodyJoint(rawSet, handle);
+            case RawJointType.Fixed:
+                return new FixedMultibodyJoint(rawSet, handle);
+            default:
+                return new MultibodyJoint(rawSet, handle);
+        }
+    }
+
+    /**
+     * Checks if this joint is still valid (i.e. that it has
+     * not been deleted from the joint set yet).
+     */
+    public isValid(): boolean {
+        return this.rawSet.contains(this.handle);
+    }
+
+    // /**
+    //  * The unique integer identifier of the first rigid-body this joint it attached to.
+    //  */
+    // public bodyHandle1(): RigidBodyHandle {
+    //     return this.rawSet.jointBodyHandle1(this.handle);
+    // }
+    //
+    // /**
+    //  * The unique integer identifier of the second rigid-body this joint is attached to.
+    //  */
+    // public bodyHandle2(): RigidBodyHandle {
+    //     return this.rawSet.jointBodyHandle2(this.handle);
+    // }
+    //
+    // /**
+    //  * The type of this joint given as a string.
+    //  */
+    // public type(): JointType {
+    //     return this.rawSet.jointType(this.handle);
+    // }
+    //
+    // // #if DIM3
+    // /**
+    //  * The rotation quaternion that aligns this joint's first local axis to the `x` axis.
+    //  */
+    // public frameX1(): Rotation {
+    //     return RotationOps.fromRaw(this.rawSet.jointFrameX1(this.handle));
+    // }
+    //
+    // // #endif
+    //
+    // // #if DIM3
+    // /**
+    //  * The rotation matrix that aligns this joint's second local axis to the `x` axis.
+    //  */
+    // public frameX2(): Rotation {
+    //     return RotationOps.fromRaw(this.rawSet.jointFrameX2(this.handle));
+    // }
+    //
+    // // #endif
+    //
+    // /**
+    //  * The position of the first anchor of this joint.
+    //  *
+    //  * The first anchor gives the position of the points application point on the
+    //  * local frame of the first rigid-body it is attached to.
+    //  */
+    // public anchor1(): Vector {
+    //     return VectorOps.fromRaw(this.rawSet.jointAnchor1(this.handle));
+    // }
+    //
+    // /**
+    //  * The position of the second anchor of this joint.
+    //  *
+    //  * The second anchor gives the position of the points application point on the
+    //  * local frame of the second rigid-body it is attached to.
+    //  */
+    // public anchor2(): Vector {
+    //     return VectorOps.fromRaw(this.rawSet.jointAnchor2(this.handle));
+    // }
+
+    /**
+     * Controls whether contacts are computed between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    public setContactsEnabled(enabled: boolean) {
+        this.rawSet.jointSetContactsEnabled(this.handle, enabled);
+    }
+
+    /**
+     * Indicates if contacts are enabled between colliders attached
+     * to the rigid-bodies linked by this joint.
+     */
+    public contactsEnabled(): boolean {
+        return this.rawSet.jointContactsEnabled(this.handle);
+    }
+}
+
+export class UnitMultibodyJoint extends MultibodyJoint {
+    /**
+     * The axis left free by this joint.
+     */
+    protected rawAxis?(): RawJointAxis;
+
+    // /**
+    //  * Are the limits enabled for this joint?
+    //  */
+    // public limitsEnabled(): boolean {
+    //     return this.rawSet.jointLimitsEnabled(this.handle, this.rawAxis());
+    // }
+    //
+    // /**
+    //  * The min limit of this joint.
+    //  */
+    // public limitsMin(): number {
+    //     return this.rawSet.jointLimitsMin(this.handle, this.rawAxis());
+    // }
+    //
+    // /**
+    //  * The max limit of this joint.
+    //  */
+    // public limitsMax(): number {
+    //     return this.rawSet.jointLimitsMax(this.handle, this.rawAxis());
+    // }
+    //
+    // public configureMotorModel(model: MotorModel) {
+    //     this.rawSet.jointConfigureMotorModel(this.handle, this.rawAxis(), model);
+    // }
+    //
+    // public configureMotorVelocity(targetVel: number, factor: number) {
+    //     this.rawSet.jointConfigureMotorVelocity(this.handle, this.rawAxis(), targetVel, factor);
+    // }
+    //
+    // public configureMotorPosition(targetPos: number, stiffness: number, damping: number) {
+    //     this.rawSet.jointConfigureMotorPosition(this.handle, this.rawAxis(), targetPos, stiffness, damping);
+    // }
+    //
+    // public configureMotor(targetPos: number, targetVel: number, stiffness: number, damping: number) {
+    //     this.rawSet.jointConfigureMotor(this.handle, this.rawAxis(), targetPos, targetVel, stiffness, damping);
+    // }
+}
+
+export class FixedMultibodyJoint extends MultibodyJoint {}
+
+export class PrismaticMultibodyJoint extends UnitMultibodyJoint {
+    public rawAxis(): RawJointAxis {
+        return RawJointAxis.LinX;
+    }
+}
+
+export class RevoluteMultibodyJoint extends UnitMultibodyJoint {
+    public rawAxis(): RawJointAxis {
+        return RawJointAxis.AngX;
+    }
+}
+

packages/rapier2d/src/dynamics/multibody_joint_set.ts

@@ -0,0 +1,154 @@
+import {RawMultibodyJointSet} from "../raw";
+import {Coarena} from "../coarena";
+import {RigidBodySet} from "./rigid_body_set";
+import {
+    MultibodyJoint,
+    MultibodyJointHandle,
+    RevoluteMultibodyJoint,
+    FixedMultibodyJoint,
+    PrismaticMultibodyJoint,
+} from "./multibody_joint";
+import {ImpulseJointHandle, JointData, JointType} from "./impulse_joint";
+import {IslandManager} from "./island_manager";
+import {ColliderHandle} from "../geometry";
+import {RigidBodyHandle} from "./rigid_body";
+
+/**
+ * A set of joints.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `jointSet.free()`
+ * once you are done using it (and all the joints it created).
+ */
+export class MultibodyJointSet {
+    raw: RawMultibodyJointSet;
+    private map: Coarena<MultibodyJoint>;
+
+    /**
+     * Release the WASM memory occupied by this joint set.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+
+        if (!!this.map) {
+            this.map.clear();
+        }
+        this.map = undefined;
+    }
+
+    constructor(raw?: RawMultibodyJointSet) {
+        this.raw = raw || new RawMultibodyJointSet();
+        this.map = new Coarena<MultibodyJoint>();
+        // Initialize the map with the existing elements, if any.
+        if (raw) {
+            raw.forEachJointHandle((handle: MultibodyJointHandle) => {
+                this.map.set(handle, MultibodyJoint.newTyped(this.raw, handle));
+            });
+        }
+    }
+
+    /**
+     * Creates a new joint and return its integer handle.
+     *
+     * @param desc - The joint's parameters.
+     * @param parent1 - The handle of the first rigid-body this joint is attached to.
+     * @param parent2 - The handle of the second rigid-body this joint is attached to.
+     * @param wakeUp - Should the attached rigid-bodies be awakened?
+     */
+    public createJoint(
+        desc: JointData,
+        parent1: RigidBodyHandle,
+        parent2: RigidBodyHandle,
+        wakeUp: boolean,
+    ): MultibodyJoint {
+        const rawParams = desc.intoRaw();
+        const handle = this.raw.createJoint(
+            rawParams,
+            parent1,
+            parent2,
+            wakeUp,
+        );
+        rawParams.free();
+        let joint = MultibodyJoint.newTyped(this.raw, handle);
+        this.map.set(handle, joint);
+        return joint;
+    }
+
+    /**
+     * Remove a joint from this set.
+     *
+     * @param handle - The integer handle of the joint.
+     * @param wake_up - If `true`, the rigid-bodies attached by the removed joint will be woken-up automatically.
+     */
+    public remove(handle: MultibodyJointHandle, wake_up: boolean) {
+        this.raw.remove(handle, wake_up);
+        this.map.delete(handle);
+    }
+
+    /**
+     * Internal function, do not call directly.
+     * @param handle
+     */
+    public unmap(handle: MultibodyJointHandle) {
+        this.map.delete(handle);
+    }
+
+    /**
+     * The number of joints on this set.
+     */
+    public len(): number {
+        return this.map.len();
+    }
+
+    /**
+     * Does this set contain a joint with the given handle?
+     *
+     * @param handle - The joint handle to check.
+     */
+    public contains(handle: MultibodyJointHandle): boolean {
+        return this.get(handle) != null;
+    }
+
+    /**
+     * Gets the joint with the given handle.
+     *
+     * Returns `null` if no joint with the specified handle exists.
+     *
+     * @param handle - The integer handle of the joint to retrieve.
+     */
+    public get(handle: MultibodyJointHandle): MultibodyJoint | null {
+        return this.map.get(handle);
+    }
+
+    /**
+     * Applies the given closure to each joint contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    public forEach(f: (joint: MultibodyJoint) => void) {
+        this.map.forEach(f);
+    }
+
+    /**
+     * Calls the given closure with the integer handle of each multibody joint attached to this rigid-body.
+     *
+     * @param f - The closure called with the integer handle of each multibody joint attached to the rigid-body.
+     */
+    public forEachJointHandleAttachedToRigidBody(
+        handle: RigidBodyHandle,
+        f: (handle: MultibodyJointHandle) => void,
+    ) {
+        this.raw.forEachJointAttachedToRigidBody(handle, f);
+    }
+
+    /**
+     * Gets all joints in the list.
+     *
+     * @returns joint list.
+     */
+    public getAll(): MultibodyJoint[] {
+        return this.map.getAll();
+    }
+}

packages/rapier2d/src/dynamics/rigid_body_set.ts

@@ -0,0 +1,211 @@
+import {RawRigidBodySet, RawRigidBodyType} from "../raw";
+import {Coarena} from "../coarena";
+import {VectorOps, RotationOps} from "../math";
+import {
+    RigidBody,
+    RigidBodyDesc,
+    RigidBodyHandle,
+    RigidBodyType,
+} from "./rigid_body";
+import {ColliderSet} from "../geometry";
+import {ImpulseJointSet} from "./impulse_joint_set";
+import {MultibodyJointSet} from "./multibody_joint_set";
+import {IslandManager} from "./island_manager";
+
+/**
+ * A set of rigid bodies that can be handled by a physics pipeline.
+ *
+ * To avoid leaking WASM resources, this MUST be freed manually with `rigidBodySet.free()`
+ * once you are done using it (and all the rigid-bodies it created).
+ */
+export class RigidBodySet {
+    raw: RawRigidBodySet;
+    private map: Coarena<RigidBody>;
+
+    /**
+     * Release the WASM memory occupied by this rigid-body set.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+
+        if (!!this.map) {
+            this.map.clear();
+        }
+        this.map = undefined;
+    }
+
+    constructor(raw?: RawRigidBodySet) {
+        this.raw = raw || new RawRigidBodySet();
+        this.map = new Coarena<RigidBody>();
+        // deserialize
+        if (raw) {
+            raw.forEachRigidBodyHandle((handle: RigidBodyHandle) => {
+                this.map.set(handle, new RigidBody(raw, null, handle));
+            });
+        }
+    }
+
+    /**
+     * Internal method, do not call this explicitly.
+     */
+    public finalizeDeserialization(colliderSet: ColliderSet) {
+        this.map.forEach((rb) => rb.finalizeDeserialization(colliderSet));
+    }
+
+    /**
+     * Creates a new rigid-body and return its integer handle.
+     *
+     * @param desc - The description of the rigid-body to create.
+     */
+    public createRigidBody(
+        colliderSet: ColliderSet,
+        desc: RigidBodyDesc,
+    ): RigidBody {
+        let rawTra = VectorOps.intoRaw(desc.translation);
+        let rawRot = RotationOps.intoRaw(desc.rotation);
+        let rawLv = VectorOps.intoRaw(desc.linvel);
+        let rawCom = VectorOps.intoRaw(desc.centerOfMass);
+
+
+        let handle = this.raw.createRigidBody(
+            desc.enabled,
+            rawTra,
+            rawRot,
+            desc.gravityScale,
+            desc.mass,
+            desc.massOnly,
+            rawCom,
+            rawLv,
+            desc.angvel,
+            desc.principalAngularInertia,
+            desc.translationsEnabledX,
+            desc.translationsEnabledY,
+            desc.rotationsEnabled,
+            desc.linearDamping,
+            desc.angularDamping,
+            desc.status as number as RawRigidBodyType,
+            desc.canSleep,
+            desc.sleeping,
+            desc.softCcdPrediction,
+            desc.ccdEnabled,
+            desc.dominanceGroup,
+            desc.additionalSolverIterations,
+        );
+
+        rawTra.free();
+        rawRot.free();
+        rawLv.free();
+        rawCom.free();
+
+
+        const body = new RigidBody(this.raw, colliderSet, handle);
+        body.userData = desc.userData;
+
+        this.map.set(handle, body);
+
+        return body;
+    }
+
+    /**
+     * Removes a rigid-body from this set.
+     *
+     * This will also remove all the colliders and joints attached to the rigid-body.
+     *
+     * @param handle - The integer handle of the rigid-body to remove.
+     * @param colliders - The set of colliders that may contain colliders attached to the removed rigid-body.
+     * @param impulseJoints - The set of impulse joints that may contain joints attached to the removed rigid-body.
+     * @param multibodyJoints - The set of multibody joints that may contain joints attached to the removed rigid-body.
+     */
+    public remove(
+        handle: RigidBodyHandle,
+        islands: IslandManager,
+        colliders: ColliderSet,
+        impulseJoints: ImpulseJointSet,
+        multibodyJoints: MultibodyJointSet,
+    ) {
+        // Unmap the entities that will be removed automatically because of the rigid-body removals.
+        for (let i = 0; i < this.raw.rbNumColliders(handle); i += 1) {
+            colliders.unmap(this.raw.rbCollider(handle, i));
+        }
+
+        impulseJoints.forEachJointHandleAttachedToRigidBody(handle, (handle) =>
+            impulseJoints.unmap(handle),
+        );
+        multibodyJoints.forEachJointHandleAttachedToRigidBody(
+            handle,
+            (handle) => multibodyJoints.unmap(handle),
+        );
+
+        // Remove the rigid-body.
+        this.raw.remove(
+            handle,
+            islands.raw,
+            colliders.raw,
+            impulseJoints.raw,
+            multibodyJoints.raw,
+        );
+        this.map.delete(handle);
+    }
+
+    /**
+     * The number of rigid-bodies on this set.
+     */
+    public len(): number {
+        return this.map.len();
+    }
+
+    /**
+     * Does this set contain a rigid-body with the given handle?
+     *
+     * @param handle - The rigid-body handle to check.
+     */
+    public contains(handle: RigidBodyHandle): boolean {
+        return this.get(handle) != null;
+    }
+
+    /**
+     * Gets the rigid-body with the given handle.
+     *
+     * @param handle - The handle of the rigid-body to retrieve.
+     */
+    public get(handle: RigidBodyHandle): RigidBody | null {
+        return this.map.get(handle);
+    }
+
+    /**
+     * Applies the given closure to each rigid-body contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    public forEach(f: (body: RigidBody) => void) {
+        this.map.forEach(f);
+    }
+
+    /**
+     * Applies the given closure to each active rigid-bodies contained by this set.
+     *
+     * A rigid-body is active if it is not sleeping, i.e., if it moved recently.
+     *
+     * @param f - The closure to apply.
+     */
+    public forEachActiveRigidBody(
+        islands: IslandManager,
+        f: (body: RigidBody) => void,
+    ) {
+        islands.forEachActiveRigidBodyHandle((handle) => {
+            f(this.get(handle));
+        });
+    }
+
+    /**
+     * Gets all rigid-bodies in the list.
+     *
+     * @returns rigid-bodies list.
+     */
+    public getAll(): RigidBody[] {
+        return this.map.getAll();
+    }
+}

packages/rapier2d/src/exports.ts

@@ -0,0 +1,27 @@
+import {version as vers, reserve_memory as reserve} from "./raw";
+
+export function version(): string {
+    return vers();
+}
+
+/// Reserves additional memory in WASM land.
+///
+/// This will grow the internal WASM memory buffer so that it can fit at least
+/// the specified amount of extra bytes. This can help reduce future runtime
+/// overhead due to dynamic internal memory growth once the limit of the
+/// pre-allocated memory is reached.
+///
+/// This feature is still experimental. Due to the nature of the internal
+/// allocator, there can be situations where the allocator decides to perform
+/// additional internal memory growth even though not all `extraBytesCount`
+/// are occupied yet.
+export function reserveMemory(extraBytesCount: number) {
+    reserve(extraBytesCount);
+}
+
+export * from "./math";
+export * from "./dynamics";
+export * from "./geometry";
+export * from "./pipeline";
+export * from "./init";
+export * from "./control";

packages/rapier2d/src/geometry/broad_phase.ts

@@ -0,0 +1,520 @@
+import {RawBroadPhase, RawRayColliderIntersection} from "../raw";
+import {RigidBodyHandle, RigidBodySet} from "../dynamics";
+import {ColliderSet} from "./collider_set";
+import {Ray, RayColliderHit, RayColliderIntersection} from "./ray";
+import {InteractionGroups} from "./interaction_groups";
+import {ColliderHandle} from "./collider";
+import {Rotation, RotationOps, Vector, VectorOps} from "../math";
+import {Shape} from "./shape";
+import {PointColliderProjection} from "./point";
+import {ColliderShapeCastHit} from "./toi";
+import {QueryFilterFlags} from "../pipeline";
+import {NarrowPhase} from "./narrow_phase";
+
+/**
+ * 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 class BroadPhase {
+    raw: RawBroadPhase;
+
+    /**
+     * Release the WASM memory occupied by this broad-phase.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    constructor(raw?: RawBroadPhase) {
+        this.raw = raw || new RawBroadPhase();
+    }
+
+    /**
+     * Find the closest intersection between a ray and a set of collider.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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.
+     */
+    public castRay(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        ray: Ray,
+        maxToi: number,
+        solid: boolean,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ): RayColliderHit | null {
+        let rawOrig = VectorOps.intoRaw(ray.origin);
+        let rawDir = VectorOps.intoRaw(ray.dir);
+        let result = RayColliderHit.fromRaw(
+            colliders,
+            this.raw.castRay(
+                narrowPhase.raw,
+                bodies.raw,
+                colliders.raw,
+                rawOrig,
+                rawDir,
+                maxToi,
+                solid,
+                filterFlags,
+                filterGroups,
+                filterExcludeCollider,
+                filterExcludeRigidBody,
+                filterPredicate,
+            ),
+        );
+
+        rawOrig.free();
+        rawDir.free();
+
+        return result;
+    }
+
+    /**
+     * Find the closest intersection between a ray and a set of collider.
+     *
+     * This also computes the normal at the hit point.
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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.
+     */
+    public castRayAndGetNormal(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        ray: Ray,
+        maxToi: number,
+        solid: boolean,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ): RayColliderIntersection | null {
+        let rawOrig = VectorOps.intoRaw(ray.origin);
+        let rawDir = VectorOps.intoRaw(ray.dir);
+        let result = RayColliderIntersection.fromRaw(
+            colliders,
+            this.raw.castRayAndGetNormal(
+                narrowPhase.raw,
+                bodies.raw,
+                colliders.raw,
+                rawOrig,
+                rawDir,
+                maxToi,
+                solid,
+                filterFlags,
+                filterGroups,
+                filterExcludeCollider,
+                filterExcludeRigidBody,
+                filterPredicate,
+            ),
+        );
+
+        rawOrig.free();
+        rawDir.free();
+
+        return result;
+    }
+
+    /**
+     * Cast a ray and collects all the intersections between a ray and the scene.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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.
+     */
+    public intersectionsWithRay(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        ray: Ray,
+        maxToi: number,
+        solid: boolean,
+        callback: (intersect: RayColliderIntersection) => boolean,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ) {
+        let rawOrig = VectorOps.intoRaw(ray.origin);
+        let rawDir = VectorOps.intoRaw(ray.dir);
+        let rawCallback = (rawInter: RawRayColliderIntersection) => {
+            return callback(
+                RayColliderIntersection.fromRaw(colliders, rawInter),
+            );
+        };
+
+        this.raw.intersectionsWithRay(
+            narrowPhase.raw,
+            bodies.raw,
+            colliders.raw,
+            rawOrig,
+            rawDir,
+            maxToi,
+            solid,
+            rawCallback,
+            filterFlags,
+            filterGroups,
+            filterExcludeCollider,
+            filterExcludeRigidBody,
+            filterPredicate,
+        );
+
+        rawOrig.free();
+        rawDir.free();
+    }
+
+    /**
+     * Gets the handle of up to one collider intersecting the given shape.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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.
+     */
+    public intersectionWithShape(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        shapePos: Vector,
+        shapeRot: Rotation,
+        shape: Shape,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ): ColliderHandle | null {
+        let rawPos = VectorOps.intoRaw(shapePos);
+        let rawRot = RotationOps.intoRaw(shapeRot);
+        let rawShape = shape.intoRaw();
+        let result = this.raw.intersectionWithShape(
+            narrowPhase.raw,
+            bodies.raw,
+            colliders.raw,
+            rawPos,
+            rawRot,
+            rawShape,
+            filterFlags,
+            filterGroups,
+            filterExcludeCollider,
+            filterExcludeRigidBody,
+            filterPredicate,
+        );
+
+        rawPos.free();
+        rawRot.free();
+        rawShape.free();
+
+        return result;
+    }
+
+    /**
+     * Find the projection of a point on the closest collider.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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.
+     */
+    public projectPoint(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        point: Vector,
+        solid: boolean,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ): PointColliderProjection | null {
+        let rawPoint = VectorOps.intoRaw(point);
+        let result = PointColliderProjection.fromRaw(
+            colliders,
+            this.raw.projectPoint(
+                narrowPhase.raw,
+                bodies.raw,
+                colliders.raw,
+                rawPoint,
+                solid,
+                filterFlags,
+                filterGroups,
+                filterExcludeCollider,
+                filterExcludeRigidBody,
+                filterPredicate,
+            ),
+        );
+
+        rawPoint.free();
+
+        return result;
+    }
+
+    /**
+     * Find the projection of a point on the closest collider.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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.
+     */
+    public projectPointAndGetFeature(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        point: Vector,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ): PointColliderProjection | null {
+        let rawPoint = VectorOps.intoRaw(point);
+        let result = PointColliderProjection.fromRaw(
+            colliders,
+            this.raw.projectPointAndGetFeature(
+                narrowPhase.raw,
+                bodies.raw,
+                colliders.raw,
+                rawPoint,
+                filterFlags,
+                filterGroups,
+                filterExcludeCollider,
+                filterExcludeRigidBody,
+                filterPredicate,
+            ),
+        );
+
+        rawPoint.free();
+
+        return result;
+    }
+
+    /**
+     * Find all the colliders containing the given point.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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`.
+     */
+    public intersectionsWithPoint(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        point: Vector,
+        callback: (handle: ColliderHandle) => boolean,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ) {
+        let rawPoint = VectorOps.intoRaw(point);
+
+        this.raw.intersectionsWithPoint(
+            narrowPhase.raw,
+            bodies.raw,
+            colliders.raw,
+            rawPoint,
+            callback,
+            filterFlags,
+            filterGroups,
+            filterExcludeCollider,
+            filterExcludeRigidBody,
+            filterPredicate,
+        );
+
+        rawPoint.free();
+    }
+
+    /**
+     * 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).
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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.
+     */
+    public castShape(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        shapePos: Vector,
+        shapeRot: Rotation,
+        shapeVel: Vector,
+        shape: Shape,
+        targetDistance: number,
+        maxToi: number,
+        stopAtPenetration: boolean,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ): ColliderShapeCastHit | null {
+        let rawPos = VectorOps.intoRaw(shapePos);
+        let rawRot = RotationOps.intoRaw(shapeRot);
+        let rawVel = VectorOps.intoRaw(shapeVel);
+        let rawShape = shape.intoRaw();
+
+        let result = ColliderShapeCastHit.fromRaw(
+            colliders,
+            this.raw.castShape(
+                narrowPhase.raw,
+                bodies.raw,
+                colliders.raw,
+                rawPos,
+                rawRot,
+                rawVel,
+                rawShape,
+                targetDistance,
+                maxToi,
+                stopAtPenetration,
+                filterFlags,
+                filterGroups,
+                filterExcludeCollider,
+                filterExcludeRigidBody,
+                filterPredicate,
+            ),
+        );
+
+        rawPos.free();
+        rawRot.free();
+        rawVel.free();
+        rawShape.free();
+
+        return result;
+    }
+
+    /**
+     * Retrieve all the colliders intersecting the given shape.
+     *
+     * @param colliders - The set of colliders taking part in this pipeline.
+     * @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`.
+     */
+    public intersectionsWithShape(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        shapePos: Vector,
+        shapeRot: Rotation,
+        shape: Shape,
+        callback: (handle: ColliderHandle) => boolean,
+        filterFlags?: QueryFilterFlags,
+        filterGroups?: InteractionGroups,
+        filterExcludeCollider?: ColliderHandle,
+        filterExcludeRigidBody?: RigidBodyHandle,
+        filterPredicate?: (collider: ColliderHandle) => boolean,
+    ) {
+        let rawPos = VectorOps.intoRaw(shapePos);
+        let rawRot = RotationOps.intoRaw(shapeRot);
+        let rawShape = shape.intoRaw();
+
+        this.raw.intersectionsWithShape(
+            narrowPhase.raw,
+            bodies.raw,
+            colliders.raw,
+            rawPos,
+            rawRot,
+            rawShape,
+            callback,
+            filterFlags,
+            filterGroups,
+            filterExcludeCollider,
+            filterExcludeRigidBody,
+            filterPredicate,
+        );
+
+        rawPos.free();
+        rawRot.free();
+        rawShape.free();
+    }
+
+    /**
+     * 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.
+     */
+    public collidersWithAabbIntersectingAabb(
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        aabbCenter: Vector,
+        aabbHalfExtents: Vector,
+        callback: (handle: ColliderHandle) => boolean,
+    ) {
+        let rawCenter = VectorOps.intoRaw(aabbCenter);
+        let rawHalfExtents = VectorOps.intoRaw(aabbHalfExtents);
+        this.raw.collidersWithAabbIntersectingAabb(
+            narrowPhase.raw,
+            bodies.raw,
+            colliders.raw,
+            rawCenter,
+            rawHalfExtents,
+            callback,
+        );
+        rawCenter.free();
+        rawHalfExtents.free();
+    }
+}

packages/rapier2d/src/geometry/collider_set.ts

@@ -0,0 +1,195 @@
+import {RawColliderSet} from "../raw";
+import {Coarena} from "../coarena";
+import {RotationOps, VectorOps} from "../math";
+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 class ColliderSet {
+    raw: RawColliderSet;
+    private map: Coarena<Collider>;
+
+    /**
+     * Release the WASM memory occupied by this collider set.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+
+        if (!!this.map) {
+            this.map.clear();
+        }
+        this.map = undefined;
+    }
+
+    constructor(raw?: RawColliderSet) {
+        this.raw = raw || new RawColliderSet();
+        this.map = new Coarena<Collider>();
+        // Initialize the map with the existing elements, if any.
+        if (raw) {
+            raw.forEachColliderHandle((handle: ColliderHandle) => {
+                this.map.set(handle, new Collider(this, handle, null));
+            });
+        }
+    }
+
+    /** @internal */
+    public castClosure<Res>(
+        f?: (collider: Collider) => Res,
+    ): (handle: ColliderHandle) => Res | undefined {
+        return (handle) => {
+            if (!!f) {
+                return f(this.get(handle));
+            } else {
+                return undefined;
+            }
+        };
+    }
+
+    /** @internal */
+    public finalizeDeserialization(bodies: RigidBodySet) {
+        this.map.forEach((collider) =>
+            collider.finalizeDeserialization(bodies),
+        );
+    }
+
+    /**
+     * 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.
+     */
+    public createCollider(
+        bodies: RigidBodySet,
+        desc: ColliderDesc,
+        parentHandle: RigidBodyHandle,
+    ): Collider {
+        let hasParent = parentHandle != undefined && parentHandle != null;
+
+        if (hasParent && isNaN(parentHandle))
+            throw Error(
+                "Cannot create a collider with a parent rigid-body handle that is not a number.",
+            );
+
+        let rawShape = desc.shape.intoRaw();
+        let rawTra = VectorOps.intoRaw(desc.translation);
+        let rawRot = RotationOps.intoRaw(desc.rotation);
+        let rawCom = VectorOps.intoRaw(desc.centerOfMass);
+
+
+        let handle = this.raw.createCollider(
+            desc.enabled,
+            rawShape,
+            rawTra,
+            rawRot,
+            desc.massPropsMode,
+            desc.mass,
+            rawCom,
+            desc.principalAngularInertia,
+            desc.density,
+            desc.friction,
+            desc.restitution,
+            desc.frictionCombineRule,
+            desc.restitutionCombineRule,
+            desc.isSensor,
+            desc.collisionGroups,
+            desc.solverGroups,
+            desc.activeCollisionTypes,
+            desc.activeHooks,
+            desc.activeEvents,
+            desc.contactForceEventThreshold,
+            desc.contactSkin,
+            hasParent,
+            hasParent ? parentHandle : 0,
+            bodies.raw,
+        );
+
+        rawShape.free();
+        rawTra.free();
+        rawRot.free();
+        rawCom.free();
+
+
+        let parent = hasParent ? bodies.get(parentHandle) : null;
+        let collider = new Collider(this, handle, parent, desc.shape);
+        this.map.set(handle, collider);
+        return 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.
+     */
+    public remove(
+        handle: ColliderHandle,
+        islands: IslandManager,
+        bodies: RigidBodySet,
+        wakeUp: boolean,
+    ) {
+        this.raw.remove(handle, islands.raw, bodies.raw, wakeUp);
+        this.unmap(handle);
+    }
+
+    /**
+     * Internal function, do not call directly.
+     * @param handle
+     */
+    public unmap(handle: ImpulseJointHandle) {
+        this.map.delete(handle);
+    }
+
+    /**
+     * Gets the rigid-body with the given handle.
+     *
+     * @param handle - The handle of the rigid-body to retrieve.
+     */
+    public get(handle: ColliderHandle): Collider | null {
+        return this.map.get(handle);
+    }
+
+    /**
+     * The number of colliders on this set.
+     */
+    public len(): number {
+        return this.map.len();
+    }
+
+    /**
+     * Does this set contain a collider with the given handle?
+     *
+     * @param handle - The collider handle to check.
+     */
+    public contains(handle: ColliderHandle): boolean {
+        return this.get(handle) != null;
+    }
+
+    /**
+     * Applies the given closure to each collider contained by this set.
+     *
+     * @param f - The closure to apply.
+     */
+    public forEach(f: (collider: Collider) => void) {
+        this.map.forEach(f);
+    }
+
+    /**
+     * Gets all colliders in the list.
+     *
+     * @returns collider list.
+     */
+    public getAll(): Collider[] {
+        return this.map.getAll();
+    }
+}

packages/rapier2d/src/geometry/contact.ts

@@ -0,0 +1,62 @@
+import {Vector, VectorOps} from "../math";
+import {RawShapeContact} from "../raw";
+
+/**
+ * The contact info between two shapes.
+ */
+export 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,
+    ) {
+        this.distance = dist;
+        this.point1 = point1;
+        this.point2 = point2;
+        this.normal1 = normal1;
+        this.normal2 = normal2;
+    }
+
+    public static fromRaw(raw: RawShapeContact): ShapeContact {
+        if (!raw) return null;
+
+        const result = new ShapeContact(
+            raw.distance(),
+            VectorOps.fromRaw(raw.point1()),
+            VectorOps.fromRaw(raw.point2()),
+            VectorOps.fromRaw(raw.normal1()),
+            VectorOps.fromRaw(raw.normal2()),
+        );
+        raw.free();
+        return result;
+    }
+}

packages/rapier2d/src/geometry/feature.ts

@@ -0,0 +1,6 @@
+export enum FeatureType {
+    Vertex,
+    Face,
+    Unknown,
+}
+

packages/rapier2d/src/geometry/index.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";

packages/rapier2d/src/geometry/interaction_groups.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 type InteractionGroups = number;

packages/rapier2d/src/geometry/narrow_phase.ts

@@ -0,0 +1,192 @@
+import {RawNarrowPhase, RawContactManifold} from "../raw";
+import {ColliderHandle} from "./collider";
+import {Vector, VectorOps} 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 class NarrowPhase {
+    raw: RawNarrowPhase;
+    tempManifold: TempContactManifold;
+
+    /**
+     * Release the WASM memory occupied by this narrow-phase.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    constructor(raw?: RawNarrowPhase) {
+        this.raw = raw || new RawNarrowPhase();
+        this.tempManifold = new TempContactManifold(null);
+    }
+
+    /**
+     * 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`.
+     */
+    public contactPairsWith(
+        collider1: ColliderHandle,
+        f: (collider2: ColliderHandle) => void,
+    ) {
+        this.raw.contact_pairs_with(collider1, f);
+    }
+
+    /**
+     * Enumerates all the colliders intersecting the given colliders, assuming one of them
+     * is a sensor.
+     */
+    public intersectionPairsWith(
+        collider1: ColliderHandle,
+        f: (collider2: ColliderHandle) => void,
+    ) {
+        this.raw.intersection_pairs_with(collider1, f);
+    }
+
+    /**
+     * 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`.
+     */
+    public contactPair(
+        collider1: ColliderHandle,
+        collider2: ColliderHandle,
+        f: (manifold: TempContactManifold, flipped: boolean) => void,
+    ) {
+        const rawPair = this.raw.contact_pair(collider1, collider2);
+
+        if (!!rawPair) {
+            const flipped = rawPair.collider1() != collider1;
+
+            let i;
+            for (i = 0; i < rawPair.numContactManifolds(); ++i) {
+                this.tempManifold.raw = rawPair.contactManifold(i);
+                if (!!this.tempManifold.raw) {
+                    f(this.tempManifold, flipped);
+                }
+
+                // SAFETY: The RawContactManifold stores a raw pointer that will be invalidated
+                //         at the next timestep. So we must be sure to free the pair here
+                //         to avoid unsoundness in the Rust code.
+                this.tempManifold.free();
+            }
+            rawPair.free();
+        }
+    }
+
+    /**
+     * 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.
+     */
+    public intersectionPair(
+        collider1: ColliderHandle,
+        collider2: ColliderHandle,
+    ): boolean {
+        return this.raw.intersection_pair(collider1, collider2);
+    }
+}
+
+export class TempContactManifold {
+    raw: RawContactManifold;
+
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    constructor(raw: RawContactManifold) {
+        this.raw = raw;
+    }
+
+    public normal(): Vector {
+        return VectorOps.fromRaw(this.raw.normal());
+    }
+
+    public localNormal1(): Vector {
+        return VectorOps.fromRaw(this.raw.local_n1());
+    }
+
+    public localNormal2(): Vector {
+        return VectorOps.fromRaw(this.raw.local_n2());
+    }
+
+    public subshape1(): number {
+        return this.raw.subshape1();
+    }
+
+    public subshape2(): number {
+        return this.raw.subshape2();
+    }
+
+    public numContacts(): number {
+        return this.raw.num_contacts();
+    }
+
+    public localContactPoint1(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.contact_local_p1(i));
+    }
+
+    public localContactPoint2(i: number): Vector | null {
+        return VectorOps.fromRaw(this.raw.contact_local_p2(i));
+    }
+
+    public contactDist(i: number): number {
+        return this.raw.contact_dist(i);
+    }
+
+    public contactFid1(i: number): number {
+        return this.raw.contact_fid1(i);
+    }
+
+    public contactFid2(i: number): number {
+        return this.raw.contact_fid2(i);
+    }
+
+    public contactImpulse(i: number): number {
+        return this.raw.contact_impulse(i);
+    }
+
+    public contactTangentImpulse(i: number): number {
+        return this.raw.contact_tangent_impulse(i);
+    }
+
+
+    public numSolverContacts(): number {
+        return this.raw.num_solver_contacts();
+    }
+
+    public solverContactPoint(i: number): Vector {
+        return VectorOps.fromRaw(this.raw.solver_contact_point(i));
+    }
+
+    public solverContactDist(i: number): number {
+        return this.raw.solver_contact_dist(i);
+    }
+
+    public solverContactFriction(i: number): number {
+        return this.raw.solver_contact_friction(i);
+    }
+
+    public solverContactRestitution(i: number): number {
+        return this.raw.solver_contact_restitution(i);
+    }
+
+    public solverContactTangentVelocity(i: number): Vector {
+        return VectorOps.fromRaw(this.raw.solver_contact_tangent_velocity(i));
+    }
+}

packages/rapier2d/src/geometry/point.ts

@@ -0,0 +1,98 @@
+import {Collider, ColliderHandle} from "./collider";
+import {Vector, VectorOps} from "../math";
+import {
+    RawFeatureType,
+    RawPointColliderProjection,
+    RawPointProjection,
+} from "../raw";
+import {FeatureType} from "./feature";
+import {ColliderSet} from "./collider_set";
+
+/**
+ * The projection of a point on a collider.
+ */
+export 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) {
+        this.point = point;
+        this.isInside = isInside;
+    }
+
+    public static fromRaw(raw: RawPointProjection): PointProjection {
+        if (!raw) return null;
+
+        const result = new PointProjection(
+            VectorOps.fromRaw(raw.point()),
+            raw.isInside(),
+        );
+        raw.free();
+        return result;
+    }
+}
+
+/**
+ * The projection of a point on a collider (includes the collider handle).
+ */
+export 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.Unknown;
+
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined = undefined;
+
+    constructor(
+        collider: Collider,
+        point: Vector,
+        isInside: boolean,
+        featureType?: FeatureType,
+        featureId?: number,
+    ) {
+        this.collider = collider;
+        this.point = point;
+        this.isInside = isInside;
+        if (featureId !== undefined) this.featureId = featureId;
+        if (featureType !== undefined) this.featureType = featureType;
+    }
+
+    public static fromRaw(
+        colliderSet: ColliderSet,
+        raw: RawPointColliderProjection,
+    ): PointColliderProjection {
+        if (!raw) return null;
+
+        const result = new PointColliderProjection(
+            colliderSet.get(raw.colliderHandle()),
+            VectorOps.fromRaw(raw.point()),
+            raw.isInside(),
+            raw.featureType() as number as FeatureType,
+            raw.featureId(),
+        );
+        raw.free();
+        return result;
+    }
+}

packages/rapier2d/src/geometry/ray.ts

@@ -0,0 +1,189 @@
+import {Vector, VectorOps} from "../math";
+import {
+    RawFeatureType,
+    RawRayColliderIntersection,
+    RawRayColliderHit,
+    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 class Ray {
+    /**
+     * The starting point of the ray.
+     */
+    public origin: Vector;
+    /**
+     * The direction of propagation of the ray.
+     */
+    public 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) {
+        this.origin = origin;
+        this.dir = dir;
+    }
+
+    public pointAt(t: number): Vector {
+        return {
+            x: this.origin.x + this.dir.x * t,
+            y: this.origin.y + this.dir.y * t,
+        };
+    }
+}
+
+/**
+ * The intersection between a ray and a collider.
+ */
+export 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 * timeOfImpact`.
+     */
+    timeOfImpact: 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.Unknown;
+
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined = undefined;
+
+    constructor(
+        timeOfImpact: number,
+        normal: Vector,
+        featureType?: FeatureType,
+        featureId?: number,
+    ) {
+        this.timeOfImpact = timeOfImpact;
+        this.normal = normal;
+        if (featureId !== undefined) this.featureId = featureId;
+        if (featureType !== undefined) this.featureType = featureType;
+    }
+
+    public static fromRaw(raw: RawRayIntersection): RayIntersection {
+        if (!raw) return null;
+
+        const result = new RayIntersection(
+            raw.time_of_impact(),
+            VectorOps.fromRaw(raw.normal()),
+            raw.featureType() as number as FeatureType,
+            raw.featureId(),
+        );
+        raw.free();
+        return result;
+    }
+}
+
+/**
+ * The intersection between a ray and a collider (includes the collider handle).
+ */
+export 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 * timeOfImpact`.
+     */
+    timeOfImpact: 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.Unknown;
+
+    /**
+     * The id of the geometric feature the point was projected on.
+     */
+    featureId: number | undefined = undefined;
+
+    constructor(
+        collider: Collider,
+        timeOfImpact: number,
+        normal: Vector,
+        featureType?: FeatureType,
+        featureId?: number,
+    ) {
+        this.collider = collider;
+        this.timeOfImpact = timeOfImpact;
+        this.normal = normal;
+        if (featureId !== undefined) this.featureId = featureId;
+        if (featureType !== undefined) this.featureType = featureType;
+    }
+
+    public static fromRaw(
+        colliderSet: ColliderSet,
+        raw: RawRayColliderIntersection,
+    ): RayColliderIntersection {
+        if (!raw) return null;
+
+        const result = new RayColliderIntersection(
+            colliderSet.get(raw.colliderHandle()),
+            raw.time_of_impact(),
+            VectorOps.fromRaw(raw.normal()),
+            raw.featureType() as number as FeatureType,
+            raw.featureId(),
+        );
+        raw.free();
+        return result;
+    }
+}
+
+/**
+ * The time of impact between a ray and a collider.
+ */
+export class RayColliderHit {
+    /**
+     * 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 * timeOfImpact`.
+     */
+    timeOfImpact: number;
+
+    constructor(collider: Collider, timeOfImpact: number) {
+        this.collider = collider;
+        this.timeOfImpact = timeOfImpact;
+    }
+
+    public static fromRaw(
+        colliderSet: ColliderSet,
+        raw: RawRayColliderHit,
+    ): RayColliderHit {
+        if (!raw) return null;
+
+        const result = new RayColliderHit(
+            colliderSet.get(raw.colliderHandle()),
+            raw.timeOfImpact(),
+        );
+        raw.free();
+        return result;
+    }
+}

packages/rapier2d/src/geometry/toi.ts

@@ -0,0 +1,105 @@
+import {Collider} from "./collider";
+import {Vector, VectorOps} from "../math";
+import {RawShapeCastHit, RawColliderShapeCastHit} from "../raw";
+import {ColliderSet} from "./collider_set";
+
+/**
+ * The intersection between a ray and a collider.
+ */
+export class ShapeCastHit {
+    /**
+     * The time of impact of the two shapes.
+     */
+    time_of_impact: 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(
+        time_of_impact: number,
+        witness1: Vector,
+        witness2: Vector,
+        normal1: Vector,
+        normal2: Vector,
+    ) {
+        this.time_of_impact = time_of_impact;
+        this.witness1 = witness1;
+        this.witness2 = witness2;
+        this.normal1 = normal1;
+        this.normal2 = normal2;
+    }
+
+    public static fromRaw(
+        colliderSet: ColliderSet,
+        raw: RawShapeCastHit,
+    ): ShapeCastHit {
+        if (!raw) return null;
+
+        const result = new ShapeCastHit(
+            raw.time_of_impact(),
+            VectorOps.fromRaw(raw.witness1()),
+            VectorOps.fromRaw(raw.witness2()),
+            VectorOps.fromRaw(raw.normal1()),
+            VectorOps.fromRaw(raw.normal2()),
+        );
+        raw.free();
+        return result;
+    }
+}
+
+/**
+ * The intersection between a ray and a collider.
+ */
+export class ColliderShapeCastHit extends ShapeCastHit {
+    /**
+     * The handle of the collider hit by the ray.
+     */
+    collider: Collider;
+
+    constructor(
+        collider: Collider,
+        time_of_impact: number,
+        witness1: Vector,
+        witness2: Vector,
+        normal1: Vector,
+        normal2: Vector,
+    ) {
+        super(time_of_impact, witness1, witness2, normal1, normal2);
+        this.collider = collider;
+    }
+
+    public static fromRaw(
+        colliderSet: ColliderSet,
+        raw: RawColliderShapeCastHit,
+    ): ColliderShapeCastHit {
+        if (!raw) return null;
+
+        const result = new ColliderShapeCastHit(
+            colliderSet.get(raw.colliderHandle()),
+            raw.time_of_impact(),
+            VectorOps.fromRaw(raw.witness1()),
+            VectorOps.fromRaw(raw.witness2()),
+            VectorOps.fromRaw(raw.normal1()),
+            VectorOps.fromRaw(raw.normal2()),
+        );
+        raw.free();
+        return result;
+    }
+}

packages/rapier2d/src/index.ts

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

packages/rapier2d/src/init.ts

@@ -0,0 +1,60 @@
+/**
+ * RAPIER initialization module with dynamic WASM loading support.
+ * RAPIER 初始化模块，支持动态 WASM 加载。
+ */
+
+import wasmInit from "../pkg/rapier_wasm2d";
+
+/**
+ * Input types for WASM initialization.
+ * WASM 初始化的输入类型。
+ */
+export type InitInput =
+    | RequestInfo         // URL string or Request object
+    | URL                 // URL object
+    | Response            // Fetch Response object
+    | BufferSource        // ArrayBuffer or TypedArray
+    | WebAssembly.Module; // Pre-compiled module
+
+let initialized = false;
+
+/**
+ * Initializes RAPIER.
+ * Has to be called and awaited before using any library methods.
+ *
+ * 初始化 RAPIER。
+ * 必须在使用任何库方法之前调用并等待。
+ *
+ * @param input - WASM source (required). Can be URL, Response, ArrayBuffer, etc.
+ *                WASM 源（必需）。可以是 URL、Response、ArrayBuffer 等。
+ *
+ * @example
+ * // Load from URL | 从 URL 加载
+ * await RAPIER.init('wasm/rapier_wasm2d_bg.wasm');
+ *
+ * @example
+ * // Load from fetch response | 从 fetch 响应加载
+ * const response = await fetch('wasm/rapier_wasm2d_bg.wasm');
+ * await RAPIER.init(response);
+ *
+ * @example
+ * // Load from ArrayBuffer | 从 ArrayBuffer 加载
+ * const buffer = await fetch('wasm/rapier_wasm2d_bg.wasm').then(r => r.arrayBuffer());
+ * await RAPIER.init(buffer);
+ */
+export async function init(input?: InitInput): Promise<void> {
+    if (initialized) {
+        return;
+    }
+
+    await wasmInit(input);
+    initialized = true;
+}
+
+/**
+ * Check if RAPIER is already initialized.
+ * 检查 RAPIER 是否已初始化。
+ */
+export function isInitialized(): boolean {
+    return initialized;
+}

packages/rapier2d/src/math.ts

@@ -0,0 +1,72 @@
+import {RawVector, RawRotation} from "./raw";
+
+export interface Vector {
+    x: number;
+    y: number;
+}
+
+/**
+ * A 2D vector.
+ */
+export class Vector2 implements Vector {
+    x: number;
+    y: number;
+
+    constructor(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+    }
+}
+
+export class VectorOps {
+    public static new(x: number, y: number): Vector {
+        return new Vector2(x, y);
+    }
+
+    public static zeros(): Vector {
+        return VectorOps.new(0.0, 0.0);
+    }
+
+    // FIXME: type ram: RawVector?
+    public static fromRaw(raw: RawVector): Vector | null {
+        if (!raw) return null;
+
+        let res = VectorOps.new(raw.x, raw.y);
+        raw.free();
+        return res;
+    }
+
+    public static intoRaw(v: Vector): RawVector {
+        return new RawVector(v.x, v.y);
+    }
+
+    public static copy(out: Vector, input: Vector) {
+        out.x = input.x;
+        out.y = input.y;
+    }
+}
+
+/**
+ * A rotation angle in radians.
+ */
+export type Rotation = number;
+
+export class RotationOps {
+    public static identity(): number {
+        return 0.0;
+    }
+
+    public static fromRaw(raw: RawRotation): Rotation | null {
+        if (!raw) return null;
+
+        let res = raw.angle;
+        raw.free();
+        return res;
+    }
+
+    public static intoRaw(angle: Rotation): RawRotation {
+        return RawRotation.fromAngle(angle);
+    }
+}
+
+

packages/rapier2d/src/pipeline/debug_render_pipeline.ts

@@ -0,0 +1,85 @@
+import {RawDebugRenderPipeline} from "../raw";
+import {Vector, VectorOps} from "../math";
+import {
+    IntegrationParameters,
+    IslandManager,
+    ImpulseJointSet,
+    MultibodyJointSet,
+    RigidBodySet,
+} from "../dynamics";
+import {BroadPhase, Collider, ColliderSet, NarrowPhase} from "../geometry";
+import {QueryFilterFlags} from "./query_pipeline";
+
+/**
+ * The vertex and color buffers for debug-redering the physics scene.
+ */
+export 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]]`.
+     */
+    public vertices: Float32Array;
+    /**
+     * The color buffer. There is one color per vertex, and each color
+     * has four consecutive components (in RGBA format).
+     */
+    public colors: Float32Array;
+
+    constructor(vertices: Float32Array, colors: Float32Array) {
+        this.vertices = vertices;
+        this.colors = colors;
+    }
+}
+
+/**
+ * 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 class DebugRenderPipeline {
+    raw: RawDebugRenderPipeline;
+    public vertices: Float32Array;
+    public colors: Float32Array;
+
+    /**
+     * Release the WASM memory occupied by this serialization pipeline.
+     */
+    free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+        this.vertices = undefined;
+        this.colors = undefined;
+    }
+
+    constructor(raw?: RawDebugRenderPipeline) {
+        this.raw = raw || new RawDebugRenderPipeline();
+    }
+
+    public render(
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        impulse_joints: ImpulseJointSet,
+        multibody_joints: MultibodyJointSet,
+        narrow_phase: NarrowPhase,
+        filterFlags?: QueryFilterFlags,
+        filterPredicate?: (collider: Collider) => boolean,
+    ) {
+        this.raw.render(
+            bodies.raw,
+            colliders.raw,
+            impulse_joints.raw,
+            multibody_joints.raw,
+            narrow_phase.raw,
+            filterFlags,
+            colliders.castClosure(filterPredicate),
+        );
+        this.vertices = this.raw.vertices();
+        this.colors = this.raw.colors();
+    }
+}

packages/rapier2d/src/pipeline/event_queue.ts

@@ -0,0 +1,158 @@
+import {RawContactForceEvent, RawEventQueue} from "../raw";
+import {RigidBodyHandle} from "../dynamics";
+import {Collider, ColliderHandle} from "../geometry";
+import {Vector, VectorOps} from "../math";
+
+/**
+ * Flags indicating what events are enabled for colliders.
+ */
+export enum ActiveEvents {
+    NONE = 0,
+    /**
+     * Enable collision events.
+     */
+    COLLISION_EVENTS = 0b0001,
+    /**
+     * Enable contact force events.
+     */
+    CONTACT_FORCE_EVENTS = 0b0010,
+}
+
+/**
+ * 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 class TempContactForceEvent {
+    raw: RawContactForceEvent;
+
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    /**
+     * The first collider involved in the contact.
+     */
+    public collider1(): ColliderHandle {
+        return this.raw.collider1();
+    }
+
+    /**
+     * The second collider involved in the contact.
+     */
+    public collider2(): ColliderHandle {
+        return this.raw.collider2();
+    }
+
+    /**
+     * The sum of all the forces between the two colliders.
+     */
+    public totalForce(): Vector {
+        return VectorOps.fromRaw(this.raw.total_force());
+    }
+
+    /**
+     * 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.
+     */
+    public totalForceMagnitude(): number {
+        return this.raw.total_force_magnitude();
+    }
+
+    /**
+     * The world-space (unit) direction of the force with strongest magnitude.
+     */
+    public maxForceDirection(): Vector {
+        return VectorOps.fromRaw(this.raw.max_force_direction());
+    }
+
+    /**
+     * The magnitude of the largest force at a contact point of this contact pair.
+     */
+    public maxForceMagnitude(): number {
+        return this.raw.max_force_magnitude();
+    }
+}
+
+/**
+ * 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 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) {
+        this.raw = raw || new RawEventQueue(autoDrain);
+    }
+
+    /**
+     * Release the WASM memory occupied by this event-queue.
+     */
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    /**
+     * 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).
+     */
+    public drainCollisionEvents(
+        f: (
+            handle1: ColliderHandle,
+            handle2: ColliderHandle,
+            started: boolean,
+        ) => void,
+    ) {
+        this.raw.drainCollisionEvents(f);
+    }
+
+    /**
+     * 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.
+     */
+    public drainContactForceEvents(f: (event: TempContactForceEvent) => void) {
+        let event = new TempContactForceEvent();
+        this.raw.drainContactForceEvents((raw: RawContactForceEvent) => {
+            event.raw = raw;
+            f(event);
+            event.free();
+        });
+    }
+
+    /**
+     * Removes all events contained by this collector
+     */
+    public clear() {
+        this.raw.clear();
+    }
+}

packages/rapier2d/src/pipeline/index.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";

packages/rapier2d/src/pipeline/physics_hooks.ts

@@ -0,0 +1,54 @@
+import {RigidBodyHandle} from "../dynamics";
+import {ColliderHandle} from "../geometry";
+
+export enum ActiveHooks {
+    NONE = 0,
+    FILTER_CONTACT_PAIRS = 0b0001,
+    FILTER_INTERSECTION_PAIRS = 0b0010,
+    // MODIFY_SOLVER_CONTACTS = 0b0100, /* Not supported yet in JS. */
+}
+
+export enum SolverFlags {
+    EMPTY = 0b000,
+    COMPUTE_IMPULSE = 0b001,
+}
+
+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;
+}

packages/rapier2d/src/pipeline/physics_pipeline.ts

@@ -0,0 +1,85 @@
+import {RawPhysicsPipeline} from "../raw";
+import {Vector, VectorOps} from "../math";
+import {
+    IntegrationParameters,
+    ImpulseJointSet,
+    MultibodyJointSet,
+    RigidBodyHandle,
+    RigidBodySet,
+    CCDSolver,
+    IslandManager,
+} from "../dynamics";
+import {
+    BroadPhase,
+    ColliderHandle,
+    ColliderSet,
+    NarrowPhase,
+} from "../geometry";
+import {EventQueue} from "./event_queue";
+import {PhysicsHooks} from "./physics_hooks";
+
+export class PhysicsPipeline {
+    raw: RawPhysicsPipeline;
+
+    public free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    constructor(raw?: RawPhysicsPipeline) {
+        this.raw = raw || new RawPhysicsPipeline();
+    }
+
+    public step(
+        gravity: Vector,
+        integrationParameters: IntegrationParameters,
+        islands: IslandManager,
+        broadPhase: BroadPhase,
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        impulseJoints: ImpulseJointSet,
+        multibodyJoints: MultibodyJointSet,
+        ccdSolver: CCDSolver,
+        eventQueue?: EventQueue,
+        hooks?: PhysicsHooks,
+    ) {
+        let rawG = VectorOps.intoRaw(gravity);
+
+        if (!!eventQueue) {
+            this.raw.stepWithEvents(
+                rawG,
+                integrationParameters.raw,
+                islands.raw,
+                broadPhase.raw,
+                narrowPhase.raw,
+                bodies.raw,
+                colliders.raw,
+                impulseJoints.raw,
+                multibodyJoints.raw,
+                ccdSolver.raw,
+                eventQueue.raw,
+                hooks,
+                !!hooks ? hooks.filterContactPair : null,
+                !!hooks ? hooks.filterIntersectionPair : null,
+            );
+        } else {
+            this.raw.step(
+                rawG,
+                integrationParameters.raw,
+                islands.raw,
+                broadPhase.raw,
+                narrowPhase.raw,
+                bodies.raw,
+                colliders.raw,
+                impulseJoints.raw,
+                multibodyJoints.raw,
+                ccdSolver.raw,
+            );
+        }
+
+        rawG.free();
+    }
+}

packages/rapier2d/src/pipeline/query_pipeline.ts

@@ -0,0 +1,57 @@
+import {RawRayColliderIntersection} from "../raw";
+import {
+    ColliderHandle,
+    ColliderSet,
+    InteractionGroups,
+    PointColliderProjection,
+    Ray,
+    RayColliderIntersection,
+    RayColliderHit,
+    Shape,
+    ColliderShapeCastHit,
+} from "../geometry";
+import {IslandManager, RigidBodyHandle, RigidBodySet} from "../dynamics";
+import {Rotation, RotationOps, Vector, VectorOps} from "../math";
+
+// NOTE: must match the bits in the QueryFilterFlags on the Rust side.
+/**
+ * Flags for excluding whole sets of colliders from a scene query.
+ */
+export enum QueryFilterFlags {
+    /**
+     * Exclude from the query any collider attached to a fixed rigid-body and colliders with no rigid-body attached.
+     */
+    EXCLUDE_FIXED = 0b0000_0001,
+    /**
+     * Exclude from the query any collider attached to a dynamic rigid-body.
+     */
+    EXCLUDE_KINEMATIC = 0b0000_0010,
+    /**
+     * Exclude from the query any collider attached to a kinematic rigid-body.
+     */
+    EXCLUDE_DYNAMIC = 0b0000_0100,
+    /**
+     * Exclude from the query any collider that is a sensor.
+     */
+    EXCLUDE_SENSORS = 0b0000_1000,
+    /**
+     * Exclude from the query any collider that is not a sensor.
+     */
+    EXCLUDE_SOLIDS = 0b0001_0000,
+    /**
+     * Excludes all colliders not attached to a dynamic rigid-body.
+     */
+    ONLY_DYNAMIC = QueryFilterFlags.EXCLUDE_FIXED |
+        QueryFilterFlags.EXCLUDE_KINEMATIC,
+    /**
+     * Excludes all colliders not attached to a kinematic rigid-body.
+     */
+    ONLY_KINEMATIC = QueryFilterFlags.EXCLUDE_DYNAMIC |
+        QueryFilterFlags.EXCLUDE_FIXED,
+    /**
+     * Exclude all colliders attached to a non-fixed rigid-body
+     * (this will not exclude colliders not attached to any rigid-body).
+     */
+    ONLY_FIXED = QueryFilterFlags.EXCLUDE_DYNAMIC |
+        QueryFilterFlags.EXCLUDE_KINEMATIC,
+}

packages/rapier2d/src/pipeline/serialization_pipeline.ts

@@ -0,0 +1,84 @@
+import {RawSerializationPipeline} from "../raw";
+import {Vector, VectorOps} from "../math";
+import {
+    IntegrationParameters,
+    IslandManager,
+    ImpulseJointSet,
+    MultibodyJointSet,
+    RigidBodySet,
+} 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 class SerializationPipeline {
+    raw: RawSerializationPipeline;
+
+    /**
+     * Release the WASM memory occupied by this serialization pipeline.
+     */
+    free() {
+        if (!!this.raw) {
+            this.raw.free();
+        }
+        this.raw = undefined;
+    }
+
+    constructor(raw?: RawSerializationPipeline) {
+        this.raw = raw || new 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.
+     */
+    public serializeAll(
+        gravity: Vector,
+        integrationParameters: IntegrationParameters,
+        islands: IslandManager,
+        broadPhase: BroadPhase,
+        narrowPhase: NarrowPhase,
+        bodies: RigidBodySet,
+        colliders: ColliderSet,
+        impulseJoints: ImpulseJointSet,
+        multibodyJoints: MultibodyJointSet,
+    ): Uint8Array {
+        let rawGra = VectorOps.intoRaw(gravity);
+
+        const res = this.raw.serializeAll(
+            rawGra,
+            integrationParameters.raw,
+            islands.raw,
+            broadPhase.raw,
+            narrowPhase.raw,
+            bodies.raw,
+            colliders.raw,
+            impulseJoints.raw,
+            multibodyJoints.raw,
+        );
+        rawGra.free();
+
+        return res;
+    }
+
+    /**
+     * Deserialize the complete physics state from a single byte array.
+     *
+     * @param data - The byte array to deserialize.
+     */
+    public deserializeAll(data: Uint8Array): World {
+        return World.fromRaw(this.raw.deserializeAll(data));
+    }
+}

packages/rapier2d/src/raw.ts

@@ -0,0 +1 @@
+export * from "../pkg/rapier_wasm2d";

packages/rapier2d/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src",
+        "strict": false,
+        "strictNullChecks": false
+    },
+    "include": ["src/**/*", "pkg/*.d.ts"]
+}

packages/rapier2d/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+    entry: ["src/index.ts"],
+    format: ["esm"],
+    dts: true,
+    sourcemap: true,
+    clean: true,
+    external: ["../pkg/rapier_wasm2d.js"],
+});