@woosh/meep-engine 3.37.0 → 3.39.0

package/src/engine/physics/cloth/ecs/cloth_gather_colliders.js

@@ -1,7 +1,13 @@
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
-import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_quaternion_apply_inverse_array } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import {
+    CCR_AABB_MAX_X,
+    CCR_AABB_MAX_Y,
+    CCR_AABB_MAX_Z,
+    CCR_AABB_MIN_X,
+    CCR_AABB_MIN_Y,
+    CCR_AABB_MIN_Z,
     CCR_FEATURE,
     CCR_FRICTION,
     CCR_INFLATION,
@@ -26,7 +32,8 @@ import {
     CCR_TY,
     CCR_TZ
 } from "../collider/ClothColliderRecord.js";
-import { cloth_collider_refit_bounds } from "../collider/cloth_collider_bounds.js";
+import { ClothColliderKind } from "../collider/ClothColliderKind.js";
+import { cloth_collider_refit_bounds, cloth_contact_rounding } from "../collider/cloth_collider_bounds.js";
 import { CLOTH_CONTACT_MARGIN } from "../solver/cloth_contact_find.js";
 import { CLOTH_COLLIDER_SLOTS } from "../solver/cloth_solver_constants.js";
 
@@ -55,10 +62,10 @@ import { CLOTH_COLLIDER_SLOTS } from "../solver/cloth_solver_constants.js";
  *
  * ## The query box
  *
- * The cloth's own particle bounds, fattened by exactly what
- * `cloth_contact_find` will reach for — no more, because a broadphase that is
- * wider than its narrowphase is collecting colliders it will then throw away.
- * {@link cloth_gather_reach} is that quantity and carries the derivation.
+ * The cloth's particle bounds are fattened by its contact radius and particle
+ * travel; the index supplies each collider's motion and inflation. Both sides
+ * include an outward rounding allowance for the solver's Float32 conversion.
+ * {@link cloth_gather_reach} carries the reach derivation.
  *
  * It used to be the velocity clamp of §7 P1 read as a distance. That was wrong
  * in both directions at once. The clamp is `4 · shortest_row · substeps ·
@@ -99,17 +106,16 @@ import { CLOTH_COLLIDER_SLOTS } from "../solver/cloth_solver_constants.js";
  *
  * The gather has one job the solver depends on: the set it hands over must
  * contain every collider `cloth_contact_find` would draw a row against. So the
- * margin is that function's own reach, maximised over the things the gather
- * cannot yet know — which collider, and which particle:
+ * reach is split between the cloth query and each collider's indexed bounds:
  *
  *     (radius + inflation) · (1 + CLOTH_CONTACT_MARGIN)   the contact itself
  *   + collider travel                                     §20, the collider's approach
  *   + |v| · dt                                            §54, the particle's own
  *
- * The radius term is added by {@link cloth_gather_colliders}, which knows the
- * cloth's `contact_radius`; this supplies the rest. Inflation and collider
- * travel come from the index as maxima over every live record, because the
- * gather has not queried yet and so cannot know which records it will get.
+ * The radius term is added by {@link cloth_gather_colliders}. This function
+ * supplies particle travel. The index expands each collider's swept bounds
+ * by its own travel and inflation, so an intersection covers the same sum
+ * without allowing one remote outlier to widen every cloth's query.
  *
  * **The velocity is read before the step and the narrowphase reads it after
  * `damp`**, which only ever scales it down — so this is an upper bound on the
@@ -142,22 +148,20 @@ export function cloth_gather_reach(state, index, dt) {
         }
     }
 
-    return dt * Math.sqrt(fastest_squared)
-        + index.max_collider_travel
-        + index.max_inflation * (1 + CLOTH_CONTACT_MARGIN);
+    return dt * Math.sqrt(fastest_squared);
 }
 
 /**
- * Query the index and rewrite the overlapping colliders into the cloth's frame.
+ * Query the index into HANDLES without touching the solver's collider table.
  *
- * @param {ClothInstance} instance read for its anchor pose and filter; its
- *   state's `collider_table`, `collider_key` and `collider_count` are filled
+ * @param {ClothInstance} instance read for its bounds, anchor pose and filter
  * @param {ClothColliderIndex} index
  * @param {number} reach how far past its particles the cloth has to look,
  *   metres — {@link cloth_gather_reach}
- * @returns {number} how many colliders were gathered
+ * @returns {number} how many handles fit in the collider table
+ * @private
  */
-export function cloth_gather_colliders(instance, index, reach) {
+function query_colliders(instance, index, reach) {
     const state = instance.state;
 
     const particle_count = state.particle_count;
@@ -186,22 +190,9 @@ export function cloth_gather_colliders(instance, index, reach) {
     }
 
     if (particle_count === 0) {
-        state.collider_count = 0;
-
         return 0;
     }
 
-    // The contact's own reach, on the same terms `cloth_contact_find` states
-    // it in, plus everything {@link cloth_gather_reach} already folded in.
-    const margin = reach + state.contact_radius * (1 + CLOTH_CONTACT_MARGIN);
-
-    min_x -= margin;
-    min_y -= margin;
-    min_z -= margin;
-    max_x += margin;
-    max_y += margin;
-    max_z += margin;
-
     // The anchor pose the particles were carried into this step, not the live
     // component — those are the same value by the time this runs, and the
     // cached pair is the one `move_local_frame` used.
@@ -209,10 +200,21 @@ export function cloth_gather_colliders(instance, index, reach) {
     const anchor_y = instance.anchor_translation[1];
     const anchor_z = instance.anchor_translation[2];
 
-    const qx = instance.anchor_rotation[0];
-    const qy = instance.anchor_rotation[1];
-    const qz = instance.anchor_rotation[2];
-    const qw = instance.anchor_rotation[3];
+    const anchor_rotation = instance.anchor_rotation;
+
+    const contact_reach = reach + state.contact_radius * (1 + CLOTH_CONTACT_MARGIN);
+    const local_scale = Math.max(Math.abs(min_x), Math.abs(max_x))
+        + Math.max(Math.abs(min_y), Math.abs(max_y))
+        + Math.max(Math.abs(min_z), Math.abs(max_z)) + contact_reach;
+    const world_scale = local_scale + Math.abs(anchor_x) + Math.abs(anchor_y) + Math.abs(anchor_z);
+    const margin = contact_reach + cloth_contact_rounding(local_scale, world_scale);
+
+    min_x -= margin;
+    min_y -= margin;
+    min_z -= margin;
+    max_x += margin;
+    max_y += margin;
+    max_z += margin;
 
     // The local box's eight corners, in world. A rotated box is not a box, so
     // the world query volume is the bounds of the rotated one rather than the
@@ -225,13 +227,13 @@ export function cloth_gather_colliders(instance, index, reach) {
     let world_max_z = -Infinity;
 
     for (let corner = 0; corner < 8; corner++) {
-        v3_quaternion_apply(
-            CORNER, 0,
-            (corner & 1) === 0 ? min_x : max_x,
-            (corner & 2) === 0 ? min_y : max_y,
-            (corner & 4) === 0 ? min_z : max_z,
-            qx, qy, qz, qw
-        );
+        // The corner and the rotation go in as arrays: handed over as seven numbers, each was boxed
+        // wherever the call was not inlined, eight times a cloth a step.
+        CORNER[0] = (corner & 1) === 0 ? min_x : max_x;
+        CORNER[1] = (corner & 2) === 0 ? min_y : max_y;
+        CORNER[2] = (corner & 4) === 0 ? min_z : max_z;
+
+        v3_quaternion_apply_array(CORNER, 0, CORNER, 0, anchor_rotation, 0);
 
         const x = CORNER[0] + anchor_x;
         const y = CORNER[1] + anchor_y;
@@ -247,11 +249,39 @@ export function cloth_gather_colliders(instance, index, reach) {
 
     const cloth = instance.cloth;
 
-    const overlapping = index.query(
-        HANDLES, world_min_x, world_min_y, world_min_z,
-        world_max_x, world_max_y, world_max_z,
-        cloth.layer, cloth.mask
-    );
+    QUERY_BOX[0] = world_min_x;
+    QUERY_BOX[1] = world_min_y;
+    QUERY_BOX[2] = world_min_z;
+    QUERY_BOX[3] = world_max_x;
+    QUERY_BOX[4] = world_max_y;
+    QUERY_BOX[5] = world_max_z;
+
+    const candidates = index.queryArray(HANDLES, QUERY_BOX, 0, cloth.layer, cloth.mask, true);
+
+    // A half-space has no bounded world-space conversion allowance, so the
+    // index keeps every plane. Reject separated planes in the exact Float32
+    // frame used by the solver, BEFORE applying the table limit. Otherwise
+    // distant floors can consume all slots and hide a real nearby contact.
+    let overlapping = 0;
+    const source = index.table;
+    for (let i = 0; i < candidates; i++) {
+        const handle = HANDLES[i];
+        if (source[handle * CCR_STRIDE + CCR_KIND] === ClothColliderKind.Plane) {
+            localise_record(PLANE_RECORD, 0, source, handle, instance);
+            const extra = Math.max(0, PLANE_RECORD[CCR_INFLATION]) * (1 + CLOTH_CONTACT_MARGIN)
+                + Math.hypot(
+                    PLANE_RECORD[CCR_TX] - PLANE_RECORD[CCR_PREV_TX],
+                    PLANE_RECORD[CCR_TY] - PLANE_RECORD[CCR_PREV_TY],
+                    PLANE_RECORD[CCR_TZ] - PLANE_RECORD[CCR_PREV_TZ]
+                );
+            if (max_x + extra < PLANE_RECORD[CCR_AABB_MIN_X] || min_x - extra > PLANE_RECORD[CCR_AABB_MAX_X]
+                || max_y + extra < PLANE_RECORD[CCR_AABB_MIN_Y] || min_y - extra > PLANE_RECORD[CCR_AABB_MAX_Y]
+                || max_z + extra < PLANE_RECORD[CCR_AABB_MIN_Z] || min_z - extra > PLANE_RECORD[CCR_AABB_MAX_Z]) {
+                continue;
+            }
+        }
+        HANDLES[overlapping++] = handle;
+    }
 
     let found = overlapping;
 
@@ -269,44 +299,28 @@ export function cloth_gather_colliders(instance, index, reach) {
         }
     }
 
+    return found;
+}
+
+/**
+ * Query the index and rewrite overlapping colliders into the cloth's frame.
+ * @param {ClothInstance} instance its state's collider table and keys are filled
+ * @param {ClothColliderIndex} index
+ * @param {number} reach particle travel from {@link cloth_gather_reach}
+ * @returns {number} how many colliders were gathered
+ */
+export function cloth_gather_colliders(instance, index, reach) {
+    const found = query_colliders(instance, index, reach);
+    const state = instance.state;
     const table = state.collider_table;
     const keys = state.collider_key;
-
     const source = index.table;
 
     for (let i = 0; i < found; i++) {
         const handle = HANDLES[i];
-
-        const from = handle * CCR_STRIDE;
-        const to = i * CCR_STRIDE;
-
         keys[i] = handle;
-
-        table[to + CCR_KIND] = source[from + CCR_KIND];
-        table[to + CCR_PARAM_0] = source[from + CCR_PARAM_0];
-        table[to + CCR_PARAM_1] = source[from + CCR_PARAM_1];
-        table[to + CCR_PARAM_2] = source[from + CCR_PARAM_2];
-        table[to + CCR_PARAM_3] = source[from + CCR_PARAM_3];
-        table[to + CCR_FEATURE] = source[from + CCR_FEATURE];
-        table[to + CCR_FRICTION] = source[from + CCR_FRICTION];
-        table[to + CCR_INFLATION] = source[from + CCR_INFLATION];
-
-        localise(
-            table, to + CCR_TX, to + CCR_QX,
-            source[from + CCR_TX], source[from + CCR_TY], source[from + CCR_TZ],
-            source[from + CCR_QX], source[from + CCR_QY], source[from + CCR_QZ], source[from + CCR_QW],
-            anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
-        );
-
-        localise(
-            table, to + CCR_PREV_TX, to + CCR_PREV_QX,
-            source[from + CCR_PREV_TX], source[from + CCR_PREV_TY], source[from + CCR_PREV_TZ],
-            source[from + CCR_PREV_QX], source[from + CCR_PREV_QY],
-            source[from + CCR_PREV_QZ], source[from + CCR_PREV_QW],
-            anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
-        );
-
-        cloth_collider_refit_bounds(table, i, CCR_STRIDE);
+        instance.gathered_collider_revisions[i] = index.revisionOf(handle);
+        localise_record(table, i, source, handle, instance);
     }
 
     state.collider_count = found;
@@ -314,45 +328,85 @@ export function cloth_gather_colliders(instance, index, reach) {
     return found;
 }
 
+/**
+ * Convert a complete record using the solver's storage precision. Shared with
+ * the plane prefilter so its bounds and travel match what discovery will read.
+ * @param {Float32Array} table
+ * @param {number} record
+ * @param {Float64Array} source
+ * @param {number} handle
+ * @param {ClothInstance} instance
+ * @private
+ */
+function localise_record(table, record, source, handle, instance) {
+    const anchor_translation = instance.anchor_translation;
+    const anchor_rotation = instance.anchor_rotation;
+    const from = handle * CCR_STRIDE;
+    const to = record * CCR_STRIDE;
+
+    table[to + CCR_KIND] = source[from + CCR_KIND];
+    table[to + CCR_PARAM_0] = source[from + CCR_PARAM_0];
+    table[to + CCR_PARAM_1] = source[from + CCR_PARAM_1];
+    table[to + CCR_PARAM_2] = source[from + CCR_PARAM_2];
+    table[to + CCR_PARAM_3] = source[from + CCR_PARAM_3];
+    table[to + CCR_FEATURE] = source[from + CCR_FEATURE];
+    table[to + CCR_FRICTION] = source[from + CCR_FRICTION];
+    table[to + CCR_INFLATION] = source[from + CCR_INFLATION];
+
+    localise(
+        table, to + CCR_TX, to + CCR_QX,
+        source, from + CCR_TX, from + CCR_QX,
+        anchor_translation, anchor_rotation
+    );
+
+    localise(
+        table, to + CCR_PREV_TX, to + CCR_PREV_QX,
+        source, from + CCR_PREV_TX, from + CCR_PREV_QX,
+        anchor_translation, anchor_rotation
+    );
+
+    cloth_collider_refit_bounds(table, record, CCR_STRIDE);
+}
+
 /**
  * Write a world pose into a record's translation and rotation slots, expressed
  * in the anchor's frame.
  *
+ * Everything goes in as arrays and slots: handed over as fourteen numbers, the
+ * pose and the anchor's were each boxed into a heap object wherever this was
+ * not inlined, twice per collider per cloth per step.
+ *
  * @param {Float32Array} table
  * @param {number} translation_slot
  * @param {number} rotation_slot
- * @param {number} tx
- * @param {number} ty
- * @param {number} tz
- * @param {number} rx
- * @param {number} ry
- * @param {number} rz
- * @param {number} rw
- * @param {number} anchor_x
- * @param {number} anchor_y
- * @param {number} anchor_z
- * @param {number} qx
- * @param {number} qy
- * @param {number} qz
- * @param {number} qw
+ * @param {Float32Array|Float64Array} source the world pose's record table
+ * @param {number} source_translation_slot `[x, y, z]`
+ * @param {number} source_rotation_slot `[x, y, z, w]`
+ * @param {Float64Array} anchor_translation `[x, y, z]`
+ * @param {Float64Array} anchor_rotation `[x, y, z, w]`
  * @private
  */
 function localise(
     table, translation_slot, rotation_slot,
-    tx, ty, tz, rx, ry, rz, rw,
-    anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
+    source, source_translation_slot, source_rotation_slot,
+    anchor_translation, anchor_rotation
 ) {
-    v3_quaternion_apply_inverse(
-        LOCAL_TRANSLATION, 0,
-        tx - anchor_x, ty - anchor_y, tz - anchor_z,
-        qx, qy, qz, qw
-    );
+    LOCAL_TRANSLATION[0] = source[source_translation_slot] - anchor_translation[0];
+    LOCAL_TRANSLATION[1] = source[source_translation_slot + 1] - anchor_translation[1];
+    LOCAL_TRANSLATION[2] = source[source_translation_slot + 2] - anchor_translation[2];
+
+    v3_quaternion_apply_inverse_array(LOCAL_TRANSLATION, 0, LOCAL_TRANSLATION, 0, anchor_rotation, 0);
 
     table[translation_slot] = LOCAL_TRANSLATION[0];
     table[translation_slot + 1] = LOCAL_TRANSLATION[1];
     table[translation_slot + 2] = LOCAL_TRANSLATION[2];
 
-    quat3_multiply(LOCAL_ROTATION, 0, -qx, -qy, -qz, qw, rx, ry, rz, rw);
+    ANCHOR_CONJUGATE[0] = -anchor_rotation[0];
+    ANCHOR_CONJUGATE[1] = -anchor_rotation[1];
+    ANCHOR_CONJUGATE[2] = -anchor_rotation[2];
+    ANCHOR_CONJUGATE[3] = anchor_rotation[3];
+
+    quat3_multiply_array(LOCAL_ROTATION, 0, ANCHOR_CONJUGATE, 0, source, source_rotation_slot);
 
     table[rotation_slot] = LOCAL_ROTATION[0];
     table[rotation_slot + 1] = LOCAL_ROTATION[1];
@@ -366,17 +420,19 @@ function localise(
  *
  * A sleeping cloth is not stepped and not written back, so something has to
  * notice when the world it was resting against changes. This is that something,
- * and it is a broadphase query plus two comparisons: cheaper than a step by
- * three orders of magnitude, which is what makes sleep worth having at all.
+ * and it queries handles and revisions without constructing a local collider
+ * table or changing solver memory.
  *
- * **Two comparisons, and the set is the one M2 did not have.** A pose
- * comparison answers "did anything move", and `ClothColliderSystem#link`
+ * **Two comparisons, and the set is the one M2 did not have.** A revision
+ * comparison answers "did anything change", and `ClothColliderSystem#link`
  * *places* a new collider rather than posing it — previous equals current — so
  * a sphere spawned around a sleeping rope is a collider that has not moved.
  * Measured: the rope slept through it and stayed asleep three hundred steps
  * later with four of its six links inside. A handle appearing in the gathered
  * set, or leaving it, is a change to the world the cloth went to sleep in
  * whatever the poses say, and it costs one integer compare per record.
+ * Revisions also detect placements (whose swept poses are equal), changed
+ * surfaces, and a removed handle reused while the cloth slept.
  *
  * The query uses the reach the cloth's last *step* gathered with, so the two
  * sets are answers to the same question. A set built at zero margin against one
@@ -387,9 +443,7 @@ function localise(
  * @returns {boolean}
  */
 export function cloth_colliders_moved(instance, index) {
-    const found = cloth_gather_colliders(instance, index, instance.gather_reach);
-
-    const keys = instance.state.collider_key;
+    const found = query_colliders(instance, index, instance.gather_reach);
 
     if (found !== instance.collider_key_count) {
         return true;
@@ -398,23 +452,7 @@ export function cloth_colliders_moved(instance, index) {
     const seen = instance.collider_keys;
 
     for (let i = 0; i < found; i++) {
-        if (keys[i] !== seen[i]) {
-            return true;
-        }
-    }
-
-    const table = instance.state.collider_table;
-
-    for (let i = 0; i < found; i++) {
-        const r = i * CCR_STRIDE;
-
-        if (table[r + CCR_TX] !== table[r + CCR_PREV_TX]
-            || table[r + CCR_TY] !== table[r + CCR_PREV_TY]
-            || table[r + CCR_TZ] !== table[r + CCR_PREV_TZ]
-            || table[r + CCR_QX] !== table[r + CCR_PREV_QX]
-            || table[r + CCR_QY] !== table[r + CCR_PREV_QY]
-            || table[r + CCR_QZ] !== table[r + CCR_PREV_QZ]
-            || table[r + CCR_QW] !== table[r + CCR_PREV_QW]) {
+        if (HANDLES[i] !== seen[i] || index.revisionOf(HANDLES[i]) !== instance.collider_revisions[i]) {
             return true;
         }
     }
@@ -440,6 +478,7 @@ export function cloth_remember_colliders(instance, reach) {
 
     for (let i = 0; i < count; i++) {
         seen[i] = keys[i];
+        instance.collider_revisions[i] = instance.gathered_collider_revisions[i];
     }
 
     instance.collider_key_count = count;
@@ -452,6 +491,9 @@ export function cloth_remember_colliders(instance, reach) {
  */
 const HANDLES = [];
 
+/** @type {Float32Array} @private */
+const PLANE_RECORD = new Float32Array(CCR_STRIDE);
+
 /**
  * @type {Float64Array}
  * @private
@@ -469,3 +511,18 @@ const LOCAL_TRANSLATION = new Float64Array(3);
  * @private
  */
 const LOCAL_ROTATION = new Float64Array(4);
+
+/**
+ * The anchor's rotation conjugated, `[-x, -y, -z, w]`: {@link localise}'s left operand.
+ * @type {Float64Array}
+ * @private
+ */
+const ANCHOR_CONJUGATE = new Float64Array(4);
+
+/**
+ * The world box {@link query_colliders} asks the index about, `[min_x, min_y, min_z, max_x, max_y,
+ * max_z]`.
+ * @type {Float64Array}
+ * @private
+ */
+const QUERY_BOX = new Float64Array(6);

package/src/engine/physics/cloth/ecs/cloth_reconstruct_pose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_reconstruct_pose.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_reconstruct_pose.js"],"names":[],"mappings":"AA6DA;;;;;;;;;;GAUG;AACH,iEAFa,IAAI,CAqEhB"}
+{"version":3,"file":"cloth_reconstruct_pose.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_reconstruct_pose.js"],"names":[],"mappings":"AA6DA;;;;;;;;;;GAUG;AACH,iEAFa,IAAI,CA+DhB"}

package/src/engine/physics/cloth/ecs/cloth_reconstruct_pose.js

@@ -1,6 +1,6 @@
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { quat3_nlerp } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
-import { quat3_shortest_arc } from "../../../../core/geom/3d/quaternion/quat3_shortest_arc.js";
+import { quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { quat3_nlerp_array } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
+import { quat3_shortest_arc_array } from "../../../../core/geom/3d/quaternion/quat3_shortest_arc.js";
 
 /**
  * # From particles to a pose — the half of the write-back that is arithmetic
@@ -114,13 +114,11 @@ export function cloth_reconstruct_pose(instance) {
 
         let swing = SWING_OUT;
 
+        // Every quaternion and direction below goes to its function as an array and an offset:
+        // handed over as numbers, each was boxed into a heap object wherever the call was not inlined,
+        // which until V8 optimises this pass is every call, per node per step.
         if (has_parent_swing && has_child_swing) {
-            quat3_nlerp(
-                SWING, SWING_OUT,
-                SWING[SWING_PARENT], SWING[SWING_PARENT + 1], SWING[SWING_PARENT + 2], SWING[SWING_PARENT + 3],
-                SWING[SWING_CHILD], SWING[SWING_CHILD + 1], SWING[SWING_CHILD + 2], SWING[SWING_CHILD + 3],
-                0.5
-            );
+            quat3_nlerp_array(SWING, SWING_OUT, SWING, SWING_PARENT, SWING, SWING_CHILD, 0.5);
         } else if (has_child_swing) {
             swing = SWING_CHILD;
         } else {
@@ -131,11 +129,7 @@ export function cloth_reconstruct_pose(instance) {
 
         // Animated orientation first, then the swing: the swing is expressed in
         // the cloth's local frame.
-        quat3_multiply(
-            reconstructed, node * 4,
-            SWING[swing], SWING[swing + 1], SWING[swing + 2], SWING[swing + 3],
-            rotation[node * 4], rotation[node * 4 + 1], rotation[node * 4 + 2], rotation[node * 4 + 3]
-        );
+        quat3_multiply_array(reconstructed, node * 4, SWING, swing, rotation, node * 4);
     }
 }
 
@@ -157,11 +151,16 @@ function link_swing(instance, from, to, out) {
     const a = from * 3;
     const b = to * 3;
 
-    const has_animated = unit(DIRECTION, 0,
-        animated[b] - animated[a], animated[b + 1] - animated[a + 1], animated[b + 2] - animated[a + 2]);
+    DIRECTION[0] = animated[b] - animated[a];
+    DIRECTION[1] = animated[b + 1] - animated[a + 1];
+    DIRECTION[2] = animated[b + 2] - animated[a + 2];
 
-    const has_blended = unit(DIRECTION, 3,
-        blended[b] - blended[a], blended[b + 1] - blended[a + 1], blended[b + 2] - blended[a + 2]);
+    DIRECTION[3] = blended[b] - blended[a];
+    DIRECTION[4] = blended[b + 1] - blended[a + 1];
+    DIRECTION[5] = blended[b + 2] - blended[a + 2];
+
+    const has_animated = unit(DIRECTION, 0);
+    const has_blended = unit(DIRECTION, 3);
 
     if (!has_animated || !has_blended) {
         identity(out);
@@ -169,11 +168,7 @@ function link_swing(instance, from, to, out) {
         return false;
     }
 
-    quat3_shortest_arc(
-        SWING, out,
-        DIRECTION[0], DIRECTION[1], DIRECTION[2],
-        DIRECTION[3], DIRECTION[4], DIRECTION[5]
-    );
+    quat3_shortest_arc_array(SWING, out, DIRECTION, 0, DIRECTION, 3);
 
     return true;
 }
@@ -213,23 +208,37 @@ function children_swing(instance, node, out) {
     for (let i = start; i < end; i++) {
         const b = child[i] * 3;
 
-        if (unit(DIRECTION, 6,
-            animated[b] - animated[a], animated[b + 1] - animated[a + 1], animated[b + 2] - animated[a + 2])) {
+        DIRECTION[6] = animated[b] - animated[a];
+        DIRECTION[7] = animated[b + 1] - animated[a + 1];
+        DIRECTION[8] = animated[b + 2] - animated[a + 2];
+
+        if (unit(DIRECTION, 6)) {
             anim_x += DIRECTION[6];
             anim_y += DIRECTION[7];
             anim_z += DIRECTION[8];
         }
 
-        if (unit(DIRECTION, 9,
-            blended[b] - blended[a], blended[b + 1] - blended[a + 1], blended[b + 2] - blended[a + 2])) {
+        DIRECTION[9] = blended[b] - blended[a];
+        DIRECTION[10] = blended[b + 1] - blended[a + 1];
+        DIRECTION[11] = blended[b + 2] - blended[a + 2];
+
+        if (unit(DIRECTION, 9)) {
             sim_x += DIRECTION[9];
             sim_y += DIRECTION[10];
             sim_z += DIRECTION[11];
         }
     }
 
-    const has_animated = unit(DIRECTION, 0, anim_x, anim_y, anim_z);
-    const has_blended = unit(DIRECTION, 3, sim_x, sim_y, sim_z);
+    DIRECTION[0] = anim_x;
+    DIRECTION[1] = anim_y;
+    DIRECTION[2] = anim_z;
+
+    DIRECTION[3] = sim_x;
+    DIRECTION[4] = sim_y;
+    DIRECTION[5] = sim_z;
+
+    const has_animated = unit(DIRECTION, 0);
+    const has_blended = unit(DIRECTION, 3);
 
     if (!has_animated || !has_blended) {
         // Branches that cancel — a node with two children pointing opposite
@@ -240,27 +249,25 @@ function children_swing(instance, node, out) {
         return false;
     }
 
-    quat3_shortest_arc(
-        SWING, out,
-        DIRECTION[0], DIRECTION[1], DIRECTION[2],
-        DIRECTION[3], DIRECTION[4], DIRECTION[5]
-    );
+    quat3_shortest_arc_array(SWING, out, DIRECTION, 0, DIRECTION, 3);
 
     return true;
 }
 
 /**
- * Normalise into `out`, reporting whether there was a direction to find.
+ * Normalise the vector at `offset` in place, reporting whether there was a direction to find; one
+ * that was not is left as it was.
  *
  * @param {Float64Array} out
  * @param {number} offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
  * @returns {boolean}
  * @private
  */
-function unit(out, offset, x, y, z) {
+function unit(out, offset) {
+    const x = out[offset];
+    const y = out[offset + 1];
+    const z = out[offset + 2];
+
     const length_squared = x * x + y * y + z * z;
 
     if (length_squared < 1e-24) {

package/src/engine/physics/cloth/ecs/cloth_write_back.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_write_back.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;GAMG;AACH,wFAFa,IAAI,CA2DhB;AAyBD;;;;;;;;;GASG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CA4BhB"}
+{"version":3,"file":"cloth_write_back.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;GAMG;AACH,wFAFa,IAAI,CAiDhB;AAyBD;;;;;;;;;GASG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CA6BhB"}