@woosh/meep-engine 2.163.8 → 2.163.10

package/src/engine/navigation/mesh/{navmesh_polyanya_find_path.js → bt_mesh_face_find_path_polyanya.js}

@@ -1,7 +1,6 @@
 import { Uint32Heap4 } from "../../../core/collection/heap/Uint32Heap4.js";
 import { line_segment_intersection_fraction_2d } from "../../../core/geom/2d/line/line_segment_intersection_fraction_2d.js";
 import { triangle2d_compute_area } from "../../../core/geom/2d/triangle2d_compute_area.js";
-import { BinaryElementPool } from "../../../core/geom/3d/topology/struct/binary/BinaryElementPool.js";
 import { NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
 import { v2_distance } from "../../../core/geom/vec2/v2_distance.js";
 
@@ -28,13 +27,18 @@ import { v2_distance } from "../../../core/geom/vec2/v2_distance.js";
  * shortest root->interval->goal measured with straight 3D chords (a lower bound on the geodesic, hence
  * admissible); the terminal node's *exact* cost unfolds the goal into the node's frame instead.
  *
- * The output path is lifted back to 3D from vertex ids: turning corners are mesh vertices (exact
- * positions), the start/goal are the given 3D points, and a goal-edge bend is the exact point on that
- * edge. Standalone -- does not (yet) replace the bt_mesh_face_find_path + funnel pipeline in NavigationMesh.
+ * The output path FOLLOWS THE SURFACE: it is subdivided at every face-boundary edge the geodesic
+ * crosses, so each emitted segment lies within a single triangle -- it never flies over a convex crease
+ * nor tunnels through a concave fold. Turning corners are mesh vertices (exact positions); each edge
+ * crossing is the exact line-vs-edge intersection lifted to 3D by lerping the edge's two endpoints; the
+ * start/goal are the given 3D points. Collinear runs (a flat stretch with no real bend) are collapsed to
+ * their endpoints, so on a planar mesh the output is just the minimal corner polyline -- the subdivision
+ * only adds points where the surface actually folds. Wired into NavigationMesh.find_path.
  */
 
 const EPS = 1e-9;            // area-sign slack (cone inside/outside tests)
 const DEDUP_EPS = 1e-7;      // merge consecutive output points equal to within f32 reconstruction error
+const COLLINEAR_EPS = 1e-4;  // drop a path point whose perpendicular offset from its neighbours / span is below this
 
 // Parameter-space tolerance for edge fractions, interval coverage and vertex snapping. Vertices are
 // stored as float32, so a point that is geometrically on an edge endpoint or already-covered carries
@@ -66,7 +70,7 @@ function touch_distance(rx, ry, i0x, i0y, i1x, i1y, gx, gy) {
         tx = _reflect[0]; ty = _reflect[1];
     }
     const t = line_segment_intersection_fraction_2d(rx, ry, tx, ty, i0x, i0y, i1x, i1y);
-    if (!Number.isNaN(t) && t >= -PEPS && t <= 1 + PEPS) {
+    if (t >= -PEPS && t <= 1 + PEPS) { // -1 (no crossing) falls below -PEPS, so the range test rejects it
         return v2_distance(rx, ry, tx, ty);
     }
     return Math.min(
@@ -248,19 +252,20 @@ function is_corner(topology, vid) {
 
 // ---- node storage ----------------------------------------------------------------------------------
 
-// Search nodes live as fixed 16-word records in a BinaryElementPool's buffer, referenced by integer id,
+// Search nodes are fixed 16-word records packed into one flat ArrayBuffer, addressed by id*NODE_WORDS,
 // so the open list is a Uint32Heap4 (id + score) rather than an object heap -- NO per-node object
 // allocation, so the hot path produces no garbage and never triggers a GC pause (which would otherwise
-// jitter the rest of the engine). We drive the buffer with our own monotonic counter rather than the
-// pool's allocate()/clear(): nodes are never released mid-query and is_allocated() is never read, so the
-// pool's per-node occupancy bit and O(capacity) clear() would be pure overhead. The buffer reallocates
-// on grow, so the cached data_* views (and the node being expanded) are refreshed accordingly.
+// jitter the rest of the engine). Allocation is a monotonic bump counter reset per query; nodes are
+// never released mid-query, so there is no free list and no occupancy bookkeeping. The buffer only ever
+// grows (by doubling, copying the existing records over) and the two typed-array views are re-cached
+// after a grow. (A pooled allocator with a free list + occupancy bitset degenerates to exactly this
+// under a never-free, bump-allocated access pattern, so a raw buffer is the honest, lighter shape.)
 //
 // A node stores its entry edge as vertex ids (E0V,E1V) AND its 2D positions in the node's unfolded frame
 // (E0X,E0Y,E1X,E1Y), the root (ROOTVID + RX,RY in the frame; ROOTVID==NULL_ID is the start point), and
 // the interval as the fractions [T0,T1] along the edge. 3D is recovered at reconstruction from vertex
 // ids; a terminal node stores the goal edge (E0V,E1V) and the final bend's fraction along it (N_FCT,
-// NaN == a straight shot).
+// -1 == a straight shot, since a real bend fraction is in [0,1]).
 const N_FACE = 0, N_E0V = 1, N_E1V = 2;
 const N_E0X = 3, N_E0Y = 4, N_E1X = 5, N_E1Y = 6;
 const N_ROOTVID = 7, N_RX = 8, N_RY = 9;
@@ -269,22 +274,23 @@ const N_G = 12, N_PARENT = 13, N_TERMINAL = 14, N_FCT = 15;
 const NODE_WORDS = 16;
 const NULL_ID = 0xFFFFFFFF;
 
-const _node_pool = new BinaryElementPool(NODE_WORDS * 4, 1024);
 const _open = new Uint32Heap4();
 
+// node records: uint32 and float32 views overlaid on one ArrayBuffer (_node_df aliases _node_du's bytes)
+let _node_capacity = 1024;                            // capacity in nodes; grows by doubling
+let _node_du = new Uint32Array(_node_capacity * NODE_WORDS);
+let _node_df = new Float32Array(_node_du.buffer);
 let _node_count = 0;
-let _node_capacity = _node_pool.capacity;
-let _node_du = _node_pool.data_uint32;
-let _node_df = _node_pool.data_float32;
 
 /** Reserve the next node slot, growing (and re-caching the views) only when the buffer is full. */
 function alloc_node() {
     const id = _node_count++;
     if (id >= _node_capacity) {
-        _node_pool.ensure_capacity(id + 1);
-        _node_capacity = _node_pool.capacity;
-        _node_du = _node_pool.data_uint32;
-        _node_df = _node_pool.data_float32;
+        _node_capacity *= 2;
+        const grown = new Uint32Array(_node_capacity * NODE_WORDS);
+        grown.set(_node_du); // copy the existing records into the larger buffer
+        _node_du = grown;
+        _node_df = new Float32Array(grown.buffer);
     }
     return id;
 }
@@ -298,8 +304,8 @@ let _goal_v0 = 0, _goal_v1 = 0, _goal_v2 = 0;
 let _goal_w0 = 0, _goal_w1 = 0, _goal_w2 = 0;
 const _bw = new Float64Array(3);
 
-// root vertex ids gathered along the parent chain during reconstruction (reused, never shrinks)
-const _recon_roots = [];
+// edge-crossing points (flat x,y,z triples) gathered along the parent chain during reconstruction
+const _recon = [];
 
 function goal_weight(vid) {
     return vid === _goal_v0 ? _goal_w0 : (vid === _goal_v1 ? _goal_w1 : _goal_w2);
@@ -322,7 +328,7 @@ function goal_weight(vid) {
  * @param {number} goal_face triangle containing the goal point
  * @returns {number} number of path POINTS written (3 numbers each), 0 if no path
  */
-export function navmesh_polyanya_find_path(output, topology, sx, sy, sz, start_face, gx, gy, gz, goal_face) {
+export function bt_mesh_face_find_path_polyanya(output, topology, sx, sy, sz, start_face, gx, gy, gz, goal_face) {
     _sx = sx; _sy = sy; _sz = sz;
     _gx = gx; _gy = gy; _gz = gz;
 
@@ -373,41 +379,101 @@ export function navmesh_polyanya_find_path(output, topology, sx, sy, sz, start_f
 
     if (best === NULL_ID) return 0;
 
-    // reconstruct in 3D: distinct roots (start .. last turning corner), final goal-edge bend, goal
+    // Reconstruct a SURFACE-FOLLOWING path. Every node in the parent chain shares one continuous unfolded
+    // frame (each node's frame extends its parent's), so the whole route -- start, turning corners, goal --
+    // lays out as a single 2D polyline in that frame, and the point where the route crosses each face's
+    // entry edge is just the intersection of that polyline with the edge. Lifting each crossing back onto
+    // its 3D edge keeps every output segment inside one face (i.e. on the surface). Crossings that fall on
+    // a straight (flat) stretch collapse away in push_point, so flat meshes still yield minimal paths.
     const du = _node_du, df = _node_df;
-    _recon_roots.length = 0;
+    const bb = best * NODE_WORDS;
+
+    // the goal's position in the shared frame: unfold the goal-face apex from the terminal's entry edge
+    const t_e0v = du[bb + N_E0V], t_e1v = du[bb + N_E1V];
+    const t_e0x = df[bb + N_E0X], t_e0y = df[bb + N_E0Y], t_e1x = df[bb + N_E1X], t_e1y = df[bb + N_E1Y];
+    const g_apex = unfold_apex(topology, goal_face, t_e0v, t_e1v, t_e0x, t_e0y, t_e1x, t_e1y);
+    const goal_u = goal_weight(t_e0v) * t_e0x + goal_weight(t_e1v) * t_e1x + goal_weight(g_apex) * _apex[0];
+    const goal_v = goal_weight(t_e0v) * t_e0y + goal_weight(t_e1v) * t_e1y + goal_weight(g_apex) * _apex[1];
+    const t_fct = df[bb + N_FCT];
+
+    // walk the chain (goal end -> start), recording each entry-edge crossing in reverse path order
+    _recon.length = 0;
+    let next_u = goal_u, next_v = goal_v;     // the next waypoint toward the goal, in the shared frame
+    let prev_root = du[bb + N_ROOTVID];
+    let prev_rx = df[bb + N_RX], prev_ry = df[bb + N_RY];
+
     for (let n = best; n !== NULL_ID; n = du[n * NODE_WORDS + N_PARENT]) {
-        _recon_roots.push(du[n * NODE_WORDS + N_ROOTVID]);
-    }
+        const base = n * NODE_WORDS;
+        const rootVid = du[base + N_ROOTVID];
+        const rx = df[base + N_RX], ry = df[base + N_RY];
+
+        // a change of root means the route turned at the previous corridor's root: emit that corner
+        // (an exact mesh vertex -- the turning point) and aim subsequent crossings at it
+        if (rootVid !== prev_root) {
+            if (prev_root !== NULL_ID) {
+                topology.vertex_read_coordinate(_va, 0, prev_root);
+                _recon.push(_va[0], _va[1], _va[2]);
+            }
+            next_u = prev_rx; next_v = prev_ry;
+            prev_root = rootVid;
+        }
 
-    let count = 0;
-    for (let i = _recon_roots.length - 1; i >= 0; i--) {
-        const vid = _recon_roots[i];
-        if (vid === NULL_ID) {
-            count = push_point(output, count, _sx, _sy, _sz);
+        const e0v = du[base + N_E0V], e1v = du[base + N_E1V];
+        const e0x = df[base + N_E0X], e0y = df[base + N_E0Y], e1x = df[base + N_E1X], e1y = df[base + N_E1Y];
+
+        // fraction along the entry edge where the route root->next crosses it (the terminal's goal-edge
+        // bend is exact and pre-computed as N_FCT)
+        let u;
+        if (n === best && t_fct !== -1) {
+            u = t_fct;
         } else {
-            topology.vertex_read_coordinate(_va, 0, vid);
-            count = push_point(output, count, _va[0], _va[1], _va[2]);
+            u = line_segment_intersection_fraction_2d(rx, ry, next_u, next_v, e0x, e0y, e1x, e1y);
+            if (u === -1) {
+                // the route line grazes a shared vertex (passes through / just outside an edge endpoint,
+                // common when the geodesic runs along a row of grid vertices): snap to the nearer endpoint
+                const dx = next_u - rx, dy = next_v - ry;
+                const s0 = Math.abs(dx * (e0y - ry) - dy * (e0x - rx));
+                const s1 = Math.abs(dx * (e1y - ry) - dy * (e1x - rx));
+                u = s0 <= s1 ? 0 : 1;
+            }
         }
+
+        topology.vertex_read_coordinate(_va, 0, e0v);
+        topology.vertex_read_coordinate(_vb, 0, e1v);
+        _recon.push(_va[0] + (_vb[0] - _va[0]) * u, _va[1] + (_vb[1] - _va[1]) * u, _va[2] + (_vb[2] - _va[2]) * u);
+
+        prev_rx = rx; prev_ry = ry;
     }
 
-    const bb = best * NODE_WORDS;
-    const fct = df[bb + N_FCT];
-    if (!Number.isNaN(fct)) {
-        topology.vertex_read_coordinate(_va, 0, du[bb + N_E0V]);
-        topology.vertex_read_coordinate(_vb, 0, du[bb + N_E1V]);
-        count = push_point(output, count,
-            _va[0] + (_vb[0] - _va[0]) * fct,
-            _va[1] + (_vb[1] - _va[1]) * fct,
-            _va[2] + (_vb[2] - _va[2]) * fct);
+    // start, the crossings in path order (reverse of how they were collected), goal
+    let count = 0;
+    count = push_point(output, count, _sx, _sy, _sz);
+    for (let i = _recon.length - 3; i >= 0; i -= 3) {
+        count = push_point(output, count, _recon[i], _recon[i + 1], _recon[i + 2]);
     }
     count = push_point(output, count, _gx, _gy, _gz);
     return count / 3;
 }
 
-/** Append a 3D point unless it duplicates the previous one (within f32 reconstruction error). */
+/**
+ * Append a 3D point, collapsing collinear runs: if the previous point lies (within tolerance) on the
+ * segment between the one before it and the new point, it is redundant and gets replaced rather than
+ * kept. Flat stretches of a surface-following path thus reduce to their endpoints; genuine bends (turning
+ * corners, folds in the surface) survive.
+ */
 function push_point(output, count, x, y, z) {
-    if (count >= 3 &&
+    if (count >= 6) {
+        const ax = output[count - 6], ay = output[count - 5], az = output[count - 4];
+        const bx = output[count - 3], by = output[count - 2], bz = output[count - 1];
+        const abx = bx - ax, aby = by - ay, abz = bz - az;
+        const acx = x - ax, acy = y - ay, acz = z - az;
+        const cross_x = aby * acz - abz * acy, cross_y = abz * acx - abx * acz, cross_z = abx * acy - aby * acx;
+        const ac_len = Math.hypot(acx, acy, acz);
+        if (ac_len < DEDUP_EPS || Math.hypot(cross_x, cross_y, cross_z) <= COLLINEAR_EPS * ac_len) {
+            output[count - 3] = x; output[count - 2] = y; output[count - 1] = z;
+            return count;
+        }
+    } else if (count >= 3 &&
         Math.abs(output[count - 3] - x) <= DEDUP_EPS &&
         Math.abs(output[count - 2] - y) <= DEDUP_EPS &&
         Math.abs(output[count - 1] - z) <= DEDUP_EPS) {
@@ -459,8 +525,9 @@ function process_far_edge(topology, from_face, Pv, Px, Py, Qv, Qx, Qy, rx, ry, r
     let m = 0;
     const tR = line_segment_intersection_fraction_2d(rx, ry, i0x, i0y, Px, Py, Qx, Qy);
     const tL = line_segment_intersection_fraction_2d(rx, ry, i1x, i1y, Px, Py, Qx, Qy);
-    if (!Number.isNaN(tR) && tR > PEPS && tR < 1 - PEPS) _split[m++] = tR;
-    if (!Number.isNaN(tL) && tL > PEPS && tL < 1 - PEPS) _split[m++] = tL;
+    // -1 (no crossing) fails `> PEPS`, so the interior-fraction test rejects it without a NaN check
+    if (tR > PEPS && tR < 1 - PEPS) _split[m++] = tR;
+    if (tL > PEPS && tL < 1 - PEPS) _split[m++] = tL;
     if (m === 2 && _split[0] > _split[1]) { const t = _split[0]; _split[0] = _split[1]; _split[1] = t; }
 
     let prev = 0;
@@ -561,13 +628,13 @@ function emit_node(topology, neighbour, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid,
 
         const fcost = g + touch_distance(rx, ry, i0x, i0y, i1x, i1y, ggx, ggy);
 
-        let fct = NaN;
+        let fct = -1; // -1 = straight shot (no forced bend at an interval endpoint); a real bend is in [0,1]
         let tx = ggx, ty = ggy;
         if (triangle2d_compute_area(i0x, i0y, i1x, i1y, rx, ry) * triangle2d_compute_area(i0x, i0y, i1x, i1y, ggx, ggy) > 0) {
             reflect(ggx, ggy, i0x, i0y, i1x, i1y); tx = _reflect[0]; ty = _reflect[1];
         }
         const t = line_segment_intersection_fraction_2d(rx, ry, tx, ty, i0x, i0y, i1x, i1y);
-        if (Number.isNaN(t) || t < -PEPS || t > 1 + PEPS) {
+        if (t < -PEPS || t > 1 + PEPS) { // -1 (no crossing) is caught by `< -PEPS`
             const d0 = v2_distance(rx, ry, i0x, i0y) + v2_distance(i0x, i0y, ggx, ggy);
             const d1 = v2_distance(rx, ry, i1x, i1y) + v2_distance(i1x, i1y, ggx, ggy);
             fct = d0 <= d1 ? i0p : i1p;
@@ -579,6 +646,8 @@ function emit_node(topology, neighbour, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid,
         du[b + N_TERMINAL] = 1;
         du[b + N_ROOTVID] = rootVid === -1 ? NULL_ID : rootVid;
         du[b + N_E0V] = Pv; du[b + N_E1V] = Qv;
+        df[b + N_E0X] = Px; df[b + N_E0Y] = Py; df[b + N_E1X] = Qx; df[b + N_E1Y] = Qy;
+        df[b + N_RX] = rx; df[b + N_RY] = ry;
         du[b + N_PARENT] = parent;
         df[b + N_FCT] = fct;
         _open.insert(id, fcost);

package/src/engine/navigation/mesh/build/navmesh_build_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAmMxB;+BAlP8B,mEAAmE"}
+{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAmNxB;+BA3Q8B,mEAAmE"}

package/src/engine/navigation/mesh/build/navmesh_build_topology.js

@@ -41,8 +41,17 @@ import {
 import {
     bt_mesh_fill_small_holes
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js";
+import {
+    bt_mesh_simplify_by_error
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_simplify_by_error.js";
 import { clip_soup_against_overhangs } from "./clip_soup_against_overhangs.js";
 
+// Fraction of the agent radius used as the navmesh cleanup error budget (see the cleanup pass in
+// navmesh_build_topology). A larger agent cannot resolve fine surface detail and the walkable
+// surface was already inset by agent_radius during erosion, so a small fraction of it is a safe,
+// navigation-imperceptible bound on how far cleanup may move the surface or the walkable outline.
+const NAVMESH_SIMPLIFY_ERROR_FRACTION = 0.05;
+
 
 /**
  * Build from given scene geometry
@@ -98,6 +107,11 @@ export function navmesh_build_topology({
     let raw_triangles = [];
     let triangle_count = 0;
 
+    // NOTE: the inherited source tessellation is cleaned up at the end of this function by
+    // bt_mesh_simplify_by_error (interior coplanar fans + collinear boundary runs collapsed). A
+    // further win -- re-triangulating large flat regions to a minimal polygon set -- is left as a
+    // possible follow-up.
+
     for (let face_id = 0; face_id < source_face_count; face_id++) {
 
         source.face_read_normal(scratch_normal, 0, face_id);
@@ -234,6 +248,17 @@ export function navmesh_build_topology({
             }
         }
 
+        // --- Clean up the dense triangulation inherited from the source render geometry ---
+        // The navmesh arrives with far more triangles than navigation needs (a flat floor comes in
+        // as many coplanar triangles). Collapse only the geometrically redundant ones -- interior
+        // near-coplanar fans and collinear runs of boundary vertices -- without moving the surface
+        // or the walkable outline (and obstacle holes) by more than a small fraction of the agent
+        // radius. With agent_radius 0 the tolerance is 0 and this is a no-op.
+        if (agent_radius > 0) {
+            bt_mesh_simplify_by_error(mesh, agent_radius * NAVMESH_SIMPLIFY_ERROR_FRACTION);
+            bt_mesh_compact(mesh);
+        }
+
         // face normals are consumed by navigation queries (string-pulling portal normals), populate them now
         bt_mesh_compute_face_normals(mesh);
 

package/src/engine/navigation/mesh/bvh_segment_penetrates_mesh.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Does the segment (ax,ay,az)->(bx,by,bz) pass THROUGH the mesh surface -- cross the interior of any
+ * triangle transversally (entering one side, exiting the other) strictly between its endpoints?
+ *
+ * This is the "penetration" test for a navmesh path piece. A piece that hugs the surface (coplanar with
+ * it) or flies over / under it -- a corner-only waypoint chord on a non-planar surface -- does NOT
+ * penetrate; a piece that tunnels through a wall or floor does. Endpoints lying on the surface (every
+ * path waypoint) are not penetrations.
+ *
+ * @param {BVH} bvh built by bvh_build_from_bt_mesh over `mesh`
+ * @param {BinaryTopology} mesh triangle mesh
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @returns {boolean}
+ */
+export function bvh_segment_penetrates_mesh(bvh: BVH, mesh: BinaryTopology, ax: number, ay: number, az: number, bx: number, by: number, bz: number): boolean;
+//# sourceMappingURL=bvh_segment_penetrates_mesh.d.ts.map

package/src/engine/navigation/mesh/bvh_segment_penetrates_mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_segment_penetrates_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/bvh_segment_penetrates_mesh.js"],"names":[],"mappings":"AAgEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,gFARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmDnB"}

package/src/engine/navigation/mesh/bvh_segment_penetrates_mesh.js

@@ -0,0 +1,133 @@
+import {
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    COLUMN_USER_DATA,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "../../../core/bvh2/bvh3/BVH.js";
+import { NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+
+// Plane-side slack and barycentric slack. Mesh vertices are float32, so a segment endpoint that lies ON
+// a triangle sits within ~coord*2^-23 of its plane; PLANE_EPS keeps those (and grazing/coplanar pieces)
+// from registering as a crossing. Only a genuinely transversal piece -- strictly on opposite sides of a
+// triangle's plane and crossing its interior away from its own endpoints -- counts as a penetration.
+const PLANE_EPS = 1e-3;
+const BARY_EPS = 1e-6;
+
+const _coords = new Float32Array(3);
+const _stack = new Uint32Array(1024); // DFS node stack; navmesh BVHs are shallow (depth ~ log2(faces))
+
+/** Standard slab test: does the segment p + t*d, t in [0,1], intersect the AABB [min,max]? */
+function segment_intersects_aabb(minx, miny, minz, maxx, maxy, maxz, px, py, pz, dx, dy, dz) {
+    let tmin = 0, tmax = 1;
+
+    if (dx > -1e-12 && dx < 1e-12) { if (px < minx || px > maxx) return false; }
+    else { let t1 = (minx - px) / dx, t2 = (maxx - px) / dx; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
+
+    if (dy > -1e-12 && dy < 1e-12) { if (py < miny || py > maxy) return false; }
+    else { let t1 = (miny - py) / dy, t2 = (maxy - py) / dy; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
+
+    if (dz > -1e-12 && dz < 1e-12) { if (pz < minz || pz > maxz) return false; }
+    else { let t1 = (minz - pz) / dz, t2 = (maxz - pz) / dz; if (t1 > t2) { const t = t1; t1 = t2; t2 = t; } if (t1 > tmin) tmin = t1; if (t2 < tmax) tmax = t2; if (tmin > tmax) return false; }
+
+    return true;
+}
+
+/** True if segment (px,py,pz)->(qx,qy,qz) crosses the interior of triangle (a,b,c) transversally. */
+function segment_crosses_triangle(px, py, pz, qx, qy, qz, ax, ay, az, bx, by, bz, cx, cy, cz) {
+    const ux = bx - ax, uy = by - ay, uz = bz - az;
+    const vx = cx - ax, vy = cy - ay, vz = cz - az;
+    const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    const nlen = Math.hypot(nx, ny, nz);
+    if (nlen < 1e-12) return false; // degenerate triangle
+
+    const dP = ((px - ax) * nx + (py - ay) * ny + (pz - az) * nz) / nlen;
+    const dQ = ((qx - ax) * nx + (qy - ay) * ny + (qz - az) * nz) / nlen;
+
+    // must cross the plane strictly (not coplanar, not endpoint-on-plane)
+    if (!((dP > PLANE_EPS && dQ < -PLANE_EPS) || (dP < -PLANE_EPS && dQ > PLANE_EPS))) return false;
+
+    const t = dP / (dP - dQ);
+    if (t <= PLANE_EPS || t >= 1 - PLANE_EPS) return false; // crossing at/near an endpoint (on the surface)
+
+    // crossing point, tested for containment via barycentric coordinates in the triangle plane
+    const wx = px + (qx - px) * t - ax, wy = py + (qy - py) * t - ay, wz = pz + (qz - pz) * t - az;
+    const d00 = ux * ux + uy * uy + uz * uz, d01 = ux * vx + uy * vy + uz * vz, d11 = vx * vx + vy * vy + vz * vz;
+    const d20 = wx * ux + wy * uy + wz * uz, d21 = wx * vx + wy * vy + wz * vz;
+    const denom = d00 * d11 - d01 * d01;
+    if (denom > -1e-18 && denom < 1e-18) return false;
+    const s = (d11 * d20 - d01 * d21) / denom;
+    const w = (d00 * d21 - d01 * d20) / denom;
+
+    return s >= -BARY_EPS && w >= -BARY_EPS && s + w <= 1 + BARY_EPS;
+}
+
+/**
+ * Does the segment (ax,ay,az)->(bx,by,bz) pass THROUGH the mesh surface -- cross the interior of any
+ * triangle transversally (entering one side, exiting the other) strictly between its endpoints?
+ *
+ * This is the "penetration" test for a navmesh path piece. A piece that hugs the surface (coplanar with
+ * it) or flies over / under it -- a corner-only waypoint chord on a non-planar surface -- does NOT
+ * penetrate; a piece that tunnels through a wall or floor does. Endpoints lying on the surface (every
+ * path waypoint) are not penetrations.
+ *
+ * @param {BVH} bvh built by bvh_build_from_bt_mesh over `mesh`
+ * @param {BinaryTopology} mesh triangle mesh
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @returns {boolean}
+ */
+export function bvh_segment_penetrates_mesh(bvh, mesh, ax, ay, az, bx, by, bz) {
+    const root = bvh.root;
+    if (root === NULL_NODE) return false;
+
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+    const dx = bx - ax, dy = by - ay, dz = bz - az;
+
+    let sp = 0;
+    _stack[sp++] = root;
+
+    while (sp > 0) {
+        const node = _stack[--sp];
+        const address = node * ELEMENT_WORD_COUNT;
+
+        if (!segment_intersects_aabb(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            ax, ay, az, dx, dy, dz
+        )) {
+            continue;
+        }
+
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+        if (child_1 !== NULL_NODE) {
+            _stack[sp++] = child_1;
+            _stack[sp++] = uint32[address + COLUMN_CHILD_2];
+            continue;
+        }
+
+        const face_id = uint32[address + COLUMN_USER_DATA];
+        const loop_a = mesh.face_read_loop(face_id);
+        if (loop_a === NULL_POINTER) continue;
+        const loop_b = mesh.loop_read_next(loop_a);
+        const loop_c = mesh.loop_read_next(loop_b);
+
+        mesh.vertex_read_coordinate(_coords, 0, mesh.loop_read_vertex(loop_a));
+        const tax = _coords[0], tay = _coords[1], taz = _coords[2];
+        mesh.vertex_read_coordinate(_coords, 0, mesh.loop_read_vertex(loop_b));
+        const tbx = _coords[0], tby = _coords[1], tbz = _coords[2];
+        mesh.vertex_read_coordinate(_coords, 0, mesh.loop_read_vertex(loop_c));
+        const tcx = _coords[0], tcy = _coords[1], tcz = _coords[2];
+
+        if (segment_crosses_triangle(ax, ay, az, bx, by, bz, tax, tay, taz, tbx, tby, tbz, tcx, tcy, tcz)) {
+            return true;
+        }
+    }
+
+    return false;
+}

package/src/core/graph/metis/native/refine/IndexedFloatMaxHeap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IndexedFloatMaxHeap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/IndexedFloatMaxHeap.js"],"names":[],"mappings":"AA6BA;IACI;;;OAGG;IACH,yBAHW,MAAM,0BACN,MAAM,EAsBhB;IAbG,wBAA4C;IAC5C,eAAe;IAEf,2BAA4E;IAC5E,2BAAwD;IACxD,6BAA0D;IAE1D;;;OAGG;IACH,cAFU,WAAW,CAE2B;IAIpD,mBAEC;IAED;;;OAGG;IACH,cAQC;IAED,2BAEC;IAED;;;OAGG;IACH,qBAkBC;IAED;;;;OAIG;IACH,oBAsBC;IAED;;;;OAIG;IACH,kBAYC;IAED,wBAUC;IAED;;;OAGG;IACH,WAHW,MAAM,SACN,MAAM,QAehB;IAED;;OAEG;IACH,WAFa,MAAM,CAuBlB;IAED;;;OAGG;IACH,WAHW,MAAM,aACN,MAAM,QAehB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CA+BnB;CACJ"}

package/src/engine/navigation/mesh/navmesh_polyanya_find_path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"navmesh_polyanya_find_path.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/navmesh_polyanya_find_path.js"],"names":[],"mappings":"AAqTA;;;;;;;;;;;;;;GAcG;AACH,mDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gCAElC,MAAM,MACN,MAAM,MACN,MAAM,cACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,MAAM,GACJ,MAAM,CAmFlB"}