@woosh/meep-engine 3.43.0 → 3.45.0

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

@@ -1,16 +1,13 @@
-import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
-import {
-    m4_from_rotation_translation_scale_array
-} from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_array.js";
+import { aabb3_transform_oriented_array } from "../../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
 import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { max2_exact } from "../../../../core/math/max2_exact.js";
+import { min2_exact } from "../../../../core/math/min2_exact.js";
 import { ClothColliderKind } from "./ClothColliderKind.js";
 import {
     CCR_AABB_MAX_X,
     CCR_AABB_MIN_X,
     CCR_KIND,
     CCR_PARAM_0,
-    CCR_PARAM_1,
-    CCR_PARAM_2,
     CCR_PARAM_3,
     CCR_PREV_QX,
     CCR_PREV_TX,
@@ -87,91 +84,25 @@ export function cloth_collider_refit_bounds(table, record, stride) {
 
     cloth_collider_local_bounds(LOCAL_BOUNDS, table, record, stride);
 
-    project(CURRENT_BOUNDS, table, r + CCR_QX, r + CCR_TX);
-    project(PREVIOUS_BOUNDS, table, r + CCR_PREV_QX, r + CCR_PREV_TX);
+    // Each pose is seven contiguous slots, translation then rotation, which is
+    // the layout the transform reads — so it reads them where they sit in the
+    // table rather than as numbers handed through a call, each of which would
+    // be boxed into a heap object wherever the call is not inlined.
+    aabb3_transform_oriented_array(CURRENT_BOUNDS, 0, LOCAL_BOUNDS, 0, table, r + CCR_TX);
+    aabb3_transform_oriented_array(PREVIOUS_BOUNDS, 0, LOCAL_BOUNDS, 0, table, r + CCR_PREV_TX);
 
+    // Not `aabb3_array_combine`: its `min2` / `max2` drop a NaN in their first
+    // operand, so a NaN pose would leave the other pose's bound depending on
+    // which side it was on. The refit keeps `Math.min`'s answer instead.
     for (let axis = 0; axis < 3; axis++) {
-        table[r + CCR_AABB_MIN_X + axis] = min_exact(CURRENT_BOUNDS[axis], PREVIOUS_BOUNDS[axis]);
-        table[r + CCR_AABB_MAX_X + axis] = max_exact(CURRENT_BOUNDS[axis + 3], PREVIOUS_BOUNDS[axis + 3]);
-    }
-}
-
-/**
- * `Math.min(a, b)` without the call: the smaller, NaN if either is, and `-0` below `+0`. The refit
- * runs a few times a cloth a step, so V8 is slow to optimise it, and until it does `Math.min` is a
- * call into a builtin that hands its answer back boxed into a heap object.
- *
- * The same as `Math.min` under `Object.is` for every pair of numbers. A NaN answer is the canonical
- * NaN; which NaN `Math.min` answers is the platform's (on x64, the one with the sign bit set).
- *
- * @param {number} a
- * @param {number} b
- * @returns {number}
- * @private
- */
-function min_exact(a, b) {
-    if (a < b) {
-        return a;
-    }
-
-    if (b < a) {
-        return b;
+        table[r + CCR_AABB_MIN_X + axis] = min2_exact(CURRENT_BOUNDS[axis], PREVIOUS_BOUNDS[axis]);
+        table[r + CCR_AABB_MAX_X + axis] = max2_exact(CURRENT_BOUNDS[axis + 3], PREVIOUS_BOUNDS[axis + 3]);
     }
-
-    if (a === b) {
-        // equal, and of two zeros the negative one if either is
-        return a === 0 && 1 / a > 0 ? b : a;
-    }
-
-    // one of them is NaN
-    return NaN;
 }
 
 /**
- * `Math.max(a, b)` without the call, as {@link min_exact}: the larger, NaN if either is, and `+0`
- * above `-0`.
- *
- * @param {number} a
- * @param {number} b
- * @returns {number}
- * @private
- */
-function max_exact(a, b) {
-    if (a > b) {
-        return a;
-    }
-
-    if (b > a) {
-        return b;
-    }
-
-    if (a === b) {
-        // equal, and of two zeros the positive one if either is
-        return a === 0 && 1 / a < 0 ? b : a;
-    }
-
-    return NaN;
-}
-
-/**
- * @param {Float64Array} out
- * @param {Float32Array|Float64Array} table
- * @param {number} rotation slot of the pose's rotation
- * @param {number} translation slot of the pose's translation
- * @private
- */
-function project(out, table, rotation, translation) {
-    // The pose is read where it sits in the table. Handed to the compose as ten numbers, the seven
-    // that are not small integers were each boxed into a heap object wherever the call was not
-    // inlined.
-    m4_from_rotation_translation_scale_array(POSE, table, rotation, table, translation, UNIT_SCALE, 0);
-
-    aabb3_matrix4_project(out, LOCAL_BOUNDS, POSE);
-}
-
-/**
- * A half-space's bounds, which cannot go through {@link aabb3_matrix4_project}
- * — an infinite extent multiplied by a zero matrix element is `NaN`. The
+ * A half-space's bounds, which cannot go through {@link aabb3_transform_oriented_array}
+ * — an infinite extent multiplied by a zero rotation element is `NaN`. The
  * plane's world normal is its local normal rotated by the pose, and the bound
  * exists on an axis exactly when that normal is aligned with it.
  *
@@ -190,7 +121,7 @@ function refit_plane(table, r) {
         const rotation = r + PLANE_POSES[p];
         const translation = r + PLANE_POSES[p + 1];
 
-        // the local normal and the rotation straight from the table, as in `project`
+        // the local normal and the rotation straight from the table, as for the other kinds
         v3_quaternion_apply_array(PLANE_NORMAL, 0, table, r + CCR_PARAM_0, table, rotation);
 
         // The boundary plane passes through `R·(offset·n_local) + t`, so its
@@ -208,9 +139,9 @@ function refit_plane(table, r) {
             // different ways is not a half-space, so the looser of the two wins
             // and a rotating plane simply stops bounding anything.
             if (n > PLANE_AXIS_TOLERANCE) {
-                table[r + CCR_AABB_MAX_X + axis] = max_exact(table[r + CCR_AABB_MAX_X + axis], offset);
+                table[r + CCR_AABB_MAX_X + axis] = max2_exact(table[r + CCR_AABB_MAX_X + axis], offset);
             } else if (n < -PLANE_AXIS_TOLERANCE) {
-                table[r + CCR_AABB_MIN_X + axis] = min_exact(table[r + CCR_AABB_MIN_X + axis], -offset);
+                table[r + CCR_AABB_MIN_X + axis] = min2_exact(table[r + CCR_AABB_MIN_X + axis], -offset);
             }
         }
     }
@@ -268,16 +199,3 @@ const CURRENT_BOUNDS = new Float64Array(6);
  * @private
  */
 const PREVIOUS_BOUNDS = new Float64Array(6);
-
-/**
- * @type {Float64Array}
- * @private
- */
-const POSE = new Float64Array(16);
-
-/**
- * The scale {@link project} composes with: a collider's pose is rigid.
- * @type {Float64Array}
- * @private
- */
-const UNIT_SCALE = new Float64Array([1, 1, 1]);

package/src/engine/physics/cloth/collider/cloth_collider_pack.d.ts

@@ -5,11 +5,8 @@
  * It runs when a `ClothCollider` is linked or its shape changes, never per step
  * and never per particle.
  *
- * `instanceof` rather than the prototype markers the physics narrowphase uses,
- * because this needs to distinguish *five* kinds rather than short-circuit one,
- * and because a marker per kind would be five new fields on `core` shapes for
- * one consumer's benefit. The ordering matters in one place and is commented
- * where it does.
+ * Each kind is asked by its prototype marker, as the physics narrowphase asks;
+ * the five are unrelated classes, so the order of the tests does not matter.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/engine/physics/cloth/collider/cloth_collider_pack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_collider_pack.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_pack.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;GASG;AACH,2CAPW,YAAY,GAAC,YAAY,UACzB,MAAM,kCAEN,MAAM,GACJ,OAAO,CAiFnB;AAED;;;;;;;;;;;;;;GAcG;AACH,iDANW,YAAY,GAAC,MAAM,EAAE,SACrB,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,OAAO,CAqCnB"}
+{"version":3,"file":"cloth_collider_pack.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_pack.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;GASG;AACH,2CAPW,YAAY,GAAC,YAAY,UACzB,MAAM,kCAEN,MAAM,GACJ,OAAO,CAiFnB;AAED;;;;;;;;;;;;;;GAcG;AACH,iDANW,YAAY,GAAC,MAAM,EAAE,SACrB,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,OAAO,CAqCnB"}

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

@@ -1,8 +1,3 @@
-import { BoxShape3D } from "../../../../core/geom/3d/shape/BoxShape3D.js";
-import { CapsuleShape3D } from "../../../../core/geom/3d/shape/CapsuleShape3D.js";
-import { CylinderShape3D } from "../../../../core/geom/3d/shape/CylinderShape3D.js";
-import { PlaneShape3D } from "../../../../core/geom/3d/shape/PlaneShape3D.js";
-import { SphereShape3D } from "../../../../core/geom/3d/shape/SphereShape3D.js";
 import { ClothColliderKind } from "./ClothColliderKind.js";
 import {
     CCR_FEATURE,
@@ -20,11 +15,8 @@ import {
  * It runs when a `ClothCollider` is linked or its shape changes, never per step
  * and never per particle.
  *
- * `instanceof` rather than the prototype markers the physics narrowphase uses,
- * because this needs to distinguish *five* kinds rather than short-circuit one,
- * and because a marker per kind would be five new fields on `core` shapes for
- * one consumer's benefit. The ordering matters in one place and is commented
- * where it does.
+ * Each kind is asked by its prototype marker, as the physics narrowphase asks;
+ * the five are unrelated classes, so the order of the tests does not matter.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -43,7 +35,7 @@ import {
 export function cloth_collider_pack(table, record, shape, stride) {
     const r = record * stride;
 
-    if (shape instanceof SphereShape3D) {
+    if (shape.isSphereShape3D === true) {
         // Covers UnitSphereShape3D, which is a SphereShape3D of radius 1.
         const radius = shape.radius;
 
@@ -57,7 +49,7 @@ export function cloth_collider_pack(table, record, shape, stride) {
         return true;
     }
 
-    if (shape instanceof CapsuleShape3D) {
+    if (shape.isCapsuleShape3D === true) {
         const radius = shape.radius;
 
         table[r + CCR_KIND] = ClothColliderKind.Capsule;
@@ -72,7 +64,7 @@ export function cloth_collider_pack(table, record, shape, stride) {
         return true;
     }
 
-    if (shape instanceof BoxShape3D) {
+    if (shape.isBoxShape3D === true) {
         // Covers UnitCubeShape3D, which is a BoxShape3D pinned to 0.5.
         const h = shape.half_extents;
 
@@ -90,7 +82,7 @@ export function cloth_collider_pack(table, record, shape, stride) {
         return true;
     }
 
-    if (shape instanceof CylinderShape3D) {
+    if (shape.isCylinderShape3D === true) {
         const radius = shape.radius;
 
         table[r + CCR_KIND] = ClothColliderKind.Cylinder;
@@ -103,7 +95,7 @@ export function cloth_collider_pack(table, record, shape, stride) {
         return true;
     }
 
-    if (shape instanceof PlaneShape3D) {
+    if (shape.isPlaneShape3D === true) {
         table[r + CCR_KIND] = ClothColliderKind.Plane;
         table[r + CCR_PARAM_0] = shape.normal_x;
         table[r + CCR_PARAM_1] = shape.normal_y;

package/src/engine/physics/cloth/collider/cloth_collider_sdf.d.ts

@@ -36,7 +36,7 @@
  * The rotation is an `nlerp` rather than a `slerp`: it is not constant angular
  * velocity, and over the fraction of a fixed step it is indistinguishable from
  * one — the two differ by under a thousandth of a degree at the half-radian per
- * step `CLOTH_ANCHOR_ROTATION_LIMIT` already treats as a spin.
+ * step `CLOTH_FRAME_ROTATION_LIMIT` already treats as a spin.
  *
  * @param {Float32Array|Float64Array} table
  * @param {number} count records in `table`

package/src/engine/physics/cloth/collider/cloth_collider_sdf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_collider_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_sdf.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CALW,YAAY,GAAC,YAAY,SACzB,MAAM,KACN,MAAM,GACJ,IAAI,CAiDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,mBAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB;AAED;;;;;;;;;;;;;;GAcG;AACH,0DATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAgChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,+CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;GAWG;AACH,qDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;GAaG;AACH,6CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;GAWG;AACH,mDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAUhB"}
+{"version":3,"file":"cloth_collider_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_sdf.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CALW,YAAY,GAAC,YAAY,SACzB,MAAM,KACN,MAAM,GACJ,IAAI,CAmBhB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,mBAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB;AAED;;;;;;;;;;;;;;GAcG;AACH,0DATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAgChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,+CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;GAWG;AACH,qDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAMhB;AAED;;;;;;;;;;;;;GAaG;AACH,6CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;GAWG;AACH,mDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAMhB"}

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

@@ -1,31 +1,24 @@
+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_nlerp_array } from "../../../../core/geom/3d/quaternion/quat3_nlerp.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,
-    CCR_INTERP_QY,
-    CCR_INTERP_QZ,
     CCR_INTERP_TX,
     CCR_INTERP_TY,
     CCR_INTERP_TZ,
     CCR_KIND,
     CCR_PARAM_0,
-    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,
@@ -72,7 +65,7 @@ import { ClothColliderKind } from "./ClothColliderKind.js";
  * The rotation is an `nlerp` rather than a `slerp`: it is not constant angular
  * velocity, and over the fraction of a fixed step it is indistinguishable from
  * one — the two differ by under a thousandth of a degree at the half-radian per
- * step `CLOTH_ANCHOR_ROTATION_LIMIT` already treats as a spin.
+ * step `CLOTH_FRAME_ROTATION_LIMIT` already treats as a spin.
  *
  * @param {Float32Array|Float64Array} table
  * @param {number} count records in `table`
@@ -89,42 +82,12 @@ export function cloth_collider_pose_at(table, count, t) {
         table[r + CCR_INTERP_TY] = s * table[r + CCR_PREV_TY] + t * table[r + CCR_TY];
         table[r + CCR_INTERP_TZ] = s * table[r + CCR_PREV_TZ] + t * table[r + CCR_TZ];
 
-        const ax = table[r + CCR_PREV_QX];
-        const ay = table[r + CCR_PREV_QY];
-        const az = table[r + CCR_PREV_QZ];
-        const aw = table[r + CCR_PREV_QW];
-
-        let bx = table[r + CCR_QX];
-        let by = table[r + CCR_QY];
-        let bz = table[r + CCR_QZ];
-        let bw = table[r + CCR_QW];
-
-        // `q` and `−q` are one rotation, so the pair has to be brought onto the
-        // same hemisphere or the interpolation takes the long way round — which
-        // for a collider is a bone that spins through the character.
-        if (ax * bx + ay * by + az * bz + aw * bw < 0) {
-            bx = -bx;
-            by = -by;
-            bz = -bz;
-            bw = -bw;
-        }
-
-        const qx = s * ax + t * bx;
-        const qy = s * ay + t * by;
-        const qz = s * az + t * bz;
-        const qw = s * aw + t * bw;
-
-        const length = Math.sqrt(qx * qx + qy * qy + qz * qz + qw * qw);
-
-        // Two opposed quaternions cancel exactly, which the hemisphere fix
-        // above makes impossible; the guard is for a record whose poses were
-        // never written rather than for a rotation.
-        const inverse = length > 0 ? 1 / length : 0;
-
-        table[r + CCR_INTERP_QX] = qx * inverse;
-        table[r + CCR_INTERP_QY] = qy * inverse;
-        table[r + CCR_INTERP_QZ] = qz * inverse;
-        table[r + CCR_INTERP_QW] = length > 0 ? qw * inverse : 1;
+        // Both poses' quaternions are contiguous `[x, y, z, w]` slots, so the
+        // blend reads them in place. `q` and `−q` are one rotation; the
+        // hemisphere flip inside the nlerp is what keeps the pair from
+        // interpolating the long way round — which for a collider is a bone
+        // that spins through the character.
+        quat3_nlerp_array(table, r + CCR_INTERP_QX, table, r + CCR_PREV_QX, table, r + CCR_QX, t);
     }
 }
 
@@ -175,11 +138,11 @@ export function cloth_collider_signed_distance(gradient, gradient_offset, table,
 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];
-
-    v3_quaternion_apply_inverse_array(LOCAL_POINT, 0, LOCAL_POINT, 0, table, r + CCR_INTERP_QX);
+    pose3_apply_inverse_point_array(
+        LOCAL_POINT, 0,
+        table, r + CCR_INTERP_TX, table, r + CCR_INTERP_QX,
+        point, point_offset
+    );
 
     const kind = table[r + CCR_KIND];
 
@@ -243,11 +206,7 @@ export function cloth_collider_from_local(out, out_offset, table, record, x, y,
 export function cloth_collider_from_local_array(out, out_offset, table, record, point, point_offset) {
     const r = record * CCR_STRIDE;
 
-    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];
-    out[out_offset + 2] += table[r + CCR_INTERP_TZ];
+    pose3_apply_point_array(out, out_offset, table, r + CCR_INTERP_TX, table, r + CCR_INTERP_QX, point, point_offset);
 }
 
 /**
@@ -287,11 +246,7 @@ export function cloth_collider_to_local(out, out_offset, table, record, x, y, z)
 export function cloth_collider_to_local_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];
-
-    v3_quaternion_apply_inverse_array(out, out_offset, LOCAL_POINT, 0, table, r + CCR_INTERP_QX);
+    pose3_apply_inverse_point_array(out, out_offset, table, r + CCR_INTERP_TX, table, r + CCR_INTERP_QX, point, point_offset);
 }
 
 /**

package/src/engine/physics/cloth/ecs/Cloth.d.ts

@@ -6,22 +6,30 @@
  *
  * ```js
  * rope_top.add(Cloth.from(ClothDynamics.ROPE));
+ * rope_top.add(ClothPin.from({ cloth: rope_top, particles: [0] }));
  * ```
  *
- * **The anchor is the entity the component is on**, and nothing names anything.
- * The particle set is that entity's own transform subtree, walked through
- * `TransformAttachmentSystem#findChildrenOf` — the parent-to-children index the
- * engine already maintains. Put `Cloth` on the top link of a rope and you get
- * the rope; put it on a node with several chains under it and you get all of
- * them in **one coupled solve**, which is what makes self-collision between
- * them work when it arrives.
+ * **The entity the component is on is the cloth's frame**, and nothing names
+ * anything. The particle set is that entity and its transform subtree, walked
+ * through `TransformAttachmentSystem#findChildrenOf` — the parent-to-children
+ * index the engine already maintains — with the entity itself as particle 0.
+ * Put `Cloth` on the top link of a rope and you get the rope; put it on a node
+ * with several chains under it and you get all of them in **one coupled
+ * solve**, which is what makes self-collision between them work.
+ *
+ * **What holds it is a separate question**, answered by {@link ClothPin}s: any
+ * number of them, on any entities, holding any particles, added and removed
+ * while it runs. The rope above is held at its top by its own entity; a rope
+ * bridge is that plus a post holding its last link; a rope nothing holds falls.
+ * The frame is only what the cloth is simulated in and what §7 P7's inertia is
+ * measured against — the entity the cloth rides, which cloth reads and never
+ * writes.
  *
  * Two rules keep the walk unambiguous:
  *
  * - **A nested `Cloth` claims its own subtree.** The walk stops when it meets
  *   another `Cloth`, so independent hanging parts of one prop partition
- *   naturally. The two solves are ordered by hierarchy depth, so the outer one
- *   has written the inner one's anchor before the inner one reads it.
+ *   naturally, each read one fixed step after the cloth above it wrote it.
  * - **{@link ClothExclude}** prunes a subtree from the walk, for the rig with a
  *   non-simulated attachment point in the middle of a chain.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"Cloth.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/Cloth.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAkDI;;;;;;;;;OASG;IACH,uBATW,aAAa;QAGC,KAAK,GAAnB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACJ,KAAK,CA6BjB;IArFD;;;;;;;OAOG;IACH,UAFU,aAAa,CAEQ;IAE/B;;;;;;;;OAQG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,OAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,cAHW,MAAM,GAAC,UAAU,GACf,OAAO,CAInB;IAyCD;;;OAGG;IACH,cAHW,KAAK,GACH,OAAO,CAgBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAUlB;IAED;;;;;;;;;;;;;;;;;MAQC;IAED;;OAEG;IACH,kDAFW,MAAM,QAehB;IAED,mBAEC;IAGL;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;;;;8BAxM6B,oBAAoB;2BACvB,iBAAiB"}
+{"version":3,"file":"Cloth.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/Cloth.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IAkDI;;;;;;;;;OASG;IACH,uBATW,aAAa;QAGC,KAAK,GAAnB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACJ,KAAK,CA6BjB;IArFD;;;;;;;OAOG;IACH,UAFU,aAAa,CAEQ;IAE/B;;;;;;;;OAQG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,OAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,cAHW,MAAM,GAAC,UAAU,GACf,OAAO,CAInB;IAyCD;;;OAGG;IACH,cAHW,KAAK,GACH,OAAO,CAgBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAUlB;IAED;;;;;;;;;;;;;;;;;MAQC;IAED;;OAEG;IACH,kDAFW,MAAM,QAehB;IAED,mBAEC;IAGL;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;;;;8BAhN6B,oBAAoB;2BACvB,iBAAiB"}