@woosh/meep-engine 2.146.0 → 2.148.0

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

@@ -1 +1 @@
-{"version":3,"file":"box_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_triangle_contact.js"],"names":[],"mappings":"AAuNA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAtBW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAuJnB;AAxUD;;;GAGG;AACH,sCAFU,MAAM,CAEyD"}
+{"version":3,"file":"box_triangle_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/box_triangle_contact.js"],"names":[],"mappings":"AAyLA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAtBW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAuJnB;AAvSD;;;GAGG;AACH,sCAFU,MAAM,CAEyD"}

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

@@ -1,5 +1,8 @@
-import { line3_closest_points_segment_segment } from "../../../core/geom/3d/line/line3_closest_points_segment_segment.js";
+import {
+    line3_closest_points_segment_segment
+} from "../../../core/geom/3d/line/line3_closest_points_segment_segment.js";
 import { quat3_to_matrix3 } from "../../../core/geom/3d/quaternion/quat3_to_matrix3.js";
+import { clip_against_axis_uv } from "./clip_against_axis_uv.js";
 
 /**
  * Multi-point manifold construction for an oriented box vs. a triangle.
@@ -97,39 +100,6 @@ function projected_box_half_extent(axes, hx, hy, hz, ux, uy, uz) {
          + (pz < 0 ? -pz : pz) * hz;
 }
 
-/**
- * Sutherland-Hodgman clip of `points_in` against the axis-aligned
- * half-plane `coord_idx ≤ bound` (or `coord_idx ≥ bound` when
- * `keep_below` is false). 2D stride 2; result to `points_out`.
- * Returns surviving vertex count.
- */
-function clip_against_axis_uv(points_in, point_count, points_out, coord_idx, bound, keep_below) {
-    let out_count = 0;
-    for (let i = 0; i < point_count; i++) {
-        const j = (i + 1) % point_count;
-        const ax = points_in[i * 2],     ay = points_in[i * 2 + 1];
-        const bx = points_in[j * 2],     by = points_in[j * 2 + 1];
-        const av = coord_idx === 0 ? ax : ay;
-        const bv = coord_idx === 0 ? bx : by;
-        const a_inside = keep_below ? (av <= bound) : (av >= bound);
-        const b_inside = keep_below ? (bv <= bound) : (bv >= bound);
-
-        if (a_inside) {
-            points_out[out_count * 2] = ax;
-            points_out[out_count * 2 + 1] = ay;
-            out_count++;
-        }
-        if (a_inside !== b_inside) {
-            const denom = bv - av;
-            const t = denom !== 0 ? (bound - av) / denom : 0;
-            points_out[out_count * 2]     = ax + (bx - ax) * t;
-            points_out[out_count * 2 + 1] = ay + (by - ay) * t;
-            out_count++;
-        }
-    }
-    return out_count;
-}
-
 /**
  * Sutherland-Hodgman clip of `points_in` against the general half-plane
  * `(p - (line_ox, line_oy)) · (line_nx, line_ny) ≤ 0`. 2D stride 2;
@@ -524,18 +494,21 @@ function emit_triangle_face_manifold(
     tnx, tny, tnz,
     nx, ny, nz
 ) {
-    // Triangle's outward face normal points box → triangle = -n.
-    // (Triangle is the reference, so its outward normal is the direction
-    // the box should be pushed to separate — opposite of triangle → box.)
-    const ref_out_x = -nx;
-    const ref_out_y = -ny;
-    const ref_out_z = -nz;
-    // But we also need to ensure ref_out aligns with the triangle's CCW
-    // face normal (tn). If tn opposes ref_out, the triangle is "facing
-    // away" from the box — would happen on a thin-shell mesh; in that
-    // case our SAT axis came from the FRONT face direction and ref_out
-    // is still correct geometrically. Either way, we use the
-    // sign-canonicalised contact normal as the source of truth.
+    // Reference = triangle. Its outward face normal points from the triangle
+    // surface toward the box — i.e. the contact normal `n` (triangle → box),
+    // which the SAT already sign-canonicalised. The incident box face is then
+    // the one whose outward normal is most antiparallel to this (the box face
+    // actually facing the triangle), and the per-point depth below measures the
+    // penetration of THAT face — not the box's far face.
+    //
+    // (The earlier `-n` here pointed the reference normal into the terrain, so
+    // the incident picker selected the box's FAR face and the plane-to-plane
+    // depth ballooned to ~the box's thickness for any tilted box — catapulting
+    // rocking boxes off heightmaps. See box_triangle_contact.spec.js
+    // "tilted box, shallow corner".)
+    const ref_out_x = nx;
+    const ref_out_y = ny;
+    const ref_out_z = nz;
 
     // Pick the incident box face: the one whose outward axis is most
     // antiparallel to ref_out.

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

@@ -0,0 +1,16 @@
+/**
+ * Sutherland-Hodgman clip of `points_in` against the axis-aligned
+ * half-plane `coord_idx ≤ bound` (or `coord_idx ≥ bound` when
+ * `keep_below` is false). 2D stride 2; result to `points_out`.
+ * Returns surviving vertex count.
+ *
+ * @param {Float64Array} points_in
+ * @param {number} point_count
+ * @param {Float64Array} points_out
+ * @param {number} coord_idx 0 = u, 1 = v
+ * @param {number} bound
+ * @param {boolean} keep_below true to keep points with coord ≤ bound
+ * @returns {number} surviving vertex count
+ */
+export function clip_against_axis_uv(points_in: Float64Array, point_count: number, points_out: Float64Array, coord_idx: number, bound: number, keep_below: boolean): number;
+//# sourceMappingURL=clip_against_axis_uv.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clip_against_axis_uv.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/clip_against_axis_uv.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,gDARW,YAAY,eACZ,MAAM,cACN,YAAY,aACZ,MAAM,SACN,MAAM,cACN,OAAO,GACL,MAAM,CAoClB"}

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

@@ -0,0 +1,49 @@
+/**
+ * Sutherland-Hodgman clip of `points_in` against the axis-aligned
+ * half-plane `coord_idx ≤ bound` (or `coord_idx ≥ bound` when
+ * `keep_below` is false). 2D stride 2; result to `points_out`.
+ * Returns surviving vertex count.
+ *
+ * @param {Float64Array} points_in
+ * @param {number} point_count
+ * @param {Float64Array} points_out
+ * @param {number} coord_idx 0 = u, 1 = v
+ * @param {number} bound
+ * @param {boolean} keep_below true to keep points with coord ≤ bound
+ * @returns {number} surviving vertex count
+ */
+export function clip_against_axis_uv(points_in, point_count, points_out, coord_idx, bound, keep_below) {
+    let out_count = 0;
+
+    for (let i = 0; i < point_count; i++) {
+        const j = (i + 1) % point_count;
+
+        const ax = points_in[i * 2], ay = points_in[i * 2 + 1];
+        const bx = points_in[j * 2], by = points_in[j * 2 + 1];
+
+        const av = coord_idx === 0 ? ax : ay;
+        const bv = coord_idx === 0 ? bx : by;
+
+        const a_inside = keep_below ? (av <= bound) : (av >= bound);
+        const b_inside = keep_below ? (bv <= bound) : (bv >= bound);
+
+        if (a_inside) {
+            points_out[out_count * 2] = ax;
+            points_out[out_count * 2 + 1] = ay;
+            out_count++;
+        }
+
+        if (a_inside !== b_inside) {
+
+            const denom = bv - av;
+            const t = denom !== 0 ? (bound - av) / denom : 0;
+
+            points_out[out_count * 2] = ax + (bx - ax) * t;
+            points_out[out_count * 2 + 1] = ay + (by - ay) * t;
+
+            out_count++;
+        }
+    }
+
+    return out_count;
+}

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":"AA2zCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qDAVW,YAAY,GAAC,MAAM,EAAE,iCAGrB;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iCAErC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,GACnC,MAAM,CAyClB;AAED;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,CAAC,QA0JlE;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,QAuF3D"}
+{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AA8zCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qDAVW,YAAY,GAAC,MAAM,EAAE,iCAGrB;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iCAErC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,GACnC,MAAM,CAyClB;AAED;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,CAAC,QA4KlE;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,QAkH3D"}

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

@@ -403,9 +403,12 @@ function dispatch_pair(count, colA, trA, colB, trB, gjk_axis_buf = null, gjk_axi
     // `deepest_pair_penetration` query passes bare `{shape}` adapters with no
     // material fields — it never writes to a manifold, so 0 is fine there.
     const fa = colA.friction, fb = colB.friction;
+
     if (fa !== undefined && fb !== undefined) {
+
         g_pair_friction = combine_friction(fa, fb);
         g_pair_restitution = combine_restitution(colA.restitution, colB.restitution);
+
     } else {
         g_pair_friction = 0;
         g_pair_restitution = 0;
@@ -1429,22 +1432,29 @@ export function narrowphase_step(pair_list, manifolds, lists) {
     for (let i = 0; i < count; i++) {
         const idA = pair_list.get_a(i);
         const idB = pair_list.get_b(i);
+
         const idxA = body_id_index(idA);
         const idxB = body_id_index(idB);
 
         const list_a = lists[idxA];
         const list_b = lists[idxB];
+
         const slot = manifolds.find(idA, idB);
 
         if (list_a === undefined || list_b === undefined
-            || list_a.length === 0 || list_b.length === 0) {
+            || list_a.length === 0 || list_b.length === 0
+        ) {
+
             manifolds.clear_contacts(slot);
             continue;
+
         }
 
         let cand_count = 0;
+
         const la_len = list_a.length;
         const lb_len = list_b.length;
+
         // Per-manifold cached GJK separating-axis seed. Threaded into
         // dispatch_pair for the GJK fallback paths. For single-collider
         // bodies (the common case) there's no contention across the
@@ -1453,12 +1463,23 @@ export function narrowphase_step(pair_list, manifolds, lists) {
         // seed (better than a cold (1, 0, 0) restart every frame).
         const gjk_axis_buf = manifolds.slot_axis_buffer;
         const gjk_axis_off = manifolds.slot_axis_offset(slot);
+
         for (let a = 0; a < la_len; a++) {
             const ea = list_a[a];
+
             for (let b = 0; b < lb_len; b++) {
                 const eb = list_b[b];
-                cand_count = dispatch_pair(cand_count, ea.collider, ea.transform, eb.collider, eb.transform,
-                    gjk_axis_buf, gjk_axis_off);
+
+                cand_count = dispatch_pair(
+                    cand_count,
+                    ea.collider,
+                    ea.transform,
+                    eb.collider,
+                    eb.transform,
+                    gjk_axis_buf,
+                    gjk_axis_off
+                );
+
             }
         }
 
@@ -1667,7 +1688,34 @@ export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
             }
         }
 
-        if (best_k === -1) continue; // no unclaimed same-fid candidate this substep — keep frozen geometry
+        // Position fallback (mirrors narrowphase_step's match-and-merge). A
+        // single triangle's clipped contact count is NOT stable across sub-mm
+        // pose changes — a box straddling a cell seam can have one triangle
+        // yield 4 points one substep and 3 the next — so an existing contact can
+        // outnumber this substep's same-fid candidates. Freezing its stale
+        // witness then duplicates a sibling contact's point, leaving a
+        // degenerate (sub-dimensional) manifold. Instead, claim the nearest
+        // unclaimed candidate of ANY fid: every contact keeps a DISTINCT live
+        // witness. The fid label is left intact and re-resolved by the next
+        // once-per-step narrowphase. (At a fixed pose the same-fid match always
+        // succeeds, so this never fires for the depth-equality guards or the
+        // one-contact-per-triangle sphere/mesh paths.)
+        if (best_k === -1) {
+            for (let k = 0; k < cc; k++) {
+                if (redetect_claimed[k] === 1) continue;
+                const co = k * CANDIDATE_STRIDE;
+                const dx = candidates[co]     - pax;
+                const dy = candidates[co + 1] - pay;
+                const dz = candidates[co + 2] - paz;
+                const d2 = dx * dx + dy * dy + dz * dz;
+                if (d2 < best_d2) {
+                    best_d2 = d2;
+                    best_k = k;
+                }
+            }
+        }
+
+        if (best_k === -1) continue; // no unclaimed candidate at all this substep — keep frozen geometry
 
         redetect_claimed[best_k] = 1;
         const co = best_k * CANDIDATE_STRIDE;

package/src/engine/physics/queries/raycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/raycast.js"],"names":[],"mappings":"AA2IA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yGAJmB,MAAM,yBAAsB,OAAO,GAEzC,OAAO,CAwCnB"}
+{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/raycast.js"],"names":[],"mappings":"AA8IA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yGAJmB,MAAM,yBAAsB,OAAO,GAEzC,OAAO,CAwCnB"}

package/src/engine/physics/queries/raycast.js

@@ -1,4 +1,3 @@
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import {
     COLUMN_CHILD_1,
     COLUMN_CHILD_2,
@@ -6,9 +5,13 @@ import {
     ELEMENT_WORD_COUNT,
     NULL_NODE,
 } from "../../../core/bvh2/bvh3/BVH.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { returnTrue } from "../../../core/function/returnTrue.js";
-import { aabb3_near_distance_to_intersection_ray_segment } from "../../../core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js";
-import { refine_ray_hit, RAY_REFINE_UNSUPPORTED } from "../narrowphase/refine_ray_hit.js";
+import {
+    aabb3_near_distance_to_intersection_ray_segment
+} from "../../../core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js";
+import { body_id_index } from "../body/BodyStorage.js";
+import { RAY_REFINE_UNSUPPORTED, refine_ray_hit } from "../narrowphase/refine_ray_hit.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
@@ -104,7 +107,7 @@ function bvh_raycast_nearest(
         const body_id = uint32[address + COLUMN_USER_DATA];
         const entity = system.entityOf(body_id);
         if (entity < 0) continue; // unlinked concurrently
-        const idx = system.__index_of(body_id);
+        const idx = body_id_index(body_id);
         const collider = system.__primary_collider(idx);
         if (collider === null) continue;
         if (!filter(entity, collider)) continue;

package/src/engine/physics/solver/solve_contacts.d.ts

@@ -48,9 +48,9 @@ export function warm_start_contacts(manifolds: ManifoldStore, system: PhysicsSys
  * for the small per-step rotation), so they are not recomputed here.
  *
  * @param {ManifoldStore} manifolds
- * @param {PhysicsSystem} system
+ * @param {Transform[]} transforms
  */
-export function refresh_contacts(manifolds: ManifoldStore, system: PhysicsSystem): void;
+export function refresh_contacts(manifolds: ManifoldStore, transforms: Transform[]): void;
 /**
  * Stage 2b (per substep) — the concave counterpart of {@link refresh_contacts}.
  *

package/src/engine/physics/solver/solve_contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AAkbA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CA+JlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FAuCC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wFAgEC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iGAmFC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,QA2GhB;AAED;;;;;;;;;;;GAWG;AACH,yFA4DC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA4EhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAahB;AA7kCD;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}
+{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AA8fA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CA8LlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FA0CC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAFW,WAAW,QA4FrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iGAsGC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,QA8HhB;AAED;;;;;;;;;;;GAWG;AACH,yFAuDC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA2EhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAahB;AAnuCD;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}