@woosh/meep-engine 2.163.3 → 2.163.4

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.163.3",
+  "version": "2.163.4",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/engine/navigation/mesh/build/bt_mesh_carve_height_clearance.d.ts

@@ -1,17 +1,18 @@
 /**
- * Carve holes into a (welded, connected) walkable topology wherever an agent of the given height
- * would not fit under overhead geometry.
+ * Carve holes into a (welded) walkable topology wherever an agent of the given height+radius would not
+ * fit under overhead geometry. INTENDED TO RUN AFTER the agent-radius boundary erosion: the boundary is
+ * already handled, so this only removes the obstacle footprints (dilated by the agent radius).
  *
- * Operates on the topology rather than a triangle soup so that all subdivision is conformal:
- * {@link bt_edge_split} re-triangulates every face around a split edge, so neighbouring faces can
- * never disagree on a shared edge (no cracks / T-junctions). Refinement is adaptive - only faces whose
- * column actually contains an overhang are subdivided, and only down to `resolution` - so clear areas
- * stay coarse and the subdivision hugs the obstacle contour instead of tessellating whole triangles.
+ * All subdivision is conformal ({@link bt_edge_split} re-triangulates every face around a split edge),
+ * and culling whole faces ({@link bt_face_kill}) never cracks neighbours - so this cannot disconnect a
+ * passable region. Refinement is tight: faces straddling the (dilated) obstacle outline are refined to
+ * `resolution`; a still-large all-clear face whose column has overhead is refined down to a coarse
+ * guard so a small obstacle cannot hide unsampled; everything else stays coarse.
  *
  * @param {object} params
  * @param {BinaryTopology} params.mesh walkable topology to carve (modified in place)
  * @param {BinaryTopology} params.source original source mesh (walkable + overhead geometry)
- * @param {BVH} params.source_bvh BVH over `source` (leaves carry source face IDs)
+ * @param {BVH} params.source_bvh BVH over `source`
  * @param {number} params.agent_height
  * @param {number} params.agent_radius
  * @param {Vector3} params.up world up direction

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

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_carve_height_clearance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/bt_mesh_carve_height_clearance.js"],"names":[],"mappings":"AA2LA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAPkC,IAAI;IACJ,MAAM;IACjB,UAAU;IACP,YAAY,EAA3B,MAAM;IACS,YAAY,EAA3B,MAAM;IACU,EAAE;SAuH5B"}
+{"version":3,"file":"bt_mesh_carve_height_clearance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/bt_mesh_carve_height_clearance.js"],"names":[],"mappings":"AA2NA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAPkC,IAAI;IACJ,MAAM;IACjB,UAAU;IACP,YAAY,EAA3B,MAAM;IACS,YAAY,EAA3B,MAAM;IACU,EAAE;SA0H5B"}

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

@@ -15,26 +15,10 @@ import {
     computeTriangleRayIntersectionBarycentric
 } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js";
 
-/**
- * Lift a ray origin off the surface so the upward clearance ray does not immediately re-hit the floor.
- * @type {number}
- */
+/** Lift a ray origin off the surface so the upward clearance ray does not re-hit the floor. */
 const SURFACE_EPSILON = 1e-4;
 
-/**
- * Horizontal inset applied to a face footprint before testing for overhead geometry. Prevents a
- * neighbour that merely *touches* a face along a shared edge (e.g. an adjacent platform at a slightly
- * different height) from being mistaken for an overhang. A real overhang overlaps the interior with
- * positive area and still registers.
- * @type {number}
- */
-const FOOTPRINT_INSET = 1e-2;
-
-/**
- * Safety cap on the number of faces the refinement is allowed to grow to, so a pathological input
- * cannot loop forever.
- * @type {number}
- */
+/** Safety cap on the face count during refinement. */
 const MAX_FACES = 200000;
 
 // reused scratch
@@ -50,11 +34,9 @@ const vc = new Float32Array(3);
 
 const overhead_hits = [];
 const query_aabb = new Float32Array(6);
+const scratch_normal = new Float32Array(3);
 
-/**
- * True if there is no source geometry within `agent_height` directly above the point along `up`.
- * (Mirrors the clearance ray-cast used by the old soup-based pass.)
- */
+/** True if nothing in `source` sits directly above the point within `agent_height` (exact ray test). */
 function point_has_clearance(source_bvh, source, px, py, pz, up_x, up_y, up_z, agent_height) {
     const origin_x = px + up_x * SURFACE_EPSILON;
     const origin_y = py + up_y * SURFACE_EPSILON;
@@ -73,9 +55,15 @@ function point_has_clearance(source_bvh, source, px, py, pz, up_x, up_y, up_z, a
         const face_id = source_bvh.node_get_user_data(node);
 
         const loop_a = source.face_read_loop(face_id);
-        if (loop_a === NULL_POINTER) {
+        if (loop_a === NULL_POINTER) continue;
+
+        // Only DOWNWARD-facing geometry (a ceiling / overhang underside) can obstruct head clearance.
+        // Up-facing walkable floors above (a higher tier, a step the agent climbs) must NOT block.
+        source.face_read_normal(scratch_normal, 0, face_id);
+        if (scratch_normal[0] * up_x + scratch_normal[1] * up_y + scratch_normal[2] * up_z >= -1e-3) {
             continue;
         }
+
         const loop_b = source.loop_read_next(loop_a);
         const loop_c = source.loop_read_next(loop_b);
 
@@ -91,62 +79,92 @@ function point_has_clearance(source_bvh, source, px, py, pz, up_x, up_y, up_z, a
             tri_b[0], tri_b[1], tri_b[2],
             tri_c[0], tri_c[1], tri_c[2]
         );
-        if (!hit) {
-            continue;
-        }
+        if (!hit) continue;
 
         const t = intersection_result[0];
-        if (t > 0 && t <= agent_height) {
-            // overhead obstruction within the agent's height
-            return false;
-        }
+        if (t > 0 && t <= agent_height) return false;
     }
 
     return true;
 }
 
 /**
- * Read the three vertices of a triangular face into va/vb/vc and return its loops.
+ * True if any source geometry sits above the point within `agent_height`, anywhere inside a horizontal
+ * disc of radius `r` (approximated by an axis-aligned box). Used to dilate the obstacle footprint by
+ * the agent radius - the agent's body cannot occupy a spot whose `r`-neighbourhood is overhung.
  */
-function read_face_triangle(mesh, face_id) {
-    const la = mesh.face_read_loop(face_id);
-    const lb = mesh.loop_read_next(la);
-    const lc = mesh.loop_read_next(lb);
+function overhead_within_radius(source_bvh, source, px, py, pz, up_x, up_y, up_z, agent_height, r) {
+    const p_along_up = px * up_x + py * up_y + pz * up_z;
 
-    mesh.vertex_read_coordinate(va, 0, mesh.loop_read_vertex(la));
-    mesh.vertex_read_coordinate(vb, 0, mesh.loop_read_vertex(lb));
-    mesh.vertex_read_coordinate(vc, 0, mesh.loop_read_vertex(lc));
+    // expand on the axes perpendicular to up by r, then sweep up by agent_height
+    const ex = r * (1 - Math.abs(up_x));
+    const ey = r * (1 - Math.abs(up_y));
+    const ez = r * (1 - Math.abs(up_z));
 
-    return { la, lb, lc };
+    let min_x = px - ex, min_y = py - ey, min_z = pz - ez;
+    let max_x = px + ex, max_y = py + ey, max_z = pz + ez;
+
+    const dx = up_x * agent_height, dy = up_y * agent_height, dz = up_z * agent_height;
+    if (dx > 0) max_x += dx; else min_x += dx;
+    if (dy > 0) max_y += dy; else min_y += dy;
+    if (dz > 0) max_z += dz; else min_z += dz;
+
+    query_aabb[0] = min_x; query_aabb[1] = min_y; query_aabb[2] = min_z;
+    query_aabb[3] = max_x; query_aabb[4] = max_y; query_aabb[5] = max_z;
+
+    const count = bvh_query_user_data_overlaps_aabb(overhead_hits, 0, source_bvh, query_aabb);
+
+    for (let i = 0; i < count; i++) {
+        const fid = overhead_hits[i];
+        const la = source.face_read_loop(fid);
+        if (la === NULL_POINTER) continue;
+
+        // only downward-facing geometry counts as an overhang (see point_has_clearance)
+        source.face_read_normal(scratch_normal, 0, fid);
+        if (scratch_normal[0] * up_x + scratch_normal[1] * up_y + scratch_normal[2] * up_z >= -1e-3) {
+            continue;
+        }
+
+        const lb = source.loop_read_next(la);
+        const lc = source.loop_read_next(lb);
+
+        source.vertex_read_coordinate(tri_a, 0, source.loop_read_vertex(la));
+        source.vertex_read_coordinate(tri_b, 0, source.loop_read_vertex(lb));
+        source.vertex_read_coordinate(tri_c, 0, source.loop_read_vertex(lc));
+
+        const cand_min_along_up = Math.min(
+            tri_a[0] * up_x + tri_a[1] * up_y + tri_a[2] * up_z,
+            tri_b[0] * up_x + tri_b[1] * up_y + tri_b[2] * up_z,
+            tri_c[0] * up_x + tri_c[1] * up_y + tri_c[2] * up_z
+        );
+
+        if (cand_min_along_up > p_along_up + 1e-3 && cand_min_along_up <= p_along_up + agent_height + 1e-3) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 /**
- * Does the upward column (height `agent_height` along `up`) over this face's footprint contain any
- * source geometry that sits *above* the face? Uses a loose axis-aligned box (conservative), inset
- * horizontally so edge-touching neighbours do not count. May report true for a face whose triangle
- * does not actually pass under the overhang, which only costs a little extra refinement, never a
- * wrong cull.
+ * Does the column over this face's footprint (inflated horizontally by `pad`) contain any DOWNWARD-
+ * facing geometry above it within `agent_height`? Footprint-wide (not just the centroid), so an
+ * obstacle sitting anywhere under a large face is detected and the face is refined toward it.
  */
-function column_has_overhead(source_bvh, source, face_max_along_up, up_x, up_y, up_z, agent_height) {
-    let min_x = Math.min(va[0], vb[0], vc[0]);
-    let min_y = Math.min(va[1], vb[1], vc[1]);
-    let min_z = Math.min(va[2], vb[2], vc[2]);
-    let max_x = Math.max(va[0], vb[0], vc[0]);
-    let max_y = Math.max(va[1], vb[1], vc[1]);
-    let max_z = Math.max(va[2], vb[2], vc[2]);
-
-    // inset the footprint on the axes perpendicular to up (so touching-only neighbours are excluded)
-    const ex = FOOTPRINT_INSET * (1 - Math.abs(up_x));
-    const ey = FOOTPRINT_INSET * (1 - Math.abs(up_y));
-    const ez = FOOTPRINT_INSET * (1 - Math.abs(up_z));
-    min_x += ex; max_x -= ex;
-    min_y += ey; max_y -= ey;
-    min_z += ez; max_z -= ez;
-    if (min_x > max_x) { const m = (min_x + max_x) * 0.5; min_x = m; max_x = m; }
-    if (min_y > max_y) { const m = (min_y + max_y) * 0.5; min_y = m; max_y = m; }
-    if (min_z > max_z) { const m = (min_z + max_z) * 0.5; min_z = m; max_z = m; }
-
-    // sweep the box by agent_height along the up direction
+function footprint_has_overhead(source_bvh, source, up_x, up_y, up_z, agent_height, pad) {
+    const face_max_along_up = Math.max(
+        va[0] * up_x + va[1] * up_y + va[2] * up_z,
+        vb[0] * up_x + vb[1] * up_y + vb[2] * up_z,
+        vc[0] * up_x + vc[1] * up_y + vc[2] * up_z
+    );
+
+    let min_x = Math.min(va[0], vb[0], vc[0]) - pad;
+    let min_y = Math.min(va[1], vb[1], vc[1]) - pad;
+    let min_z = Math.min(va[2], vb[2], vc[2]) - pad;
+    let max_x = Math.max(va[0], vb[0], vc[0]) + pad;
+    let max_y = Math.max(va[1], vb[1], vc[1]) + pad;
+    let max_z = Math.max(va[2], vb[2], vc[2]) + pad;
+
     const dx = up_x * agent_height, dy = up_y * agent_height, dz = up_z * agent_height;
     if (dx > 0) max_x += dx; else min_x += dx;
     if (dy > 0) max_y += dy; else min_y += dy;
@@ -159,24 +177,26 @@ function column_has_overhead(source_bvh, source, face_max_along_up, up_x, up_y,
 
     for (let i = 0; i < count; i++) {
         const fid = overhead_hits[i];
-
         const la = source.face_read_loop(fid);
         if (la === NULL_POINTER) continue;
+
+        source.face_read_normal(scratch_normal, 0, fid);
+        if (scratch_normal[0] * up_x + scratch_normal[1] * up_y + scratch_normal[2] * up_z >= -1e-3) {
+            continue;
+        }
+
         const lb = source.loop_read_next(la);
         const lc = source.loop_read_next(lb);
-
         source.vertex_read_coordinate(tri_a, 0, source.loop_read_vertex(la));
         source.vertex_read_coordinate(tri_b, 0, source.loop_read_vertex(lb));
         source.vertex_read_coordinate(tri_c, 0, source.loop_read_vertex(lc));
 
-        // lowest extent of the candidate along up
         const cand_min_along_up = Math.min(
             tri_a[0] * up_x + tri_a[1] * up_y + tri_a[2] * up_z,
             tri_b[0] * up_x + tri_b[1] * up_y + tri_b[2] * up_z,
             tri_c[0] * up_x + tri_c[1] * up_y + tri_c[2] * up_z
         );
 
-        // strictly above the face (the face's own/coplanar floor reads <= face_max_along_up)
         if (cand_min_along_up > face_max_along_up + 1e-3) {
             return true;
         }
@@ -185,20 +205,33 @@ function column_has_overhead(source_bvh, source, face_max_along_up, up_x, up_y,
     return false;
 }
 
+function read_face_triangle(mesh, face_id) {
+    const la = mesh.face_read_loop(face_id);
+    const lb = mesh.loop_read_next(la);
+    const lc = mesh.loop_read_next(lb);
+
+    mesh.vertex_read_coordinate(va, 0, mesh.loop_read_vertex(la));
+    mesh.vertex_read_coordinate(vb, 0, mesh.loop_read_vertex(lb));
+    mesh.vertex_read_coordinate(vc, 0, mesh.loop_read_vertex(lc));
+
+    return { la, lb, lc };
+}
+
 /**
- * Carve holes into a (welded, connected) walkable topology wherever an agent of the given height
- * would not fit under overhead geometry.
+ * Carve holes into a (welded) walkable topology wherever an agent of the given height+radius would not
+ * fit under overhead geometry. INTENDED TO RUN AFTER the agent-radius boundary erosion: the boundary is
+ * already handled, so this only removes the obstacle footprints (dilated by the agent radius).
  *
- * Operates on the topology rather than a triangle soup so that all subdivision is conformal:
- * {@link bt_edge_split} re-triangulates every face around a split edge, so neighbouring faces can
- * never disagree on a shared edge (no cracks / T-junctions). Refinement is adaptive - only faces whose
- * column actually contains an overhang are subdivided, and only down to `resolution` - so clear areas
- * stay coarse and the subdivision hugs the obstacle contour instead of tessellating whole triangles.
+ * All subdivision is conformal ({@link bt_edge_split} re-triangulates every face around a split edge),
+ * and culling whole faces ({@link bt_face_kill}) never cracks neighbours - so this cannot disconnect a
+ * passable region. Refinement is tight: faces straddling the (dilated) obstacle outline are refined to
+ * `resolution`; a still-large all-clear face whose column has overhead is refined down to a coarse
+ * guard so a small obstacle cannot hide unsampled; everything else stays coarse.
  *
  * @param {object} params
  * @param {BinaryTopology} params.mesh walkable topology to carve (modified in place)
  * @param {BinaryTopology} params.source original source mesh (walkable + overhead geometry)
- * @param {BVH} params.source_bvh BVH over `source` (leaves carry source face IDs)
+ * @param {BVH} params.source_bvh BVH over `source`
  * @param {number} params.agent_height
  * @param {number} params.agent_radius
  * @param {Vector3} params.up world up direction
@@ -212,28 +245,32 @@ export function bt_mesh_carve_height_clearance({
                                                    up,
                                                }) {
 
-    if (agent_height <= 0 || source_bvh.root === NULL_NODE) {
-        // nothing overhead can obstruct anything
-        return;
-    }
+    if (agent_height <= 0 || source_bvh.root === NULL_NODE) return;
 
-    // normalize up
     let up_x = up.x, up_y = up.y, up_z = up.z;
     const up_len = Math.sqrt(up_x * up_x + up_y * up_y + up_z * up_z);
-    if (up_len === 0) {
-        return;
-    }
+    if (up_len === 0) return;
     up_x /= up_len; up_y /= up_len; up_z /= up_len;
 
-    // Contour resolution: how finely the obstacle outline is resolved. Tied to the agent footprint;
-    // floored so a tiny radius cannot trigger runaway refinement.
-    const resolution = Math.max(agent_radius > 0 ? agent_radius : agent_height / 4, 0.25);
+    const r = Math.max(agent_radius, 0);
+    const resolution = Math.max(agent_radius > 0 ? agent_radius : agent_height / 4, 0.3);
+    const coarse_guard = Math.max(2 * agent_radius, agent_height / 2, 0.8);
     const res_sq = resolution * resolution;
+    const guard_sq = coarse_guard * coarse_guard;
+
+    // The agent fits at p iff nothing overhangs directly above it AND nothing overhangs within its body
+    // radius. (For r == 0 this is just the exact overhead ray.)
+    function agent_fits(px, py, pz) {
+        if (!point_has_clearance(source_bvh, source, px, py, pz, up_x, up_y, up_z, agent_height)) {
+            return false;
+        }
+        if (r > 0 && overhead_within_radius(source_bvh, source, px, py, pz, up_x, up_y, up_z, agent_height, r)) {
+            return false;
+        }
+        return true;
+    }
 
-    // ---- Phase 1: adaptive, conformal refinement around overhangs ----
-    // Repeated fixed-point passes: split the longest edge of any face that (a) is still larger than
-    // the contour resolution and (b) has overhead geometry in its column. Splitting is conformal, so
-    // the mesh stays crack-free throughout.
+    // ---- Phase 1: tight, conformal refinement around the (dilated) obstacle outline ----
     let changed = true;
     let guard = 0;
 
@@ -244,53 +281,57 @@ export function bt_mesh_carve_height_clearance({
         const face_count = mesh.faces.size;
 
         for (let f = 0; f < face_count; f++) {
-            if (!mesh.faces.is_allocated(f)) {
-                continue;
-            }
+            if (!mesh.faces.is_allocated(f)) continue;
 
             read_face_triangle(mesh, f);
 
-            // longest edge (by squared length); read_face_triangle puts va/vb/vc in loop order
-            // la=(a,b), lb=(b,c), lc=(c,a)
             const ab = (va[0] - vb[0]) ** 2 + (va[1] - vb[1]) ** 2 + (va[2] - vb[2]) ** 2;
             const bc = (vb[0] - vc[0]) ** 2 + (vb[1] - vc[1]) ** 2 + (vb[2] - vc[2]) ** 2;
             const ca = (vc[0] - va[0]) ** 2 + (vc[1] - va[1]) ** 2 + (vc[2] - va[2]) ** 2;
-
             const longest_sq = Math.max(ab, bc, ca);
 
-            if (longest_sq <= res_sq) {
-                // small enough to resolve the contour
-                continue;
+            if (longest_sq <= res_sq) continue;
+
+            const mab_x = (va[0] + vb[0]) * 0.5, mab_y = (va[1] + vb[1]) * 0.5, mab_z = (va[2] + vb[2]) * 0.5;
+            const mbc_x = (vb[0] + vc[0]) * 0.5, mbc_y = (vb[1] + vc[1]) * 0.5, mbc_z = (vb[2] + vc[2]) * 0.5;
+            const mca_x = (vc[0] + va[0]) * 0.5, mca_y = (vc[1] + va[1]) * 0.5, mca_z = (vc[2] + va[2]) * 0.5;
+            const cx = (va[0] + vb[0] + vc[0]) / 3, cy = (va[1] + vb[1] + vc[1]) / 3, cz = (va[2] + vb[2] + vc[2]) / 3;
+
+            const samples = [
+                va[0], va[1], va[2], vb[0], vb[1], vb[2], vc[0], vc[1], vc[2],
+                mab_x, mab_y, mab_z, mbc_x, mbc_y, mbc_z, mca_x, mca_y, mca_z,
+                cx, cy, cz,
+            ];
+            let n_clear = 0, n_block = 0;
+            for (let s = 0; s < samples.length; s += 3) {
+                if (agent_fits(samples[s], samples[s + 1], samples[s + 2])) n_clear++; else n_block++;
             }
 
-            const face_max_along_up = Math.max(
-                va[0] * up_x + va[1] * up_y + va[2] * up_z,
-                vb[0] * up_x + vb[1] * up_y + vb[2] * up_z,
-                vc[0] * up_x + vc[1] * up_y + vc[2] * up_z
-            );
-
-            if (!column_has_overhead(source_bvh, source, face_max_along_up, up_x, up_y, up_z, agent_height)) {
-                // fully clear column - keep this face coarse
-                continue;
+            let refine = false;
+            if (n_block > 0 && n_clear > 0) {
+                refine = true;   // (dilated) outline crosses this face -> hug it at `resolution`
+            } else if (n_block === 0 && longest_sq > guard_sq) {
+                // all clear by sampling, but still large enough to hide an obstacle between samples:
+                // refine if any downward-facing overhang sits under the whole face footprint (+ radius)
+                if (footprint_has_overhead(source_bvh, source, up_x, up_y, up_z, agent_height, r)) {
+                    refine = true;
+                }
             }
+            // n_clear === 0 (fully blocked): leave it for the cull phase
+
+            if (!refine) continue;
 
             const { la, lb, lc } = read_face_triangle(mesh, f);
             let split_loop;
-            if (longest_sq === ab) {
-                split_loop = la;
-            } else if (longest_sq === bc) {
-                split_loop = lb;
-            } else {
-                split_loop = lc;
-            }
+            if (longest_sq === ab) split_loop = la;
+            else if (longest_sq === bc) split_loop = lb;
+            else split_loop = lc;
 
             bt_edge_split(mesh, mesh.loop_read_edge(split_loop), 0.5);
             changed = true;
         }
 
-        if (mesh.faces.size > MAX_FACES) {
-            break;
-        }
+        if (mesh.faces.size > MAX_FACES) break;
     }
 
     // ---- Phase 2: cull blocked faces (whole-face, conformal) ----
@@ -298,19 +339,14 @@ export function bt_mesh_carve_height_clearance({
     const face_count = mesh.faces.size;
 
     for (let f = 0; f < face_count; f++) {
-        if (!mesh.faces.is_allocated(f)) {
-            continue;
-        }
+        if (!mesh.faces.is_allocated(f)) continue;
 
         read_face_triangle(mesh, f);
-
         const cx = (va[0] + vb[0] + vc[0]) / 3;
         const cy = (va[1] + vb[1] + vc[1]) / 3;
         const cz = (va[2] + vb[2] + vc[2]) / 3;
 
-        if (!point_has_clearance(source_bvh, source, cx, cy, cz, up_x, up_y, up_z, agent_height)) {
-            faces_to_kill.push(f);
-        }
+        if (!agent_fits(cx, cy, cz)) faces_to_kill.push(f);
     }
 
     for (let i = 0; i < faces_to_kill.length; i++) {

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":"AA2CA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAiLxB;+BA5N8B,mEAAmE"}
+{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAkLxB;+BA7N8B,mEAAmE"}

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

@@ -164,10 +164,29 @@ export function navmesh_build_topology({
         // which is what the loop-based neighbour queries rely on
         bt_mesh_fuse_duplicate_edges(mesh);
 
-        // Carve holes wherever an agent of the given height would not fit under overhead geometry.
-        // Done on the welded topology (rather than the raw soup) so the subdivision is conformal -
-        // bt_edge_split re-triangulates every face around a shared edge, so neighbours can never crack
-        // apart - and adaptive, hugging each obstacle's contour instead of tessellating whole triangles.
+        // --- Agent-radius erosion FIRST, on the clean welded surface ---
+        // Erosion is reliable on a clean triangulation; running it BEFORE the obstacle carve avoids
+        // feeding it the irregular, hole-punched mesh the carve would otherwise produce (which made the
+        // vertex-sampled distance field mis-estimate the inset, both over-culling and fragmenting).
+        {
+            const islands = bt_mesh_compute_face_islands(mesh);
+
+            // decouple so islands can be eroded independently
+            bt_mesh_face_decouple_islands(mesh, islands);
+
+            for (const island of islands) {
+                bt_mesh_face_island_erode(mesh, island, agent_radius);
+            }
+
+            // remove dangling references, then compact (erosion frees faces, leaving holes in the ID space)
+            bt_mesh_cleanup_faceless_references(mesh);
+            bt_mesh_compact(mesh);
+        }
+
+        // --- Then carve the obstacle footprints (dilated by the agent radius) ---
+        // Runs on the already-eroded surface. Conformal edge-splits + whole-face culls only: this can
+        // never crack a passable region apart, it can only open holes where the agent genuinely cannot
+        // fit under an overhang.
         if (agent_height > 0) {
             bt_mesh_carve_height_clearance({
                 mesh,
@@ -177,29 +196,11 @@ export function navmesh_build_topology({
                 agent_radius,
                 up,
             });
-        }
-
-        const islands = bt_mesh_compute_face_islands(mesh);
 
-        // enabled us to modify islands independently
-        bt_mesh_face_decouple_islands(mesh, islands);
-
-        // shrink islands to agent_radius
-        for (const island of islands) {
-            bt_mesh_face_island_erode(mesh, island, agent_radius);
+            // carve kills faces via the free-list; compact back to a dense, hole-free topology
+            bt_mesh_compact(mesh);
         }
 
-        // TODO attempt to reduce mesh complexity by re-triangulating flat areas or running a very constrained decimation
-
-        // remove dangling references
-        bt_mesh_cleanup_faceless_references(mesh);
-
-        // Island erosion (above) kills faces via the pool's free-list, leaving holes in the ID space.
-        // `faces.size` is a high-water mark, not a live count, so consumers that iterate `0..faces.size`
-        // (e.g. bvh_build_from_bt_mesh) would touch freed slots. Compact so every consumer sees a dense,
-        // hole-free topology - this is the single invariant downstream code relies on.
-        bt_mesh_compact(mesh);
-
         // bridge across small steps / gaps so stair-separated or slightly-broken tiers are reachable.
         // Opt-in: with both step params 0 (the default) the topology is left untouched.
         if (agent_max_step_height > 0 || agent_max_step_distance > 0) {