@woosh/meep-engine 3.43.0 → 3.44.0

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

@@ -21,16 +21,25 @@ import { ClothDynamics } from "./ClothDynamics.js";
  *
  * ## 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
@@ -38,7 +47,8 @@ import { ClothDynamics } from "./ClothDynamics.js";
 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 = -1;
@@ -49,11 +59,120 @@ export class ClothInstance {
     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 = 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 = -1;
+
+    /**
+     * 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 = 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 = 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 = [];
+
+    /**
+     * Which {@link holds} entry holds each node, `−1` for a free node.
+     * @type {Int32Array|null}
+     */
+    node_hold = null;
+
+    /**
+     * Where in its hold's particle list each held node is, `−1` for a free node.
+     * @type {Int32Array|null}
+     */
+    node_hold_slot = 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 = -1;
+
+    /**
+     * 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 = -1;
+
+    /**
+     * 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 = 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 = 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 = null;
+
+    /**
+     * How many {@link tether_loose} nodes are left.
+     * @type {number}
+     */
+    tether_loose_count = 0;
+
+    /**
+     * 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 = true;
+
+    /**
+     * The furthest any held node is carried this step, metres.
+     * @type {number}
+     */
+    kinematic_travel = 0;
+
     /**
      * `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
@@ -74,13 +193,18 @@ export class ClothInstance {
     node_count = 0;
 
     /**
-     * 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 = 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 = null;
@@ -105,8 +229,8 @@ export class ClothInstance {
     node_transform = [];
 
     /**
-     * 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[]}
@@ -114,7 +238,7 @@ export class ClothInstance {
     node_joint = [];
 
     /**
-     * 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
@@ -126,10 +250,10 @@ export class ClothInstance {
      * scabbard hangs from.
      * @type {Transform64}
      */
-    anchor_pose = new Transform64();
+    frame_pose = new 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
@@ -210,34 +334,55 @@ export class ClothInstance {
     particle_of_node = 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 = 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 = null;
+    rest_position = 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}
      */
+    rest_rotation = 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 = null;
+
+    /**
+     * The animated pose's orientation in the cloth's frame, 4 per node.
+     * @type {Float64Array|null}
+     */
     animated_rotation = null;
 
     /**
@@ -267,41 +412,126 @@ export class ClothInstance {
 
     /**
      * 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 = 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 = 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 = 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 = 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 = null;
+
+    /**
+     * Rest length of each {@link edge}, metres, in double — what the geodesics
+     * are summed from.
+     * @type {Float64Array|null}
+     */
+    edge_length = null;
+
+    /**
+     * The edges touching each node, CSR — the geodesic search's adjacency.
+     * @type {{offset: Int32Array, edge: Int32Array}|null}
+     */
+    edge_incidence = null;
+
+    /**
+     * Each hold's turn in the frame since it began, 4 per entry of {@link holds},
+     * rebuilt every step.
+     * @type {Float64Array}
+     */
+    hold_turn = new Float64Array(0);
+
+    /**
+     * 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 = null;
+
+    /**
+     * CSR offsets into {@link surface_triangle}, `node_count + 1` entries, or
+     * `null` for a cloth with no triangles.
+     * @type {Int32Array|null}
+     */
+    surface_offset = null;
+
+    /**
+     * The triangles around each node, as indices into {@link triangle}.
+     * @type {Int32Array|null}
+     */
+    surface_triangle = null;
+
+    /**
+     * One neighbour per node, along an edge — the direction a surface node's
+     * twist is measured by.
+     * @type {Int32Array|null}
+     */
+    surface_neighbour = 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 = null;
+
+    /**
+     * Stretch row carrying each {@link edge}.
      * @type {Int32Array|null}
      */
-    link_row = null;
+    edge_row = 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 = 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 = 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 = 0;
@@ -319,24 +549,24 @@ export class ClothInstance {
     shortest_row = 0;
 
     /**
-     * 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 = new Float64Array(3);
+    frame_translation = new Float64Array(3);
 
     /**
-     * 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 = new Float64Array([0, 0, 0, 1]);
+    frame_rotation = new Float64Array([0, 0, 0, 1]);
 
     /**
-     * `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 = false;
+    frame_valid = false;
 
     /**
      * What {@link Cloth#dynamics} looked like when the rows were last

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

@@ -0,0 +1,73 @@
+/**
+ * # This entity holds some of a cloth's particles
+ *
+ * Put it on whatever does the holding — a pole, a hook, a hand, a shoulder bone,
+ * the cloth's own entity — and the particles it names stop being simulated and
+ * follow it, each at the offset it had from this entity when the hold began.
+ *
+ * ```js
+ * pole.add(ClothPin.from({ cloth: flag, particles: flag_groups.hoist }));
+ * ```
+ *
+ * A cloth has as many holders as name it, and none is a cloth nothing holds:
+ * there is no anchor, and nothing about a pinned particle is different from a
+ * free one except that something holds it. That is the whole of §3.4's fixed
+ * set, made into a component.
+ *
+ * - **The hold begins where the particle is.** On a cloth's first step that is
+ *   its rest pose; added to a live cloth, it is wherever the fabric has got to,
+ *   which is what grabbing it means.
+ * - **Removing the component lets go**, and so does destroying this entity. A
+ *   particle let go carries the velocity its holder was giving it.
+ * - **The references are fixed while the component is attached**: remove it and
+ *   add it back to change them, the contract `TransformAttachment#parent` and
+ *   `IKGoal` carry.
+ * - **A particle has one holder.** When two pins name the same particle the one
+ *   on the lower entity holds it, every time.
+ * - **A holder the cloth itself moves is refused** — a link of the same rope,
+ *   or anything hanging below one — once, by name, because it would chase its
+ *   own write-back. The cloth's own entity is fine: it is the frame, and cloth
+ *   reads it.
+ *
+ * {@link particles} are indices in the cloth's own numbering: a `ClothProxy`'s
+ * particle order, which its builder hands back as groups, or — for a cloth
+ * over its own entity subtree — the breadth-first walk, where `0` is the entity
+ * carrying the `Cloth`.
+ *
+ * Saved with its entity (`ClothPinSerializationAdapter`): a scene's entities
+ * keep their ids across a save, and a rope saved without the pin that holds it
+ * would load as a rope that falls. A pin on a bone a model spawned goes with
+ * the bone, which is never saved, and is put back by whatever spawns the model.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ClothPin {
+    /**
+     * @param {{cloth: number, particles: Int32Array|number[]}} options every field required
+     * @returns {ClothPin}
+     */
+    static from({ cloth, particles }: {
+        cloth: number;
+        particles: Int32Array | number[];
+    }): ClothPin;
+    /**
+     * The entity carrying the {@link Cloth} whose particles this holds.
+     * @type {number}
+     */
+    cloth: number;
+    /**
+     * The particles held, in the cloth's own numbering.
+     * @type {Int32Array}
+     */
+    particles: Int32Array;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isClothPin: boolean;
+}
+export namespace ClothPin {
+    let typeName: string;
+}
+//# sourceMappingURL=ClothPin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClothPin.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothPin.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAcI;;;OAGG;IACH,kCAHW;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,UAAU,GAAC,MAAM,EAAE,CAAA;KAAC,GAC7C,QAAQ,CAgBpB;IA9BD;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,WAFU,UAAU,CAEU;IAuBlC;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B;;kBAUS,MAAM"}

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

@@ -0,0 +1,92 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * # This entity holds some of a cloth's particles
+ *
+ * Put it on whatever does the holding — a pole, a hook, a hand, a shoulder bone,
+ * the cloth's own entity — and the particles it names stop being simulated and
+ * follow it, each at the offset it had from this entity when the hold began.
+ *
+ * ```js
+ * pole.add(ClothPin.from({ cloth: flag, particles: flag_groups.hoist }));
+ * ```
+ *
+ * A cloth has as many holders as name it, and none is a cloth nothing holds:
+ * there is no anchor, and nothing about a pinned particle is different from a
+ * free one except that something holds it. That is the whole of §3.4's fixed
+ * set, made into a component.
+ *
+ * - **The hold begins where the particle is.** On a cloth's first step that is
+ *   its rest pose; added to a live cloth, it is wherever the fabric has got to,
+ *   which is what grabbing it means.
+ * - **Removing the component lets go**, and so does destroying this entity. A
+ *   particle let go carries the velocity its holder was giving it.
+ * - **The references are fixed while the component is attached**: remove it and
+ *   add it back to change them, the contract `TransformAttachment#parent` and
+ *   `IKGoal` carry.
+ * - **A particle has one holder.** When two pins name the same particle the one
+ *   on the lower entity holds it, every time.
+ * - **A holder the cloth itself moves is refused** — a link of the same rope,
+ *   or anything hanging below one — once, by name, because it would chase its
+ *   own write-back. The cloth's own entity is fine: it is the frame, and cloth
+ *   reads it.
+ *
+ * {@link particles} are indices in the cloth's own numbering: a `ClothProxy`'s
+ * particle order, which its builder hands back as groups, or — for a cloth
+ * over its own entity subtree — the breadth-first walk, where `0` is the entity
+ * carrying the `Cloth`.
+ *
+ * Saved with its entity (`ClothPinSerializationAdapter`): a scene's entities
+ * keep their ids across a save, and a rope saved without the pin that holds it
+ * would load as a rope that falls. A pin on a bone a model spawned goes with
+ * the bone, which is never saved, and is put back by whatever spawns the model.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ClothPin {
+
+    /**
+     * The entity carrying the {@link Cloth} whose particles this holds.
+     * @type {number}
+     */
+    cloth = -1;
+
+    /**
+     * The particles held, in the cloth's own numbering.
+     * @type {Int32Array}
+     */
+    particles = new Int32Array(0);
+
+    /**
+     * @param {{cloth: number, particles: Int32Array|number[]}} options every field required
+     * @returns {ClothPin}
+     */
+    static from({ cloth, particles }) {
+        assert.isNonNegativeInteger(cloth, 'cloth');
+        assert.defined(particles, 'particles');
+
+        const pin = new ClothPin();
+
+        pin.cloth = cloth;
+        pin.particles = Int32Array.from(particles);
+
+        for (let i = 0; i < pin.particles.length; i++) {
+            assert.isNonNegativeInteger(pin.particles[i], `particles[${i}]`);
+        }
+
+        return pin;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ClothPin.prototype.isClothPin = true;
+
+/**
+ * @readonly
+ * @type {string}
+ */
+ClothPin.typeName = "ClothPin";

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

@@ -0,0 +1,36 @@
+/**
+ * # Binary serialization for {@link ClothPin}
+ *
+ * The cloth's entity, then the particles. A rope is saved as its links and its
+ * `Cloth`; without its pin it would load as a rope nothing holds, and fall.
+ *
+ * The cloth is written as a raw entity id, the way `JointSerializationAdapter`
+ * writes its two: a scene's entities keep their ids across a save. A pin on an
+ * entity that is not saved — a bone a model spawned, which is transient — is
+ * not saved with it, and is put back by whatever spawns the model, as its
+ * `ClothRig` is.
+ *
+ * ## Version 0, and no upgrader
+ *
+ * A first version has no predecessor stream to upgrade from.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ClothPinSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof ClothPin;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ClothPin} value
+     */
+    serialize(buffer: BinaryBuffer, value: ClothPin): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {ClothPin} value
+     */
+    deserialize(buffer: BinaryBuffer, value: ClothPin): void;
+}
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { ClothPin } from "./ClothPin.js";
+//# sourceMappingURL=ClothPinSerializationAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClothPinSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothPinSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,uBAAiB;IAGjB;;;OAGG;IACH,uCAFW,QAAQ,QAYlB;IAED;;;OAGG;IACH,yCAFW,QAAQ,QAclB;CACJ;gDA5D+C,gEAAgE;yBACvF,eAAe"}