@woosh/meep-engine 2.163.2 → 2.163.4

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

@@ -0,0 +1,359 @@
+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 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: 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 && 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;
+
+            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/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,QAkLxB;+BA7N8B,mEAAmE"}