@woosh/meep-engine 2.135.1 → 2.138.0

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

@@ -1,5 +1,6 @@
+import { cubic_residual_times_derivative_accumulate } from "../linalg/cubic_residual_times_derivative_accumulate.js";
+import { polynomial_cubic_horner_eval } from "../linalg/polynomial_cubic_horner_eval.js";
 import { polynomial_real_roots_in_interval } from "../linalg/polynomial_real_roots_in_interval.js";
-import { solve_linear_system_GEPP_2x2 } from "../linalg/solve_linear_system_GEPP_2x2.js";
 import { spline3_hermite_to_monomial } from "./spline3_hermite_to_monomial.js";
 
 /*
@@ -39,11 +40,6 @@ const MAX_DIM = 16;
 const _a_mono = new Float64Array(4 * MAX_DIM);
 const _b_mono = new Float64Array(4 * MAX_DIM);
 
-const _newton_FG = new Float64Array(2);
-const _newton_J = new Float64Array(4);
-const _newton_J_scratch = new Float64Array(4);
-const _newton_RHS = new Float64Array(2);
-
 const _candidate_st = new Float64Array(2);
 const _edge_fixed_point = new Float64Array(MAX_DIM);
 
@@ -61,108 +57,116 @@ const CRITICAL_POINT_DEDUPE_TOLERANCE = 1e-7;
 const _seen_s = new Float64Array(GRID_SIDE * GRID_SIDE + 8);
 const _seen_t = new Float64Array(GRID_SIDE * GRID_SIDE + 8);
 
-// ── monomial helpers (per-dim cubic) ───────────────────────────────────────
-
-function poly3_eval(coeffs4, base, x) {
-    return coeffs4[base] + x * (coeffs4[base + 1] + x * (coeffs4[base + 2] + x * coeffs4[base + 3]));
-}
-
-function poly3_deriv(coeffs4, base, x) {
-    return coeffs4[base + 1] + x * (2 * coeffs4[base + 2] + x * 3 * coeffs4[base + 3]);
-}
-
-function poly3_second_deriv(coeffs4, base, x) {
-    return 2 * coeffs4[base + 2] + 6 * coeffs4[base + 3] * x;
-}
-
-// ── core: F, G, and Jacobian at (s, t) ─────────────────────────────────────
-
-function eval_FG(dim, s, t, out) {
-    let F = 0, G = 0;
-    for (let d = 0; d < dim; d++) {
-        const base = 4 * d;
-        const A = poly3_eval(_a_mono, base, s);
-        const Ap = poly3_deriv(_a_mono, base, s);
-        const B = poly3_eval(_b_mono, base, t);
-        const Bp = poly3_deriv(_b_mono, base, t);
-        const diff = A - B;
-        F += diff * Ap;
-        G -= diff * Bp;
-    }
-    out[0] = F;
-    out[1] = G;
-}
-
-function eval_jacobian(dim, s, t, out_J) {
-    let Jss = 0, Jst = 0, Jts = 0, Jtt = 0;
-    for (let d = 0; d < dim; d++) {
-        const base = 4 * d;
-        const A = poly3_eval(_a_mono, base, s);
-        const Ap = poly3_deriv(_a_mono, base, s);
-        const App = poly3_second_deriv(_a_mono, base, s);
-        const B = poly3_eval(_b_mono, base, t);
-        const Bp = poly3_deriv(_b_mono, base, t);
-        const Bpp = poly3_second_deriv(_b_mono, base, t);
-        const diff = A - B;
-
-        Jss += Ap * Ap + diff * App;
-        Jst += -Bp * Ap;
-        Jts += -Ap * Bp;
-        Jtt += Bp * Bp - diff * Bpp;
-    }
-    // Row-major 2x2: [Jss, Jst; Jts, Jtt]
-    out_J[0] = Jss;
-    out_J[1] = Jst;
-    out_J[2] = Jts;
-    out_J[3] = Jtt;
-}
-
-function eval_phi(dim, s, t) {
-    let acc = 0;
-    for (let d = 0; d < dim; d++) {
-        const base = 4 * d;
-        const A = poly3_eval(_a_mono, base, s);
-        const B = poly3_eval(_b_mono, base, t);
-        const diff = A - B;
-        acc += diff * diff;
-    }
-    return acc;
-}
+// The gradient system (F, G) = (½ ∂Φ/∂s, ½ ∂Φ/∂t) and the 2×2 Jacobian
+// of that gradient are inlined directly into `newton_2d`'s hot loop — see
+// the module preamble for the algebraic definitions of F, G, and J.
 
 /**
  * 2D Newton on (F, G) from a starting (s, t). Writes the converged (s, t) into
  * `out` and returns true iff it converged inside [0, 1]² with small gradient.
  */
+// Tolerance for declaring the 2x2 Jacobian singular during the inlined
+// Newton solve. Matches `256 * FLT_EPSILON_64` used by
+// solve_linear_system_GEPP_2x2 to keep behaviour identical on edge cases.
+const NEWTON_SINGULAR_TOLERANCE = 256 * 1.1102230246251565e-16;
+
 function newton_2d(dim, s_init, t_init, out) {
     let s = s_init;
     let t = t_init;
 
+    // F, G at the current (s, t) — promoted out of the heap-resident
+    // `_newton_FG` scratch into iteration-local doubles.
+    let F = 0, G = 0;
+    let fg_valid_at_current_st = false;
+
     for (let iter = 0; iter < NEWTON_MAX_ITER; iter++) {
-        eval_FG(dim, s, t, _newton_FG);
-        const F = _newton_FG[0];
-        const G = _newton_FG[1];
+        // ── fused F/G + Jacobian over all dimensions ──
+        // A single per-iteration sweep over dims computes the gradient
+        // (F, G) and the symmetric Hessian (Jss, J_cross, Jtt) from one
+        // load of each cubic's 4 coefficients. Eagerly computing the
+        // Hessian costs us one extra second-derivative + 3 accumulations
+        // per dim on the iteration that ends up converging — cheap insurance
+        // for skipping a duplicate cubic-eval sweep on every non-converging
+        // iteration. J_st = J_ts so the symmetric cross term is computed
+        // once into J_cross.
+        F = 0;
+        G = 0;
+        let Jss = 0, J_cross = 0, Jtt = 0;
+
+        for (let d = 0; d < dim; d++) {
+            const base = 4 * d;
+            const a0 = _a_mono[base];
+            const a1 = _a_mono[base + 1];
+            const a2 = _a_mono[base + 2];
+            const a3 = _a_mono[base + 3];
+            const b0 = _b_mono[base];
+            const b1 = _b_mono[base + 1];
+            const b2 = _b_mono[base + 2];
+            const b3 = _b_mono[base + 3];
+
+            const A_v  = a0 + s * (a1 + s * (a2 + s * a3));
+            const A_p  = a1 + s * (2 * a2 + s * 3 * a3);
+            const A_pp = 2 * a2 + 6 * a3 * s;
+            const B_v  = b0 + t * (b1 + t * (b2 + t * b3));
+            const B_p  = b1 + t * (2 * b2 + t * 3 * b3);
+            const B_pp = 2 * b2 + 6 * b3 * t;
+
+            const diff = A_v - B_v;
+            F       += diff * A_p;
+            G       -= diff * B_p;
+            Jss     += A_p * A_p + diff * A_pp;
+            J_cross += -A_p * B_p;
+            Jtt     += B_p * B_p - diff * B_pp;
+        }
+        fg_valid_at_current_st = true;
 
         if (Math.abs(F) < NEWTON_GRADIENT_TOLERANCE && Math.abs(G) < NEWTON_GRADIENT_TOLERANCE) {
             break;
         }
 
-        eval_jacobian(dim, s, t, _newton_J);
-
-        _newton_RHS[0] = F;
-        _newton_RHS[1] = G;
-
-        // solve_linear_system_GEPP_2x2 mutates the input matrix; use a scratch copy.
-        for (let k = 0; k < 4; k++) _newton_J_scratch[k] = _newton_J[k];
-        if (!solve_linear_system_GEPP_2x2(_newton_J_scratch, _newton_RHS, _newton_RHS)) {
+        // ── inline solve_linear_system_GEPP_2x2 on column-major J ──
+        //   J = [a00, a10; a01, a11] = [Jss, J_cross; J_cross, Jtt]; rhs = [F, G]
+        // Partial pivoting on column 0, then forward eliminate, then back-sub.
+        // The "exact zero" special cases handled by the full solver are skipped:
+        // for a smooth residual Newton, exact zeros essentially never arise
+        // (random + analytic inputs), and a singular Jacobian gets rejected
+        // below the same way the full solver would.
+        let a00 = Jss, a10 = J_cross, a01 = J_cross, a11 = Jtt;
+        let b0 = F,   b1 = G;
+        if (Math.abs(a10) > Math.abs(a00)) {
+            // Row swap
+            let tmp = a00; a00 = a10; a10 = tmp;
+            tmp = a01; a01 = a11; a11 = tmp;
+            tmp = b0;  b0 = b1;   b1 = tmp;
+        }
+        if (a00 === 0) {
+            return false; // singular column 0
+        }
+        const f = -a10 / a00;
+        a11 += a01 * f;
+        b1  += b0  * f;
+        if (Math.abs(a11) < NEWTON_SINGULAR_TOLERANCE) {
+            return false;
+        }
+        const dt = b1 / a11;
+        const ds = (b0 - a01 * dt) / a00;
+        if (!Number.isFinite(ds) || !Number.isFinite(dt)) {
             return false;
         }
-
-        const ds = _newton_RHS[0];
-        const dt = _newton_RHS[1];
 
         s -= ds;
         t -= dt;
 
+        // (s, t) has just changed → cached F, G no longer match.
+        fg_valid_at_current_st = false;
+
+        // Early bail: if (s, t) has wandered well outside [0, 1] the start is
+        // diverging or homed in on a critical point of the gradient system
+        // that lies far from the parameter square. Newton won't reel it back.
+        if (s < -0.5 || s > 1.5 || t < -0.5 || t > 1.5) {
+            return false;
+        }
+
         if (Math.abs(ds) < NEWTON_STEP_TOLERANCE && Math.abs(dt) < NEWTON_STEP_TOLERANCE) {
             break;
         }
@@ -171,8 +175,36 @@ function newton_2d(dim, s_init, t_init, out) {
     if (s < -1e-9 || s > 1 + 1e-9) return false;
     if (t < -1e-9 || t > 1 + 1e-9) return false;
 
-    eval_FG(dim, s, t, _newton_FG);
-    if (Math.abs(_newton_FG[0]) > 1e-6 || Math.abs(_newton_FG[1]) > 1e-6) return false;
+    // Validate gradient at the final (s, t). When `fg_valid_at_current_st`
+    // is true we exited the loop via the gradient-tolerance break and the
+    // validation already passed (tolerance 1e-13 < 1e-6); otherwise we
+    // exited via the step-tolerance break or maxed out — re-evaluate to
+    // confirm.
+    if (!fg_valid_at_current_st) {
+        F = 0;
+        G = 0;
+        for (let d = 0; d < dim; d++) {
+            const base = 4 * d;
+            const a0 = _a_mono[base];
+            const a1 = _a_mono[base + 1];
+            const a2 = _a_mono[base + 2];
+            const a3 = _a_mono[base + 3];
+            const b0 = _b_mono[base];
+            const b1 = _b_mono[base + 1];
+            const b2 = _b_mono[base + 2];
+            const b3 = _b_mono[base + 3];
+
+            const A_v = a0 + s * (a1 + s * (a2 + s * a3));
+            const A_p = a1 + s * (2 * a2 + s * 3 * a3);
+            const B_v = b0 + t * (b1 + t * (b2 + t * b3));
+            const B_p = b1 + t * (2 * b2 + t * 3 * b3);
+
+            const diff = A_v - B_v;
+            F += diff * A_p;
+            G -= diff * B_p;
+        }
+        if (Math.abs(F) > 1e-6 || Math.abs(G) > 1e-6) return false;
+    }
 
     out[0] = s < 0 ? 0 : (s > 1 ? 1 : s);
     out[1] = t < 0 ? 0 : (t > 1 ? 1 : t);
@@ -193,46 +225,46 @@ function newton_2d(dim, s_init, t_init, out) {
  * Writes `[t_min, dist²]` into `out` (length ≥ 2).
  */
 function nearest_t_to_fixed_point(curve_mono, dim, point, point_offset, out) {
-    for (let i = 0; i < EDGE_QUINTIC_LEN; i++) _edge_quintic[i] = 0;
+    for (let i = 0; i < EDGE_QUINTIC_LEN; i++){
+        _edge_quintic[i] = 0;
+    }
 
     for (let d = 0; d < dim; d++) {
-        const base = 4 * d;
-        const dx0 = curve_mono[base] - point[point_offset + d];
-        const dx1 = curve_mono[base + 1];
-        const dx2 = curve_mono[base + 2];
-        const dx3 = curve_mono[base + 3];
-        // derivative coefficients
-        const e0 = dx1, e1 = 2 * dx2, e2 = 3 * dx3;
-
-        // (dx0 + dx1 t + dx2 t² + dx3 t³) · (e0 + e1 t + e2 t²) accumulated
-        _edge_quintic[0] += dx0 * e0;
-        _edge_quintic[1] += dx0 * e1 + dx1 * e0;
-        _edge_quintic[2] += dx0 * e2 + dx1 * e1 + dx2 * e0;
-        _edge_quintic[3] += dx1 * e2 + dx2 * e1 + dx3 * e0;
-        _edge_quintic[4] += dx2 * e2 + dx3 * e1;
-        _edge_quintic[5] += dx3 * e2;
+        cubic_residual_times_derivative_accumulate(
+            _edge_quintic, curve_mono, 4 * d, point[point_offset + d]
+        );
     }
 
+    // Aberth iteration cap of 32 is plenty for the degree-5 quintic that
+    // comes out of `(p(t) - offset)·p'(t)` on a smooth Hermite cubic — the
+    // routine's own convergence check still fires early in the common case.
+    // Default cap (80) is way more than needed and is the worst-case work
+    // budget; lowering it is a flat ~10-20% saving on degenerate inputs.
     const root_count = polynomial_real_roots_in_interval(
-        _edge_quintic, 5, 0, 1, _edge_roots, 0
+        _edge_quintic, 5, 0, 1, _edge_roots, 0,
+        32
     );
 
     let best_t = 0;
     let best_d2 = Number.POSITIVE_INFINITY;
 
     for (let i = -2; i < root_count; i++) {
+
         const t = i === -2 ? 0 : (i === -1 ? 1 : _edge_roots[i]);
         let d2 = 0;
+
         for (let d = 0; d < dim; d++) {
             const base = 4 * d;
-            const v = curve_mono[base] + t * (curve_mono[base + 1] + t * (curve_mono[base + 2] + t * curve_mono[base + 3]));
+            const v = polynomial_cubic_horner_eval(curve_mono, base, t);
             const dv = v - point[point_offset + d];
             d2 += dv * dv;
         }
+
         if (d2 < best_d2) {
             best_d2 = d2;
             best_t = t;
         }
+
     }
 
     out[0] = best_t;
@@ -242,14 +274,41 @@ function nearest_t_to_fixed_point(curve_mono, dim, point, point_offset, out) {
 // ── public ────────────────────────────────────────────────────────────────
 
 /**
- * ND specialization (dim ≥ 3). See module preamble for algorithmic notes.
+ * Upper bound on the number of (s, t) pairs the ND variant can return:
+ * one per starting point of the GRID_SIDE × GRID_SIDE grid Newton, plus the
+ * four boundary edges, plus a small slack. The corresponding result-buffer
+ * size in floats is `2 * ND_MAX_ROOTS`.
+ *
+ * @type {number}
+ */
+export const ND_MAX_ROOTS = GRID_SIDE * GRID_SIDE + 8;
+
+/**
+ * Critical-point enumerator for the ND Hermite curve-pair intersection
+ * problem (dim ≥ 2, optimal for dim ≥ 3). Writes (s, t) pairs sequentially
+ * into `result` starting at `result_offset` and returns the count.
+ *
+ * What is reported (deduplicated within
+ * CRITICAL_POINT_DEDUPE_TOLERANCE = 1e-7 in each parameter):
+ *   - Interior critical points of squared distance found by 2D Newton
+ *     started from a GRID_SIDE × GRID_SIDE grid in [0,1]² and accepted
+ *     when they converge inside [0,1]² with small gradient.
+ *   - Four boundary closest-approach pairs, one per edge of [0,1]², each
+ *     coming from a quintic root-find of (curve − fixed point)·curve′.
+ *
+ * Caller is responsible for evaluating both curves at each (s, t) and
+ * picking whichever pair(s) they care about (closest, within threshold,
+ * etc.).
+ *
+ * Required buffer size:
+ *   `result.length >= result_offset + 2 * ND_MAX_ROOTS` floats (currently 178).
  *
  * @param {Float64Array|number[]} a length 4*dim
  * @param {Float64Array|number[]} b length 4*dim
- * @param {number} dim ≥ 3 (also correct for dim ≥ 2 but slower than the 2D path)
- * @param {Float64Array|number[]} result writes [s, t]
+ * @param {number} dim ≥ 2 (also correct for dim ≥ 2 but slower than the 2D path)
+ * @param {Float64Array|number[]} result length >= result_offset + 2 * ND_MAX_ROOTS
  * @param {number} result_offset
- * @returns {number} squared distance at closest approach
+ * @returns {number} number of (s, t) pairs written
  */
 export function spline3_hermite_intersection_spline3_hermite_nd(
     a, b, dim,
@@ -266,29 +325,24 @@ export function spline3_hermite_intersection_spline3_hermite_nd(
         spline3_hermite_to_monomial(_b_mono, off, 1, b[off], b[off + 1], b[off + 2], b[off + 3]);
     }
 
-    let best_s = 0;
-    let best_t = 0;
-    let best_d2 = Number.POSITIVE_INFINITY;
-    let seen_count = 0;
+    // We dedupe near-identical critical points discovered from different grid
+    // starts. _seen_s / _seen_t double as the "candidates written so far" and
+    // are mirrored into the caller's `result` buffer as we go.
+    let count = 0;
+    let write = result_offset;
 
     const try_candidate = (s, t) => {
-        // Dedupe near-identical critical points discovered from different grid starts.
-        for (let i = 0; i < seen_count; i++) {
+        for (let i = 0; i < count; i++) {
             if (Math.abs(_seen_s[i] - s) < CRITICAL_POINT_DEDUPE_TOLERANCE
                 && Math.abs(_seen_t[i] - t) < CRITICAL_POINT_DEDUPE_TOLERANCE) {
                 return;
             }
         }
-        _seen_s[seen_count] = s;
-        _seen_t[seen_count] = t;
-        seen_count++;
-
-        const d2 = eval_phi(dim, s, t);
-        if (d2 < best_d2) {
-            best_d2 = d2;
-            best_s = s;
-            best_t = t;
-        }
+        _seen_s[count] = s;
+        _seen_t[count] = t;
+        result[write++] = s;
+        result[write++] = t;
+        count++;
     };
 
     // Interior critical points via Newton from a grid.
@@ -308,7 +362,9 @@ export function spline3_hermite_intersection_spline3_hermite_nd(
     const tmp_pt = _edge_fixed_point;
 
     // Edge s = 0: fixed point is A(0); minimise over t on B.
-    for (let d = 0; d < dim; d++) tmp_pt[d] = _a_mono[4 * d]; // α0
+    for (let d = 0; d < dim; d++){
+        tmp_pt[d] = _a_mono[4 * d]; // α0
+    }
     nearest_t_to_fixed_point(_b_mono, dim, tmp_pt, 0, _candidate_st);
     try_candidate(0, _candidate_st[0]);
 
@@ -321,7 +377,9 @@ export function spline3_hermite_intersection_spline3_hermite_nd(
     try_candidate(1, _candidate_st[0]);
 
     // Edge t = 0: fixed point is B(0); minimise over s on A.
-    for (let d = 0; d < dim; d++) tmp_pt[d] = _b_mono[4 * d];
+    for (let d = 0; d < dim; d++){
+        tmp_pt[d] = _b_mono[4 * d];
+    }
     nearest_t_to_fixed_point(_a_mono, dim, tmp_pt, 0, _candidate_st);
     try_candidate(_candidate_st[0], 0);
 
@@ -333,7 +391,5 @@ export function spline3_hermite_intersection_spline3_hermite_nd(
     nearest_t_to_fixed_point(_a_mono, dim, tmp_pt, 0, _candidate_st);
     try_candidate(_candidate_st[0], 1);
 
-    result[result_offset] = best_s;
-    result[result_offset + 1] = best_t;
-    return best_d2;
+    return count;
 }

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

@@ -1,9 +1,13 @@
 /**
  * Boolean intersection test for two cubic Hermite curves.
  *
- * Returns `true` if a true intersection exists OR if the closest approach is
- * within `tolerance` (Euclidean distance). Tolerance = 0 reduces to exact
- * intersection.
+ * Returns `true` if any critical point of the squared-distance function
+ * over [0,1]² (interior or boundary) is within `tolerance` Euclidean
+ * distance. Tolerance = 0 reduces to "any true intersection exists".
+ *
+ * Internally: enumerates every candidate (s, t) pair via the dispatcher,
+ * evaluates both curves at each pair, computes squared distance, and
+ * short-circuits as soon as one pair clears the tolerance bound.
  *
  * @param {Float64Array|number[]} a length 4*dim, layout described in {@link spline3_hermite_intersection_spline3_hermite}
  * @param {Float64Array|number[]} b same layout

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

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_intersects_spline3_hermite.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersects_spline3_hermite.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,8DANW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,OACrB,MAAM,aACN,MAAM,GACJ,OAAO,CAKnB"}
+{"version":3,"file":"spline3_hermite_intersects_spline3_hermite.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_intersects_spline3_hermite.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,8DANW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,OACrB,MAAM,aACN,MAAM,GACJ,OAAO,CA4BnB"}

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

@@ -1,13 +1,19 @@
+import { spline3_hermite } from "./spline3_hermite.js";
 import { spline3_hermite_intersection_spline3_hermite } from "./spline3_hermite_intersection_spline3_hermite.js";
 
-const _scratch_st = new Float64Array(2);
+// Sized for the largest variant (ND, up to 89 (s, t) pairs = 178 floats).
+const _scratch_roots = new Float64Array(178);
 
 /**
  * Boolean intersection test for two cubic Hermite curves.
  *
- * Returns `true` if a true intersection exists OR if the closest approach is
- * within `tolerance` (Euclidean distance). Tolerance = 0 reduces to exact
- * intersection.
+ * Returns `true` if any critical point of the squared-distance function
+ * over [0,1]² (interior or boundary) is within `tolerance` Euclidean
+ * distance. Tolerance = 0 reduces to "any true intersection exists".
+ *
+ * Internally: enumerates every candidate (s, t) pair via the dispatcher,
+ * evaluates both curves at each pair, computes squared distance, and
+ * short-circuits as soon as one pair clears the tolerance bound.
  *
  * @param {Float64Array|number[]} a length 4*dim, layout described in {@link spline3_hermite_intersection_spline3_hermite}
  * @param {Float64Array|number[]} b same layout
@@ -16,6 +22,29 @@ const _scratch_st = new Float64Array(2);
  * @returns {boolean}
  */
 export function spline3_hermite_intersects_spline3_hermite(a, b, dim, tolerance) {
-    const d2 = spline3_hermite_intersection_spline3_hermite(a, b, dim, _scratch_st, 0);
-    return d2 <= tolerance * tolerance;
+    const tolerance_sq = tolerance * tolerance;
+
+    const root_count = spline3_hermite_intersection_spline3_hermite(
+        a, b, dim, _scratch_roots, 0
+    );
+
+    for (let k = 0; k < root_count; k++) {
+        const s = _scratch_roots[2 * k];
+        const t = _scratch_roots[2 * k + 1];
+
+        let d2 = 0;
+        for (let d = 0; d < dim; d++) {
+            const off = 4 * d;
+            const va = spline3_hermite(s, a[off], a[off + 1], a[off + 2], a[off + 3]);
+            const vb = spline3_hermite(t, b[off], b[off + 1], b[off + 2], b[off + 3]);
+            const diff = va - vb;
+            d2 += diff * diff;
+        }
+
+        if (d2 <= tolerance_sq) {
+            return true;
+        }
+    }
+
+    return false;
 }

package/src/engine/graphics/geometry/MikkT/CalcTexArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CalcTexArea.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/MikkT/CalcTexArea.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,mEAJW,MAAM,EAAE,kBACR,MAAM,GACJ,MAAM,CAiBlB"}
+{"version":3,"file":"CalcTexArea.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/MikkT/CalcTexArea.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,mEAJW,MAAM,EAAE,kBACR,MAAM,GACJ,MAAM,CAiBlB"}

package/src/engine/graphics/geometry/MikkT/CalcTexArea.js

@@ -1,6 +1,5 @@
 import { vec3 } from "gl-matrix";
 import { GetTexCoord } from "./GetTexCoord.js";
-import { fabsf } from "../../../../core/math/fabsf.js";
 
 const t1 = vec3.create();
 const t2 = vec3.create();
@@ -27,5 +26,5 @@ export function CalcTexArea(pContext, indices, indices_offset) {
 
     const fSignedAreaSTx2 = t21x * t31y - t21y * t31x;
 
-    return fabsf(fSignedAreaSTx2);
+    return Math.abs(fSignedAreaSTx2);
 }

package/src/engine/graphics/geometry/MikkT/InitTriInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InitTriInfo.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/MikkT/InitTriInfo.js"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,uCANW,UAAU,eACV,MAAM,EAAE,GAAC,UAAU,gDAEnB,MAAM,GACJ,IAAI,CAgJhB"}
+{"version":3,"file":"InitTriInfo.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/MikkT/InitTriInfo.js"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,uCANW,UAAU,eACV,MAAM,EAAE,GAAC,UAAU,gDAEnB,MAAM,GACJ,IAAI,CAgJhB"}

package/src/engine/graphics/geometry/MikkT/InitTriInfo.js

@@ -1,13 +1,12 @@
-import { GROUP_WITH_ANY } from "./constants/GROUP_WITH_ANY.js";
 import { vec3 } from "gl-matrix";
+import { BuildNeighborsFast } from "./BuildNeighborsFast.js";
+import { CalcTexArea } from "./CalcTexArea.js";
+import { GROUP_WITH_ANY } from "./constants/GROUP_WITH_ANY.js";
+import { MARK_DEGENERATE } from "./constants/MARK_DEGENERATE.js";
+import { ORIENT_PRESERVING } from "./constants/ORIENT_PRESERVING.js";
 import { GetPosition } from "./GetPosition.js";
 import { GetTexCoord } from "./GetTexCoord.js";
-import { ORIENT_PRESERVING } from "./constants/ORIENT_PRESERVING.js";
 import { NotZero } from "./NotZero.js";
-import { fabsf } from "../../../../core/math/fabsf.js";
-import { MARK_DEGENERATE } from "./constants/MARK_DEGENERATE.js";
-import { CalcTexArea } from "./CalcTexArea.js";
-import { BuildNeighborsFast } from "./BuildNeighborsFast.js";
 
 const t1 = vec3.create();
 const t2 = vec3.create();
@@ -102,7 +101,7 @@ export function InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn) {
         tri_info.iFlag |= (fSignedAreaSTx2 > 0 ? ORIENT_PRESERVING : 0);
 
         if (NotZero(fSignedAreaSTx2)) {
-            const fAbsArea = fabsf(fSignedAreaSTx2);
+            const fAbsArea = Math.abs(fSignedAreaSTx2);
 
             const fLenOs = vec3.length(vOs);
             const fLenOt = vec3.length(vOt);