@woosh/meep-engine 3.38.0 → 3.40.0

package/src/engine/physics/cloth/collider/cloth_collider_sdf.js

@@ -1,10 +1,10 @@
-import { sdf3_box_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_box.js";
-import { sdf3_capsule_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_capsule.js";
-import { sdf3_cylinder_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_cylinder.js";
-import { sdf3_plane_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_plane.js";
-import { sdf3_sphere_gradient } from "../../../../core/geom/3d/shape/sdf/sdf3_sphere.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 { sdf3_box_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_box.js";
+import { sdf3_capsule_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_capsule.js";
+import { sdf3_cylinder_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_cylinder.js";
+import { sdf3_plane_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_plane.js";
+import { sdf3_sphere_gradient_array } from "../../../../core/geom/3d/shape/sdf/sdf3_sphere.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_INTERP_QW,
     CCR_INTERP_QX,
@@ -15,9 +15,6 @@ import {
     CCR_INTERP_TZ,
     CCR_KIND,
     CCR_PARAM_0,
-    CCR_PARAM_1,
-    CCR_PARAM_2,
-    CCR_PARAM_3,
     CCR_PREV_QW,
     CCR_PREV_QX,
     CCR_PREV_QY,
@@ -49,9 +46,10 @@ import { ClothColliderKind } from "./ClothColliderKind.js";
  * inverts by conjugating its quaternion and subtracting its translation, which
  * costs less than storing an inverse and is exact rather than cached.
  *
- * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions
- * over scalars, so this dispatch and {@link SphereShape3D} and the rest are
- * calling one implementation (§14.1). Before M2 those shapes fell back to
+ * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions,
+ * so this dispatch, through their array forms, and {@link SphereShape3D} and
+ * the rest, through their scalar forms, are calling one implementation
+ * (§14.1). Before M2 those shapes fell back to
  * `compute_signed_distance_gradient_by_sampling` — four field evaluations and a
  * normalise, for shapes whose gradients are two lines of algebra.
  *
@@ -146,63 +144,64 @@ export function cloth_collider_pose_at(table, count, t) {
  * @returns {number} the signed distance
  */
 export function cloth_collider_signed_distance(gradient, gradient_offset, table, record, x, y, z) {
-    const r = record * CCR_STRIDE;
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
 
-    const qx = table[r + CCR_INTERP_QX];
-    const qy = table[r + CCR_INTERP_QY];
-    const qz = table[r + CCR_INTERP_QZ];
-    const qw = table[r + CCR_INTERP_QW];
+    cloth_collider_signed_distance_array(SCALAR_RESULT, 0, table, record, SCALAR_POINT, 0);
 
-    v3_quaternion_apply_inverse(
-        LOCAL_POINT, 0,
-        x - table[r + CCR_INTERP_TX],
-        y - table[r + CCR_INTERP_TY],
-        z - table[r + CCR_INTERP_TZ],
-        qx, qy, qz, qw
-    );
+    gradient[gradient_offset] = SCALAR_RESULT[0];
+    gradient[gradient_offset + 1] = SCALAR_RESULT[1];
+    gradient[gradient_offset + 2] = SCALAR_RESULT[2];
 
-    const lx = LOCAL_POINT[0];
-    const ly = LOCAL_POINT[1];
-    const lz = LOCAL_POINT[2];
+    return SCALAR_RESULT[3];
+}
 
-    const kind = table[r + CCR_KIND];
+/**
+ * {@link cloth_collider_signed_distance} with the point read from an array and the distance written
+ * beside the gradient rather than returned. For the solver's per-particle, per-iteration loops: a
+ * point handed over as three numbers, or a distance handed back as one, is boxed into a heap object
+ * wherever V8 does not inline the call.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record record index, not a slot offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, in the frame `table` is expressed in
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_signed_distance_array(out, out_offset, table, record, point, point_offset) {
+    const r = record * CCR_STRIDE;
+
+    LOCAL_POINT[0] = point[point_offset] - table[r + CCR_INTERP_TX];
+    LOCAL_POINT[1] = point[point_offset + 1] - table[r + CCR_INTERP_TY];
+    LOCAL_POINT[2] = point[point_offset + 2] - table[r + CCR_INTERP_TZ];
 
-    let distance;
+    v3_quaternion_apply_inverse_array(LOCAL_POINT, 0, LOCAL_POINT, 0, table, r + CCR_INTERP_QX);
 
+    const kind = table[r + CCR_KIND];
+
+    // A record's shape parameters sit in a row from `CCR_PARAM_0`, in the order each field's array
+    // form reads them.
     if (kind === ClothColliderKind.Sphere) {
-        distance = sdf3_sphere_gradient(LOCAL_GRADIENT, 0, lx, ly, lz, table[r + CCR_PARAM_0]);
+        sdf3_sphere_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
     } else if (kind === ClothColliderKind.Capsule) {
-        distance = sdf3_capsule_gradient(
-            LOCAL_GRADIENT, 0, lx, ly, lz,
-            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1]
-        );
+        sdf3_capsule_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
     } else if (kind === ClothColliderKind.Box) {
-        distance = sdf3_box_gradient(
-            LOCAL_GRADIENT, 0, lx, ly, lz,
-            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1], table[r + CCR_PARAM_2]
-        );
+        sdf3_box_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
     } else if (kind === ClothColliderKind.Cylinder) {
-        distance = sdf3_cylinder_gradient(
-            LOCAL_GRADIENT, 0, lx, ly, lz,
-            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1]
-        );
+        sdf3_cylinder_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
     } else {
-        distance = sdf3_plane_gradient(
-            LOCAL_GRADIENT, 0, lx, ly, lz,
-            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1], table[r + CCR_PARAM_2],
-            table[r + CCR_PARAM_3]
-        );
+        sdf3_plane_gradient_array(LOCAL_RESULT, 0, LOCAL_POINT, 0, table, r + CCR_PARAM_0);
     }
 
     // The gradient is a direction, so it takes the rotation and not the
     // translation.
-    v3_quaternion_apply(
-        gradient, gradient_offset,
-        LOCAL_GRADIENT[0], LOCAL_GRADIENT[1], LOCAL_GRADIENT[2],
-        qx, qy, qz, qw
-    );
+    v3_quaternion_apply_array(out, out_offset, LOCAL_RESULT, 0, table, r + CCR_INTERP_QX);
 
-    return distance;
+    out[out_offset + 3] = LOCAL_RESULT[3];
 }
 
 /**
@@ -222,13 +221,29 @@ export function cloth_collider_signed_distance(gradient, gradient_offset, table,
  * @returns {void}
  */
 export function cloth_collider_from_local(out, out_offset, table, record, x, y, z) {
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    cloth_collider_from_local_array(out, out_offset, table, record, SCALAR_POINT, 0);
+}
+
+/**
+ * {@link cloth_collider_from_local} with the point read from an array, for the same reason as
+ * {@link cloth_collider_signed_distance_array}. `out` may be `point`.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, local
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_from_local_array(out, out_offset, table, record, point, point_offset) {
     const r = record * CCR_STRIDE;
 
-    v3_quaternion_apply(
-        out, out_offset, x, y, z,
-        table[r + CCR_INTERP_QX], table[r + CCR_INTERP_QY],
-        table[r + CCR_INTERP_QZ], table[r + CCR_INTERP_QW]
-    );
+    v3_quaternion_apply_array(out, out_offset, point, point_offset, table, r + CCR_INTERP_QX);
 
     out[out_offset] += table[r + CCR_INTERP_TX];
     out[out_offset + 1] += table[r + CCR_INTERP_TY];
@@ -250,26 +265,59 @@ export function cloth_collider_from_local(out, out_offset, table, record, x, y,
  * @returns {void}
  */
 export function cloth_collider_to_local(out, out_offset, table, record, x, y, z) {
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    cloth_collider_to_local_array(out, out_offset, table, record, SCALAR_POINT, 0);
+}
+
+/**
+ * {@link cloth_collider_to_local} with the point read from an array, for the same reason as
+ * {@link cloth_collider_signed_distance_array}. `out` may be `point`.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, in the frame `table` is expressed in
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_to_local_array(out, out_offset, table, record, point, point_offset) {
     const r = record * CCR_STRIDE;
 
-    v3_quaternion_apply_inverse(
-        out, out_offset,
-        x - table[r + CCR_INTERP_TX],
-        y - table[r + CCR_INTERP_TY],
-        z - table[r + CCR_INTERP_TZ],
-        table[r + CCR_INTERP_QX], table[r + CCR_INTERP_QY],
-        table[r + CCR_INTERP_QZ], table[r + CCR_INTERP_QW]
-    );
+    LOCAL_POINT[0] = point[point_offset] - table[r + CCR_INTERP_TX];
+    LOCAL_POINT[1] = point[point_offset + 1] - table[r + CCR_INTERP_TY];
+    LOCAL_POINT[2] = point[point_offset + 2] - table[r + CCR_INTERP_TZ];
+
+    v3_quaternion_apply_inverse_array(out, out_offset, LOCAL_POINT, 0, table, r + CCR_INTERP_QX);
 }
 
 /**
+ * A collider's field at a point in its own frame, `[gx, gy, gz, distance]`, as the fields' array
+ * forms write it.
  * @type {Float64Array}
  * @private
  */
-const LOCAL_GRADIENT = new Float64Array(3);
+const LOCAL_RESULT = new Float64Array(4);
 
 /**
  * @type {Float64Array}
  * @private
  */
 const LOCAL_POINT = new Float64Array(3);
+
+/**
+ * The scalar forms' point, packed for the array forms they delegate to.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_POINT = new Float64Array(3);
+
+/**
+ * {@link cloth_collider_signed_distance}'s gradient and distance, as the array form writes them.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_RESULT = new Float64Array(4);

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

@@ -1 +1 @@
-{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;;;;;;;;;;;;;;OAeG;IACH,QAFU;QAAC,WAAW,SAAW,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC,CAAA;KAAC,GAAC,IAAI,CAEvD;IAEd;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;OAKG;IACH,2CAiBC;IAED;;;;;OAKG;IACH,YALW,KAAK,kCAEL,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAanC;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAwFD;;;;;;;;;;;OAWG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CAmPnB;;CA8EJ;8BAp/B6B,oBAAoB;0CAjB3C,gEAAgE;oCAcnC,0BAA0B;sBA4BxC,YAAY"}
+{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;;;;;;;;;;;;;;OAeG;IACH,QAFU;QAAC,WAAW,SAAW,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC,CAAA;KAAC,GAAC,IAAI,CAEvD;IAEd;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;OAKG;IACH,2CAiBC;IAED;;;;;OAKG;IACH,YALW,KAAK,kCAEL,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAanC;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAwFD;;;;;;;;;;;OAWG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CA0PnB;;CA8EJ;8BA3/B6B,oBAAoB;0CAjB3C,gEAAgE;oCAcnC,0BAA0B;sBA4BxC,YAAY"}

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

@@ -1,8 +1,8 @@
 import { assert } from "../../../../core/assert.js";
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { quat3_nlerp } from "../../../../core/geom/3d/quaternion/quat3_nlerp.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 { quat3_nlerp_array } from "../../../../core/geom/3d/quaternion/quat3_nlerp.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 { EntityObserver } from "../../../ecs/EntityObserver.js";
 import {
     TransformAttachment
@@ -832,11 +832,17 @@ export class ClothWorld {
             if (teleport) {
                 this.#teleport(instance);
             } else {
-                move_local_frame(
-                    instance,
-                    tx, ty, tz, qx, qy, qz, qw,
-                    previous_translation, previous_rotation
-                );
+                // the new pose goes in as an array: handed over as seven numbers, each was boxed
+                // wherever the call was not inlined
+                ANCHOR_POSE[0] = tx;
+                ANCHOR_POSE[1] = ty;
+                ANCHOR_POSE[2] = tz;
+                ANCHOR_POSE[3] = qx;
+                ANCHOR_POSE[4] = qy;
+                ANCHOR_POSE[5] = qz;
+                ANCHOR_POSE[6] = qw;
+
+                move_local_frame(instance, ANCHOR_POSE, previous_translation, previous_rotation);
             }
         } else if (instance.anchor_valid && instance.cloth.dynamics.inertia > 0) {
             // The frame is identical. Preserve the pinning side effect of
@@ -862,7 +868,8 @@ export class ClothWorld {
         // Gravity is a world vector and the solve is in the anchor's frame.
         const gravity = this.gravity;
 
-        v3_quaternion_apply_inverse(LOCAL_GRAVITY, 0, gravity[0], gravity[1], gravity[2], qx, qy, qz, qw);
+        // `previous_rotation` has just been set to this step's `q`; vector and rotation go in as arrays
+        v3_quaternion_apply_inverse_array(LOCAL_GRAVITY, 0, gravity, 0, previous_rotation, 0);
 
         const state = instance.state;
 
@@ -1060,6 +1067,28 @@ const LOCAL_GRAVITY = new Float64Array(3);
  */
 const FRAME = new Float64Array(8);
 
+/**
+ * The anchor's pose this step, `[tx, ty, tz, qx, qy, qz, qw]`, as {@link move_local_frame} takes it.
+ * @type {Float64Array}
+ * @private
+ */
+const ANCHOR_POSE = new Float64Array(7);
+
+/**
+ * {@link move_local_frame}'s `q_now⁻¹`, `[-qx, -qy, -qz, qw]`.
+ * @type {Float64Array}
+ * @private
+ */
+const POSE_CONJUGATE = new Float64Array(4);
+
+/**
+ * The identity rotation, `[0, 0, 0, 1]`, which {@link move_local_frame} limits a turn towards. Never
+ * written.
+ * @type {Float64Array}
+ * @private
+ */
+const IDENTITY_ROTATION = new Float64Array([0, 0, 0, 1]);
+
 /**
  * Carry the particles across a change of anchor pose, by however much of it the
  * fabric is willing to feel. §7 P7.
@@ -1076,23 +1105,17 @@ const FRAME = new Float64Array(8);
  * teleports a metre — or spins — something a cape *lags behind* rather than
  * something it is fired out of.
  *
+ * Every vector and quaternion 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
+ * is every call, twice per particle per step of a moving anchor.
+ *
  * @param {ClothInstance} instance
- * @param {number} tx
- * @param {number} ty
- * @param {number} tz
- * @param {number} qx
- * @param {number} qy
- * @param {number} qz
- * @param {number} qw
+ * @param {Float64Array} pose the anchor's pose now, `[tx, ty, tz, qx, qy, qz, qw]`
  * @param {Float64Array} previous_translation
  * @param {Float64Array} previous_rotation
  * @private
  */
-function move_local_frame(
-    instance,
-    tx, ty, tz, qx, qy, qz, qw,
-    previous_translation, previous_rotation
-) {
+function move_local_frame(instance, pose, previous_translation, previous_rotation) {
     let inertia = instance.cloth.dynamics.inertia;
 
     if (inertia <= 0) {
@@ -1103,13 +1126,11 @@ function move_local_frame(
         inertia = 1;
     }
 
-    v3_quaternion_apply_inverse(
-        FRAME, 0,
-        previous_translation[0] - tx,
-        previous_translation[1] - ty,
-        previous_translation[2] - tz,
-        qx, qy, qz, qw
-    );
+    FRAME[0] = previous_translation[0] - pose[0];
+    FRAME[1] = previous_translation[1] - pose[1];
+    FRAME[2] = previous_translation[2] - pose[2];
+
+    v3_quaternion_apply_inverse_array(FRAME, 0, FRAME, 0, pose, 3);
 
     const travel_limit = CLOTH_ANCHOR_TRAVEL_REACH * instance.reach;
 
@@ -1123,11 +1144,12 @@ function move_local_frame(
         FRAME[2] *= scale;
     }
 
-    quat3_multiply(
-        FRAME, 4,
-        -qx, -qy, -qz, qw,
-        previous_rotation[0], previous_rotation[1], previous_rotation[2], previous_rotation[3]
-    );
+    POSE_CONJUGATE[0] = -pose[3];
+    POSE_CONJUGATE[1] = -pose[4];
+    POSE_CONJUGATE[2] = -pose[5];
+    POSE_CONJUGATE[3] = pose[6];
+
+    quat3_multiply_array(FRAME, 4, POSE_CONJUGATE, 0, previous_rotation, 0);
 
     // `|w|` is `cos(θ/2)`, so this is the angle test without an `acos`.
     const half_angle_cos = FRAME[7] < 0 ? -FRAME[7] : FRAME[7];
@@ -1135,12 +1157,7 @@ function move_local_frame(
     if (half_angle_cos < Math.cos(CLOTH_ANCHOR_ROTATION_LIMIT * 0.5)) {
         const angle = 2 * Math.acos(half_angle_cos > 1 ? 1 : half_angle_cos);
 
-        quat3_nlerp(
-            FRAME, 4,
-            0, 0, 0, 1,
-            FRAME[4], FRAME[5], FRAME[6], FRAME[7],
-            CLOTH_ANCHOR_ROTATION_LIMIT / angle
-        );
+        quat3_nlerp_array(FRAME, 4, IDENTITY_ROTATION, 0, FRAME, 4, CLOTH_ANCHOR_ROTATION_LIMIT / angle);
     }
 
     const state = instance.state;
@@ -1154,21 +1171,16 @@ function move_local_frame(
     const dy = FRAME[1];
     const dz = FRAME[2];
 
-    const rx = FRAME[4];
-    const ry = FRAME[5];
-    const rz = FRAME[6];
-    const rw = FRAME[7];
-
     for (let i = 0; i < particle_count; i++) {
         const p = i * 3;
 
-        v3_quaternion_apply(CARRIED, 0, position[p], position[p + 1], position[p + 2], rx, ry, rz, rw);
+        v3_quaternion_apply_array(CARRIED, 0, position, p, FRAME, 4);
 
         position[p] += inertia * (CARRIED[0] + dx - position[p]);
         position[p + 1] += inertia * (CARRIED[1] + dy - position[p + 1]);
         position[p + 2] += inertia * (CARRIED[2] + dz - position[p + 2]);
 
-        v3_quaternion_apply(CARRIED, 0, velocity[p], velocity[p + 1], velocity[p + 2], rx, ry, rz, rw);
+        v3_quaternion_apply_array(CARRIED, 0, velocity, p, FRAME, 4);
 
         velocity[p] += inertia * (CARRIED[0] - velocity[p]);
         velocity[p + 1] += inertia * (CARRIED[1] - velocity[p + 1]);

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_gather_colliders.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_gather_colliders.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qFAHW,MAAM,GACJ,MAAM,CAsBlB;AAyJD;;;;;;GAMG;AACH,kGAHW,MAAM,GACJ,MAAM,CAmBlB;AAgGD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2FAFa,OAAO,CAkBnB;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,IAAI,CAgBhB"}
+{"version":3,"file":"cloth_gather_colliders.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_gather_colliders.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qFAHW,MAAM,GACJ,MAAM,CAsBlB;AAyJD;;;;;;GAMG;AACH,kGAHW,MAAM,GACJ,MAAM,CAmBlB;AAwFD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2FAFa,OAAO,CAkBnB;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,IAAI,CAgBhB"}

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

@@ -1,6 +1,6 @@
-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,
@@ -200,10 +200,7 @@ function query_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))
@@ -230,13 +227,13 @@ function query_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;
@@ -252,11 +249,14 @@ function query_colliders(instance, index, reach) {
 
     const cloth = instance.cloth;
 
-    const candidates = 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, true
-    );
+    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
@@ -339,13 +339,8 @@ export function cloth_gather_colliders(instance, index, reach) {
  * @private
  */
 function localise_record(table, record, source, handle, instance) {
-    const anchor_x = instance.anchor_translation[0];
-    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_translation = instance.anchor_translation;
+    const anchor_rotation = instance.anchor_rotation;
     const from = handle * CCR_STRIDE;
     const to = record * CCR_STRIDE;
 
@@ -360,17 +355,14 @@ function localise_record(table, record, source, handle, instance) {
 
     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
+        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], 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
+        source, from + CCR_PREV_TX, from + CCR_PREV_QX,
+        anchor_translation, anchor_rotation
     );
 
     cloth_collider_refit_bounds(table, record, CCR_STRIDE);
@@ -380,41 +372,41 @@ function localise_record(table, record, source, handle, instance) {
  * 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];
@@ -519,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"}