@woosh/meep-engine 3.43.0 → 3.44.0

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

@@ -17,23 +17,33 @@
  *
  * ## The local frame
  *
- * Particle positions live in the **anchor's own frame** — rigid, so translation
+ * Particle positions live in the **cloth's own frame** — rigid, so translation
  * and rotation but not scale, following the same convention the colliders use.
  * That is what makes §7 P7's inertia model natural (a cloth that feels none of
- * its anchor's motion is one whose local coordinates simply do not change) and,
+ * its frame's motion is one whose local coordinates simply do not change) and,
  * as a consequence rather than as a goal, what makes `Float32` positions ample:
  * the coordinates are garment-sized rather than world-sized.
  *
- * The anchor is node 0, particle `particle_of_node[0]`, sits at the local
- * origin, and is pinned. §11.1's "the anchor entity itself is the fixed set" is
- * that sentence.
+ * The frame is what the cloth **rides**: the entity carrying the `Cloth` for a
+ * subtree, the joint its proxy names for a rig. It is not what holds the cloth.
+ *
+ * ## What holds it
+ *
+ * Nothing, unless something says so. A {@link ClothPin} on any entity holds the
+ * particles it names, and a held particle is kinematic: it follows its holder
+ * at the offset it had when the hold began ({@link holds}). A cloth has as many
+ * holds as name it, and a cloth with none falls. Every quantity that used to be
+ * measured from "the anchor" — the tether, the slack profile, the animated pose
+ * the slack is measured against, `reach` — is measured from the nearest held
+ * particle instead, which for a rope hung from its own top is the same thing.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
 export class ClothInstance {
     /**
-     * The entity carrying the {@link Cloth} component — the anchor.
+     * The entity carrying the {@link Cloth} component. For a subtree cloth it is
+     * the root of the walk, node 0, and the cloth's frame.
      * @type {number}
      */
     entity: number;
@@ -42,10 +52,105 @@ export class ClothInstance {
      */
     cloth: Cloth | null;
     /**
-     * The anchor's world transform, which is also the cloth's local frame.
+     * The world transform of the entity carrying the {@link Cloth} — a subtree
+     * cloth's frame.
      * @type {Transform64|null}
      */
     transform: Transform64 | null;
+    /**
+     * The entity whose pose is the cloth's frame: {@link entity} for a subtree,
+     * the joint the proxy names for a rig.
+     * @type {number}
+     */
+    frame_entity: number;
+    /**
+     * Whether cloth writes each node's pose. `0` for a node that is an entity
+     * cloth only reads: a subtree's root, which is its frame, and the bones a
+     * rig hangs from. Such a node is still a particle — something can hold it,
+     * and links run from it — but its output is somebody else's.
+     * @type {Uint8Array|null}
+     */
+    node_output: Uint8Array | null;
+    /**
+     * The pose, in the cloth's frame, of the entity behind each node with no
+     * output — translation then rotation, 7 per node, meaningless for the rest.
+     *
+     * A node's local transform is written against its parent **entity**, and
+     * when that parent is not cloth's to write, its pose is whatever its owner
+     * gave it, not where its particle happens to be. A subtree's root is the
+     * frame, so the identity; a rig's bone is evaluated each step, in
+     * `advance`, so that the write-back reads a snapshot taken at the same
+     * moment under either system.
+     * @type {Float64Array|null}
+     */
+    boundary_pose: Float64Array | null;
+    /**
+     * Every hold on this cloth, by holder entity ascending, as
+     * {@link ClothWorld} applied them. Shared with the world's registry, so the
+     * offsets a hold captured outlive a re-seed.
+     * @type {ClothHold[]}
+     */
+    holds: ClothHold[];
+    /**
+     * Which {@link holds} entry holds each node, `−1` for a free node.
+     * @type {Int32Array|null}
+     */
+    node_hold: Int32Array | null;
+    /**
+     * Where in its hold's particle list each held node is, `−1` for a free node.
+     * @type {Int32Array|null}
+     */
+    node_hold_slot: Int32Array | null;
+    /**
+     * The registry version {@link holds} was built from. A different one is a
+     * hold added or let go, and the next step re-derives everything a hold
+     * decides.
+     * @type {number}
+     */
+    holds_version: number;
+    /**
+     * The {@link holds_version} whose holds are written into {@link state}, or
+     * `−1` for a state that holds nothing yet — a fresh seed.
+     * @type {number}
+     */
+    holds_applied: number;
+    /**
+     * The held node each node's tether and slack are measured from — the
+     * nearest, along the fabric — or `−1` where nothing held is reachable.
+     * @type {Int32Array|null}
+     */
+    tether_source: Int32Array | null;
+    /**
+     * Where each held node is to be at the end of this step, in the cloth's
+     * frame, 3 per node. Written in `advance`.
+     * @type {Float64Array|null}
+     */
+    held_target: Float64Array | null;
+    /**
+     * `1` for a node whose tether began wider than `d_geo` — a hold taken
+     * where the fabric already was — and is still coming down to it.
+     * `cloth_holds.js` carries why a tether starts loose.
+     * @type {Uint8Array|null}
+     */
+    tether_loose: Uint8Array | null;
+    /**
+     * How many {@link tether_loose} nodes are left.
+     * @type {number}
+     */
+    tether_loose_count: number;
+    /**
+     * Whether what `cloth_hold_step` derives — the held targets, the animated
+     * pose, the leash offsets — has to be derived again even though no hold has
+     * moved in the frame: the holds have just changed, or the particles have
+     * just been put somewhere (a teleport).
+     * @type {boolean}
+     */
+    holds_dirty: boolean;
+    /**
+     * The furthest any held node is carried this step, metres.
+     * @type {number}
+     */
+    kinematic_travel: number;
     /**
      * `false` until the subtree has been walked. Seeding is deferred to the
      * first step rather than done at link, because a rope's links arrive as
@@ -63,12 +168,17 @@ export class ClothInstance {
      */
     node_count: number;
     /**
-     * Entity per node, in walk order. Node 0 is the anchor.
+     * Entity per node, in walk order. Node 0 is the cloth's own entity.
      * @type {Int32Array|null}
      */
     node_entity: Int32Array | null;
     /**
-     * Parent node index, `−1` for the anchor.
+     * Parent node index, `−1` for a root: a subtree's node 0, a bone a rig
+     * hangs from.
+     *
+     * The seeder's **tree**, which is what the write-back reconstructs
+     * orientation along and expresses local transforms against. The rows are
+     * built from {@link edge}, {@link skip} and {@link hinge} instead.
      * @type {Int32Array|null}
      */
     node_parent: Int32Array | null;
@@ -90,15 +200,15 @@ export class ClothInstance {
      */
     node_transform: Transform64[];
     /**
-     * The joint entity each node drives. **Rig path only**, and node 0 is the
-     * anchor joint, which is not simulated. A skinned model is a prefab spawned
+     * The joint entity of each node. **Rig path only**; a node with no
+     * {@link node_output} is a bone the garment hangs from, which cloth reads. A skinned model is a prefab spawned
      * as entities, so a joint is an entity carrying a `TransformAttachment`,
      * and that offset is the writable handle; {@link node_attachment} holds it.
      * @type {Int32Array|number[]}
      */
     node_joint: Int32Array | number[];
     /**
-     * The anchor joint's **world** pose, evaluated on the CPU each step from the
+     * The frame joint's **world** pose, evaluated on the CPU each step from the
      * clips the entity is playing. **Rig path only.**
      *
      * Evaluated rather than read: a joint of an animated skeleton has granted
@@ -110,9 +220,9 @@ export class ClothInstance {
      * scabbard hangs from.
      * @type {Transform64}
      */
-    anchor_pose: Transform64;
+    frame_pose: Transform64;
     /**
-     * Live `TransformAttachment` per node; `null` for the anchor.
+     * Live `TransformAttachment` per node; `null` for a node with no output.
      *
      * **While a cloth is live this is its output, not its input.** The
      * write-back writes the local transform as well as the world one, so that a
@@ -182,33 +292,52 @@ export class ClothInstance {
      */
     particle_of_node: Int32Array | null;
     /**
-     * Geodesic distance from the anchor to each node, metres — the sum of the
-     * rest link lengths along the path, not the straight-line distance.
+     * Geodesic distance from each node to the nearest held node, metres — the
+     * rest lengths along the shortest path through the fabric, not the
+     * straight-line distance — and `Infinity` where nothing held is reachable.
      *
-     * This one array drives the tether radius, the slack profile and the pin,
-     * so the three cannot disagree (§3.4). The anchor's is zero, which is what
-     * makes it the fixed set without a second mechanism saying so.
+     * This one array drives the tether radius and the slack profile, so the two
+     * cannot disagree (§3.4). A held node's is zero.
      * @type {Float32Array|null}
      */
     geodesic: Float32Array | null;
     /**
-     * The animated pose in the cloth's local frame — position, 3 per node —
-     * composed once at seed from {@link rest_local_position} down the walk.
-     *
-     * **Constant, and that is a property of the entity path rather than an
-     * optimisation.** The subtree's authored pose is rigid relative to its
-     * anchor, so expressed in the anchor's own frame it does not move; the only
-     * thing that changes step to step is where that frame is. A subtree whose
-     * links are themselves animated is not an M1 case — that is the rig path,
-     * where the animated pose comes from the skeleton (§11.2) and is live.
+     * The rest pose in the cloth's frame — position, 3 per node — as the seeder
+     * found it: the authored subtree composed down from its root, or a rig's
+     * bind pose. Constant; what the rows' rest lengths are read from.
      * @type {Float32Array|null}
      */
-    animated_position: Float32Array | null;
+    rest_position: Float32Array | null;
     /**
-     * The animated pose's orientation in the cloth's local frame, 4 per node.
+     * The rest pose's orientation in the cloth's frame, 4 per node.
      * @type {Float32Array|null}
      */
-    animated_rotation: Float32Array | null;
+    rest_rotation: Float32Array | null;
+    /**
+     * The animated pose in the cloth's frame — position, 3 per node — which is
+     * the **rest pose hung from what holds it**, rebuilt every step:
+     *
+     *     s_i = x_p + R_p · (r_i − r_p)
+     *
+     * with `p` the nearest held node ({@link tether_source}), `x_p` where it
+     * is held this step and `R_p` how far its holder has turned in the frame
+     * since the hold began. A held node's is where it is held; a node nothing
+     * held reaches hangs from the frame, `s_i = r_i`.
+     *
+     * It is what the slack row is a leash to, what `blend = 0` shows and what a
+     * teleport resets to. §3.4's bound survives it exactly: `|s_i − x_p|` is the
+     * rest distance `|r_i − r_p|`, which is no more than `d_geo`, so with the
+     * tether a particle is never more than `2·d_geo` from its centre and
+     * `slack = 1` is still no leash at all. A cloth whose holders ride its frame
+     * has `s_i = r_i` for ever, which is the constant pose this used to be.
+     * @type {Float64Array|null}
+     */
+    animated_position: Float64Array | null;
+    /**
+     * The animated pose's orientation in the cloth's frame, 4 per node.
+     * @type {Float64Array|null}
+     */
+    animated_rotation: Float64Array | null;
     /**
      * The pose the write-back actually writes: the simulated position lerped
      * towards the animated one by {@link Cloth#blend}, in node order and in
@@ -234,36 +363,113 @@ export class ClothInstance {
     blended_rotation: Float64Array | null;
     /**
      * Leash row enforcing the slack bound for each node, `−1` where there is
-     * none — the anchor, and any node whose `slack` reaches the bound at which
-     * the row is provably inactive.
+     * none — a fabric whose `slack` reaches the bound at which the row is
+     * provably inactive. A node nothing holds has one of radius `Infinity`.
      * @type {Int32Array|null}
      */
     slack_row: Int32Array | null;
     /**
-     * Leash row enforcing the tether bound for each node, `−1` for the anchor.
+     * Leash row enforcing the tether bound for each node — every node has one,
+     * of radius `Infinity` while nothing it can reach is held.
      * @type {Int32Array|null}
      */
     tether_row: Int32Array | null;
     /**
-     * Stretch rows carrying the parent link of each node, `−1` for the anchor.
+     * The fabric: pairs of nodes joined by a hard stretch row, 2 per edge.
+     *
+     * **The particle graph, not the walk's tree.** A seeder hands over whatever
+     * joins its particles — a tree's parent links, a mesh's triangle edges — and
+     * `cloth_build_rows` builds the same rows from either. Nothing about the rows
+     * needs a parent, which is what lets a cloth be a sheet, or several pieces.
+     * @type {Int32Array|null}
+     */
+    edge: Int32Array | null;
+    /**
+     * A chain's bending model: pairs of nodes two links apart, joined by a soft
+     * stretch row at their authored distance (`cloth_seed_subtree.js` carries
+     * why a chain bends this way and a sheet does not), 2 per pair.
+     * @type {Int32Array|null}
+     */
+    skip: Int32Array | null;
+    /**
+     * A surface's bending model: four nodes per hinge — the shared edge, then
+     * the wing opposite it in each of its two triangles — which is
+     * `cloth_bend_row`'s stencil.
+     * @type {Int32Array|null}
+     */
+    hinge: Int32Array | null;
+    /**
+     * Rest length of each {@link edge}, metres, in double — what the geodesics
+     * are summed from.
+     * @type {Float64Array|null}
+     */
+    edge_length: Float64Array | null;
+    /**
+     * The edges touching each node, CSR — the geodesic search's adjacency.
+     * @type {{offset: Int32Array, edge: Int32Array}|null}
+     */
+    edge_incidence: {
+        offset: Int32Array;
+        edge: Int32Array;
+    } | null;
+    /**
+     * Each hold's turn in the frame since it began, 4 per entry of {@link holds},
+     * rebuilt every step.
+     * @type {Float64Array}
+     */
+    hold_turn: Float64Array;
+    /**
+     * Triangles over the nodes, 3 each, for a cloth with a surface — what a
+     * joint's orientation is read off when it has no chain to swing along.
+     * Empty for a chain.
+     * @type {Int32Array|null}
+     */
+    triangle: Int32Array | null;
+    /**
+     * CSR offsets into {@link surface_triangle}, `node_count + 1` entries, or
+     * `null` for a cloth with no triangles.
+     * @type {Int32Array|null}
+     */
+    surface_offset: Int32Array | null;
+    /**
+     * The triangles around each node, as indices into {@link triangle}.
+     * @type {Int32Array|null}
+     */
+    surface_triangle: Int32Array | null;
+    /**
+     * One neighbour per node, along an edge — the direction a surface node's
+     * twist is measured by.
+     * @type {Int32Array|null}
+     */
+    surface_neighbour: Int32Array | null;
+    /**
+     * Each hinge's effective inertia, kg — what its stiffness is a ratio of
+     * (`cloth_hinge_inertia`). Bend row `h` is hinge `h`.
+     * @type {Float32Array|null}
+     */
+    hinge_inertia: Float32Array | null;
+    /**
+     * Stretch row carrying each {@link edge}.
      * @type {Int32Array|null}
      */
-    link_row: Int32Array | null;
+    edge_row: Int32Array | null;
     /**
-     * Strain-limit rows on the same links, `−1` when the flag is clear.
+     * Strain-limit row on each {@link edge}, `−1` when the flag is clear.
      * @type {Int32Array|null}
      */
     strain_row: Int32Array | null;
     /**
-     * Skip rows — the bending model for a chain, one per node that has a
-     * grandparent. `−1` where there is none.
+     * Stretch row carrying each {@link skip} pair, `−1` when there is no bending
+     * to carry.
      * @type {Int32Array|null}
      */
     skip_row: Int32Array | null;
     /**
-     * Largest {@link geodesic} in the cloth: how far this cloth can reach from
-     * its anchor, and the length scale the anchor limits and the teleport
-     * threshold are derived from.
+     * How far this cloth can reach from what it hangs from — the largest
+     * {@link geodesic}, with a node nothing held reaches counted at its rest
+     * distance from the frame's origin, which is what it hangs from instead —
+     * and the length scale the frame limits, the teleport threshold and the
+     * sleep window are derived from.
      * @type {number}
      */
     reach: number;
@@ -279,22 +485,22 @@ export class ClothInstance {
      */
     shortest_row: number;
     /**
-     * The anchor's world translation as of the previous step, `[x, y, z]`.
+     * The frame's world translation as of the previous step, `[x, y, z]`.
      * @type {Float64Array}
      */
-    anchor_translation: Float64Array;
+    frame_translation: Float64Array;
     /**
-     * The anchor's world rotation as of the previous step, `[x, y, z, w]`.
+     * The frame's world rotation as of the previous step, `[x, y, z, w]`.
      * @type {Float64Array}
      */
-    anchor_rotation: Float64Array;
+    frame_rotation: Float64Array;
     /**
-     * `false` until the first step has recorded an anchor pose to compare
+     * `false` until the first step has recorded a frame pose to compare
      * against. The first step feels no inertia, which is correct: there is no
      * motion yet, only a starting place.
      * @type {boolean}
      */
-    anchor_valid: boolean;
+    frame_valid: boolean;
     /**
      * What {@link Cloth#dynamics} looked like when the rows were last
      * parameterised. Compared rather than watched — a value object is cheap to

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

@@ -1 +1 @@
-{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"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"}