@woosh/meep-engine 2.155.0 → 2.156.0

package/src/engine/physics/fluid/ecs/FluidSystem.d.ts

@@ -38,7 +38,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {FluidEffectorsComponent} effectors_component
      * @param {Transform} transform
      */
-    static "__#135@#sync_effectors_from_transform"(effectors_component: FluidEffectorsComponent, transform: Transform): void;
+    static "__#139@#sync_effectors_from_transform"(effectors_component: FluidEffectorsComponent, transform: Transform): void;
     /**
      * Visitor for the (FluidComponent, Transform) traversal — keeps the field's
      * grid origin locked to a cell-aligned position near the transform.
@@ -61,7 +61,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {FluidComponent} component
      * @param {Transform} transform
      */
-    static "__#135@#reanchor_field"(component: FluidComponent, transform: Transform): void;
+    static "__#139@#reanchor_field"(component: FluidComponent, transform: Transform): void;
     /**
      * Write the world-to-grid affine for a FluidComponent into `out`. Axis-aligned,
      * uniform-scale, so the matrix is sparse:
@@ -76,7 +76,7 @@ export class FluidSystem extends System<any, any, any, any, any> {
      * @param {Float32Array} out  length-16
      * @param {FluidComponent} component
      */
-    static "__#135@#build_world_to_grid"(out: Float32Array, component: FluidComponent): void;
+    static "__#139@#build_world_to_grid"(out: Float32Array, component: FluidComponent): void;
     constructor();
     dependencies: (typeof FluidComponent)[];
     /**

package/src/engine/physics/gjk/gjk_epa_penetration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AAmhBA;;;;;;;;;GASG;AACH,yCALW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CAQlB;;;;;;8BAndY;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}
+{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AA+gBA;;;;;;;;;GASG;AACH,yCALW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CAQlB;;;;;;8BA9cY;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}

package/src/engine/physics/gjk/gjk_epa_penetration.js

@@ -1,3 +1,4 @@
+import { v3_compute_triangle_normal } from "../../../core/geom/3d/triangle/v3_compute_triangle_normal.js";
 import { v3_array_copy } from "../../../core/geom/vec3/v3_array_copy.js";
 import { v3_cross } from "../../../core/geom/vec3/v3_cross.js";
 import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
@@ -344,16 +345,11 @@ function tetra_case() {
  */
 function add_face(i, j, k, face_count) {
     const ax = VERTS[i * 3], ay = VERTS[i * 3 + 1], az = VERTS[i * 3 + 2];
-    v3_subtract(_ab, 0, VERTS[j * 3], VERTS[j * 3 + 1], VERTS[j * 3 + 2], ax, ay, az);
-    v3_subtract(_ac, 0, VERTS[k * 3], VERTS[k * 3 + 1], VERTS[k * 3 + 2], ax, ay, az);
-    v3_cross(_t, 0, _ab[0], _ab[1], _ab[2], _ac[0], _ac[1], _ac[2]);
-
+    const bx = VERTS[j * 3], by = VERTS[j * 3 + 1], bz = VERTS[j * 3 + 2];
+    const cx = VERTS[k * 3], cy = VERTS[k * 3 + 1], cz = VERTS[k * 3 + 2];
+    // (b−a)×(c−a), normalised (degenerate → (0,1,0)); see v3_compute_triangle_normal
+    v3_compute_triangle_normal(_t, 0, ax, ay, az, bx, by, bz, cx, cy, cz);
     let nx = _t[0], ny = _t[1], nz = _t[2];
-    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-    const inv = 1 / len;
-    nx *= inv;
-    ny *= inv;
-    nz *= inv;
 
     // orient outward: the normal must point away from the interior (centroid)
     if (v3_dot(nx, ny, nz, ax - CEN[0], ay - CEN[1], az - CEN[2]) < 0) {

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

@@ -1 +1 @@
-{"version":3,"file":"convex_convex_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_convex_manifold.js"],"names":[],"mappings":"AAoJA;;;;;;;;;;GAUG;AACH,4CAPW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KAC/B;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,GAC7B,OAAO,CAsDnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,sCANW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAAY;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KAC7E;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAAY;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,MAC7E,MAAM,MAAa,MAAM,MAAa,MAAM,GAC1C,OAAO,CA+CnB;AA9ND,8CAA0E"}
+{"version":3,"file":"convex_convex_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_convex_manifold.js"],"names":[],"mappings":"AAiJA;;;;;;;;;;GAUG;AACH,4CAPW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KAC/B;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,GAC7B,OAAO,CAsDnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,sCANW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAAY;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KAC7E;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAAY;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QAAe;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,MAC7E,MAAM,MAAa,MAAM,MAAa,MAAM,GAC1C,OAAO,CA+CnB;AAxND,8CAA0E"}

package/src/engine/physics/narrowphase/convex_convex_manifold.js

@@ -1,3 +1,6 @@
+import { v3_array_centroid } from "../../../core/geom/vec3/v3_array_centroid.js";
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
 import { reduce_manifold_contacts } from "./reduce_manifold_contacts.js";
 
@@ -95,12 +98,6 @@ function load_world(out, verts, n, p, q) {
     }
 }
 
-function centroid(out, wv, n) {
-    let cx = 0, cy = 0, cz = 0;
-    for (let i = 0; i < n; i++) { cx += wv[i * 3]; cy += wv[i * 3 + 1]; cz += wv[i * 3 + 2]; }
-    out[0] = cx / n; out[1] = cy / n; out[2] = cz / n;
-}
-
 /**
  * Outward normal of a polygon face (Newell's method over the whole loop, world).
  * Robust against collinear consecutive vertices, unlike a first-three cross.
@@ -125,12 +122,12 @@ function test_axis(ux, uy, uz, nA, nB, kind, face) {
 
     let minA = Infinity, maxA = -Infinity;
     for (let i = 0; i < nA; i++) {
-        const d = ux * wvA[i * 3] + uy * wvA[i * 3 + 1] + uz * wvA[i * 3 + 2];
+        const d = v3_dot(ux, uy, uz, wvA[i * 3], wvA[i * 3 + 1], wvA[i * 3 + 2]);
         if (d < minA) minA = d; if (d > maxA) maxA = d;
     }
     let minB = Infinity, maxB = -Infinity;
     for (let i = 0; i < nB; i++) {
-        const d = ux * wvB[i * 3] + uy * wvB[i * 3 + 1] + uz * wvB[i * 3 + 2];
+        const d = v3_dot(ux, uy, uz, wvB[i * 3], wvB[i * 3 + 1], wvB[i * 3 + 2]);
         if (d < minB) minB = d; if (d > maxB) maxB = d;
     }
     if (maxA < minB || maxB < minA) return true;
@@ -139,7 +136,7 @@ function test_axis(ux, uy, uz, nA, nB, kind, face) {
     if (sat.kind === -1 || overlap < sat.overlap - (sat.overlap * TIE_REL + TIE_ABS)) {
         sat.overlap = overlap;
         const dcx = cenA[0] - cenB[0], dcy = cenA[1] - cenB[1], dcz = cenA[2] - cenB[2];
-        const sign = (ux * dcx + uy * dcy + uz * dcz) >= 0 ? 1 : -1;
+        const sign = v3_dot(ux, uy, uz, dcx, dcy, dcz) >= 0 ? 1 : -1;
         sat.nx = ux * sign; sat.ny = uy * sign; sat.nz = uz * sign;
         sat.kind = kind; sat.face = face;
     }
@@ -162,8 +159,8 @@ export function convex_convex_manifold(out, A, posA, rotA, B, posB, rotB) {
 
     load_world(wvA, A.vertices, g_nA, posA, rotA);
     load_world(wvB, B.vertices, g_nB, posB, rotB);
-    centroid(cenA, wvA, g_nA);
-    centroid(cenB, wvB, g_nB);
+    v3_array_centroid(cenA, 0, wvA, 0, g_nA);
+    v3_array_centroid(cenB, 0, wvB, 0, g_nB);
 
     sat.kind = -1; sat.overlap = Infinity;
 
@@ -237,8 +234,8 @@ export function convex_hull_clip(out, A, posA, rotA, B, posB, rotB, nx, ny, nz)
     // guard (transform positions) degenerates when the two origins nearly
     // coincide — e.g. a tet resting base-to-base on another, both transforms at
     // the contact plane — leaving the normal mis-oriented and the stack tunnels.
-    centroid(cenA, wvA, g_nA);
-    centroid(cenB, wvB, g_nB);
+    v3_array_centroid(cenA, 0, wvA, 0, g_nA);
+    v3_array_centroid(cenB, 0, wvB, 0, g_nB);
     if (nx * (cenA[0] - cenB[0]) + ny * (cenA[1] - cenB[1]) + nz * (cenA[2] - cenB[2]) < 0) {
         nx = -nx; ny = -ny; nz = -nz;
     }
@@ -252,15 +249,15 @@ export function convex_hull_clip(out, A, posA, rotA, B, posB, rotB, nx, ny, nz)
     let bestA = -Infinity, faceA = 0;
     for (let f = 0; f < g_fA; f++) {
         face_normal(tmp_n, wvA, g_flA, g_foA[f], g_foA[f + 1]);
-        const l = Math.sqrt(tmp_n[0] * tmp_n[0] + tmp_n[1] * tmp_n[1] + tmp_n[2] * tmp_n[2]) || 1;
-        const d = (tmp_n[0] * -nx + tmp_n[1] * -ny + tmp_n[2] * -nz) / l;
+        const l = v3_length(tmp_n[0], tmp_n[1], tmp_n[2]) || 1;
+        const d = v3_dot(tmp_n[0], tmp_n[1], tmp_n[2], -nx, -ny, -nz) / l;
         if (d > bestA) { bestA = d; faceA = f; }
     }
     let bestB = -Infinity, faceB = 0;
     for (let f = 0; f < g_fB; f++) {
         face_normal(tmp_n, wvB, g_flB, g_foB[f], g_foB[f + 1]);
-        const l = Math.sqrt(tmp_n[0] * tmp_n[0] + tmp_n[1] * tmp_n[1] + tmp_n[2] * tmp_n[2]) || 1;
-        const d = (tmp_n[0] * nx + tmp_n[1] * ny + tmp_n[2] * nz) / l;
+        const l = v3_length(tmp_n[0], tmp_n[1], tmp_n[2]) || 1;
+        const d = v3_dot(tmp_n[0], tmp_n[1], tmp_n[2], nx, ny, nz) / l;
         if (d > bestB) { bestB = d; faceB = f; }
     }
 
@@ -278,11 +275,11 @@ export function convex_hull_clip(out, A, posA, rotA, B, posB, rotB, nx, ny, nz)
 function projection_overlap(nx, ny, nz) {
     let minA = Infinity, maxB = -Infinity;
     for (let i = 0; i < g_nA; i++) {
-        const d = nx * wvA[i * 3] + ny * wvA[i * 3 + 1] + nz * wvA[i * 3 + 2];
+        const d = v3_dot(nx, ny, nz, wvA[i * 3], wvA[i * 3 + 1], wvA[i * 3 + 2]);
         if (d < minA) minA = d;
     }
     for (let i = 0; i < g_nB; i++) {
-        const d = nx * wvB[i * 3] + ny * wvB[i * 3 + 1] + nz * wvB[i * 3 + 2];
+        const d = v3_dot(nx, ny, nz, wvB[i * 3], wvB[i * 3 + 1], wvB[i * 3 + 2]);
         if (d > maxB) maxB = d;
     }
     return maxB - minA;
@@ -292,12 +289,12 @@ function projection_overlap(nx, ny, nz) {
 function emit_single_contact(out, nx, ny, nz, depth) {
     let sa = -Infinity, ai = 0;
     for (let i = 0; i < g_nA; i++) {
-        const d = -(nx * wvA[i * 3] + ny * wvA[i * 3 + 1] + nz * wvA[i * 3 + 2]);
+        const d = -v3_dot(nx, ny, nz, wvA[i * 3], wvA[i * 3 + 1], wvA[i * 3 + 2]);
         if (d > sa) { sa = d; ai = i; }
     }
     let sb = -Infinity, bi = 0;
     for (let i = 0; i < g_nB; i++) {
-        const d = nx * wvB[i * 3] + ny * wvB[i * 3 + 1] + nz * wvB[i * 3 + 2];
+        const d = v3_dot(nx, ny, nz, wvB[i * 3], wvB[i * 3 + 1], wvB[i * 3 + 2]);
         if (d > sb) { sb = d; bi = i; }
     }
     out[3] = 1;
@@ -335,8 +332,8 @@ function emit_face_manifold(out, ref_is_A, ref_face, nx, ny, nz) {
     let inc_face = 0, most_anti = Infinity;
     for (let f = 0; f < inc_fcount; f++) {
         face_normal(tmp_n, inc_wv, inc_fl, inc_fo[f], inc_fo[f + 1]);
-        const l = Math.sqrt(tmp_n[0] * tmp_n[0] + tmp_n[1] * tmp_n[1] + tmp_n[2] * tmp_n[2]) || 1;
-        const dot = (tmp_n[0] * rmx + tmp_n[1] * rmy + tmp_n[2] * rmz) / l;
+        const l = v3_length(tmp_n[0], tmp_n[1], tmp_n[2]) || 1;
+        const dot = v3_dot(tmp_n[0], tmp_n[1], tmp_n[2], rmx, rmy, rmz) / l;
         if (dot < most_anti) { most_anti = dot; inc_face = f; }
     }
 
@@ -405,8 +402,8 @@ function clip_poly(src, n, dst, sx, sy, sz, ax, ay, az) {
         const j = (i + 1) % n;
         const px = src[i * 3], py = src[i * 3 + 1], pz = src[i * 3 + 2];
         const qx = src[j * 3], qy = src[j * 3 + 1], qz = src[j * 3 + 2];
-        const dp = (px - ax) * sx + (py - ay) * sy + (pz - az) * sz;
-        const dq = (qx - ax) * sx + (qy - ay) * sy + (qz - az) * sz;
+        const dp = v3_dot(px - ax, py - ay, pz - az, sx, sy, sz);
+        const dq = v3_dot(qx - ax, qy - ay, qz - az, sx, sy, sz);
         const p_in = dp <= 0, q_in = dq <= 0;
         if (p_in) { dst[m * 3] = px; dst[m * 3 + 1] = py; dst[m * 3 + 2] = pz; m++; }
         if (p_in !== q_in) {

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

@@ -1,13 +1,19 @@
-export function face_key(a: any, b: any, c: any): string;
 /**
- * @param {{tet_mesh, tet_positions, compute_bounding_box}} meshShape
+ * Exact, collision-free, order-independent key for a triangle's vertex triple:
+ * the three indices sorted ascending and joined with commas, so two faces with
+ * the same vertex set (any winding) map to the same key.
+ *
+ * @param {number} a first vertex index
+ * @param {number} b second vertex index
+ * @param {number} c third vertex index
+ * @returns {string} canonical `"x,y,z"` key with x ≤ y ≤ z
+ */
+export function face_key(a: number, b: number, c: number): string;
+/**
+ * @param {MeshShape3D} meshShape
  * @returns {{pieces: Array<{vertices:Float32Array, face_offsets:Uint32Array, face_loops:Uint32Array, aabb:Float64Array}>, bvh: BVH}}
  */
-export function build_convex_decomposition(meshShape: {
-    tet_mesh;
-    tet_positions;
-    compute_bounding_box;
-}): {
+export function build_convex_decomposition(meshShape: MeshShape3D): {
     pieces: Array<{
         vertices: Float32Array;
         face_offsets: Uint32Array;
@@ -16,12 +22,25 @@ export function build_convex_decomposition(meshShape: {
     }>;
     bvh: BVH;
 };
-/** Build a clippable piece from its boundary triangles: coplanar-merge into
- *  polygon faces and localise vertex indices. `boundary` is a Map keyed by
- *  face_key → {a,b,c} (any winding; orientation is re-derived from the piece
- *  centroid). Exported so the convex-mesh fast path can build a single
- *  coplanar-merged hull from a whole mesh's boundary. */
-export function build_piece(tp: any, boundary: any): {
+/**
+ * Build a clippable piece from its boundary triangles: coplanar-merge them into
+ * polygon faces and localise the vertex indices. Orientation is re-derived from
+ * the piece centroid, so the `boundary` triples may have any winding. Exported
+ * so the convex-mesh fast path ({@link mesh_convex_hull}) can build a single
+ * coplanar-merged hull from a whole mesh's boundary.
+ *
+ * @param {Float32Array|Float64Array|number[]} tp tet positions: flat `(x, y, z)`
+ *   per vertex, indexed by global vertex index
+ * @param {Map<string, {a:number, b:number, c:number}>} boundary boundary faces
+ *   keyed by {@link face_key}; each value is a vertex triple (any winding)
+ * @returns {{vertices: Float32Array, face_offsets: Uint32Array, face_loops: Uint32Array, aabb: Float64Array}}
+ *   a clippable convex piece — local vertices, CSR polygon-face loops, and local AABB
+ */
+export function build_piece(tp: Float32Array | Float64Array | number[], boundary: Map<string, {
+    a: number;
+    b: number;
+    c: number;
+}>): {
     vertices: Float32Array;
     face_offsets: Uint32Array;
     face_loops: Uint32Array;

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

@@ -1 +1 @@
-{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AAsCA,yDAOC;AAED;;;GAGG;AACH,sDAHW;IAAC,QAAQ,CAAC;IAAC,aAAa,CAAC;IAAC,oBAAoB,CAAA;CAAC;YACpC,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC;SAAO,GAAG;EA+IlI;AAED;;;;yDAIyD;AACzD;;;;;EA6FC;AAhQD,kCAAiF;oBApC7D,gCAAgC"}
+{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH;YAFsB,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC;SAAO,GAAG;EAmHlI;AAED;;;;;;;;;;;;;GAaG;AACH,gCAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAElC,IAAI,MAAM,EAAE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,CAAC;cAE9B,YAAY;kBAAgB,WAAW;gBAAc,WAAW;UAAQ,YAAY;EAgG3G;AAzPD,kCAAiF;oBAvC7D,gCAAgC"}

package/src/engine/physics/narrowphase/convex_decomposition.js

@@ -1,4 +1,7 @@
 import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
+import { v3_compute_triangle_normal } from "../../../core/geom/3d/triangle/v3_compute_triangle_normal.js";
+import { tetrahedral_mesh_tet_get_neighbours } from "../../../core/geom/3d/tetrahedra/tetrahedral_mesh_tet_get_neighbours.js";
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
 
 /**
  * Greedy convex decomposition of a tetrahedralised mesh into a small set of
@@ -36,8 +39,20 @@ const PLANE_OFFSET_TOL = 1e-4;
 // tet-face convention rather than keeping a parallel copy.
 export const FACE_OPP = [[1, 2, 3, 0], [0, 2, 3, 1], [0, 1, 3, 2], [0, 1, 2, 3]];
 
+// Reusable scratch for v3_compute_triangle_normal (writes a unit normal as 3 floats).
+const _face_normal = new Float64Array(3);
+
+/**
+ * Exact, collision-free, order-independent key for a triangle's vertex triple:
+ * the three indices sorted ascending and joined with commas, so two faces with
+ * the same vertex set (any winding) map to the same key.
+ *
+ * @param {number} a first vertex index
+ * @param {number} b second vertex index
+ * @param {number} c third vertex index
+ * @returns {string} canonical `"x,y,z"` key with x ≤ y ≤ z
+ */
 export function face_key(a, b, c) {
-    // Exact, collision-free order-independent key for a triangle's vertex triple.
     let x = a, y = b, z = c, t;
     if (x > y) { t = x; x = y; y = t; }
     if (y > z) { t = y; y = z; z = t; }
@@ -46,7 +61,7 @@ export function face_key(a, b, c) {
 }
 
 /**
- * @param {{tet_mesh, tet_positions, compute_bounding_box}} meshShape
+ * @param {MeshShape3D} meshShape
  * @returns {{pieces: Array<{vertices:Float32Array, face_offsets:Uint32Array, face_loops:Uint32Array, aabb:Float64Array}>, bvh: BVH}}
  */
 export function build_convex_decomposition(meshShape) {
@@ -60,49 +75,20 @@ export function build_convex_decomposition(meshShape) {
     const diag = Math.hypot(bb[3] - bb[0], bb[4] - bb[1], bb[5] - bb[2]) || 1;
     const EPS = 1e-6 * diag;
 
-    // Tet vertices (global indices) and the 4 faces (each: 3 face verts + the
-    // opposite vertex, for outward orientation).
-    const tetV = new Int32Array(N * 4);
-    for (let t = 0; t < N; t++) {
-        for (let i = 0; i < 4; i++) tetV[t * 4 + i] = tm.getVertexIndex(t, i);
-    }
-
-    // Adjacency: face-key → list of (tet) owners. Two tets sharing a face are
-    // neighbours. Exact triple stored alongside to resolve hash collisions.
-    const faceOwners = new Map(); // key → array of { tet, fi }
-    for (let t = 0; t < N; t++) {
-        for (let f = 0; f < 4; f++) {
-            const o = FACE_OPP[f];
-            const a = tetV[t * 4 + o[0]], b = tetV[t * 4 + o[1]], c = tetV[t * 4 + o[2]];
-            const k = face_key(a, b, c);
-            let arr = faceOwners.get(k);
-            if (arr === undefined) { arr = []; faceOwners.set(k, arr); }
-            arr.push({ tet: t, fi: f, a, b, c });
-        }
-    }
-    // tet → neighbour tets (sharing a face).
-    const neighbours = (t) => {
-        const out = [];
-        for (let f = 0; f < 4; f++) {
-            const o = FACE_OPP[f];
-            const a = tetV[t * 4 + o[0]], b = tetV[t * 4 + o[1]], c = tetV[t * 4 + o[2]];
-            const arr = faceOwners.get(face_key(a, b, c));
-            if (arr === undefined) continue;
-            for (const e of arr) if (e.tet !== t) out.push(e.tet);
-        }
-        return out;
-    };
-
     const visited = new Uint8Array(N);
     const pieces = [];
 
+    // Per-tet face neighbours are read straight from the mesh's stored adjacency
+    // via tetrahedral_mesh_tet_get_neighbours; this is its reusable output scratch
+    // (a tet has at most 4 face neighbours).
+    const tet_neighbours = new Int32Array(4);
+
     // Reusable boundary structure for the growing piece: key → oriented face.
     for (let seed = 0; seed < N; seed++) {
         if (visited[seed]) continue;
 
         const boundary = new Map(); // key → {a,b,c (oriented), nx,ny,nz}
         const pieceVerts = new Set();
-        const pieceTets = [];
 
         // Toggle a tet's 4 faces against the boundary (its own inverse): a face
         // shared with a piece tet cancels (becomes interior). Store just the
@@ -110,13 +96,13 @@ export function build_convex_decomposition(meshShape) {
         const toggle_tet_faces = (t) => {
             for (let f = 0; f < 4; f++) {
                 const o = FACE_OPP[f];
-                const a = tetV[t * 4 + o[0]], b = tetV[t * 4 + o[1]], c = tetV[t * 4 + o[2]];
+                const a = tm.getVertexIndex(t, o[0]), b = tm.getVertexIndex(t, o[1]), c = tm.getVertexIndex(t, o[2]);
                 const k = face_key(a, b, c);
                 if (boundary.has(k)) boundary.delete(k);
                 else boundary.set(k, { a, b, c });
             }
         };
-        const add_verts = (t) => { for (let i = 0; i < 4; i++) pieceVerts.add(tetV[t * 4 + i]); };
+        const add_verts = (t) => { for (let i = 0; i < 4; i++) pieceVerts.add(tm.getVertexIndex(t, i)); };
 
         // Convex iff every boundary-face PLANE is supporting: all vertices lie
         // on one side of it. Orientation-free — no need to know which side is
@@ -124,20 +110,20 @@ export function build_convex_decomposition(meshShape) {
         const convex_with = (candVerts) => {
             for (const [, fc] of boundary) {
                 const ax = tp[fc.a * 3], ay = tp[fc.a * 3 + 1], az = tp[fc.a * 3 + 2];
-                const e1x = tp[fc.b * 3] - ax, e1y = tp[fc.b * 3 + 1] - ay, e1z = tp[fc.b * 3 + 2] - az;
-                const e2x = tp[fc.c * 3] - ax, e2y = tp[fc.c * 3 + 1] - ay, e2z = tp[fc.c * 3 + 2] - az;
-                let nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
-                const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-                nx /= len; ny /= len; nz /= len;
+                v3_compute_triangle_normal(_face_normal, 0,
+                    ax, ay, az,
+                    tp[fc.b * 3], tp[fc.b * 3 + 1], tp[fc.b * 3 + 2],
+                    tp[fc.c * 3], tp[fc.c * 3 + 1], tp[fc.c * 3 + 2]);
+                const nx = _face_normal[0], ny = _face_normal[1], nz = _face_normal[2];
                 let pos = false, neg = false;
                 for (const v of pieceVerts) {
-                    const d = nx * (tp[v * 3] - ax) + ny * (tp[v * 3 + 1] - ay) + nz * (tp[v * 3 + 2] - az);
+                    const d = v3_dot(nx, ny, nz, tp[v * 3] - ax, tp[v * 3 + 1] - ay, tp[v * 3 + 2] - az);
                     if (d > EPS) pos = true; else if (d < -EPS) neg = true;
                     if (pos && neg) return false;
                 }
                 for (let i = 0; i < 4; i++) {
                     const v = candVerts[i];
-                    const d = nx * (tp[v * 3] - ax) + ny * (tp[v * 3 + 1] - ay) + nz * (tp[v * 3 + 2] - az);
+                    const d = v3_dot(nx, ny, nz, tp[v * 3] - ax, tp[v * 3 + 1] - ay, tp[v * 3 + 2] - az);
                     if (d > EPS) pos = true; else if (d < -EPS) neg = true;
                     if (pos && neg) return false;
                 }
@@ -146,13 +132,13 @@ export function build_convex_decomposition(meshShape) {
         };
 
         visited[seed] = 1;
-        pieceTets.push(seed);
         toggle_tet_faces(seed);
         add_verts(seed);
 
         const tried = new Set([seed]);
-        const frontier = neighbours(seed);
-        for (const n of frontier) tried.add(n);
+        const frontier = [];
+        const seed_nbr_count = tetrahedral_mesh_tet_get_neighbours(tm, tet_neighbours, 0, seed);
+        for (let i = 0; i < seed_nbr_count; i++) { frontier.push(tet_neighbours[i]); tried.add(tet_neighbours[i]); }
 
         while (frontier.length > 0) {
             const t = frontier.pop();
@@ -160,13 +146,14 @@ export function build_convex_decomposition(meshShape) {
 
             // Tentatively add t: toggle its faces into the boundary, test
             // convexity, then commit or revert (toggle is its own inverse).
-            const cand = [tetV[t * 4], tetV[t * 4 + 1], tetV[t * 4 + 2], tetV[t * 4 + 3]];
+            const cand = [tm.getVertexIndex(t, 0), tm.getVertexIndex(t, 1), tm.getVertexIndex(t, 2), tm.getVertexIndex(t, 3)];
             toggle_tet_faces(t);
             if (convex_with(cand)) {
                 visited[t] = 1;
-                pieceTets.push(t);
                 add_verts(t);
-                for (const n of neighbours(t)) {
+                const nbr_count = tetrahedral_mesh_tet_get_neighbours(tm, tet_neighbours, 0, t);
+                for (let i = 0; i < nbr_count; i++) {
+                    const n = tet_neighbours[i];
                     if (!visited[n] && !tried.has(n)) { tried.add(n); frontier.push(n); }
                 }
             } else {
@@ -192,11 +179,20 @@ export function build_convex_decomposition(meshShape) {
     return { pieces, bvh };
 }
 
-/** Build a clippable piece from its boundary triangles: coplanar-merge into
- *  polygon faces and localise vertex indices. `boundary` is a Map keyed by
- *  face_key → {a,b,c} (any winding; orientation is re-derived from the piece
- *  centroid). Exported so the convex-mesh fast path can build a single
- *  coplanar-merged hull from a whole mesh's boundary. */
+/**
+ * Build a clippable piece from its boundary triangles: coplanar-merge them into
+ * polygon faces and localise the vertex indices. Orientation is re-derived from
+ * the piece centroid, so the `boundary` triples may have any winding. Exported
+ * so the convex-mesh fast path ({@link mesh_convex_hull}) can build a single
+ * coplanar-merged hull from a whole mesh's boundary.
+ *
+ * @param {Float32Array|Float64Array|number[]} tp tet positions: flat `(x, y, z)`
+ *   per vertex, indexed by global vertex index
+ * @param {Map<string, {a:number, b:number, c:number}>} boundary boundary faces
+ *   keyed by {@link face_key}; each value is a vertex triple (any winding)
+ * @returns {{vertices: Float32Array, face_offsets: Uint32Array, face_loops: Uint32Array, aabb: Float64Array}}
+ *   a clippable convex piece — local vertices, CSR polygon-face loops, and local AABB
+ */
 export function build_piece(tp, boundary) {
     // Piece centroid (from boundary vertices) — strictly interior for a convex
     // piece, so it orients every face normal outward unambiguously.
@@ -210,16 +206,16 @@ export function build_piece(tp, boundary) {
     const groups = []; // { nx,ny,nz, off, tris: [[a,b,c], ...] }
     for (const [, fc] of boundary) {
         const ax = tp[fc.a * 3], ay = tp[fc.a * 3 + 1], az = tp[fc.a * 3 + 2];
-        const e1x = tp[fc.b * 3] - ax, e1y = tp[fc.b * 3 + 1] - ay, e1z = tp[fc.b * 3 + 2] - az;
-        const e2x = tp[fc.c * 3] - ax, e2y = tp[fc.c * 3 + 1] - ay, e2z = tp[fc.c * 3 + 2] - az;
-        let nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
-        const len = Math.hypot(nx, ny, nz) || 1;
-        nx /= len; ny /= len; nz /= len;
-        if (nx * (ax - pcx) + ny * (ay - pcy) + nz * (az - pcz) < 0) { nx = -nx; ny = -ny; nz = -nz; }
-        const off = nx * ax + ny * ay + nz * az;
+        v3_compute_triangle_normal(_face_normal, 0,
+            ax, ay, az,
+            tp[fc.b * 3], tp[fc.b * 3 + 1], tp[fc.b * 3 + 2],
+            tp[fc.c * 3], tp[fc.c * 3 + 1], tp[fc.c * 3 + 2]);
+        let nx = _face_normal[0], ny = _face_normal[1], nz = _face_normal[2];
+        if (v3_dot(nx, ny, nz, ax - pcx, ay - pcy, az - pcz) < 0) { nx = -nx; ny = -ny; nz = -nz; }
+        const off = v3_dot(nx, ny, nz, ax, ay, az);
         let g = null;
         for (const cand of groups) {
-            if (Math.abs(cand.nx * nx + cand.ny * ny + cand.nz * nz - 1) < PLANE_NORMAL_TOL
+            if (Math.abs(v3_dot(cand.nx, cand.ny, cand.nz, nx, ny, nz) - 1) < PLANE_NORMAL_TOL
                 && Math.abs(cand.off - off) < PLANE_OFFSET_TOL) { g = cand; break; }
         }
         if (g === null) { g = { nx, ny, nz, off, tris: [] }; groups.push(g); }
@@ -252,7 +248,7 @@ export function build_piece(tp, boundary) {
 
         const items = varr.map((gv) => {
             const dx = tp[gv * 3] - cx, dy = tp[gv * 3 + 1] - cy, dz = tp[gv * 3 + 2] - cz;
-            return { gv, ang: Math.atan2(dx * vx + dy * vy + dz * vz, dx * ux + dy * uy + dz * uz) };
+            return { gv, ang: Math.atan2(v3_dot(dx, dy, dz, vx, vy, vz), v3_dot(dx, dy, dz, ux, uy, uz)) };
         });
         items.sort((p, q) => p.ang - q.ang);
         loops.push(items.map((it) => it.gv));

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

@@ -1 +1 @@
-{"version":3,"file":"mesh_convex_hull.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/mesh_convex_hull.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,gDAJW;IAAC,QAAQ,CAAC;IAAC,aAAa,CAAC;IAAC,oBAAoB,CAAA;CAAC,GAC7C;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAC;IAAC,IAAI,EAAC,YAAY,CAAC;IAAC,OAAO,WAAS;CAAC,GAAC,IAAI,CAQ/H"}
+{"version":3,"file":"mesh_convex_hull.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/mesh_convex_hull.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,gDAJW;IAAC,QAAQ,CAAC;IAAC,aAAa,CAAC;IAAC,oBAAoB,CAAA;CAAC,GAC7C;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAC;IAAC,IAAI,EAAC,YAAY,CAAC;IAAC,OAAO,WAAS;CAAC,GAAC,IAAI,CAQ/H"}

package/src/engine/physics/narrowphase/mesh_convex_hull.js

@@ -1,5 +1,10 @@
+import { v3_compute_triangle_normal } from "../../../core/geom/3d/triangle/v3_compute_triangle_normal.js";
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
 import { build_piece, face_key, FACE_OPP } from "./convex_decomposition.js";
 
+// Reusable scratch for v3_compute_triangle_normal (writes a unit normal as 3 floats).
+const _face_normal = new Float64Array(3);
+
 /**
  * Convex fast path for a triangulated {@link MeshShape3D}: if the whole mesh is
  * convex, represent it as a single coplanar-merged convex piece so it collides
@@ -73,15 +78,15 @@ function build_if_convex(meshShape) {
         if (fc.count !== 1) continue;
         boundaryCount++;
         const ax = tp[fc.a * 3], ay = tp[fc.a * 3 + 1], az = tp[fc.a * 3 + 2];
-        const e1x = tp[fc.b * 3] - ax, e1y = tp[fc.b * 3 + 1] - ay, e1z = tp[fc.b * 3 + 2] - az;
-        const e2x = tp[fc.c * 3] - ax, e2y = tp[fc.c * 3 + 1] - ay, e2z = tp[fc.c * 3 + 2] - az;
-        let nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
+        v3_compute_triangle_normal(_face_normal, 0,
+            ax, ay, az,
+            tp[fc.b * 3], tp[fc.b * 3 + 1], tp[fc.b * 3 + 2],
+            tp[fc.c * 3], tp[fc.c * 3 + 1], tp[fc.c * 3 + 2]);
+        let ix = _face_normal[0], iy = _face_normal[1], iz = _face_normal[2];
         const ox = tp[fc.opp * 3] - ax, oy = tp[fc.opp * 3 + 1] - ay, oz = tp[fc.opp * 3 + 2] - az;
-        if (nx * ox + ny * oy + nz * oz > 0) { nx = -nx; ny = -ny; nz = -nz; } // outward
-        const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-        const ix = nx / len, iy = ny / len, iz = nz / len;
+        if (v3_dot(ix, iy, iz, ox, oy, oz) > 0) { ix = -ix; iy = -iy; iz = -iz; } // outward
         for (let v = 0; v < nVerts; v++) {
-            const d = ix * (tp[v * 3] - ax) + iy * (tp[v * 3 + 1] - ay) + iz * (tp[v * 3 + 2] - az);
+            const d = v3_dot(ix, iy, iz, tp[v * 3] - ax, tp[v * 3 + 1] - ay, tp[v * 3 + 2] - az);
             if (d > EPS) return null; // a vertex in front of a face → concave
         }
         boundary.set(k, { a: fc.a, b: fc.b, c: fc.c });
@@ -95,7 +100,7 @@ function build_if_convex(meshShape) {
     piece.support = function (result, result_offset, dx, dy, dz) {
         let bi = 0, best = -Infinity;
         for (let i = 0; i < vc; i++) {
-            const d = dx * v[i * 3] + dy * v[i * 3 + 1] + dz * v[i * 3 + 2];
+            const d = v3_dot(dx, dy, dz, v[i * 3], v[i * 3 + 1], v[i * 3 + 2]);
             if (d > best) { best = d; bi = i; }
         }
         result[result_offset] = v[bi * 3];

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

@@ -1 +1 @@
-{"version":3,"file":"refine_ray_concave.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_concave.js"],"names":[],"mappings":"AAsCA;;;;;;;;;GASG;AACH,qEARW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAClB,MAAM,CAyGlB"}
+{"version":3,"file":"refine_ray_concave.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_concave.js"],"names":[],"mappings":"AAwCA;;;;;;;;;GASG;AACH,qEARW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAClB,MAAM,CAyGlB"}

package/src/engine/physics/narrowphase/refine_ray_concave.js

@@ -1,4 +1,6 @@
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import { v3_quat3_apply } from "../../../core/geom/vec3/v3_quat3_apply.js";
+import { v3_quat3_apply_inverse } from "../../../core/geom/vec3/v3_quat3_apply_inverse.js";
 import { TRIANGLE_FLOAT_STRIDE } from "./decomposition/triangle_buffer_layout.js";
 import { mesh_enumerate_triangles } from "./decomposition/mesh_enumerate_triangles.js";
 import { heightmap_enumerate_triangles } from "./decomposition/heightmap_enumerate_triangles.js";
@@ -49,8 +51,8 @@ const AABB_FATTEN = 1e-5; // guards triangles whose AABB just abuts the segment
 export function refine_ray_concave(shape, position, rotation, ox, oy, oz, dx, dy, dz, tMax, outNormal) {
     const qx = rotation[0], qy = rotation[1], qz = rotation[2], qw = rotation[3];
     // World → local (inverse body rotation; unit dir stays unit → t preserved).
-    v3_quat3_apply(lo, 0, ox - position.x, oy - position.y, oz - position.z, -qx, -qy, -qz, qw);
-    v3_quat3_apply(ld, 0, dx, dy, dz, -qx, -qy, -qz, qw);
+    v3_quat3_apply_inverse(lo, 0, ox - position.x, oy - position.y, oz - position.z, qx, qy, qz, qw);
+    v3_quat3_apply_inverse(ld, 0, dx, dy, dz, qx, qy, qz, qw);
     const lox = lo[0], loy = lo[1], loz = lo[2];
     const ldx = ld[0], ldy = ld[1], ldz = ld[2];
 
@@ -143,7 +145,7 @@ export function refine_ray_concave(shape, position, rotation, ox, oy, oz, dx, dy
     if (!found) return Infinity;
 
     // Normalise, orient to face the ray, then rotate the local normal to world.
-    let nl = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    let nl = v3_length(nx, ny, nz);
     if (nl === 0) nl = 1;
     nx /= nl; ny /= nl; nz /= nl;
     if (nx * ldx + ny * ldy + nz * ldz > 0) { nx = -nx; ny = -ny; nz = -nz; }

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

@@ -1 +1 @@
-{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iEAVW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CAsClB;AAzED;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}
+{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,iEAVW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MAAa,MAAM,MAAa,MAAM,MAC5C,MAAM,MAAa,MAAM,MAAa,MAAM,QAC5C,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CAsClB;AAzED;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}