@woosh/meep-engine 3.43.0 → 3.45.0

package/src/engine/physics/cloth/build/cloth_proxy_from_mesh.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @typedef {import("../../../graphics3/prefab/Prefab.js").Prefab} Prefab
+ * @typedef {import("../../../../shade/renderer/animation/Skin.js").Skin} Skin
+ * @typedef {import("./cloth_proxy_from_joints.js").ClothProxyBuildResult} ClothProxyBuildResult
+ */
+/**
+ * # Building a proxy for a sheet: one joint per vertex, and the triangles between them
+ *
+ * A sheet — a flag, a banner, a curtain, a cloth dropped on a sphere — is a
+ * triangle mesh, and what drives its render mesh is a skin with **one joint per
+ * vertex**: each vertex weighted wholly to its own joint, every joint hanging
+ * straight off one root joint. That skin is ordinary; the engine draws it the way
+ * it draws any skinned model, and cloth moves its joints the way it moves a
+ * cape's. This builds the proxy for it — §11.3's steps 4, 6 and 10 over a mesh
+ * that is already welded and already a particle set:
+ *
+ * - **a hard stretch row per edge**, every edge of every triangle once;
+ * - **a hinge per interior edge** — the shared edge, then the wing opposite it in
+ *   each triangle, which is `cloth_bend_row`'s stencil order. The stencil is built
+ *   here rather than read through `bt_edge_read_diamond`, whose quad puts the
+ *   shared edge in the middle;
+ * - the bind pose of every joint in the root joint's, and the root joint as the
+ *   frame the sheet is simulated in.
+ *
+ * **Nothing is pinned.** Which vertices are held is the scene's business — a pole
+ * holding a flag's hoist, a hook holding a ribbon's top — and a `ClothPin` names
+ * them by particle, which is their position in `joint_names`.
+ *
+ * ## What is refused, and why at build
+ *
+ * §7 P8: a triangle with no area (no normal, no stencil), an edge three triangles
+ * share (no single hinge across it), joints that do not all hang from the same
+ * root, and a name the skin does not have. Each is an authoring mistake, and each
+ * comes back as a message naming it rather than as a sheet that misbehaves.
+ *
+ * ## The rest shape is assumed flat where it bends
+ *
+ * The hinge is §6's quadratic stencil, which annihilates a planar rest shape and
+ * every affine image of it and reads a curved rest as already bent (§18). A flag,
+ * a sheet and a circle skirt cut flat are what this serves; a tube is not.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Build a proxy from the joints of a sheet's skin and the triangles over them.
+ *
+ * @param {Prefab} prefab the compiled model the joints are nodes of
+ * @param {Skin} skin one of the prefab's skins — joints as node indices
+ * @param {string[]} joint_names one joint per vertex; particle `i` is `joint_names[i]`
+ * @param {Int32Array|number[]} triangles indices into `joint_names`, 3 per triangle
+ * @param {object} [options]
+ * @param {string} [options.name]
+ * @returns {ClothProxyBuildResult}
+ */
+export function cloth_proxy_from_mesh(prefab: Prefab, skin: Skin, joint_names: string[], triangles: Int32Array | number[], { name }?: {
+    name?: string;
+}): ClothProxyBuildResult;
+export type Prefab = import("../../../graphics3/prefab/Prefab.js").Prefab;
+export type Skin = import("../../../../shade/renderer/animation/Skin.js").Skin;
+export type ClothProxyBuildResult = import("./cloth_proxy_from_joints.js").ClothProxyBuildResult;
+//# sourceMappingURL=cloth_proxy_from_mesh.d.ts.map

package/src/engine/physics/cloth/build/cloth_proxy_from_mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_proxy_from_mesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/build/cloth_proxy_from_mesh.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;GAUG;AACH,8CARW,MAAM,QACN,IAAI,eACJ,MAAM,EAAE,aACR,UAAU,GAAC,MAAM,EAAE;IAEF,IAAI,GAArB,MAAM;IACJ,qBAAqB,CA8MjC;qBApQY,OAAO,qCAAqC,EAAE,MAAM;mBACpD,OAAO,8CAA8C,EAAE,IAAI;oCAC3D,OAAO,8BAA8B,EAAE,qBAAqB"}

package/src/engine/physics/cloth/build/cloth_proxy_from_mesh.js

@@ -0,0 +1,275 @@
+import { tri3_area } from "../../../../core/geom/3d/triangle/tri3_area.js";
+import { ClothProxy } from "./ClothProxy.js";
+import { cloth_bind_in_frame, cloth_bind_scaled_above } from "./cloth_bind_in_frame.js";
+
+/**
+ * @typedef {import("../../../graphics3/prefab/Prefab.js").Prefab} Prefab
+ * @typedef {import("../../../../shade/renderer/animation/Skin.js").Skin} Skin
+ * @typedef {import("./cloth_proxy_from_joints.js").ClothProxyBuildResult} ClothProxyBuildResult
+ */
+
+/**
+ * # Building a proxy for a sheet: one joint per vertex, and the triangles between them
+ *
+ * A sheet — a flag, a banner, a curtain, a cloth dropped on a sphere — is a
+ * triangle mesh, and what drives its render mesh is a skin with **one joint per
+ * vertex**: each vertex weighted wholly to its own joint, every joint hanging
+ * straight off one root joint. That skin is ordinary; the engine draws it the way
+ * it draws any skinned model, and cloth moves its joints the way it moves a
+ * cape's. This builds the proxy for it — §11.3's steps 4, 6 and 10 over a mesh
+ * that is already welded and already a particle set:
+ *
+ * - **a hard stretch row per edge**, every edge of every triangle once;
+ * - **a hinge per interior edge** — the shared edge, then the wing opposite it in
+ *   each triangle, which is `cloth_bend_row`'s stencil order. The stencil is built
+ *   here rather than read through `bt_edge_read_diamond`, whose quad puts the
+ *   shared edge in the middle;
+ * - the bind pose of every joint in the root joint's, and the root joint as the
+ *   frame the sheet is simulated in.
+ *
+ * **Nothing is pinned.** Which vertices are held is the scene's business — a pole
+ * holding a flag's hoist, a hook holding a ribbon's top — and a `ClothPin` names
+ * them by particle, which is their position in `joint_names`.
+ *
+ * ## What is refused, and why at build
+ *
+ * §7 P8: a triangle with no area (no normal, no stencil), an edge three triangles
+ * share (no single hinge across it), joints that do not all hang from the same
+ * root, and a name the skin does not have. Each is an authoring mistake, and each
+ * comes back as a message naming it rather than as a sheet that misbehaves.
+ *
+ * ## The rest shape is assumed flat where it bends
+ *
+ * The hinge is §6's quadratic stencil, which annihilates a planar rest shape and
+ * every affine image of it and reads a curved rest as already bent (§18). A flag,
+ * a sheet and a circle skirt cut flat are what this serves; a tube is not.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Build a proxy from the joints of a sheet's skin and the triangles over them.
+ *
+ * @param {Prefab} prefab the compiled model the joints are nodes of
+ * @param {Skin} skin one of the prefab's skins — joints as node indices
+ * @param {string[]} joint_names one joint per vertex; particle `i` is `joint_names[i]`
+ * @param {Int32Array|number[]} triangles indices into `joint_names`, 3 per triangle
+ * @param {object} [options]
+ * @param {string} [options.name]
+ * @returns {ClothProxyBuildResult}
+ */
+export function cloth_proxy_from_mesh(prefab, skin, joint_names, triangles, { name = "" } = {}) {
+    if (prefab === undefined || prefab === null || prefab.isPrefab !== true) {
+        return refuse(`${name}: no prefab`);
+    }
+
+    if (skin === undefined || skin === null) {
+        return refuse(`${name}: no skin`);
+    }
+
+    const joints = skin.joints;
+    const parent_of = prefab.parent;
+    const name_of = prefab.name;
+
+    /**
+     * @type {Map<number, number>} node index → position in the skin's joints
+     */
+    const index_of = new Map();
+
+    /**
+     * @type {Map<string, number>}
+     */
+    const by_name = new Map();
+
+    for (let i = 0; i < joints.length; i++) {
+        index_of.set(joints[i], i);
+
+        const joint_name = name_of[joints[i]];
+
+        if (joint_name !== "" && !by_name.has(joint_name)) {
+            by_name.set(joint_name, joints[i]);
+        }
+    }
+
+    const particle_count = joint_names.length;
+
+    if (particle_count === 0) {
+        return refuse(`${name}: no joints`);
+    }
+
+    const node = new Int32Array(particle_count);
+
+    const seen = new Set();
+
+    for (let i = 0; i < particle_count; i++) {
+        const found = by_name.get(joint_names[i]);
+
+        if (found === undefined) {
+            return refuse(`${name}: the skin has no joint named "${joint_names[i]}"`);
+        }
+
+        if (seen.has(found)) {
+            return refuse(`${name}: "${joint_names[i]}" is named twice`);
+        }
+
+        seen.add(found);
+
+        node[i] = found;
+    }
+
+    // One root for every vertex joint: the frame, and what the write-back
+    // expresses each joint against.
+    const frame_node = parent_of[node[0]];
+
+    for (let i = 1; i < particle_count; i++) {
+        if (parent_of[node[i]] !== frame_node) {
+            return refuse(
+                `${name}: "${joint_names[0]}" hangs from "${name_of[frame_node] ?? 'nothing'}" and "${joint_names[i]}"`
+                + ` from "${name_of[parent_of[node[i]]] ?? 'nothing'}" — a sheet's joints hang from one root joint`
+            );
+        }
+    }
+
+    if (frame_node < 0 || !index_of.has(frame_node)) {
+        return refuse(`${name}: the sheet's joints hang from "${name_of[frame_node] ?? 'nothing'}", which is not a joint of this skin`);
+    }
+
+    const triangle_count = Math.floor(triangles.length / 3);
+
+    if (triangle_count * 3 !== triangles.length) {
+        return refuse(`${name}: ${triangles.length} triangle indices is not a whole number of triangles`);
+    }
+
+    // Every vertex joint hangs from the frame, so one walk up from any of them asks the lot.
+    const scaled = cloth_bind_scaled_above(prefab, node[0]);
+
+    if (scaled >= 0) {
+        const local = prefab.local[scaled];
+
+        return refuse(
+            `${name}: "${name_of[scaled]}", above "${name_of[node[0]]}", is scaled by (${local.scale_x}, ${local.scale_y}, ${local.scale_z}) at rest;`
+            + ` cloth poses its joints rigidly, so it would simulate a different garment from the one drawn`
+        );
+    }
+
+    const pose = cloth_bind_in_frame(prefab, frame_node);
+
+    const rest_position = new Float32Array(particle_count * 3);
+    const rest_rotation = new Float32Array(particle_count * 4);
+
+    for (let i = 0; i < particle_count; i++) {
+        const p = pose(node[i]);
+
+        rest_position[i * 3] = p[0];
+        rest_position[i * 3 + 1] = p[1];
+        rest_position[i * 3 + 2] = p[2];
+
+        rest_rotation[i * 4] = p[3];
+        rest_rotation[i * 4 + 1] = p[4];
+        rest_rotation[i * 4 + 2] = p[5];
+        rest_rotation[i * 4 + 3] = p[6];
+    }
+
+    /**
+     * Every edge once, keyed by its two particles, with the wing opposite it in
+     * each triangle that has it.
+     * @type {Map<number, {a: number, b: number, wings: number[]}>}
+     */
+    const edges = new Map();
+
+    for (let t = 0; t < triangle_count; t++) {
+        const i0 = triangles[t * 3];
+        const i1 = triangles[t * 3 + 1];
+        const i2 = triangles[t * 3 + 2];
+
+        for (const index of [i0, i1, i2]) {
+            if (!(index >= 0 && index < particle_count)) {
+                return refuse(`${name}: triangle ${t} names particle ${index} of ${particle_count}`);
+            }
+        }
+
+        if (tri3_area(
+            rest_position[i0 * 3], rest_position[i0 * 3 + 1], rest_position[i0 * 3 + 2],
+            rest_position[i1 * 3], rest_position[i1 * 3 + 1], rest_position[i1 * 3 + 2],
+            rest_position[i2 * 3], rest_position[i2 * 3 + 1], rest_position[i2 * 3 + 2]
+        ) <= 0) {
+            return refuse(
+                `${name}: triangle ${t} ("${joint_names[i0]}", "${joint_names[i1]}", "${joint_names[i2]}") has no area,`
+                + ` so no normal and no hinge across it`
+            );
+        }
+
+        const corners = [i0, i1, i2];
+
+        for (let k = 0; k < 3; k++) {
+            const a = corners[k];
+            const b = corners[(k + 1) % 3];
+            const wing = corners[(k + 2) % 3];
+
+            const lo = a < b ? a : b;
+            const hi = a < b ? b : a;
+
+            const key = lo * particle_count + hi;
+
+            let edge = edges.get(key);
+
+            if (edge === undefined) {
+                edge = { a: lo, b: hi, wings: [] };
+
+                edges.set(key, edge);
+            }
+
+            edge.wings.push(wing);
+
+            if (edge.wings.length > 2) {
+                return refuse(
+                    `${name}: the edge "${joint_names[lo]}"–"${joint_names[hi]}" is shared by more than two triangles,`
+                    + ` so there is no one hinge across it`
+                );
+            }
+        }
+    }
+
+    const edge = [];
+    const hinge = [];
+
+    for (const { a, b, wings } of edges.values()) {
+        edge.push(a, b);
+
+        if (wings.length === 2) {
+            hinge.push(a, b, wings[0], wings[1]);
+        }
+    }
+
+    const particle_name = joint_names.slice();
+
+    return {
+        proxy: ClothProxy.from({
+            name,
+            joint: Array.from(node, n => index_of.get(n)),
+            output: new Uint8Array(particle_count).fill(1),
+            // every joint hangs straight off the frame
+            parent: new Int32Array(particle_count).fill(-1),
+            edge,
+            skip: [],
+            hinge,
+            triangle: Int32Array.from(triangles),
+            frame: index_of.get(frame_node),
+            rest_position,
+            rest_rotation,
+            particle_name
+        }),
+        groups: [],
+        error: ""
+    };
+}
+
+/**
+ * @param {string} error
+ * @returns {ClothProxyBuildResult}
+ * @private
+ */
+function refuse(error) {
+    return { proxy: null, groups: [], error };
+}

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

@@ -164,6 +164,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

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

@@ -1 +1 @@
-{"version":3,"file":"ClothColliderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderIndex.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;IAEI;;;;;;OAMG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;;OAKG;IACH,MAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;OAMG;IACH,qBAFU,MAAM,CAEQ;IAoFxB;;;;;;;;;;;OAWG;IACH,sCAPW,MAAM,aACN,MAAM,SACN,MAAM,QACN,MAAM,UACN,MAAM,GACJ,MAAM,CA8DlB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,IAAI,CAoChB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAuDhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CA8BhB;IAwID;;;;;;;;;;;;;;;OAeG;IACH,kBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAmBhB;IAED;;;;;;;;OAQG;IACH,mBALW,MAAM,YACN,MAAM,aACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,IAAI,CAWhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAdW,MAAM,EAAE,SACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,YACN,OAAO,GAGL,MAAM,CAWlB;IAED;;;;;;;;;;;OAWG;IACH,gBARW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,QACN,MAAM,WACN,OAAO,GACL,MAAM,CA6DlB;;CAyGJ"}
+{"version":3,"file":"ClothColliderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderIndex.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;IAEI;;;;;;OAMG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;;OAKG;IACH,MAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;OAMG;IACH,qBAFU,MAAM,CAEQ;IAoFxB;;;;;;;;;;;OAWG;IACH,sCAPW,MAAM,aACN,MAAM,SACN,MAAM,QACN,MAAM,UACN,MAAM,GACJ,MAAM,CA8DlB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,IAAI,CAkChB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,IAAI,CA4ChB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAqBhB;IAsLD;;;;;;;;;;;;;;;OAeG;IACH,kBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;;;;;OAQG;IACH,mBALW,MAAM,YACN,MAAM,aACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,IAAI,CAWhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAdW,MAAM,EAAE,SACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,YACN,OAAO,GAGL,MAAM,CAWlB;IAED;;;;;;;;;;;OAWG;IACH,gBARW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,QACN,MAAM,WACN,OAAO,GACL,MAAM,CA6DlB;;CAyGJ"}

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"}