@woosh/meep-engine 2.163.5 → 2.163.6

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.6",
   "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,CAoClB"}

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

@@ -0,0 +1,144 @@
+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;
+
+    const cycles = bt_mesh_walk_boundary_loops(mesh);
+    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/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":"AAiDA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAmMxB;+BApP8B,mEAAmE"}

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

@@ -42,6 +42,9 @@ import { bt_mesh_carve_height_clearance } from "./bt_mesh_carve_height_clearance
 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";
 
 
 /**
@@ -224,6 +227,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);