@woosh/meep-engine 2.139.0 → 2.141.0

package/src/engine/physics/narrowphase/decomposition/heightmap_enumerate_triangles.js

@@ -0,0 +1,204 @@
+import { TRIANGLE_FEATURE_ID_OFFSET, TRIANGLE_FLOAT_STRIDE } from "./triangle_buffer_layout.js";
+
+/**
+ * Write the heightmap's triangles that may overlap the given body-local
+ * query AABB into `output`, starting at float-index `offset`.
+ *
+ * Each triangle occupies {@link TRIANGLE_FLOAT_STRIDE} consecutive floats:
+ *   [+0..+2]  vA.xyz   (body-local frame)
+ *   [+3..+5]  vB.xyz
+ *   [+6..+8]  vC.xyz
+ *   [+9]      feature_id   (stable across frames; warm-start key)
+ *
+ * The feature_id encodes `(cell_y * (W - 1) + cell_x) * 2 + tri_idx`
+ * where (cell_x, cell_y) is the grid cell and tri_idx ∈ {0, 1}. Two
+ * triangles per cell, lower-left-diagonal split (matches the existing
+ * {@link build_height_field_geometry} winding).
+ *
+ * The query AABB is filtered against the footprint *and* against the
+ * cell grid; triangles outside the query AABB along the height axis are
+ * NOT filtered out — that test is left to the per-triangle narrowphase
+ * (where the precise GJK distance is computed anyway). This keeps the
+ * enumerator branch-free over the height field and aligned with what
+ * Bullet's btHeightfieldTerrainShape does.
+ *
+ * The caller is responsible for ensuring
+ *   `output.length - offset >= cells_in_query * 2 * TRIANGLE_FLOAT_STRIDE`
+ * — sizing the scratch buffer for the *worst-case* query AABB is the
+ * right pattern (the broadphase already bounded the AABB to one body's
+ * world envelope, so the cell count is bounded by the footprint
+ * resolution).
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {HeightMapShape3D} shape
+ * @param {number} aabb_min_x  query AABB in shape's body-local frame
+ * @param {number} aabb_min_y
+ * @param {number} aabb_min_z
+ * @param {number} aabb_max_x
+ * @param {number} aabb_max_y
+ * @param {number} aabb_max_z
+ * @returns {number} number of triangles written
+ */
+export function heightmap_enumerate_triangles(
+    output, offset, shape,
+    aabb_min_x, aabb_min_y, aabb_min_z,
+    aabb_max_x, aabb_max_y, aabb_max_z
+) {
+    const sampler = shape.sampler;
+
+    if (sampler === null) {
+        return 0;
+    }
+
+    const W = sampler.width;
+    const H = sampler.height;
+
+    if (W < 2 || H < 2) {
+        // need at least one cell (one cell = 2 vertices per axis)
+        return 0;
+    }
+
+    const size_x = shape.size[0];
+    const size_z = shape.size[2];
+
+    if (size_x <= 0 || size_z <= 0) {
+        return 0;
+    }
+
+    // ── Project body-local AABB into heightmap-local (u, v, h) frame ─────
+    // Basis rows = (u_axis, v_axis, n_axis) in body-local frame. The
+    // body→heightmap rotation is therefore B (rows of basis), and the
+    // Arvo trick gives us the projected AABB extents.
+
+    shape._ensure_basis();
+    const b = shape._basis;
+
+    const c_x = 0.5 * (aabb_min_x + aabb_max_x);
+    const c_y = 0.5 * (aabb_min_y + aabb_max_y);
+    const c_z = 0.5 * (aabb_min_z + aabb_max_z);
+
+    const h_x = 0.5 * (aabb_max_x - aabb_min_x);
+    const h_y = 0.5 * (aabb_max_y - aabb_min_y);
+    const h_z = 0.5 * (aabb_max_z - aabb_min_z);
+
+    const u_c = b[0] * c_x + b[1] * c_y + b[2] * c_z;
+    const v_c = b[3] * c_x + b[4] * c_y + b[5] * c_z;
+    // height axis (b[6..8]) is intentionally not projected — see fn docstring
+
+    const u_e = Math.abs(b[0]) * h_x + Math.abs(b[1]) * h_y + Math.abs(b[2]) * h_z;
+    const v_e = Math.abs(b[3]) * h_x + Math.abs(b[4]) * h_y + Math.abs(b[5]) * h_z;
+
+    const half_u = size_x * 0.5;
+    const half_v = size_z * 0.5;
+
+    // ── Intersect with footprint, derive cell range ──────────────────────
+
+    const u_lo_q = u_c - u_e;
+    const u_hi_q = u_c + u_e;
+    const v_lo_q = v_c - v_e;
+    const v_hi_q = v_c + v_e;
+
+    if (u_lo_q > half_u || u_hi_q < -half_u) return 0;
+    if (v_lo_q > half_v || v_hi_q < -half_v) return 0;
+
+    const u_lo = u_lo_q > -half_u ? u_lo_q : -half_u;
+    const u_hi = u_hi_q < +half_u ? u_hi_q : +half_u;
+    const v_lo = v_lo_q > -half_v ? v_lo_q : -half_v;
+    const v_hi = v_hi_q < +half_v ? v_hi_q : +half_v;
+
+    const inv_cell_u = (W - 1) / size_x;
+    const inv_cell_v = (H - 1) / size_z;
+
+    let i_first = Math.floor((u_lo + half_u) * inv_cell_u);
+    let i_last  = Math.ceil ((u_hi + half_u) * inv_cell_u) - 1;
+    let j_first = Math.floor((v_lo + half_v) * inv_cell_v);
+    let j_last  = Math.ceil ((v_hi + half_v) * inv_cell_v) - 1;
+
+    if (i_first < 0) i_first = 0;
+    if (j_first < 0) j_first = 0;
+    if (i_last  > W - 2) i_last  = W - 2;
+    if (j_last  > H - 2) j_last  = H - 2;
+
+    if (i_first > i_last || j_first > j_last) return 0;
+
+    // ── Emit triangles ───────────────────────────────────────────────────
+    //
+    // For each cell (i, j) we sample 4 corner heights and emit 2 triangles
+    // matching the build_height_field_geometry winding:
+    //   A = (i,   j  ),  B = (i+1, j  )
+    //   D = (i,   j+1),  C = (i+1, j+1)
+    //   tri 0 = (A, D, B)
+    //   tri 1 = (D, C, B)
+    //
+    // body_point = u_axis * u_coord + v_axis * v_coord + n_axis * h_coord
+    // where columns of the body-frame projection matrix are the basis rows
+    // of B (since B is orthonormal, body→heightmap and heightmap→body
+    // matrices are mutual transposes).
+
+    const ux = b[0]; const uy = b[1]; const uz = b[2];
+    const vx = b[3]; const vy = b[4]; const vz = b[5];
+    const nx = b[6]; const ny = b[7]; const nz = b[8];
+
+    const inv_W1 = 1 / (W - 1);
+    const inv_H1 = 1 / (H - 1);
+
+    let count = 0;
+    let cursor = offset;
+
+    for (let j = j_first; j <= j_last; j++) {
+        const v01_lo = j * inv_H1;
+        const v01_hi = (j + 1) * inv_H1;
+        const v_lo_coord = -half_v + size_z * v01_lo;
+        const v_hi_coord = -half_v + size_z * v01_hi;
+
+        for (let i = i_first; i <= i_last; i++) {
+            const u01_lo = i * inv_W1;
+            const u01_hi = (i + 1) * inv_W1;
+            const u_lo_coord = -half_u + size_x * u01_lo;
+            const u_hi_coord = -half_u + size_x * u01_hi;
+
+            const hA = sampler.sampleChannelCatmullRomUV(u01_lo, v01_lo, 0);
+            const hB = sampler.sampleChannelCatmullRomUV(u01_hi, v01_lo, 0);
+            const hC = sampler.sampleChannelCatmullRomUV(u01_hi, v01_hi, 0);
+            const hD = sampler.sampleChannelCatmullRomUV(u01_lo, v01_hi, 0);
+
+            const Ax = ux * u_lo_coord + vx * v_lo_coord + nx * hA;
+            const Ay = uy * u_lo_coord + vy * v_lo_coord + ny * hA;
+            const Az = uz * u_lo_coord + vz * v_lo_coord + nz * hA;
+
+            const Bx = ux * u_hi_coord + vx * v_lo_coord + nx * hB;
+            const By = uy * u_hi_coord + vy * v_lo_coord + ny * hB;
+            const Bz = uz * u_hi_coord + vz * v_lo_coord + nz * hB;
+
+            const Cx = ux * u_hi_coord + vx * v_hi_coord + nx * hC;
+            const Cy = uy * u_hi_coord + vy * v_hi_coord + ny * hC;
+            const Cz = uz * u_hi_coord + vz * v_hi_coord + nz * hC;
+
+            const Dx = ux * u_lo_coord + vx * v_hi_coord + nx * hD;
+            const Dy = uy * u_lo_coord + vy * v_hi_coord + ny * hD;
+            const Dz = uz * u_lo_coord + vz * v_hi_coord + nz * hD;
+
+            const cell_idx = j * (W - 1) + i;
+            const fid_base = cell_idx * 2;
+
+            // triangle 0: (A, D, B)
+            output[cursor    ] = Ax; output[cursor + 1] = Ay; output[cursor + 2] = Az;
+            output[cursor + 3] = Dx; output[cursor + 4] = Dy; output[cursor + 5] = Dz;
+            output[cursor + 6] = Bx; output[cursor + 7] = By; output[cursor + 8] = Bz;
+            output[cursor + TRIANGLE_FEATURE_ID_OFFSET] = fid_base;
+            cursor += TRIANGLE_FLOAT_STRIDE;
+            count++;
+
+            // triangle 1: (D, C, B)
+            output[cursor    ] = Dx; output[cursor + 1] = Dy; output[cursor + 2] = Dz;
+            output[cursor + 3] = Cx; output[cursor + 4] = Cy; output[cursor + 5] = Cz;
+            output[cursor + 6] = Bx; output[cursor + 7] = By; output[cursor + 8] = Bz;
+            output[cursor + TRIANGLE_FEATURE_ID_OFFSET] = fid_base + 1;
+            cursor += TRIANGLE_FLOAT_STRIDE;
+            count++;
+        }
+    }
+
+    return count;
+}

package/src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Write the mesh's surface triangles that may overlap the given query
+ * AABB into `output`, starting at float-index `offset`.
+ *
+ * Each triangle occupies {@link TRIANGLE_FLOAT_STRIDE} consecutive floats:
+ *   [+0..+2]  vA.xyz   (shape's body-local frame, i.e. read directly from
+ *                       {@link MeshShape3D#positions})
+ *   [+3..+5]  vB.xyz
+ *   [+6..+8]  vC.xyz
+ *   [+9]      feature_id   (the surface triangle's index)
+ *
+ * Triangles are AABB-filtered: a triangle is emitted iff its tight AABB
+ * (min/max across its 3 vertices) overlaps the query AABB. This is a
+ * linear O(N) scan over the mesh's surface triangles — no surface-BVH
+ * yet (the existing BVH on MeshShape3D is over the *tet* decomposition
+ * used by `contains_point`, with different leaf semantics). For meshes
+ * up to a few thousand triangles the linear scan is comfortably faster
+ * than a BVH would be after broadphase has already given us a tight
+ * query AABB; we can graduate to a per-mesh surface BVH later.
+ *
+ * Determinism: triangles are emitted in the natural index order, so
+ * feature_id values inside `output` rise monotonically over a single
+ * call. The narrowphase relies on this for stable contact-manifold
+ * pairing across frames.
+ *
+ * Caller is responsible for ensuring
+ *   `output.length - offset >= shape.indices.length / 3 * TRIANGLE_FLOAT_STRIDE`
+ * in the worst case (every triangle overlaps).
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {MeshShape3D} shape
+ * @param {number} aabb_min_x  query AABB in shape's body-local frame
+ * @param {number} aabb_min_y
+ * @param {number} aabb_min_z
+ * @param {number} aabb_max_x
+ * @param {number} aabb_max_y
+ * @param {number} aabb_max_z
+ * @returns {number} number of triangles written
+ */
+export function mesh_enumerate_triangles(output: Float64Array, offset: number, shape: MeshShape3D, aabb_min_x: number, aabb_min_y: number, aabb_min_z: number, aabb_max_x: number, aabb_max_y: number, aabb_max_z: number): number;
+//# sourceMappingURL=mesh_enumerate_triangles.d.ts.map

package/src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_enumerate_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,iDAXW,YAAY,UACZ,MAAM,kCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAqDlB"}

package/src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.js

@@ -0,0 +1,94 @@
+import { TRIANGLE_FEATURE_ID_OFFSET, TRIANGLE_FLOAT_STRIDE } from "./triangle_buffer_layout.js";
+
+/**
+ * Write the mesh's surface triangles that may overlap the given query
+ * AABB into `output`, starting at float-index `offset`.
+ *
+ * Each triangle occupies {@link TRIANGLE_FLOAT_STRIDE} consecutive floats:
+ *   [+0..+2]  vA.xyz   (shape's body-local frame, i.e. read directly from
+ *                       {@link MeshShape3D#positions})
+ *   [+3..+5]  vB.xyz
+ *   [+6..+8]  vC.xyz
+ *   [+9]      feature_id   (the surface triangle's index)
+ *
+ * Triangles are AABB-filtered: a triangle is emitted iff its tight AABB
+ * (min/max across its 3 vertices) overlaps the query AABB. This is a
+ * linear O(N) scan over the mesh's surface triangles — no surface-BVH
+ * yet (the existing BVH on MeshShape3D is over the *tet* decomposition
+ * used by `contains_point`, with different leaf semantics). For meshes
+ * up to a few thousand triangles the linear scan is comfortably faster
+ * than a BVH would be after broadphase has already given us a tight
+ * query AABB; we can graduate to a per-mesh surface BVH later.
+ *
+ * Determinism: triangles are emitted in the natural index order, so
+ * feature_id values inside `output` rise monotonically over a single
+ * call. The narrowphase relies on this for stable contact-manifold
+ * pairing across frames.
+ *
+ * Caller is responsible for ensuring
+ *   `output.length - offset >= shape.indices.length / 3 * TRIANGLE_FLOAT_STRIDE`
+ * in the worst case (every triangle overlaps).
+ *
+ * @param {Float64Array} output
+ * @param {number} offset float-index into output
+ * @param {MeshShape3D} shape
+ * @param {number} aabb_min_x  query AABB in shape's body-local frame
+ * @param {number} aabb_min_y
+ * @param {number} aabb_min_z
+ * @param {number} aabb_max_x
+ * @param {number} aabb_max_y
+ * @param {number} aabb_max_z
+ * @returns {number} number of triangles written
+ */
+export function mesh_enumerate_triangles(
+    output, offset, shape,
+    aabb_min_x, aabb_min_y, aabb_min_z,
+    aabb_max_x, aabb_max_y, aabb_max_z
+) {
+    const positions = shape.positions;
+    const indices = shape.indices;
+
+    const tri_count = (indices.length / 3) | 0;
+    if (tri_count === 0) {
+        return 0;
+    }
+
+    let count = 0;
+    let cursor = offset;
+
+    for (let t = 0; t < tri_count; t++) {
+        const i_a = indices[t * 3    ] * 3;
+        const i_b = indices[t * 3 + 1] * 3;
+        const i_c = indices[t * 3 + 2] * 3;
+
+        const ax = positions[i_a    ]; const ay = positions[i_a + 1]; const az = positions[i_a + 2];
+        const bx = positions[i_b    ]; const by = positions[i_b + 1]; const bz = positions[i_b + 2];
+        const cx = positions[i_c    ]; const cy = positions[i_c + 1]; const cz = positions[i_c + 2];
+
+        // tight per-triangle AABB
+        const tri_min_x = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx);
+        if (tri_min_x > aabb_max_x) continue;
+        const tri_max_x = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx);
+        if (tri_max_x < aabb_min_x) continue;
+
+        const tri_min_y = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy);
+        if (tri_min_y > aabb_max_y) continue;
+        const tri_max_y = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
+        if (tri_max_y < aabb_min_y) continue;
+
+        const tri_min_z = az < bz ? (az < cz ? az : cz) : (bz < cz ? bz : cz);
+        if (tri_min_z > aabb_max_z) continue;
+        const tri_max_z = az > bz ? (az > cz ? az : cz) : (bz > cz ? bz : cz);
+        if (tri_max_z < aabb_min_z) continue;
+
+        output[cursor    ] = ax; output[cursor + 1] = ay; output[cursor + 2] = az;
+        output[cursor + 3] = bx; output[cursor + 4] = by; output[cursor + 5] = bz;
+        output[cursor + 6] = cx; output[cursor + 7] = cy; output[cursor + 8] = cz;
+        output[cursor + TRIANGLE_FEATURE_ID_OFFSET] = t;
+
+        cursor += TRIANGLE_FLOAT_STRIDE;
+        count++;
+    }
+
+    return count;
+}

package/src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Per-triangle stride in the Float64 decomposition buffer used by the
+ * narrowphase to consume non-convex shapes (heightmaps, meshes).
+ *
+ * Layout per triangle, starting at buffer[base]:
+ *
+ *   [base +  0]  vA.x
+ *   [base +  1]  vA.y
+ *   [base +  2]  vA.z
+ *   [base +  3]  vB.x
+ *   [base +  4]  vB.y
+ *   [base +  5]  vB.z
+ *   [base +  6]  vC.x
+ *   [base +  7]  vC.y
+ *   [base +  8]  vC.z
+ *   [base +  9]  feature_id  (uint32 packed as f64 — safe to 2^53)
+ *
+ * Coordinates are in the producer shape's local frame. The feature_id is
+ * stable across frames for the same triangle of the same shape — the
+ * manifold cache uses it as the warm-start match key.
+ *
+ * Stride 10 (rather than 9) is the small cost we pay for clean warm-start
+ * matching; see the discussion in PLAN.md's "Pair-key → slot map" section
+ * for why ID-based matching beats position-distance matching when shapes
+ * slide along curved surfaces.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const TRIANGLE_FLOAT_STRIDE: number;
+/**
+ * Float offset of feature_id within a triangle entry.
+ * @readonly
+ * @type {number}
+ */
+export const TRIANGLE_FEATURE_ID_OFFSET: number;
+//# sourceMappingURL=triangle_buffer_layout.d.ts.map

package/src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangle_buffer_layout.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B"}

package/src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js

@@ -0,0 +1,37 @@
+/**
+ * Per-triangle stride in the Float64 decomposition buffer used by the
+ * narrowphase to consume non-convex shapes (heightmaps, meshes).
+ *
+ * Layout per triangle, starting at buffer[base]:
+ *
+ *   [base +  0]  vA.x
+ *   [base +  1]  vA.y
+ *   [base +  2]  vA.z
+ *   [base +  3]  vB.x
+ *   [base +  4]  vB.y
+ *   [base +  5]  vB.z
+ *   [base +  6]  vC.x
+ *   [base +  7]  vC.y
+ *   [base +  8]  vC.z
+ *   [base +  9]  feature_id  (uint32 packed as f64 — safe to 2^53)
+ *
+ * Coordinates are in the producer shape's local frame. The feature_id is
+ * stable across frames for the same triangle of the same shape — the
+ * manifold cache uses it as the warm-start match key.
+ *
+ * Stride 10 (rather than 9) is the small cost we pay for clean warm-start
+ * matching; see the discussion in PLAN.md's "Pair-key → slot map" section
+ * for why ID-based matching beats position-distance matching when shapes
+ * slide along curved surfaces.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const TRIANGLE_FLOAT_STRIDE = 10;
+
+/**
+ * Float offset of feature_id within a triangle entry.
+ * @readonly
+ * @type {number}
+ */
+export const TRIANGLE_FEATURE_ID_OFFSET = 9;

package/src/engine/physics/narrowphase/narrowphase_step.d.ts

@@ -5,7 +5,46 @@
  *
  * @param {PairList} pair_list
  * @param {ManifoldStore} manifolds
- * @param {PhysicsSystem} system supplies per-body collider lists + transforms
+ * @param {Array<Array<{collider: Collider, transform: Transform}>>} lists
+ *   per-body collider lists, indexed by body-storage slot index. Typically
+ *   `system.__body_collider_lists` — passed in directly so this helper
+ *   has no dependency on `PhysicsSystem`.
  */
-export function narrowphase_step(pair_list: PairList, manifolds: ManifoldStore, system: PhysicsSystem): void;
+export function narrowphase_step(pair_list: PairList, manifolds: ManifoldStore, lists: Array<Array<{
+    collider: Collider;
+    transform: Transform;
+}>>): void;
+/**
+ * Re-detect contact GEOMETRY for one existing manifold slot at the bodies'
+ * current poses, updating the witness points / normal / depth of the slot's
+ * existing contacts in place. Does NOT change the contact count, the
+ * feature ids, or the accumulated impulses — it only refreshes geometry.
+ *
+ * This is the per-substep concave path (TGS): for a contact pair involving a
+ * concave body, the contact *feature* (which triangle is deepest, and its
+ * normal) genuinely changes as the body rocks, so the solver's cheap analytic
+ * refresh — which freezes the feature for the whole outer step — pumps energy
+ * in. Re-running the narrowphase geometry each substep gives a fresh,
+ * correct normal so the body settles instead of rocking. Convex pairs keep
+ * the analytic refresh and never call this (their feature is stable).
+ *
+ * Matching is by feature id (stable per-triangle for the decomposition path),
+ * so a contact's geometry tracks the same triangle across substeps. A contact
+ * whose triangle isn't found this substep keeps its previous geometry (a rare
+ * transient; the once-per-frame {@link narrowphase_step} re-establishes the
+ * contact set next outer step). Count never changes here, so the solver's
+ * per-contact scratch (sized once at prepare) stays aligned.
+ *
+ * @param {ManifoldStore} manifolds
+ * @param {number} slot
+ * @param {Array<{collider: Collider, transform: Transform}>} list_a
+ * @param {Array<{collider: Collider, transform: Transform}>} list_b
+ */
+export function redetect_pair_geometry(manifolds: ManifoldStore, slot: number, list_a: Array<{
+    collider: Collider;
+    transform: Transform;
+}>, list_b: Array<{
+    collider: Collider;
+    transform: Transform;
+}>): void;
 //# sourceMappingURL=narrowphase_step.d.ts.map

package/src/engine/physics/narrowphase/narrowphase_step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAsUA;;;;;;;;GAQG;AACH,6GA8CC"}
+{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AA6uCA;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,CAAC,QAyJlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,UACjD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,QAiD3D"}