@woosh/meep-engine 2.163.5 → 2.163.7

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.5",
+  "version": "2.163.7",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fill boundary holes that are too thin for the agent to occupy.
+ *
+ * Erosion/clearance can leave a hair-thin sliver hole hugging an obstacle's offset edge (a strip of
+ * cells that are actually clear but get pinched off into their own tiny loop). Such a hole is narrower
+ * than the agent, so it can never be a real navigation obstacle - it is numerical noise that inflates
+ * the boundary, the face count, and the loop count. This fills any inner loop whose mean width
+ * (2*area/perimeter, the inradius of an equivalent disc) is below the agent radius. The single
+ * largest-area loop (the outer boundary) is never filled.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} agent_radius
+ * @returns {number} number of holes filled
+ */
+export function bt_mesh_fill_small_holes(mesh: BinaryTopology, agent_radius: number): number;
+//# sourceMappingURL=bt_mesh_fill_small_holes.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_fill_small_holes.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;GAaG;AACH,6EAHW,MAAM,GACJ,MAAM,CA2ClB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js

@@ -0,0 +1,151 @@
+import { bt_mesh_walk_boundary_loops } from "../query/bt_mesh_walk_boundary_loops.js";
+import { bt_mesh_face_poke } from "./face/bt_face_poke.js";
+import { bt_radial_loop_add } from "./bt_radial_loop_add.js";
+
+const _c = [0, 0, 0];
+const _p = [0, 0, 0];
+const _q = [0, 0, 0];
+
+/**
+ * Order a boundary cycle's edges into a vertex/edge walk starting at `start_vertex`.
+ * (Same traversal as bt_mesh_close_boundary_holes.)
+ */
+function order_cycle_from(mesh, cycle, start_vertex, out_vertices, out_edges) {
+    const n = cycle.length;
+    const v_to_edges = new Map();
+    for (let i = 0; i < n; i++) {
+        const e = cycle[i];
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+        let bucket = v_to_edges.get(v1);
+        if (bucket === undefined) { bucket = []; v_to_edges.set(v1, bucket); }
+        bucket.push(e);
+        bucket = v_to_edges.get(v2);
+        if (bucket === undefined) { bucket = []; v_to_edges.set(v2, bucket); }
+        bucket.push(e);
+    }
+    let v_curr = start_vertex;
+    let e_prev = -1;
+    for (let i = 0; i < n; i++) {
+        out_vertices[i] = v_curr;
+        const edges_at_v = v_to_edges.get(v_curr);
+        const e_next = (edges_at_v[0] === e_prev) ? edges_at_v[1] : edges_at_v[0];
+        out_edges[i] = e_next;
+        const e_v1 = mesh.edge_read_vertex1(e_next);
+        const e_v2 = mesh.edge_read_vertex2(e_next);
+        v_curr = (e_v1 === v_curr) ? e_v2 : e_v1;
+        e_prev = e_next;
+    }
+}
+
+/** Perimeter and (Newell) 3D area of an ordered loop of vertices. */
+function loop_perimeter_and_area(mesh, verts) {
+    const n = verts.length;
+    let perimeter = 0;
+    let nx = 0, ny = 0, nz = 0;
+    for (let i = 0; i < n; i++) {
+        mesh.vertex_read_coordinate(_p, 0, verts[i]);
+        mesh.vertex_read_coordinate(_q, 0, verts[(i + 1) % n]);
+        perimeter += Math.hypot(_q[0] - _p[0], _q[1] - _p[1], _q[2] - _p[2]);
+        // Newell's method for polygon area normal
+        nx += (_p[1] - _q[1]) * (_p[2] + _q[2]);
+        ny += (_p[2] - _q[2]) * (_p[0] + _q[0]);
+        nz += (_p[0] - _q[0]) * (_p[1] + _q[1]);
+    }
+    const area = 0.5 * Math.hypot(nx, ny, nz);
+    return { perimeter, area };
+}
+
+/** Fan-fill a single boundary loop (n-gon face + centroid poke), as close_boundary_holes does. */
+function fill_loop(mesh, cycle) {
+    const n = cycle.length;
+    const seed_edge = cycle[0];
+    const seed_loop = mesh.edge_read_loop(seed_edge);
+    const existing_loop_vertex = mesh.loop_read_vertex(seed_loop);
+    const seed_v1 = mesh.edge_read_vertex1(seed_edge);
+    const seed_v2 = mesh.edge_read_vertex2(seed_edge);
+    const start_vertex = (existing_loop_vertex === seed_v1) ? seed_v2 : seed_v1;
+
+    const ordered_vertices = new Array(n);
+    const ordered_edges = new Array(n);
+    order_cycle_from(mesh, cycle, start_vertex, ordered_vertices, ordered_edges);
+
+    let cx = 0, cy = 0, cz = 0;
+    for (let i = 0; i < n; i++) {
+        mesh.vertex_read_coordinate(_c, 0, ordered_vertices[i]);
+        cx += _c[0]; cy += _c[1]; cz += _c[2];
+    }
+    cx /= n; cy /= n; cz /= n;
+
+    const new_face = mesh.faces.allocate();
+    const loops = new Array(n);
+    for (let i = 0; i < n; i++) {
+        loops[i] = mesh.loop_create();
+        mesh.loop_write_vertex(loops[i], ordered_vertices[i]);
+        mesh.loop_write_face(loops[i], new_face);
+        bt_radial_loop_add(mesh, loops[i], ordered_edges[i]);
+    }
+    for (let i = 0; i < n; i++) {
+        mesh.loop_write_next(loops[i], loops[(i + 1) % n]);
+        mesh.loop_write_prev(loops[i], loops[(i - 1 + n) % n]);
+    }
+    mesh.face_write_loop(new_face, loops[0]);
+    bt_mesh_face_poke(mesh, new_face, cx, cy, cz);
+}
+
+/**
+ * Fill boundary holes that are too thin for the agent to occupy.
+ *
+ * Erosion/clearance can leave a hair-thin sliver hole hugging an obstacle's offset edge (a strip of
+ * cells that are actually clear but get pinched off into their own tiny loop). Such a hole is narrower
+ * than the agent, so it can never be a real navigation obstacle - it is numerical noise that inflates
+ * the boundary, the face count, and the loop count. This fills any inner loop whose mean width
+ * (2*area/perimeter, the inradius of an equivalent disc) is below the agent radius. The single
+ * largest-area loop (the outer boundary) is never filled.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} agent_radius
+ * @returns {number} number of holes filled
+ */
+export function bt_mesh_fill_small_holes(mesh, agent_radius) {
+    if (agent_radius <= 0) return 0;
+
+    let cycles;
+    try {
+        cycles = bt_mesh_walk_boundary_loops(mesh);
+    } catch (e) {
+        // a malformed (pinched) boundary can arise at float32-precision limits (e.g. geometry far from
+        // the origin); skip hole-filling rather than aborting the whole build
+        return 0;
+    }
+    if (cycles.length <= 1) return 0;
+
+    // measure every loop; the largest-area one is the outer boundary and is never filled
+    const measures = cycles.map(c => {
+        const n = c.length;
+        const verts = new Array(n);
+        const edges = new Array(n);
+        const v1 = mesh.edge_read_vertex1(c[0]);
+        order_cycle_from(mesh, c, v1, verts, edges);
+        return loop_perimeter_and_area(mesh, verts);
+    });
+
+    let outer = 0;
+    for (let i = 1; i < measures.length; i++) {
+        if (measures[i].area > measures[outer].area) outer = i;
+    }
+
+    let filled = 0;
+    for (let i = 0; i < cycles.length; i++) {
+        if (i === outer) continue;
+        const { perimeter, area } = measures[i];
+        if (perimeter <= 0) continue;
+        // mean width of the hole = 2*area/perimeter; fill when the agent disc cannot fit
+        if (2 * area / perimeter < agent_radius) {
+            fill_loop(mesh, cycles[i]);
+            filled++;
+        }
+    }
+
+    return filled;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} soup flat XYZ triangle soup (9 floats per triangle)
+ * @param {number} triangle_count
+ * @param {BinaryTopology} source source mesh (face normals must be populated)
+ * @param {number} agent_height
+ * @param {number} agent_radius dilation applied to each footprint
+ * @param {Vector3} up
+ * @returns {number[]} new soup with (dilated) obstacle footprints removed
+ */
+export function clip_soup_against_overhangs(soup: number[], triangle_count: number, source: BinaryTopology, agent_height: number, agent_radius: number, up: Vector3): number[];
+//# sourceMappingURL=clip_soup_against_overhangs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clip_soup_against_overhangs.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/clip_soup_against_overhangs.js"],"names":[],"mappings":"AA4IA;;;;;;;;GAQG;AACH,kDARW,MAAM,EAAE,kBACR,MAAM,wCAEN,MAAM,gBACN,MAAM,gBAEJ,MAAM,EAAE,CA4GpB"}

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

@@ -0,0 +1,256 @@
+/**
+ * Exact obstacle carving at the triangle-soup level, with a faithful agent-radius offset.
+ *
+ * Each overhead obstacle's footprint is DILATED by the agent radius (Minkowski sum with a disc: edges
+ * pushed out by r, convex corners replaced by a rounded arc), and that dilated polygon is subtracted
+ * from the walkable triangles. The resulting hole boundary is therefore the true offset of the
+ * obstacle - straight along edges, a clean arc at corners - rather than a wavy/mitred contour produced
+ * by sampling-then-eroding. (Run AFTER the outer boundary has been eroded by r, so the obstacle holes
+ * are not eroded a second time.)
+ *
+ * Overhead obstacles are the DOWNWARD-facing source faces; a face carves a walkable triangle only where
+ * it sits above it, within `agent_height`.
+ *
+ * The subtraction uses the disjoint half-plane decomposition of a convex-polygon difference:
+ *     T \ F = U_i ( T ∩ inside(e_0..e_{i-1}) ∩ outside(e_i) )
+ * each term convex, the terms disjoint, the union exactly T minus the convex (dilated) footprint F.
+ * Clipping is in the plane perpendicular to `up`; world XYZ is carried and interpolated so kept pieces
+ * stay on the original (possibly tilted) walkable plane. Degenerate pieces/triangles are dropped.
+ */
+
+import { convex_hull_monotone_2d } from "../../../../core/geom/2d/convex-hull/convex_hull_monotone_2d.js";
+
+const POINT_EPS = 1e-9;
+const AREA_EPS = 1e-9;
+const CORNER_SEGMENT_ANGLE = Math.PI / 6; // ~30 deg per rounded-corner segment
+
+function basis_for_up(up_x, up_y, up_z) {
+    let rx = 1, ry = 0, rz = 0;
+    if (Math.abs(up_x) > 0.9) { rx = 0; ry = 1; rz = 0; }
+    let ux = up_y * rz - up_z * ry;
+    let uy = up_z * rx - up_x * rz;
+    let uz = up_x * ry - up_y * rx;
+    const ul = Math.hypot(ux, uy, uz) || 1;
+    ux /= ul; uy /= ul; uz /= ul;
+    const vx = up_y * uz - up_z * uy;
+    const vy = up_z * ux - up_x * uz;
+    const vz = up_x * uy - up_y * ux;
+    return { ux, uy, uz, vx, vy, vz };
+}
+
+function clip_halfplane(poly, ax, az, dx, dz, keep_left) {
+    const n = poly.length;
+    if (n === 0) return poly;
+
+    const out = [];
+    const push = (p) => {
+        const last = out[out.length - 1];
+        if (last && Math.abs(last.u - p.u) < POINT_EPS && Math.abs(last.v - p.v) < POINT_EPS) return;
+        out.push(p);
+    };
+
+    for (let i = 0; i < n; i++) {
+        const A = poly[i];
+        const C = poly[(i + 1) % n];
+        const sa = dx * (A.v - az) - dz * (A.u - ax);
+        const sc = dx * (C.v - az) - dz * (C.u - ax);
+        const inA = keep_left ? (sa >= -POINT_EPS) : (sa <= POINT_EPS);
+        const inC = keep_left ? (sc >= -POINT_EPS) : (sc <= POINT_EPS);
+        if (inA) push(A);
+        if (inA !== inC) {
+            const t = sa / (sa - sc);
+            push({
+                x: A.x + t * (C.x - A.x),
+                y: A.y + t * (C.y - A.y),
+                z: A.z + t * (C.z - A.z),
+                u: A.u + t * (C.u - A.u),
+                v: A.v + t * (C.v - A.v),
+            });
+        }
+    }
+    if (out.length > 1) {
+        const f = out[0], l = out[out.length - 1];
+        if (Math.abs(f.u - l.u) < POINT_EPS && Math.abs(f.v - l.v) < POINT_EPS) out.pop();
+    }
+    return out;
+}
+
+function signed_area_uv(poly) {
+    let a = 0;
+    for (let i = 0; i < poly.length; i++) {
+        const A = poly[i], C = poly[(i + 1) % poly.length];
+        a += A.u * C.v - C.u * A.v;
+    }
+    return a * 0.5;
+}
+
+/** Outward (Minkowski-with-disc) offset of a convex CCW polygon by r, with rounded corners. */
+function offset_convex_ccw(poly, r) {
+    const n = poly.length;
+    if (n < 3 || r <= 0) return poly;
+
+    // outward edge normals (right of each CCW edge)
+    const enx = new Array(n), enz = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const a = poly[i], b = poly[(i + 1) % n];
+        let dx = b.u - a.u, dz = b.v - a.v;
+        const len = Math.hypot(dx, dz) || 1;
+        dx /= len; dz /= len;
+        enx[i] = dz;   // (dir.v, -dir.u) = right/outward of a CCW edge
+        enz[i] = -dx;
+    }
+
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const prevEdge = (i - 1 + n) % n; // edge ending at vertex i
+        const nextEdge = i;               // edge starting at vertex i
+        const v = poly[i];
+
+        let a1 = Math.atan2(enz[prevEdge], enx[prevEdge]);
+        let a2 = Math.atan2(enz[nextEdge], enx[nextEdge]);
+        let da = a2 - a1;
+        while (da < 0) da += 2 * Math.PI;
+        while (da > 2 * Math.PI) da -= 2 * Math.PI;
+
+        const steps = Math.max(1, Math.ceil(da / CORNER_SEGMENT_ANGLE));
+        for (let s = 0; s <= steps; s++) {
+            const a = a1 + da * (s / steps);
+            out.push({ u: v.u + r * Math.cos(a), v: v.v + r * Math.sin(a) });
+        }
+    }
+    return out;
+}
+
+function subtract_convex(P, F) {
+    const pieces = [];
+    let current = P;
+    for (let i = 0; i < F.length; i++) {
+        if (current.length < 3) break;
+        const a = F[i];
+        const b = F[(i + 1) % F.length];
+        const ax = a.u, az = a.v;
+        const dx = b.u - a.u, dz = b.v - a.v;
+        if (Math.abs(dx) < POINT_EPS && Math.abs(dz) < POINT_EPS) continue; // skip degenerate edge
+        const outside = clip_halfplane(current, ax, az, dx, dz, false);
+        if (outside.length >= 3 && Math.abs(signed_area_uv(outside)) > AREA_EPS) pieces.push(outside);
+        current = clip_halfplane(current, ax, az, dx, dz, true);
+    }
+    return pieces;
+}
+
+/**
+ * @param {number[]} soup flat XYZ triangle soup (9 floats per triangle)
+ * @param {number} triangle_count
+ * @param {BinaryTopology} source source mesh (face normals must be populated)
+ * @param {number} agent_height
+ * @param {number} agent_radius dilation applied to each footprint
+ * @param {Vector3} up
+ * @returns {number[]} new soup with (dilated) obstacle footprints removed
+ */
+export function clip_soup_against_overhangs(soup, triangle_count, source, agent_height, agent_radius, up) {
+    let upx = up.x, upy = up.y, upz = up.z;
+    const ul = Math.hypot(upx, upy, upz);
+    if (ul === 0) return soup.slice(0, triangle_count * 9);
+    upx /= ul; upy /= ul; upz /= ul;
+
+    const B = basis_for_up(upx, upy, upz);
+    const along = (x, y, z) => x * upx + y * upy + z * upz;
+    const uOf = (x, y, z) => x * B.ux + y * B.uy + z * B.uz;
+    const vOf = (x, y, z) => x * B.vx + y * B.vy + z * B.vz;
+
+    // collect downward-facing (overhead) source triangles in (u,v) with their along-up height
+    const overhead = [];
+    const fn = new Float32Array(3);
+    const fc = new Float32Array(3);
+    const faceCount = source.faces.size;
+    for (let f = 0; f < faceCount; f++) {
+        if (!source.faces.is_allocated(f)) continue;
+        source.face_read_normal(fn, 0, f);
+        if (fn[0] * upx + fn[1] * upy + fn[2] * upz >= -1e-3) continue;
+
+        const la = source.face_read_loop(f);
+        const lb = source.loop_read_next(la);
+        const lc = source.loop_read_next(lb);
+        const uv = [];
+        let hsum = 0;
+        for (const l of [la, lb, lc]) {
+            source.vertex_read_coordinate(fc, 0, source.loop_read_vertex(l));
+            uv.push({ u: uOf(fc[0], fc[1], fc[2]), v: vOf(fc[0], fc[1], fc[2]) });
+            hsum += along(fc[0], fc[1], fc[2]);
+        }
+        overhead.push({ uv, h: hsum / 3 });
+    }
+
+    if (overhead.length === 0) return soup.slice(0, triangle_count * 9);
+
+    // Group overhead triangles that share a (coincident) vertex into one obstacle. Each obstacle's
+    // footprint is the convex hull of its vertices, dilated by the agent radius. Treating the obstacle
+    // as one polygon (rather than per-triangle) avoids self-touching/pinched union boundaries.
+    const QK = 1e4;
+    const vkey = (p) => Math.round(p.u * QK) + "," + Math.round(p.v * QK);
+    const parent = [];
+    const find = (a) => { while (parent[a] !== a) { parent[a] = parent[parent[a]]; a = parent[a]; } return a; };
+    for (let i = 0; i < overhead.length; i++) parent[i] = i;
+    const keyToTri = new Map();
+    for (let i = 0; i < overhead.length; i++) {
+        for (const p of overhead[i].uv) {
+            const k = vkey(p);
+            if (keyToTri.has(k)) parent[find(i)] = find(keyToTri.get(k)); else keyToTri.set(k, i);
+        }
+    }
+    const groups = new Map();
+    for (let i = 0; i < overhead.length; i++) {
+        const r = find(i);
+        let g = groups.get(r);
+        if (!g) { g = { pts: [], hsum: 0, n: 0 }; groups.set(r, g); }
+        for (const p of overhead[i].uv) g.pts.push(p.u, p.v);
+        g.hsum += overhead[i].h; g.n++;
+    }
+
+    const footprints = [];
+    for (const g of groups.values()) {
+        const hull = convex_hull_monotone_2d(g.pts, g.pts.length / 2);
+        if (hull.length < 3) continue;
+        let poly = hull.map((idx) => ({ u: g.pts[idx * 2], v: g.pts[idx * 2 + 1] }));
+        if (signed_area_uv(poly) < 0) poly = poly.slice().reverse();
+        if (agent_radius > 0) poly = offset_convex_ccw(poly, agent_radius);
+        footprints.push({ poly, h: g.hsum / g.n });
+    }
+
+    if (footprints.length === 0) return soup.slice(0, triangle_count * 9);
+
+    const out = [];
+    for (let t = 0; t < triangle_count; t++) {
+        const o = t * 9;
+        const tri = [];
+        let th = 0;
+        for (let k = 0; k < 3; k++) {
+            const x = soup[o + k * 3], y = soup[o + k * 3 + 1], z = soup[o + k * 3 + 2];
+            tri.push({ x, y, z, u: uOf(x, y, z), v: vOf(x, y, z) });
+            th += along(x, y, z);
+        }
+        th /= 3;
+
+        let pieces = [tri];
+        for (const fp of footprints) {
+            const dh = fp.h - th;
+            if (dh <= 1e-3 || dh > agent_height + 1e-3) continue;
+            const next = [];
+            for (const p of pieces) {
+                for (const s of subtract_convex(p, fp.poly)) next.push(s);
+            }
+            pieces = next;
+            if (pieces.length === 0) break;
+        }
+
+        for (const p of pieces) {
+            for (let i = 1; i + 1 < p.length; i++) {
+                const a0 = p[0], a1 = p[i], a2 = p[i + 1];
+                const area2 = Math.abs((a1.u - a0.u) * (a2.v - a0.v) - (a2.u - a0.u) * (a1.v - a0.v));
+                if (area2 < 2 * AREA_EPS) continue;
+                out.push(a0.x, a0.y, a0.z, a1.x, a1.y, a1.z, a2.x, a2.y, a2.z);
+            }
+        }
+    }
+    return out;
+}

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,QAyLxB;+BAvO8B,mEAAmE"}
+{"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"}

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

@@ -1,5 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { BinaryTopology } from "../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
 import {
     bt_mesh_cleanup_faceless_references
@@ -36,12 +35,13 @@ import {
 } from "../../../../core/geom/3d/topology/struct/binary/query/bt_mesh_compute_face_islands.js";
 import { v3_angle_between } from "../../../../core/geom/vec3/v3_angle_between.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
-import { bvh_build_from_bt_mesh } from "../bvh_build_from_bt_mesh.js";
-import { bvh_build_from_unindexed_triangles } from "./bvh_build_from_unindexed_triangles.js";
-import { bt_mesh_carve_height_clearance } from "./bt_mesh_carve_height_clearance.js";
 import {
     bt_mesh_resolve_t_junctions
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_resolve_t_junctions.js";
+import {
+    bt_mesh_fill_small_holes
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js";
+import { clip_soup_against_overhangs } from "./clip_soup_against_overhangs.js";
 
 
 /**
@@ -82,11 +82,6 @@ export function navmesh_build_topology({
     // outward winding; that remains an input contract we cannot recover from here.
     bt_mesh_compute_face_normals(source);
 
-    const source_bvh = new BVH();
-
-    // prepare a BVH, we'll need it for height queries later on
-    bvh_build_from_bt_mesh(source_bvh, source);
-
     const scratch_normal = new Float32Array(3);
 
     // unpack topology into triangle soup
@@ -100,7 +95,7 @@ export function navmesh_build_topology({
      *
      * @type {number[]}
      */
-    const raw_triangles = [];
+    let raw_triangles = [];
     let triangle_count = 0;
 
     for (let face_id = 0; face_id < source_face_count; face_id++) {
@@ -144,14 +139,6 @@ export function navmesh_build_topology({
     }
 
     {
-        const bvh = new BVH();
-
-        // first dump all triangles into a BVH for speed of access
-        bvh_build_from_unindexed_triangles(bvh, raw_triangles, triangle_count);
-
-        // find possible triangle edge connections, that is - where edges of 2 triangles touch, but don't match exactly.
-        // the touching edges will need to be cut and affected triangles split accordingly
-
         const mesh = new BinaryTopology();
 
         // raw_triangles may have stale tail data from filtering steps above (e.g. degenerate/steep);
@@ -177,27 +164,10 @@ export function navmesh_build_topology({
             bt_mesh_fuse_duplicate_edges(mesh);
         }
 
-        // --- Carve obstacle footprints first (no radius dilation here) ---
-        // Cull the floor directly under any overhang, opening a hole at each obstacle footprint. The
-        // agent-radius dilation is handled by the erosion below, which treats these holes as boundaries
-        // and insets them (and the outer edge) by exactly agent_radius - giving both a uniform inset and
-        // a smooth, consistent outline around obstacles from a single, robust pass.
-        if (agent_height > 0) {
-            bt_mesh_carve_height_clearance({
-                mesh,
-                source,
-                source_bvh,
-                agent_height,
-                agent_radius: 0,
-                up,
-            });
-
-            bt_mesh_compact(mesh);
-        }
-
-        // --- Then erode every boundary (outer edge + obstacle holes) by the agent radius ---
-        // The erosion uses an exact Euclidean distance field with cut-band refinement, so it stays
-        // accurate and connected even on the hole-punched mesh the carve produces.
+        // --- Erode the outer boundary by the agent radius (no obstacles carved yet) ---
+        // The erosion uses an exact Euclidean distance field with cut-band refinement, so the inset is
+        // uniform. Obstacles are carved afterwards (below) as pre-dilated footprints, so they are not
+        // eroded here a second time.
         {
             const islands = bt_mesh_compute_face_islands(mesh);
 
@@ -211,6 +181,36 @@ export function navmesh_build_topology({
             bt_mesh_compact(mesh);
         }
 
+        // --- Carve obstacle footprints, pre-dilated by the agent radius with rounded corners ---
+        // Subtract each overhead obstacle's r-dilated footprint from the (already outer-eroded) surface.
+        // The hole boundary is then the true offset of the obstacle - straight along edges, a clean arc
+        // at corners - instead of the wavy / mitred contour that sampling-then-eroding produced.
+        if (agent_height > 0) {
+            const soup = [];
+            const sv = [0, 0, 0];
+            for (let f = 0; f < mesh.faces.size; f++) {
+                if (!mesh.faces.is_allocated(f)) continue;
+                let l = mesh.face_read_loop(f);
+                for (let i = 0; i < 3; i++) {
+                    mesh.vertex_read_coordinate(sv, 0, mesh.loop_read_vertex(l));
+                    soup.push(sv[0], sv[1], sv[2]);
+                    l = mesh.loop_read_next(l);
+                }
+            }
+
+            const carved = clip_soup_against_overhangs(soup, (soup.length / 9) | 0, source, agent_height, agent_radius, up);
+
+            const carved_mesh = new BinaryTopology();
+            bt_mesh_from_unindexed_geometry(carved_mesh, carved);
+            bt_merge_verts_by_distance(carved_mesh, 1e-6);
+            bt_mesh_fuse_duplicate_edges(carved_mesh);
+            if (bt_mesh_resolve_t_junctions(carved_mesh, 1e-4) > 0) {
+                bt_merge_verts_by_distance(carved_mesh, 1e-6);
+                bt_mesh_fuse_duplicate_edges(carved_mesh);
+            }
+            mesh.copy(carved_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) {
@@ -224,6 +224,16 @@ export function navmesh_build_topology({
             bt_mesh_compact(mesh);
         }
 
+        // Fill hair-thin sliver holes left by erosion/clearance around obstacle offsets. They are
+        // narrower than the agent (it could never fit inside them), so they are numerical noise rather
+        // than real obstacles - removing them restores wrongly-culled walkable area and keeps the
+        // boundary clean (one outer loop + one loop per genuine obstacle).
+        if (agent_radius > 0) {
+            if (bt_mesh_fill_small_holes(mesh, agent_radius) > 0) {
+                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/build/bt_mesh_carve_height_clearance.d.ts

@@ -1,28 +0,0 @@
-/**
- * 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).
- *
- * 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`
- * @param {number} params.agent_height
- * @param {number} params.agent_radius
- * @param {Vector3} params.up world up direction
- */
-export function bt_mesh_carve_height_clearance({ mesh, source, source_bvh, agent_height, agent_radius, up, }: {
-    mesh: BinaryTopology;
-    source: BinaryTopology;
-    source_bvh: BVH;
-    agent_height: number;
-    agent_radius: number;
-    up: Vector3;
-}): void;
-//# sourceMappingURL=bt_mesh_carve_height_clearance.d.ts.map

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

@@ -1 +0,0 @@
-{"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;SAyH5B"}

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

@@ -1,358 +0,0 @@
-import { NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
-import {
-    bvh_query_leaves_ray_segment
-} from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.js";
-import {
-    bvh_query_user_data_overlaps_aabb
-} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
-import { NULL_POINTER } from "../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-import {
-    bt_mesh_cleanup_faceless_references
-} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.js";
-import { bt_edge_split } from "../../../../core/geom/3d/topology/struct/binary/io/edge/bt_edge_split.js";
-import { bt_face_kill } from "../../../../core/geom/3d/topology/struct/binary/io/face/bt_face_kill.js";
-import {
-    computeTriangleRayIntersectionBarycentric
-} from "../../../../core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js";
-
-/** Lift a ray origin off the surface so the upward clearance ray does not re-hit the floor. */
-const SURFACE_EPSILON = 1e-4;
-
-/** Safety cap on the face count during refinement. */
-const MAX_FACES = 200000;
-
-// reused scratch
-const ray_leaf_buffer = [];
-const intersection_result = new Float32Array(6);
-const tri_a = new Float32Array(3);
-const tri_b = new Float32Array(3);
-const tri_c = new Float32Array(3);
-
-const va = new Float32Array(3);
-const vb = new Float32Array(3);
-const vc = new Float32Array(3);
-
-const overhead_hits = [];
-const query_aabb = new Float32Array(6);
-const scratch_normal = new Float32Array(3);
-
-/** 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;
-    const origin_z = pz + up_z * SURFACE_EPSILON;
-
-    const leaf_count = bvh_query_leaves_ray_segment(
-        source_bvh, source_bvh.root,
-        ray_leaf_buffer, 0,
-        origin_x, origin_y, origin_z,
-        up_x, up_y, up_z,
-        0, agent_height
-    );
-
-    for (let i = 0; i < leaf_count; i++) {
-        const node = ray_leaf_buffer[i];
-        const face_id = source_bvh.node_get_user_data(node);
-
-        const loop_a = source.face_read_loop(face_id);
-        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);
-
-        source.vertex_read_coordinate(tri_a, 0, source.loop_read_vertex(loop_a));
-        source.vertex_read_coordinate(tri_b, 0, source.loop_read_vertex(loop_b));
-        source.vertex_read_coordinate(tri_c, 0, source.loop_read_vertex(loop_c));
-
-        const hit = computeTriangleRayIntersectionBarycentric(
-            intersection_result,
-            origin_x, origin_y, origin_z,
-            up_x, up_y, up_z,
-            tri_a[0], tri_a[1], tri_a[2],
-            tri_b[0], tri_b[1], tri_b[2],
-            tri_c[0], tri_c[1], tri_c[2]
-        );
-        if (!hit) continue;
-
-        const t = intersection_result[0];
-        if (t > 0 && t <= agent_height) return false;
-    }
-
-    return true;
-}
-
-/**
- * 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 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;
-
-    // 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));
-
-    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 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 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;
-    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;
-
-        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 > face_max_along_up + 1e-3) {
-            return true;
-        }
-    }
-
-    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) 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).
- *
- * 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`
- * @param {number} params.agent_height
- * @param {number} params.agent_radius
- * @param {Vector3} params.up world up direction
- */
-export function bt_mesh_carve_height_clearance({
-                                                   mesh,
-                                                   source,
-                                                   source_bvh,
-                                                   agent_height,
-                                                   agent_radius,
-                                                   up,
-                                               }) {
-
-    if (agent_height <= 0 || source_bvh.root === NULL_NODE) return;
-
-    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;
-    up_x /= up_len; up_y /= up_len; up_z /= up_len;
-
-    const r = Math.max(agent_radius, 0);
-    const resolution = Math.max(agent_radius > 0 ? agent_radius : agent_height / 4, 0.3);
-    const res_sq = resolution * resolution;
-
-    // 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: tight, conformal refinement around the (dilated) obstacle outline ----
-    let changed = true;
-    let guard = 0;
-
-    while (changed && guard < 64) {
-        changed = false;
-        guard++;
-
-        const face_count = mesh.faces.size;
-
-        for (let f = 0; f < face_count; f++) {
-            if (!mesh.faces.is_allocated(f)) continue;
-
-            read_face_triangle(mesh, f);
-
-            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) 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++;
-            }
-
-            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) {
-                // all clear by sampling, but a small obstacle can hide entirely between the samples of a
-                // coarse face. If any downward-facing overhang sits under the face footprint, keep
-                // refining down to the contour resolution so even sub-sample obstacles get caught.
-                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;
-
-            bt_edge_split(mesh, mesh.loop_read_edge(split_loop), 0.5);
-            changed = true;
-        }
-
-        if (mesh.faces.size > MAX_FACES) break;
-    }
-
-    // ---- Phase 2: cull blocked faces (whole-face, conformal) ----
-    const faces_to_kill = [];
-    const face_count = mesh.faces.size;
-
-    for (let f = 0; f < face_count; f++) {
-        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 (!agent_fits(cx, cy, cz)) faces_to_kill.push(f);
-    }
-
-    for (let i = 0; i < faces_to_kill.length; i++) {
-        bt_face_kill(mesh, faces_to_kill[i]);
-    }
-
-    if (faces_to_kill.length > 0) {
-        bt_mesh_cleanup_faceless_references(mesh);
-    }
-}

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

@@ -1,23 +0,0 @@
-/**
- * Knock holes in the walkable triangle soup wherever an agent of the given height would not fit under
- * overhead geometry.
- *
- * Approach: subdivide each candidate triangle to a resolution tied to the agent's footprint, cast an
- * upward clearance ray from each sub-triangle centroid against the source geometry, and keep only the
- * sub-triangles that have clearance. Fully-clear triangles are emitted unchanged (no subdivision), so
- * the common case adds no triangles; fully-blocked triangles are dropped; partially-blocked triangles
- * are replaced by their clear sub-triangles. Accuracy is bounded by the sampling resolution.
- *
- * The `triangles` array is rewritten in place with the surviving triangles.
- *
- * @param {BVH} bvh source-geometry BVH (leaves carry source face IDs)
- * @param {BinaryTopology} source source mesh, used to resolve face IDs to triangle vertices
- * @param {number} agent_height
- * @param {number} agent_radius
- * @param {number} triangle_count number of triangles currently in `triangles`
- * @param {number[]} triangles flat XYZ soup, 9 floats per triangle
- * @param {Vector3} up world up direction
- * @returns {number} new triangle count
- */
-export function enforce_agent_height_clearance({ bvh, source, agent_height, agent_radius, triangle_count, triangles, up, }: BVH): number;
-//# sourceMappingURL=enforce_agent_height_clearance.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"enforce_agent_height_clearance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/enforce_agent_height_clearance.js"],"names":[],"mappings":"AAmHA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kIAFa,MAAM,CA4IlB"}

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

@@ -1,319 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-import { NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
-import {
-    bvh_query_leaves_ray_segment
-} from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.js";
-import { NULL_POINTER } from "../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-import { compute_triangle_area_3d } from "../../../../core/geom/3d/triangle/compute_triangle_area_3d.js";
-import {
-    computeTriangleRayIntersectionBarycentric
-} from "../../../../core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js";
-import { clamp } from "../../../../core/math/clamp.js";
-
-/**
- * Upper bound on the per-edge subdivision factor, so a single huge triangle cannot explode into an
- * unbounded number of sub-triangles. At this cap a triangle is sampled with up to K_MAX^2 points.
- * @type {number}
- */
-const K_MAX = 64;
-
-/**
- * Small offset (in world units) used to lift a ray origin off the surface it sits on, so the upward
- * clearance ray does not immediately re-intersect the floor it starts from.
- * @type {number}
- */
-const SURFACE_EPSILON = 1e-4;
-
-// reused scratch (build-time, but there's no reason to churn allocations per triangle)
-const ray_leaf_buffer = [];
-const intersection_result = new Float32Array(6);
-const tri_a = new Float32Array(3);
-const tri_b = new Float32Array(3);
-const tri_c = new Float32Array(3);
-
-/**
- * True if there is no source geometry within `agent_height` directly above the point, measured along
- * the world up direction. Casts a ray up from the point (nudged off the surface) and checks every
- * source face whose AABB the ray crosses with a precise ray-triangle test.
- *
- * @param {BVH} bvh source-geometry BVH (leaves carry source face IDs)
- * @param {BinaryTopology} source source mesh, used to resolve face IDs to triangle vertices
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @param {number} up_x normalized world up
- * @param {number} up_y
- * @param {number} up_z
- * @param {number} agent_height
- * @returns {boolean}
- */
-function point_has_clearance(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;
-    const origin_z = pz + up_z * SURFACE_EPSILON;
-
-    const leaf_count = bvh_query_leaves_ray_segment(
-        bvh, bvh.root,
-        ray_leaf_buffer, 0,
-        origin_x, origin_y, origin_z,
-        up_x, up_y, up_z,
-        0, agent_height
-    );
-
-    for (let i = 0; i < leaf_count; i++) {
-        const node = ray_leaf_buffer[i];
-        const face_id = bvh.node_get_user_data(node);
-
-        const loop_a = source.face_read_loop(face_id);
-
-        if (loop_a === NULL_POINTER) {
-            continue;
-        }
-
-        const loop_b = source.loop_read_next(loop_a);
-        const loop_c = source.loop_read_next(loop_b);
-
-        source.vertex_read_coordinate(tri_a, 0, source.loop_read_vertex(loop_a));
-        source.vertex_read_coordinate(tri_b, 0, source.loop_read_vertex(loop_b));
-        source.vertex_read_coordinate(tri_c, 0, source.loop_read_vertex(loop_c));
-
-        const hit = computeTriangleRayIntersectionBarycentric(
-            intersection_result,
-            origin_x, origin_y, origin_z,
-            up_x, up_y, up_z,
-            tri_a[0], tri_a[1], tri_a[2],
-            tri_b[0], tri_b[1], tri_b[2],
-            tri_c[0], tri_c[1], tri_c[2]
-        );
-
-        if (!hit) {
-            continue;
-        }
-
-        const t = intersection_result[0];
-
-        if (t > 0 && t <= agent_height) {
-            // an overhead obstruction sits within the agent's height
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Append a triangle (9 floats) to `output`.
- */
-function emit_triangle(
-    output,
-    ax, ay, az,
-    bx, by, bz,
-    cx, cy, cz
-) {
-    output.push(ax, ay, az, bx, by, bz, cx, cy, cz);
-}
-
-/**
- * Knock holes in the walkable triangle soup wherever an agent of the given height would not fit under
- * overhead geometry.
- *
- * Approach: subdivide each candidate triangle to a resolution tied to the agent's footprint, cast an
- * upward clearance ray from each sub-triangle centroid against the source geometry, and keep only the
- * sub-triangles that have clearance. Fully-clear triangles are emitted unchanged (no subdivision), so
- * the common case adds no triangles; fully-blocked triangles are dropped; partially-blocked triangles
- * are replaced by their clear sub-triangles. Accuracy is bounded by the sampling resolution.
- *
- * The `triangles` array is rewritten in place with the surviving triangles.
- *
- * @param {BVH} bvh source-geometry BVH (leaves carry source face IDs)
- * @param {BinaryTopology} source source mesh, used to resolve face IDs to triangle vertices
- * @param {number} agent_height
- * @param {number} agent_radius
- * @param {number} triangle_count number of triangles currently in `triangles`
- * @param {number[]} triangles flat XYZ soup, 9 floats per triangle
- * @param {Vector3} up world up direction
- * @returns {number} new triangle count
- */
-export function enforce_agent_height_clearance({
-                                                   bvh,
-                                                   source,
-                                                   agent_height,
-                                                   agent_radius,
-                                                   triangle_count,
-                                                   triangles,
-                                                   up,
-                                               }) {
-
-    assert.defined(bvh, 'bvh');
-    assert.defined(source, 'source');
-    assert.greaterThan(agent_height, 0, 'agent_height');
-
-    if (bvh.root === NULL_NODE) {
-        // no source geometry to obstruct anything
-        return triangle_count;
-    }
-
-    // normalize up so ray-intersection distances are world distances
-    let up_x = up.x;
-    let up_y = up.y;
-    let up_z = up.z;
-
-    const up_length = Math.sqrt(up_x * up_x + up_y * up_y + up_z * up_z);
-
-    assert.greaterThan(up_length, 0, 'up vector length');
-
-    up_x /= up_length;
-    up_y /= up_length;
-    up_z /= up_length;
-
-    /**
-     * Resolution at which clearance is sampled. Tied to the agent footprint so the sampling grid is
-     * fine enough to resolve gaps the agent could (or could not) fit through.
-     * @type {number}
-     */
-    const sampling_resolution = Math.min(
-        agent_height / 4,
-        Math.max(agent_radius / 2, 0.001)
-    );
-
-    assert.isFinite(sampling_resolution, 'sampling_resolution');
-    assert.greaterThan(sampling_resolution, 0, 'sampling_resolution');
-
-    /**
-     * Surviving triangles. Built separately because the count can grow (subdivision), then copied back.
-     * @type {number[]}
-     */
-    const output = [];
-
-    for (let i = 0; i < triangle_count; i++) {
-        const address = i * 9;
-
-        const ax = triangles[address];
-        const ay = triangles[address + 1];
-        const az = triangles[address + 2];
-
-        const bx = triangles[address + 3];
-        const by = triangles[address + 4];
-        const bz = triangles[address + 5];
-
-        const cx = triangles[address + 6];
-        const cy = triangles[address + 7];
-        const cz = triangles[address + 8];
-
-        const area = compute_triangle_area_3d(ax, ay, az, bx, by, bz, cx, cy, cz);
-
-        if (area === 0) {
-            // degenerate, nothing meaningful to sample - keep as-is
-            emit_triangle(output, ax, ay, az, bx, by, bz, cx, cy, cz);
-            continue;
-        }
-
-        // edges, used both to size the subdivision and to place sub-triangle vertices
-        const e0x = bx - ax, e0y = by - ay, e0z = bz - az; // a -> b
-        const e1x = cx - ax, e1y = cy - ay, e1z = cz - az; // a -> c
-
-        const len_ab = Math.sqrt(e0x * e0x + e0y * e0y + e0z * e0z);
-        const len_ac = Math.sqrt(e1x * e1x + e1y * e1y + e1z * e1z);
-        const dbcx = cx - bx, dbcy = cy - by, dbcz = cz - bz;
-        const len_bc = Math.sqrt(dbcx * dbcx + dbcy * dbcy + dbcz * dbcz);
-
-        const longest_edge = Math.max(len_ab, len_ac, len_bc);
-
-        const k = clamp(Math.ceil(longest_edge / sampling_resolution), 1, K_MAX);
-
-        const inv_k = 1 / k;
-
-        // Sub-triangle vertices are P(i,j) = a + (i/k)*(b-a) + (j/k)*(c-a), for i+j <= k.
-        // Walk the k^2 sub-triangles (k*(k+... )/...) testing each centroid for clearance.
-        let any_blocked = false;
-        let any_clear = false;
-
-        // reuse a per-triangle scratch list of clear sub-triangles only when we actually subdivide
-        const clear_subtriangles = [];
-
-        for (let row = 0; row < k; row++) {
-            for (let col = 0; col < k - row; col++) {
-                // "upward" sub-triangle: P(col,row), P(col+1,row), P(col,row+1)
-                emit_subtriangle_if_clear(
-                    bvh, source, agent_height, up_x, up_y, up_z,
-                    ax, ay, az, e0x, e0y, e0z, e1x, e1y, e1z, inv_k,
-                    col, row, col + 1, row, col, row + 1,
-                    clear_subtriangles
-                ) ? (any_clear = true) : (any_blocked = true);
-
-                // "downward" sub-triangle: P(col+1,row), P(col+1,row+1), P(col,row+1)
-                if (col < k - row - 1) {
-                    emit_subtriangle_if_clear(
-                        bvh, source, agent_height, up_x, up_y, up_z,
-                        ax, ay, az, e0x, e0y, e0z, e1x, e1y, e1z, inv_k,
-                        col + 1, row, col + 1, row + 1, col, row + 1,
-                        clear_subtriangles
-                    ) ? (any_clear = true) : (any_blocked = true);
-                }
-            }
-        }
-
-        if (!any_blocked) {
-            // fully clear - keep the original triangle, no subdivision, no bloat
-            emit_triangle(output, ax, ay, az, bx, by, bz, cx, cy, cz);
-        } else if (any_clear) {
-            // partially blocked - replace with the surviving sub-triangles
-            for (let s = 0; s < clear_subtriangles.length; s++) {
-                output.push(clear_subtriangles[s]);
-            }
-        }
-        // else fully blocked - drop the triangle entirely
-    }
-
-    // rewrite the soup in place with the survivors
-    for (let i = 0; i < output.length; i++) {
-        triangles[i] = output[i];
-    }
-    triangles.length = output.length;
-
-    return (output.length / 9) | 0;
-}
-
-/**
- * Build sub-triangle vertices P(i,j) = a + (i/k)*e0 + (j/k)*e1, test its centroid for clearance, and
- * push its 9 coordinates into `out` when clear. Returns whether it was clear.
- */
-function emit_subtriangle_if_clear(
-    bvh, source, agent_height, up_x, up_y, up_z,
-    ax, ay, az, e0x, e0y, e0z, e1x, e1y, e1z, inv_k,
-    i0, j0, i1, j1, i2, j2,
-    out
-) {
-    const s0 = i0 * inv_k, t0 = j0 * inv_k;
-    const s1 = i1 * inv_k, t1 = j1 * inv_k;
-    const s2 = i2 * inv_k, t2 = j2 * inv_k;
-
-    const p0x = ax + s0 * e0x + t0 * e1x;
-    const p0y = ay + s0 * e0y + t0 * e1y;
-    const p0z = az + s0 * e0z + t0 * e1z;
-
-    const p1x = ax + s1 * e0x + t1 * e1x;
-    const p1y = ay + s1 * e0y + t1 * e1y;
-    const p1z = az + s1 * e0z + t1 * e1z;
-
-    const p2x = ax + s2 * e0x + t2 * e1x;
-    const p2y = ay + s2 * e0y + t2 * e1y;
-    const p2z = az + s2 * e0z + t2 * e1z;
-
-    const centroid_x = (p0x + p1x + p2x) / 3;
-    const centroid_y = (p0y + p1y + p2y) / 3;
-    const centroid_z = (p0z + p1z + p2z) / 3;
-
-    const clear = point_has_clearance(
-        bvh, source,
-        centroid_x, centroid_y, centroid_z,
-        up_x, up_y, up_z,
-        agent_height
-    );
-
-    if (clear) {
-        out.push(p0x, p0y, p0z, p1x, p1y, p1z, p2x, p2y, p2z);
-    }
-
-    return clear;
-}