@woosh/meep-engine 2.163.11 → 2.164.0

package/src/engine/graphics/trail/tube/TubeXPlugin.js

@@ -0,0 +1,80 @@
+import { Cache } from "../../../../core/cache/Cache.js";
+import { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
+import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
+import { TubeMaterialX } from "./TubeMaterialX.js";
+
+/**
+ * Shares and caches {@link TubeMaterialX} instances across all {@link Trail3D}
+ * tubes. Mirrors {@link RibbonXPlugin} but needs no screen-resolution uniform,
+ * since the tube extrudes in world space rather than screen space.
+ *
+ * Acquired lazily by {@link Trail3DSystem} via `engine.plugins.acquire`; it does
+ * not need explicit registration.
+ */
+export class TubeXPlugin extends EnginePlugin {
+
+    /**
+     * @type {Cache<TubeXMaterialSpec, TubeMaterialX>}
+     */
+    #materialCache = null;
+
+    initialize(engine) {
+        super.initialize(engine);
+
+        this.id = 'tube-x-plugin';
+
+        this.#materialCache = new Cache({
+            maxWeight: 128,
+
+            keyHashFunction: invokeObjectHash,
+            keyEqualityFunction: invokeObjectEquals
+        });
+    }
+
+    /**
+     * @param {TubeXMaterialSpec} spec
+     * @returns {TubeMaterialX}
+     */
+    obtain_material_x(spec) {
+        return this.#materialCache.getOrCompute(spec, this.#build_material, this);
+    }
+
+    /**
+     * @param {TubeXMaterialSpec} spec
+     * @returns {TubeMaterialX}
+     */
+    #build_material(spec) {
+
+        const material = new TubeMaterialX({
+            transparent: true,
+            depthWrite: spec.depthWrite,
+            wireframe: false
+        });
+
+        if (typeof spec.diffuse === "string") {
+            const am = this.engine.assetManager;
+
+            am.get({
+                path: spec.diffuse,
+                type: GameAssetType.Texture,
+                callback: (asset) => {
+                    /**
+                     * @type {Texture}
+                     */
+                    const texture = asset.create();
+
+                    texture.generateMipmaps = true;
+
+                    material.uniforms.uDiffuse.value = texture;
+                }, failure: console.warn
+            });
+
+            material.defines.USE_TEXTURE = true;
+            material.needsUpdate = true;
+        }
+
+        return material;
+    }
+}

package/src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Fixed-function simulation for {@link TubeX} tubes — the 3D analogue of
+ * {@link RibbonXFixedPhysicsSimulator}. Ages every knot, fades its alpha to zero
+ * as it approaches `max_age`, and flows the along-tube UV coordinate with age.
+ */
+export class TubeXFixedPhysicsSimulator {
+    /**
+     * @param {TubeX} tube
+     * @param {number} max_age
+     * @param {number} timeDelta
+     */
+    update(tube: TubeX, max_age: number, timeDelta: number): void;
+}
+//# sourceMappingURL=TubeXFixedPhysicsSimulator.d.ts.map

package/src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TubeXFixedPhysicsSimulator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IAEI;;;;OAIG;IACH,6BAHW,MAAM,aACN,MAAM,QAiBhB;CACJ"}

package/src/engine/graphics/trail/tube/simulator/TubeXFixedPhysicsSimulator.js

@@ -0,0 +1,32 @@
+import { clamp01 } from "../../../../../core/math/clamp01.js";
+import { TUBE_ATTRIBUTE_ADDRESS_AGE, TUBE_ATTRIBUTE_ADDRESS_UV_V } from "../tube_attributes_spec.js";
+
+/**
+ * Fixed-function simulation for {@link TubeX} tubes — the 3D analogue of
+ * {@link RibbonXFixedPhysicsSimulator}. Ages every knot, fades its alpha to zero
+ * as it approaches `max_age`, and flows the along-tube UV coordinate with age.
+ */
+export class TubeXFixedPhysicsSimulator {
+
+    /**
+     * @param {TubeX} tube
+     * @param {number} max_age
+     * @param {number} timeDelta
+     */
+    update(tube, max_age, timeDelta) {
+
+        const n = tube.getCount();
+
+        for (let i = 0; i < n; i++) {
+            const age = tube.incrementKnotAttribute_Scalar(i, TUBE_ATTRIBUTE_ADDRESS_AGE, timeDelta);
+
+            const relative_age = clamp01(age / max_age);
+
+            // fade out with age
+            tube.setKnotAlpha(i, 1.0 - relative_age);
+
+            // flow the along-tube UV with age
+            tube.setKnotAttribute_Scalar(i, TUBE_ATTRIBUTE_ADDRESS_UV_V, relative_age);
+        }
+    }
+}

package/src/engine/graphics/trail/tube/tube_attributes_spec.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-vertex attribute layout for a {@link TubeX}.
+ *
+ * Unlike {@link RibbonX} (which extrudes in screen space and therefore stores
+ * the neighbouring positions to derive a 2D normal), the tube extrudes in WORLD
+ * space inside the vertex shader using a per-knot tangent frame. Every vertex of
+ * a knot's ring shares the same centre/frame/colour/etc and differs only by `off`
+ * (its angular position around the ring), so the heavy per-frame work is just
+ * writing the knot centre + frame to the ring's `radial+1` rows.
+ *
+ * Layout is floats-first then a uint8 colour triple, padded to a 4-byte multiple
+ * so the interleaved Float32 view (stride = bytesPerRecord >> 2) stays aligned —
+ * the same trick {@link ribbon_attributes_spec} relies on.
+ */
+export const tube_attributes_spec: RowFirstTableSpec;
+export const TUBE_ATTRIBUTE_ADDRESS_AGE: 0;
+export const TUBE_ATTRIBUTE_ADDRESS_POSITION: 1;
+export const TUBE_ATTRIBUTE_ADDRESS_NORMAL: 4;
+export const TUBE_ATTRIBUTE_ADDRESS_BINORMAL: 7;
+export const TUBE_ATTRIBUTE_ADDRESS_OFF: 10;
+export const TUBE_ATTRIBUTE_ADDRESS_UV_V: 11;
+export const TUBE_ATTRIBUTE_ADDRESS_ALPHA: 12;
+export const TUBE_ATTRIBUTE_ADDRESS_THICKNESS: 13;
+export const TUBE_ATTRIBUTE_ADDRESS_COLOR: 14;
+import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
+//# sourceMappingURL=tube_attributes_spec.d.ts.map

package/src/engine/graphics/trail/tube/tube_attributes_spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tube_attributes_spec.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/tube_attributes_spec.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,qDAuC4B;AAG5B,2CAA4C;AAC5C,gDAAiD;AACjD,8CAA+C;AAC/C,gDAAiD;AACjD,4CAA6C;AAC7C,6CAA8C;AAC9C,8CAA+C;AAC/C,kDAAmD;AACnD,8CAA+C;kCAlEb,wDAAwD"}

package/src/engine/graphics/trail/tube/tube_attributes_spec.js

@@ -0,0 +1,69 @@
+import { EndianType } from "../../../../core/binary/EndianType.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
+import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
+
+/**
+ * Per-vertex attribute layout for a {@link TubeX}.
+ *
+ * Unlike {@link RibbonX} (which extrudes in screen space and therefore stores
+ * the neighbouring positions to derive a 2D normal), the tube extrudes in WORLD
+ * space inside the vertex shader using a per-knot tangent frame. Every vertex of
+ * a knot's ring shares the same centre/frame/colour/etc and differs only by `off`
+ * (its angular position around the ring), so the heavy per-frame work is just
+ * writing the knot centre + frame to the ring's `radial+1` rows.
+ *
+ * Layout is floats-first then a uint8 colour triple, padded to a 4-byte multiple
+ * so the interleaved Float32 view (stride = bytesPerRecord >> 2) stays aligned —
+ * the same trick {@link ribbon_attributes_spec} relies on.
+ */
+export const tube_attributes_spec = new RowFirstTableSpec([
+    // age (CPU-side bookkeeping for the simulator; NOT a GPU attribute)
+    BinaryDataType.Float32,
+
+    // position (ring centre, world space)
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+
+    // frame normal (ring basis axis 1, world space, unit)
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+
+    // frame binormal (ring basis axis 2, world space, unit)
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+
+    // off (angular position around the ring, 0..1; STATIC per radial index = uv.x)
+    BinaryDataType.Float32,
+
+    // uv_v (position along the tube; DYNAMIC = uv.y)
+    BinaryDataType.Float32,
+
+    // alpha
+    BinaryDataType.Float32,
+
+    // thickness (tube diameter; radius = thickness * 0.5)
+    BinaryDataType.Float32,
+
+    // color
+    BinaryDataType.Uint8,
+    BinaryDataType.Uint8,
+    BinaryDataType.Uint8,
+
+    // padding -> bytesPerRecord = 60 (divisible by 4, keeps the Float32 view aligned)
+    BinaryDataType.Uint8,
+
+], EndianType.LittleEndian);
+
+// Column indices into {@link tube_attributes_spec} for RowFirstTable read/write.
+export const TUBE_ATTRIBUTE_ADDRESS_AGE = 0;
+export const TUBE_ATTRIBUTE_ADDRESS_POSITION = 1;
+export const TUBE_ATTRIBUTE_ADDRESS_NORMAL = 4;
+export const TUBE_ATTRIBUTE_ADDRESS_BINORMAL = 7;
+export const TUBE_ATTRIBUTE_ADDRESS_OFF = 10;
+export const TUBE_ATTRIBUTE_ADDRESS_UV_V = 11;
+export const TUBE_ATTRIBUTE_ADDRESS_ALPHA = 12;
+export const TUBE_ATTRIBUTE_ADDRESS_THICKNESS = 13;
+export const TUBE_ATTRIBUTE_ADDRESS_COLOR = 14;

package/src/engine/graphics/trail/tube/tube_frame.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Compute a rotation-minimising (parallel-transported) tangent frame for one knot
+ * of a tube and write it as `[Nx, Ny, Nz, Bx, By, Bz]` to `out` at `out_offset`.
+ *
+ * Given the local unit tangent `T` and the previous knot's normal `prevN`, the new
+ * normal is `prevN` projected onto the plane perpendicular to `T` (Gram-Schmidt) —
+ * this is the discrete rotation-minimising frame, which carries the ring's
+ * orientation forward with no twist as the tangent turns. The binormal is `T × N`.
+ *
+ * When `prevN` is (nearly) parallel to `T` the projection collapses; we then
+ * bootstrap a stable arbitrary basis from `T` alone via
+ * {@link v3_orthonormal_matrix_from_normal}. This is a genuine geometric
+ * degeneracy (motion exactly along the previous normal), not a defensive guard.
+ *
+ * Equivalent to `m3_make_rotation_TBN(M, T, prevN)` (whose binormal row is
+ * `prevN × T` and whose normal row is the same projection), but written inline so
+ * we can detect the degeneracy BEFORE normalising — `Vector3.set` asserts on NaN,
+ * so feeding a zero vector to a normalising primitive would throw in dev builds.
+ *
+ * PRECONDITION: `T` is a unit vector. `prevN` should be a unit vector.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number} tx unit tangent x
+ * @param {number} ty unit tangent y
+ * @param {number} tz unit tangent z
+ * @param {number} pnx previous normal x
+ * @param {number} pny previous normal y
+ * @param {number} pnz previous normal z
+ */
+export function tube_frame_transport(out: number[] | Float32Array | Float64Array, out_offset: number, tx: number, ty: number, tz: number, pnx: number, pny: number, pnz: number): void;
+//# sourceMappingURL=tube_frame.d.ts.map

package/src/engine/graphics/trail/tube/tube_frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tube_frame.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/tube_frame.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,0CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAoChB"}

package/src/engine/graphics/trail/tube/tube_frame.js

@@ -0,0 +1,83 @@
+import { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
+
+/**
+ * Below this squared length the projected normal is treated as degenerate (the
+ * previous normal was ~parallel to the new tangent) and we bootstrap a fresh
+ * basis instead of normalising a near-zero vector.
+ * @type {number}
+ */
+const FRAME_DEGENERATE_EPSILON_SQR = 1e-10;
+
+/**
+ * Scratch for the bootstrap path; module-static so transport never allocates.
+ * Float64 so the util doesn't lose precision internally — the caller decides the
+ * storage precision of the result.
+ * @type {Float64Array}
+ */
+const _boot = new Float64Array(9);
+
+/**
+ * Compute a rotation-minimising (parallel-transported) tangent frame for one knot
+ * of a tube and write it as `[Nx, Ny, Nz, Bx, By, Bz]` to `out` at `out_offset`.
+ *
+ * Given the local unit tangent `T` and the previous knot's normal `prevN`, the new
+ * normal is `prevN` projected onto the plane perpendicular to `T` (Gram-Schmidt) —
+ * this is the discrete rotation-minimising frame, which carries the ring's
+ * orientation forward with no twist as the tangent turns. The binormal is `T × N`.
+ *
+ * When `prevN` is (nearly) parallel to `T` the projection collapses; we then
+ * bootstrap a stable arbitrary basis from `T` alone via
+ * {@link v3_orthonormal_matrix_from_normal}. This is a genuine geometric
+ * degeneracy (motion exactly along the previous normal), not a defensive guard.
+ *
+ * Equivalent to `m3_make_rotation_TBN(M, T, prevN)` (whose binormal row is
+ * `prevN × T` and whose normal row is the same projection), but written inline so
+ * we can detect the degeneracy BEFORE normalising — `Vector3.set` asserts on NaN,
+ * so feeding a zero vector to a normalising primitive would throw in dev builds.
+ *
+ * PRECONDITION: `T` is a unit vector. `prevN` should be a unit vector.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number} tx unit tangent x
+ * @param {number} ty unit tangent y
+ * @param {number} tz unit tangent z
+ * @param {number} pnx previous normal x
+ * @param {number} pny previous normal y
+ * @param {number} pnz previous normal z
+ */
+export function tube_frame_transport(out, out_offset, tx, ty, tz, pnx, pny, pnz) {
+    const d = pnx * tx + pny * ty + pnz * tz;
+
+    let nx = pnx - d * tx;
+    let ny = pny - d * ty;
+    let nz = pnz - d * tz;
+
+    const n_len2 = nx * nx + ny * ny + nz * nz;
+
+    if (n_len2 > FRAME_DEGENERATE_EPSILON_SQR) {
+        const inv = 1 / Math.sqrt(n_len2);
+
+        nx *= inv;
+        ny *= inv;
+        nz *= inv;
+
+        out[out_offset] = nx;
+        out[out_offset + 1] = ny;
+        out[out_offset + 2] = nz;
+
+        // B = T x N (unit, since T and N are orthonormal)
+        out[out_offset + 3] = ty * nz - tz * ny;
+        out[out_offset + 4] = tz * nx - tx * nz;
+        out[out_offset + 5] = tx * ny - ty * nx;
+    } else {
+        v3_orthonormal_matrix_from_normal(_boot, 0, tx, ty, tz);
+
+        out[out_offset] = _boot[0];
+        out[out_offset + 1] = _boot[1];
+        out[out_offset + 2] = _boot[2];
+        out[out_offset + 3] = _boot[3];
+        out[out_offset + 4] = _boot[4];
+        out[out_offset + 5] = _boot[5];
+    }
+}

package/src/engine/graphics/util/composeMatrix4.js

@@ -1,4 +1,4 @@
-import { compose_matrix4_array } from "../../../core/geom/3d/mat4/compose_matrix4_array.js";
+import { m4_compose } from "../../../core/geom/3d/mat4/m4_compose.js";
 
 /**
  *
@@ -9,5 +9,5 @@ import { compose_matrix4_array } from "../../../core/geom/3d/mat4/compose_matrix
  */
 export function composeMatrix4(result, position, rotation, scale) {
     const te = result.elements;
-    compose_matrix4_array(te, position, rotation, scale);
+    m4_compose(te, position, rotation, scale);
 }

package/src/engine/navigation/mesh/NavigationMesh.js

@@ -2,9 +2,9 @@ import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
 import { BinaryTopology, NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { navmesh_build_topology } from "./build/navmesh_build_topology.js";
-import { bt_mesh_face_find_path_polyanya } from "./bt_mesh_face_find_path_polyanya.js";
-import { bvh_build_from_bt_mesh } from "./bvh_build_from_bt_mesh.js";
-import { bvh_query_nearest_face } from "./bvh_query_nearest_face.js";
+import { bt_mesh_face_find_path_polyanya } from "../../../core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.js";
+import { bt_mesh_build_face_bvh } from "../../../core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js";
+import { bt_mesh_find_nearest_face } from "../../../core/geom/3d/topology/struct/binary/query/bt_mesh_find_nearest_face.js";
 
 // snapped (on-mesh) start/goal positions, reused across queries
 const scratch_start_point = new Float32Array(3);
@@ -80,7 +80,7 @@ export class NavigationMesh {
             up,
         });
 
-        bvh_build_from_bt_mesh(this.bvh, this.topology);
+        bt_mesh_build_face_bvh(this.bvh, this.topology);
     }
 
 
@@ -114,14 +114,14 @@ export class NavigationMesh {
         const mesh = this.topology;
         const bvh = this.bvh;
 
-        const start_face_id = bvh_query_nearest_face(bvh, mesh, start_x, start_y, start_z, scratch_start_point);
+        const start_face_id = bt_mesh_find_nearest_face(bvh, mesh, start_x, start_y, start_z, scratch_start_point);
 
         if (start_face_id === NULL_POINTER) {
             // probably topology is empty
             return 0;
         }
 
-        const goal_face_id = bvh_query_nearest_face(bvh, mesh, goal_x, goal_y, goal_z, scratch_goal_point);
+        const goal_face_id = bt_mesh_find_nearest_face(bvh, mesh, goal_x, goal_y, goal_z, scratch_goal_point);
 
         if (goal_face_id === NULL_POINTER) {
             // should never happen if we got the start face

package/src/engine/navigation/mesh/PATHFINDING_PLAN.md

@@ -193,7 +193,7 @@ Built as a **standalone 2-D module** `bt_mesh_face_find_path_polyanya` (xy-plane
    sidestepped it by orienting on face normals, not a cone). Full `navigation/mesh` suite stays green.
 
    **Path validation + a finding (done).** Both benches keep their paths and validate them against a
-   BVH: `bvh_segment_penetrates_mesh` flags any piece that crosses a triangle interior transversally, and
+   BVH: `bt_mesh_segment_penetrates_surface` flags any piece that crosses a triangle interior transversally, and
    sampling reports how far each piece strays off the surface. The finding: a **corner-only** waypoint path
    is correct only AT its turning corners, so the straight chord between two corners on different levels
    flew over / cut through the ramped geometry between them (the funnel had the same property) — on the

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

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

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

@@ -27,11 +27,12 @@
  */
 
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { bvh_query_user_data_overlaps_aabb } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
+import { bvh_query_user_data_intersects_aabb } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
 import { convex_hull_monotone_2d } from "../../../../core/geom/2d/convex-hull/convex_hull_monotone_2d.js";
 import { compute_polygon_area_2d } from "../../../../core/geom/2d/compute_polygon_area_2d.js";
+import { polygon2_clip_halfplane } from "../../../../core/geom/2d/polygon/polygon2_clip_halfplane.js";
 
 const POINT_EPS = 1e-9;
 const AREA_EPS = 1e-9;
@@ -70,53 +71,6 @@ function ensure_capacity(buf, vertex_count) {
     return new Float64Array(size);
 }
 
-/**
- * Sutherland-Hodgman clip of a 2D polygon against one half-plane of a directed edge - the general-edge
- * analogue of {@link polygon2_clip_axis_halfplane}. The edge passes through (ex, ez) with direction
- * (dx, dz); `keep_left` keeps the side with `cross(dir, P - e) >= 0`, otherwise the right side.
- *
- * @param {Float64Array} in_pts input vertices (stride 2)
- * @param {number} in_n input vertex count
- * @param {Float64Array} out_pts output buffer (stride 2), sized for at least in_n + 1 vertices
- * @param {number} ex
- * @param {number} ez a point on the edge
- * @param {number} dx
- * @param {number} dz the edge direction
- * @param {boolean} keep_left keep the left half-plane when true
- * @returns {number} surviving vertex count
- */
-function clip_halfplane(in_pts, in_n, out_pts, ex, ez, dx, dz, keep_left) {
-    let out_n = 0;
-
-    for (let i = 0; i < in_n; i++) {
-        const j = (i + 1) % in_n;
-
-        const a_u = in_pts[i * 2], a_v = in_pts[i * 2 + 1];
-        const b_u = in_pts[j * 2], b_v = in_pts[j * 2 + 1];
-
-        const sa = dx * (a_v - ez) - dz * (a_u - ex);
-        const sb = dx * (b_v - ez) - dz * (b_u - ex);
-
-        const in_a = keep_left ? (sa >= -POINT_EPS) : (sa <= POINT_EPS);
-        const in_b = keep_left ? (sb >= -POINT_EPS) : (sb <= POINT_EPS);
-
-        if (in_a) {
-            out_pts[out_n * 2] = a_u;
-            out_pts[out_n * 2 + 1] = a_v;
-            out_n++;
-        }
-
-        if (in_a !== in_b) {
-            const t = sa / (sa - sb);
-            out_pts[out_n * 2] = a_u + t * (b_u - a_u);
-            out_pts[out_n * 2 + 1] = a_v + t * (b_v - a_v);
-            out_n++;
-        }
-    }
-
-    return out_n;
-}
-
 /**
  * Outward Minkowski-with-disc offset of a convex CCW polygon by `r`: each edge is pushed out by `r` and
  * each convex corner is replaced by a rounded arc. Input/output are flat (u,v) pairs.
@@ -194,13 +148,13 @@ function subtract_footprint(poly, poly_n, fp, fp_n, out_pieces) {
         if (Math.abs(dx) < POINT_EPS && Math.abs(dz) < POINT_EPS) continue; // degenerate edge
 
         // piece outside this edge (and inside all earlier edges) leaves the footprint here -> it survives
-        const side_n = clip_halfplane(cur, cur_n, _side, ex, ez, dx, dz, false);
+        const side_n = polygon2_clip_halfplane(cur, cur_n, _side, ex, ez, dx, dz, false);
         if (side_n >= 3 && Math.abs(compute_polygon_area_2d(_side, side_n)) > AREA_EPS) {
             out_pieces.push(_side.slice(0, side_n * 2));
         }
 
         // keep marching with the part still inside this edge
-        cur_n = clip_halfplane(cur, cur_n, tmp, ex, ez, dx, dz, true);
+        cur_n = polygon2_clip_halfplane(cur, cur_n, tmp, ex, ez, dx, dz, true);
         const swap = cur; cur = tmp; tmp = swap;
     }
 }
@@ -388,7 +342,7 @@ export function clip_soup_against_overhangs(soup, triangle_count, source, agent_
         query_aabb[0] = min_u; query_aabb[1] = min_v; query_aabb[2] = th;
         query_aabb[3] = max_u; query_aabb[4] = max_v; query_aabb[5] = th;
 
-        const hit_count = bvh_query_user_data_overlaps_aabb(query_hits, 0, footprint_bvh, query_aabb);
+        const hit_count = bvh_query_user_data_intersects_aabb(query_hits, 0, footprint_bvh, query_aabb);
         if (hit_count === 0) {
             // no obstacle overlaps here - copy straight through
             for (let i = 0; i < 9; i++) out.push(soup[o + i]);

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":"AAuDA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAmNxB;+BA3Q8B,mEAAmE"}
+{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAmNxB;+BAvQ8B,mEAAmE"}

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

@@ -1,11 +1,10 @@
 import { assert } from "../../../../core/assert.js";
 import { BinaryTopology } from "../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import { bt_mesh_bridge_islands } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_bridge_islands.js";
 import {
     bt_mesh_cleanup_faceless_references
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.js";
-import {
-    bt_mesh_compact
-} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_compact.js";
+import { bt_mesh_compact } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_compact.js";
 import {
     bt_mesh_compute_face_normals
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_compute_face_normals.js";
@@ -16,34 +15,31 @@ import {
 import {
     bt_mesh_face_island_erode
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.js";
+import {
+    bt_mesh_fill_small_holes
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js";
 import {
     bt_mesh_from_unindexed_geometry
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_from_unindexed_geometry.js";
+import {
+    bt_mesh_resolve_t_junctions
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_resolve_t_junctions.js";
+import {
+    bt_mesh_simplify_by_error
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_simplify_by_error.js";
 import { bt_mesh_triangulate } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_triangulate.js";
 import {
     bt_mesh_fuse_duplicate_edges
 } from "../../../../core/geom/3d/topology/struct/binary/io/edge/bt_mesh_fuse_duplicate_edges.js";
 import {
-    bt_merge_verts_by_distance
-} from "../../../../core/geom/3d/topology/struct/binary/io/vertex/bt_merge_verts_by_distance.js";
+    bt_merge_vertices_by_distance
+} from "../../../../core/geom/3d/topology/struct/binary/io/vertex/bt_merge_vertices_by_distance.js";
 import { bt_face_is_degenerate } from "../../../../core/geom/3d/topology/struct/binary/query/bt_face_is_degenerate.js";
-import {
-    bt_mesh_bridge_islands
-} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_bridge_islands.js";
 import {
     bt_mesh_compute_face_islands
 } 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 { v3_angle } from "../../../../core/geom/vec3/v3_angle.js";
 import Vector3 from "../../../../core/geom/Vector3.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 {
-    bt_mesh_simplify_by_error
-} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_simplify_by_error.js";
 import { clip_soup_against_overhangs } from "./clip_soup_against_overhangs.js";
 
 // Fraction of the agent radius used as the navmesh cleanup error budget (see the cleanup pass in
@@ -116,7 +112,7 @@ export function navmesh_build_topology({
 
         source.face_read_normal(scratch_normal, 0, face_id);
 
-        const angle = v3_angle_between(up.x, up.y, up.z, scratch_normal[0], scratch_normal[1], scratch_normal[2]);
+        const angle = v3_angle(up.x, up.y, up.z, scratch_normal[0], scratch_normal[1], scratch_normal[2]);
 
         if (angle > agent_max_climb_angle) {
             // discard
@@ -162,7 +158,7 @@ export function navmesh_build_topology({
         bt_mesh_from_unindexed_geometry(mesh, raw_triangles);
 
         // fuse coincident positions so neighbouring triangles share a vertex id...
-        bt_merge_verts_by_distance(mesh, 1e-6);
+        bt_merge_vertices_by_distance(mesh, 1e-6);
 
         // ...then fuse the resulting duplicate edges so they share an edge id too,
         // which is what the loop-based neighbour queries rely on
@@ -174,7 +170,7 @@ export function navmesh_build_topology({
         // treat them as disconnected. Split such edges at the stray vertex, then re-weld/fuse so the
         // pieces share a real edge.
         if (bt_mesh_resolve_t_junctions(mesh, 1e-4) > 0) {
-            bt_merge_verts_by_distance(mesh, 1e-6);
+            bt_merge_vertices_by_distance(mesh, 1e-6);
             bt_mesh_fuse_duplicate_edges(mesh);
         }
 
@@ -216,10 +212,10 @@ export function navmesh_build_topology({
 
             const carved_mesh = new BinaryTopology();
             bt_mesh_from_unindexed_geometry(carved_mesh, carved);
-            bt_merge_verts_by_distance(carved_mesh, 1e-6);
+            bt_merge_vertices_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_merge_vertices_by_distance(carved_mesh, 1e-6);
                 bt_mesh_fuse_duplicate_edges(carved_mesh);
             }
             mesh.copy(carved_mesh);