@woosh/meep-engine 3.37.0 → 3.39.0

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

@@ -1,8 +1,8 @@
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import {
-    m4_from_rotation_translation_scale_scalar
-} from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+    m4_from_rotation_translation_scale_array
+} from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_array.js";
+import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import { ClothColliderKind } from "./ClothColliderKind.js";
 import {
     CCR_AABB_MAX_X,
@@ -19,6 +19,39 @@ import {
 } from "./ClothColliderRecord.js";
 import { cloth_collider_local_bounds } from "./cloth_collider_pack.js";
 
+/**
+ * Outward error allowance when a world-space query precedes the solver's
+ * Float32 conversion. Shared by the cloth query and the collider leaf: their
+ * allowances add, just as their speculative contact reaches do.
+ *
+ * Let u = 2^-24, P bound the particle's local distance from the anchor, G the
+ * shape radius, and L the sum of the contact and motion reaches. Rounding a
+ * localized translation contributes at most u times its length; rounding both
+ * swept translations adds at most u(2|t| + travel) to the measured travel.
+ * The relative quaternion is rounded, normalized and rounded again. Its
+ * error is less than 4u, so its inverse rotation/scale displaces a point by
+ * less than 9u times its radius. Shape parameters and inflation round once.
+ * Together these are bounded by 4u|t| + 16u(G + L). For an accepted contact,
+ * |t| <= P + G + L + error; substituting bounds that error by 32u(P + G + L).
+ * We spend 64u, including outward arithmetic rounding. P and the particle
+ * reach are paid by the query, G and collider reach by the index. No world
+ * coordinate is multiplied by a Float32 epsilon.
+ *
+ * World transforms/bounds use doubles: the separate world term covers their
+ * subtraction and rotation arithmetic, including cancellation far from the
+ * origin. The absolute term covers Float32 subnormals. Assumes finite solver
+ * values and rigid unit-quaternion input poses, as the collider API does.
+ * Unbounded planes cannot use a shape-radius bound and are always candidates
+ * for a contact query (their layer/mask still applies).
+ *
+ * @param {number} local_scale nonnegative local length bound
+ * @param {number} world_scale nonnegative world arithmetic magnitude bound
+ * @returns {number} metres of outward padding
+ */
+export function cloth_contact_rounding(local_scale, world_scale) {
+    return 64 * (2 ** -24 * local_scale + Number.EPSILON * world_scale + 2 ** -149);
+}
+
 /**
  * # The swept bounds of a packed collider
  *
@@ -58,11 +91,68 @@ export function cloth_collider_refit_bounds(table, record, stride) {
     project(PREVIOUS_BOUNDS, table, r + CCR_PREV_QX, r + CCR_PREV_TX);
 
     for (let axis = 0; axis < 3; axis++) {
-        table[r + CCR_AABB_MIN_X + axis] = Math.min(CURRENT_BOUNDS[axis], PREVIOUS_BOUNDS[axis]);
-        table[r + CCR_AABB_MAX_X + axis] = Math.max(CURRENT_BOUNDS[axis + 3], PREVIOUS_BOUNDS[axis + 3]);
+        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;
+    }
+
+    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
@@ -71,12 +161,10 @@ export function cloth_collider_refit_bounds(table, record, stride) {
  * @private
  */
 function project(out, table, rotation, translation) {
-    m4_from_rotation_translation_scale_scalar(
-        POSE,
-        table[rotation], table[rotation + 1], table[rotation + 2], table[rotation + 3],
-        table[translation], table[translation + 1], table[translation + 2],
-        1, 1, 1
-    );
+    // 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);
 }
@@ -97,15 +185,13 @@ function refit_plane(table, r) {
         table[r + CCR_AABB_MAX_X + axis] = -Infinity;
     }
 
-    for (const pose of PLANE_POSES) {
-        const rotation = r + pose[0];
-        const translation = r + pose[1];
+    // indexed rather than `for...of`, which until V8 optimises this allocates an iterator result per pose
+    for (let p = 0; p < PLANE_POSES.length; p += 2) {
+        const rotation = r + PLANE_POSES[p];
+        const translation = r + PLANE_POSES[p + 1];
 
-        v3_quaternion_apply(
-            PLANE_NORMAL, 0,
-            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1], table[r + CCR_PARAM_2],
-            table[rotation], table[rotation + 1], table[rotation + 2], table[rotation + 3]
-        );
+        // the local normal and the rotation straight from the table, as in `project`
+        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
         // offset along the *world* normal is `offset + n_world·t`.
@@ -122,9 +208,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] = Math.max(table[r + CCR_AABB_MAX_X + axis], offset);
+                table[r + CCR_AABB_MAX_X + axis] = max_exact(table[r + CCR_AABB_MAX_X + axis], offset);
             } else if (n < -PLANE_AXIS_TOLERANCE) {
-                table[r + CCR_AABB_MIN_X + axis] = Math.min(table[r + CCR_AABB_MIN_X + axis], -offset);
+                table[r + CCR_AABB_MIN_X + axis] = min_exact(table[r + CCR_AABB_MIN_X + axis], -offset);
             }
         }
     }
@@ -153,11 +239,11 @@ const PLANE_AXIS_TOLERANCE = 0.999999;
 
 /**
  * The two pose slot pairs a plane's bounds are computed from — current, then
- * previous — as `[rotation, translation]` offsets within a record.
- * @type {number[][]}
+ * previous — as `rotation, translation` offsets within a record, flat.
+ * @type {number[]}
  * @private
  */
-const PLANE_POSES = [[CCR_QX, CCR_TX], [CCR_PREV_QX, CCR_PREV_TX]];
+const PLANE_POSES = [CCR_QX, CCR_TX, CCR_PREV_QX, CCR_PREV_TX];
 
 /**
  * @type {Float64Array}
@@ -188,3 +274,10 @@ const PREVIOUS_BOUNDS = new Float64Array(6);
  * @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_sdf.d.ts

@@ -11,9 +11,10 @@
  * inverts by conjugating its quaternion and subtracting its translation, which
  * costs less than storing an inverse and is exact rather than cached.
  *
- * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions
- * over scalars, so this dispatch and {@link SphereShape3D} and the rest are
- * calling one implementation (§14.1). Before M2 those shapes fell back to
+ * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions,
+ * so this dispatch, through their array forms, and {@link SphereShape3D} and
+ * the rest, through their scalar forms, are calling one implementation
+ * (§14.1). Before M2 those shapes fell back to
  * `compute_signed_distance_gradient_by_sampling` — four field evaluations and a
  * normalise, for shapes whose gradients are two lines of algebra.
  *
@@ -59,6 +60,22 @@ export function cloth_collider_pose_at(table: Float32Array | Float64Array, count
  * @returns {number} the signed distance
  */
 export function cloth_collider_signed_distance(gradient: Float32Array | Float64Array | number[], gradient_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): number;
+/**
+ * {@link cloth_collider_signed_distance} with the point read from an array and the distance written
+ * beside the gradient rather than returned. For the solver's per-particle, per-iteration loops: a
+ * point handed over as three numbers, or a distance handed back as one, is boxed into a heap object
+ * wherever V8 does not inline the call.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record record index, not a slot offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, in the frame `table` is expressed in
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_signed_distance_array(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, point: Float32Array | Float64Array | number[], point_offset: number): void;
 /**
  * Bring a point expressed in a collider's own local frame out into the frame
  * the table is expressed in, using the interpolated pose. This is the inverse
@@ -76,6 +93,19 @@ export function cloth_collider_signed_distance(gradient: Float32Array | Float64A
  * @returns {void}
  */
 export function cloth_collider_from_local(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): void;
+/**
+ * {@link cloth_collider_from_local} with the point read from an array, for the same reason as
+ * {@link cloth_collider_signed_distance_array}. `out` may be `point`.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, local
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_from_local_array(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, point: Float32Array | Float64Array | number[], point_offset: number): void;
 /**
  * Bring a point out of the table's frame into a collider's own local frame,
  * using the interpolated pose. The anchoring half of
@@ -91,4 +121,17 @@ export function cloth_collider_from_local(out: Float32Array | Float64Array | num
  * @returns {void}
  */
 export function cloth_collider_to_local(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): void;
+/**
+ * {@link cloth_collider_to_local} with the point read from an array, for the same reason as
+ * {@link cloth_collider_signed_distance_array}. `out` may be `point`.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, in the frame `table` is expressed in
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_to_local_array(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, point: Float32Array | Float64Array | number[], point_offset: number): void;
 //# sourceMappingURL=cloth_collider_sdf.d.ts.map

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":"AAsCA;;;;;;;;;;;;;;;;;;;;;GAqBG;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,CA4DlB;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,CAchB;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,CAahB"}
+{"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"}

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

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

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

@@ -24,7 +24,8 @@ export const ClothColliderFlags = {
      * the sweep degenerates to the pose it already had. Move the entity anyway
      * and the cloth will not notice: that is the trade, and it is why this is
      * an author's assertion rather than something derived from a pose that
-     * happens not to have changed yet.
+     * happens not to have changed yet. An explicit TRANSFORM64_EVENT_PLACED
+     * (including PhysicsSystem.setPose) does re-place a static proxy.
      */
     Static: 1
 };

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

@@ -63,7 +63,8 @@ export class ClothColliderSystem extends System<any> {
      * they were linked. Held rather than looked up per step for the same reason
      * `ClothInstance` holds its transforms: a refresh is a loop over live
      * colliders, not a query.
-     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number}[]}
+     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number,
+     *   linked: boolean, onPlaced: function(): void}[]}
      * @private
      */
     private __linked;
@@ -99,6 +100,14 @@ export class ClothColliderSystem extends System<any> {
      * @returns {void}
      */
     refreshSurface(entity: number): void;
+    /**
+     * Reset motion history at an explicitly published placement, including
+     * static proxies. The next refresh can still sweep any subsequent motion.
+     * @param {number} handle
+     * @param {Transform64} transform
+     * @private
+     */
+    private __place;
     /**
      * @param {number} entity
      * @returns {number} the index handle, or `undefined` if the entity is not indexed

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

@@ -1 +1 @@
-{"version":3,"file":"ClothColliderSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothColliderSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;;IAEI,8EAAsD;IAEtD,wKAIE;IAEF;;OAEG;IACH,OAFU,kBAAkB,CAEK;IAEjC;;;;;;OAMG;IACH,kBAAsB;IAEtB;;;;;;;OAOG;IACH,iBAAc;IAEd;;;;;OAKG;IACH,qBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAsChB;IAED;;;;;OAKG;IACH,uBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAmBhB;IAED;;;;;;OAMG;IACH,WAFa,IAAI,CAkChB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,IAAI,CAyBhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ;uBAhPsB,wBAAwB;4BAKxC,uCAAuC;yBACrB,uBAAuB;8BAElB,oBAAoB;4CATN,uDAAuD;mCAQhE,mCAAmC"}
+{"version":3,"file":"ClothColliderSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothColliderSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;;IAEI,8EAAsD;IAEtD,wKAIE;IAEF;;OAEG;IACH,OAFU,kBAAkB,CAEK;IAEjC;;;;;;OAMG;IACH,kBAAsB;IAEtB;;;;;;;;OAQG;IACH,iBAAc;IAEd;;;;;OAKG;IACH,qBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAoChB;IAED;;;;;OAKG;IACH,uBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAqBhB;IAED;;;;;;OAMG;IACH,WAFa,IAAI,CAkChB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,IAAI,CAyBhB;IAED;;;;;;OAMG;IACH,gBAWC;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ;uBAtQsB,wBAAwB;4BAMxC,uCAAuC;yBACrB,uBAAuB;8BAElB,oBAAoB;4CAVN,uDAAuD;mCAShE,mCAAmC"}

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

@@ -1,6 +1,7 @@
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { System } from "../../../ecs/System.js";
+import { TRANSFORM64_EVENT_PLACED } from "../../../ecs/transform/TRANSFORM64_EVENT_PLACED.js";
 import {
     TRANSFORM64_ROTATION_OFFSET,
     TRANSFORM64_TRANSLATION_OFFSET,
@@ -84,7 +85,8 @@ export class ClothColliderSystem extends System {
      * they were linked. Held rather than looked up per step for the same reason
      * `ClothInstance` holds its transforms: a refresh is a loop over live
      * colliders, not a query.
-     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number}[]}
+     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number,
+     *   linked: boolean, onPlaced: function(): void}[]}
      * @private
      */
     __linked = [];
@@ -117,20 +119,18 @@ export class ClothColliderSystem extends System {
 
         this.__handles.set(entity, handle);
 
-        this.__linked.push({ collider: cloth_collider, transform, entity, handle });
+        const entry = { collider: cloth_collider, transform, entity, handle, linked: true, onPlaced: () => {
+            // Dispatch snapshots can retain this listener after unlink, even
+            // after both its entity id and index slot have been reused.
+            if (entry.linked) this.__place(handle, transform);
+        } };
+        this.__linked.push(entry);
+
+        this.entityManager.dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_PLACED, entry.onPlaced);
 
         // Placed rather than posed, so its first step sweeps nothing. A
         // collider that has just appeared did not move.
-        this.index.placePose(
-            handle,
-            transform[TRANSFORM64_TRANSLATION_OFFSET],
-            transform[TRANSFORM64_TRANSLATION_OFFSET + 1],
-            transform[TRANSFORM64_TRANSLATION_OFFSET + 2],
-            transform[TRANSFORM64_ROTATION_OFFSET],
-            transform[TRANSFORM64_ROTATION_OFFSET + 1],
-            transform[TRANSFORM64_ROTATION_OFFSET + 2],
-            transform[TRANSFORM64_ROTATION_OFFSET + 3]
-        );
+        this.__place(handle, transform);
     }
 
     /**
@@ -148,9 +148,11 @@ export class ClothColliderSystem extends System {
 
         this.__handles.delete(entity);
         this.index.remove(handle);
-
         for (let i = 0; i < this.__linked.length; i++) {
-            if (this.__linked[i].entity === entity) {
+            const entry = this.__linked[i];
+            if (entry.entity === entity) {
+                entry.linked = false;
+                this.entityManager.dataset.removeEntityEventListener(entity, TRANSFORM64_EVENT_PLACED, entry.onPlaced);
                 this.__linked.splice(i, 1);
 
                 break;
@@ -233,6 +235,26 @@ export class ClothColliderSystem extends System {
         this.index.setFilter(handle, cloth_collider.layer, cloth_collider.mask);
     }
 
+    /**
+     * Reset motion history at an explicitly published placement, including
+     * static proxies. The next refresh can still sweep any subsequent motion.
+     * @param {number} handle
+     * @param {Transform64} transform
+     * @private
+     */
+    __place(handle, transform) {
+        this.index.placePose(
+            handle,
+            transform[TRANSFORM64_TRANSLATION_OFFSET],
+            transform[TRANSFORM64_TRANSLATION_OFFSET + 1],
+            transform[TRANSFORM64_TRANSLATION_OFFSET + 2],
+            transform[TRANSFORM64_ROTATION_OFFSET],
+            transform[TRANSFORM64_ROTATION_OFFSET + 1],
+            transform[TRANSFORM64_ROTATION_OFFSET + 2],
+            transform[TRANSFORM64_ROTATION_OFFSET + 3]
+        );
+    }
+
     /**
      * @param {number} entity
      * @returns {number} the index handle, or `undefined` if the entity is not indexed