@woosh/meep-engine 3.22.0 → 3.23.0

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

@@ -0,0 +1,328 @@
+import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import {
+    CCR_FEATURE,
+    CCR_FRICTION,
+    CCR_INFLATION,
+    CCR_KIND,
+    CCR_PARAM_0,
+    CCR_PARAM_1,
+    CCR_PARAM_2,
+    CCR_PARAM_3,
+    CCR_PREV_QW,
+    CCR_PREV_QX,
+    CCR_PREV_QY,
+    CCR_PREV_QZ,
+    CCR_PREV_TX,
+    CCR_PREV_TY,
+    CCR_PREV_TZ,
+    CCR_QW,
+    CCR_QX,
+    CCR_QY,
+    CCR_QZ,
+    CCR_STRIDE,
+    CCR_TX,
+    CCR_TY,
+    CCR_TZ
+} from "../collider/ClothColliderRecord.js";
+import { cloth_collider_refit_bounds } from "../collider/cloth_collider_bounds.js";
+
+/**
+ * # Bringing the world's colliders into a cloth's frame
+ *
+ * The index holds every live cloth collider in **world** coordinates; the
+ * solver works in the cloth's own **local** frame (§12 — garment-sized
+ * coordinates are what makes `Float32` particle state ample, and the local
+ * frame is what makes §7 P7's inertia model natural). So once per cloth per
+ * step, the colliders that could touch it are queried out of the index and
+ * rewritten into its frame.
+ *
+ * ## Both poses go into the *current* anchor frame
+ *
+ * A record carries where the collider was and where it is. Both are converted
+ * using the anchor's pose **now**, not each with the anchor pose of its own
+ * step, so what the sweep interpolates is the collider's motion *relative to
+ * the cloth's frame*. That is the motion the particles actually see: the frame
+ * change has already been applied to them by `move_local_frame`, scaled by
+ * `ClothDynamics#inertia`, before the step begins.
+ *
+ * The alternative — converting each pose in its own frame — would make a
+ * collider appear to move whenever the anchor did, so a character running past
+ * a static wall would sweep the wall through their own cape.
+ *
+ * ## The query box
+ *
+ * The cloth's own particle bounds, fattened by how far a contact reaches, and
+ * then by how far the solver will let a particle travel in one step. The second
+ * term is what stops a fast cloth outrunning its own broadphase within the step
+ * it was gathered for; it is the velocity clamp of §7 P1 read as a distance,
+ * which is the quantity it was built out of.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Query the index and rewrite the overlapping colliders into the cloth's frame.
+ *
+ * @param {ClothInstance} instance filled in place — `collider_table`,
+ *   `collider_key` and `collider_count`
+ * @param {ClothColliderIndex} index
+ * @param {number} reach how far a particle may travel this step, metres
+ * @returns {number} how many colliders were gathered
+ */
+export function cloth_gather_colliders(instance, index, reach) {
+    const state = instance.state;
+
+    const particle_count = state.particle_count;
+    const position = state.position;
+
+    let min_x = Infinity;
+    let min_y = Infinity;
+    let min_z = Infinity;
+    let max_x = -Infinity;
+    let max_y = -Infinity;
+    let max_z = -Infinity;
+
+    for (let i = 0; i < particle_count; i++) {
+        const p = i * 3;
+
+        const x = position[p];
+        const y = position[p + 1];
+        const z = position[p + 2];
+
+        if (x < min_x) { min_x = x; }
+        if (y < min_y) { min_y = y; }
+        if (z < min_z) { min_z = z; }
+        if (x > max_x) { max_x = x; }
+        if (y > max_y) { max_y = y; }
+        if (z > max_z) { max_z = z; }
+    }
+
+    if (particle_count === 0) {
+        instance.collider_count = 0;
+
+        return 0;
+    }
+
+    const margin = reach + state.contact_radius * 2;
+
+    min_x -= margin;
+    min_y -= margin;
+    min_z -= margin;
+    max_x += margin;
+    max_y += margin;
+    max_z += margin;
+
+    // The anchor pose the particles were carried into this step, not the live
+    // component — those are the same value by the time this runs, and the
+    // cached pair is the one `move_local_frame` used.
+    const anchor_x = instance.anchor_translation[0];
+    const anchor_y = instance.anchor_translation[1];
+    const anchor_z = instance.anchor_translation[2];
+
+    const qx = instance.anchor_rotation[0];
+    const qy = instance.anchor_rotation[1];
+    const qz = instance.anchor_rotation[2];
+    const qw = instance.anchor_rotation[3];
+
+    // The local box's eight corners, in world. A rotated box is not a box, so
+    // the world query volume is the bounds of the rotated one rather than the
+    // rotation of the bounds.
+    let world_min_x = Infinity;
+    let world_min_y = Infinity;
+    let world_min_z = Infinity;
+    let world_max_x = -Infinity;
+    let world_max_y = -Infinity;
+    let world_max_z = -Infinity;
+
+    for (let corner = 0; corner < 8; corner++) {
+        v3_quaternion_apply(
+            CORNER, 0,
+            (corner & 1) === 0 ? min_x : max_x,
+            (corner & 2) === 0 ? min_y : max_y,
+            (corner & 4) === 0 ? min_z : max_z,
+            qx, qy, qz, qw
+        );
+
+        const x = CORNER[0] + anchor_x;
+        const y = CORNER[1] + anchor_y;
+        const z = CORNER[2] + anchor_z;
+
+        if (x < world_min_x) { world_min_x = x; }
+        if (y < world_min_y) { world_min_y = y; }
+        if (z < world_min_z) { world_min_z = z; }
+        if (x > world_max_x) { world_max_x = x; }
+        if (y > world_max_y) { world_max_y = y; }
+        if (z > world_max_z) { world_max_z = z; }
+    }
+
+    const cloth = instance.cloth;
+
+    const found = index.query(
+        HANDLES, world_min_x, world_min_y, world_min_z,
+        world_max_x, world_max_y, world_max_z,
+        cloth.layer, cloth.mask
+    );
+
+    if (instance.collider_table === null || instance.collider_table.length < found * CCR_STRIDE) {
+        let capacity = 8;
+
+        while (capacity < found) {
+            capacity *= 2;
+        }
+
+        instance.collider_table = new Float32Array(capacity * CCR_STRIDE);
+        instance.collider_key = new Int32Array(capacity);
+    }
+
+    const table = instance.collider_table;
+    const keys = instance.collider_key;
+
+    const source = index.table;
+
+    for (let i = 0; i < found; i++) {
+        const handle = HANDLES[i];
+
+        const from = handle * CCR_STRIDE;
+        const to = i * CCR_STRIDE;
+
+        keys[i] = handle;
+
+        table[to + CCR_KIND] = source[from + CCR_KIND];
+        table[to + CCR_PARAM_0] = source[from + CCR_PARAM_0];
+        table[to + CCR_PARAM_1] = source[from + CCR_PARAM_1];
+        table[to + CCR_PARAM_2] = source[from + CCR_PARAM_2];
+        table[to + CCR_PARAM_3] = source[from + CCR_PARAM_3];
+        table[to + CCR_FEATURE] = source[from + CCR_FEATURE];
+        table[to + CCR_FRICTION] = source[from + CCR_FRICTION];
+        table[to + CCR_INFLATION] = source[from + CCR_INFLATION];
+
+        localise(
+            table, to + CCR_TX, to + CCR_QX,
+            source[from + CCR_TX], source[from + CCR_TY], source[from + CCR_TZ],
+            source[from + CCR_QX], source[from + CCR_QY], source[from + CCR_QZ], source[from + CCR_QW],
+            anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
+        );
+
+        localise(
+            table, to + CCR_PREV_TX, to + CCR_PREV_QX,
+            source[from + CCR_PREV_TX], source[from + CCR_PREV_TY], source[from + CCR_PREV_TZ],
+            source[from + CCR_PREV_QX], source[from + CCR_PREV_QY],
+            source[from + CCR_PREV_QZ], source[from + CCR_PREV_QW],
+            anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
+        );
+
+        cloth_collider_refit_bounds(table, i, CCR_STRIDE);
+    }
+
+    instance.collider_count = found;
+
+    return found;
+}
+
+/**
+ * Write a world pose into a record's translation and rotation slots, expressed
+ * in the anchor's frame.
+ *
+ * @param {Float32Array} table
+ * @param {number} translation_slot
+ * @param {number} rotation_slot
+ * @param {number} tx
+ * @param {number} ty
+ * @param {number} tz
+ * @param {number} rx
+ * @param {number} ry
+ * @param {number} rz
+ * @param {number} rw
+ * @param {number} anchor_x
+ * @param {number} anchor_y
+ * @param {number} anchor_z
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @private
+ */
+function localise(
+    table, translation_slot, rotation_slot,
+    tx, ty, tz, rx, ry, rz, rw,
+    anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
+) {
+    v3_quaternion_apply_inverse(
+        LOCAL_TRANSLATION, 0,
+        tx - anchor_x, ty - anchor_y, tz - anchor_z,
+        qx, qy, qz, qw
+    );
+
+    table[translation_slot] = LOCAL_TRANSLATION[0];
+    table[translation_slot + 1] = LOCAL_TRANSLATION[1];
+    table[translation_slot + 2] = LOCAL_TRANSLATION[2];
+
+    quat3_multiply(LOCAL_ROTATION, 0, -qx, -qy, -qz, qw, rx, ry, rz, rw);
+
+    table[rotation_slot] = LOCAL_ROTATION[0];
+    table[rotation_slot + 1] = LOCAL_ROTATION[1];
+    table[rotation_slot + 2] = LOCAL_ROTATION[2];
+    table[rotation_slot + 3] = LOCAL_ROTATION[3];
+}
+
+/**
+ * Whether any collider overlapping this cloth moved between the previous step
+ * and this one — §7 P5's "wake on collider motion", asked without waking.
+ *
+ * A sleeping cloth is not stepped and not written back, so something has to
+ * notice when the world it was resting against moves. This is that something,
+ * and it is a broadphase query plus a pose comparison: cheaper than a step by
+ * three orders of magnitude, which is what makes sleep worth having at all.
+ *
+ * @param {ClothInstance} instance
+ * @param {ClothColliderIndex} index
+ * @returns {boolean}
+ */
+export function cloth_colliders_moved(instance, index) {
+    const found = cloth_gather_colliders(instance, index, 0);
+
+    const table = instance.collider_table;
+
+    for (let i = 0; i < found; i++) {
+        const r = i * CCR_STRIDE;
+
+        if (table[r + CCR_TX] !== table[r + CCR_PREV_TX]
+            || table[r + CCR_TY] !== table[r + CCR_PREV_TY]
+            || table[r + CCR_TZ] !== table[r + CCR_PREV_TZ]
+            || table[r + CCR_QX] !== table[r + CCR_PREV_QX]
+            || table[r + CCR_QY] !== table[r + CCR_PREV_QY]
+            || table[r + CCR_QZ] !== table[r + CCR_PREV_QZ]
+            || table[r + CCR_QW] !== table[r + CCR_PREV_QW]) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * @type {number[]}
+ * @private
+ */
+const HANDLES = [];
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const CORNER = new Float64Array(3);
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const LOCAL_TRANSLATION = new Float64Array(3);
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const LOCAL_ROTATION = new Float64Array(4);

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

@@ -0,0 +1,13 @@
+/**
+ * Fill `blended_position` and `blended_rotation` from the solved particles.
+ *
+ * Both are in the **cloth's own frame**: the position is the particle lerped
+ * towards its animated one by `Cloth#blend`, and the rotation is the swing
+ * composed onto the animated orientation. Node 0 — the anchor — is the origin of
+ * that frame, so its rotation is the identity rather than anything read off it.
+ *
+ * @param {ClothInstance} instance
+ * @returns {void}
+ */
+export function cloth_reconstruct_pose(instance: ClothInstance): void;
+//# sourceMappingURL=cloth_reconstruct_pose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_reconstruct_pose.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_reconstruct_pose.js"],"names":[],"mappings":"AA6DA;;;;;;;;;;GAUG;AACH,iEAFa,IAAI,CAqEhB"}

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

@@ -0,0 +1,288 @@
+import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { quat3_nlerp } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
+import { quat3_shortest_arc } from "../../../../core/geom/3d/quaternion/quat3_shortest_arc.js";
+
+/**
+ * # From particles to a pose — the half of the write-back that is arithmetic
+ *
+ * A particle has a position and no orientation, so a node's rotation has to be
+ * reconstructed. This module does that, in the cloth's own frame, into
+ * {@link ClothInstance#blended_position} and
+ * {@link ClothInstance#blended_rotation} — and then stops. What is done with the
+ * result is the *writer's* business, and there are two of them: the entity path
+ * writes a `Transform64` and a `TransformAttachment`, the rig path writes a
+ * `Node3D`.
+ *
+ * M3 split it out for exactly that reason. §11 claims "the solver is identical
+ * either way; only seeding and write-back differ", and a second copy of the
+ * swing reconstruction would have made that claim true of the solver and false
+ * of everything above it.
+ *
+ * ## Rotation is a swing on top of the animated orientation
+ *
+ *     q_node = swing(d_animated → d_simulated) ⊗ q_animated
+ *
+ * Twist about the link is inherited from the animation rather than invented,
+ * which is right: a chain of particles carries no twist degree of freedom and
+ * any twist this code produced would be a fabrication. And it degenerates
+ * correctly — at `blend = 0` the simulated direction *is* the animated one, the
+ * swing is the identity, and the reconstruction reproduces the authored pose
+ * exactly.
+ *
+ * A node with a parent and children has two links and two swings, and takes the
+ * half-way rotation between them. A leaf has only its parent's. Without that,
+ * every link points at its child and a two-link chain reads as a hinge with a
+ * corner in it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Scratch for one node's swing quaternions. Module-level: the reconstruction
+ * allocates nothing.
+ * @type {Float64Array}
+ * @private
+ */
+const SWING = new Float64Array(12);
+
+/** Where the parent-driven swing sits in {@link SWING}. @private */
+const SWING_PARENT = 0;
+/** Where the child-driven swing sits in {@link SWING}. @private */
+const SWING_CHILD = 4;
+/** Where the blended swing sits. @private */
+const SWING_OUT = 8;
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const DIRECTION = new Float64Array(12);
+
+/**
+ * Fill `blended_position` and `blended_rotation` from the solved particles.
+ *
+ * Both are in the **cloth's own frame**: the position is the particle lerped
+ * towards its animated one by `Cloth#blend`, and the rotation is the swing
+ * composed onto the animated orientation. Node 0 — the anchor — is the origin of
+ * that frame, so its rotation is the identity rather than anything read off it.
+ *
+ * @param {ClothInstance} instance
+ * @returns {void}
+ */
+export function cloth_reconstruct_pose(instance) {
+    const node_count = instance.node_count;
+
+    const state = instance.state;
+    const particle_of_node = instance.particle_of_node;
+
+    const blended = instance.blended_position;
+    const animated = instance.animated_position;
+
+    let blend = instance.cloth.blend;
+
+    if (blend < 0) {
+        blend = 0;
+    } else if (blend > 1) {
+        blend = 1;
+    }
+
+    const position = state.position;
+
+    for (let node = 0; node < node_count; node++) {
+        const p = particle_of_node[node] * 3;
+        const n = node * 3;
+
+        blended[n] = animated[n] + blend * (position[p] - animated[n]);
+        blended[n + 1] = animated[n + 1] + blend * (position[p + 1] - animated[n + 1]);
+        blended[n + 2] = animated[n + 2] + blend * (position[p + 2] - animated[n + 2]);
+    }
+
+    const parent = instance.node_parent;
+    const rotation = instance.animated_rotation;
+
+    const reconstructed = instance.blended_rotation;
+
+    reconstructed[0] = 0;
+    reconstructed[1] = 0;
+    reconstructed[2] = 0;
+    reconstructed[3] = 1;
+
+    for (let node = 1; node < node_count; node++) {
+        const has_parent_swing = link_swing(instance, parent[node], node, SWING_PARENT);
+        const has_child_swing = children_swing(instance, node, SWING_CHILD);
+
+        let swing = SWING_OUT;
+
+        if (has_parent_swing && has_child_swing) {
+            quat3_nlerp(
+                SWING, SWING_OUT,
+                SWING[SWING_PARENT], SWING[SWING_PARENT + 1], SWING[SWING_PARENT + 2], SWING[SWING_PARENT + 3],
+                SWING[SWING_CHILD], SWING[SWING_CHILD + 1], SWING[SWING_CHILD + 2], SWING[SWING_CHILD + 3],
+                0.5
+            );
+        } else if (has_child_swing) {
+            swing = SWING_CHILD;
+        } else {
+            // A leaf, or a link so short its direction is meaningless — in
+            // which case `link_swing` left the identity there.
+            swing = SWING_PARENT;
+        }
+
+        // Animated orientation first, then the swing: the swing is expressed in
+        // the cloth's local frame.
+        quat3_multiply(
+            reconstructed, node * 4,
+            SWING[swing], SWING[swing + 1], SWING[swing + 2], SWING[swing + 3],
+            rotation[node * 4], rotation[node * 4 + 1], rotation[node * 4 + 2], rotation[node * 4 + 3]
+        );
+    }
+}
+
+/**
+ * Swing of the link from `from` to `to`, into `SWING` at `out`.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} from node
+ * @param {number} to node
+ * @param {number} out
+ * @returns {boolean} false when the link is too short to carry a direction, in
+ *   which case the identity was written
+ * @private
+ */
+function link_swing(instance, from, to, out) {
+    const animated = instance.animated_position;
+    const blended = instance.blended_position;
+
+    const a = from * 3;
+    const b = to * 3;
+
+    const has_animated = unit(DIRECTION, 0,
+        animated[b] - animated[a], animated[b + 1] - animated[a + 1], animated[b + 2] - animated[a + 2]);
+
+    const has_blended = unit(DIRECTION, 3,
+        blended[b] - blended[a], blended[b + 1] - blended[a + 1], blended[b + 2] - blended[a + 2]);
+
+    if (!has_animated || !has_blended) {
+        identity(out);
+
+        return false;
+    }
+
+    quat3_shortest_arc(
+        SWING, out,
+        DIRECTION[0], DIRECTION[1], DIRECTION[2],
+        DIRECTION[3], DIRECTION[4], DIRECTION[5]
+    );
+
+    return true;
+}
+
+/**
+ * Swing of a node's outgoing links, averaged over its simulated children.
+ *
+ * The average is over **unit** directions rather than over child positions, so
+ * a fork whose two branches are of different lengths is not dominated by the
+ * longer one.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} node
+ * @param {number} out
+ * @returns {boolean}
+ * @private
+ */
+function children_swing(instance, node, out) {
+    const start = instance.node_child_offset[node];
+    const end = instance.node_child_offset[node + 1];
+
+    if (start === end) {
+        identity(out);
+
+        return false;
+    }
+
+    const animated = instance.animated_position;
+    const blended = instance.blended_position;
+    const child = instance.node_child;
+
+    const a = node * 3;
+
+    let anim_x = 0, anim_y = 0, anim_z = 0;
+    let sim_x = 0, sim_y = 0, sim_z = 0;
+
+    for (let i = start; i < end; i++) {
+        const b = child[i] * 3;
+
+        if (unit(DIRECTION, 6,
+            animated[b] - animated[a], animated[b + 1] - animated[a + 1], animated[b + 2] - animated[a + 2])) {
+            anim_x += DIRECTION[6];
+            anim_y += DIRECTION[7];
+            anim_z += DIRECTION[8];
+        }
+
+        if (unit(DIRECTION, 9,
+            blended[b] - blended[a], blended[b + 1] - blended[a + 1], blended[b + 2] - blended[a + 2])) {
+            sim_x += DIRECTION[9];
+            sim_y += DIRECTION[10];
+            sim_z += DIRECTION[11];
+        }
+    }
+
+    const has_animated = unit(DIRECTION, 0, anim_x, anim_y, anim_z);
+    const has_blended = unit(DIRECTION, 3, sim_x, sim_y, sim_z);
+
+    if (!has_animated || !has_blended) {
+        // Branches that cancel — a node with two children pointing opposite
+        // ways has no outgoing direction to speak of, and the parent link is a
+        // better answer than an arbitrary one.
+        identity(out);
+
+        return false;
+    }
+
+    quat3_shortest_arc(
+        SWING, out,
+        DIRECTION[0], DIRECTION[1], DIRECTION[2],
+        DIRECTION[3], DIRECTION[4], DIRECTION[5]
+    );
+
+    return true;
+}
+
+/**
+ * Normalise into `out`, reporting whether there was a direction to find.
+ *
+ * @param {Float64Array} out
+ * @param {number} offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {boolean}
+ * @private
+ */
+function unit(out, offset, x, y, z) {
+    const length_squared = x * x + y * y + z * z;
+
+    if (length_squared < 1e-24) {
+        return false;
+    }
+
+    const inverse = 1 / Math.sqrt(length_squared);
+
+    out[offset] = x * inverse;
+    out[offset + 1] = y * inverse;
+    out[offset + 2] = z * inverse;
+
+    return true;
+}
+
+/**
+ * @param {number} offset
+ * @private
+ */
+function identity(offset) {
+    SWING[offset] = 0;
+    SWING[offset + 1] = 0;
+    SWING[offset + 2] = 0;
+    SWING[offset + 3] = 1;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * # Seeding a cloth from a skinned model's joints — §11.2
+ *
+ * One particle per joint the proxy names, with the anchor as the fixed set, and
+ * everything after that is `cloth_build_rows.js` — the same rows, the same
+ * geodesics, the same leashes the entity path gets. §11 says "the solver is
+ * identical either way; only seeding and write-back differ", and this file plus
+ * `cloth_write_back_rig.js` is the whole of the difference.
+ *
+ * ## Cloth takes authority, and that is a real claim
+ *
+ * §11.2 says the writable handle is "the joint's `Node3D.transform_local` — the
+ * same handle the animation systems write". **The animation systems do not
+ * write it.** `TransformAuthority` is explicit: a node a clip drives is
+ * `GPU`, and "the CPU allocates and seeds the row, then never writes to it
+ * again, so the node's own `transform_local` stops describing it and should not
+ * be read as if it did". Cloth writing `transform_local` on such a node would
+ * be writing to something nothing reads.
+ *
+ * So the seed **claims** `TransformAuthority.CPU` on every joint it drives. The
+ * consequence is stated rather than hidden: a joint cloth simulates stops being
+ * animatable by a clip, because two writers of one row is the race the authority
+ * enum exists to prevent. That is the right trade for a cape — the whole point
+ * of simulating it is that nobody keyframes it — and it is an authoring error
+ * for a garment whose joints are also keyed, which is why the seed says so.
+ *
+ * ## The animated pose is constant, exactly as it is for a rope
+ *
+ * §11.1 says a subtree's authored pose is rigid relative to its anchor, so in
+ * the anchor's own frame it does not move, and then says "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 and is live".
+ *
+ * For a **rigged** garment it is not live either, and the reason is the
+ * authority claim above: cloth owns those joints, so nothing else poses them,
+ * so their authored pose is the proxy's baked bind pose — constant in the
+ * anchor's frame, exactly as a rope's is. What moves is the anchor, and the
+ * anchor is a joint of the character's own animated skeleton.
+ *
+ * The live case is the **unrigged** path, where the animated targets are mesh
+ * vertices skinned to the character's skeleton by
+ * `mesh_apply_skeletal_vertex_skinning` and genuinely move under the animation.
+ * That path is not in M3.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Seed `instance` from a proxy and the joints of a skin.
+ *
+ * @param {ClothInstance} instance seeded in place
+ * @param {ClothProxy} proxy
+ * @param {Node3D[]} joints the skin's joints, in the order the proxy indexes
+ * @param {number} dt fixed step, seconds
+ * @returns {void}
+ */
+export function cloth_seed_rig(instance: ClothInstance, proxy: ClothProxy, joints: Node3D[], dt: number): void;
+//# sourceMappingURL=cloth_seed_rig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_seed_rig.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_seed_rig.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;GAQG;AACH,mFAJW,QAAQ,MACR,MAAM,GACJ,IAAI,CA6DhB"}