@woosh/meep-engine 3.37.0 → 3.39.0

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

@@ -0,0 +1,85 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a (non-uniform) scale,
+ * each read from an array at an offset. `out = T * R * S`.
+ *
+ * The one place the quaternion→matrix expansion lives: {@link m4_from_rotation_translation_scale}
+ * (arrays at offset 0) hands it its arrays, and {@link m4_from_rotation_translation_scale_scalar}
+ * packs its numbers for it. Use this one wherever the operands already sit in flat arrays, such as
+ * {@link Transform64}, which packs the matrix and all three operands in a single buffer: a caller V8
+ * does not inline this into passes arrays and small integers, where handing over the ten operands as
+ * numbers would box each of them into a new heap object.
+ *
+ * Inverse of {@link m4_decompose_array}, and shaped like it: the matrix at offset 0, each operand at
+ * its own offset.
+ *
+ * Every operand is read before the first element of `out` is written, so the operands may overlap
+ * `out`, as a {@link Transform64}'s translation overlaps its matrix.
+ *
+ * The quaternion is assumed to be of unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix, column-major
+ * @param {number[]|Float32Array|Float64Array} rotation quaternion `[x, y, z, w]`
+ * @param {number} rotation_offset offset into `rotation`
+ * @param {number[]|Float32Array|Float64Array} translation `[x, y, z]`
+ * @param {number} translation_offset offset into `translation`
+ * @param {number[]|Float32Array|Float64Array} scale `[x, y, z]`
+ * @param {number} scale_offset offset into `scale`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale_array(
+    out,
+    rotation, rotation_offset,
+    translation, translation_offset,
+    scale, scale_offset
+) {
+    const qx = rotation[rotation_offset];
+    const qy = rotation[rotation_offset + 1];
+    const qz = rotation[rotation_offset + 2];
+    const qw = rotation[rotation_offset + 3];
+
+    const tx = translation[translation_offset];
+    const ty = translation[translation_offset + 1];
+    const tz = translation[translation_offset + 2];
+
+    const sx = scale[scale_offset];
+    const sy = scale[scale_offset + 1];
+    const sz = scale[scale_offset + 2];
+
+    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/mat4/m4_from_rotation_translation_scale_scalar.d.ts

@@ -2,9 +2,9 @@
  * 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.
+ * {@link m4_compose} (object operands) reads its inputs into this. The arithmetic lives in
+ * {@link m4_from_rotation_translation_scale_array}, which this packs its numbers for; a caller whose
+ * operands already sit in flat arrays should call that one, so the numbers never cross a call.
  *
  * The quaternion is assumed to be of unit length. Allocation-free.
  *

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

@@ -1 +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"}
+{"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":"AASA;;;;;;;;;;;;;;;;;;;;;;;;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,QA2BhB"}

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

@@ -1,10 +1,19 @@
+import { m4_from_rotation_translation_scale_array } from "./m4_from_rotation_translation_scale_array.js";
+
+/**
+ * Where {@link m4_from_rotation_translation_scale_scalar} packs its operands: rotation at 0, translation
+ * at 4, scale at 7.
+ * @type {Float64Array}
+ */
+const operands = new Float64Array(10);
+
 /**
  * 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.
+ * {@link m4_compose} (object operands) reads its inputs into this. The arithmetic lives in
+ * {@link m4_from_rotation_translation_scale_array}, which this packs its numbers for; a caller whose
+ * operands already sit in flat arrays should call that one, so the numbers never cross a call.
  *
  * The quaternion is assumed to be of unit length. Allocation-free.
  *
@@ -29,39 +38,20 @@ export function m4_from_rotation_translation_scale_scalar(
     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;
+    const o = operands;
 
-    out[0] = (1 - (yy + zz)) * sx;
-    out[1] = (xy + wz) * sx;
-    out[2] = (xz - wy) * sx;
-    out[3] = 0;
+    o[0] = qx;
+    o[1] = qy;
+    o[2] = qz;
+    o[3] = qw;
 
-    out[4] = (xy - wz) * sy;
-    out[5] = (1 - (xx + zz)) * sy;
-    out[6] = (yz + wx) * sy;
-    out[7] = 0;
+    o[4] = tx;
+    o[5] = ty;
+    o[6] = tz;
 
-    out[8] = (xz + wy) * sz;
-    out[9] = (yz - wx) * sz;
-    out[10] = (1 - (xx + yy)) * sz;
-    out[11] = 0;
+    o[7] = sx;
+    o[8] = sy;
+    o[9] = sz;
 
-    out[12] = tx;
-    out[13] = ty;
-    out[14] = tz;
-    out[15] = 1;
+    m4_from_rotation_translation_scale_array(out, o, 0, o, 4, o, 7);
 }

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

@@ -24,4 +24,21 @@
  * @param {number} dt
  */
 export function quat3_integrate(result_q: number[] | Float64Array | Quaternion, qx: number, qy: number, qz: number, qw: number, omega_x: number, omega_y: number, omega_z: number, dt: number): void;
+/**
+ * {@link quat3_integrate} with the quaternion read from `q[q_offset ..+3]` and the angular velocity
+ * from `omega[omega_offset ..+2]`, writing the result at `result_q[result_offset]`. The one place the
+ * arithmetic lives. For a caller that cannot have the call inlined, where passing the seven numbers
+ * would box each into a new heap object, once per body per substep.
+ *
+ * Every input is read before the result is written, so `result_q` may be `q`.
+ *
+ * @param {number[]|Float64Array|Quaternion} result_q destination
+ * @param {number} result_offset
+ * @param {number[]|Float64Array} q unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float64Array} omega angular velocity `[x, y, z]`
+ * @param {number} omega_offset
+ * @param {number} dt
+ */
+export function quat3_integrate_array(result_q: number[] | Float64Array | Quaternion, result_offset: number, q: number[] | Float64Array, q_offset: number, omega: number[] | Float64Array, omega_offset: number, dt: number): void;
 //# sourceMappingURL=quat3_integrate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quat3_integrate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_integrate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0CAVW,MAAM,EAAE,GAAC,YAAY,aAAW,MAChC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,MACN,MAAM,QAsChB"}
+{"version":3,"file":"quat3_integrate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_integrate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0CAVW,MAAM,EAAE,GAAC,YAAY,aAAW,MAChC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,MACN,MAAM,QAmBhB;AAKD;;;;;;;;;;;;;;;GAeG;AACH,gDARW,MAAM,EAAE,GAAC,YAAY,aAAW,iBAChC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,MACN,MAAM,QAyChB"}

package/src/core/geom/3d/quaternion/quat3_integrate.js

@@ -29,6 +29,47 @@ export function quat3_integrate(
     omega_x, omega_y, omega_z,
     dt
 ) {
+    const inputs = integrate_inputs;
+
+    inputs[0] = qx;
+    inputs[1] = qy;
+    inputs[2] = qz;
+    inputs[3] = qw;
+    inputs[4] = omega_x;
+    inputs[5] = omega_y;
+    inputs[6] = omega_z;
+
+    quat3_integrate_array(result_q, 0, inputs, 0, inputs, 4, dt);
+}
+
+/** Where {@link quat3_integrate} packs its quaternion and angular velocity. */
+const integrate_inputs = new Float64Array(7);
+
+/**
+ * {@link quat3_integrate} with the quaternion read from `q[q_offset ..+3]` and the angular velocity
+ * from `omega[omega_offset ..+2]`, writing the result at `result_q[result_offset]`. The one place the
+ * arithmetic lives. For a caller that cannot have the call inlined, where passing the seven numbers
+ * would box each into a new heap object, once per body per substep.
+ *
+ * Every input is read before the result is written, so `result_q` may be `q`.
+ *
+ * @param {number[]|Float64Array|Quaternion} result_q destination
+ * @param {number} result_offset
+ * @param {number[]|Float64Array} q unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float64Array} omega angular velocity `[x, y, z]`
+ * @param {number} omega_offset
+ * @param {number} dt
+ */
+export function quat3_integrate_array(
+    result_q, result_offset,
+    q, q_offset,
+    omega, omega_offset,
+    dt
+) {
+    const qx = q[q_offset], qy = q[q_offset + 1], qz = q[q_offset + 2], qw = q[q_offset + 3];
+    const omega_x = omega[omega_offset], omega_y = omega[omega_offset + 1], omega_z = omega[omega_offset + 2];
+
     const h = 0.5 * dt;
 
     const dqx = h * (omega_x * qw + omega_y * qz - omega_z * qy);
@@ -55,8 +96,8 @@ export function quat3_integrate(
         nx = 0; ny = 0; nz = 0; nw = 1;
     }
 
-    result_q[0] = nx;
-    result_q[1] = ny;
-    result_q[2] = nz;
-    result_q[3] = nw;
+    result_q[result_offset] = nx;
+    result_q[result_offset + 1] = ny;
+    result_q[result_offset + 2] = nz;
+    result_q[result_offset + 3] = nw;
 }

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

@@ -24,4 +24,20 @@
  * @param {number} bw
  */
 export function quat3_multiply(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number): void;
+/**
+ * {@link quat3_multiply} with both operands read from arrays, `out = a ⊗ b`. For a caller whose inlining
+ * budget is spent: there a call to the scalar form is a real call, and a real call boxes each of its
+ * eight numbers into a new heap object. The arithmetic is the scalar form's, written out again rather
+ * than called, for the same reason; the two must stay operation for operation the same.
+ *
+ * `out` may be `a` or `b`: both are read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`
+ * @param {number} b_offset
+ */
+export function quat3_multiply_array(out: number[] | Float32Array | Float64Array, out_offset: number, a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number): void;
 //# sourceMappingURL=quat3_multiply.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quat3_multiply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,oCAXW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB"}
+{"version":3,"file":"quat3_multiply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,oCAXW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB;AAED;;;;;;;;;;;;;;GAcG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAUhB"}

package/src/core/geom/3d/quaternion/quat3_multiply.js

@@ -29,3 +29,28 @@ export function quat3_multiply(out, out_offset, ax, ay, az, aw, bx, by, bz, bw)
     out[out_offset + 2] = aw * bz + ax * by - ay * bx + az * bw;
     out[out_offset + 3] = aw * bw - ax * bx - ay * by - az * bz;
 }
+
+/**
+ * {@link quat3_multiply} with both operands read from arrays, `out = a ⊗ b`. For a caller whose inlining
+ * budget is spent: there a call to the scalar form is a real call, and a real call boxes each of its
+ * eight numbers into a new heap object. The arithmetic is the scalar form's, written out again rather
+ * than called, for the same reason; the two must stay operation for operation the same.
+ *
+ * `out` may be `a` or `b`: both are read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`
+ * @param {number} b_offset
+ */
+export function quat3_multiply_array(out, out_offset, a, a_offset, b, b_offset) {
+    const ax = a[a_offset], ay = a[a_offset + 1], az = a[a_offset + 2], aw = a[a_offset + 3];
+    const bx = b[b_offset], by = b[b_offset + 1], bz = b[b_offset + 2], bw = b[b_offset + 3];
+
+    out[out_offset]     = aw * bx + ax * bw + ay * bz - az * by;
+    out[out_offset + 1] = aw * by - ax * bz + ay * bw + az * bx;
+    out[out_offset + 2] = aw * bz + ax * by - ay * bx + az * bw;
+    out[out_offset + 3] = aw * bw - ax * bx - ay * by - az * bz;
+}

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

@@ -45,4 +45,22 @@
  * @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;
+/**
+ * {@link quat3_nlerp} with both quaternions read from arrays. For a caller whose inlining budget is
+ * spent, or code V8 has not optimised yet: there a call to the scalar form is a real call, and a real
+ * call boxes each of its eight numbers into a new heap object. The arithmetic is the scalar form's,
+ * written out again rather than called, for the same reason; the two must stay operation for
+ * operation the same.
+ *
+ * Every component is read before the first write, so `out` may be `a` or `b`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`
+ * @param {number} b_offset
+ * @param {number} t blend fraction, `0` is `a` and `1` is `b`
+ */
+export function quat3_nlerp_array(out: number[] | Float32Array | Float64Array, out_offset: number, a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number, t: number): void;
 //# sourceMappingURL=quat3_nlerp.d.ts.map

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

@@ -1 +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"}
+{"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;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,uCARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,QA4BhB"}

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

@@ -70,3 +70,48 @@ export function quat3_nlerp(out, out_offset, ax, ay, az, aw, bx, by, bz, bw, t)
     out[out_offset + 2] = qz * inv_len;
     out[out_offset + 3] = qw * inv_len;
 }
+
+/**
+ * {@link quat3_nlerp} with both quaternions read from arrays. For a caller whose inlining budget is
+ * spent, or code V8 has not optimised yet: there a call to the scalar form is a real call, and a real
+ * call boxes each of its eight numbers into a new heap object. The arithmetic is the scalar form's,
+ * written out again rather than called, for the same reason; the two must stay operation for
+ * operation the same.
+ *
+ * Every component is read before the first write, so `out` may be `a` or `b`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`
+ * @param {number} b_offset
+ * @param {number} t blend fraction, `0` is `a` and `1` is `b`
+ */
+export function quat3_nlerp_array(out, out_offset, a, a_offset, b, b_offset, t) {
+    const ax = a[a_offset], ay = a[a_offset + 1], az = a[a_offset + 2], aw = a[a_offset + 3];
+    let bx = b[b_offset], by = b[b_offset + 1], bz = b[b_offset + 2], bw = b[b_offset + 3];
+
+    if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+        bx = -bx;
+        by = -by;
+        bz = -bz;
+        bw = -bw;
+    }
+
+    const qx = ax + (bx - ax) * t;
+    const qy = ay + (by - ay) * t;
+    const qz = az + (bz - az) * t;
+    const qw = aw + (bw - aw) * t;
+
+    const len2 = qx * qx + qy * qy + qz * qz + qw * qw;
+
+    assert.ok(len2 > 0, 'quat3_nlerp_array: blend cancelled to the zero quaternion; a or b was not a rotation');
+
+    const inv_len = 1 / Math.sqrt(len2);
+
+    out[out_offset] = qx * inv_len;
+    out[out_offset + 1] = qy * inv_len;
+    out[out_offset + 2] = qz * inv_len;
+    out[out_offset + 3] = qw * inv_len;
+}

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

@@ -38,4 +38,21 @@
  * @copyright Company Named Limited (c) 2026
  */
 export function quat3_shortest_arc(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number): void;
+/**
+ * {@link quat3_shortest_arc} with both vectors read from arrays. For a caller whose inlining budget
+ * is spent, or code V8 has not optimised yet: there a call to the scalar form is a real call, and a
+ * real call boxes each of its six numbers into a new heap object. The arithmetic is the scalar
+ * form's, written out again rather than called, for the same reason; the two must stay operation for
+ * operation the same.
+ *
+ * Both vectors are read before the first write, so `out` may overlap either.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} a unit vector `[x, y, z]`, from
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b unit vector `[x, y, z]`, to
+ * @param {number} b_offset
+ */
+export function quat3_shortest_arc_array(out: number[] | Float32Array | Float64Array, out_offset: number, a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number): void;
 //# sourceMappingURL=quat3_shortest_arc.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quat3_shortest_arc.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_shortest_arc.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA2DhB"}
+{"version":3,"file":"quat3_shortest_arc.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_shortest_arc.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA2DhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,8CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QA6ChB"}