@woosh/meep-engine 2.169.0 → 2.169.2

package/src/core/geom/3d/mat4/m4_compose.js

@@ -1,53 +1,22 @@
-/**
- *
- * @param {number[]|Float32Array|mat4} result
- * @param { { x:number, y:number, z:number } } position
- * @param { { x:number, y:number, z:number, w:number } } rotation
- * @param { { x:number, y:number, z:number } } scale
- */
-export function m4_compose(result, position, rotation, scale) {
-    const x = rotation.x;
-    const y = rotation.y;
-    const z = rotation.z;
-    const w = rotation.w;
-
-    const x2 = x + x;
-    const y2 = y + y;
-    const z2 = z + z;
-
-    const xx = x * x2;
-    const xy = x * y2;
-    const xz = x * z2;
-
-    const yy = y * y2;
-    const yz = y * z2;
-    const zz = z * z2;
-
-    const wx = w * x2;
-    const wy = w * y2;
-    const wz = w * z2;
-
-    const sx = scale.x;
-    const sy = scale.y;
-    const sz = scale.z;
-
-    result[0] = (1 - (yy + zz)) * sx;
-    result[1] = (xy + wz) * sx;
-    result[2] = (xz - wy) * sx;
-    result[3] = 0;
-
-    result[4] = (xy - wz) * sy;
-    result[5] = (1 - (xx + zz)) * sy;
-    result[6] = (yz + wx) * sy;
-    result[7] = 0;
-
-    result[8] = (xz + wy) * sz;
-    result[9] = (yz - wx) * sz;
-    result[10] = (1 - (xx + yy)) * sz;
-    result[11] = 0;
-
-    result[12] = position.x;
-    result[13] = position.y;
-    result[14] = position.z;
-    result[15] = 1;
-}
+import { m4_from_rotation_translation_scale_scalar } from "./m4_from_rotation_translation_scale_scalar.js";
+
+/**
+ * Compose a 4x4 transform matrix from a position, a rotation quaternion and a (non-uniform) scale.
+ * `result = T * R * S`.
+ *
+ * Object-argument face of {@link m4_from_rotation_translation_scale_scalar}; see
+ * {@link m4_from_rotation_translation_scale} for the flat-array flavour.
+ *
+ * @param {number[]|Float32Array|mat4} result
+ * @param { { x:number, y:number, z:number } } position
+ * @param { { x:number, y:number, z:number, w:number } } rotation
+ * @param { { x:number, y:number, z:number } } scale
+ */
+export function m4_compose(result, position, rotation, scale) {
+    m4_from_rotation_translation_scale_scalar(
+        result,
+        rotation.x, rotation.y, rotation.z, rotation.w,
+        position.x, position.y, position.z,
+        scale.x, scale.y, scale.z
+    );
+}

package/src/core/geom/3d/mat4/m4_decompose.d.ts

@@ -1,4 +1,12 @@
 /**
+ * Decompose a 4x4 transform into position, rotation and scale.
+ *
+ * The three column magnitudes are computed the same way {@link m4_extract_scale} computes them, but this
+ * is deliberately NOT delegated: `m4_extract_scale` reports the raw column lengths, whereas this folds a
+ * reflection (negative upper-left determinant) into one scale axis so the extracted rotation is proper.
+ * The two therefore return different scale values for a mirrored matrix and are not interchangeable —
+ * only the three `v3_length` calls coincide, and this function needs the raw `m11..m33` components again
+ * for the determinant and the rotation extraction.
  *
  * @param {number[]} mat4
  * @param {Vector3|{set(x:number,y:number,z:number)}} position

package/src/core/geom/3d/mat4/m4_decompose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_decompose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,mCALW,MAAM,EAAE,yDAuElB"}
+{"version":3,"file":"m4_decompose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,mCALW,MAAM,EAAE,yDAuElB"}

package/src/core/geom/3d/mat4/m4_decompose.js

@@ -1,76 +1,84 @@
-import { v3_length } from "../../vec3/v3_length.js";
-
-/**
- *
- * @param {number[]} mat4
- * @param {Vector3|{set(x:number,y:number,z:number)}} position
- * @param {Quaternion} rotation
- * @param {Vector3|{set(x:number,y:number,z:number)}} scale
- */
-export function m4_decompose(mat4, position, rotation, scale) {
-    const m11 = mat4[0];
-    const m12 = mat4[1];
-    const m13 = mat4[2];
-
-    const scale_x = v3_length(m11, m12, m13);
-
-    const m21 = mat4[4];
-    const m22 = mat4[5];
-    const m23 = mat4[6];
-
-    const scale_y = v3_length(m21, m22, m23);
-
-    const m31 = mat4[8];
-    const m32 = mat4[9];
-    const m33 = mat4[10];
-
-    const scale_z = v3_length(m31, m32, m33);
-
-    // If the upper-left 3x3 has a negative determinant the matrix encodes a reflection; fold that sign into
-    // one scale axis (matching three.js, which negates scale.x) so the extracted rotation is a proper rotation
-    // rather than a mirror (which __setFromRotationMatrix would decode incorrectly).
-    const det =
-        m11 * (m22 * m33 - m23 * m32)
-        - m12 * (m21 * m33 - m23 * m31)
-        + m13 * (m21 * m32 - m22 * m31);
-
-    const signed_scale_x = det < 0 ? -scale_x : scale_x;
-
-    // extract rotation matrix
-    // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
-    const is1 = signed_scale_x !== 0 ? 1 / signed_scale_x : 1e7;
-    const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
-    const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
-
-    const sm11 = m11 * is1;
-    const sm12 = m12 * is1;
-    const sm13 = m13 * is1;
-
-    const sm21 = m21 * is2;
-    const sm22 = m22 * is2;
-    const sm23 = m23 * is2;
-
-    const sm31 = m31 * is3;
-    const sm32 = m32 * is3;
-    const sm33 = m33 * is3;
-
-    // write out results
-
-    position.set(
-        mat4[12],
-        mat4[13],
-        mat4[14]
-    );
-
-    scale.set(
-        signed_scale_x,
-        scale_y,
-        scale_z
-    );
-
-    rotation.__setFromRotationMatrix(
-        sm11, sm21, sm31,
-        sm12, sm22, sm32,
-        sm13, sm23, sm33
-    );
-}
+import { v3_length } from "../../vec3/v3_length.js";
+
+/**
+ * Decompose a 4x4 transform into position, rotation and scale.
+ *
+ * The three column magnitudes are computed the same way {@link m4_extract_scale} computes them, but this
+ * is deliberately NOT delegated: `m4_extract_scale` reports the raw column lengths, whereas this folds a
+ * reflection (negative upper-left determinant) into one scale axis so the extracted rotation is proper.
+ * The two therefore return different scale values for a mirrored matrix and are not interchangeable —
+ * only the three `v3_length` calls coincide, and this function needs the raw `m11..m33` components again
+ * for the determinant and the rotation extraction.
+ *
+ * @param {number[]} mat4
+ * @param {Vector3|{set(x:number,y:number,z:number)}} position
+ * @param {Quaternion} rotation
+ * @param {Vector3|{set(x:number,y:number,z:number)}} scale
+ */
+export function m4_decompose(mat4, position, rotation, scale) {
+    const m11 = mat4[0];
+    const m12 = mat4[1];
+    const m13 = mat4[2];
+
+    const scale_x = v3_length(m11, m12, m13);
+
+    const m21 = mat4[4];
+    const m22 = mat4[5];
+    const m23 = mat4[6];
+
+    const scale_y = v3_length(m21, m22, m23);
+
+    const m31 = mat4[8];
+    const m32 = mat4[9];
+    const m33 = mat4[10];
+
+    const scale_z = v3_length(m31, m32, m33);
+
+    // If the upper-left 3x3 has a negative determinant the matrix encodes a reflection; fold that sign into
+    // one scale axis (matching three.js, which negates scale.x) so the extracted rotation is a proper rotation
+    // rather than a mirror (which __setFromRotationMatrix would decode incorrectly).
+    const det =
+        m11 * (m22 * m33 - m23 * m32)
+        - m12 * (m21 * m33 - m23 * m31)
+        + m13 * (m21 * m32 - m22 * m31);
+
+    const signed_scale_x = det < 0 ? -scale_x : scale_x;
+
+    // extract rotation matrix
+    // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
+    const is1 = signed_scale_x !== 0 ? 1 / signed_scale_x : 1e7;
+    const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
+    const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
+
+    const sm11 = m11 * is1;
+    const sm12 = m12 * is1;
+    const sm13 = m13 * is1;
+
+    const sm21 = m21 * is2;
+    const sm22 = m22 * is2;
+    const sm23 = m23 * is2;
+
+    const sm31 = m31 * is3;
+    const sm32 = m32 * is3;
+    const sm33 = m33 * is3;
+
+    // write out results
+
+    position.set(
+        mat4[12],
+        mat4[13],
+        mat4[14]
+    );
+
+    scale.set(
+        signed_scale_x,
+        scale_y,
+        scale_z
+    );
+
+    rotation.__setFromRotationMatrix(
+        sm11, sm21, sm31,
+        sm12, sm22, sm32,
+        sm13, sm23, sm33
+    );
+}

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.d.ts

@@ -7,6 +7,8 @@
  * gl-matrix `mat4.fromRotationTranslationScale`. The quaternion is assumed to be of
  * unit length. Allocation-free.
  *
+ * Both flavours share {@link m4_from_rotation_translation_scale_scalar}.
+ *
  * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
  * @param {number[]|Float32Array|Float64Array} q rotation quaternion `[x, y, z, w]`
  * @param {number[]|Float32Array|Float64Array} v translation `[x, y, z]`

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_from_rotation_translation_scale.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wDATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAoD9C"}
+{"version":3,"file":"m4_from_rotation_translation_scale.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wDATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAc9C"}

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale.js

@@ -1,3 +1,5 @@
+import { m4_from_rotation_translation_scale_scalar } from "./m4_from_rotation_translation_scale_scalar.js";
+
 /**
  * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a
  * (non-uniform) scale. `out = T * R * S`.
@@ -7,6 +9,8 @@
  * gl-matrix `mat4.fromRotationTranslationScale`. The quaternion is assumed to be of
  * unit length. Allocation-free.
  *
+ * Both flavours share {@link m4_from_rotation_translation_scale_scalar}.
+ *
  * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
  * @param {number[]|Float32Array|Float64Array} q rotation quaternion `[x, y, z, w]`
  * @param {number[]|Float32Array|Float64Array} v translation `[x, y, z]`
@@ -17,50 +21,12 @@
  * @copyright Company Named Limited (c) 2026
  */
 export function m4_from_rotation_translation_scale(out, q, v, s) {
-    const x = q[0];
-    const y = q[1];
-    const z = q[2];
-    const w = q[3];
-
-    const x2 = x + x;
-    const y2 = y + y;
-    const z2 = z + z;
-
-    const xx = x * x2;
-    const xy = x * y2;
-    const xz = x * z2;
-
-    const yy = y * y2;
-    const yz = y * z2;
-    const zz = z * z2;
-
-    const wx = w * x2;
-    const wy = w * y2;
-    const wz = w * z2;
-
-    const sx = s[0];
-    const sy = s[1];
-    const sz = s[2];
-
-    out[0] = (1 - (yy + zz)) * sx;
-    out[1] = (xy + wz) * sx;
-    out[2] = (xz - wy) * sx;
-    out[3] = 0;
-
-    out[4] = (xy - wz) * sy;
-    out[5] = (1 - (xx + zz)) * sy;
-    out[6] = (yz + wx) * sy;
-    out[7] = 0;
-
-    out[8] = (xz + wy) * sz;
-    out[9] = (yz - wx) * sz;
-    out[10] = (1 - (xx + yy)) * sz;
-    out[11] = 0;
-
-    out[12] = v[0];
-    out[13] = v[1];
-    out[14] = v[2];
-    out[15] = 1;
+    m4_from_rotation_translation_scale_scalar(
+        out,
+        q[0], q[1], q[2], q[3],
+        v[0], v[1], v[2],
+        s[0], s[1], s[2]
+    );
 
     return out;
 }

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a (non-uniform) scale,
+ * taking every operand as a loose scalar. `out = T * R * S`.
+ *
+ * This is the shared core of {@link m4_compose} (object operands) and
+ * {@link m4_from_rotation_translation_scale} (array operands) — those two differ only in how they read
+ * their inputs, and previously each carried its own copy of the quaternion→matrix expansion.
+ *
+ * The quaternion is assumed to be of unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} tx
+ * @param {number} ty
+ * @param {number} tz
+ * @param {number} sx
+ * @param {number} sy
+ * @param {number} sz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale_scalar(out: number[] | Float32Array | Float64Array, qx: number, qy: number, qz: number, qw: number, tx: number, ty: number, tz: number, sx: number, sy: number, sz: number): void;
+//# sourceMappingURL=m4_from_rotation_translation_scale_scalar.d.ts.map

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_from_rotation_translation_scale_scalar.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+DAfW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,MAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA8ChB"}

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js

@@ -0,0 +1,67 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a (non-uniform) scale,
+ * taking every operand as a loose scalar. `out = T * R * S`.
+ *
+ * This is the shared core of {@link m4_compose} (object operands) and
+ * {@link m4_from_rotation_translation_scale} (array operands) — those two differ only in how they read
+ * their inputs, and previously each carried its own copy of the quaternion→matrix expansion.
+ *
+ * The quaternion is assumed to be of unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} tx
+ * @param {number} ty
+ * @param {number} tz
+ * @param {number} sx
+ * @param {number} sy
+ * @param {number} sz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale_scalar(
+    out,
+    qx, qy, qz, qw,
+    tx, ty, tz,
+    sx, sy, sz
+) {
+    const x2 = qx + qx;
+    const y2 = qy + qy;
+    const z2 = qz + qz;
+
+    const xx = qx * x2;
+    const xy = qx * y2;
+    const xz = qx * z2;
+
+    const yy = qy * y2;
+    const yz = qy * z2;
+    const zz = qz * z2;
+
+    const wx = qw * x2;
+    const wy = qw * y2;
+    const wz = qw * z2;
+
+    out[0] = (1 - (yy + zz)) * sx;
+    out[1] = (xy + wz) * sx;
+    out[2] = (xz - wy) * sx;
+    out[3] = 0;
+
+    out[4] = (xy - wz) * sy;
+    out[5] = (1 - (xx + zz)) * sy;
+    out[6] = (yz + wx) * sy;
+    out[7] = 0;
+
+    out[8] = (xz + wy) * sz;
+    out[9] = (yz - wx) * sz;
+    out[10] = (1 - (xx + yy)) * sz;
+    out[11] = 0;
+
+    out[12] = tx;
+    out[13] = ty;
+    out[14] = tz;
+    out[15] = 1;
+}

package/src/core/geom/3d/plane/orient3d_fast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orient3d_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/orient3d_fast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA2BlB"}
+{"version":3,"file":"orient3d_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/orient3d_fast.js"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB"}

package/src/core/geom/3d/plane/orient3d_fast.js

@@ -1,3 +1,4 @@
+import { orient3d_fast_point } from "./orient3d_fast_point.js";
 /**
  * Non-robust
  *
@@ -20,29 +21,8 @@
  * @returns {number}
  */
 export function orient3d_fast(points, a, b, c, d) {
-    const a3 = a * 3;
     const d3 = d * 3;
-    const b3 = b * 3;
-    const c3 = c * 3;
 
-    const d_x = points[d3];
-    const d_y = points[d3 + 1];
-    const d_z = points[d3 + 2];
-
-    const adx = points[a3] - d_x;
-    const ady = points[a3 + 1] - d_y;
-    const adz = points[a3 + 2] - d_z;
-
-    const bdx = points[b3] - d_x;
-    const bdy = points[b3 + 1] - d_y;
-    const bdz = points[b3 + 2] - d_z;
-
-    const cdx = points[c3] - d_x;
-    const cdy = points[c3 + 1] - d_y;
-    const cdz = points[c3 + 2] - d_z;
-
-    return adx * (bdy * cdz - bdz * cdy)
-        + bdx * (cdy * adz - cdz * ady)
-        + cdx * (ady * bdz - adz * bdy);
+    return orient3d_fast_point(points, a, b, c, points[d3], points[d3 + 1], points[d3 + 2]);
 }
 

package/src/core/geom/3d/plane/orient3d_fast_point.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Non-robust `orient3d`: the signed volume (x6) of the tetrahedron `(a, b, c, e)`, where `a`/`b`/`c` are
+ * INDICES into a flat `(x, y, z)`-per-point buffer and `e` is given as loose coordinates.
+ *
+ * Sign convention matches {@link orient3d_fast}: positive when `e` is below the plane of `a`, `b`, `c`
+ * with respect to their winding.
+ *
+ * This is the shared core of {@link orient3d_fast} — that one simply reads its fourth point out of the
+ * same buffer first. Use this flavour when the query point is not stored in the buffer, which is the
+ * common case for point-in-solid tests.
+ *
+ * NON-ROBUST: this is the floating-point determinant, not the adaptive-precision predicate. Use
+ * `orient3d_robust` when the sign must be exact for nearly-degenerate configurations.
+ *
+ * @param {number[]|Float32Array|Float64Array} points flat `(x, y, z)` per point
+ * @param {number} a index of the first plane point
+ * @param {number} b index of the second plane point
+ * @param {number} c index of the third plane point
+ * @param {number} ex query point x
+ * @param {number} ey query point y
+ * @param {number} ez query point z
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function orient3d_fast_point(points: number[] | Float32Array | Float64Array, a: number, b: number, c: number, ex: number, ey: number, ez: number): number;
+//# sourceMappingURL=orient3d_fast_point.d.ts.map

package/src/core/geom/3d/plane/orient3d_fast_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orient3d_fast_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/orient3d_fast_point.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4CAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyBlB"}

package/src/core/geom/3d/plane/orient3d_fast_point.js

@@ -0,0 +1,47 @@
+/**
+ * Non-robust `orient3d`: the signed volume (x6) of the tetrahedron `(a, b, c, e)`, where `a`/`b`/`c` are
+ * INDICES into a flat `(x, y, z)`-per-point buffer and `e` is given as loose coordinates.
+ *
+ * Sign convention matches {@link orient3d_fast}: positive when `e` is below the plane of `a`, `b`, `c`
+ * with respect to their winding.
+ *
+ * This is the shared core of {@link orient3d_fast} — that one simply reads its fourth point out of the
+ * same buffer first. Use this flavour when the query point is not stored in the buffer, which is the
+ * common case for point-in-solid tests.
+ *
+ * NON-ROBUST: this is the floating-point determinant, not the adaptive-precision predicate. Use
+ * `orient3d_robust` when the sign must be exact for nearly-degenerate configurations.
+ *
+ * @param {number[]|Float32Array|Float64Array} points flat `(x, y, z)` per point
+ * @param {number} a index of the first plane point
+ * @param {number} b index of the second plane point
+ * @param {number} c index of the third plane point
+ * @param {number} ex query point x
+ * @param {number} ey query point y
+ * @param {number} ez query point z
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function orient3d_fast_point(points, a, b, c, ex, ey, ez) {
+    const a3 = a * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
+
+    const adx = points[a3] - ex;
+    const ady = points[a3 + 1] - ey;
+    const adz = points[a3 + 2] - ez;
+
+    const bdx = points[b3] - ex;
+    const bdy = points[b3 + 1] - ey;
+    const bdz = points[b3 + 2] - ez;
+
+    const cdx = points[c3] - ex;
+    const cdy = points[c3 + 1] - ey;
+    const cdz = points[c3 + 2] - ez;
+
+    return adx * (bdy * cdz - bdz * cdy)
+        + bdx * (cdy * adz - cdz * ady)
+        + cdx * (ady * bdz - adz * bdy);
+}

package/src/core/geom/3d/quaternion/quat3_nlerp.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Shortest-path normalized linear interpolation between two unit quaternions:
+ * `out = normalize(a + (b' - a) * t)`, where `b'` is `b` negated when the two
+ * point into opposite hemispheres.
+ *
+ * The hemisphere flip is what makes this "shortest path". `q` and `-q` name the
+ * same rotation, so a raw componentwise lerp between two quaternions whose dot
+ * product is negative travels the long way round — a visible backwards spin at
+ * playback. Testing `a · b < 0` and negating `b` costs four multiplies and
+ * removes the failure mode entirely.
+ *
+ * nlerp, not slerp: the path is the same, only the angular *rate* differs, and
+ * the error is bounded by a few degrees for the per-tick steps this is built
+ * for (network interpolation between adjacent snapshots, render smoothing).
+ * Slerp's `acos`/`sin` pair costs far more than the visual difference is worth
+ * at those step sizes. Reach for {@link Quaternion#slerpQuaternions} instead
+ * when blending across wide angles, e.g. animation keyframes seconds apart.
+ *
+ * Exists because this was hand-inlined at three separate interpolation sites
+ * with no primitive to call — the `quat3_*` family had `multiply`, `integrate`
+ * and the uint32 codecs but no blend.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and
+ * the rest of the `core/geom/3d/quaternion/` family.
+ *
+ * All eight components are read from the argument list before anything is
+ * written, so `out` may safely be the same backing array the inputs were read
+ * from, at any offset.
+ *
+ * **Precondition: `a` and `b` are non-zero.** The blend cannot otherwise
+ * cancel to the zero quaternion — the hemisphere flip guarantees the endpoints
+ * are never antipodal by the time they are mixed, so the only way to reach a
+ * zero-length result is to hand in a zero-length input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} aw
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} bw
+ * @param {number} t blend factor; 0 yields `a`, 1 yields `b` (or `-b`)
+ */
+export function quat3_nlerp(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number, t: number): void;
+//# sourceMappingURL=quat3_nlerp.d.ts.map

package/src/core/geom/3d/quaternion/quat3_nlerp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_nlerp.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_nlerp.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,iCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,KACN,MAAM,QAyBhB"}