@woosh/meep-engine 3.44.0 → 3.46.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.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/Cloth.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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,CAYlB;IAED;;;;;;;;;;;;;;;;;MAQC;IAED;;OAEG;IACH,kDAFW,MAAM,QAehB;IAED,mBAEC;IAGL;;;OAGG;IACH,kBAFU,OAAO,CAEM;CANtB;;;;8BAlN6B,oBAAoB;2BACvB,iBAAiB"}

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

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { ClothDynamics } from "./ClothDynamics.js";
 import { ClothFlags } from "./ClothFlags.js";
@@ -169,10 +169,12 @@ export class Cloth {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
-            this.dynamics.hash(),
-            computeHashFloat(this.blend),
-            this.layer,
+        return hash_mix3(
+            hash_mix3(
+                this.dynamics.hash(),
+                computeHashFloat(this.blend),
+                this.layer
+            ),
             this.mask,
             this.flags
         );

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

@@ -1 +1 @@
-{"version":3,"file":"ClothCollider.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothCollider.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IA0CI;;;;;;;;OAQG;IACH;QAPyB,SAAS,GAAvB,MAAM;QACQ,cAAc,GAA5B,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACJ,aAAa,CA0BzB;IAzED;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,OAFU,MAAM,CAEgB;IAqChC;;;OAGG;IACH,cAHW,MAAM,GAAC,kBAAkB,GACvB,OAAO,CAInB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAgBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAUlB;IAED;;;;;;MAQC;IAED;;OAEG;IACH,4DAFW,MAAM,QAchB;IAED,mBAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;;;;mCA3LkC,yBAAyB"}
+{"version":3,"file":"ClothCollider.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothCollider.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IA0CI;;;;;;;;OAQG;IACH;QAPyB,SAAS,GAAvB,MAAM;QACQ,cAAc,GAA5B,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACJ,aAAa,CA0BzB;IAzED;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,OAFU,MAAM,CAEgB;IAqChC;;;OAGG;IACH,cAHW,MAAM,GAAC,kBAAkB,GACvB,OAAO,CAInB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAgBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAYlB;IAED;;;;;;MAQC;IAED;;OAEG;IACH,4DAFW,MAAM,QAchB;IAED,mBAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;;;;mCA7LkC,yBAAyB"}

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

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { ClothColliderFlags } from "./ClothColliderFlags.js";
 
@@ -149,10 +149,12 @@ export class ClothCollider {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.inflation),
-            computeHashFloat(this.friction_scale),
-            this.layer,
+        return hash_mix3(
+            hash_mix3(
+                computeHashFloat(this.inflation),
+                computeHashFloat(this.friction_scale),
+                this.layer
+            ),
             this.mask,
             this.flags
         );

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

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

@@ -8,26 +8,13 @@
  * @copyright Company Named Limited (c) 2026
  */
 export const ClothColliderFlags = {
-    None: 0,
+    None: 0
 
-    /**
-     * The collider never moves, so it is placed once and never swept.
-     *
-     * §8.2's swept collision interpolates each collider's pose between the
-     * previous step's and this one's, and rolling one pose into the other and
-     * refitting the swept bounds is the per-collider, per-step cost of that. A
-     * ground plane, a wall, a rock pays it for nothing, and a large static
-     * collider pays the most because its bounds are the biggest thing the
-     * broadphase tests against.
-     *
-     * Set this and the pose is written once, at link, into **both** slots, so
-     * 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. An explicit TRANSFORM64_EVENT_PLACED
-     * (including PhysicsSystem.setPose) does re-place a static proxy.
-     */
-    Static: 1
+    // Bit 0 was `Static`: "this collider never moves, so place it once and
+    // never sweep it". It is retired rather than reused, because saves carry
+    // it. The index skips the refit of a collider whose pose did not change,
+    // which is the saving the flag bought, observed rather than promised — and
+    // a "static" collider that moves anyway is swept like any other.
 };
 
 Object.freeze(ClothColliderFlags);

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

@@ -100,8 +100,7 @@ export class ClothColliderSystem extends System<any> {
      */
     refreshSurface(entity: number): void;
     /**
-     * Reset motion history at an explicitly published placement, including
-     * static proxies. The next refresh can still sweep any subsequent motion.
+     * Reset motion history at an explicitly published placement. The next refresh can still sweep any subsequent motion.
      * @param {number} handle
      * @param {Transform64} transform
      * @private

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":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;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;uBArQsB,wBAAwB;4BAMxC,uCAAuC;yBACrB,uBAAuB;8BAElB,oBAAoB;4CAVN,uDAAuD;mCAShE,mCAAmC"}
+{"version":3,"file":"ClothColliderSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothColliderSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;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,CA2BhB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,IAAI,CAyBhB;IAED;;;;;OAKG;IACH,gBAWC;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ;uBA5PsB,wBAAwB;4BAMxC,uCAAuC;yBACrB,uBAAuB;8BAElB,oBAAoB;4CAVN,uDAAuD;mCAShE,mCAAmC"}

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

@@ -10,7 +10,6 @@ import {
 import { Collider } from "../../ecs/Collider.js";
 import { ClothColliderIndex } from "../collider/ClothColliderIndex.js";
 import { ClothCollider } from "./ClothCollider.js";
-import { ClothColliderFlags } from "./ClothColliderFlags.js";
 
 /**
  * # The index's owner
@@ -176,15 +175,8 @@ export class ClothColliderSystem extends System {
         for (let i = 0; i < linked.length; i++) {
             const entry = linked[i];
 
-            const cloth_collider = entry.collider;
-
-            if ((cloth_collider.flags & ClothColliderFlags.Static) !== 0) {
-                // Placed once at link and never swept. `advance` has just made
-                // its previous pose equal to its current one, which is exactly
-                // the state a static collider wants and costs nothing to leave.
-                continue;
-            }
-
+            // A collider that has not moved since the last step is a pose equal
+            // to the one the index holds, which it does not refit.
             const transform = entry.transform;
 
             index.setPose(
@@ -235,8 +227,7 @@ export class ClothColliderSystem extends System {
     }
 
     /**
-     * Reset motion history at an explicitly published placement, including
-     * static proxies. The next refresh can still sweep any subsequent motion.
+     * Reset motion history at an explicitly published placement. The next refresh can still sweep any subsequent motion.
      * @param {number} handle
      * @param {Transform64} transform
      * @private

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

@@ -1 +1 @@
-{"version":3,"file":"ClothDynamics.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothDynamics.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IAgGI;;;;;;;;;;;;;;;;OAgBG;IACH;QAZyB,OAAO,GAArB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,OAAO,GAArB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,SAAS,GAAvB,MAAM;QACQ,OAAO,GAArB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,QAAQ,GAAtB,MAAM;QACQ,UAAU,GAAxB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACJ,aAAa,CAQzB;IArHD;;;;;OAKG;IACH,SAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,MAFU,MAAM,CAEL;IAEX;;;;OAIG;IACH,SAFU,MAAM,CAED;IAEf;;;;;;;OAOG;IACH,OAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,WAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;;;;;;;;;OAcG;IACH,MAFU,MAAM,CAEL;IAEX;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,OAFU,MAAM,CAEuB;IAEvC;;;OAGG;IACH,cAHW,MAAM,GAAC,kBAAkB,GACvB,OAAO,CAInB;IAkED;;;;;;OAMG;IACH,SAFa,aAAa,CAiBzB;IAED;;;OAGG;IACH,YAHW,aAAa,GACX,OAAO,CAenB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAqBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAelB;IAED;;;;;;;;;;;MAaC;IAED;;OAEG;IACH,eAFW,MAAM,QAIhB;IAED,mBAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;;;;mCAxUkC,yBAAyB"}
+{"version":3,"file":"ClothDynamics.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothDynamics.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IAgGI;;;;;;;;;;;;;;;;OAgBG;IACH;QAZyB,OAAO,GAArB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,OAAO,GAArB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACQ,SAAS,GAAvB,MAAM;QACQ,OAAO,GAArB,MAAM;QACQ,IAAI,GAAlB,MAAM;QACQ,QAAQ,GAAtB,MAAM;QACQ,UAAU,GAAxB,MAAM;QACQ,KAAK,GAAnB,MAAM;QACJ,aAAa,CAQzB;IArHD;;;;;OAKG;IACH,SAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,MAFU,MAAM,CAEL;IAEX;;;;OAIG;IACH,SAFU,MAAM,CAED;IAEf;;;;;;;OAOG;IACH,OAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,WAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;;;;;;;;;OAcG;IACH,MAFU,MAAM,CAEL;IAEX;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,OAFU,MAAM,CAEuB;IAEvC;;;OAGG;IACH,cAHW,MAAM,GAAC,kBAAkB,GACvB,OAAO,CAInB;IAkED;;;;;;OAMG;IACH,SAFa,aAAa,CAiBzB;IAED;;;OAGG;IACH,YAHW,aAAa,GACX,OAAO,CAenB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAqBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAuBlB;IAED;;;;;;;;;;;MAaC;IAED;;OAEG;IACH,eAFW,MAAM,QAIhB;IAED,mBAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;;;;mCAhVkC,yBAAyB"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { ClothDynamicsFlags } from "./ClothDynamicsFlags.js";
 
@@ -290,16 +291,24 @@ export class ClothDynamics {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.stretch),
-            computeHashFloat(this.bend),
-            computeHashFloat(this.damping),
-            computeHashFloat(this.slack),
-            computeHashFloat(this.thickness),
-            computeHashFloat(this.inertia),
-            computeHashFloat(this.drag),
-            this.substeps,
-            this.iterations,
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    hash_mix3(
+                        hash_mix3(
+                            computeHashFloat(this.stretch),
+                            computeHashFloat(this.bend),
+                            computeHashFloat(this.damping)
+                        ),
+                        computeHashFloat(this.slack),
+                        computeHashFloat(this.thickness)
+                    ),
+                    computeHashFloat(this.inertia),
+                    computeHashFloat(this.drag)
+                ),
+                this.substeps,
+                this.iterations
+            ),
             this.flags
         );
     }

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

@@ -1 +1 @@
-{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AAmEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;;OAMG;IACH,uBAKE;IA0BF;;;;;OAKG;IACH,2CAaC;IAED;;;;;OAKG;IACH,YALW,KAAK,aACL,WAAW,UACX,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAehB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAOhB;IA+YD;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAuBnC;IAED;;;;;;;;OAQG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,UACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAyFD;;;;;;;;;;;;OAYG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CAuUnB;;CA8GJ;8BAhlD6B,oBAAoB;0CAnB3C,gEAAgE;oCAenC,0BAA0B;sBA+BxC,YAAY;4BAzC3B,uCAAuC"}
+{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;;OAMG;IACH,uBAKE;IA0BF;;;;;OAKG;IACH,2CAaC;IAED;;;;;OAKG;IACH,YALW,KAAK,aACL,WAAW,UACX,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAehB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAOhB;IAmXD;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAuBnC;IAED;;;;;;;;OAQG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,UACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAyFD;;;;;;;;;;;;OAYG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CA6TnB;;CA0GJ;8BAtiD6B,oBAAoB;0CApB3C,gEAAgE;oCAgBnC,0BAA0B;sBA+BxC,YAAY;4BA1C3B,uCAAuC"}