@woosh/meep-engine 3.22.0 → 3.23.0

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

@@ -0,0 +1,49 @@
+/**
+ * # Putting the answer back onto a skinned model's joints — §11.2
+ *
+ * The same reconstruction the entity path uses, written onto `Node3D`s instead
+ * of onto entities. **Cloth moves joints; it does not produce vertices** — the
+ * mapping from a simulated joint to a render vertex already exists in this
+ * engine and it is the skin, so the existing skinning pass does the rest,
+ * including bounds refresh and BLAS refit that a bespoke vertex-deformation
+ * path would have to reimplement.
+ *
+ * ## `transform_local` is the output, and `transform_global` is written too
+ *
+ * `transform_local` is a joint's own truth and the handle §11.2 names. It is
+ * also *passive*: a `Node3D` does not track its components, and nothing
+ * downstream sees a change until `updateMatrices` runs — which recurses into
+ * every descendant, so calling it on the anchor would recompose the whole
+ * character every fixed step to move a cape.
+ *
+ * So this pass composes the cloth subtree's `transform_global` itself, which
+ * costs nothing because the pose is already in hand, and bumps each joint's
+ * version through `needsUpdate` so the renderer uploads the row. Nothing above
+ * the anchor is touched and nothing below the garment is walked.
+ *
+ * `transform_global` is derived, so writing it is only ever a shortcut for the
+ * recomposition it saves — and it is a *correct* shortcut only because this
+ * pass has the anchor's world pose and the whole chain under it. Anything that
+ * moves the anchor without telling cloth invalidates it, which is the same
+ * contract every consumer of a derived transform already has.
+ *
+ * ## What is not here
+ *
+ * No announcement, and no pruned boundary. The entity path has both because its
+ * subtree is an entity hierarchy with other things hanging off it; a proxy's
+ * joint list is closed by construction, and a socket parented to a cape joint
+ * follows it through the ordinary node hierarchy.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Write one cloth's solved pose onto the joints it drives.
+ *
+ * @param {ClothInstance} instance
+ * @param {Transform64} anchor the anchor joint's **world** pose, evaluated by
+ *   the caller — see `ClothSystem` for why it is not read off the node
+ * @returns {void}
+ */
+export function cloth_write_back_rig(instance: ClothInstance, anchor: Transform64): void;
+//# sourceMappingURL=cloth_write_back_rig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_write_back_rig.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back_rig.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;GAOG;AACH,oFAFa,IAAI,CA2DhB"}

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

@@ -0,0 +1,115 @@
+import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import {
+    TRANSFORM64_ROTATION_OFFSET,
+    TRANSFORM64_TRANSLATION_OFFSET
+} from "../../../ecs/transform/Transform64.js";
+import { cloth_reconstruct_pose } from "./cloth_reconstruct_pose.js";
+import { cloth_write_local_pose } from "./cloth_write_back.js";
+
+/**
+ * # Putting the answer back onto a skinned model's joints — §11.2
+ *
+ * The same reconstruction the entity path uses, written onto `Node3D`s instead
+ * of onto entities. **Cloth moves joints; it does not produce vertices** — the
+ * mapping from a simulated joint to a render vertex already exists in this
+ * engine and it is the skin, so the existing skinning pass does the rest,
+ * including bounds refresh and BLAS refit that a bespoke vertex-deformation
+ * path would have to reimplement.
+ *
+ * ## `transform_local` is the output, and `transform_global` is written too
+ *
+ * `transform_local` is a joint's own truth and the handle §11.2 names. It is
+ * also *passive*: a `Node3D` does not track its components, and nothing
+ * downstream sees a change until `updateMatrices` runs — which recurses into
+ * every descendant, so calling it on the anchor would recompose the whole
+ * character every fixed step to move a cape.
+ *
+ * So this pass composes the cloth subtree's `transform_global` itself, which
+ * costs nothing because the pose is already in hand, and bumps each joint's
+ * version through `needsUpdate` so the renderer uploads the row. Nothing above
+ * the anchor is touched and nothing below the garment is walked.
+ *
+ * `transform_global` is derived, so writing it is only ever a shortcut for the
+ * recomposition it saves — and it is a *correct* shortcut only because this
+ * pass has the anchor's world pose and the whole chain under it. Anything that
+ * moves the anchor without telling cloth invalidates it, which is the same
+ * contract every consumer of a derived transform already has.
+ *
+ * ## What is not here
+ *
+ * No announcement, and no pruned boundary. The entity path has both because its
+ * subtree is an entity hierarchy with other things hanging off it; a proxy's
+ * joint list is closed by construction, and a socket parented to a cape joint
+ * follows it through the ordinary node hierarchy.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Write one cloth's solved pose onto the joints it drives.
+ *
+ * @param {ClothInstance} instance
+ * @param {Transform64} anchor the anchor joint's **world** pose, evaluated by
+ *   the caller — see `ClothSystem` for why it is not read off the node
+ * @returns {void}
+ */
+export function cloth_write_back_rig(instance, anchor) {
+    cloth_reconstruct_pose(instance);
+
+    const node_count = instance.node_count;
+
+    const blended = instance.blended_position;
+    const reconstructed = instance.blended_rotation;
+
+    const ax = anchor[TRANSFORM64_TRANSLATION_OFFSET];
+    const ay = anchor[TRANSFORM64_TRANSLATION_OFFSET + 1];
+    const az = anchor[TRANSFORM64_TRANSLATION_OFFSET + 2];
+
+    const aqx = anchor[TRANSFORM64_ROTATION_OFFSET];
+    const aqy = anchor[TRANSFORM64_ROTATION_OFFSET + 1];
+    const aqz = anchor[TRANSFORM64_ROTATION_OFFSET + 2];
+    const aqw = anchor[TRANSFORM64_ROTATION_OFFSET + 3];
+
+    const parent = instance.node_parent;
+    const node_joint = instance.node_joint;
+
+    for (let node = 1; node < node_count; node++) {
+        const joint = node_joint[node];
+
+        if (joint === undefined || joint === null) {
+            continue;
+        }
+
+        cloth_write_local_pose(joint.transform_local, instance, node, parent[node]);
+
+        const global = joint.transform_global;
+
+        const n = node * 3;
+
+        v3_quaternion_apply(
+            global, TRANSFORM64_TRANSLATION_OFFSET,
+            blended[n], blended[n + 1], blended[n + 2],
+            aqx, aqy, aqz, aqw
+        );
+
+        global[TRANSFORM64_TRANSLATION_OFFSET] += ax;
+        global[TRANSFORM64_TRANSLATION_OFFSET + 1] += ay;
+        global[TRANSFORM64_TRANSLATION_OFFSET + 2] += az;
+
+        quat3_multiply(
+            global, TRANSFORM64_ROTATION_OFFSET,
+            aqx, aqy, aqz, aqw,
+            reconstructed[node * 4], reconstructed[node * 4 + 1],
+            reconstructed[node * 4 + 2], reconstructed[node * 4 + 3]
+        );
+
+        global.updateMatrix();
+
+        // The version is what the renderer compares against to decide whether
+        // to upload the row, so a joint whose transform changed and whose
+        // version did not is a joint that moved nowhere.
+        joint.needsUpdate = true;
+    }
+}

package/src/engine/physics/cloth/playground/README.md

@@ -4,13 +4,15 @@
 npm run dev --workspace @woosh/meep-engine
 ```
 
-Two pages, one directory, one layer of the system each. (Vite takes the next
+Four pages, one directory, one layer of the system each. (Vite takes the next
 free port if 5173 is busy — the terminal says which.)
 
 | | |
 |---|---|
 | [`index.html`](./index.html) | **the solver, M0.** `cloth_step` over a `ClothState`, no ECS at all. |
 | [`rig.html`](./rig.html) | **the entity subtree, M1.** A real `EntityManager`, real entities, `ClothSystem` walking and writing back. |
+| [`collide.html`](./collide.html) | **collision, M2.** The solver again, with a packed collider table in the argument list. |
+| [`garment.html`](./garment.html) | **skinned garments, M3, and self-collision, M4.** A `Node3D` skeleton, a `Skin`, and a `Cloth` + `ClothRig` driving some of its joints. |
 
 Both are at
 `http://localhost:5173/src/engine/physics/cloth/playground/<page>`.
@@ -183,3 +185,155 @@ real: `rebuild` returns a promise, because `EntityManager#startup` does and an
 entity created before it resolves is never linked; and `render` is separate from
 `step_once`, because `requestAnimationFrame` does not fire in a hidden pane and
 everything on the page hangs off it.
+
+---
+
+# The collision page — `collide.html`
+
+## What it is
+
+The solver page again, with a **packed collider table** in `cloth_step`'s
+argument list. There is no `EntityManager`, no `ClothColliderIndex` and no
+`ClothColliderSystem`: `collide_build.js` hands the solver exactly what
+`cloth_gather_colliders` would, already in the cloth's own frame, so what is on
+screen is the layer M2's findings live in and nothing above it.
+
+Two of those findings are things to *watch* rather than read.
+
+**The sweep, which is not really about tunnelling.** Pick **a capsule swept
+through** and press *end-of-step only*. The capsule stops being *noticed*: the
+contact readout drops by four while the capsule visibly passes through the sheet.
+Discovery evaluates the field at the end-of-step pose, so a collider that crossed
+the cloth within the step is nowhere near it by then, and without the travel term
+in the discovery reach no row is ever created for the swept poses to act through.
+At 20 m/s in `MEASUREMENTS.md` §20 the difference is 95 rows a step against none.
+
+**The penalty floor, which decides how hard a new contact hits.** Pick **the
+ground**, drag `k_min ÷ k_max` to 1, and press *reset*: the cape slaps down.
+Drag it back to 1/32 and it lands. Peak contact force across that range measured
+18.9 N against 0.16 N, and the settled energy six orders of magnitude apart —
+with the *penetration improving* at the low end, which is the augmented
+Lagrangian working as designed. §17.
+
+## The scenes
+
+- **sphere under a cape** — the simplest thing a contact row can be right about.
+- **every primitive** — sphere, capsule, box and cylinder side by side, each
+  protruding 25 mm through the sheet. Four different fields, one dispatch, and
+  the same free functions the shape classes now call.
+- **the ground** — `PlaneShape3D`, which §14.3 asked for and did not exist.
+- **a shoulder, animated** — three capsules as an arm, swinging. The swept pose,
+  in the configuration it was designed for.
+- **a capsule swept through** — 3 m/s straight through the sheet. The sweep
+  toggle's scene.
+- **a spinning bar** — a bar turning behind the cape and through its plane. It is
+  also the one scene that does not resolve: a rigid collider driven through cloth
+  that is pinned above it wraps rather than parts, and the 18 mm of resting
+  penetration is the row bounding a case it cannot prevent. That is authoring
+  rather than a solver gap, and it is here so it is visible rather than
+  surprising.
+
+## The readout
+
+- **contacts** — rows the discovery pass created this step. Zero while a collider
+  is visibly passing through the cloth is the finding above.
+- **worst penetration** — the deepest any particle got, over the whole run.
+- **resting penetration** — how deep anything is *now*. This is the number that
+  says whether a screenshot showing a sphere apparently poking through a cape is
+  a simulation problem or a drawing one — the collider outline is dashed and has
+  no depth test, so it is painted over the cloth whether it is in front or behind.
+- **step** — milliseconds for `cloth_contact_find` plus `cloth_step`, window
+  minimum, against §17's 2 ms. Browser `performance.now()` is coarse and a hidden
+  pane throttles the page; `__fixtures__/cloth_m2_measure.mjs` under node is the
+  number that means something.
+
+## Notes
+
+`globalThis.cloth_collide_playground` exposes `{ control, camera, rebuild,
+step_once, penetration, cloth, colliders, contacts }`. `requestAnimationFrame`
+does not fire in a hidden pane, so a driver calls `step_once` itself.
+
+---
+
+# The garment page — `garment.html`
+
+## What it is
+
+`rig.html` is a `Cloth` over an entity subtree; this is a `Cloth` + a `ClothRig`
+over a skinned model's **joints**. Every point on screen is a
+`Node3D.transform_global` — a joint of a `Skin`, not an entity — and it is where
+it is because the solver wrote its `transform_local` and this page composed the
+chain.
+
+`ClothSystem#models` takes a stub rather than a `MeshSystem` for the reason the
+field exists: a `MeshSystem` needs a graphics engine, a scene and a loader, and a
+garment's joints are a `Node3D` tree that needs none of the three. The stub
+answers exactly the one method the system calls.
+
+## The garments
+
+- **cape** — five strips of seven off the chest. The common case and the cheap
+  one: an artist made the joints and skinned the cape to them, so the proxy is
+  joint indices, the topology and the bind pose. No binding step, no generated
+  geometry.
+- **coat tails** — three strips of nine in denim, which is the library entry that
+  spends its two levers on particles rather than iterations.
+- **ponytail** — one chain of twelve off the neck. The rig path is the entity
+  path with `Node3D`s in it, and a single chain is where that is most obviously
+  true.
+- **loincloth** — seven strips of five off the pelvis, and the one preset that
+  spends most of its time against the leg colliders.
+
+## The motion drives the character, and only the character
+
+The buttons write the **character's own bones**. The garment's joints are
+cloth's, and the seed says so: it claims `TransformAuthority.CPU` on every one of
+them, because a joint a clip drives is under GPU authority and its
+`transform_local` is not read by anything. Two writers of one row is the race the
+authority enum exists to prevent, and the claim is where a garment whose joints
+are *also* keyed shows up as an authoring error.
+
+**sprint** is §7 P7's own profile: a square wave in velocity, integrated. Written
+as a position that resets it would be a nine-metre discontinuity, which is a
+teleport wearing a sprint's clothes — and the cloth would be right to treat it as
+one.
+
+## The readout
+
+- **worst |x−anchor| / d_geo** — §7 P2's rubber number. Green at rest and under
+  walking and turning; **sprint takes it past 1.1**, which is P2's own conditional
+  bound showing on a shape M1 did not measure. `MEASUREMENTS.md` §26 has both
+  paths side by side, and they agree to the digit — this is the geometry, not the
+  rig path.
+- **contacts** — with **collide with the body** on. A cape clear of its own
+  torso reads zero here most of the time, which is what a garment that was
+  authored correctly looks like; see below.
+- **self pairs** — M4's, with **collide with itself** on. Zero while the
+  garment hangs and climbing the moment a fold closes, which is the shape of
+  the whole tier: it is a broadphase over particles and it has nothing to do
+  until two of them are near. Three library entries set the flag — silk,
+  cotton and hair — and the button overrides whichever the fabric picker is
+  on, by cloning the frozen entry and moving one bit.
+
+  **The radius is the proxy's resolution, not the fabric's thickness**, and it
+  is the single thing most worth knowing about this tier. Silk is 4 mm thick
+  and this cape's particles are 8 cm apart; at 4 mm the two layers of a fold
+  are never in contact and the feature does nothing at all.
+  `MEASUREMENTS.md` §31 is the sweep, §36 is the clamp at the other end.
+
+## The one thing worth knowing before authoring a garment
+
+A garment authored **inside** its own body collider reads as a *tether* failure.
+The contact row pushes it out, the tether pulls it back, the contact wins, and
+the readout says the tether is failing by thirty per cent. It is not. §11.3
+step 10 validates exactly this at build time — "the skinned bind pose is
+collision-free against the character's `ClothCollider` set" — and M3 does not
+build that check, so this page's geometry is right by hand. `MEASUREMENTS.md` §29
+has the numbers, because it cost an hour to diagnose the first time.
+
+## Notes
+
+`globalThis.cloth_garment_playground` exposes `{ control, camera, ready, rebuild,
+step_once, draw, scene }`. `rebuild` returns a promise, because
+`EntityManager#startup` does and an entity created before it resolves is never
+linked.

package/src/engine/physics/cloth/playground/collide.html

@@ -0,0 +1,178 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>meep — cloth collision (M2)</title>
+    <style>
+        :root {
+            color-scheme: dark;
+            --ink: #d6dae0;
+            --dim: #8b939f;
+            --line: #2b3038;
+            --panel: #14171c;
+            --warn: #e5b54a;
+            --bad: #e5533d;
+            --good: #5ad19a;
+        }
+
+        html, body {
+            margin: 0;
+            height: 100%;
+            background: #0d0f12;
+            color: var(--ink);
+            font: 12px/1.5 ui-monospace, Consolas, monospace;
+            overflow: hidden;
+        }
+
+        body { display: flex; }
+
+        #stage { position: relative; flex: 1; min-width: 0; }
+        #view { display: block; width: 100%; height: 100%; cursor: grab; }
+        #view.grabbing { cursor: grabbing; }
+
+        #hint {
+            position: absolute; left: 14px; bottom: 12px;
+            color: var(--dim); pointer-events: none;
+        }
+
+        #readout {
+            position: absolute; left: 14px; top: 12px;
+            background: rgba(13, 15, 18, 0.82);
+            border: 1px solid var(--line);
+            padding: 8px 12px;
+            min-width: 260px;
+        }
+
+        #readout table { border-collapse: collapse; width: 100%; }
+        #readout td { padding: 1px 0; white-space: nowrap; }
+        #readout td:last-child { text-align: right; padding-left: 18px; }
+        #readout td:first-child { color: var(--dim); }
+
+        #budget {
+            height: 4px; margin-top: 7px;
+            background: #22262d; position: relative; overflow: hidden;
+        }
+        #budget > i { display: block; height: 100%; background: var(--good); width: 0; }
+        #budget.over > i { background: var(--bad); }
+
+        aside {
+            width: 310px; flex: none; overflow-y: auto;
+            background: var(--panel); border-left: 1px solid var(--line);
+            padding: 12px 14px 40px;
+        }
+
+        aside h2 {
+            font-size: 11px; text-transform: uppercase; letter-spacing: 0.08em;
+            color: var(--dim); margin: 18px 0 6px; font-weight: 600;
+        }
+
+        aside h2:first-child { margin-top: 0; }
+
+        .blurb { color: var(--dim); margin: 0 0 8px; font-size: 11px; }
+        .blurb b { color: var(--ink); font-weight: 600; }
+
+        label { display: flex; align-items: center; gap: 8px; margin: 3px 0; }
+        label > span { flex: none; width: 96px; color: var(--dim); }
+        label > input[type=range] { flex: 1; min-width: 0; accent-color: #6b8afd; }
+        label > output { flex: none; width: 54px; text-align: right; }
+
+        select {
+            width: 100%; background: #1b1f26; color: var(--ink);
+            border: 1px solid var(--line); padding: 4px 6px; font: inherit;
+        }
+
+        .buttons { display: flex; flex-wrap: wrap; gap: 6px; margin: 6px 0; }
+
+        button {
+            background: #1b1f26; color: var(--ink); border: 1px solid var(--line);
+            padding: 4px 9px; font: inherit; cursor: pointer;
+        }
+
+        button:hover { border-color: #47506045; background: #232833; }
+        button.on { background: #2b3546; border-color: #4a5b7d; color: #cfe0ff; }
+
+        .bad { color: var(--bad); }
+        .warn { color: var(--warn); }
+        .good { color: var(--good); }
+    </style>
+</head>
+<body>
+<div id="stage">
+    <canvas id="view"></canvas>
+
+    <div id="readout">
+        <table>
+            <tr><td>step</td><td id="r_step">—</td></tr>
+            <tr><td>contacts</td><td id="r_contacts">—</td></tr>
+            <tr><td>worst penetration</td><td id="r_pen">—</td></tr>
+            <tr><td>resting penetration</td><td id="r_rest">—</td></tr>
+            <tr><td>kinetic energy</td><td id="r_energy">—</td></tr>
+            <tr><td>finite</td><td id="r_finite">—</td></tr>
+        </table>
+        <div id="budget"><i></i></div>
+    </div>
+
+    <div id="hint">drag to orbit · shift-drag to pan · wheel to zoom · the dashed collider outline has no depth test</div>
+</div>
+
+<aside>
+    <h2>Scene</h2>
+    <select id="scene"></select>
+    <p class="blurb" id="scene_blurb"></p>
+
+    <h2>Cloth</h2>
+    <label><span>particles</span><input id="size" type="range" min="8" max="34" step="1"><output id="size_out"></output></label>
+    <label><span>spacing</span><input id="spacing" type="range" min="0.01" max="0.08" step="0.002"><output id="spacing_out"></output></label>
+    <label><span>thickness</span><input id="thickness" type="range" min="0.001" max="0.05" step="0.001"><output id="thickness_out"></output></label>
+    <p class="blurb">
+        <b>thickness</b> is the contact offset: the row holds every particle that far off the surface,
+        and a row is created — inactive — from twice that out. It is <i>not</i> where the velocity
+        clamp comes from; §7 P1 measured that and it is the solver's own correction authority.
+    </p>
+
+    <h2>Surface</h2>
+    <label><span>friction</span><input id="friction" type="range" min="0" max="2" step="0.02"><output id="friction_out"></output></label>
+    <label><span>inflation</span><input id="inflation" type="range" min="0" max="0.06" step="0.002"><output id="inflation_out"></output></label>
+    <p class="blurb">
+        Friction is a row on the same contact, clamped at <b>μ·f<sub>n</sub></b> — the collision row's
+        own force this iteration. Its anchor lives in the <b>collider's</b> frame, which is what makes
+        a sliding surface drag cloth instead of a stationary point holding it still.
+    </p>
+
+    <h2>Budget</h2>
+    <label><span>substeps</span><input id="substeps" type="range" min="1" max="8" step="1"><output id="substeps_out"></output></label>
+    <label><span>iterations</span><input id="iterations" type="range" min="1" max="16" step="1"><output id="iterations_out"></output></label>
+
+    <h2>Contact band</h2>
+    <p class="blurb">
+        M0 could not choose these: the ramp only means something for a row that <b>arrives</b>, and a
+        contact is the first one in the system that does. Measured defaults are
+        k_min = k_max/32 and β = 1e3.
+    </p>
+    <label><span>k_min ÷ k_max</span><input id="k_floor" type="range" min="-7" max="0" step="0.25"><output id="k_floor_out"></output></label>
+    <label><span>β</span><input id="beta" type="range" min="0" max="7" step="0.25"><output id="beta_out"></output></label>
+    <div class="buttons"><button id="defaults">measured defaults</button></div>
+
+    <h2>Sweep</h2>
+    <div class="buttons">
+        <button id="sweep" class="on">swept (§8.2)</button>
+        <button id="unswept">end-of-step only</button>
+    </div>
+    <p class="blurb">
+        With the sweep off, a collider's previous pose is its current one: the substeps stop
+        interpolating <i>and</i> the discovery pass loses the travel margin. On the swept-capsule
+        scene that is the difference between a capsule the cloth notices and one it does not.
+    </p>
+
+    <h2>Run</h2>
+    <div class="buttons">
+        <button id="pause">pause</button>
+        <button id="single">step once</button>
+        <button id="reset">reset</button>
+        <button id="animate" class="on">animate colliders</button>
+    </div>
+</aside>
+
+<script type="module" src="./collide_main.js"></script>
+</body>
+</html>

package/src/engine/physics/cloth/playground/collide_build.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} angle radians
+ * @returns {number[]} `[x, y, z, w]`
+ */
+export function axis_angle(x: number, y: number, z: number, angle: number): number[];
+/**
+ * Move a record, carrying its current pose into its previous one — what a fixed
+ * step does to the index.
+ *
+ * @param {ColliderScene} built
+ * @param {number} record
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function move(built: ColliderScene, record: number, x: number, y: number, z: number): void;
+/**
+ * @param {ColliderScene} built
+ * @param {number} record
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]} rotation
+ */
+export function turn(built: ColliderScene, record: number, x: number, y: number, z: number, rotation: number[]): void;
+/**
+ * Freeze a record's previous pose onto its current one, so the sweep has nothing
+ * to interpolate. This is the "sweep off" switch, and it is exactly what the
+ * design would be without §8.2.
+ *
+ * @param {ColliderScene} built
+ * @param {number} record
+ */
+export function unsweep(built: ColliderScene, record: number): void;
+/**
+ * # The collider scenes the M2 page collides against
+ *
+ * Packed tables built straight from shapes, already in the cloth's own frame —
+ * there is no `EntityManager` on this page, so `ClothColliderIndex` and
+ * `ClothColliderSystem` are not in the loop and everything below the gather is.
+ *
+ * Kept beside the page rather than in `__fixtures__` for the reason
+ * `cloth_playground_build.js` gives: `__fixtures__` is excluded from the
+ * published package and the playground is not, so importing across that line
+ * would ship a broken module.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @typedef {object} ColliderScene
+ * @property {string} label
+ * @property {string} blurb what the scene is for
+ * @property {Float32Array} table packed records, cloth-local
+ * @property {Int32Array} keys
+ * @property {number} count
+ * @property {AbstractShape3D[]} shape the shape behind each record, for drawing
+ * @property {function(number, number): void} [animate] `(record, time) => void`
+ */
+/**
+ * Every scene, by name.
+ * @type {Readonly<Object<string, {label: string, blurb: string, build: function}>>}
+ */
+export const COLLIDER_SCENES: Readonly<{
+    [x: string]: {
+        label: string;
+        blurb: string;
+        build: Function;
+    };
+}>;
+export type ColliderScene = {
+    label: string;
+    /**
+     * what the scene is for
+     */
+    blurb: string;
+    /**
+     * packed records, cloth-local
+     */
+    table: Float32Array;
+    keys: Int32Array;
+    count: number;
+    /**
+     * the shape behind each record, for drawing
+     */
+    shape: AbstractShape3D[];
+    /**
+     * `(record, time) => void`
+     */
+    animate?: (arg0: number, arg1: number) => void;
+};
+//# sourceMappingURL=collide_build.d.ts.map

package/src/engine/physics/cloth/playground/collide_build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collide_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/collide_build.js"],"names":[],"mappings":"AAsKA;;;;;;GAMG;AACH,8BANW,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,GACJ,MAAM,EAAE,CAOpB;AAyDD;;;;;;;;;GASG;AACH,4BANW,aAAa,UACb,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAchB;AAED;;;;;;;GAOG;AACH,4BAPW,aAAa,UACb,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,EAAE,QAmBlB;AAED;;;;;;;GAOG;AACH,+BAHW,aAAa,UACb,MAAM,QAMhB;AA/QD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AAEH;;;GAGG;AACH,8BAFU;QAAgB,MAAM,GAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,WAAU;KAAC;EAAE,CA4GhF;;WAvHW,MAAM;;;;WACN,MAAM;;;;WACN,YAAY;UACZ,UAAU;WACV,MAAM;;;;WACN,iBAAiB;;;;qBACR,MAAM,QAAE,MAAM,KAAG,IAAI"}