@woosh/meep-engine 2.169.1 → 2.169.2

package/src/core/geom/3d/line/line3_segment_segment_closest_point_pair.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Closest pair of points between two 3D segments, written into `out` as
+ * `(pax, pay, paz, pbx, pby, pbz)` — the point on segment A followed by the point on segment B.
+ *
+ * Wraps {@link line3_compute_segment_segment_closest_points}, which reports the closest pair as the
+ * parameters `(s, t)`. Every caller of that function immediately reconstructed both world points with the
+ * same six lines, and three of the four then took the squared distance between them — returned here.
+ *
+ * The reconstruction uses the `a + (b - a) * t` form deliberately, matching all previous call sites
+ * bit-for-bit; the algebraically equal `(1 - t) * a + t * b` is NOT the same in floating point and would
+ * perturb the contact manifolds this feeds.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, at least 6 elements from `out_offset`
+ * @param {number} out_offset
+ * @param {number} a0x
+ * @param {number} a0y
+ * @param {number} a0z
+ * @param {number} a1x
+ * @param {number} a1y
+ * @param {number} a1z
+ * @param {number} b0x
+ * @param {number} b0y
+ * @param {number} b0z
+ * @param {number} b1x
+ * @param {number} b1y
+ * @param {number} b1z
+ * @returns {number} SQUARED distance between the two closest points
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function line3_segment_segment_closest_point_pair(out: number[] | Float32Array | Float64Array, out_offset: number, a0x: number, a0y: number, a0z: number, a1x: number, a1y: number, a1z: number, b0x: number, b0y: number, b0z: number, b1x: number, b1y: number, b1z: number): number;
+//# sourceMappingURL=line3_segment_segment_closest_point_pair.d.ts.map

package/src/core/geom/3d/line/line3_segment_segment_closest_point_pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line3_segment_segment_closest_point_pair.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_segment_segment_closest_point_pair.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8DAnBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAuClB"}

package/src/core/geom/3d/line/line3_segment_segment_closest_point_pair.js

@@ -0,0 +1,71 @@
+import { line3_compute_segment_segment_closest_points } from "./line3_compute_segment_segment_closest_points.js";
+
+// [s, t] parameters along segment A and segment B
+const scratch_st = new Float64Array(2);
+
+/**
+ * Closest pair of points between two 3D segments, written into `out` as
+ * `(pax, pay, paz, pbx, pby, pbz)` — the point on segment A followed by the point on segment B.
+ *
+ * Wraps {@link line3_compute_segment_segment_closest_points}, which reports the closest pair as the
+ * parameters `(s, t)`. Every caller of that function immediately reconstructed both world points with the
+ * same six lines, and three of the four then took the squared distance between them — returned here.
+ *
+ * The reconstruction uses the `a + (b - a) * t` form deliberately, matching all previous call sites
+ * bit-for-bit; the algebraically equal `(1 - t) * a + t * b` is NOT the same in floating point and would
+ * perturb the contact manifolds this feeds.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, at least 6 elements from `out_offset`
+ * @param {number} out_offset
+ * @param {number} a0x
+ * @param {number} a0y
+ * @param {number} a0z
+ * @param {number} a1x
+ * @param {number} a1y
+ * @param {number} a1z
+ * @param {number} b0x
+ * @param {number} b0y
+ * @param {number} b0z
+ * @param {number} b1x
+ * @param {number} b1y
+ * @param {number} b1z
+ * @returns {number} SQUARED distance between the two closest points
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function line3_segment_segment_closest_point_pair(
+    out, out_offset,
+    a0x, a0y, a0z, a1x, a1y, a1z,
+    b0x, b0y, b0z, b1x, b1y, b1z
+) {
+    line3_compute_segment_segment_closest_points(
+        scratch_st,
+        a0x, a0y, a0z, a1x, a1y, a1z,
+        b0x, b0y, b0z, b1x, b1y, b1z
+    );
+
+    const s = scratch_st[0];
+    const t = scratch_st[1];
+
+    const pax = a0x + (a1x - a0x) * s;
+    const pay = a0y + (a1y - a0y) * s;
+    const paz = a0z + (a1z - a0z) * s;
+
+    const pbx = b0x + (b1x - b0x) * t;
+    const pby = b0y + (b1y - b0y) * t;
+    const pbz = b0z + (b1z - b0z) * t;
+
+    out[out_offset] = pax;
+    out[out_offset + 1] = pay;
+    out[out_offset + 2] = paz;
+    out[out_offset + 3] = pbx;
+    out[out_offset + 4] = pby;
+    out[out_offset + 5] = pbz;
+
+    const dx = pax - pbx;
+    const dy = pay - pby;
+    const dz = paz - pbz;
+
+    return dx * dx + dy * dy + dz * dz;
+}

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

@@ -1,4 +1,9 @@
 /**
+ * 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

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

@@ -1 +1 @@
-{"version":3,"file":"m4_compose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_compose.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,mCALW,MAAM,EAAE,GAAC,YAAY,OAAK;OACrB,MAAM;OAAI,MAAM;OAAI,MAAM;;OAC1B,MAAM;OAAI,MAAM;OAAI,MAAM;OAAI,MAAM;;OACpC,MAAM;OAAI,MAAM;OAAI,MAAM;SA+CzC"}
+{"version":3,"file":"m4_compose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_compose.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,mCALW,MAAM,EAAE,GAAC,YAAY,OAAK,YACzB;IAAE,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAE,YAChC;IAAE,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAE,SAC1C;IAAE,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAE,QAS3C"}

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"}