@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -1,7 +1,7 @@
-import { tri3_closest_point_barycentric } from "../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
+import { tri3_closest_point_barycentric_array } from "../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
 import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
-import { capsule_world_segment } from "./capsule_contacts.js";
-import { sphere_triangle_contact } from "./sphere_triangle_contact.js";
+import { capsule_world_segment_array } from "./capsule_contacts.js";
+import { sphere_triangle_contact_array } from "./sphere_triangle_contact.js";
 
 /**
  * Multi-point capsule-vs-triangle contact generation.
@@ -80,47 +80,70 @@ const INSIDE_TRIANGLE_EPS_SQR = 1e-10;
 
 // --- scratch (allocation-free across calls) ---------------------------------
 
-const scratch_seg = new Float64Array(6);
 const scratch_bary = new Float64Array(2);
 const scratch_pair_st = new Float64Array(2);
-const scratch_seg_tri = new Float64Array(6); // closest segment / triangle world points
+const scratch_seg_tri = new Float64Array(7); // closest segment / triangle world points, their distance
 const scratch_sphere = new Float64Array(10);
 
+/** A cap's sphere, `[x, y, z, radius]`, for {@link try_endpoint_contact}. */
+const scratch_cap = new Float64Array(4);
+
+/** The case-0 intersection point, for the closest-point query. */
+const scratch_point = new Float64Array(3);
+
 // --- hoisted segment-vs-edge test (D3) -----------------------------------------
 //
 // `test_edge` used to be a per-call closure inside segment_triangle_closest —
 // allocated for every capsule-triangle candidate because it captures and
 // MUTATES the running closest-pair accumulator. Hoisted to module scope; the
-// segment endpoints + accumulator live in the g_ct_* slots, staged once per
-// call. Same arithmetic, same order — bit-identical results.
+// segment endpoints + accumulator live in `ct`, staged once per call. Same
+// arithmetic, same order — bit-identical results.
+//
+// Staged in a Float64Array, not module `let`s, which box every number written to
+// them; and the segment, the triangle and the cap spheres reach the helpers
+// below in arrays, because none of them is inlined, and a call that is not
+// inlined boxes every number passed to it.
 
-let g_ct_p1x = 0, g_ct_p1y = 0, g_ct_p1z = 0;
-let g_ct_p2x = 0, g_ct_p2y = 0, g_ct_p2z = 0;
-let g_ct_best_dist_sqr = Infinity;
-let g_ct_best_sx = 0, g_ct_best_sy = 0, g_ct_best_sz = 0;
-let g_ct_best_tx = 0, g_ct_best_ty = 0, g_ct_best_tz = 0;
+const CT_P1 = 0;              // segment endpoint 1, x y z
+const CT_P2 = 3;              // segment endpoint 2
+const CT_BEST_DIST_SQR = 6;
+const CT_BEST_S = 7;          // the running closest point on the segment
+const CT_BEST_T = 10;         // and on the triangle
+
+const ct = new Float64Array(13);
+
+/**
+ * Segment-vs-triangle-edge closest pair; folds into the running minimum in `ct`.
+ *
+ * @param {Float64Array} triangle
+ * @param {number} e1 offset of the edge's first endpoint in `triangle`
+ * @param {number} e2 offset of its second
+ */
+function test_edge(triangle, e1, e2) {
+    const p1x = ct[CT_P1], p1y = ct[CT_P1 + 1], p1z = ct[CT_P1 + 2];
+    const p2x = ct[CT_P2], p2y = ct[CT_P2 + 1], p2z = ct[CT_P2 + 2];
+    const e_p1x = triangle[e1], e_p1y = triangle[e1 + 1], e_p1z = triangle[e1 + 2];
+    const e_p2x = triangle[e2], e_p2y = triangle[e2 + 1], e_p2z = triangle[e2 + 2];
 
-/** Segment-vs-triangle-edge closest pair; folds into the g_ct_best_* minimum. */
-function test_edge(e_p1x, e_p1y, e_p1z, e_p2x, e_p2y, e_p2z) {
     line3_compute_segment_segment_closest_points(
         scratch_pair_st,
-        g_ct_p1x, g_ct_p1y, g_ct_p1z, g_ct_p2x, g_ct_p2y, g_ct_p2z,
+        p1x, p1y, p1z, p2x, p2y, p2z,
         e_p1x, e_p1y, e_p1z, e_p2x, e_p2y, e_p2z
     );
     const s = scratch_pair_st[0];
     const t = scratch_pair_st[1];
-    const sx = g_ct_p1x + s * (g_ct_p2x - g_ct_p1x);
-    const sy = g_ct_p1y + s * (g_ct_p2y - g_ct_p1y);
-    const sz = g_ct_p1z + s * (g_ct_p2z - g_ct_p1z);
+    const sx = p1x + s * (p2x - p1x);
+    const sy = p1y + s * (p2y - p1y);
+    const sz = p1z + s * (p2z - p1z);
     const tx = e_p1x + t * (e_p2x - e_p1x);
     const ty = e_p1y + t * (e_p2y - e_p1y);
     const tz = e_p1z + t * (e_p2z - e_p1z);
     const dx = sx - tx, dy = sy - ty, dz = sz - tz;
     const d_sqr = dx * dx + dy * dy + dz * dz;
-    if (d_sqr < g_ct_best_dist_sqr) {
-        g_ct_best_dist_sqr = d_sqr;
-        g_ct_best_sx = sx; g_ct_best_sy = sy; g_ct_best_sz = sz;
-        g_ct_best_tx = tx; g_ct_best_ty = ty; g_ct_best_tz = tz;
+    if (d_sqr < ct[CT_BEST_DIST_SQR]) {
+        ct[CT_BEST_DIST_SQR] = d_sqr;
+        ct[CT_BEST_S] = sx; ct[CT_BEST_S + 1] = sy; ct[CT_BEST_S + 2] = sz;
+        ct[CT_BEST_T] = tx; ct[CT_BEST_T + 1] = ty; ct[CT_BEST_T + 2] = tz;
     }
 }
 
@@ -141,21 +164,26 @@ function test_edge(e_p1x, e_p1y, e_p1z, e_p2x, e_p2y, e_p2z) {
  *    "segment interior closest to triangle edge" case that the
  *    endpoint queries miss.
  *
- * @param {number[]|Float64Array} out length >= 6
+ * The segment is the one staged in `ct` (`CT_P1`, `CT_P2`); the distance is written to `out[6]`
+ * rather than returned, which would box it.
+ *
+ * @param {number[]|Float64Array} out length >= 7
+ * @param {Float64Array} triangle apices A, B, C
+ * @param {number} triangle_offset
  */
-function segment_triangle_closest(
-    out,
-    p1x, p1y, p1z, p2x, p2y, p2z,
-    ax, ay, az, bx, by, bz, cx, cy, cz
-) {
-    // Stage the segment + reset the closest-pair accumulator for the hoisted
-    // test_edge (see the D3 note above it). Cases 1/2 below fold into the
-    // same accumulator.
-    g_ct_p1x = p1x; g_ct_p1y = p1y; g_ct_p1z = p1z;
-    g_ct_p2x = p2x; g_ct_p2y = p2y; g_ct_p2z = p2z;
-    g_ct_best_dist_sqr = Infinity;
-    g_ct_best_sx = 0; g_ct_best_sy = 0; g_ct_best_sz = 0;
-    g_ct_best_tx = 0; g_ct_best_ty = 0; g_ct_best_tz = 0;
+function segment_triangle_closest(out, triangle, triangle_offset) {
+    const p1x = ct[CT_P1], p1y = ct[CT_P1 + 1], p1z = ct[CT_P1 + 2];
+    const p2x = ct[CT_P2], p2y = ct[CT_P2 + 1], p2z = ct[CT_P2 + 2];
+
+    const ax = triangle[triangle_offset], ay = triangle[triangle_offset + 1], az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3], by = triangle[triangle_offset + 4], bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6], cy = triangle[triangle_offset + 7], cz = triangle[triangle_offset + 8];
+
+    // Reset the closest-pair accumulator for the hoisted test_edge (see the D3
+    // note above it). Cases 1/2 below fold into the same accumulator.
+    ct[CT_BEST_DIST_SQR] = Infinity;
+    ct[CT_BEST_S] = 0; ct[CT_BEST_S + 1] = 0; ct[CT_BEST_S + 2] = 0;
+    ct[CT_BEST_T] = 0; ct[CT_BEST_T + 1] = 0; ct[CT_BEST_T + 2] = 0;
 
     // --- Case 0: segment intersects triangle plane INSIDE the face -----------
     const dx_seg = p2x - p1x, dy_seg = p2y - p1y, dz_seg = p2z - p1z;
@@ -176,13 +204,8 @@ function segment_triangle_closest(
             // closest point on the triangle. If the closest point equals
             // the input (within INSIDE_TRIANGLE_EPS_SQR), the intersection
             // is inside the face.
-            tri3_closest_point_barycentric(
-                scratch_bary, 0,
-                ix, iy, iz,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
-            );
+            scratch_point[0] = ix; scratch_point[1] = iy; scratch_point[2] = iz;
+            tri3_closest_point_barycentric_array(scratch_bary, 0, scratch_point, 0, triangle, triangle_offset);
             const alpha = scratch_bary[0];
             const beta = scratch_bary[1];
             const gamma = 1 - alpha - beta;
@@ -193,19 +216,14 @@ function segment_triangle_closest(
             if (diff_x * diff_x + diff_y * diff_y + diff_z * diff_z < INSIDE_TRIANGLE_EPS_SQR) {
                 out[0] = ix; out[1] = iy; out[2] = iz;
                 out[3] = ix; out[4] = iy; out[5] = iz;
-                return 0;
+                out[6] = 0;
+                return;
             }
         }
     }
 
     // --- Case 1: P1 vs closest-on-triangle -----------------------------------
-    tri3_closest_point_barycentric(
-        scratch_bary, 0,
-        p1x, p1y, p1z,
-        ax, ay, az,
-        bx, by, bz,
-        cx, cy, cz
-    );
+    tri3_closest_point_barycentric_array(scratch_bary, 0, ct, CT_P1, triangle, triangle_offset);
     {
         const alpha = scratch_bary[0];
         const beta = scratch_bary[1];
@@ -215,21 +233,15 @@ function segment_triangle_closest(
         const qz = alpha * az + beta * bz + gamma * cz;
         const dx = p1x - qx, dy = p1y - qy, dz = p1z - qz;
         const d_sqr = dx * dx + dy * dy + dz * dz;
-        if (d_sqr < g_ct_best_dist_sqr) {
-            g_ct_best_dist_sqr = d_sqr;
-            g_ct_best_sx = p1x; g_ct_best_sy = p1y; g_ct_best_sz = p1z;
-            g_ct_best_tx = qx;  g_ct_best_ty = qy;  g_ct_best_tz = qz;
+        if (d_sqr < ct[CT_BEST_DIST_SQR]) {
+            ct[CT_BEST_DIST_SQR] = d_sqr;
+            ct[CT_BEST_S] = p1x; ct[CT_BEST_S + 1] = p1y; ct[CT_BEST_S + 2] = p1z;
+            ct[CT_BEST_T] = qx;  ct[CT_BEST_T + 1] = qy;  ct[CT_BEST_T + 2] = qz;
         }
     }
 
     // --- Case 2: P2 vs closest-on-triangle -----------------------------------
-    tri3_closest_point_barycentric(
-        scratch_bary, 0,
-        p2x, p2y, p2z,
-        ax, ay, az,
-        bx, by, bz,
-        cx, cy, cz
-    );
+    tri3_closest_point_barycentric_array(scratch_bary, 0, ct, CT_P2, triangle, triangle_offset);
     {
         const alpha = scratch_bary[0];
         const beta = scratch_bary[1];
@@ -239,21 +251,21 @@ function segment_triangle_closest(
         const qz = alpha * az + beta * bz + gamma * cz;
         const dx = p2x - qx, dy = p2y - qy, dz = p2z - qz;
         const d_sqr = dx * dx + dy * dy + dz * dz;
-        if (d_sqr < g_ct_best_dist_sqr) {
-            g_ct_best_dist_sqr = d_sqr;
-            g_ct_best_sx = p2x; g_ct_best_sy = p2y; g_ct_best_sz = p2z;
-            g_ct_best_tx = qx;  g_ct_best_ty = qy;  g_ct_best_tz = qz;
+        if (d_sqr < ct[CT_BEST_DIST_SQR]) {
+            ct[CT_BEST_DIST_SQR] = d_sqr;
+            ct[CT_BEST_S] = p2x; ct[CT_BEST_S + 1] = p2y; ct[CT_BEST_S + 2] = p2z;
+            ct[CT_BEST_T] = qx;  ct[CT_BEST_T + 1] = qy;  ct[CT_BEST_T + 2] = qz;
         }
     }
 
     // --- Cases 3..5: segment vs each triangle edge (hoisted helper) ----------
-    test_edge(ax, ay, az, bx, by, bz);
-    test_edge(bx, by, bz, cx, cy, cz);
-    test_edge(cx, cy, cz, ax, ay, az);
+    test_edge(triangle, triangle_offset, triangle_offset + 3);
+    test_edge(triangle, triangle_offset + 3, triangle_offset + 6);
+    test_edge(triangle, triangle_offset + 6, triangle_offset);
 
-    out[0] = g_ct_best_sx; out[1] = g_ct_best_sy; out[2] = g_ct_best_sz;
-    out[3] = g_ct_best_tx; out[4] = g_ct_best_ty; out[5] = g_ct_best_tz;
-    return Math.sqrt(g_ct_best_dist_sqr);
+    out[0] = ct[CT_BEST_S]; out[1] = ct[CT_BEST_S + 1]; out[2] = ct[CT_BEST_S + 2];
+    out[3] = ct[CT_BEST_T]; out[4] = ct[CT_BEST_T + 1]; out[5] = ct[CT_BEST_T + 2];
+    out[6] = Math.sqrt(ct[CT_BEST_DIST_SQR]);
 }
 
 // --- main --------------------------------------------------------------------
@@ -286,17 +298,50 @@ export function capsule_triangle_contact(
     c_cx, c_cy, c_cz, c_qx, c_qy, c_qz, c_qw, c_radius, c_half_h,
     ax, ay, az, bx, by, bz, cx, cy, cz
 ) {
-    // Capsule's world-space segment endpoints.
-    capsule_world_segment(scratch_seg, c_cx, c_cy, c_cz, c_qx, c_qy, c_qz, c_qw, c_half_h);
-    const sax = scratch_seg[0], say = scratch_seg[1], saz = scratch_seg[2];
-    const sbx = scratch_seg[3], sby = scratch_seg[4], sbz = scratch_seg[5];
+    const capsule = scratch_capsule;
+    const triangle = scratch_triangle;
+
+    capsule[0] = c_cx; capsule[1] = c_cy; capsule[2] = c_cz;
+    capsule[3] = c_qx; capsule[4] = c_qy; capsule[5] = c_qz; capsule[6] = c_qw;
+    capsule[7] = c_radius; capsule[8] = c_half_h;
+
+    triangle[0] = ax; triangle[1] = ay; triangle[2] = az;
+    triangle[3] = bx; triangle[4] = by; triangle[5] = bz;
+    triangle[6] = cx; triangle[7] = cy; triangle[8] = cz;
+
+    return capsule_triangle_contact_array(out, capsule, 0, triangle, 0);
+}
+
+/** Where {@link capsule_triangle_contact} packs its capsule and its triangle. */
+const scratch_capsule = new Float64Array(9);
+const scratch_triangle = new Float64Array(9);
+
+/**
+ * {@link capsule_triangle_contact} with the capsule and the triangle read from arrays: a call V8 does
+ * not inline boxes each number passed to it, eighteen here, once per triangle under a capsule.
+ *
+ * @param {Float64Array} out length >= CAPSULE_TRIANGLE_MAX_CONTACTS * CAPSULE_TRIANGLE_CONTACT_STRIDE
+ * @param {Float64Array} capsule centre (world), orientation (unit quaternion), radius, half-height
+ *   (not including caps) — nine numbers
+ * @param {number} capsule_offset
+ * @param {Float64Array} triangle vertices A, B, C (world)
+ * @param {number} triangle_offset
+ * @returns {number} number of contacts emitted, in `[0, CAPSULE_TRIANGLE_MAX_CONTACTS]`
+ */
+export function capsule_triangle_contact_array(out, capsule, capsule_offset, triangle, triangle_offset) {
+    const c_radius = capsule[capsule_offset + 7];
+
+    const ax = triangle[triangle_offset], ay = triangle[triangle_offset + 1], az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3], by = triangle[triangle_offset + 4], bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6], cy = triangle[triangle_offset + 7], cz = triangle[triangle_offset + 8];
+
+    // Capsule's world-space segment endpoints, staged for segment_triangle_closest: `ct` holds them
+    // at CT_P1 and CT_P2, six numbers from 0, as capsule_world_segment_array writes them.
+    capsule_world_segment_array(ct, capsule, capsule_offset);
 
     // Primary contact: closest segment point ↔ closest triangle point.
-    const dist = segment_triangle_closest(
-        scratch_seg_tri,
-        sax, say, saz, sbx, sby, sbz,
-        ax, ay, az, bx, by, bz, cx, cy, cz
-    );
+    segment_triangle_closest(scratch_seg_tri, triangle, triangle_offset);
+    const dist = scratch_seg_tri[6];
     if (dist >= c_radius) return 0;
 
     const seg_pt_x = scratch_seg_tri[0];
@@ -344,8 +389,14 @@ export function capsule_triangle_contact(
 
     // Endpoint sphere contacts. Inline the 2 endpoint queries to keep
     // allocation-free.
-    count = try_endpoint_contact(out, count, sax, say, saz, c_radius, ax, ay, az, bx, by, bz, cx, cy, cz);
-    count = try_endpoint_contact(out, count, sbx, sby, sbz, c_radius, ax, ay, az, bx, by, bz, cx, cy, cz);
+    const cap = scratch_cap;
+    cap[3] = c_radius;
+
+    cap[0] = ct[CT_P1]; cap[1] = ct[CT_P1 + 1]; cap[2] = ct[CT_P1 + 2];
+    count = try_endpoint_contact(out, count, cap, triangle, triangle_offset);
+
+    cap[0] = ct[CT_P2]; cap[1] = ct[CT_P2 + 1]; cap[2] = ct[CT_P2 + 2];
+    count = try_endpoint_contact(out, count, cap, triangle, triangle_offset);
 
     return count;
 }
@@ -355,18 +406,15 @@ export function capsule_triangle_contact(
  * resulting contact to `out` (with spatial dedup against the
  * already-emitted entries). Returns the new contact count.
  *
+ * @param {Float64Array} out
+ * @param {number} count
+ * @param {Float64Array} cap the cap's sphere, `[x, y, z, radius]`
+ * @param {Float64Array} triangle
+ * @param {number} triangle_offset
  * @returns {number}
  */
-function try_endpoint_contact(
-    out, count,
-    cap_x, cap_y, cap_z, radius,
-    ax, ay, az, bx, by, bz, cx, cy, cz
-) {
-    const ok = sphere_triangle_contact(
-        scratch_sphere,
-        cap_x, cap_y, cap_z, radius,
-        ax, ay, az, bx, by, bz, cx, cy, cz
-    );
+function try_endpoint_contact(out, count, cap, triangle, triangle_offset) {
+    const ok = sphere_triangle_contact_array(scratch_sphere, cap, 0, triangle, triangle_offset);
     if (!ok) return count;
 
     const e_nx = scratch_sphere[0], e_ny = scratch_sphere[1], e_nz = scratch_sphere[2];

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

@@ -31,18 +31,24 @@
  *     resting on a large box reports the few-cm overlap through the near face
  *     rather than the metres-deep "exit through the far side" a centroid-seeded
  *     MPR portal used to return.
- *   - **general convex pairs** (anything without a closed form) → GJK + EPA,
- *     which is exact for polytopes and is only ever reached by polytope-like
- *     shapes here, since every curved primitive (sphere, capsule) has a closed
- *     form above.
+ *   - **convex hull pairs** → a hull against a hull or a box takes the GJK +
+ *     EPA axis and the hull face clip; against a sphere, a closed form.
+ *   - **every other convex pair** (a cylinder against anything, a capsule
+ *     against a hull, a scaling TransformedShape3D) → GJK + EPA for the axis
+ *     and depth, the contacts from the two shapes' supporting features. EPA is
+ *     exact for polytopes; on a curved support (the cylinder's side, the
+ *     capsule's ends) its depth is good to its convergence tolerance. A rigid
+ *     TransformedShape3D is collided as its subject, so it takes whichever of
+ *     these its subject does.
  *   - **convex vs concave** (one of heightmap / mesh) → triangle decomposition
  *     over the convex AABB + the closed-form per-triangle solvers
- *     (`sphere_triangle`, `box_triangle`, `capsule_triangle`), deepest wins.
+ *     (`sphere_triangle`, `box_triangle`, `capsule_triangle`), or GJK + EPA and
+ *     the supporting features for any other convex shape, deepest wins.
  *     These are bounded to each triangle's true 2-D extent, so the historical
  *     over-report on closed-mesh side faces (infinite-plane extrapolation) is
  *     gone.
  *
- * ## Convex-vs-concave recovery (fully-tunnelled bodies)
+ * ## Convex-vs-concave recovery (tunnelled bodies)
  *
  * The per-triangle closed-form solvers are intentionally one-sided: a convex
  * shape that has crossed to the *inner* side of a surface produces no
@@ -52,8 +58,19 @@
  * back out. When the primary dispatch finds no contact for a convex-vs-concave
  * pair, this function falls back to a half-space test
  * ({@link concave_recovery_penetration}) that reports the outward push-out
- * vector. This is exact for heightmap terrain and a valid (if not strictly
- * minimal) recovery direction for closed meshes.
+ * vector. What that recovers depends on what the concave shape is:
+ *
+ *   - A **heightmap** is solid everywhere under its surface, so a convex behind
+ *     one of its triangles is in it, crossing the surface or wholly below it,
+ *     and is pushed back up.
+ *   - A **mesh** is a surface. Only a convex that crosses one of its triangles
+ *     is recovered, through the triangle it crosses. A convex wholly behind a
+ *     mesh triangle without touching it — under a roof, beneath an open sheet,
+ *     wholly past a one-sided face it tunnelled through, or wholly inside a
+ *     closed mesh — is reported as not penetrating (0). This path used to push
+ *     such a convex out through the plane of any triangle near it, which
+ *     recovered a body sealed inside a closed mesh but also pushed a mover up
+ *     through a roof it was standing under.
  *
  * Concave-vs-concave throws — the M×N triangle-pair cost is out of scope (and
  * is also refused by the narrowphase for dynamic pairs).
@@ -62,9 +79,10 @@
  *
  * Every pose component is consumed as `position[0..2]` / `rotation[0..3]` —
  * here in the recovery path, and inside the {@link deepest_pair_penetration}
- * dispatch this hands them to. A `Transform64`'s `translation` / `rotation`
- * (`Float64Array` views — what the ECS callers pass), a `Vector3` /
- * `Quaternion` (both `Float64Array` subclasses) and plain `[x, y, z]` /
+ * dispatch this hands them to. A retained `Float64Array` the caller copied a
+ * Transform64's pose into (its `translation` / `rotation` accessors allocate
+ * a view per read), a `Vector3` / `Quaternion` (both `Float64Array`
+ * subclasses) and plain `[x, y, z]` /
  * `[x, y, z, w]` arrays all satisfy that; an `{x, y, z}` / `{x, y, z, w}`
  * object does NOT. Its components read as `undefined`, which trips
  * `Transform64.setTranslation`'s `assert.isNumber` in development — but

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

@@ -1 +1 @@
-{"version":3,"file":"compute_penetration.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/compute_penetration.js"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,mDAfW,YAAY,GAAC,MAAM,EAAE,wCAGrB,UAAU,MAAM,CAAC,cAEjB,UAAU,MAAM,CAAC,wCAGjB,UAAU,MAAM,CAAC,cAEjB,UAAU,MAAM,CAAC,GAEf,MAAM,CAwClB"}
+{"version":3,"file":"compute_penetration.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/compute_penetration.js"],"names":[],"mappings":"AAoGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6GG;AACH,mDAfW,YAAY,GAAC,MAAM,EAAE,wCAGrB,UAAU,MAAM,CAAC,cAEjB,UAAU,MAAM,CAAC,wCAGjB,UAAU,MAAM,CAAC,cAEjB,UAAU,MAAM,CAAC,GAEf,MAAM,CAwClB"}