@woosh/meep-engine 3.43.0 → 3.45.0

package/editor/prototypeEditorShell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prototypeEditorShell.d.ts","sourceRoot":"","sources":["../../editor/prototypeEditorShell.js"],"names":[],"mappings":"AAuLA;;;;;GAKG;AACH,2BAFU,QAAQ;IAAC,MAAM,SAAS;IAAC,MAAM,SAAS;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,UAAS;CAAC,CAAC,CAEzD"}
+{"version":3,"file":"prototypeEditorShell.d.ts","sourceRoot":"","sources":["../../editor/prototypeEditorShell.js"],"names":[],"mappings":"AAyLA;;;;;GAKG;AACH,2BAFU,QAAQ;IAAC,MAAM,SAAS;IAAC,MAAM,SAAS;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,UAAS;CAAC,CAAC,CAEzD"}

package/editor/prototypeEditorShell.js

@@ -32,6 +32,7 @@ import {
 import {
     ShadedGeometrySystem
 } from "../src/engine/graphics3/ShadedGeometrySystem.js";
+import { MeshSkinSystem } from "../src/engine/graphics3/MeshSkinSystem.js";
 import { GPUParticleEmitterSystem } from "../src/engine/graphics3/GPUParticleEmitterSystem.js";
 import { enableEditor } from "./enableEditor.js";
 
@@ -96,9 +97,10 @@ async function addGraphicsSystems(engine) {
 
     await em.addSystem(meshes);
 
-    // a model with neither skin nor clip becomes entities, and its primitives are drawn by the
-    // system that owns primitives (D47)
+    // a model becomes entities: its primitives are drawn by the system that owns primitives
+    // (D47), and the skinned ones deformed by the system that owns skins
     await em.addSystem(new ShadedGeometrySystem(engine.graphics, EngineHarness.shadeScene(engine)));
+    await em.addSystem(new MeshSkinSystem(engine.graphics, EngineHarness.shadeScene(engine)));
 
     /*
      One outline pass and both of its sources, because the editor offers a `Highlight` editor and

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.43.0",
+  "version": "3.45.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/collection/array/array_sort_insertion_ascending.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sort `array[start, end)` ascending by `>`, in place, by insertion.
+ *
+ * For a few elements — a query's handful of hits — an insertion sort is as fast as anything
+ * cleverer and allocates nothing, where `Array.prototype.sort` copies the elements into a work array
+ * of its own on every call and `TypedArray.prototype.sort` over a range needs a `subarray` view. Its
+ * cost is quadratic, so a caller that can be handed many elements picks its own cut-over to
+ * something linear-logarithmic or a radix sort.
+ *
+ * Stable. Numbers only: the comparison is `>`, so a NaN never moves past anything and leaves the
+ * range unsorted around it.
+ *
+ * @param {number[]|Uint32Array|Int32Array|Float32Array|Float64Array} array
+ * @param {number} start first index of the range
+ * @param {number} end one past the last index of the range
+ * @returns {void}
+ */
+export function array_sort_insertion_ascending(array: number[] | Uint32Array | Int32Array | Float32Array | Float64Array, start: number, end: number): void;
+//# sourceMappingURL=array_sort_insertion_ascending.d.ts.map

package/src/core/collection/array/array_sort_insertion_ascending.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_sort_insertion_ascending.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_sort_insertion_ascending.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,sDALW,MAAM,EAAE,GAAC,WAAW,GAAC,UAAU,GAAC,YAAY,GAAC,YAAY,SACzD,MAAM,OACN,MAAM,GACJ,IAAI,CAehB"}

package/src/core/collection/array/array_sort_insertion_ascending.js

@@ -0,0 +1,31 @@
+/**
+ * Sort `array[start, end)` ascending by `>`, in place, by insertion.
+ *
+ * For a few elements — a query's handful of hits — an insertion sort is as fast as anything
+ * cleverer and allocates nothing, where `Array.prototype.sort` copies the elements into a work array
+ * of its own on every call and `TypedArray.prototype.sort` over a range needs a `subarray` view. Its
+ * cost is quadratic, so a caller that can be handed many elements picks its own cut-over to
+ * something linear-logarithmic or a radix sort.
+ *
+ * Stable. Numbers only: the comparison is `>`, so a NaN never moves past anything and leaves the
+ * range unsorted around it.
+ *
+ * @param {number[]|Uint32Array|Int32Array|Float32Array|Float64Array} array
+ * @param {number} start first index of the range
+ * @param {number} end one past the last index of the range
+ * @returns {void}
+ */
+export function array_sort_insertion_ascending(array, start, end) {
+    for (let i = start + 1; i < end; i++) {
+        const v = array[i];
+
+        let j = i - 1;
+
+        while (j >= start && array[j] > v) {
+            array[j + 1] = array[j];
+            j--;
+        }
+
+        array[j + 1] = v;
+    }
+}

package/src/core/geom/3d/aabb/aabb3_array_round_outward_f32.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Round a box outward to float32: each lower bound down and each upper bound up to the nearest
+ * float32 on that side, so the result is the tightest float32 box that contains the input.
+ *
+ * A float32 store — a BVH node, a GPU buffer — rounds to the NEAREST float32, which is inward on
+ * any side that rounds that way, by up to half a float32 step. That step is a proportion of the
+ * magnitude, so the inward error is too: 3 cm at 1e6 m, half a metre at 1e7. A box stored that way
+ * stops containing what it
+ * bounded, and a query reaching the content through the box misses whatever lay outside it — far
+ * from the origin only, and silently. Rounding through this first makes the store exact.
+ * Measured in the rigid-body broadphase before it did this: a ray dropped onto a 2 mm plate 1e6 m
+ * out missed it, and so did rays a millimetre inside a 1 m crate's faces 1e5 m out.
+ *
+ * A bound that is already a float32 is kept as it is. A bound beyond the largest finite float32
+ * on its own side — a lower bound below `-F32_MAX`, an upper bound above `F32_MAX` — goes to that
+ * side's infinity; one beyond it on the other side becomes `±F32_MAX`. A NaN stays NaN.
+ *
+ * `result` may be `aabb` at the same offset.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} aabb `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} aabb_offset
+ * @returns {void}
+ */
+export function aabb3_array_round_outward_f32(result: number[] | Float32Array | Float64Array, result_offset: number, aabb: number[] | Float32Array | Float64Array, aabb_offset: number): void;
+//# sourceMappingURL=aabb3_array_round_outward_f32.d.ts.map

package/src/core/geom/3d/aabb/aabb3_array_round_outward_f32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_array_round_outward_f32.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_array_round_outward_f32.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,GACJ,IAAI,CAYhB"}

package/src/core/geom/3d/aabb/aabb3_array_round_outward_f32.js

@@ -0,0 +1,39 @@
+import { f32_next_down } from "../../../math/f32_next_down.js";
+import { f32_next_up } from "../../../math/f32_next_up.js";
+
+/**
+ * Round a box outward to float32: each lower bound down and each upper bound up to the nearest
+ * float32 on that side, so the result is the tightest float32 box that contains the input.
+ *
+ * A float32 store — a BVH node, a GPU buffer — rounds to the NEAREST float32, which is inward on
+ * any side that rounds that way, by up to half a float32 step. That step is a proportion of the
+ * magnitude, so the inward error is too: 3 cm at 1e6 m, half a metre at 1e7. A box stored that way
+ * stops containing what it
+ * bounded, and a query reaching the content through the box misses whatever lay outside it — far
+ * from the origin only, and silently. Rounding through this first makes the store exact.
+ * Measured in the rigid-body broadphase before it did this: a ray dropped onto a 2 mm plate 1e6 m
+ * out missed it, and so did rays a millimetre inside a 1 m crate's faces 1e5 m out.
+ *
+ * A bound that is already a float32 is kept as it is. A bound beyond the largest finite float32
+ * on its own side — a lower bound below `-F32_MAX`, an upper bound above `F32_MAX` — goes to that
+ * side's infinity; one beyond it on the other side becomes `±F32_MAX`. A NaN stays NaN.
+ *
+ * `result` may be `aabb` at the same offset.
+ *
+ * @param {number[]|Float32Array|Float64Array} result receives `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} aabb `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} aabb_offset
+ * @returns {void}
+ */
+export function aabb3_array_round_outward_f32(result, result_offset, aabb, aabb_offset) {
+    for (let i = 0; i < 3; i++) {
+        const lower = aabb[aabb_offset + i];
+        const lower_f32 = Math.fround(lower);
+        result[result_offset + i] = lower_f32 > lower ? f32_next_down(lower_f32) : lower_f32;
+
+        const upper = aabb[aabb_offset + i + 3];
+        const upper_f32 = Math.fround(upper);
+        result[result_offset + i + 3] = upper_f32 < upper ? f32_next_up(upper_f32) : upper_f32;
+    }
+}

package/src/core/geom/3d/aabb/aabb3_from_v3_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_from_v3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,4CAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAAM,SAC7C,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,QA6BhB"}
+{"version":3,"file":"aabb3_from_v3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,4CAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAAM,SAC7C,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,QAgChB"}

package/src/core/geom/3d/aabb/aabb3_from_v3_array.js

@@ -10,7 +10,10 @@ import { aabb3_array_set } from "./aabb3_array_set.js";
  * @param {number} input_length length of the input array
  */
 export function aabb3_from_v3_array(result, input, input_length) {
-    assert.equal(input_length % 3, 0, `Input must be divisible by 3, instead was ${input_length}`)
+    // the message is built only on failure: this runs per step in physics
+    if (input_length % 3 !== 0) {
+        assert.ok(false, `Input must be divisible by 3, instead was ${input_length}`);
+    }
 
     let x0 = Infinity;
     let y0 = Infinity;

package/src/core/geom/3d/aabb/aabb3_transform_oriented.d.ts

@@ -37,9 +37,9 @@ export function aabb3_transform_oriented(result: number[] | Float32Array | Float
  * @param {number} result_offset
  * @param {number[]|Float32Array|Float64Array} aabb local box `[x0, y0, z0, x1, y1, z1]`
  * @param {number} aabb_offset
- * @param {number[]|Float64Array} pose translation then orientation (unit quaternion):
+ * @param {number[]|Float32Array|Float64Array} pose translation then orientation (unit quaternion):
  *   `[px, py, pz, qx, qy, qz, qw]`
  * @param {number} pose_offset
  */
-export function aabb3_transform_oriented_array(result: number[] | Float32Array | Float64Array, result_offset: number, aabb: number[] | Float32Array | Float64Array, aabb_offset: number, pose: number[] | Float64Array, pose_offset: number): void;
+export function aabb3_transform_oriented_array(result: number[] | Float32Array | Float64Array, result_offset: number, aabb: number[] | Float32Array | Float64Array, aabb_offset: number, pose: number[] | Float32Array | Float64Array, pose_offset: number): void;
 //# sourceMappingURL=aabb3_transform_oriented.d.ts.map

package/src/core/geom/3d/aabb/aabb3_transform_oriented.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_transform_oriented.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAhBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;AAMD;;;;;;;;;;;;;GAaG;AACH,uDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,eAErB,MAAM,QAuEhB"}
+{"version":3,"file":"aabb3_transform_oriented.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAhBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;AAMD;;;;;;;;;;;;;GAaG;AACH,uDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAElC,MAAM,QAuEhB"}

package/src/core/geom/3d/aabb/aabb3_transform_oriented.js

@@ -58,7 +58,7 @@ const scratch_pose = new Float64Array(7);
  * @param {number} result_offset
  * @param {number[]|Float32Array|Float64Array} aabb local box `[x0, y0, z0, x1, y1, z1]`
  * @param {number} aabb_offset
- * @param {number[]|Float64Array} pose translation then orientation (unit quaternion):
+ * @param {number[]|Float32Array|Float64Array} pose translation then orientation (unit quaternion):
  *   `[px, py, pz, qx, qy, qz, qw]`
  * @param {number} pose_offset
  */

package/src/core/geom/3d/pose/pose3_apply_inverse_point_array.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bring a point into a rigid pose's frame: `out = q⁻¹·(p − t)`.
+ *
+ * The inverse of {@link pose3_apply_point_array}, and with the same operands: translation and unit
+ * rotation separately, each an array and an offset, so a `Transform64`'s lanes, a cloth's split frame
+ * arrays and a packed seven-float record are all read where they sit. Nothing is allocated.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the difference is held aside before the first
+ * write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the frame the pose is expressed in
+ * @param {number} p_offset
+ */
+export function pose3_apply_inverse_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, t: number[] | Float32Array | Float64Array, t_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number, p: number[] | Float32Array | Float64Array, p_offset: number): void;
+//# sourceMappingURL=pose3_apply_inverse_point_array.d.ts.map

package/src/core/geom/3d/pose/pose3_apply_inverse_point_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_apply_inverse_point_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_apply_inverse_point_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qDATW,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,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAUhB"}

package/src/core/geom/3d/pose/pose3_apply_inverse_point_array.js

@@ -0,0 +1,36 @@
+import { v3_quaternion_apply_inverse_array } from "../../vec3/v3_quaternion_apply_inverse.js";
+
+/**
+ * Bring a point into a rigid pose's frame: `out = q⁻¹·(p − t)`.
+ *
+ * The inverse of {@link pose3_apply_point_array}, and with the same operands: translation and unit
+ * rotation separately, each an array and an offset, so a `Transform64`'s lanes, a cloth's split frame
+ * arrays and a packed seven-float record are all read where they sit. Nothing is allocated.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the difference is held aside before the first
+ * write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the frame the pose is expressed in
+ * @param {number} p_offset
+ */
+export function pose3_apply_inverse_point_array(out, out_offset, t, t_offset, q, q_offset, p, p_offset) {
+    const offset = scratch_offset;
+
+    offset[0] = p[p_offset] - t[t_offset];
+    offset[1] = p[p_offset + 1] - t[t_offset + 1];
+    offset[2] = p[p_offset + 2] - t[t_offset + 2];
+
+    v3_quaternion_apply_inverse_array(out, out_offset, offset, 0, q, q_offset);
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_offset = new Float64Array(3);

package/src/core/geom/3d/pose/pose3_apply_point_array.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bring a point out of a rigid pose's frame: `out = t + q·p`.
+ *
+ * A rigid pose here is a translation and a unit rotation with no scale — what a body, a holder, a
+ * cloth's local frame or a joint is — and the two are separate operands rather than one packed record,
+ * because the poses that use them are kept both ways: a `Transform64` holds its translation at lane 12
+ * and its rotation at lane 16, a cloth keeps its frame in two arrays, a contact record packs seven
+ * floats. Each operand is an array and an offset; nothing is allocated.
+ *
+ * The inverse is {@link pose3_apply_inverse_point_array}.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the rotated point is held aside before the
+ * first write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the pose's frame
+ * @param {number} p_offset
+ */
+export function pose3_apply_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, t: number[] | Float32Array | Float64Array, t_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number, p: number[] | Float32Array | Float64Array, p_offset: number): void;
+//# sourceMappingURL=pose3_apply_point_array.d.ts.map

package/src/core/geom/3d/pose/pose3_apply_point_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_apply_point_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_apply_point_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CATW,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,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAUhB"}

package/src/core/geom/3d/pose/pose3_apply_point_array.js

@@ -0,0 +1,40 @@
+import { v3_quaternion_apply_array } from "../../vec3/v3_quaternion_apply.js";
+
+/**
+ * Bring a point out of a rigid pose's frame: `out = t + q·p`.
+ *
+ * A rigid pose here is a translation and a unit rotation with no scale — what a body, a holder, a
+ * cloth's local frame or a joint is — and the two are separate operands rather than one packed record,
+ * because the poses that use them are kept both ways: a `Transform64` holds its translation at lane 12
+ * and its rotation at lane 16, a cloth keeps its frame in two arrays, a contact record packs seven
+ * floats. Each operand is an array and an offset; nothing is allocated.
+ *
+ * The inverse is {@link pose3_apply_inverse_point_array}.
+ *
+ * `out` may be `p`, and may be `t` at the same offset: the rotated point is held aside before the
+ * first write. It may not otherwise overlap `t` or `q`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 3 floats
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation `[x, y, z]`
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, a unit quaternion `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number[]|Float32Array|Float64Array} p the point, in the pose's frame
+ * @param {number} p_offset
+ */
+export function pose3_apply_point_array(out, out_offset, t, t_offset, q, q_offset, p, p_offset) {
+    const rotated = scratch_rotated;
+
+    v3_quaternion_apply_array(rotated, 0, p, p_offset, q, q_offset);
+
+    out[out_offset] = t[t_offset] + rotated[0];
+    out[out_offset + 1] = t[t_offset + 1] + rotated[1];
+    out[out_offset + 2] = t[t_offset + 2] + rotated[2];
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_rotated = new Float64Array(3);

package/src/core/geom/3d/pose/pose3_compose_array.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compose two rigid poses, a local one hung from a parent: `t' = t_p + q_p·t_l`, `q' = q_p ⊗ q_l`.
+ *
+ * What a child's pose is once its parent's is known — a bind pose built down a hierarchy, a seeded
+ * subtree's rest pose. The inverse is {@link pose3_to_local_array}.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `parent_t` or `local_t` at the same offset, and `out_q` may be `parent_q` or
+ * `local_q` at the same offset; the translation is written before the rotations are read, so `out_t`
+ * may not otherwise overlap any operand.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} parent_t the parent's translation
+ * @param {number} parent_t_offset
+ * @param {number[]|Float32Array|Float64Array} parent_q the parent's rotation, a unit quaternion
+ * @param {number} parent_q_offset
+ * @param {number[]|Float32Array|Float64Array} local_t the local pose's translation, in the parent's frame
+ * @param {number} local_t_offset
+ * @param {number[]|Float32Array|Float64Array} local_q the local pose's rotation, likewise
+ * @param {number} local_q_offset
+ */
+export function pose3_compose_array(out_t: number[] | Float32Array | Float64Array, out_t_offset: number, out_q: number[] | Float32Array | Float64Array, out_q_offset: number, parent_t: number[] | Float32Array | Float64Array, parent_t_offset: number, parent_q: number[] | Float32Array | Float64Array, parent_q_offset: number, local_t: number[] | Float32Array | Float64Array, local_t_offset: number, local_q: number[] | Float32Array | Float64Array, local_q_offset: number): void;
+//# sourceMappingURL=pose3_compose_array.d.ts.map

package/src/core/geom/3d/pose/pose3_compose_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_compose_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_compose_array.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CAbW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,QAahB"}

package/src/core/geom/3d/pose/pose3_compose_array.js

@@ -0,0 +1,41 @@
+import { quat3_multiply_array } from "../quaternion/quat3_multiply.js";
+import { pose3_apply_point_array } from "./pose3_apply_point_array.js";
+
+/**
+ * Compose two rigid poses, a local one hung from a parent: `t' = t_p + q_p·t_l`, `q' = q_p ⊗ q_l`.
+ *
+ * What a child's pose is once its parent's is known — a bind pose built down a hierarchy, a seeded
+ * subtree's rest pose. The inverse is {@link pose3_to_local_array}.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `parent_t` or `local_t` at the same offset, and `out_q` may be `parent_q` or
+ * `local_q` at the same offset; the translation is written before the rotations are read, so `out_t`
+ * may not otherwise overlap any operand.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} parent_t the parent's translation
+ * @param {number} parent_t_offset
+ * @param {number[]|Float32Array|Float64Array} parent_q the parent's rotation, a unit quaternion
+ * @param {number} parent_q_offset
+ * @param {number[]|Float32Array|Float64Array} local_t the local pose's translation, in the parent's frame
+ * @param {number} local_t_offset
+ * @param {number[]|Float32Array|Float64Array} local_q the local pose's rotation, likewise
+ * @param {number} local_q_offset
+ */
+export function pose3_compose_array(
+    out_t, out_t_offset,
+    out_q, out_q_offset,
+    parent_t, parent_t_offset,
+    parent_q, parent_q_offset,
+    local_t, local_t_offset,
+    local_q, local_q_offset
+) {
+    pose3_apply_point_array(out_t, out_t_offset, parent_t, parent_t_offset, parent_q, parent_q_offset, local_t, local_t_offset);
+
+    quat3_multiply_array(out_q, out_q_offset, parent_q, parent_q_offset, local_q, local_q_offset);
+}

package/src/core/geom/3d/pose/pose3_to_local_array.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Express a rigid pose in another pose's frame: `t' = q_f⁻¹·(t − t_f)`, `q' = q_f⁻¹ ⊗ q`.
+ *
+ * What a world pose is relative to a parent, a holder in a cloth's moving frame, a collider in the
+ * frame its contacts are solved in. The inverse is {@link pose3_compose_array}: composing the frame
+ * with the result gives the pose back.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `t` at the same offset and `out_q` may be `q` at the same offset; the translation is
+ * written before the rotation is read, so `out_t` may not overlap `q`, `frame_q` or `frame_t`
+ * otherwise, and `out_q` may not overlap `frame_q` otherwise.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} frame_t the frame's translation
+ * @param {number} frame_t_offset
+ * @param {number[]|Float32Array|Float64Array} frame_q the frame's rotation, a unit quaternion
+ * @param {number} frame_q_offset
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation, in the frame the frame is in
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, likewise
+ * @param {number} q_offset
+ */
+export function pose3_to_local_array(out_t: number[] | Float32Array | Float64Array, out_t_offset: number, out_q: number[] | Float32Array | Float64Array, out_q_offset: number, frame_t: number[] | Float32Array | Float64Array, frame_t_offset: number, frame_q: number[] | Float32Array | Float64Array, frame_q_offset: number, t: number[] | Float32Array | Float64Array, t_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number): void;
+//# sourceMappingURL=pose3_to_local_array.d.ts.map

package/src/core/geom/3d/pose/pose3_to_local_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pose3_to_local_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/pose/pose3_to_local_array.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAbW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,kBAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAahB"}

package/src/core/geom/3d/pose/pose3_to_local_array.js

@@ -0,0 +1,42 @@
+import { quat3_multiply_conjugate_left_array } from "../quaternion/quat3_multiply_conjugate_left_array.js";
+import { pose3_apply_inverse_point_array } from "./pose3_apply_inverse_point_array.js";
+
+/**
+ * Express a rigid pose in another pose's frame: `t' = q_f⁻¹·(t − t_f)`, `q' = q_f⁻¹ ⊗ q`.
+ *
+ * What a world pose is relative to a parent, a holder in a cloth's moving frame, a collider in the
+ * frame its contacts are solved in. The inverse is {@link pose3_compose_array}: composing the frame
+ * with the result gives the pose back.
+ *
+ * Every operand is an array and an offset, translation and rotation apart — see
+ * {@link pose3_apply_point_array} for why. Nothing is allocated.
+ *
+ * `out_t` may be `t` at the same offset and `out_q` may be `q` at the same offset; the translation is
+ * written before the rotation is read, so `out_t` may not overlap `q`, `frame_q` or `frame_t`
+ * otherwise, and `out_q` may not overlap `frame_q` otherwise.
+ *
+ * @param {number[]|Float32Array|Float64Array} out_t receives 3 floats
+ * @param {number} out_t_offset
+ * @param {number[]|Float32Array|Float64Array} out_q receives 4 floats
+ * @param {number} out_q_offset
+ * @param {number[]|Float32Array|Float64Array} frame_t the frame's translation
+ * @param {number} frame_t_offset
+ * @param {number[]|Float32Array|Float64Array} frame_q the frame's rotation, a unit quaternion
+ * @param {number} frame_q_offset
+ * @param {number[]|Float32Array|Float64Array} t the pose's translation, in the frame the frame is in
+ * @param {number} t_offset
+ * @param {number[]|Float32Array|Float64Array} q the pose's rotation, likewise
+ * @param {number} q_offset
+ */
+export function pose3_to_local_array(
+    out_t, out_t_offset,
+    out_q, out_q_offset,
+    frame_t, frame_t_offset,
+    frame_q, frame_q_offset,
+    t, t_offset,
+    q, q_offset
+) {
+    pose3_apply_inverse_point_array(out_t, out_t_offset, frame_t, frame_t_offset, frame_q, frame_q_offset, t, t_offset);
+
+    quat3_multiply_conjugate_left_array(out_q, out_q_offset, frame_q, frame_q_offset, q, q_offset);
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Limit a rotation's angle: `out` turns about the same axis as `q` by `min(θ, max_angle)`, exactly.
+ *
+ * The rotation is read as an axis and an angle and the angle is replaced, so the answer is the
+ * limit itself and not an approximation of it. The alternative it exists to replace — nlerp from
+ * the identity towards `q` by `max_angle / θ` — follows the chord rather than the arc and
+ * undershoots more the larger `θ` is: at `θ = π` asked for `π/4` it turns `0.64` rad, not `0.785`.
+ *
+ * `q` and `-q` name the same rotation; the angle is measured on the one with `w ≥ 0`, so `θ` is
+ * the shorter turn, in `[0, π]`. A rotation within the limit is passed through unchanged, sign
+ * included; one beyond it is written with `w ≥ 0`. The identity (no axis) is within any limit.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `q`: every component is read before the first write.
+ *
+ * **Precondition: `q` is a unit quaternion.** The angle is `2·atan2(|v|, w)`, which does not care,
+ * but a limited rotation is written unit and an unlimited one as it came.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} q `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number} max_angle radians, `≥ 0`
+ */
+export function quat3_clamp_angle_array(out: number[] | Float32Array | Float64Array, out_offset: number, q: number[] | Float32Array | Float64Array, q_offset: number, max_angle: number): void;
+//# sourceMappingURL=quat3_clamp_angle_array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_clamp_angle_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_clamp_angle_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,6CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,aACN,MAAM,QAuChB"}

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

@@ -0,0 +1,66 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Limit a rotation's angle: `out` turns about the same axis as `q` by `min(θ, max_angle)`, exactly.
+ *
+ * The rotation is read as an axis and an angle and the angle is replaced, so the answer is the
+ * limit itself and not an approximation of it. The alternative it exists to replace — nlerp from
+ * the identity towards `q` by `max_angle / θ` — follows the chord rather than the arc and
+ * undershoots more the larger `θ` is: at `θ = π` asked for `π/4` it turns `0.64` rad, not `0.785`.
+ *
+ * `q` and `-q` name the same rotation; the angle is measured on the one with `w ≥ 0`, so `θ` is
+ * the shorter turn, in `[0, π]`. A rotation within the limit is passed through unchanged, sign
+ * included; one beyond it is written with `w ≥ 0`. The identity (no axis) is within any limit.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `q`: every component is read before the first write.
+ *
+ * **Precondition: `q` is a unit quaternion.** The angle is `2·atan2(|v|, w)`, which does not care,
+ * but a limited rotation is written unit and an unlimited one as it came.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} q `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number} max_angle radians, `≥ 0`
+ */
+export function quat3_clamp_angle_array(out, out_offset, q, q_offset, max_angle) {
+    assert.isNumber(max_angle, 'max_angle');
+    assert.greaterThanOrEqual(max_angle, 0, 'max_angle must be non-negative');
+
+    let x = q[q_offset], y = q[q_offset + 1], z = q[q_offset + 2], w = q[q_offset + 3];
+
+    const pass_x = x, pass_y = y, pass_z = z, pass_w = w;
+
+    if (w < 0) {
+        x = -x;
+        y = -y;
+        z = -z;
+        w = -w;
+    }
+
+    const sin_half = Math.sqrt(x * x + y * y + z * z);
+
+    // atan2 rather than acos(w): accurate near the identity, where acos loses half the digits
+    const angle = 2 * Math.atan2(sin_half, w);
+
+    if (angle <= max_angle) {
+        out[out_offset] = pass_x;
+        out[out_offset + 1] = pass_y;
+        out[out_offset + 2] = pass_z;
+        out[out_offset + 3] = pass_w;
+
+        return;
+    }
+
+    // sin_half > 0 here: a zero vector part has angle 0, within any limit
+    const half = max_angle * 0.5;
+    const k = Math.sin(half) / sin_half;
+
+    out[out_offset] = x * k;
+    out[out_offset + 1] = y * k;
+    out[out_offset + 2] = z * k;
+    out[out_offset + 3] = Math.cos(half);
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Hamilton product with the left operand conjugated, `out = a* ⊗ b`, both read from arrays.
+ *
+ * For unit quaternions the conjugate is the inverse, so this is `a⁻¹ ⊗ b`: the rotation `b` expressed
+ * in the frame `a` rotates into — a world orientation written in a parent's or a body's frame. Callers
+ * used to build `a*` in a scratch array and hand it to {@link quat3_multiply_array}; the conjugate's
+ * signs are folded into the product here instead, so there is no scratch and no extra pass.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `a` or `b`: all eight components are read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`, the operand that is conjugated
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`
+ * @param {number} b_offset
+ */
+export function quat3_multiply_conjugate_left_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_conjugate_left_array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_multiply_conjugate_left_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply_conjugate_left_array.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yDAPW,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,QAWhB"}