@woosh/meep-engine 2.138.20 → 2.140.0

package/src/engine/physics/broadphase/PairList.js

@@ -0,0 +1,97 @@
+/**
+ * Growable Uint32Array list of `(idA, idB)` body-id pairs. Stride is 2 words
+ * per pair. `count` tracks the number of pairs; capacity grows by doubling.
+ *
+ * No allocation happens during {@link push} until capacity is exceeded. The
+ * intended usage is `clear()` at the top of each step and `push` for each
+ * candidate pair encountered during broadphase.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PairList {
+
+    /**
+     * @param {number} [initial_capacity] pairs (not words)
+     */
+    constructor(initial_capacity = 64) {
+        this.__capacity = Math.max(1, initial_capacity);
+        this.__count = 0;
+        this.__data = new Uint32Array(this.__capacity * 2);
+    }
+
+    /**
+     * @returns {number} number of pairs currently stored
+     */
+    get count() {
+        return this.__count;
+    }
+
+    /**
+     * @returns {number} pair capacity (doubles on overflow)
+     */
+    get capacity() {
+        return this.__capacity;
+    }
+
+    /**
+     * Raw word buffer. `data[i*2 + 0]` is idA, `data[i*2 + 1]` is idB for the
+     * `i`-th pair, where `i < count`. Exposed for hot-loop iteration; valid
+     * until the next {@link push} that triggers a grow.
+     * @returns {Uint32Array}
+     */
+    get data() {
+        return this.__data;
+    }
+
+    /**
+     * Reset to empty without releasing capacity.
+     */
+    clear() {
+        this.__count = 0;
+    }
+
+    /**
+     * Append a pair. Caller is expected to have already canonicalised
+     * `idA < idB` if symmetric semantics are needed.
+     *
+     * @param {number} idA
+     * @param {number} idB
+     */
+    push(idA, idB) {
+        if (this.__count === this.__capacity) {
+            this.__grow();
+        }
+        const off = this.__count * 2;
+        this.__data[off] = idA;
+        this.__data[off + 1] = idB;
+        this.__count++;
+    }
+
+    /**
+     * @param {number} i pair index, `[0, count)`
+     * @returns {number}
+     */
+    get_a(i) {
+        return this.__data[i * 2];
+    }
+
+    /**
+     * @param {number} i pair index, `[0, count)`
+     * @returns {number}
+     */
+    get_b(i) {
+        return this.__data[i * 2 + 1];
+    }
+
+    /**
+     * @private
+     */
+    __grow() {
+        const new_capacity = this.__capacity << 1;
+        const next = new Uint32Array(new_capacity * 2);
+        next.set(this.__data);
+        this.__data = next;
+        this.__capacity = new_capacity;
+    }
+}

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Compute the inflated world AABB of a shape under a pose, padded by both a
+ * constant slack and a velocity-proportional swept extent. The output is the
+ * thing to hand to `BVH#node_move_aabb`.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape
+ * @param {Transform} transform
+ * @param {number} vx world linear velocity x
+ * @param {number} vy world linear velocity y
+ * @param {number} vz world linear velocity z
+ * @param {number} dt step size
+ */
+export function compute_fat_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform, vx: number, vy: number, vz: number, dt: number): void;
+//# sourceMappingURL=compute_fat_world_aabb.d.ts.map

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,oDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA6BhB"}

package/src/engine/physics/broadphase/compute_fat_world_aabb.js

@@ -0,0 +1,61 @@
+import { aabb3_transform_oriented } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
+
+const scratch_local = new Float64Array(6);
+
+/**
+ * Constant inflation applied to a world AABB so a small motion doesn't churn
+ * the broadphase. Tuned to Box2D / Bullet conventions.
+ * @type {number}
+ */
+const FAT_LINEAR = 0.05;
+
+/**
+ * Per-second-of-velocity inflation. Two seconds of motion is a generous look-ahead
+ * — `node_move_aabb` only re-inserts when the inflated AABB no longer encloses
+ * the actual one, so this is a hint, not an upper bound.
+ * @type {number}
+ */
+const FAT_VELOCITY_MULTIPLIER = 2;
+
+/**
+ * Compute the inflated world AABB of a shape under a pose, padded by both a
+ * constant slack and a velocity-proportional swept extent. The output is the
+ * thing to hand to `BVH#node_move_aabb`.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape
+ * @param {Transform} transform
+ * @param {number} vx world linear velocity x
+ * @param {number} vy world linear velocity y
+ * @param {number} vz world linear velocity z
+ * @param {number} dt step size
+ */
+export function compute_fat_world_aabb(
+    result, result_offset,
+    shape, transform,
+    vx, vy, vz, dt
+) {
+    shape.compute_bounding_box(scratch_local);
+
+    const p = transform.position;
+    const q = transform.rotation;
+
+    aabb3_transform_oriented(
+        result, result_offset,
+        scratch_local[0], scratch_local[1], scratch_local[2],
+        scratch_local[3], scratch_local[4], scratch_local[5],
+        p.x, p.y, p.z,
+        q.x, q.y, q.z, q.w
+    );
+
+    const speed = Math.sqrt(vx * vx + vy * vy + vz * vz);
+    const pad = FAT_LINEAR + FAT_VELOCITY_MULTIPLIER * speed * dt;
+
+    result[result_offset] -= pad;
+    result[result_offset + 1] -= pad;
+    result[result_offset + 2] -= pad;
+    result[result_offset + 3] += pad;
+    result[result_offset + 4] += pad;
+    result[result_offset + 5] += pad;
+}

package/src/engine/physics/broadphase/generate_pairs.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Iterate every awake body, query both BVHs from each of its attached
+ * collider leaves, dedupe via the {@link ManifoldStore}, optionally gate
+ * each candidate through a user-supplied filter, and append each surviving
+ * body-pair to `pair_list_out`.
+ *
+ * Compound-body aware: a body with multiple colliders has multiple BVH
+ * leaves (one per collider). Each leaf's AABB query may turn up the same
+ * other-body multiple times (across the multiple leaves on either side)
+ * but the per-slot touched flag collapses those into one entry in the
+ * canonical `(min, max)` pair list — narrowphase then resolves the
+ * collider-cross-product internally.
+ *
+ * Determinism: pair encounter order is fully determined by the awake-list
+ * order × per-body collider-list order × BVH leaf traversal order. All
+ * three are deterministic functions of the link/unlink sequence and the
+ * BVH state, so two worlds with the same scene history produce identical
+ * pair lists.
+ *
+ * @param {BodyStorage} storage
+ * @param {BVH} dynamic_bvh
+ * @param {BVH} static_bvh
+ * @param {ManifoldStore} manifolds
+ * @param {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>} body_collider_lists
+ * @param {PairList} pair_list_out cleared and filled
+ * @param {((idA: number, idB: number) => boolean) | null} pair_filter optional
+ *        gate. Returning `false` rejects the pair entirely — no manifold
+ *        slot, no narrowphase, no contact events. Existing cached
+ *        manifolds for a rejected pair time out naturally via the
+ *        manifold-store grace counter.
+ */
+export function generate_pairs(storage: BodyStorage, dynamic_bvh: BVH, static_bvh: BVH, manifolds: ManifoldStore, body_collider_lists: Array<Array<{
+    collider: Collider;
+    transform: Transform;
+    entity: number;
+    bvhNode: number;
+}>>, pair_list_out: PairList, pair_filter?: (idA: number, idB: number) => boolean): void;
+//# sourceMappingURL=generate_pairs.d.ts.map

package/src/engine/physics/broadphase/generate_pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uIARW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,+CAElF,MAAM,OAAO,MAAM,KAAK,OAAO,QAsEhD"}

package/src/engine/physics/broadphase/generate_pairs.js

@@ -0,0 +1,101 @@
+import { bvh_query_user_data_overlaps_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
+
+const scratch_aabb = new Float64Array(6);
+const candidates = new Uint32Array(1024);
+
+/**
+ * Iterate every awake body, query both BVHs from each of its attached
+ * collider leaves, dedupe via the {@link ManifoldStore}, optionally gate
+ * each candidate through a user-supplied filter, and append each surviving
+ * body-pair to `pair_list_out`.
+ *
+ * Compound-body aware: a body with multiple colliders has multiple BVH
+ * leaves (one per collider). Each leaf's AABB query may turn up the same
+ * other-body multiple times (across the multiple leaves on either side)
+ * but the per-slot touched flag collapses those into one entry in the
+ * canonical `(min, max)` pair list — narrowphase then resolves the
+ * collider-cross-product internally.
+ *
+ * Determinism: pair encounter order is fully determined by the awake-list
+ * order × per-body collider-list order × BVH leaf traversal order. All
+ * three are deterministic functions of the link/unlink sequence and the
+ * BVH state, so two worlds with the same scene history produce identical
+ * pair lists.
+ *
+ * @param {BodyStorage} storage
+ * @param {BVH} dynamic_bvh
+ * @param {BVH} static_bvh
+ * @param {ManifoldStore} manifolds
+ * @param {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>} body_collider_lists
+ * @param {PairList} pair_list_out cleared and filled
+ * @param {((idA: number, idB: number) => boolean) | null} pair_filter optional
+ *        gate. Returning `false` rejects the pair entirely — no manifold
+ *        slot, no narrowphase, no contact events. Existing cached
+ *        manifolds for a rejected pair time out naturally via the
+ *        manifold-store grace counter.
+ */
+export function generate_pairs(
+    storage,
+    dynamic_bvh,
+    static_bvh,
+    manifolds,
+    body_collider_lists,
+    pair_list_out,
+    pair_filter = null
+) {
+    pair_list_out.clear();
+
+    const awake_count = storage.awake_count;
+
+    for (let i = 0; i < awake_count; i++) {
+        const body_idx = storage.awake_at(i);
+        const list = body_collider_lists[body_idx];
+        if (list === undefined || list.length === 0) continue;
+
+        const gen = storage.generation_at(body_idx);
+        const my_packed = (body_idx << 8) | gen;
+
+        for (let k = 0; k < list.length; k++) {
+            const node = list[k].bvhNode;
+            dynamic_bvh.node_get_aabb(node, scratch_aabb);
+
+            // Dynamic ↔ Dynamic.
+            let n = bvh_query_user_data_overlaps_aabb(
+                candidates, 0,
+                dynamic_bvh,
+                scratch_aabb
+            );
+            for (let c = 0; c < n; c++) {
+                const other = candidates[c];
+                if (other === my_packed) continue;
+
+                const idA = my_packed < other ? my_packed : other;
+                const idB = my_packed < other ? other : my_packed;
+
+                const existing = manifolds.find(idA, idB);
+                if (existing !== -1 && manifolds.is_touched(existing)) continue;
+                if (pair_filter !== null && !pair_filter(idA, idB)) continue;
+                manifolds.acquire(idA, idB);
+                pair_list_out.push(idA, idB);
+            }
+
+            // Dynamic ↔ Static.
+            n = bvh_query_user_data_overlaps_aabb(
+                candidates, 0,
+                static_bvh,
+                scratch_aabb
+            );
+            for (let c = 0; c < n; c++) {
+                const other = candidates[c];
+                const idA = my_packed < other ? my_packed : other;
+                const idB = my_packed < other ? other : my_packed;
+
+                const existing = manifolds.find(idA, idB);
+                if (existing !== -1 && manifolds.is_touched(existing)) continue;
+                if (pair_filter !== null && !pair_filter(idA, idB)) continue;
+                manifolds.acquire(idA, idB);
+                pair_list_out.push(idA, idB);
+            }
+        }
+    }
+}

package/src/engine/physics/contact/ManifoldStore.d.ts

@@ -0,0 +1,299 @@
+/**
+ * Maximum contact points per manifold. Four is the universal industry choice
+ * (Bullet's btPersistentManifold, Box2D, Jolt) — enough to express stable
+ * face-on-face contact, small enough to fit inertia-driven solver passes.
+ * @type {number}
+ */
+export const MAX_CONTACTS_PER_MANIFOLD: number;
+/**
+ * Per-contact field stride in the data Float64Array.
+ *
+ * Layout per contact (all world-space):
+ *   0..2  : world_a    (contact point on body A's surface)
+ *   3..5  : world_b    (contact point on body B's surface)
+ *   6..8  : normal_w   (from B toward A)
+ *   9     : depth      (positive = penetration, negative = speculative gap)
+ *   10    : j_n        (accumulated normal impulse, warm-start)
+ *   11    : j_t1       (accumulated tangent impulse, axis 1)
+ *   12    : j_t2       (accumulated tangent impulse, axis 2)
+ *   13    : feature_id (uint32 packed as f64 — stable cross-frame ID of the
+ *                       geometric feature pair that produced this contact;
+ *                       0 means "no info, fall back to position matching")
+ *
+ * Solver uses `(world_a + world_b) * 0.5` as the application point; storing
+ * both surface points enables the per-frame warm-start matcher in the
+ * narrowphase to compare contact-point positions when feature_id is 0.
+ *
+ * @type {number}
+ */
+export const CONTACT_STRIDE: number;
+/**
+ * Per-contact feature_id offset within {@link CONTACT_STRIDE}.
+ * Exposed for the narrowphase matcher; solver code does not read this.
+ * @type {number}
+ */
+export const CONTACT_FEATURE_ID_OFFSET: number;
+/**
+ * Per-slot Float64 stride: room for {@link MAX_CONTACTS_PER_MANIFOLD} contacts.
+ * @type {number}
+ */
+export const SLOT_DATA_STRIDE: number;
+/**
+ * Sentinel for "no slot".
+ * @type {number}
+ */
+export const MANIFOLD_SLOT_ABSENT: number;
+/**
+ * Persistent contact-manifold cache keyed by canonical body-id pairs.
+ *
+ * Owns:
+ *  - the SoA `Float64Array` of contact points (per-slot stride 52),
+ *  - the small meta `Uint32Array` (bodyA, bodyB, packed flags + count),
+ *  - a {@link PairUint32Map} from `(idA, idB)` to slot id,
+ *  - a dense `__live_slots` array of currently-allocated slot ids,
+ *  - a min-heap-free-stack of released slot ids so reuse is deterministic.
+ *
+ * Lifecycle per simulation step:
+ *  1. Broadphase calls {@link acquire} for every encountered pair, which marks
+ *     each touched slot as "fresh this frame".
+ *  2. Narrowphase fills in contact points via {@link set_contact} /
+ *     {@link clear_contacts}.
+ *  3. End-of-step calls {@link advance_frame} to roll touched → prev_touched
+ *     and evict slots that have been untouched for {@link DEFAULT_GRACE}
+ *     consecutive frames.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ManifoldStore {
+    /**
+     * @param {number} [initial_capacity] slots
+     */
+    constructor(initial_capacity?: number);
+    __capacity: number;
+    __high_water: number;
+    __data: Float64Array;
+    __meta: Uint32Array;
+    __slot_axis: Float64Array;
+    __pair_index: PairUint32Map;
+    __live_slots: Uint32Array;
+    __live_pos: Int32Array;
+    __live_count: number;
+    __free_heap: Uint32Array;
+    __free_count: number;
+    /**
+     * @returns {number} number of currently-live slots
+     */
+    get count(): number;
+    /**
+     * @returns {number} total allocated slot capacity
+     */
+    get capacity(): number;
+    /**
+     * Look up a slot by canonical pair. Caller is responsible for ordering
+     * `(idA, idB)` such that the same pair always hashes the same way.
+     *
+     * @param {number} idA
+     * @param {number} idB
+     * @returns {number} slot id or {@link MANIFOLD_SLOT_ABSENT}
+     */
+    find(idA: number, idB: number): number;
+    /**
+     * Acquire a slot for the pair, creating one if absent, and mark it
+     * "touched this frame". Returns the slot id. Calling `acquire` twice in
+     * the same step on the same pair is a no-op for the second call.
+     *
+     * @param {number} idA
+     * @param {number} idB
+     * @returns {number} slot id
+     */
+    acquire(idA: number, idB: number): number;
+    /**
+     * @param {number} slot
+     * @returns {number} body A id stored at this slot
+     */
+    bodyA(slot: number): number;
+    /**
+     * @param {number} slot
+     * @returns {number}
+     */
+    bodyB(slot: number): number;
+    /**
+     * @param {number} slot
+     * @returns {number} 0..MAX_CONTACTS_PER_MANIFOLD
+     */
+    contact_count(slot: number): number;
+    /**
+     * @param {number} slot
+     * @returns {boolean}
+     */
+    is_touched(slot: number): boolean;
+    /**
+     * @param {number} slot
+     * @returns {boolean}
+     */
+    was_touched_prev(slot: number): boolean;
+    /**
+     * Iterate the dense list of currently-live slots without going through
+     * the pair map. `i` ranges `[0, count)`.
+     * @param {number} i
+     * @returns {number}
+     */
+    live_at(i: number): number;
+    /**
+     * Clear the contact list for a slot (counts go to zero, warm-start
+     * impulses also reset). Used when narrowphase determines the pair is
+     * separated this frame.
+     * @param {number} slot
+     */
+    clear_contacts(slot: number): void;
+    /**
+     * Reset the contact count to zero so the next `set_contact(slot, 0, …)`
+     * lands at index 0, but DO NOT zero the data slab. Warm-start impulses
+     * (`j_n`, `j_t1`, `j_t2`) at each contact slot survive — the subsequent
+     * `set_contact` calls only overwrite the first 10 floats (position,
+     * normal, depth) per contact.
+     *
+     * Use this when narrowphase determines the pair still has overlap and
+     * is about to refill the slot with the new frame's contacts. Use
+     * {@link clear_contacts} instead when the pair has genuinely separated
+     * and the cached impulses should be evicted.
+     *
+     * @param {number} slot
+     */
+    begin_refill(slot: number): void;
+    /**
+     * Write a contact point into a slot. Increments contact_count if `idx`
+     * exceeds the current count.
+     *
+     * Writes geometry (offsets 0..9) and the feature_id at offset 13.
+     * Deliberately does NOT touch the warm-start impulse fields (offsets
+     * 10..12) — the narrowphase match-and-merge pass uses this to refill
+     * a slot while preserving the cached impulses that the solver's
+     * warm-start needs.
+     *
+     * @param {number} slot
+     * @param {number} idx contact index in `[0, MAX_CONTACTS_PER_MANIFOLD)`
+     * @param {number} lax
+     * @param {number} lay
+     * @param {number} laz
+     * @param {number} lbx
+     * @param {number} lby
+     * @param {number} lbz
+     * @param {number} nx normal world x (B toward A)
+     * @param {number} ny
+     * @param {number} nz
+     * @param {number} depth
+     * @param {number} feature_id stable cross-frame identifier of the
+     *   geometric feature pair that produced this contact; 0 means
+     *   "no info, fall back to position matching"
+     */
+    set_contact(slot: number, idx: number, lax: number, lay: number, laz: number, lbx: number, lby: number, lbz: number, nx: number, ny: number, nz: number, depth: number, feature_id?: number): void;
+    /**
+     * Zero the warm-start impulse fields (j_n, j_t1, j_t2) for one contact
+     * index inside a slot. Called by the narrowphase match-and-merge pass
+     * after writing a candidate that did NOT match any prior-frame contact:
+     * the geometry at this index is "new" and inheriting impulses from
+     * whatever happened to be cached at this index last frame would
+     * destabilise the solver.
+     *
+     * Distinct from {@link clear_contacts} (which wipes the entire slot's
+     * data slab including geometry) — `clear_impulses` only touches the
+     * three impulse fields at one contact index, leaving the geometric
+     * fields and feature_id intact.
+     *
+     * @param {number} slot
+     * @param {number} idx
+     */
+    clear_impulses(slot: number, idx: number): void;
+    /**
+     * Read the feature_id stored at one contact within a slot.
+     * @param {number} slot
+     * @param {number} idx
+     * @returns {number}
+     */
+    feature_id_of(slot: number, idx: number): number;
+    /**
+     * Read a contact point. Writes 10 floats: lax, lay, laz, lbx, lby, lbz, nx, ny, nz, depth.
+     * @param {number} slot
+     * @param {number} idx
+     * @param {number[]|Float64Array} out
+     * @param {number} out_offset
+     */
+    get_contact(slot: number, idx: number, out: number[] | Float64Array, out_offset: number): void;
+    /**
+     * Get the contact-normal world x component for a given contact.
+     * Provided for testability without exposing the raw Float64Array view.
+     * @param {number} slot
+     * @param {number} idx
+     * @returns {number}
+     */
+    contact_normal_x(slot: number, idx: number): number;
+    /** @param {number} slot @param {number} idx @returns {number} */
+    contact_normal_y(slot: number, idx: number): number;
+    /** @param {number} slot @param {number} idx @returns {number} */
+    contact_normal_z(slot: number, idx: number): number;
+    /** @param {number} slot @param {number} idx @returns {number} */
+    contact_depth(slot: number, idx: number): number;
+    /**
+     * Raw contact-point buffer. Hot-path solver code dereferences this
+     * directly via {@link slot_data_offset} + {@link CONTACT_STRIDE} to avoid
+     * per-field accessor overhead. Buffer identity is stable until grow.
+     * @returns {Float64Array}
+     */
+    get data_buffer(): Float64Array;
+    /**
+     * Per-slot cached GJK separating axis buffer. Hot-path GJK callers
+     * pass this together with {@link slot_axis_offset} to
+     * `gjk_with_axis(...)` so the cached axis seeds the next iteration.
+     * Buffer identity is stable until grow.
+     * @returns {Float64Array}
+     */
+    get slot_axis_buffer(): Float64Array;
+    /**
+     * Float offset into {@link slot_axis_buffer} where this slot's
+     * cached axis lives (3 floats: x, y, z).
+     * @param {number} slot
+     * @returns {number}
+     */
+    slot_axis_offset(slot: number): number;
+    /**
+     * Word offset into {@link data_buffer} where the first contact of `slot`
+     * begins. Subsequent contacts within the slot are at
+     * `offset + c * CONTACT_STRIDE`.
+     * @param {number} slot
+     * @returns {number}
+     */
+    slot_data_offset(slot: number): number;
+    /**
+     * Advance touched flags by one frame and evict slots that have been
+     * untouched for {@link DEFAULT_GRACE} consecutive frames.
+     */
+    advance_frame(): void;
+    /**
+     * @private
+     * @returns {number} newly-allocated slot id
+     */
+    private __allocate_slot;
+    /**
+     * @private
+     * @param {number} slot
+     */
+    private __release_slot;
+    /**
+     * @private
+     */
+    private __grow;
+    /**
+     * @private
+     * @param {number} v
+     */
+    private __heap_push;
+    /**
+     * @private
+     * @returns {number}
+     */
+    private __heap_pop;
+}
+import { PairUint32Map } from "../../../core/collection/PairUint32Map.js";
+//# sourceMappingURL=ManifoldStore.d.ts.map

package/src/engine/physics/contact/ManifoldStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManifoldStore.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/contact/ManifoldStore.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6BAFU,MAAM,CAEiB;AAEjC;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+BAFU,MAAM,CAE2D;AAyB3E;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAIvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;OAEG;IACH,+BAFW,MAAM,EA6BhB;IAzBG,mBAA+C;IAC/C,qBAAqB;IAErB,qBAAkE;IAClE,oBAAiE;IAQjE,0BAAwD;IAExD,4BAA0D;IAG1D,0BAAoD;IACpD,uBAAiD;IAEjD,qBAAqB;IAGrB,yBAAmD;IACnD,qBAAqB;IAGzB;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,UAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,aAJW,MAAM,OACN,MAAM,GACJ,MAAM,CA+BlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAQhB;IAED;;;;;;;;;;;;;OAaG;IACH,mBAFW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kBAhBW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,eACN,MAAM,QAwBhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAHW,MAAM,OACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,oBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,qCAEC;IAED;;;;;OAKG;IACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,sBA6BC;IAED;;;OAGG;IACH,wBAcC;IAED;;;OAGG;IACH,uBAkBC;IAED;;OAEG;IACH,eA+BC;IAED;;;OAGG;IACH,oBAaC;IAED;;;OAGG;IACH,mBAqBC;CACJ;8BA9lBqD,2CAA2C"}