@woosh/meep-engine 3.38.0 → 3.40.0

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

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

@@ -1,7 +1,7 @@
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.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
+    v3_quaternion_apply_inverse_array
 } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import { t64_announce_change } from "../../../ecs/transform/t64_announce_change.js";
 import {
@@ -90,10 +90,9 @@ export function cloth_write_back(instance, ecd) {
     const ay = instance.anchor_translation[1];
     const az = instance.anchor_translation[2];
 
-    const aqx = instance.anchor_rotation[0];
-    const aqy = instance.anchor_rotation[1];
-    const aqz = instance.anchor_rotation[2];
-    const aqw = instance.anchor_rotation[3];
+    // The rotations go in as arrays, read where they sit: handed over as seven and eight numbers,
+    // each was boxed into a heap object wherever the call was not inlined.
+    const anchor_rotation = instance.anchor_rotation;
 
     const parent = instance.node_parent;
 
@@ -102,22 +101,13 @@ export function cloth_write_back(instance, ecd) {
 
         const n = node * 3;
 
-        v3_quaternion_apply(
-            transform, TRANSFORM64_TRANSLATION_OFFSET,
-            blended[n], blended[n + 1], blended[n + 2],
-            aqx, aqy, aqz, aqw
-        );
+        v3_quaternion_apply_array(transform, TRANSFORM64_TRANSLATION_OFFSET, blended, n, anchor_rotation, 0);
 
         transform[TRANSFORM64_TRANSLATION_OFFSET] += ax;
         transform[TRANSFORM64_TRANSLATION_OFFSET + 1] += ay;
         transform[TRANSFORM64_TRANSLATION_OFFSET + 2] += az;
 
-        quat3_multiply(
-            transform, TRANSFORM64_ROTATION_OFFSET,
-            aqx, aqy, aqz, aqw,
-            reconstructed[node * 4], reconstructed[node * 4 + 1],
-            reconstructed[node * 4 + 2], reconstructed[node * 4 + 3]
-        );
+        quat3_multiply_array(transform, TRANSFORM64_ROTATION_OFFSET, anchor_rotation, 0, reconstructed, node * 4);
 
         transform.updateMatrix();
 
@@ -164,24 +154,25 @@ export function cloth_write_local_pose(local, instance, node, parent) {
     const blended = instance.blended_position;
     const rotation = instance.blended_rotation;
 
-    const pqx = rotation[parent * 4];
-    const pqy = rotation[parent * 4 + 1];
-    const pqz = rotation[parent * 4 + 2];
-    const pqw = rotation[parent * 4 + 3];
-
-    v3_quaternion_apply_inverse(
-        local, TRANSFORM64_TRANSLATION_OFFSET,
-        blended[node * 3] - blended[parent * 3],
-        blended[node * 3 + 1] - blended[parent * 3 + 1],
-        blended[node * 3 + 2] - blended[parent * 3 + 2],
-        pqx, pqy, pqz, pqw
-    );
-
-    quat3_multiply(
-        local, TRANSFORM64_ROTATION_OFFSET,
-        -pqx, -pqy, -pqz, pqw,
-        rotation[node * 4], rotation[node * 4 + 1], rotation[node * 4 + 2], rotation[node * 4 + 3]
-    );
+    // Operands go in as arrays, the parent's rotation and the node's straight from the instance, the
+    // offset and the conjugate through scratch: handed over as seven and eight numbers, each was
+    // boxed into a heap object wherever the call was not inlined.
+    const offset = scratch_local_offset;
+
+    offset[0] = blended[node * 3] - blended[parent * 3];
+    offset[1] = blended[node * 3 + 1] - blended[parent * 3 + 1];
+    offset[2] = blended[node * 3 + 2] - blended[parent * 3 + 2];
+
+    v3_quaternion_apply_inverse_array(local, TRANSFORM64_TRANSLATION_OFFSET, offset, 0, rotation, parent * 4);
+
+    const conjugate = scratch_parent_conjugate;
+
+    conjugate[0] = -rotation[parent * 4];
+    conjugate[1] = -rotation[parent * 4 + 1];
+    conjugate[2] = -rotation[parent * 4 + 2];
+    conjugate[3] = rotation[parent * 4 + 3];
+
+    quat3_multiply_array(local, TRANSFORM64_ROTATION_OFFSET, conjugate, 0, rotation, node * 4);
 
     // `multiplyTransforms` reads the matrix, not the components, so a local
     // transform that is not refreshed here composes the pose it had last time.
@@ -218,3 +209,17 @@ function pose_pruned(instance, ecd) {
         t64_announce_change(ecd, instance.pruned_entity[i]);
     }
 }
+
+/**
+ * {@link cloth_write_local_pose}'s node position less its parent's, in the cloth's frame.
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_local_offset = new Float64Array(3);
+
+/**
+ * {@link cloth_write_local_pose}'s parent rotation, conjugated: `[-x, -y, -z, w]`.
+ * @type {Float64Array}
+ * @private
+ */
+const scratch_parent_conjugate = new Float64Array(4);

package/src/engine/physics/cloth/playground/garment_build.js

@@ -157,9 +157,9 @@ export async function build_garment({ preset, dynamics, links, spacing, collide,
     cloth.fixedUpdate(1 / 60);
 
     const bind = skeleton.joint.map(entity => {
-        const t = ecd.getComponent(entity, Transform64).translation;
+        const t = ecd.getComponent(entity, Transform64);
 
-        return [t[0], t[1], t[2]];
+        return [t.translation_x, t.translation_y, t.translation_z];
     });
 
     return {
@@ -351,13 +351,13 @@ export function garment_sync_colliders(scene) {
         const t = scene.ecd.getComponent(part.node, Transform64);
 
         part.transform.setTranslation(
-            t.translation[0] + part.offset[0],
-            t.translation[1] + part.offset[1],
-            t.translation[2] + part.offset[2]
+            t.translation_x + part.offset[0],
+            t.translation_y + part.offset[1],
+            t.translation_z + part.offset[2]
         );
 
         part.transform.setRotation(
-            t.rotation[0], t.rotation[1], t.rotation[2], t.rotation[3]
+            t.rotation_x, t.rotation_y, t.rotation_z, t.rotation_w
         );
 
         part.transform.updateMatrix();

package/src/engine/physics/cloth/playground/garment_main.js

@@ -201,9 +201,9 @@ function draw() {
  * @returns {number} depth
  */
 function project_node(node, out, width, height) {
-    const t = scene.ecd.getComponent(node, Transform64).translation;
+    const t = scene.ecd.getComponent(node, Transform64);
 
-    return project(out, camera, t[0], t[1], t[2], width, height);
+    return project(out, camera, t.translation_x, t.translation_y, t.translation_z, width, height);
 }
 
 /**
@@ -291,11 +291,15 @@ function draw_bind(width, height) {
         const parent = parent_of(node);
         const parent_index = joint.indexOf(parent);
 
-        const from = parent_index >= 0
-            ? bind[parent_index]
-            : Array.from(scene.ecd.getComponent(parent, Transform64).translation);
+        if (parent_index >= 0) {
+            const from = bind[parent_index];
 
-        project(SCREEN, camera, from[0], from[1], from[2], width, height);
+            project(SCREEN, camera, from[0], from[1], from[2], width, height);
+        } else {
+            const from = scene.ecd.getComponent(parent, Transform64);
+
+            project(SCREEN, camera, from.translation_x, from.translation_y, from.translation_z, width, height);
+        }
         project(OTHER, camera, bind[i][0], bind[i][1], bind[i][2], width, height);
 
         context.beginPath();
@@ -356,13 +360,13 @@ function draw_frames(width, height) {
     for (const node of scene.joint) {
         const t = scene.ecd.getComponent(node, Transform64);
 
-        project(SCREEN, camera, t.translation[0], t.translation[1], t.translation[2], width, height);
+        project(SCREEN, camera, t.translation_x, t.translation_y, t.translation_z, width, height);
 
         for (const [colour, x, y, z] of axes) {
-            const qx = t.rotation[0];
-            const qy = t.rotation[1];
-            const qz = t.rotation[2];
-            const qw = t.rotation[3];
+            const qx = t.rotation_x;
+            const qy = t.rotation_y;
+            const qz = t.rotation_z;
+            const qw = t.rotation_w;
 
             const tx = 2 * (qy * z - qz * y);
             const ty = 2 * (qz * x - qx * z);
@@ -374,9 +378,9 @@ function draw_frames(width, height) {
 
             project(
                 OTHER, camera,
-                t.translation[0] + dx * length,
-                t.translation[1] + dy * length,
-                t.translation[2] + dz * length,
+                t.translation_x + dx * length,
+                t.translation_y + dy * length,
+                t.translation_z + dz * length,
                 width, height
             );
 

package/src/engine/physics/cloth/solver/cloth_contact_find.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DARW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,MACN,MAAM,GAGJ,MAAM,CAqLlB;AA/RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB"}
+{"version":3,"file":"cloth_contact_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_contact_find.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DARW,YAAY,GAAC,YAAY,QACzB,UAAU,SACV,MAAM,MACN,MAAM,GAGJ,MAAM,CAwLlB;AAlSD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB"}

package/src/engine/physics/cloth/solver/cloth_contact_find.js

@@ -16,8 +16,8 @@ import {
 } from "../collider/ClothColliderRecord.js";
 import {
     cloth_collider_pose_at,
-    cloth_collider_signed_distance,
-    cloth_collider_to_local
+    cloth_collider_signed_distance_array,
+    cloth_collider_to_local_array
 } from "../collider/cloth_collider_sdf.js";
 import { CLOTH_CONTACT_SLOTS } from "./constraint/cloth_contact_row.js";
 
@@ -235,7 +235,10 @@ export function cloth_contact_find(state, table, keys, count, dt) {
                 continue;
             }
 
-            const distance = cloth_collider_signed_distance(NORMAL, 0, table, record, x, y, z);
+            // the particle where it sits, the distance beside the normal: no number crosses the call
+            cloth_collider_signed_distance_array(NORMAL, 0, table, record, position, p);
+
+            const distance = NORMAL[3];
 
             if (distance > reach) {
                 continue;
@@ -300,7 +303,7 @@ export function cloth_contact_find(state, table, keys, count, dt) {
                 friction_penalty[slot] = 0;
 
                 // A new contact sticks where the particle is now.
-                cloth_collider_to_local(anchor, slot * 3, table, record, x, y, z);
+                cloth_collider_to_local_array(anchor, slot * 3, table, record, position, p);
             }
 
             created++;
@@ -322,7 +325,7 @@ let TRAVEL = new Float64Array(0);
  * @type {Float64Array}
  * @private
  */
-const NORMAL = new Float64Array(3);
+const NORMAL = new Float64Array(4);
 
 /**
  * @type {Float64Array}

package/src/engine/physics/cloth/solver/cloth_solve_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_solve_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solve_vertex.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;GAaG;AACH,gEANW,MAAM,qBACN,MAAM,mBACN,YAAY,GAAC,YAAY,GAAC,IAAI,QA6HxC"}
+{"version":3,"file":"cloth_solve_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solve_vertex.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;GAaG;AACH,gEANW,MAAM,qBACN,MAAM,mBACN,YAAY,GAAC,YAAY,GAAC,IAAI,QAgIxC"}

package/src/engine/physics/cloth/solver/cloth_solve_vertex.js

@@ -163,11 +163,14 @@ export function cloth_solve_vertex(state, particle, inverse_h_squared, collider_
 
     // The pivots of an SPD matrix are its `H` restricted to nested subspaces,
     // so all three positive *is* positive definiteness — the same claim §5.3
-    // makes, checked where it is actually used.
-    assert.ok(
-        pivot_x > 0 && pivot_y > 0 && pivot_z > 0,
-        `cloth vertex ${particle}: H is not positive definite (pivots ${pivot_x}, ${pivot_y}, ${pivot_z}) — the SPD-by-construction argument of §5.3 has been broken`
-    );
+    // makes, checked where it is actually used. The message is built only when the check fails: as
+    // an argument it was a string of four numbers per vertex per iteration.
+    if (!(pivot_x > 0 && pivot_y > 0 && pivot_z > 0)) {
+        assert.ok(
+            false,
+            `cloth vertex ${particle}: H is not positive definite (pivots ${pivot_x}, ${pivot_y}, ${pivot_z}) — the SPD-by-construction argument of §5.3 has been broken`
+        );
+    }
 
     const force_x = accumulator[CVA_F_X];
     const force_y = accumulator[CVA_F_Y];

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AAuHA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QA8LnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA8ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAsGhB;AAxdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}
+{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AAuHA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QA+LnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA8ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAqGhB;AAxdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.js

@@ -5,9 +5,9 @@ import {
     CCR_STRIDE
 } from "../../collider/ClothColliderRecord.js";
 import {
-    cloth_collider_from_local,
-    cloth_collider_signed_distance,
-    cloth_collider_to_local
+    cloth_collider_from_local_array,
+    cloth_collider_signed_distance_array,
+    cloth_collider_to_local_array
 } from "../../collider/cloth_collider_sdf.js";
 import {
     CVA_F_X,
@@ -177,7 +177,11 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
 
         const r = record * CCR_STRIDE;
 
-        const distance = cloth_collider_signed_distance(NORMAL, 0, table, record, x, y, z);
+        // The particle goes in where it sits and the distance comes back beside the normal:
+        // handed over and back as numbers, each was boxed wherever the call was not inlined.
+        cloth_collider_signed_distance_array(NORMAL, 0, table, record, position, self);
+
+        const distance = NORMAL[3];
 
         const offset = radius + table[r + CCR_INFLATION];
 
@@ -190,7 +194,7 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
             // clamped out — and while it is, the friction anchor follows the
             // particle, so that when it *does* touch it sticks where it landed
             // rather than being dragged back to wherever it last was.
-            cloth_collider_to_local(anchor, slot * 3, table, record, x, y, z);
+            cloth_collider_to_local_array(anchor, slot * 3, table, record, position, self);
 
             friction_lambda[slot] = 0;
 
@@ -238,10 +242,7 @@ export function cloth_contact_accumulate(accumulator, state, particle, table) {
             continue;
         }
 
-        cloth_collider_from_local(
-            ANCHOR_WORLD, 0, table, record,
-            anchor[slot * 3], anchor[slot * 3 + 1], anchor[slot * 3 + 2]
-        );
+        cloth_collider_from_local_array(ANCHOR_WORLD, 0, table, record, anchor, slot * 3);
 
         const dx = x - ANCHOR_WORLD[0];
         const dy = y - ANCHOR_WORLD[1];
@@ -440,7 +441,9 @@ export function cloth_contact_dual_update(state, table, beta, k_max_ratio, inver
 
             const r = record * CCR_STRIDE;
 
-            const distance = cloth_collider_signed_distance(NORMAL, 0, table, record, x, y, z);
+            cloth_collider_signed_distance_array(NORMAL, 0, table, record, position, self);
+
+            const distance = NORMAL[3];
 
             const c = radius + table[r + CCR_INFLATION] - distance;
 
@@ -464,10 +467,7 @@ export function cloth_contact_dual_update(state, table, beta, k_max_ratio, inver
                 continue;
             }
 
-            cloth_collider_from_local(
-                ANCHOR_WORLD, 0, table, record,
-                anchor[slot * 3], anchor[slot * 3 + 1], anchor[slot * 3 + 2]
-            );
+            cloth_collider_from_local_array(ANCHOR_WORLD, 0, table, record, anchor, slot * 3);
 
             const dx = x - ANCHOR_WORLD[0];
             const dy = y - ANCHOR_WORLD[1];
@@ -515,7 +515,7 @@ function clamp_band(value, lo, hi) {
  * @type {Float64Array}
  * @private
  */
-const NORMAL = new Float64Array(3);
+const NORMAL = new Float64Array(4);
 
 /**
  * @type {Float64Array}

package/src/engine/physics/cloth/solver/find_non_finite_cloth_state.d.ts

@@ -17,6 +17,11 @@
  * carries state across steps: a multiplier that goes non-finite poisons every
  * subsequent step even after the positions that produced it have been reset.
  *
+ * Every test is `v - v === 0`, which is `Number.isFinite(v)` for a number — `v - v` is zero for any
+ * finite `v` and NaN for NaN and both infinities — without the call. Until V8 optimises this sweep,
+ * which takes a few hundred steps, `Number.isFinite` is a call into a builtin and every number handed
+ * to it is boxed into a heap object first.
+ *
  * @param {ClothState} state
  * @returns {string} "" when clean, else a description of the first non-finite value
  *

package/src/engine/physics/cloth/solver/find_non_finite_cloth_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find_non_finite_cloth_state.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/find_non_finite_cloth_state.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gEALa,MAAM,CAmFlB"}
+{"version":3,"file":"find_non_finite_cloth_state.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/find_non_finite_cloth_state.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,gEALa,MAAM,CAqGlB"}

package/src/engine/physics/cloth/solver/find_non_finite_cloth_state.js

@@ -17,6 +17,11 @@
  * carries state across steps: a multiplier that goes non-finite poisons every
  * subsequent step even after the positions that produced it have been reset.
  *
+ * Every test is `v - v === 0`, which is `Number.isFinite(v)` for a number — `v - v` is zero for any
+ * finite `v` and NaN for NaN and both infinities — without the call. Until V8 optimises this sweep,
+ * which takes a few hundred steps, `Number.isFinite` is a call into a builtin and every number handed
+ * to it is boxed into a heap object first.
+ *
  * @param {ClothState} state
  * @returns {string} "" when clean, else a description of the first non-finite value
  *
@@ -32,11 +37,15 @@ export function find_non_finite_cloth_state(state) {
     for (let i = 0; i < particle_count; i++) {
         const p = i * 3;
 
-        if (!Number.isFinite(position[p] + position[p + 1] + position[p + 2])) {
+        const position_sum = position[p] + position[p + 1] + position[p + 2];
+
+        if (!(position_sum - position_sum === 0)) {
             return `particle[${i}].position = (${position[p]}, ${position[p + 1]}, ${position[p + 2]})`;
         }
 
-        if (!Number.isFinite(velocity[p] + velocity[p + 1] + velocity[p + 2])) {
+        const velocity_sum = velocity[p] + velocity[p + 1] + velocity[p + 2];
+
+        if (!(velocity_sum - velocity_sum === 0)) {
             return `particle[${i}].velocity = (${velocity[p]}, ${velocity[p + 1]}, ${velocity[p + 2]})`;
         }
     }
@@ -47,11 +56,15 @@ export function find_non_finite_cloth_state(state) {
     const stretch_penalty = state.stretch_penalty;
 
     for (let row = 0; row < stretch_count; row++) {
-        if (!Number.isFinite(stretch_lambda[row])) {
+        const stretch_lambda_value = stretch_lambda[row];
+
+        if (!(stretch_lambda_value - stretch_lambda_value === 0)) {
             return `stretch[${row}].lambda = ${stretch_lambda[row]}`;
         }
 
-        if (!Number.isFinite(stretch_penalty[row])) {
+        const stretch_penalty_value = stretch_penalty[row];
+
+        if (!(stretch_penalty_value - stretch_penalty_value === 0)) {
             return `stretch[${row}].penalty = ${stretch_penalty[row]}`;
         }
     }
@@ -64,11 +77,15 @@ export function find_non_finite_cloth_state(state) {
     for (let row = 0; row < bend_count; row++) {
         const dual = row * 3;
 
-        if (!Number.isFinite(bend_lambda[dual] + bend_lambda[dual + 1] + bend_lambda[dual + 2])) {
+        const bend_lambda_sum = bend_lambda[dual] + bend_lambda[dual + 1] + bend_lambda[dual + 2];
+
+        if (!(bend_lambda_sum - bend_lambda_sum === 0)) {
             return `bend[${row}].lambda = (${bend_lambda[dual]}, ${bend_lambda[dual + 1]}, ${bend_lambda[dual + 2]})`;
         }
 
-        if (!Number.isFinite(bend_penalty[row])) {
+        const bend_penalty_value = bend_penalty[row];
+
+        if (!(bend_penalty_value - bend_penalty_value === 0)) {
             return `bend[${row}].penalty = ${bend_penalty[row]}`;
         }
     }
@@ -80,11 +97,15 @@ export function find_non_finite_cloth_state(state) {
     const leash_target = state.leash_target;
 
     for (let row = 0; row < leash_count; row++) {
-        if (!Number.isFinite(leash_lambda[row])) {
+        const leash_lambda_value = leash_lambda[row];
+
+        if (!(leash_lambda_value - leash_lambda_value === 0)) {
             return `leash[${row}].lambda = ${leash_lambda[row]}`;
         }
 
-        if (!Number.isFinite(leash_penalty[row])) {
+        const leash_penalty_value = leash_penalty[row];
+
+        if (!(leash_penalty_value - leash_penalty_value === 0)) {
             return `leash[${row}].penalty = ${leash_penalty[row]}`;
         }
 
@@ -95,7 +116,9 @@ export function find_non_finite_cloth_state(state) {
         // than a solve.
         const target = row * 3;
 
-        if (!Number.isFinite(leash_target[target] + leash_target[target + 1] + leash_target[target + 2])) {
+        const leash_target_sum = leash_target[target] + leash_target[target + 1] + leash_target[target + 2];
+
+        if (!(leash_target_sum - leash_target_sum === 0)) {
             return `leash[${row}].target = (${leash_target[target]}, ${leash_target[target + 1]}, ${leash_target[target + 2]})`;
         }
     }