@woosh/meep-engine 2.138.20 → 2.140.0

package/src/engine/physics/integration/integrate_position.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Integrate `transform.position` and `transform.rotation` from the body's
+ * current linear and angular velocity over a step `dt`. Static bodies are
+ * not touched.
+ *
+ * The trailing six arguments are the body's *pseudo-velocity*: the
+ * position-pass output from the constraint solver (Catto split-impulse).
+ * Pseudo-velocity exists only inside the step — it's folded into the
+ * integration so the position update reflects depth correction, then
+ * implicitly discarded. The body's persistent `linearVelocity` /
+ * `angularVelocity` (which carry restitution + warm-start across steps)
+ * are never contaminated by it.
+ *
+ * Callers with no position-pass output should pass zeros for the six
+ * pseudo arguments — folding zero is free (one add per axis).
+ *
+ * KinematicPosition bodies are treated like Dynamic for the position
+ * update — if the gameplay code is driving them, their velocity is
+ * whatever the user wrote (typically zero); the step is effectively a
+ * no-op in that case. KinematicVelocity bodies advance under their
+ * user-set velocity.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform
+ * @param {number} dt
+ * @param {number} ps_lin_x pseudo-linear-velocity x (0 when no contacts)
+ * @param {number} ps_lin_y
+ * @param {number} ps_lin_z
+ * @param {number} ps_ang_x pseudo-angular-velocity x (0 when no contacts)
+ * @param {number} ps_ang_y
+ * @param {number} ps_ang_z
+ */
+export function integrate_position(rb: RigidBody, transform: Transform, dt: number, ps_lin_x: number, ps_lin_y: number, ps_lin_z: number, ps_ang_x: number, ps_ang_y: number, ps_ang_z: number): void;
+//# sourceMappingURL=integrate_position.d.ts.map

package/src/engine/physics/integration/integrate_position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrate_position.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_position.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4EARW,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,QA2ChB"}

package/src/engine/physics/integration/integrate_position.js

@@ -0,0 +1,79 @@
+import { BodyKind } from "../ecs/BodyKind.js";
+import { quat_integrate } from "./quat_integrate.js";
+
+const scratch_q = new Float64Array(4);
+
+/**
+ * Integrate `transform.position` and `transform.rotation` from the body's
+ * current linear and angular velocity over a step `dt`. Static bodies are
+ * not touched.
+ *
+ * The trailing six arguments are the body's *pseudo-velocity*: the
+ * position-pass output from the constraint solver (Catto split-impulse).
+ * Pseudo-velocity exists only inside the step — it's folded into the
+ * integration so the position update reflects depth correction, then
+ * implicitly discarded. The body's persistent `linearVelocity` /
+ * `angularVelocity` (which carry restitution + warm-start across steps)
+ * are never contaminated by it.
+ *
+ * Callers with no position-pass output should pass zeros for the six
+ * pseudo arguments — folding zero is free (one add per axis).
+ *
+ * KinematicPosition bodies are treated like Dynamic for the position
+ * update — if the gameplay code is driving them, their velocity is
+ * whatever the user wrote (typically zero); the step is effectively a
+ * no-op in that case. KinematicVelocity bodies advance under their
+ * user-set velocity.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform
+ * @param {number} dt
+ * @param {number} ps_lin_x pseudo-linear-velocity x (0 when no contacts)
+ * @param {number} ps_lin_y
+ * @param {number} ps_lin_z
+ * @param {number} ps_ang_x pseudo-angular-velocity x (0 when no contacts)
+ * @param {number} ps_ang_y
+ * @param {number} ps_ang_z
+ */
+export function integrate_position(
+    rb, transform, dt,
+    ps_lin_x, ps_lin_y, ps_lin_z,
+    ps_ang_x, ps_ang_y, ps_ang_z,
+) {
+    if (rb.kind === BodyKind.Static) {
+        return;
+    }
+
+    const lv = rb.linearVelocity;
+    const p = transform.position;
+
+    // Combined integration velocity: persistent + pseudo. The pseudo
+    // contribution exists only for this step and never lands in `lv`.
+    const vx = lv[0] + ps_lin_x;
+    const vy = lv[1] + ps_lin_y;
+    const vz = lv[2] + ps_lin_z;
+
+    // Direct reads via typed-array index; the write goes through .set() so
+    // Transform's onChanged subscribers (matrix recompose, parent/child sync,
+    // viewport position, fog-of-war reveal) fire once per body per step.
+    p.set(
+        p[0] + vx * dt,
+        p[1] + vy * dt,
+        p[2] + vz * dt
+    );
+
+    const av = rb.angularVelocity;
+    const wx = av[0] + ps_ang_x;
+    const wy = av[1] + ps_ang_y;
+    const wz = av[2] + ps_ang_z;
+    if (wx !== 0 || wy !== 0 || wz !== 0) {
+        const q = transform.rotation;
+        quat_integrate(
+            scratch_q,
+            q[0], q[1], q[2], q[3],
+            wx, wy, wz,
+            dt
+        );
+        q.set(scratch_q[0], scratch_q[1], scratch_q[2], scratch_q[3]);
+    }
+}

package/src/engine/physics/integration/integrate_velocity.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Semi-implicit Euler velocity integration for a single rigid body.
+ *
+ * For Dynamic bodies:
+ *  - gravity (scaled by `gravityScale`) and the accumulated force are converted
+ *    to a velocity delta via `1/mass`,
+ *  - accumulated torque is converted to angular acceleration via the
+ *    world-frame inverse inertia (R · diag(I_local) · R^T applied to τ),
+ *  - linear and angular damping are applied as a stable implicit decay
+ *    `v *= 1 / (1 + d·dt)` (Box2D / Bullet recipe — never goes negative, no
+ *    `exp()` call on the hot path),
+ *  - the force / torque accumulators are zeroed afterwards.
+ *
+ * Kinematic and Static bodies are skipped — their velocity is the
+ * user / animation system's responsibility.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {number} gx world gravity x
+ * @param {number} gy world gravity y
+ * @param {number} gz world gravity z
+ * @param {number} dt step size in seconds
+ */
+export function integrate_velocity(rb: RigidBody, transform: Transform, gx: number, gy: number, gz: number, dt: number): void;
+/**
+ * Apply the accumulated force / torque to velocity over a step `dt`, then
+ * zero the accumulators. Gravity and damping are NOT applied here.
+ *
+ * The "once per outer step" half of the TGS integrator: a user force is a
+ * per-frame budget that must land in full exactly once, independent of
+ * substep count. Gravity is the continuous field re-applied every substep
+ * by {@link integrate_velocity_gravity}.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {number} dt full outer-step size in seconds
+ */
+export function integrate_velocity_forces(rb: RigidBody, transform: Transform, dt: number): void;
+/**
+ * Apply gravity and velocity damping over a (sub)step `dt`. Does NOT touch
+ * the force / torque accumulators (consumed once by
+ * {@link integrate_velocity_forces}).
+ *
+ * The "every substep" half of the TGS integrator. Per substep the body sees
+ * only `g·h` of gravity, which the per-substep contact warm-start + solve
+ * cancels exactly — keeping a resting stack at zero velocity. Damping is the
+ * stable implicit decay `v *= 1/(1 + d·dt)` applied at the substep `dt`.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  (unused; signature symmetry with the family)
+ * @param {number} gx @param {number} gy @param {number} gz world gravity
+ * @param {number} dt sub-step size in seconds
+ */
+export function integrate_velocity_gravity(rb: RigidBody, transform: Transform, gx: number, gy: number, gz: number, dt: number): void;
+//# sourceMappingURL=integrate_velocity.d.ts.map

package/src/engine/physics/integration/integrate_velocity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrate_velocity.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_velocity.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,4EALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoDhB;AAED;;;;;;;;;;;;GAYG;AACH,mFAFW,MAAM,QA6BhB;AAED;;;;;;;;;;;;;;GAcG;AACH,oFAHW,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,QAwBhB"}

package/src/engine/physics/integration/integrate_velocity.js

@@ -0,0 +1,160 @@
+import { BodyKind } from "../ecs/BodyKind.js";
+import { world_inverse_inertia_apply } from "../inertia/world_inverse_inertia.js";
+
+const scratch_angular = new Float64Array(3);
+
+/**
+ * Semi-implicit Euler velocity integration for a single rigid body.
+ *
+ * For Dynamic bodies:
+ *  - gravity (scaled by `gravityScale`) and the accumulated force are converted
+ *    to a velocity delta via `1/mass`,
+ *  - accumulated torque is converted to angular acceleration via the
+ *    world-frame inverse inertia (R · diag(I_local) · R^T applied to τ),
+ *  - linear and angular damping are applied as a stable implicit decay
+ *    `v *= 1 / (1 + d·dt)` (Box2D / Bullet recipe — never goes negative, no
+ *    `exp()` call on the hot path),
+ *  - the force / torque accumulators are zeroed afterwards.
+ *
+ * Kinematic and Static bodies are skipped — their velocity is the
+ * user / animation system's responsibility.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {number} gx world gravity x
+ * @param {number} gy world gravity y
+ * @param {number} gz world gravity z
+ * @param {number} dt step size in seconds
+ */
+export function integrate_velocity(rb, transform, gx, gy, gz, dt) {
+    const af = rb.accumulatedForce;
+    const at = rb.accumulatedTorque;
+
+    if (rb.kind !== BodyKind.Dynamic) {
+        // Direct indexing — no observer listens to body-internal accumulators.
+        af[0] = 0; af[1] = 0; af[2] = 0;
+        at[0] = 0; at[1] = 0; at[2] = 0;
+        return;
+    }
+
+    const inv_m = rb.mass > 0 ? 1 / rb.mass : 0;
+    const gs = rb.gravityScale;
+
+    // Linear velocity update: v += (F * invM + g * gravityScale) * dt
+    const lv = rb.linearVelocity;
+    let lvx = lv[0] + (af[0] * inv_m + gx * gs) * dt;
+    let lvy = lv[1] + (af[1] * inv_m + gy * gs) * dt;
+    let lvz = lv[2] + (af[2] * inv_m + gz * gs) * dt;
+
+    if (rb.linearDamping > 0) {
+        const k = 1 / (1 + rb.linearDamping * dt);
+        lvx *= k;
+        lvy *= k;
+        lvz *= k;
+    }
+    lv[0] = lvx; lv[1] = lvy; lv[2] = lvz;
+
+    // Angular velocity update: ω += I_world⁻¹ · τ · dt
+    const av = rb.angularVelocity;
+    let avx = av[0];
+    let avy = av[1];
+    let avz = av[2];
+    if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
+        world_inverse_inertia_apply(scratch_angular, 0, rb.inverseInertiaLocal, transform.rotation, at[0], at[1], at[2]);
+        avx += scratch_angular[0] * dt;
+        avy += scratch_angular[1] * dt;
+        avz += scratch_angular[2] * dt;
+    }
+
+    if (rb.angularDamping > 0) {
+        const k = 1 / (1 + rb.angularDamping * dt);
+        avx *= k;
+        avy *= k;
+        avz *= k;
+    }
+    av[0] = avx; av[1] = avy; av[2] = avz;
+
+    af[0] = 0; af[1] = 0; af[2] = 0;
+    at[0] = 0; at[1] = 0; at[2] = 0;
+}
+
+/**
+ * Apply the accumulated force / torque to velocity over a step `dt`, then
+ * zero the accumulators. Gravity and damping are NOT applied here.
+ *
+ * The "once per outer step" half of the TGS integrator: a user force is a
+ * per-frame budget that must land in full exactly once, independent of
+ * substep count. Gravity is the continuous field re-applied every substep
+ * by {@link integrate_velocity_gravity}.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  used to rotate body-frame inertia into world
+ * @param {number} dt full outer-step size in seconds
+ */
+export function integrate_velocity_forces(rb, transform, dt) {
+    const af = rb.accumulatedForce;
+    const at = rb.accumulatedTorque;
+
+    if (rb.kind !== BodyKind.Dynamic) {
+        af[0] = 0; af[1] = 0; af[2] = 0;
+        at[0] = 0; at[1] = 0; at[2] = 0;
+        return;
+    }
+
+    const inv_m = rb.mass > 0 ? 1 / rb.mass : 0;
+
+    const lv = rb.linearVelocity;
+    lv[0] += af[0] * inv_m * dt;
+    lv[1] += af[1] * inv_m * dt;
+    lv[2] += af[2] * inv_m * dt;
+
+    if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
+        world_inverse_inertia_apply(scratch_angular, 0, rb.inverseInertiaLocal, transform.rotation, at[0], at[1], at[2]);
+        const av = rb.angularVelocity;
+        av[0] += scratch_angular[0] * dt;
+        av[1] += scratch_angular[1] * dt;
+        av[2] += scratch_angular[2] * dt;
+    }
+
+    af[0] = 0; af[1] = 0; af[2] = 0;
+    at[0] = 0; at[1] = 0; at[2] = 0;
+}
+
+/**
+ * Apply gravity and velocity damping over a (sub)step `dt`. Does NOT touch
+ * the force / torque accumulators (consumed once by
+ * {@link integrate_velocity_forces}).
+ *
+ * The "every substep" half of the TGS integrator. Per substep the body sees
+ * only `g·h` of gravity, which the per-substep contact warm-start + solve
+ * cancels exactly — keeping a resting stack at zero velocity. Damping is the
+ * stable implicit decay `v *= 1/(1 + d·dt)` applied at the substep `dt`.
+ *
+ * @param {RigidBody} rb
+ * @param {Transform} transform  (unused; signature symmetry with the family)
+ * @param {number} gx @param {number} gy @param {number} gz world gravity
+ * @param {number} dt sub-step size in seconds
+ */
+export function integrate_velocity_gravity(rb, transform, gx, gy, gz, dt) {
+    if (rb.kind !== BodyKind.Dynamic) {
+        return;
+    }
+
+    const gs = rb.gravityScale;
+    const lv = rb.linearVelocity;
+    let lvx = lv[0] + gx * gs * dt;
+    let lvy = lv[1] + gy * gs * dt;
+    let lvz = lv[2] + gz * gs * dt;
+
+    if (rb.linearDamping > 0) {
+        const k = 1 / (1 + rb.linearDamping * dt);
+        lvx *= k; lvy *= k; lvz *= k;
+    }
+    lv[0] = lvx; lv[1] = lvy; lv[2] = lvz;
+
+    if (rb.angularDamping > 0) {
+        const av = rb.angularVelocity;
+        const k = 1 / (1 + rb.angularDamping * dt);
+        av[0] *= k; av[1] *= k; av[2] *= k;
+    }
+}

package/src/engine/physics/integration/quat_integrate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Advance a unit quaternion `q` by an angular velocity `omega` over a step `dt`,
+ * using the first-order formula
+ *
+ *     dq/dt = 0.5 * Omega(omega) * q
+ *
+ * where `Omega(omega)` is the pure-quaternion `(omega_x, omega_y, omega_z, 0)`.
+ * Result is renormalised so the output stays unit.
+ *
+ * This is the standard semi-implicit angular integrator (Catto GDC 2009 et al.).
+ * For typical game-physics step sizes (1/60 s) and angular speeds, the
+ * first-order error is dominated by the renormalisation projection back to the
+ * unit sphere — closed-form exp via axis-angle would only matter for very large
+ * `|omega|·dt`.
+ *
+ * @param {number[]|Float64Array|Quaternion} result_q  destination (may alias `qx..qw`)
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} omega_x
+ * @param {number} omega_y
+ * @param {number} omega_z
+ * @param {number} dt
+ */
+export function quat_integrate(result_q: number[] | Float64Array | Quaternion, qx: number, qy: number, qz: number, qw: number, omega_x: number, omega_y: number, omega_z: number, dt: number): void;
+//# sourceMappingURL=quat_integrate.d.ts.map

package/src/engine/physics/integration/quat_integrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat_integrate.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/quat_integrate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,yCAVW,MAAM,EAAE,GAAC,YAAY,aAAW,MAChC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,MACN,MAAM,QAsChB"}

package/src/engine/physics/integration/quat_integrate.js

@@ -0,0 +1,62 @@
+/**
+ * Advance a unit quaternion `q` by an angular velocity `omega` over a step `dt`,
+ * using the first-order formula
+ *
+ *     dq/dt = 0.5 * Omega(omega) * q
+ *
+ * where `Omega(omega)` is the pure-quaternion `(omega_x, omega_y, omega_z, 0)`.
+ * Result is renormalised so the output stays unit.
+ *
+ * This is the standard semi-implicit angular integrator (Catto GDC 2009 et al.).
+ * For typical game-physics step sizes (1/60 s) and angular speeds, the
+ * first-order error is dominated by the renormalisation projection back to the
+ * unit sphere — closed-form exp via axis-angle would only matter for very large
+ * `|omega|·dt`.
+ *
+ * @param {number[]|Float64Array|Quaternion} result_q  destination (may alias `qx..qw`)
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} omega_x
+ * @param {number} omega_y
+ * @param {number} omega_z
+ * @param {number} dt
+ */
+export function quat_integrate(
+    result_q,
+    qx, qy, qz, qw,
+    omega_x, omega_y, omega_z,
+    dt
+) {
+    const h = 0.5 * dt;
+
+    const dqx = h * (omega_x * qw + omega_y * qz - omega_z * qy);
+    const dqy = h * (omega_y * qw + omega_z * qx - omega_x * qz);
+    const dqz = h * (omega_z * qw + omega_x * qy - omega_y * qx);
+    const dqw = -h * (omega_x * qx + omega_y * qy + omega_z * qz);
+
+    let nx = qx + dqx;
+    let ny = qy + dqy;
+    let nz = qz + dqz;
+    let nw = qw + dqw;
+
+    // Renormalise. Using sqrt (which is bit-exact across IEEE-754 platforms)
+    // rather than the (3 - |q|²)/2 cheap-Newton trick — the latter biases
+    // length for non-unit inputs.
+    const norm_sqr = nx * nx + ny * ny + nz * nz + nw * nw;
+    if (norm_sqr > 0) {
+        const inv_len = 1 / Math.sqrt(norm_sqr);
+        nx *= inv_len;
+        ny *= inv_len;
+        nz *= inv_len;
+        nw *= inv_len;
+    } else {
+        nx = 0; ny = 0; nz = 0; nw = 1;
+    }
+
+    result_q[0] = nx;
+    result_q[1] = ny;
+    result_q[2] = nz;
+    result_q[3] = nw;
+}

package/src/engine/physics/island/IslandBuilder.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Partitions this frame's awake dynamic bodies + touched non-sensor contacts
+ * into connected components ("islands") via union-find. The solver iterates
+ * each island independently (so impulses converge inside an island without
+ * waiting for global passes) and the sleep test will eventually use island
+ * granularity for atomic whole-island sleep.
+ *
+ * Static and Kinematic bodies are not merged into islands — they act as
+ * constraint anchors. A 1000-block stack on a static floor is therefore one
+ * island of 1000 dynamic bodies, not 1001 — the floor anchors the island but
+ * does not enlarge it. Multiple separate piles all resting on the same static
+ * floor remain *separate* islands so each can sleep/wake independently.
+ *
+ * Sensor contacts are skipped entirely: they don't transmit constraint
+ * forces, so two bodies linked only by a sensor pair are not in the same
+ * structural island.
+ *
+ * Determinism contract:
+ *  - Union-find uses union-by-min-index + path halving, so the canonical
+ *    root of any component is the smallest body index of any of its members.
+ *  - Islands are emitted sorted ascending by root index.
+ *  - Bodies within an island are emitted sorted ascending by body index.
+ *  - Contacts within an island are emitted sorted ascending by manifold slot id.
+ *
+ * Output layout is CSR-like — `body_offsets[i]..body_offsets[i+1]` indexes
+ * into `body_data` for island `i`, similarly for contacts.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class IslandBuilder {
+    /**
+     * @param {RigidBody} rb
+     * @param {Array} collider_list collider list for the body (or undefined)
+     * @returns {boolean}
+     * @private
+     */
+    private static __body_is_sensor;
+    /**
+     * Union-find parent table, indexed by body index (NOT packed id).
+     * Sized to `storage.high_water_mark` at `build` time; reallocated by
+     * doubling when the body pool grows past current capacity.
+     * @type {Uint32Array}
+     */
+    parent: Uint32Array;
+    /**
+     * Per-body island id. `island_of_body[idx] === -1` means the body
+     * is not in any island this frame (static, kinematic, or unallocated).
+     * @type {Int32Array}
+     */
+    island_of_body: Int32Array;
+    /**
+     * Number of islands this frame.
+     * @type {number}
+     */
+    island_count: number;
+    /**
+     * CSR offsets into `body_data`. Length is `island_count + 1`. Bodies
+     * for island `i` live in `body_data[body_offsets[i]..body_offsets[i+1])`.
+     * @type {Uint32Array}
+     */
+    body_offsets: Uint32Array;
+    /**
+     * Flattened body indices, grouped by island, sorted ascending within
+     * each island.
+     * @type {Uint32Array}
+     */
+    body_data: Uint32Array;
+    /**
+     * Total number of body entries across all islands (= sum of island sizes).
+     * @type {number}
+     */
+    body_total: number;
+    /**
+     * CSR offsets into `contact_data`. Length is `island_count + 1`.
+     * Manifold slot ids for island `i` live in
+     * `contact_data[contact_offsets[i]..contact_offsets[i+1])`.
+     * @type {Uint32Array}
+     */
+    contact_offsets: Uint32Array;
+    /**
+     * Flattened manifold slot ids, grouped by island, sorted ascending
+     * within each island.
+     * @type {Uint32Array}
+     */
+    contact_data: Uint32Array;
+    /**
+     * Total number of contact entries across all islands.
+     * @type {number}
+     */
+    contact_total: number;
+    /**
+     * Scratch: root body index → island id, or -1 if unassigned.
+     * Sized in lockstep with `parent`.
+     * @private
+     * @type {Int32Array}
+     */
+    private __root_to_island;
+    /**
+     * Scratch: list of distinct root indices observed this frame, used
+     * to sort them ascending before assigning island ids.
+     * @private
+     * @type {Uint32Array}
+     */
+    private __scratch_roots;
+    /**
+     * Scratch write-cursors, one per island.
+     * @private
+     * @type {Uint32Array}
+     */
+    private __cursors;
+    /**
+     * (Re)build islands from `manifolds`' currently-touched non-sensor slots
+     * and the bodies in `storage`'s awake list.
+     *
+     * @param {BodyStorage} storage
+     * @param {ManifoldStore} manifolds
+     * @param {RigidBody[]} bodies sparse, indexed by body index
+     * @param {Array[]} body_collider_lists sparse, indexed by body index
+     */
+    build(storage: BodyStorage, manifolds: ManifoldStore, bodies: RigidBody[], body_collider_lists: any[][]): void;
+    /**
+     * Fill `body_offsets` + `body_data` with awake dynamic bodies grouped
+     * by island, sorted ascending within each island.
+     * @private
+     */
+    private __build_body_csr;
+    /**
+     * Fill `contact_offsets` + `contact_data` with touched non-sensor manifold
+     * slot ids grouped by island. A contact belongs to its dynamic
+     * participant's island (if both sides are dynamic they share an island
+     * by construction). Static-vs-static contacts are skipped.
+     * @private
+     */
+    private __build_contact_csr;
+    /**
+     * Resolve which island a manifold slot belongs to.
+     *
+     * Returns `-1` if the manifold is not touched this frame, is a sensor
+     * pair, or both bodies are non-dynamic (static-static, which the solver
+     * wouldn't act on anyway).
+     *
+     * @private
+     */
+    private __island_of_slot;
+    /**
+     * @private
+     * @param {number} n
+     */
+    private __ensure_body_capacity;
+    /**
+     * @private
+     * @param {number} n
+     */
+    private __ensure_island_count_capacity;
+    /**
+     * @private
+     * @param {number} n
+     */
+    private __ensure_body_data_capacity;
+    /**
+     * @private
+     * @param {number} n
+     */
+    private __ensure_contact_data_capacity;
+}
+//# sourceMappingURL=IslandBuilder.d.ts.map

package/src/engine/physics/island/IslandBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IslandBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/island/IslandBuilder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAyFI;;;;;OAKG;IACH,gCAUC;IAtGG;;;;;OAKG;IACH,QAFU,WAAW,CAEY;IAEjC;;;;OAIG;IACH,gBAFU,UAAU,CAEoB;IAExC;;;OAGG;IACH,cAFU,MAAM,CAEK;IAErB;;;;OAIG;IACH,cAFU,WAAW,CAEiB;IAEtC;;;;OAIG;IACH,WAFU,WAAW,CAEe;IAEpC;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;;OAKG;IACH,iBAFU,WAAW,CAEoB;IAEzC;;;;OAIG;IACH,cAFU,WAAW,CAEkB;IAEvC;;;OAGG;IACH,eAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,yBAA0C;IAE1C;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;OAIG;IACH,kBAAmC;IAqBvC;;;;;;;;OAQG;IACH,8DAHW,WAAW,uBACX,OAAO,QAuEjB;IAED;;;;OAIG;IACH,yBA+CC;IAED;;;;;;OAMG;IACH,4BAwCC;IAED;;;;;;;;OAQG;IACH,yBAcC;IAID;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,uCAOC;IAED;;;OAGG;IACH,oCAIC;IAED;;;OAGG;IACH,uCAIC;CACJ"}