@woosh/meep-engine 3.44.0 → 3.45.0

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

@@ -1,8 +1,15 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH, NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
+import { number_compare_ascending } from "../../../../core/primitives/numbers/number_compare_ascending.js";
 import {
     bvh_query_user_data_intersects_aabb
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { array_range_equal_strict } from "../../../../core/collection/array/array_range_equal_strict.js";
+import { array_remove_first } from "../../../../core/collection/array/array_remove_first.js";
+import { array_sort_insertion_ascending } from "../../../../core/collection/array/array_sort_insertion_ascending.js";
+import { aabb3_array_round_outward_f32 } from "../../../../core/geom/3d/aabb/aabb3_array_round_outward_f32.js";
+import { FAT_LINEAR } from "../../broadphase/compute_fat_world_aabb.js";
 import {
     CCR_AABB_MAX_X,
     CCR_AABB_MAX_Y,
@@ -341,11 +348,9 @@ export class ClothColliderIndex {
         const node = this.#node[handle];
 
         if (node === NULL_NODE) {
-            const at = this.#planes.indexOf(handle);
+            const planes = this.#planes;
 
-            if (at >= 0) {
-                this.#planes.splice(at, 1);
-            }
+            array_remove_first(planes, handle, 0, planes.length);
         } else {
             this.#bvh.remove_leaf(node);
             this.#bvh.release_node(node);
@@ -419,22 +424,11 @@ export class ClothColliderIndex {
                 this.max_inflation = table[r + CCR_INFLATION];
             }
 
-            const moved = table[r + CCR_PREV_TX] !== table[r + CCR_TX]
-                || table[r + CCR_PREV_TY] !== table[r + CCR_TY]
-                || table[r + CCR_PREV_TZ] !== table[r + CCR_TZ]
-                || table[r + CCR_PREV_QX] !== table[r + CCR_QX]
-                || table[r + CCR_PREV_QY] !== table[r + CCR_QY]
-                || table[r + CCR_PREV_QZ] !== table[r + CCR_QZ]
-                || table[r + CCR_PREV_QW] !== table[r + CCR_QW];
-
-            table[r + CCR_PREV_TX] = table[r + CCR_TX];
-            table[r + CCR_PREV_TY] = table[r + CCR_TY];
-            table[r + CCR_PREV_TZ] = table[r + CCR_TZ];
+            // A pose is seven contiguous slots, translation then rotation, in
+            // both the current and the previous half of the record.
+            const moved = !array_range_equal_strict(table, r + CCR_PREV_TX, table, r + CCR_TX, POSE_SLOTS);
 
-            table[r + CCR_PREV_QX] = table[r + CCR_QX];
-            table[r + CCR_PREV_QY] = table[r + CCR_QY];
-            table[r + CCR_PREV_QZ] = table[r + CCR_QZ];
-            table[r + CCR_PREV_QW] = table[r + CCR_QW];
+            array_copy(table, r + CCR_TX, table, r + CCR_PREV_TX, POSE_SLOTS);
 
             if (moved) {
                 cloth_collider_refit_bounds(table, handle, CCR_STRIDE);
@@ -451,6 +445,13 @@ export class ClothColliderIndex {
      * ignores it, so a distance in the shape's local frame is a distance in
      * world space.
      *
+     * A pose equal to the one the record already holds is not refit: its
+     * bounds were fit to exactly this pair of poses when either last changed —
+     * here, in {@link placePose}, or in {@link advance} — so the refit would
+     * write what is there. That is what a collider that never moves costs, and
+     * why nothing has to say it will not: 1.43 µs per collider per step
+     * refitting, 0.42 µs skipping, of which {@link advance} is 0.32.
+     *
      * @param {number} handle
      * @param {number} tx
      * @param {number} ty
@@ -471,6 +472,35 @@ export class ClothColliderIndex {
 
         const r = handle * CCR_STRIDE;
 
+        if (table[r + CCR_TX] === tx && table[r + CCR_TY] === ty && table[r + CCR_TZ] === tz
+            && table[r + CCR_QX] === qx && table[r + CCR_QY] === qy
+            && table[r + CCR_QZ] === qz && table[r + CCR_QW] === qw
+            // no leaf — never posed, or a plane, which is never in the tree — refits regardless
+            && this.#node[handle] !== NULL_NODE) {
+            return;
+        }
+
+        this.#pose(handle, tx, ty, tz, qx, qy, qz, qw);
+    }
+
+    /**
+     * Write the current pose and refit, unconditionally.
+     *
+     * @param {number} handle
+     * @param {number} tx
+     * @param {number} ty
+     * @param {number} tz
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} qz
+     * @param {number} qw
+     * @private
+     */
+    #pose(handle, tx, ty, tz, qx, qy, qz, qw) {
+        const table = this.table;
+
+        const r = handle * CCR_STRIDE;
+
         if (table[r + CCR_TX] !== tx || table[r + CCR_TY] !== ty || table[r + CCR_TZ] !== tz
             || table[r + CCR_QX] !== qx || table[r + CCR_QY] !== qy
             || table[r + CCR_QZ] !== qz || table[r + CCR_QW] !== qw) {
@@ -561,9 +591,15 @@ export class ClothColliderIndex {
             if (lower < STORED_AABB[axis] || upper > STORED_AABB[axis + 3]) contained = false;
             // A one-step outlier must not leave a scene-sized leaf behind once
             // motion stops. Allow ordinary jitter to keep spending the slack.
+            // The yardstick is twice what a store would write now: the slack
+            // on both sides plus the outward rounding, which grows each side by
+            // under one float32 step of its magnitude. Without that term a leaf
+            // far enough out that a step outgrows the slack — past about four
+            // hundred kilometres — would read as oversized straight after being
+            // stored, and be re-homed every step.
             if (STORED_AABB[axis + 3] - STORED_AABB[axis]
-                > 2 * (upper - lower + 2 * BVH_LEAF_SLACK
-                    + (Math.abs(lower) + Math.abs(upper)) * FLOAT32_ROUNDING)) oversized = true;
+                > 2 * (upper - lower + 2 * FAT_LINEAR
+                    + (Math.abs(lower) + Math.abs(upper) + 2 * FAT_LINEAR) * FLOAT32_STEP)) oversized = true;
         }
 
         if (contained && !oversized) {
@@ -589,18 +625,18 @@ export class ClothColliderIndex {
      * Write a record's swept bounds plus its contact reach into {@link FAT_AABB}
      * with the slack the refit skip spends, and store them on the leaf.
      *
-     * The slack is also what makes the tree's `Float32` nodes safe to hold a
-     * `Float64` world, and it has two terms because one is not enough. The
-     * constant covers jitter. The relative term covers the rounding
-     * {@link BVH#node_set_aabb} does on the way in: a bound can move by an ulp,
-     * and `Float32`'s ulp is a *proportion* of the magnitude — a millimetre at
-     * ten kilometres out, but **a whole metre at ten thousand**, which is well
-     * past the constant: measured, a leaf there comes back 45 cm inside its own
-     * record. A bound that rounds inward past its slack is a leaf
-     * smaller than the record it stands for, and that is a collider the tree
-     * stops answering with — silently, and only far from the origin, which is
-     * the worst shape a bug can have. Two ulps of the magnitude puts it back
-     * outside at every scale the `Float64` table is kept for.
+     * The slack covers jitter; it does not cover the tree's `Float32` nodes
+     * holding a `Float64` world. {@link BVH#node_set_aabb} rounds each bound to
+     * the nearest `Float32`, and `Float32`'s step is a *proportion* of the
+     * magnitude — a millimetre at ten kilometres out, but **a whole metre at
+     * ten thousand**, which is well past any constant: measured, a leaf there
+     * fattened by 5 cm came back 45 cm inside its own record. A bound that
+     * rounds inward past its slack is a leaf smaller than the record it stands
+     * for, and that is a collider the tree stops answering with — silently,
+     * and only far from the origin, which is the worst shape a bug can have.
+     * So the fattened box is rounded outward to `Float32` before it is stored,
+     * which makes the store exact at every scale and leaves the constant to do
+     * only its own job.
      *
      * The exact test in {@link query} reads the `Float64` record, so the tree
      * only ever has to avoid a false **negative**; being generous here costs a
@@ -618,10 +654,12 @@ export class ClothColliderIndex {
             const lower = table[r + CCR_AABB_MIN_X + axis] - reach;
             const upper = table[r + CCR_AABB_MAX_X + axis] + reach;
 
-            FAT_AABB[axis] = lower - BVH_LEAF_SLACK - Math.abs(lower) * FLOAT32_ROUNDING;
-            FAT_AABB[axis + 3] = upper + BVH_LEAF_SLACK + Math.abs(upper) * FLOAT32_ROUNDING;
+            FAT_AABB[axis] = lower - FAT_LINEAR;
+            FAT_AABB[axis + 3] = upper + FAT_LINEAR;
         }
 
+        aabb3_array_round_outward_f32(FAT_AABB, 0, FAT_AABB, 0);
+
         this.#bvh.node_set_aabb(node, FAT_AABB);
     }
 
@@ -657,7 +695,9 @@ export class ClothColliderIndex {
         this.table[r + CCR_PREV_QZ] = qz;
         this.table[r + CCR_PREV_QW] = qw;
 
-        this.setPose(handle, tx, ty, tz, qx, qy, qz, qw);
+        // Not {@link setPose}: the previous pose has just changed, so the
+        // bounds are stale even when the current one has not.
+        this.#pose(handle, tx, ty, tz, qx, qy, qz, qw);
     }
 
     /**
@@ -926,21 +966,19 @@ export class ClothColliderIndex {
 }
 
 /**
- * How far past a record's swept bounds its leaf is stored, metres. The same
- * constant `compute_fat_world_aabb` spends on a rigid body, and for the same
- * reason: a collider jittering inside its own slack must not cost a refit.
+ * One `Float32` step as a proportion of a value's magnitude, an upper bound
+ * for every normal `Float32`: 23 fraction bits, so a step is at most `2^-23`
+ * of the magnitude. The most an outward rounding can widen a bound by.
  * @type {number}
  */
-const BVH_LEAF_SLACK = 0.05;
+const FLOAT32_STEP = 2 ** -23;
 
 /**
- * Two `Float32` ulps as a proportion of a value's magnitude — what a bound has
- * to be widened by to survive being stored in a `Float32` leaf whatever the
- * rounding does. `Float32` carries 23 fraction bits, so one ulp is `2^-23` of
- * the magnitude and two is the first multiple that is unconditionally outside.
+ * Slots in one pose, `[tx, ty, tz, qx, qy, qz, qw]`: {@link CCR_TX} to {@link CCR_QW}, and the same
+ * from {@link CCR_PREV_TX}.
  * @type {number}
  */
-const FLOAT32_ROUNDING = 2 ** -22;
+const POSE_SLOTS = 7;
 
 /**
  * The box being queried, `[min_x, min_y, min_z, max_x, max_y, max_z]`: what the tree is walked with
@@ -972,23 +1010,12 @@ function sort_handles(handles) {
     const n = handles.length;
 
     if (n > INSERTION_SORT_LIMIT) {
-        handles.sort(ASCENDING);
+        handles.sort(number_compare_ascending);
 
         return;
     }
 
-    for (let i = 1; i < n; i++) {
-        const handle = handles[i];
-
-        let j = i - 1;
-
-        while (j >= 0 && handles[j] > handle) {
-            handles[j + 1] = handles[j];
-            j--;
-        }
-
-        handles[j + 1] = handle;
-    }
+    array_sort_insertion_ascending(handles, 0, n);
 }
 
 /**
@@ -1002,12 +1029,3 @@ const FAT_AABB = new Float64Array(6);
  * @type {Float32Array}
  */
 const STORED_AABB = new Float32Array(6);
-
-/**
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-function ASCENDING(a, b) {
-    return a - b;
-}

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_collider_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_bounds.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oDAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,mDALW,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,IAAI,CAoBhB"}
+{"version":3,"file":"cloth_collider_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_bounds.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oDAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,mDALW,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,IAAI,CA2BhB"}

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.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,
@@ -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/ClothColliderFlags.d.ts

@@ -4,6 +4,5 @@
 export type ClothColliderFlags = number;
 export namespace ClothColliderFlags {
     let None: number;
-    let Static: number;
 }
 //# sourceMappingURL=ClothColliderFlags.d.ts.map