@woosh/meep-engine 2.163.2 → 2.163.3

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

@@ -0,0 +1,323 @@
+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 immediately re-hit the floor.
+ * @type {number}
+ */
+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}
+ */
+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);
+
+/**
+ * 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.)
+ */
+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;
+        }
+        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) {
+            // overhead obstruction within the agent's height
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Read the three vertices of a triangular face into va/vb/vc and return its loops.
+ */
+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 };
+}
+
+/**
+ * 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.
+ */
+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
+    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;
+        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;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Carve holes into a (welded, connected) walkable topology wherever an agent of the given height
+ * would not fit under overhead geometry.
+ *
+ * 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.
+ *
+ * @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 {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) {
+        // nothing overhead can obstruct anything
+        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;
+    }
+    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 res_sq = resolution * resolution;
+
+    // ---- 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.
+    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);
+
+            // 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;
+            }
+
+            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;
+            }
+
+            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 (!point_has_clearance(source_bvh, source, cx, cy, cz, up_x, up_y, up_z, agent_height)) {
+            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/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,QAoLxB;+BA/N8B,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,QAiLxB;+BA5N8B,mEAAmE"}