@woosh/meep-engine 2.169.1 → 2.169.3

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,9 +1,13 @@
 /**
+ * Decompose a 4x4 transform into position, rotation and scale.
  *
- * @param {number[]} mat4
+ * The three outputs are written through their setters, so `Vector3`/`Quaternion` change signals fire.
+ * Use {@link m4_decompose_array} instead when the destinations are flat arrays.
+ *
+ * @param {number[]|Float32Array|Float64Array|mat4} mat4
  * @param {Vector3|{set(x:number,y:number,z:number)}} position
- * @param {Quaternion} rotation
+ * @param {Quaternion|{set(x:number,y:number,z:number,w:number)}} rotation
  * @param {Vector3|{set(x:number,y:number,z:number)}} scale
  */
-export function m4_decompose(mat4: number[], position: any, rotation: Quaternion, scale: any): void;
+export function m4_decompose(mat4: any, position: any, rotation: any, scale: any): void;
 //# sourceMappingURL=m4_decompose.d.ts.map

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":"AAOA;;;;;;;;;;GAUG;AACH,wFA6CC"}

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

@@ -1,76 +1,64 @@
-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 { m4_decompose_array } from "./m4_decompose_array.js";
+
+/**
+ * @type {Float64Array}
+ */
+const scratch = new Float64Array(10);
+
+/**
+ * Decompose a 4x4 transform into position, rotation and scale.
+ *
+ * The three outputs are written through their setters, so `Vector3`/`Quaternion` change signals fire.
+ * Use {@link m4_decompose_array} instead when the destinations are flat arrays.
+ *
+ * @param {number[]|Float32Array|Float64Array|mat4} mat4
+ * @param {Vector3|{set(x:number,y:number,z:number)}} position
+ * @param {Quaternion|{set(x:number,y:number,z:number,w:number)}} rotation
+ * @param {Vector3|{set(x:number,y:number,z:number)}} scale
+ */
+export function m4_decompose(mat4, position, rotation, scale) {
+
+    // the scratch is what lets this share the decomposition math with `m4_decompose_array`
+    // instead of carrying a second copy of it, laid out as [translation:3, rotation:4, scale:3]
+    m4_decompose_array(
+        mat4,
+        scratch, 0,
+        scratch, 3,
+        scratch, 7
+    );
+
+    // Drain the scratch before writing anything out. The setters below dispatch change signals, and a
+    // handler is free to call this function again - that would overwrite the module-static scratch
+    // part-way through, and the rest of this call would read the re-entrant call's numbers.
+    const position_x = scratch[0];
+    const position_y = scratch[1];
+    const position_z = scratch[2];
+
+    const rotation_x = scratch[3];
+    const rotation_y = scratch[4];
+    const rotation_z = scratch[5];
+    const rotation_w = scratch[6];
+
+    const scale_x = scratch[7];
+    const scale_y = scratch[8];
+    const scale_z = scratch[9];
+
+    position.set(
+        position_x,
+        position_y,
+        position_z
+    );
+
+    scale.set(
+        scale_x,
+        scale_y,
+        scale_z
+    );
+
+    rotation.set(
+        rotation_x,
+        rotation_y,
+        rotation_z,
+        rotation_w
+    );
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Decompose a 4x4 transform into a translation, a rotation quaternion and a (non-uniform) scale,
+ * written into flat arrays at explicit offsets.
+ *
+ * Array-argument companion to {@link m4_decompose}, which takes `Vector3`/`Quaternion` objects instead.
+ * Use this one when the destinations are already flat arrays, such as {@link Transform64} which packs
+ * all four of these in a single buffer.
+ *
+ * The three destinations may all be the same array, as long as the ranges do not overlap, and they may
+ * overlap `m4` itself - every component of `m4` is read before the first write.
+ *
+ * A reflection (negative upper-left determinant) is folded into one scale axis, so that the extracted
+ * rotation is always proper. Note that this makes the scale reported here differ from
+ * {@link m4_extract_scale}, which reports raw column lengths; the two are not interchangeable.
+ *
+ * @param {number[]|Float32Array|Float64Array|mat4} m4 source 4x4 matrix
+ * @param {number[]|Float32Array|Float64Array} translation receives 3 numbers (x, y, z)
+ * @param {number} translation_offset offset into `translation`
+ * @param {number[]|Float32Array|Float64Array} rotation receives 4 numbers (x, y, z, w)
+ * @param {number} rotation_offset offset into `rotation`
+ * @param {number[]|Float32Array|Float64Array} scale receives 3 numbers (x, y, z)
+ * @param {number} scale_offset offset into `scale`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_decompose_array(m4: number[] | Float32Array | Float64Array | mat4, translation: number[] | Float32Array | Float64Array, translation_offset: number, rotation: number[] | Float32Array | Float64Array, rotation_offset: number, scale: number[] | Float32Array | Float64Array, scale_offset: number): void;
+//# sourceMappingURL=m4_decompose_array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"m4_decompose_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uCAXW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,OAAK,eACvC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,QAqIhB"}

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

@@ -0,0 +1,157 @@
+import { v3_length } from "../../vec3/v3_length.js";
+
+/**
+ * Decompose a 4x4 transform into a translation, a rotation quaternion and a (non-uniform) scale,
+ * written into flat arrays at explicit offsets.
+ *
+ * Array-argument companion to {@link m4_decompose}, which takes `Vector3`/`Quaternion` objects instead.
+ * Use this one when the destinations are already flat arrays, such as {@link Transform64} which packs
+ * all four of these in a single buffer.
+ *
+ * The three destinations may all be the same array, as long as the ranges do not overlap, and they may
+ * overlap `m4` itself - every component of `m4` is read before the first write.
+ *
+ * A reflection (negative upper-left determinant) is folded into one scale axis, so that the extracted
+ * rotation is always proper. Note that this makes the scale reported here differ from
+ * {@link m4_extract_scale}, which reports raw column lengths; the two are not interchangeable.
+ *
+ * @param {number[]|Float32Array|Float64Array|mat4} m4 source 4x4 matrix
+ * @param {number[]|Float32Array|Float64Array} translation receives 3 numbers (x, y, z)
+ * @param {number} translation_offset offset into `translation`
+ * @param {number[]|Float32Array|Float64Array} rotation receives 4 numbers (x, y, z, w)
+ * @param {number} rotation_offset offset into `rotation`
+ * @param {number[]|Float32Array|Float64Array} scale receives 3 numbers (x, y, z)
+ * @param {number} scale_offset offset into `scale`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_decompose_array(
+    m4,
+    translation, translation_offset,
+    rotation, rotation_offset,
+    scale, scale_offset
+) {
+    const m11 = m4[0];
+    const m12 = m4[1];
+    const m13 = m4[2];
+
+    const scale_x = v3_length(m11, m12, m13);
+
+    const m21 = m4[4];
+    const m22 = m4[5];
+    const m23 = m4[6];
+
+    const scale_y = v3_length(m21, m22, m23);
+
+    const m31 = m4[8];
+    const m32 = m4[9];
+    const m33 = m4[10];
+
+    const scale_z = v3_length(m31, m32, m33);
+
+    const translation_x = m4[12];
+    const translation_y = m4[13];
+    const translation_z = m4[14];
+
+    // 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 the quaternion extraction below 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;
+
+    // Convert the rotation matrix to a quaternion.
+    // This algorithm comes from "Quaternion Calculus and Fast Animation", Ken Shoemake, 1987 SIGGRAPH course notes
+    // @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/Quaternion.h#L813
+    // NOTE: `sm` is stored column-major, so the row-major element `m_ij` used by the algorithm is `sm_ji`
+    const trace = sm11 + sm22 + sm33;
+
+    let x, y, z, w, s;
+
+    if (trace > 0) {
+
+        s = Math.sqrt(trace + 1.0);
+
+        w = 0.5 * s;
+
+        s = 0.5 / s;
+
+        x = (sm23 - sm32) * s;
+        y = (sm31 - sm13) * s;
+        z = (sm12 - sm21) * s;
+
+    } else if (sm11 > sm22 && sm11 > sm33) {
+
+        s = Math.sqrt(1.0 + sm11 - sm22 - sm33);
+
+        x = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (sm23 - sm32) * s;
+        y = (sm21 + sm12) * s;
+        z = (sm31 + sm13) * s;
+
+    } else if (sm22 > sm33) {
+
+        s = Math.sqrt(1.0 + sm22 - sm11 - sm33);
+
+        y = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (sm31 - sm13) * s;
+        x = (sm21 + sm12) * s;
+        z = (sm32 + sm23) * s;
+
+    } else {
+
+        s = Math.sqrt(1.0 + sm33 - sm11 - sm22);
+
+        z = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (sm12 - sm21) * s;
+        x = (sm31 + sm13) * s;
+        y = (sm32 + sm23) * s;
+
+    }
+
+    // write out results
+
+    translation[translation_offset] = translation_x;
+    translation[translation_offset + 1] = translation_y;
+    translation[translation_offset + 2] = translation_z;
+
+    rotation[rotation_offset] = x;
+    rotation[rotation_offset + 1] = y;
+    rotation[rotation_offset + 2] = z;
+    rotation[rotation_offset + 3] = w;
+
+    scale[scale_offset] = signed_scale_x;
+    scale[scale_offset + 1] = scale_y;
+    scale[scale_offset + 2] = scale_z;
+}

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