@woosh/meep-engine 2.147.0 → 2.149.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.147.0",
+  "version": "2.149.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_bridge_islands.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Connect islands that are not topologically joined but lie within a small step (vertical) and/or gap
+ * (lateral) of one another, so an agent can path across stairs and small breaks in the floor.
+ *
+ * The two unused params on the build path (`agent_max_step_height`, `agent_max_step_distance`) drive this.
+ * Boundary edges of distinct islands whose endpoints can be paired within the thresholds are stitched
+ * with a bridge quad (two triangles). Connectivity is realised by rebuilding the mesh from its triangle
+ * soup plus the bridge quads and re-running the same vertex-merge / edge-fuse the build already uses -
+ * the bridge corners are copied verbatim from existing boundary vertices, so they fuse onto the islands.
+ *
+ * Mutates `mesh` in place. Triangulated input is assumed (as produced by the navmesh build pipeline).
+ *
+ * @param {BinaryTopology} mesh
+ * @param {{max_step_height:number, max_step_distance:number, up:Vector3}} options
+ * @returns {number} number of bridges added
+ */
+export function bt_mesh_bridge_islands(mesh: BinaryTopology, { max_step_height, max_step_distance, up }: {
+    max_step_height: number;
+    max_step_distance: number;
+    up: Vector3;
+}): number;
+import { BinaryTopology } from "../BinaryTopology.js";
+//# sourceMappingURL=bt_mesh_bridge_islands.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_bridge_islands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_bridge_islands.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_bridge_islands.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;GAeG;AACH,6CAJW,cAAc,8CACd;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,iBAAiB,EAAC,MAAM,CAAC;IAAC,EAAE,UAAQ;CAAC,GAC5D,MAAM,CAoKlB;+BAtS8B,sBAAsB"}

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

@@ -0,0 +1,295 @@
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_compute_face_islands } from "../query/bt_mesh_compute_face_islands.js";
+import { bt_query_edge_is_boundary } from "../query/bt_query_edge_is_boundary.js";
+import { bt_mesh_from_unindexed_geometry } from "./bt_mesh_from_unindexed_geometry.js";
+import { bt_mesh_fuse_duplicate_edges } from "./edge/bt_mesh_fuse_duplicate_edges.js";
+import { bt_merge_verts_by_distance } from "./vertex/bt_merge_verts_by_distance.js";
+
+/**
+ * Distance under which rebuilt vertices are fused, matching the navmesh build pipeline. Bridge corner
+ * coordinates are copied verbatim from existing boundary vertices, so they fuse exactly.
+ * @type {number}
+ */
+const VERTEX_MERGE_DISTANCE = 1e-6;
+
+/**
+ * Tolerance added to the step thresholds so exactly-on-the-limit connections (e.g. a perfectly aligned
+ * step with zero lateral gap, tested against max_step_distance = 0) are accepted.
+ * @type {number}
+ */
+const THRESHOLD_EPSILON = 1e-6;
+
+/**
+ * Decompose the vector (px,py,pz) - (qx,qy,qz) into components along and perpendicular to `up` and,
+ * if it is within the step thresholds, return the perpendicular (lateral) distance; otherwise -1.
+ */
+function connection_lateral_distance(
+    px, py, pz,
+    qx, qy, qz,
+    up_x, up_y, up_z,
+    max_step_height, max_step_distance
+) {
+    const dx = px - qx;
+    const dy = py - qy;
+    const dz = pz - qz;
+
+    const along_up = dx * up_x + dy * up_y + dz * up_z;
+    const vertical = Math.abs(along_up);
+    const lateral = Math.sqrt(Math.max(0, (dx * dx + dy * dy + dz * dz) - along_up * along_up));
+
+    if (vertical <= max_step_height + THRESHOLD_EPSILON && lateral <= max_step_distance + THRESHOLD_EPSILON) {
+        return lateral;
+    }
+
+    return -1;
+}
+
+/**
+ * Evaluate whether two boundary edges can be bridged and, if so, which endpoint pairing to use.
+ * Writes the cheaper valid pairing into `out_best` as `[pairing, cost]` (pairing 1 = a1<->b1 / a2<->b2,
+ * pairing 2 = a1<->b2 / a2<->b1) and returns true; returns false (leaving `out_best` untouched) when
+ * neither pairing fits the thresholds. `out_best` is supplied by the caller to avoid per-pair allocation.
+ *
+ * @returns {boolean}
+ */
+function evaluate_pair(a, b, up_x, up_y, up_z, max_step_height, max_step_distance, out_best) {
+    // pairing 1: a.p1 <-> b.p1, a.p2 <-> b.p2
+    const c1_1 = connection_lateral_distance(b.x1, b.y1, b.z1, a.x1, a.y1, a.z1, up_x, up_y, up_z, max_step_height, max_step_distance);
+    const c1_2 = connection_lateral_distance(b.x2, b.y2, b.z2, a.x2, a.y2, a.z2, up_x, up_y, up_z, max_step_height, max_step_distance);
+
+    // pairing 2: a.p1 <-> b.p2, a.p2 <-> b.p1
+    const c2_1 = connection_lateral_distance(b.x2, b.y2, b.z2, a.x1, a.y1, a.z1, up_x, up_y, up_z, max_step_height, max_step_distance);
+    const c2_2 = connection_lateral_distance(b.x1, b.y1, b.z1, a.x2, a.y2, a.z2, up_x, up_y, up_z, max_step_height, max_step_distance);
+
+    let found = false;
+    let pairing = 0;
+    let cost = Infinity;
+
+    if (c1_1 >= 0 && c1_2 >= 0) {
+        pairing = 1;
+        cost = c1_1 + c1_2;
+        found = true;
+    }
+
+    if (c2_1 >= 0 && c2_2 >= 0) {
+        const cost_2 = c2_1 + c2_2;
+        if (!found || cost_2 < cost) {
+            pairing = 2;
+            cost = cost_2;
+            found = true;
+        }
+    }
+
+    if (found) {
+        out_best[0] = pairing;
+        out_best[1] = cost;
+    }
+
+    return found;
+}
+
+/**
+ * Append a triangle to the soup, choosing the winding so its normal points along `up` (keeps bridge
+ * faces walkable / consistently oriented with the floor islands they connect).
+ */
+function push_triangle_facing_up(
+    soup,
+    p0x, p0y, p0z,
+    p1x, p1y, p1z,
+    p2x, p2y, p2z,
+    up_x, up_y, up_z
+) {
+    const e1x = p1x - p0x, e1y = p1y - p0y, e1z = p1z - p0z;
+    const e2x = p2x - p0x, e2y = p2y - p0y, e2z = p2z - p0z;
+
+    const nx = e1y * e2z - e1z * e2y;
+    const ny = e1z * e2x - e1x * e2z;
+    const nz = e1x * e2y - e1y * e2x;
+
+    if (nx * up_x + ny * up_y + nz * up_z >= 0) {
+        soup.push(p0x, p0y, p0z, p1x, p1y, p1z, p2x, p2y, p2z);
+    } else {
+        // flip winding so the normal faces up (preserves the undirected edges, only reverses direction)
+        soup.push(p0x, p0y, p0z, p2x, p2y, p2z, p1x, p1y, p1z);
+    }
+}
+
+/**
+ * Connect islands that are not topologically joined but lie within a small step (vertical) and/or gap
+ * (lateral) of one another, so an agent can path across stairs and small breaks in the floor.
+ *
+ * The two unused params on the build path (`agent_max_step_height`, `agent_max_step_distance`) drive this.
+ * Boundary edges of distinct islands whose endpoints can be paired within the thresholds are stitched
+ * with a bridge quad (two triangles). Connectivity is realised by rebuilding the mesh from its triangle
+ * soup plus the bridge quads and re-running the same vertex-merge / edge-fuse the build already uses -
+ * the bridge corners are copied verbatim from existing boundary vertices, so they fuse onto the islands.
+ *
+ * Mutates `mesh` in place. Triangulated input is assumed (as produced by the navmesh build pipeline).
+ *
+ * @param {BinaryTopology} mesh
+ * @param {{max_step_height:number, max_step_distance:number, up:Vector3}} options
+ * @returns {number} number of bridges added
+ */
+export function bt_mesh_bridge_islands(mesh, { max_step_height, max_step_distance, up }) {
+    const islands = bt_mesh_compute_face_islands(mesh);
+
+    if (islands.length < 2) {
+        // a single (or empty) connected component - nothing to bridge
+        return 0;
+    }
+
+    // normalize up so the along/perpendicular split uses world distances
+    let up_x = up.x;
+    let up_y = up.y;
+    let up_z = up.z;
+
+    const up_length = Math.sqrt(up_x * up_x + up_y * up_y + up_z * up_z);
+    up_x /= up_length;
+    up_y /= up_length;
+    up_z /= up_length;
+
+    // face -> island index
+    const island_of_face = new Map();
+    for (let i = 0; i < islands.length; i++) {
+        const faces = islands[i];
+        for (let k = 0; k < faces.length; k++) {
+            island_of_face.set(faces[k], i);
+        }
+    }
+
+    // collect boundary edges, tagged with their island and endpoint coordinates
+    const boundary = [];
+    const edge_count = mesh.edges.size;
+    const coord_1 = [0, 0, 0];
+    const coord_2 = [0, 0, 0];
+
+    for (let e = 0; e < edge_count; e++) {
+        if (!mesh.edges.is_allocated(e)) {
+            continue;
+        }
+
+        if (!bt_query_edge_is_boundary(mesh, e)) {
+            continue;
+        }
+
+        const loop = mesh.edge_read_loop(e);
+        const face = mesh.loop_read_face(loop);
+        const island = island_of_face.get(face);
+
+        mesh.vertex_read_coordinate(coord_1, 0, mesh.edge_read_vertex1(e));
+        mesh.vertex_read_coordinate(coord_2, 0, mesh.edge_read_vertex2(e));
+
+        boundary.push({
+            island,
+            x1: coord_1[0], y1: coord_1[1], z1: coord_1[2],
+            x2: coord_2[0], y2: coord_2[1], z2: coord_2[2],
+        });
+    }
+
+    // for each boundary edge, find its cheapest bridgeable partner in another island
+    const bridges = [];
+    const bridged_pairs = new Set();
+
+    // reused [pairing, cost] scratch, written by evaluate_pair, so the inner loop allocates nothing
+    const pair_result = [0, 0];
+
+    for (let i = 0; i < boundary.length; i++) {
+        let best_j = -1;
+        let best_cost = Infinity;
+        let best_pairing = 0;
+
+        for (let j = 0; j < boundary.length; j++) {
+            if (boundary[j].island === boundary[i].island) {
+                continue;
+            }
+
+            if (evaluate_pair(boundary[i], boundary[j], up_x, up_y, up_z, max_step_height, max_step_distance, pair_result)) {
+                const cost = pair_result[1];
+
+                if (cost < best_cost) {
+                    best_cost = cost;
+                    best_j = j;
+                    best_pairing = pair_result[0];
+                }
+            }
+        }
+
+        if (best_j === -1) {
+            continue;
+        }
+
+        const key = i < best_j ? `${i}_${best_j}` : `${best_j}_${i}`;
+        if (bridged_pairs.has(key)) {
+            continue;
+        }
+        bridged_pairs.add(key);
+
+        bridges.push({ a: boundary[i], b: boundary[best_j], pairing: best_pairing });
+    }
+
+    if (bridges.length === 0) {
+        return 0;
+    }
+
+    // extract the current mesh as a triangle soup
+    const soup = [];
+    const face_count = mesh.faces.size;
+    const coord = [0, 0, 0];
+
+    for (let f = 0; f < face_count; f++) {
+        if (!mesh.faces.is_allocated(f)) {
+            continue;
+        }
+
+        const loop_start = mesh.face_read_loop(f);
+        let loop = loop_start;
+
+        do {
+            mesh.vertex_read_coordinate(coord, 0, mesh.loop_read_vertex(loop));
+            soup.push(coord[0], coord[1], coord[2]);
+            loop = mesh.loop_read_next(loop);
+        } while (loop !== loop_start);
+    }
+
+    // append the bridge quads (two triangles each)
+    for (let i = 0; i < bridges.length; i++) {
+        const { a, b, pairing } = bridges[i];
+
+        // corner0/corner1 are A's boundary edge; corner2/corner3 are B's, ordered so that the quad's
+        // first triangle carries A's edge and the second carries B's edge (so both fuse onto their island)
+        const b2x = pairing === 1 ? b.x2 : b.x1;
+        const b2y = pairing === 1 ? b.y2 : b.y1;
+        const b2z = pairing === 1 ? b.z2 : b.z1;
+
+        const b3x = pairing === 1 ? b.x1 : b.x2;
+        const b3y = pairing === 1 ? b.y1 : b.y2;
+        const b3z = pairing === 1 ? b.z1 : b.z2;
+
+        push_triangle_facing_up(
+            soup,
+            a.x1, a.y1, a.z1,
+            a.x2, a.y2, a.z2,
+            b2x, b2y, b2z,
+            up_x, up_y, up_z
+        );
+
+        push_triangle_facing_up(
+            soup,
+            a.x1, a.y1, a.z1,
+            b2x, b2y, b2z,
+            b3x, b3y, b3z,
+            up_x, up_y, up_z
+        );
+    }
+
+    // rebuild topology from the augmented soup; the same merge/fuse the initial build uses re-establishes
+    // connectivity, joining the bridge triangles onto the island boundaries whose vertices they share
+    const rebuilt = new BinaryTopology();
+    bt_mesh_from_unindexed_geometry(rebuilt, soup);
+    bt_merge_verts_by_distance(rebuilt, VERTEX_MERGE_DISTANCE);
+    bt_mesh_fuse_duplicate_edges(rebuilt);
+
+    mesh.copy(rebuilt);
+
+    return bridges.length;
+}

package/src/core/math/spline/spline3_hermite_intersection_spline3_hermite.d.ts

@@ -13,10 +13,10 @@
  * of candidate critical points (see the variant docs for what each reports
  * and how many entries the result buffer needs):
  *   - 1D: range overlap or extrema-based closest pair → 1 pair.
- *   - 2D: (3,3)/(3,3) Bezout interior intersections + boundary minima → up
- *     to 13 pairs (~26 floats).
- *   - ND (≥ 3): grid-Newton interior critical points + boundary minima → up
- *     to 89 pairs (~178 floats).
+ *   - ND (≥ 2): grid-Newton interior critical points + boundary minima → up
+ *     to 89 pairs (~178 floats). dim === 2 uses this path too; the former
+ *     bespoke 2D Bezout specialization was removed because it missed interior
+ *     non-intersection closest approaches.
  *
  * Required buffer size: caller must reserve enough space for the worst
  * case of the dim it intends to call with. Reserving ≥ 178 floats past

package/src/core/math/spline/spline3_hermite_intersection_spline3_hermite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_intersection_spline3_hermite.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersection_spline3_hermite.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,gEAPW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,OACrB,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,GACJ,MAAM,CAiBlB"}
+{"version":3,"file":"spline3_hermite_intersection_spline3_hermite.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersection_spline3_hermite.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,gEAPW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,OACrB,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,GACJ,MAAM,CAclB"}

package/src/core/math/spline/spline3_hermite_intersection_spline3_hermite.js

@@ -1,52 +1,48 @@
-import { assert } from "../../assert.js";
-import { spline3_hermite_intersection_spline3_hermite_1d } from "./spline3_hermite_intersection_spline3_hermite_1d.js";
-import { spline3_hermite_intersection_spline3_hermite_2d } from "./spline3_hermite_intersection_spline3_hermite_2d.js";
-import { spline3_hermite_intersection_spline3_hermite_nd } from "./spline3_hermite_intersection_spline3_hermite_nd.js";
-
-/**
- * Critical points of squared distance between two cubic Hermite curves over
- * the [0,1]² parameter square. Writes (s, t) pairs sequentially into
- * `result` starting at `result_offset` and returns the count of pairs
- * written. Caller is responsible for evaluating both curves at each pair
- * and computing distance (e.g. to pick the nearest root).
- *
- * Coefficient layout for `a` and `b`: per-dimension grouped quads,
- *   `[p0_0, p1_0, m0_0, m1_0, p0_1, p1_1, m0_1, m1_1, ..., m1_{dim-1}]`,
- * length `4 * dim`. dim ≥ 1.
- *
- * Internally dispatched by dimension; each path enumerates different sets
- * of candidate critical points (see the variant docs for what each reports
- * and how many entries the result buffer needs):
- *   - 1D: range overlap or extrema-based closest pair → 1 pair.
- *   - 2D: (3,3)/(3,3) Bezout interior intersections + boundary minima → up
- *     to 13 pairs (~26 floats).
- *   - ND (≥ 3): grid-Newton interior critical points + boundary minima → up
- *     to 89 pairs (~178 floats).
- *
- * Required buffer size: caller must reserve enough space for the worst
- * case of the dim it intends to call with. Reserving ≥ 178 floats past
- * `result_offset` covers all dims.
- *
- * @param {Float64Array|number[]} a length 4*dim
- * @param {Float64Array|number[]} b length 4*dim
- * @param {number} dim
- * @param {Float64Array|number[]} result
- * @param {number} result_offset
- * @returns {number} number of (s, t) pairs written
- */
-export function spline3_hermite_intersection_spline3_hermite(
-    a, b, dim,
-    result, result_offset
-) {
-    assert.greaterThanOrEqual(dim, 1, 'dim');
-
-    if (dim === 1) {
-        return spline3_hermite_intersection_spline3_hermite_1d(a, b, result, result_offset);
-    }
-
-    if (dim === 2) {
-        return spline3_hermite_intersection_spline3_hermite_2d(a, b, result, result_offset);
-    }
-
-    return spline3_hermite_intersection_spline3_hermite_nd(a, b, dim, result, result_offset);
-}
+import { assert } from "../../assert.js";
+import { spline3_hermite_intersection_spline3_hermite_1d } from "./spline3_hermite_intersection_spline3_hermite_1d.js";
+import { spline3_hermite_intersection_spline3_hermite_nd } from "./spline3_hermite_intersection_spline3_hermite_nd.js";
+
+/**
+ * Critical points of squared distance between two cubic Hermite curves over
+ * the [0,1]² parameter square. Writes (s, t) pairs sequentially into
+ * `result` starting at `result_offset` and returns the count of pairs
+ * written. Caller is responsible for evaluating both curves at each pair
+ * and computing distance (e.g. to pick the nearest root).
+ *
+ * Coefficient layout for `a` and `b`: per-dimension grouped quads,
+ *   `[p0_0, p1_0, m0_0, m1_0, p0_1, p1_1, m0_1, m1_1, ..., m1_{dim-1}]`,
+ * length `4 * dim`. dim ≥ 1.
+ *
+ * Internally dispatched by dimension; each path enumerates different sets
+ * of candidate critical points (see the variant docs for what each reports
+ * and how many entries the result buffer needs):
+ *   - 1D: range overlap or extrema-based closest pair → 1 pair.
+ *   - ND (≥ 2): grid-Newton interior critical points + boundary minima → up
+ *     to 89 pairs (~178 floats). dim === 2 uses this path too; the former
+ *     bespoke 2D Bezout specialization was removed because it missed interior
+ *     non-intersection closest approaches.
+ *
+ * Required buffer size: caller must reserve enough space for the worst
+ * case of the dim it intends to call with. Reserving ≥ 178 floats past
+ * `result_offset` covers all dims.
+ *
+ * @param {Float64Array|number[]} a length 4*dim
+ * @param {Float64Array|number[]} b length 4*dim
+ * @param {number} dim
+ * @param {Float64Array|number[]} result
+ * @param {number} result_offset
+ * @returns {number} number of (s, t) pairs written
+ */
+export function spline3_hermite_intersection_spline3_hermite(
+    a, b, dim,
+    result, result_offset
+) {
+    assert.greaterThanOrEqual(dim, 1, 'dim');
+
+    if (dim === 1) {
+        return spline3_hermite_intersection_spline3_hermite_1d(a, b, result, result_offset);
+    }
+
+    // dim >= 2 (including 2D) goes through the dimension-agnostic ND path.
+    return spline3_hermite_intersection_spline3_hermite_nd(a, b, dim, result, result_offset);
+}

package/src/core/math/spline/spline3_hermite_intersection_spline3_hermite_2d.d.ts

@@ -1,31 +1,33 @@
 /**
- * Critical-point enumerator for the 2D Hermite curve-pair intersection
- * problem. Writes (s, t) pairs sequentially into `result` starting at
- * `result_offset` and returns the count.
+ * @deprecated The dedicated 2D Bezout specialization has been removed. It
+ * enumerated interior *intersections* (via the (3,3)/(3,3) Bezout resultant)
+ * plus the four boundary-edge minima only — it never enumerated interior
+ * *non-intersection* critical points, so it silently missed the closest
+ * approach of two non-intersecting cubic arcs whenever that approach is
+ * interior-to-interior (wrong on ~27% of random curve pairs, by as much as
+ * several units of squared distance). Its premise — "no interior intersection
+ * ⇒ the global minimum lies on the boundary" — is false for cubic arcs.
  *
- * What is reported:
- *   - All interior true intersections found by the Bezout resultant (up to 9).
- *   - Four boundary closest-approach pairs, one per edge of [0,1]²:
- *       (0, t*) with t* minimising ‖A(0) − B(t)‖²
- *       (1, t*) with t* minimising ‖A(1) − B(t)‖²
- *       (s*, 0) with s* minimising ‖A(s) − B(0)‖²
- *       (s*, 1) with s* minimising ‖A(s) − B(1)‖²
- *     Each `nearest_t_on_curve` call internally tests endpoints, so corners
- *     are folded into these as appropriate.
+ * This symbol is retained only so existing callers keep working; it now
+ * forwards to the dimension-agnostic
+ * {@link spline3_hermite_intersection_spline3_hermite_nd} path, which
+ * enumerates interior critical points (grid-seeded 2D Newton) in addition to
+ * the boundary minima and is correct for the full closest-approach problem.
  *
- * Caller is responsible for evaluating both curves at each (s, t) and picking
- * whichever pair(s) they care about (closest, within threshold, etc.).
+ * Prefer the dimension dispatcher
+ * {@link spline3_hermite_intersection_spline3_hermite} or
+ * `spline3_hermite_intersection_spline3_hermite_nd` directly. Note the buffer
+ * requirement is now the ND worst case: `result.length >= result_offset +
+ * 2 * ND_MAX_ROOTS` floats (currently 178), not the old 2D bound.
  *
- * Typical buffer size: at most 9 interior + 4 boundary = 13 pairs →
- * `result.length >= result_offset + 26`. in degenerate cases up to 89 pairs.
- *
- * Edge case: if the Bezout resultant is numerically degenerate (one of the
- * input curves is constant on an axis, etc.), the routine forwards to the
- * dimension-agnostic ND path.
+ * Critical-point enumerator for the 2D Hermite curve-pair problem. Writes
+ * (s, t) pairs sequentially into `result` starting at `result_offset` and
+ * returns the count of pairs written. The caller evaluates both curves at each
+ * pair and picks the one(s) it cares about (closest, within threshold, etc.).
  *
  * @param {Float64Array|number[]} a length 8: [a_p0_x, a_p1_x, a_m0_x, a_m1_x, a_p0_y, a_p1_y, a_m0_y, a_m1_y]
  * @param {Float64Array|number[]} b length 8 (same layout)
- * @param {Float64Array|number[]} result length >= result_offset + 198
+ * @param {Float64Array|number[]} result length >= result_offset + 2 * ND_MAX_ROOTS
  * @param {number} result_offset
  * @returns {number} number of (s, t) pairs written
  */

package/src/core/math/spline/spline3_hermite_intersection_spline3_hermite_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_intersection_spline3_hermite_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersection_spline3_hermite_2d.js"],"names":[],"mappings":"AA+SA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,mEANW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,UACrB,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,GACJ,MAAM,CAyElB"}
+{"version":3,"file":"spline3_hermite_intersection_spline3_hermite_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersection_spline3_hermite_2d.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,mEANW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,UACrB,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,GACJ,MAAM,CAOlB"}