@woosh/meep-engine 3.44.0 → 3.46.0

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

@@ -1,6 +1,6 @@
-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 { aabb3_from_v3_array } from "../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
+import { aabb3_transform_oriented_array } from "../../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
+import { pose3_to_local_array } from "../../../../core/geom/3d/pose/pose3_to_local_array.js";
 import {
     CCR_AABB_MAX_X,
     CCR_AABB_MAX_Y,
@@ -16,17 +16,11 @@ import {
     CCR_PARAM_1,
     CCR_PARAM_2,
     CCR_PARAM_3,
-    CCR_PREV_QW,
     CCR_PREV_QX,
-    CCR_PREV_QY,
-    CCR_PREV_QZ,
     CCR_PREV_TX,
     CCR_PREV_TY,
     CCR_PREV_TZ,
-    CCR_QW,
     CCR_QX,
-    CCR_QY,
-    CCR_QZ,
     CCR_STRIDE,
     CCR_TX,
     CCR_TY,
@@ -167,32 +161,19 @@ function query_colliders(instance, index, reach) {
     const particle_count = state.particle_count;
     const position = state.position;
 
-    let min_x = Infinity;
-    let min_y = Infinity;
-    let min_z = Infinity;
-    let max_x = -Infinity;
-    let max_y = -Infinity;
-    let max_z = -Infinity;
-
-    for (let i = 0; i < particle_count; i++) {
-        const p = i * 3;
-
-        const x = position[p];
-        const y = position[p + 1];
-        const z = position[p + 2];
-
-        if (x < min_x) { min_x = x; }
-        if (y < min_y) { min_y = y; }
-        if (z < min_z) { min_z = z; }
-        if (x > max_x) { max_x = x; }
-        if (y > max_y) { max_y = y; }
-        if (z > max_z) { max_z = z; }
-    }
-
     if (particle_count === 0) {
         return 0;
     }
 
+    aabb3_from_v3_array(LOCAL_BOX, position, particle_count * 3);
+
+    let min_x = LOCAL_BOX[0];
+    let min_y = LOCAL_BOX[1];
+    let min_z = LOCAL_BOX[2];
+    let max_x = LOCAL_BOX[3];
+    let max_y = LOCAL_BOX[4];
+    let max_z = LOCAL_BOX[5];
+
     // The frame 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.
@@ -216,46 +197,29 @@ function query_colliders(instance, index, reach) {
     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
-    // rotation of the bounds.
-    let world_min_x = Infinity;
-    let world_min_y = Infinity;
-    let world_min_z = Infinity;
-    let world_max_x = -Infinity;
-    let world_max_y = -Infinity;
-    let world_max_z = -Infinity;
-
-    for (let corner = 0; corner < 8; corner++) {
-        // 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, frame_rotation, 0);
-
-        const x = CORNER[0] + frame_x;
-        const y = CORNER[1] + frame_y;
-        const z = CORNER[2] + frame_z;
-
-        if (x < world_min_x) { world_min_x = x; }
-        if (y < world_min_y) { world_min_y = y; }
-        if (z < world_min_z) { world_min_z = z; }
-        if (x > world_max_x) { world_max_x = x; }
-        if (y > world_max_y) { world_max_y = y; }
-        if (z > world_max_z) { world_max_z = z; }
-    }
+    LOCAL_BOX[0] = min_x;
+    LOCAL_BOX[1] = min_y;
+    LOCAL_BOX[2] = min_z;
+    LOCAL_BOX[3] = max_x;
+    LOCAL_BOX[4] = max_y;
+    LOCAL_BOX[5] = max_z;
+
+    // The frame pose as the seven contiguous numbers the transform reads,
+    // translation then rotation; the instance keeps the two apart.
+    FRAME_POSE[0] = frame_x;
+    FRAME_POSE[1] = frame_y;
+    FRAME_POSE[2] = frame_z;
+    FRAME_POSE[3] = frame_rotation[0];
+    FRAME_POSE[4] = frame_rotation[1];
+    FRAME_POSE[5] = frame_rotation[2];
+    FRAME_POSE[6] = frame_rotation[3];
+
+    // A rotated box is not a box, so the world query volume is the bounds of
+    // the rotated one rather than the rotation of the bounds.
+    aabb3_transform_oriented_array(QUERY_BOX, 0, LOCAL_BOX, 0, FRAME_POSE, 0);
 
     const cloth = instance.cloth;
 
-    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
@@ -391,27 +355,14 @@ function localise(
     source, source_translation_slot, source_rotation_slot,
     frame_translation, frame_rotation
 ) {
-    LOCAL_TRANSLATION[0] = source[source_translation_slot] - frame_translation[0];
-    LOCAL_TRANSLATION[1] = source[source_translation_slot + 1] - frame_translation[1];
-    LOCAL_TRANSLATION[2] = source[source_translation_slot + 2] - frame_translation[2];
-
-    v3_quaternion_apply_inverse_array(LOCAL_TRANSLATION, 0, LOCAL_TRANSLATION, 0, frame_rotation, 0);
-
-    table[translation_slot] = LOCAL_TRANSLATION[0];
-    table[translation_slot + 1] = LOCAL_TRANSLATION[1];
-    table[translation_slot + 2] = LOCAL_TRANSLATION[2];
-
-    FRAME_CONJUGATE[0] = -frame_rotation[0];
-    FRAME_CONJUGATE[1] = -frame_rotation[1];
-    FRAME_CONJUGATE[2] = -frame_rotation[2];
-    FRAME_CONJUGATE[3] = frame_rotation[3];
-
-    quat3_multiply_array(LOCAL_ROTATION, 0, FRAME_CONJUGATE, 0, source, source_rotation_slot);
-
-    table[rotation_slot] = LOCAL_ROTATION[0];
-    table[rotation_slot + 1] = LOCAL_ROTATION[1];
-    table[rotation_slot + 2] = LOCAL_ROTATION[2];
-    table[rotation_slot + 3] = LOCAL_ROTATION[3];
+    pose3_to_local_array(
+        table, translation_slot,
+        table, rotation_slot,
+        frame_translation, 0,
+        frame_rotation, 0,
+        source, source_translation_slot,
+        source, source_rotation_slot
+    );
 }
 
 /**
@@ -495,29 +446,18 @@ const HANDLES = [];
 const PLANE_RECORD = new Float32Array(CCR_STRIDE);
 
 /**
+ * The cloth's particle bounds, then the same fattened by the query margin, in its local frame.
  * @type {Float64Array}
  * @private
  */
-const CORNER = new Float64Array(3);
-
-/**
- * @type {Float64Array}
- * @private
- */
-const LOCAL_TRANSLATION = new Float64Array(3);
-
-/**
- * @type {Float64Array}
- * @private
- */
-const LOCAL_ROTATION = new Float64Array(4);
+const LOCAL_BOX = new Float64Array(6);
 
 /**
- * The anchor's rotation conjugated, `[-x, -y, -z, w]`: {@link localise}'s left operand.
+ * The cloth's frame pose, `[px, py, pz, qx, qy, qz, qw]`, for {@link aabb3_transform_oriented_array}.
  * @type {Float64Array}
  * @private
  */
-const FRAME_CONJUGATE = new Float64Array(4);
+const FRAME_POSE = new Float64Array(7);
 
 /**
  * The world box {@link query_colliders} asks the index about, `[min_x, min_y, min_z, max_x, max_y,

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_geodesic.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_geodesic.js"],"names":[],"mappings":"AAsCA;;;;;;;GAOG;AACH,iDALW,MAAM,QACN,UAAU,GACR;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,CAyBlD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mDAXW,YAAY,eACZ,UAAU,cACV,MAAM,QACN,UAAU,eACV,YAAY,aACZ;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,UACtC,UAAU,GAAC,MAAM,EAAE,gBACnB,MAAM,WACN,UAAU,GAAC,IAAI,QAsDzB"}
+{"version":3,"file":"cloth_geodesic.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_geodesic.js"],"names":[],"mappings":"AAuCA;;;;;;;GAOG;AACH,iDALW,MAAM,QACN,UAAU,GACR;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,CAiBlD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mDAXW,YAAY,eACZ,UAAU,cACV,MAAM,QACN,UAAU,eACV,YAAY,aACZ;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,UACtC,UAAU,GAAC,MAAM,EAAE,gBACnB,MAAM,WACN,UAAU,GAAC,IAAI,QAsDzB"}

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

@@ -1,4 +1,5 @@
 import { Uint32Heap } from "../../../../core/collection/heap/Uint32Heap.js";
+import { csr_build_incidence } from "../../../../core/graph/csr/csr_build_incidence.js";
 
 /**
  * # How far each particle is from a set of particles, along the fabric
@@ -48,21 +49,13 @@ export function cloth_edge_incidence(node_count, edge) {
     const edge_count = edge.length >> 1;
 
     const offset = new Int32Array(node_count + 1);
-
-    for (let i = 0; i < edge_count * 2; i++) {
-        offset[edge[i] + 1]++;
-    }
-
-    for (let n = 0; n < node_count; n++) {
-        offset[n + 1] += offset[n];
-    }
-
     const incident = new Int32Array(edge_count * 2);
-    const cursor = offset.slice(0, node_count);
 
-    for (let e = 0; e < edge_count; e++) {
-        incident[cursor[edge[e * 2]]++] = e;
-        incident[cursor[edge[e * 2 + 1]]++] = e;
+    csr_build_incidence(offset, incident, edge, edge_count * 2, node_count);
+
+    // an endpoint's flat index `e·2 + k` to its edge `e`
+    for (let i = 0; i < edge_count * 2; i++) {
+        incident[i] >>= 1;
     }
 
     return { offset, edge: incident };

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_holds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_holds.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,gGAJW,YAAY,kBACZ,YAAY,GACV,IAAI,CA6ChB;AAED;;;;;;;;;;;GAWG;AACH,4DAFa,IAAI,CA0KhB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAFa,IAAI,CA2KhB"}
+{"version":3,"file":"cloth_holds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_holds.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,gGAJW,YAAY,kBACZ,YAAY,GACV,IAAI,CAyChB;AAED;;;;;;;;;;;GAWG;AACH,4DAFa,IAAI,CA0KhB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAFa,IAAI,CA+JhB"}

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

@@ -1,6 +1,11 @@
-import { quat3_multiply, 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 { array_range_equal_strict } from "../../../../core/collection/array/array_range_equal_strict.js";
+import { pose3_apply_inverse_point_array } from "../../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
+import { pose3_apply_point_array } from "../../../../core/geom/3d/pose/pose3_apply_point_array.js";
+import { quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import {
+    quat3_multiply_conjugate_right_array
+} from "../../../../core/geom/3d/quaternion/quat3_multiply_conjugate_right_array.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
 import { CLOTH_PARTICLE_MASS, CLOTH_SLACK_REACH } from "./cloth_build_rows.js";
 import { cloth_geodesic_field } from "./cloth_geodesic.js";
 
@@ -90,14 +95,10 @@ export function cloth_capture_hold(instance, hold, frame_translation, frame_rota
         const p = particle_of_node[node] * 3;
 
         // the particle in the world
-        v3_quaternion_apply_array(SCRATCH, 0, position, p, frame_rotation, 0);
-
-        SCRATCH[0] += frame_translation[0] - world[0];
-        SCRATCH[1] += frame_translation[1] - world[1];
-        SCRATCH[2] += frame_translation[2] - world[2];
+        pose3_apply_point_array(SCRATCH, 0, frame_translation, 0, frame_rotation, 0, position, p);
 
         // relative to the holder, in its frame
-        v3_quaternion_apply_inverse_array(offset, k * 3, SCRATCH, 0, world, 3);
+        pose3_apply_inverse_point_array(offset, k * 3, world, 0, world, 3, SCRATCH, 0);
     }
 
     hold.offset = offset;
@@ -344,11 +345,7 @@ export function cloth_hold_step(instance) {
         const at = hold.rotation_at_hold;
         const pose = hold.pose;
 
-        quat3_multiply(
-            turn, h * 4,
-            pose[3], pose[4], pose[5], pose[6],
-            -at[0], -at[1], -at[2], at[3]
-        );
+        quat3_multiply_conjugate_right_array(turn, h * 4, pose, 3, at, 0);
     }
 
     const target = instance.held_target;
@@ -368,11 +365,7 @@ export function cloth_hold_step(instance) {
 
         const n = node * 3;
 
-        v3_quaternion_apply_array(target, n, hold.offset, node_hold_slot[node] * 3, pose, 3);
-
-        target[n] += pose[0];
-        target[n + 1] += pose[1];
-        target[n + 2] += pose[2];
+        pose3_apply_point_array(target, n, pose, 0, pose, 3, hold.offset, node_hold_slot[node] * 3);
 
         const p = particle_of_node[node] * 3;
 
@@ -437,11 +430,7 @@ export function cloth_hold_step(instance) {
         SCRATCH[1] = rest[n + 1] - rest[m + 1];
         SCRATCH[2] = rest[n + 2] - rest[m + 2];
 
-        v3_quaternion_apply_array(animated, n, SCRATCH, 0, turn, t);
-
-        animated[n] += target[m];
-        animated[n + 1] += target[m + 1];
-        animated[n + 2] += target[m + 2];
+        pose3_apply_point_array(animated, n, target, m, turn, t, SCRATCH, 0);
 
         quat3_multiply_array(animated_rotation, r, turn, t, rest_rotation, r);
     }
@@ -499,13 +488,8 @@ function holds_still(holds) {
             return false;
         }
 
-        const pose = hold.pose;
-        const before = hold.pose_previous;
-
-        for (let i = 0; i < 7; i++) {
-            if (pose[i] !== before[i]) {
-                return false;
-            }
+        if (!array_range_equal_strict(hold.pose, 0, hold.pose_previous, 0, 7)) {
+            return false;
         }
     }
 
@@ -584,15 +568,6 @@ function cloth_tether_ratchet(instance) {
     }
 }
 
-/**
- * @param {number} v
- * @returns {number}
- * @private
- */
-function clamp01(v) {
-    return v < 0 ? 0 : (v > 1 ? 1 : v);
-}
-
 /**
  * @type {Float64Array}
  * @private

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":"AA6EA;;;;;;;;;;GAUG;AACH,iEAFa,IAAI,CAyEhB"}
+{"version":3,"file":"cloth_reconstruct_pose.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_reconstruct_pose.js"],"names":[],"mappings":"AAyFA;;;;;;;;;;GAUG;AACH,iEAFa,IAAI,CAmEhB"}

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

@@ -1,7 +1,11 @@
 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";
+import { tri3_compute_normal_area_weighted_array } from "../../../../core/geom/3d/triangle/tri3_compute_normal_area_weighted_array.js";
+import { v3_normalize_array_checked } from "../../../../core/geom/vec3/v3_normalize_array_checked.js";
 import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_reject_array } from "../../../../core/geom/vec3/v3_reject_array.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
 
 /**
  * # From particles to a pose — the half of the write-back that is arithmetic
@@ -75,6 +79,14 @@ const SWING_TWIST = 12;
  */
 const DIRECTION = new Float64Array(12);
 
+/**
+ * Squared length below which a direction in {@link DIRECTION} is rounding
+ * rather than a direction, and is left as it was.
+ * @type {number}
+ * @private
+ */
+const NO_DIRECTION_SQR = 1e-24;
+
 /**
  * Fill `blended_position` and `blended_rotation` from the solved particles.
  *
@@ -95,13 +107,7 @@ export function cloth_reconstruct_pose(instance) {
     const blended = instance.blended_position;
     const animated = instance.animated_position;
 
-    let blend = instance.cloth.blend;
-
-    if (blend < 0) {
-        blend = 0;
-    } else if (blend > 1) {
-        blend = 1;
-    }
+    const blend = clamp01(instance.cloth.blend);
 
     const position = state.position;
 
@@ -175,7 +181,9 @@ function surface_turn(instance, node, out) {
     surface_normal(DIRECTION, 0, instance, animated, node);
     surface_normal(DIRECTION, 3, instance, blended, node);
 
-    const has_normal = unit(DIRECTION, 0) && unit(DIRECTION, 3);
+    const has_normal =
+        v3_normalize_array_checked(DIRECTION, 0, DIRECTION, 0, NO_DIRECTION_SQR) &&
+        v3_normalize_array_checked(DIRECTION, 3, DIRECTION, 3, NO_DIRECTION_SQR);
 
     // the swing: normal onto normal
     if (has_normal) {
@@ -203,11 +211,14 @@ function surface_turn(instance, node, out) {
     if (has_normal) {
         // both into the plane the normal leaves them, so the arc between them
         // turns about the normal and nothing else
-        reject(DIRECTION, 6, DIRECTION, 3);
-        reject(DIRECTION, 9, DIRECTION, 3);
+        v3_reject_array(DIRECTION, 6, DIRECTION, 6, DIRECTION, 3);
+        v3_reject_array(DIRECTION, 9, DIRECTION, 9, DIRECTION, 3);
     }
 
-    if (!unit(DIRECTION, 6) || !unit(DIRECTION, 9)) {
+    if (
+        !v3_normalize_array_checked(DIRECTION, 6, DIRECTION, 6, NO_DIRECTION_SQR) ||
+        !v3_normalize_array_checked(DIRECTION, 9, DIRECTION, 9, NO_DIRECTION_SQR)
+    ) {
         return;
     }
 
@@ -217,6 +228,13 @@ function surface_turn(instance, node, out) {
     quat3_multiply_array(SWING, out, SWING, SWING_TWIST, SWING, out);
 }
 
+/**
+ * One triangle's area-weighted normal, before it is summed.
+ * @type {Float64Array}
+ * @private
+ */
+const FACE_NORMAL = new Float64Array(3);
+
 /**
  * The area-weighted normal of the triangles around a node, unnormalised, into
  * `out` at `offset`.
@@ -237,22 +255,17 @@ function surface_normal(out, offset, instance, position, node) {
     for (let k = instance.surface_offset[node]; k < instance.surface_offset[node + 1]; k++) {
         const t = surface[k] * 3;
 
-        const a = triangle[t] * 3;
-        const b = triangle[t + 1] * 3;
-        const c = triangle[t + 2] * 3;
-
-        const ux = position[b] - position[a];
-        const uy = position[b + 1] - position[a + 1];
-        const uz = position[b + 2] - position[a + 2];
-
-        const vx = position[c] - position[a];
-        const vy = position[c + 1] - position[a + 1];
-        const vz = position[c + 2] - position[a + 2];
-
         // twice the area, along the normal: the weighting is the cross product's own length
-        nx += uy * vz - uz * vy;
-        ny += uz * vx - ux * vz;
-        nz += ux * vy - uy * vx;
+        tri3_compute_normal_area_weighted_array(
+            FACE_NORMAL, 0,
+            position, triangle[t] * 3,
+            position, triangle[t + 1] * 3,
+            position, triangle[t + 2] * 3
+        );
+
+        nx += FACE_NORMAL[0];
+        ny += FACE_NORMAL[1];
+        nz += FACE_NORMAL[2];
     }
 
     out[offset] = nx;
@@ -260,24 +273,6 @@ function surface_normal(out, offset, instance, position, node) {
     out[offset + 2] = nz;
 }
 
-/**
- * Remove from the vector at `offset` its part along the unit vector at
- * `normal_offset`.
- *
- * @param {Float64Array} v
- * @param {number} offset
- * @param {Float64Array} n
- * @param {number} normal_offset
- * @private
- */
-function reject(v, offset, n, normal_offset) {
-    const d = v[offset] * n[normal_offset] + v[offset + 1] * n[normal_offset + 1] + v[offset + 2] * n[normal_offset + 2];
-
-    v[offset] -= d * n[normal_offset];
-    v[offset + 1] -= d * n[normal_offset + 1];
-    v[offset + 2] -= d * n[normal_offset + 2];
-}
-
 /**
  * @type {Float64Array}
  * @private
@@ -310,8 +305,8 @@ function link_swing(instance, from, to, out) {
     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);
+    const has_animated = v3_normalize_array_checked(DIRECTION, 0, DIRECTION, 0, NO_DIRECTION_SQR);
+    const has_blended = v3_normalize_array_checked(DIRECTION, 3, DIRECTION, 3, NO_DIRECTION_SQR);
 
     if (!has_animated || !has_blended) {
         identity(out);
@@ -363,7 +358,7 @@ function children_swing(instance, node, out) {
         DIRECTION[7] = animated[b + 1] - animated[a + 1];
         DIRECTION[8] = animated[b + 2] - animated[a + 2];
 
-        if (unit(DIRECTION, 6)) {
+        if (v3_normalize_array_checked(DIRECTION, 6, DIRECTION, 6, NO_DIRECTION_SQR)) {
             anim_x += DIRECTION[6];
             anim_y += DIRECTION[7];
             anim_z += DIRECTION[8];
@@ -373,7 +368,7 @@ function children_swing(instance, node, out) {
         DIRECTION[10] = blended[b + 1] - blended[a + 1];
         DIRECTION[11] = blended[b + 2] - blended[a + 2];
 
-        if (unit(DIRECTION, 9)) {
+        if (v3_normalize_array_checked(DIRECTION, 9, DIRECTION, 9, NO_DIRECTION_SQR)) {
             sim_x += DIRECTION[9];
             sim_y += DIRECTION[10];
             sim_z += DIRECTION[11];
@@ -388,8 +383,8 @@ function children_swing(instance, node, out) {
     DIRECTION[4] = sim_y;
     DIRECTION[5] = sim_z;
 
-    const has_animated = unit(DIRECTION, 0);
-    const has_blended = unit(DIRECTION, 3);
+    const has_animated = v3_normalize_array_checked(DIRECTION, 0, DIRECTION, 0, NO_DIRECTION_SQR);
+    const has_blended = v3_normalize_array_checked(DIRECTION, 3, DIRECTION, 3, NO_DIRECTION_SQR);
 
     if (!has_animated || !has_blended) {
         // Branches that cancel — a node with two children pointing opposite
@@ -405,35 +400,6 @@ function children_swing(instance, node, out) {
     return true;
 }
 
-/**
- * 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
- * @returns {boolean}
- * @private
- */
-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) {
-        return false;
-    }
-
-    const inverse = 1 / Math.sqrt(length_squared);
-
-    out[offset] = x * inverse;
-    out[offset + 1] = y * inverse;
-    out[offset + 2] = z * inverse;
-
-    return true;
-}
-
 /**
  * @param {number} offset
  * @private

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_seed_subtree.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_seed_subtree.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH;;;;;;;;;GASG;AACH,6CAPW,aAAa,2EAGb,MAAM,GAEJ,IAAI,CAqHhB;AA8GD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAJW,aAAa,gCAEX,IAAI,CAkChB;8BAhW6B,oBAAoB"}
+{"version":3,"file":"cloth_seed_subtree.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_seed_subtree.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH;;;;;;;;;GASG;AACH,6CAPW,aAAa,2EAGb,MAAM,GAEJ,IAAI,CAqHhB;AAiGD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAJW,aAAa,gCAEX,IAAI,CAkChB;8BAnV6B,oBAAoB"}

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

@@ -1,6 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { pose3_compose_array } from "../../../../core/geom/3d/pose/pose3_compose_array.js";
 import { GPUStateAuthorityFlags } from "../../../ecs/gpu/GPUStateAuthorityFlags.js";
 import { gpu_authority_assert_cpu } from "../../../ecs/gpu/gpu_authority_assert_cpu.js";
 import { TransformAttachment } from "../../../ecs/transform-attachment/TransformAttachment.js";
@@ -282,26 +281,13 @@ function read_rest_pose(instance, remembered) {
         // always already done, so one forward pass is the whole hierarchy.
         const p = parent[node];
 
-        const pqx = rotation[p * 4];
-        const pqy = rotation[p * 4 + 1];
-        const pqz = rotation[p * 4 + 2];
-        const pqw = rotation[p * 4 + 3];
-
-        v3_quaternion_apply(
-            COMPOSE, 0,
-            local_position[node * 3], local_position[node * 3 + 1], local_position[node * 3 + 2],
-            pqx, pqy, pqz, pqw
-        );
-
-        position[node * 3] = position[p * 3] + COMPOSE[0];
-        position[node * 3 + 1] = position[p * 3 + 1] + COMPOSE[1];
-        position[node * 3 + 2] = position[p * 3 + 2] + COMPOSE[2];
-
-        quat3_multiply(
+        pose3_compose_array(
+            position, node * 3,
             rotation, node * 4,
-            pqx, pqy, pqz, pqw,
-            local_rotation[node * 4], local_rotation[node * 4 + 1],
-            local_rotation[node * 4 + 2], local_rotation[node * 4 + 3]
+            position, p * 3,
+            rotation, p * 4,
+            local_position, node * 3,
+            local_rotation, node * 4
         );
     }
 
@@ -366,12 +352,6 @@ export function cloth_release_subtree(instance, ecd) {
     t64_announce_change(ecd, instance.node_entity[0]);
 }
 
-/**
- * @type {Float64Array}
- * @private
- */
-const COMPOSE = new Float64Array(3);
-
 /**
  * The authored pose a previous seeding captured, keyed by entity, so a re-seed
  * of a live cloth does not mistake the shape the solver left behind for the

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,CAwDhB;AAyBD;;;;;;;;;;;;;;GAcG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CA6DhB"}
+{"version":3,"file":"cloth_write_back.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;GAMG;AACH,wFAFa,IAAI,CAqDhB;AAyBD;;;;;;;;;;;;;;GAcG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAiDhB"}