@woosh/meep-engine 2.163.10 → 2.164.0

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_shared_loop.js

@@ -0,0 +1,48 @@
+import { assert } from "../../../../../../assert.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Find the loop in `face_a` whose edge is shared with `face_b`.
+ *
+ * The returned loop belongs to `face_a` and its edge is also used by a loop in `face_b`.
+ * Combined with {@link BinaryTopology#loop_read_vertex} and {@link BinaryTopology#loop_read_next},
+ * this is enough to read the two vertices of the shared edge in `face_a`'s winding order,
+ * which is useful for constructing directed portals.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face_a
+ * @param {number} face_b
+ * @returns {number} loop ID in `face_a` that shares an edge with `face_b`, or {@link NULL_POINTER} if no shared edge exists
+ */
+export function bt_face_get_shared_loop(mesh, face_a, face_b) {
+    assert.defined(mesh, "mesh");
+    assert.notNull(mesh, "mesh");
+    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
+    assert.isNonNegativeInteger(face_a, "face_a");
+    assert.isNonNegativeInteger(face_b, "face_b");
+
+    const start_loop = mesh.face_read_loop(face_a);
+
+    if (start_loop === NULL_POINTER) {
+        return NULL_POINTER;
+    }
+
+    let current_loop = start_loop;
+
+    do {
+        // walk the radial cycle around the edge of this loop
+        let radial_loop = mesh.loop_read_radial_next(current_loop);
+
+        while (radial_loop !== current_loop) {
+            if (mesh.loop_read_face(radial_loop) === face_b) {
+                return current_loop;
+            }
+
+            radial_loop = mesh.loop_read_radial_next(radial_loop);
+        }
+
+        current_loop = mesh.loop_read_next(current_loop);
+    } while (current_loop !== start_loop);
+
+    return NULL_POINTER;
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_vertex_adjacent_faces.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Given a face, get a list of its attached faces.
+ * Two faces are attached if they share a vertex.
+ * @param {number[]|Uint32Array} output
+ * @param {number} output_offset
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {number} number of faces written to output
+ * @see bt_face_get_neighbour_faces
+ */
+export function bt_face_get_vertex_adjacent_faces(output: number[] | Uint32Array, output_offset: number, mesh: BinaryTopology, face_id: number): number;
+//# sourceMappingURL=bt_face_get_vertex_adjacent_faces.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_vertex_adjacent_faces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_face_get_vertex_adjacent_faces.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_get_vertex_adjacent_faces.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,0DAPW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,iCAEN,MAAM,GACJ,MAAM,CAqFlB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_vertex_adjacent_faces.js

@@ -0,0 +1,96 @@
+import { assert } from "../../../../../../assert.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Given a face, get a list of its attached faces.
+ * Two faces are attached if they share a vertex.
+ * @param {number[]|Uint32Array} output
+ * @param {number} output_offset
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {number} number of faces written to output
+ * @see bt_face_get_neighbour_faces
+ */
+export function bt_face_get_vertex_adjacent_faces(
+    output,
+    output_offset,
+    mesh,
+    face_id
+) {
+
+    assert.isArrayLike(output, "output");
+    assert.isNonNegativeInteger(output_offset, "output_offset");
+    assert.isNonNegativeInteger(face_id, "face_id");
+    assert.defined(mesh, "mesh");
+    assert.notNull(mesh, "mesh");
+    assert.isObject(mesh, "mesh");
+    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
+
+    let count = 0;
+    const first_loop = mesh.face_read_loop(face_id);
+
+    // Safety check for malformed faces
+    if (first_loop === NULL_POINTER) {
+        return 0;
+    }
+
+    let curr_loop = first_loop;
+
+    // 1. Iterate through every loop (vertex) of the given face
+    do {
+        const v = mesh.loop_read_vertex(curr_loop);
+        const first_edge = mesh.vertex_read_edge(v);
+
+        if (first_edge !== NULL_POINTER) {
+            let curr_edge = first_edge;
+
+            // 2. Iterate through the disk cycle (all edges connected to this vertex)
+            do {
+                const first_radial_loop = mesh.edge_read_loop(curr_edge);
+
+                if (first_radial_loop !== NULL_POINTER) {
+                    let curr_radial_loop = first_radial_loop;
+
+                    // 3. Iterate through the radial cycle (all faces sharing this edge)
+                    do {
+                        const adj_face = mesh.loop_read_face(curr_radial_loop);
+
+                        // Ignore the original face and null pointers
+                        if (adj_face !== face_id && adj_face !== NULL_POINTER) {
+
+                            // Check for duplicates (linear scan is fastest for small n)
+                            let is_duplicate = false;
+                            for (let i = 0; i < count; i++) {
+                                if (output[output_offset + i] === adj_face) {
+                                    is_duplicate = true;
+                                    break;
+                                }
+                            }
+
+                            // Write to output if it's uniquely discovered
+                            if (!is_duplicate) {
+                                output[output_offset + count] = adj_face;
+                                count++;
+                            }
+                        }
+
+                        curr_radial_loop = mesh.loop_read_radial_next(curr_radial_loop);
+                    } while (curr_radial_loop !== first_radial_loop && curr_radial_loop !== NULL_POINTER);
+                }
+
+                // Move to the next edge in the vertex's disk cycle
+                if (mesh.edge_read_vertex1(curr_edge) === v) {
+                    curr_edge = mesh.edge_read_v1_disk_next(curr_edge);
+                } else {
+                    curr_edge = mesh.edge_read_v2_disk_next(curr_edge);
+                }
+
+            } while (curr_edge !== first_edge && curr_edge !== NULL_POINTER);
+        }
+
+        // Move to the next loop in the face
+        curr_loop = mesh.loop_read_next(curr_loop);
+    } while (curr_loop !== first_loop && curr_loop !== NULL_POINTER);
+
+    return count;
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_island_flood_fill.js

@@ -1,4 +1,4 @@
-import { bt_face_get_neighbour_faces } from "./bt_face_get_neighbour_faces.js";
+import { bt_face_get_edge_adjacent_faces } from "./bt_face_get_edge_adjacent_faces.js";
 
 const _neighbours = [];
 
@@ -33,7 +33,7 @@ export function bt_face_island_flood_fill(mesh, seed_faces, out, visited) {
         const f = open.pop();
         out.push(f);
 
-        const neighbour_count = bt_face_get_neighbour_faces(_neighbours, 0, mesh, f);
+        const neighbour_count = bt_face_get_edge_adjacent_faces(_neighbours, 0, mesh, f);
         for (let i = 0; i < neighbour_count; i++) {
             const g = _neighbours[i];
             if (visited.getAndSet(g)) continue;

package/src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.d.ts

@@ -1,15 +1,7 @@
 /**
- * Find the loop in `face_a` whose edge is shared with `face_b`.
- *
- * The returned loop belongs to `face_a` and its edge is also used by a loop in `face_b`.
- * Combined with {@link BinaryTopology#loop_read_vertex} and {@link BinaryTopology#loop_read_next},
- * this is enough to read the two vertices of the shared edge in `face_a`'s winding order,
- * which is useful for constructing directed portals.
- *
- * @param {BinaryTopology} mesh
- * @param {number} face_a
- * @param {number} face_b
- * @returns {number} loop ID in `face_a` that shares an edge with `face_b`, or {@link NULL_POINTER} if no shared edge exists
+ * @deprecated Renamed to {@link bt_face_get_shared_loop}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function bt_faces_shared_loop(mesh: BinaryTopology, face_a: number, face_b: number): number;
+export const bt_faces_shared_loop: typeof bt_face_get_shared_loop;
+import { bt_face_get_shared_loop } from "./bt_face_get_shared_loop.js";
 //# sourceMappingURL=bt_faces_shared_loop.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_faces_shared_loop.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,mEAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiClB"}
+{"version":3,"file":"bt_faces_shared_loop.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,kEAA4D;wCANpB,8BAA8B"}

package/src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.js

@@ -1,48 +1,7 @@
-import { assert } from "../../../../../../assert.js";
-import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_face_get_shared_loop } from "./bt_face_get_shared_loop.js";
 
 /**
- * Find the loop in `face_a` whose edge is shared with `face_b`.
- *
- * The returned loop belongs to `face_a` and its edge is also used by a loop in `face_b`.
- * Combined with {@link BinaryTopology#loop_read_vertex} and {@link BinaryTopology#loop_read_next},
- * this is enough to read the two vertices of the shared edge in `face_a`'s winding order,
- * which is useful for constructing directed portals.
- *
- * @param {BinaryTopology} mesh
- * @param {number} face_a
- * @param {number} face_b
- * @returns {number} loop ID in `face_a` that shares an edge with `face_b`, or {@link NULL_POINTER} if no shared edge exists
+ * @deprecated Renamed to {@link bt_face_get_shared_loop}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function bt_faces_shared_loop(mesh, face_a, face_b) {
-    assert.defined(mesh, "mesh");
-    assert.notNull(mesh, "mesh");
-    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
-    assert.isNonNegativeInteger(face_a, "face_a");
-    assert.isNonNegativeInteger(face_b, "face_b");
-
-    const start_loop = mesh.face_read_loop(face_a);
-
-    if (start_loop === NULL_POINTER) {
-        return NULL_POINTER;
-    }
-
-    let current_loop = start_loop;
-
-    do {
-        // walk the radial cycle around the edge of this loop
-        let radial_loop = mesh.loop_read_radial_next(current_loop);
-
-        while (radial_loop !== current_loop) {
-            if (mesh.loop_read_face(radial_loop) === face_b) {
-                return current_loop;
-            }
-
-            radial_loop = mesh.loop_read_radial_next(radial_loop);
-        }
-
-        current_loop = mesh.loop_read_next(current_loop);
-    } while (current_loop !== start_loop);
-
-    return NULL_POINTER;
-}
+export const bt_faces_shared_loop = bt_face_get_shared_loop;

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.d.ts

@@ -1,26 +1,3 @@
-/**
- * Gather the geometry of a set of boundary edges into a flat segment buffer for fast distance queries.
- *
- * Each edge contributes 6 consecutive numbers: `ax, ay, az, bx, by, bz`. The buffer is reused: it is
- * written from index 0 and truncated to the exact number of values produced, so callers can keep a
- * single array alive across many invocations without churning the garbage collector.
- *
- * @param {BinaryTopology} mesh
- * @param {Iterable<number>} boundary_edges boundary edge IDs
- * @param {number[]} out_segments reused output buffer (filled and length-truncated in place)
- * @returns {number} the number of segments written
- */
-export function bt_collect_boundary_segments(mesh: BinaryTopology, boundary_edges: Iterable<number>, out_segments: number[]): number;
-/**
- * Exact straight-line (Euclidean) distance from a point to the nearest boundary segment.
- *
- * @param {number[]} segments flat segment buffer (6 numbers per segment) from {@link bt_collect_boundary_segments}
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number} the distance, or `Infinity` when the buffer is empty
- */
-export function bt_point_distance_to_segments(segments: number[], px: number, py: number, pz: number): number;
 /**
  * Build a Euclidean boundary distance field for an island: for every island vertex, the exact
  * straight-line distance to the nearest boundary segment.

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_build_boundary_euclidean_distance_field.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,mFAJW,SAAS,MAAM,CAAC,gBAChB,MAAM,EAAE,GACN,MAAM,CAgBlB;AAED;;;;;;;;GAQG;AACH,wDANW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;;;;;;GAcG;AACH,2FALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,SAAS,MAAM,CAAC,YAChB,MAAM,EAAE,QAclB"}
+{"version":3,"file":"bt_mesh_build_boundary_euclidean_distance_field.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,2FALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,SAAS,MAAM,CAAC,YAChB,MAAM,EAAE,QAclB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.js

@@ -1,59 +1,7 @@
-import { line3_compute_segment_point_distance_sqr } from "../../../../line/line3_compute_segment_point_distance_sqr.js";
+import { segment3_point_distance_to_segments } from "../../../../line/segment3_point_distance_to_segments.js";
 
 const _v = new Float32Array(3);
 
-/**
- * Gather the geometry of a set of boundary edges into a flat segment buffer for fast distance queries.
- *
- * Each edge contributes 6 consecutive numbers: `ax, ay, az, bx, by, bz`. The buffer is reused: it is
- * written from index 0 and truncated to the exact number of values produced, so callers can keep a
- * single array alive across many invocations without churning the garbage collector.
- *
- * @param {BinaryTopology} mesh
- * @param {Iterable<number>} boundary_edges boundary edge IDs
- * @param {number[]} out_segments reused output buffer (filled and length-truncated in place)
- * @returns {number} the number of segments written
- */
-export function bt_collect_boundary_segments(mesh, boundary_edges, out_segments) {
-    let w = 0;
-    let count = 0;
-
-    for (const e of boundary_edges) {
-        mesh.vertex_read_coordinate(_v, 0, mesh.edge_read_vertex1(e));
-        out_segments[w++] = _v[0]; out_segments[w++] = _v[1]; out_segments[w++] = _v[2];
-        mesh.vertex_read_coordinate(_v, 0, mesh.edge_read_vertex2(e));
-        out_segments[w++] = _v[0]; out_segments[w++] = _v[1]; out_segments[w++] = _v[2];
-        count++;
-    }
-
-    out_segments.length = w;
-    return count;
-}
-
-/**
- * Exact straight-line (Euclidean) distance from a point to the nearest boundary segment.
- *
- * @param {number[]} segments flat segment buffer (6 numbers per segment) from {@link bt_collect_boundary_segments}
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number} the distance, or `Infinity` when the buffer is empty
- */
-export function bt_point_distance_to_segments(segments, px, py, pz) {
-    let best_sq = Infinity;
-
-    for (let i = 0; i < segments.length; i += 6) {
-        const d_sq = line3_compute_segment_point_distance_sqr(
-            segments[i], segments[i + 1], segments[i + 2],
-            segments[i + 3], segments[i + 4], segments[i + 5],
-            px, py, pz
-        );
-        if (d_sq < best_sq) best_sq = d_sq;
-    }
-
-    return best_sq === Infinity ? Infinity : Math.sqrt(best_sq);
-}
-
 /**
  * Build a Euclidean boundary distance field for an island: for every island vertex, the exact
  * straight-line distance to the nearest boundary segment.
@@ -79,6 +27,6 @@ export function bt_mesh_build_boundary_euclidean_distance_field(
 
     for (const v of island_vertices) {
         mesh.vertex_read_coordinate(_v, 0, v);
-        vertex_boundary_distances.set(v, bt_point_distance_to_segments(segments, _v[0], _v[1], _v[2]));
+        vertex_boundary_distances.set(v, segment3_point_distance_to_segments(segments, _v[0], _v[1], _v[2]));
     }
 }

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Build a face BVH over a binary-topology mesh: each leaf holds a `face_id` and its bounds are the
+ * corresponding face's bounds. The resulting BVH is what {@link bt_mesh_find_nearest_face} and
+ * {@link bt_mesh_segment_penetrates_surface} expect.
+ * @param {BVH} bvh
+ * @param {BinaryTopology} mesh
+ */
+export function bt_mesh_build_face_bvh(bvh: BVH, mesh: BinaryTopology): void;
+//# sourceMappingURL=bt_mesh_build_face_bvh.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_build_face_bvh.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,6EAwDC"}

package/src/{engine/navigation/mesh/bvh_build_from_bt_mesh.js → core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js}

@@ -1,11 +1,13 @@
-import { assert } from "../../../core/assert.js";
+import { assert } from "../../../../../../assert.js";
 
 /**
- * BVH leaves will contain `face_id` and their bounds will be set from the corresponding face bounds.
+ * Build a face BVH over a binary-topology mesh: each leaf holds a `face_id` and its bounds are the
+ * corresponding face's bounds. The resulting BVH is what {@link bt_mesh_find_nearest_face} and
+ * {@link bt_mesh_segment_penetrates_surface} expect.
  * @param {BVH} bvh
  * @param {BinaryTopology} mesh
  */
-export function bvh_build_from_bt_mesh(bvh, mesh) {
+export function bt_mesh_build_face_bvh(bvh, mesh) {
     assert.defined(bvh, 'bvh');
     assert.defined(mesh, 'mesh');
     assert.equal(mesh.isBinaryTopology, true, 'mesh.isBinaryTopology !== true');

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_face_find_path.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path.js"],"names":[],"mappings":"AAwoBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAVW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,gBACN,MAAM,8CAEN,MAAM,GAGJ,MAAM,CAuDlB"}

package/src/{engine/navigation/mesh → core/geom/3d/topology/struct/binary/query}/bt_mesh_face_find_path.js

@@ -1,12 +1,10 @@
-import { assert } from "../../../core/assert.js";
-import { Uint32Heap } from "../../../core/collection/heap/Uint32Heap.js";
-import { NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-import {
-    bt_face_get_neighbour_faces
-} from "../../../core/geom/3d/topology/struct/binary/query/bt_face_get_neighbour_faces.js";
+import { assert } from "../../../../../../assert.js";
+import { Uint32Heap } from "../../../../../../collection/heap/Uint32Heap.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_face_get_edge_adjacent_faces } from "./bt_face_get_edge_adjacent_faces.js";
 import {
     bt_mesh_compute_edge_distance_eikonal
-} from "../../../core/geom/3d/topology/struct/binary/query/bt_mesh_compute_edge_distance_eikonal.js";
+} from "./bt_mesh_compute_edge_distance_eikonal.js";
 
 /**
  * Note that we limit the supported number of neighbors, a reasonable mesh will fit this criteria
@@ -407,7 +405,7 @@ function pick_exit_edge(
  * the gradient march cannot pick a forward exit edge.
  */
 function lowest_unvisited_neighbour(topology, face) {
-    const count = bt_face_get_neighbour_faces(neighbors, 0, topology, face);
+    const count = bt_face_get_edge_adjacent_faces(neighbors, 0, topology, face);
 
     let best_face = NULL_POINTER;
     let best_distance = Infinity;
@@ -608,7 +606,7 @@ function search_corridor(output, topology, start_face, goal_face, max_path_lengt
             return construct_path(output, start_face, goal_face, max_path_length);
         }
 
-        const count = bt_face_get_neighbour_faces(neighbors, 0, topology, current);
+        const count = bt_face_get_edge_adjacent_faces(neighbors, 0, topology, current);
 
         for (let i = 0; i < count; i++) {
             const neighbor = neighbors[i];

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_face_find_path_polyanya.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.js"],"names":[],"mappings":"AA2TA;;;;;;;;;;;;;;GAcG;AACH,wDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gCAElC,MAAM,MACN,MAAM,MACN,MAAM,cACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,MAAM,GACJ,MAAM,CA+HlB"}

package/src/{engine/navigation/mesh → core/geom/3d/topology/struct/binary/query}/bt_mesh_face_find_path_polyanya.js

@@ -1,8 +1,8 @@
-import { Uint32Heap4 } from "../../../core/collection/heap/Uint32Heap4.js";
-import { line_segment_intersection_fraction_2d } from "../../../core/geom/2d/line/line_segment_intersection_fraction_2d.js";
-import { triangle2d_compute_area } from "../../../core/geom/2d/triangle2d_compute_area.js";
-import { NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-import { v2_distance } from "../../../core/geom/vec2/v2_distance.js";
+import { Uint32Heap4 } from "../../../../../../collection/heap/Uint32Heap4.js";
+import { line2_segment_intersection_fraction_2d } from "../../../../../2d/line/line2_segment_intersection_fraction_2d.js";
+import { tri2_signed_area } from "../../../../../2d/triangle/tri2_signed_area.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { v2_distance } from "../../../../../vec2/v2_distance.js";
 
 /*
  * Polyanya: exact any-angle shortest path on a triangle navmesh.
@@ -65,11 +65,11 @@ function reflect(px, py, ax, ay, bx, by) {
 /** Exact root->interval->goal distance in the unfolded frame (the terminal node's true final cost). */
 function touch_distance(rx, ry, i0x, i0y, i1x, i1y, gx, gy) {
     let tx = gx, ty = gy;
-    if (triangle2d_compute_area(i0x, i0y, i1x, i1y, rx, ry) * triangle2d_compute_area(i0x, i0y, i1x, i1y, gx, gy) > 0) {
+    if (tri2_signed_area(i0x, i0y, i1x, i1y, rx, ry) * tri2_signed_area(i0x, i0y, i1x, i1y, gx, gy) > 0) {
         reflect(gx, gy, i0x, i0y, i1x, i1y);
         tx = _reflect[0]; ty = _reflect[1];
     }
-    const t = line_segment_intersection_fraction_2d(rx, ry, tx, ty, i0x, i0y, i1x, i1y);
+    const t = line2_segment_intersection_fraction_2d(rx, ry, tx, ty, i0x, i0y, i1x, i1y);
     if (t >= -PEPS && t <= 1 + PEPS) { // -1 (no crossing) falls below -PEPS, so the range test rejects it
         return v2_distance(rx, ry, tx, ty);
     }
@@ -427,7 +427,7 @@ export function bt_mesh_face_find_path_polyanya(output, topology, sx, sy, sz, st
         if (n === best && t_fct !== -1) {
             u = t_fct;
         } else {
-            u = line_segment_intersection_fraction_2d(rx, ry, next_u, next_v, e0x, e0y, e1x, e1y);
+            u = line2_segment_intersection_fraction_2d(rx, ry, next_u, next_v, e0x, e0y, e1x, e1y);
             if (u === -1) {
                 // the route line grazes a shared vertex (passes through / just outside an edge endpoint,
                 // common when the geodesic runs along a row of grid vertices): snap to the nearer endpoint
@@ -504,7 +504,7 @@ function expand(topology, id, goal_face) {
     // interval endpoints + their edge vertex ids, ordered so i1 is left of the ray root->i0
     let i0x = e0x + t0 * (e1x - e0x), i0y = e0y + t0 * (e1y - e0y), i0v = t0 <= PEPS ? e0v : (t0 >= 1 - PEPS ? e1v : -1);
     let i1x = e0x + t1 * (e1x - e0x), i1y = e0y + t1 * (e1y - e0y), i1v = t1 <= PEPS ? e0v : (t1 >= 1 - PEPS ? e1v : -1);
-    if (triangle2d_compute_area(rx, ry, i0x, i0y, i1x, i1y) < 0) {
+    if (tri2_signed_area(rx, ry, i0x, i0y, i1x, i1y) < 0) {
         const sxx = i0x, syy = i0y, svv = i0v;
         i0x = i1x; i0y = i1y; i0v = i1v; i1x = sxx; i1y = syy; i1v = svv;
     }
@@ -523,8 +523,8 @@ function process_far_edge(topology, from_face, Pv, Px, Py, Qv, Qx, Qy, rx, ry, r
     const neighbour = neighbour_across(topology, from_face, Pv, Qv);
 
     let m = 0;
-    const tR = line_segment_intersection_fraction_2d(rx, ry, i0x, i0y, Px, Py, Qx, Qy);
-    const tL = line_segment_intersection_fraction_2d(rx, ry, i1x, i1y, Px, Py, Qx, Qy);
+    const tR = line2_segment_intersection_fraction_2d(rx, ry, i0x, i0y, Px, Py, Qx, Qy);
+    const tL = line2_segment_intersection_fraction_2d(rx, ry, i1x, i1y, Px, Py, Qx, Qy);
     // -1 (no crossing) fails `> PEPS`, so the interior-fraction test rejects it without a NaN check
     if (tR > PEPS && tR < 1 - PEPS) _split[m++] = tR;
     if (tL > PEPS && tL < 1 - PEPS) _split[m++] = tL;
@@ -536,8 +536,8 @@ function process_far_edge(topology, from_face, Pv, Px, Py, Qv, Qx, Qy, rx, ry, r
         if (next - prev < PEPS) { prev = next; continue; }
 
         const mx = Px + (Qx - Px) * (prev + next) * 0.5, my = Py + (Qy - Py) * (prev + next) * 0.5;
-        const sR = triangle2d_compute_area(rx, ry, i0x, i0y, mx, my); // >=0: left of right-ray (inside cone)
-        const sL = triangle2d_compute_area(rx, ry, i1x, i1y, mx, my); // <=0: right of left-ray (inside cone)
+        const sR = tri2_signed_area(rx, ry, i0x, i0y, mx, my); // >=0: left of right-ray (inside cone)
+        const sL = tri2_signed_area(rx, ry, i1x, i1y, mx, my); // <=0: right of left-ray (inside cone)
 
         if (sR >= -EPS && sL <= EPS) {
             add_successor(topology, neighbour, from_face, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid, g, parent, prev, next, goal_face);
@@ -622,7 +622,7 @@ function emit_node(topology, neighbour, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid,
 
         let i0x = Px + t0 * (Qx - Px), i0y = Py + t0 * (Qy - Py), i0p = t0;
         let i1x = Px + t1 * (Qx - Px), i1y = Py + t1 * (Qy - Py), i1p = t1;
-        if (triangle2d_compute_area(rx, ry, i0x, i0y, i1x, i1y) < 0) {
+        if (tri2_signed_area(rx, ry, i0x, i0y, i1x, i1y) < 0) {
             const sxx = i0x, syy = i0y, sp = i0p; i0x = i1x; i0y = i1y; i0p = i1p; i1x = sxx; i1y = syy; i1p = sp;
         }
 
@@ -630,10 +630,10 @@ function emit_node(topology, neighbour, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid,
 
         let fct = -1; // -1 = straight shot (no forced bend at an interval endpoint); a real bend is in [0,1]
         let tx = ggx, ty = ggy;
-        if (triangle2d_compute_area(i0x, i0y, i1x, i1y, rx, ry) * triangle2d_compute_area(i0x, i0y, i1x, i1y, ggx, ggy) > 0) {
+        if (tri2_signed_area(i0x, i0y, i1x, i1y, rx, ry) * tri2_signed_area(i0x, i0y, i1x, i1y, ggx, ggy) > 0) {
             reflect(ggx, ggy, i0x, i0y, i1x, i1y); tx = _reflect[0]; ty = _reflect[1];
         }
-        const t = line_segment_intersection_fraction_2d(rx, ry, tx, ty, i0x, i0y, i1x, i1y);
+        const t = line2_segment_intersection_fraction_2d(rx, ry, tx, ty, i0x, i0y, i1x, i1y);
         if (t < -PEPS || t > 1 + PEPS) { // -1 (no crossing) is caught by `< -PEPS`
             const d0 = v2_distance(rx, ry, i0x, i0y) + v2_distance(i0x, i0y, ggx, ggy);
             const d1 = v2_distance(rx, ry, i1x, i1y) + v2_distance(i1x, i1y, ggx, ggy);

package/src/{engine/navigation/mesh/bvh_query_nearest_face.d.ts → core/geom/3d/topology/struct/binary/query/bt_mesh_find_nearest_face.d.ts}

@@ -1,6 +1,6 @@
 /**
  * Find the face of `mesh` whose surface is closest to the given point.
- * Expects `bvh` to have been built by {@link bvh_build_from_bt_mesh}, so each leaf's user data is a face ID.
+ * Expects `bvh` to have been built by {@link bt_mesh_build_face_bvh}, so each leaf's user data is a face ID.
  * Faces are expected to be triangles (as produced by the navmesh build pipeline).
  *
  * @param {BVH} bvh
@@ -14,5 +14,5 @@
  * @param {number} [max_distance=Infinity] optional cutoff, only faces within this distance are considered
  * @returns {number} face ID of the nearest face, or {@link NULL_POINTER} if no face was found within the cutoff
  */
-export function bvh_query_nearest_face(bvh: BVH, mesh: BinaryTopology, x: number, y: number, z: number, out_point: Float32Array | number[], out_point_offset?: number, max_distance?: number): number;
-//# sourceMappingURL=bvh_query_nearest_face.d.ts.map
+export function bt_mesh_find_nearest_face(bvh: BVH, mesh: BinaryTopology, x: number, y: number, z: number, out_point: Float32Array | number[], out_point_offset?: number, max_distance?: number): number;
+//# sourceMappingURL=bt_mesh_find_nearest_face.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_find_nearest_face.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_find_nearest_face.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_find_nearest_face.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;GAeG;AACH,6EATW,MAAM,KACN,MAAM,KACN,MAAM,aACN,YAAY,GAAC,MAAM,EAAE,qBAErB,MAAM,iBACN,MAAM,GACJ,MAAM,CA+HlB"}

package/src/{engine/navigation/mesh/bvh_query_nearest_face.js → core/geom/3d/topology/struct/binary/query/bt_mesh_find_nearest_face.js}

@@ -1,19 +1,17 @@
-import { assert } from "../../../core/assert.js";
+import { assert } from "../../../../../../assert.js";
 import {
     COLUMN_CHILD_1,
     COLUMN_CHILD_2,
     COLUMN_USER_DATA,
     ELEMENT_WORD_COUNT,
     NULL_NODE
-} from "../../../core/bvh2/bvh3/BVH.js";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+} from "../../../../../../bvh2/bvh3/BVH.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import {
     aabb3_unsigned_distance_sqr_to_point
-} from "../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
-import { NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
-import {
-    computeTriangleClosestPointToPointBarycentric
-} from "../../../core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js";
+} from "../../../../aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { tri3_closest_point_barycentric } from "../../../../triangle/tri3_closest_point_barycentric.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
@@ -22,7 +20,7 @@ const scratch_coords = new Float32Array(3);
 
 /**
  * Find the face of `mesh` whose surface is closest to the given point.
- * Expects `bvh` to have been built by {@link bvh_build_from_bt_mesh}, so each leaf's user data is a face ID.
+ * Expects `bvh` to have been built by {@link bt_mesh_build_face_bvh}, so each leaf's user data is a face ID.
  * Faces are expected to be triangles (as produced by the navmesh build pipeline).
  *
  * @param {BVH} bvh
@@ -36,7 +34,7 @@ const scratch_coords = new Float32Array(3);
  * @param {number} [max_distance=Infinity] optional cutoff, only faces within this distance are considered
  * @returns {number} face ID of the nearest face, or {@link NULL_POINTER} if no face was found within the cutoff
  */
-export function bvh_query_nearest_face(
+export function bt_mesh_find_nearest_face(
     bvh,
     mesh,
     x, y, z,
@@ -122,7 +120,7 @@ export function bvh_query_nearest_face(
         const cx = scratch_coords[0], cy = scratch_coords[1], cz = scratch_coords[2];
 
         // reuse the same scratch for the barycentric output (only the first two slots are written)
-        computeTriangleClosestPointToPointBarycentric(
+        tri3_closest_point_barycentric(
             scratch_coords, 0,
             x, y, z,
             ax, ay, az,

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_sample_interior_grid_points.js

@@ -3,7 +3,7 @@ import { BVH, NULL_NODE } from "../../../../../../bvh2/bvh3/BVH.js";
 import { bvh_query_user_data_ray } from "../../../../../../bvh2/bvh3/query/bvh_query_user_data_ray.js";
 import { seededRandom } from "../../../../../../math/random/seededRandom.js";
 import { SurfacePoint3 } from "../../../../SurfacePoint3.js";
-import { computeTriangleRayIntersection } from "../../../../triangle/computeTriangleRayIntersection.js";
+import { tri3_ray_intersection } from "../../../../triangle/tri3_ray_intersection.js";
 
 // Three irrational, mutually unrelated ray directions for parity ray-cast
 // majority vote. Same scheme as tetrahedral_mesh_carve_outside_surface — a
@@ -87,8 +87,8 @@ function point_is_inside(mesh, bvh, ox, oy, oz) {
         const dz = RAY_DIRECTIONS[r * 3 + 2];
 
         const candidate_count = bvh_query_user_data_ray(
-            bvh, root,
             ray_candidates, 0,
+            bvh, root,
             ox, oy, oz,
             dx, dy, dz
         );
@@ -104,7 +104,7 @@ function point_is_inside(mesh, bvh, ox, oy, oz) {
             mesh.vertex_read_coordinate(vb, 0, mesh.loop_read_vertex(l1));
             mesh.vertex_read_coordinate(vc, 0, mesh.loop_read_vertex(l2));
 
-            const hit = computeTriangleRayIntersection(
+            const hit = tri3_ray_intersection(
                 ray_hit,
                 ox, oy, oz,
                 dx, dy, dz,