@woosh/meep-engine 3.25.0 → 3.26.0

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

@@ -1,201 +1,249 @@
-import { assert } from "../../../../core/assert.js";
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
-import { GPUStateAuthorityFlags } from "../../../ecs/gpu/GPUStateAuthorityFlags.js";
-import { gpu_authority_revoke } from "../../../ecs/gpu/gpu_authority_revoke.js";
-import { TransformAttachment } from "../../../ecs/transform-attachment/TransformAttachment.js";
-import { cloth_build_children, cloth_build_rows } from "./cloth_build_rows.js";
-
-/**
- * # 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.
- *
- * ## The joints are entities, and cloth takes them back from the GPU
- *
- * A skinned model is a prefab spawned as entities, so a joint is an entity with
- * a `TransformAttachment` — the offset from its parent joint — and a
- * `GPUStateAuthority` saying who writes that offset's row. A joint a clip
- * drives is the GPU's: the clip resolves the row on the GPU and the CPU never
- * writes it, so the attachment's offset stops describing it. Cloth writing that
- * offset on such a joint would be writing to something nothing reads.
- *
- * So the seed **revokes** the GPU's authority over 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 component 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, whose pose the
- * system evaluates exactly (`t64_evaluate_world`).
- *
- * @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 {number[]} joints the skin's joints as entities, in the order the proxy indexes
- * @param {EntityComponentDataset} ecd
- * @param {number} dt
- */
-export function cloth_seed_rig(instance, proxy, joints, ecd, dt) {
-    assert.ok(proxy.isClothProxy === true, 'proxy must be a ClothProxy');
-
-    const joint_count = proxy.joint_count;
-
-    // Node 0 is the anchor, exactly as it is for the entity path: the fixed
-    // set, the origin of the local frame, and `d_geo = 0`.
-    const node_count = joint_count + 1;
-
-    instance.node_count = node_count;
-
-    const node_parent = new Int32Array(node_count);
-
-    node_parent[0] = -1;
-
-    for (let i = 0; i < joint_count; i++) {
-        node_parent[i + 1] = proxy.joint_parent[i] + 1;
-    }
-
-    instance.node_parent = node_parent;
-
-    const node_joint = new Int32Array(node_count);
-
-    node_joint[0] = joints[proxy.anchor];
-
-    const node_attachment = new Array(node_count);
-
-    node_attachment[0] = null;
-
-    for (let i = 0; i < joint_count; i++) {
-        const joint = joints[proxy.joint[i]];
-
-        assert.defined(joint, `joint ${proxy.joint[i]} of the skin`);
-        assert.ok(ecd.entityExists(joint), `joint ${proxy.joint[i]} of the skin, entity ${joint}, does not exist`);
-
-        node_joint[i + 1] = joint;
-
-        const attachment = ecd.getComponent(joint, TransformAttachment);
-
-        assert.defined(attachment, `joint entity ${joint} carries no TransformAttachment to write`);
-
-        node_attachment[i + 1] = attachment;
-
-        // See the module docblock. A clip-driven joint's offset is the GPU's, and taking it back
-        // is what makes the write-back reach the row at all. An entity that never declared has
-        // nothing to take back.
-        gpu_authority_revoke(ecd, joint, GPUStateAuthorityFlags.TransformAttachment);
-    }
-
-    instance.node_joint = node_joint;
-    instance.node_attachment = node_attachment;
-
-    // The entity path's arrays have no meaning here and holding stale ones is
-    // how a write-back reaches into a previous seeding's entities.
-    instance.node_entity = null;
-    instance.node_transform = [];
-    instance.pruned_count = 0;
-    instance.pruned_entity = null;
-    instance.pruned_parent = null;
-    instance.pruned_transform = [];
-    instance.pruned_attachment = [];
-
-    cloth_build_children(instance);
-
-    read_bind_pose(instance, proxy);
-
-    instance.dynamics_seen.copy(instance.cloth.dynamics);
-
-    cloth_build_rows(instance, dt);
-
-    instance.seeded = true;
-}
-
-/**
- * The proxy's bind pose, composed: local offsets per node and the position and
- * rotation of every node in the anchor's frame.
- *
- * @param {ClothInstance} instance
- * @param {ClothProxy} proxy
- */
-function read_bind_pose(instance, proxy) {
-    const node_count = instance.node_count;
-
-    const local_position = new Float32Array(node_count * 3);
-    const local_rotation = new Float32Array(node_count * 4);
-
-    const position = new Float32Array(node_count * 3);
-    const rotation = new Float32Array(node_count * 4);
-
-    // The anchor is the origin of the frame it anchors.
-    local_rotation[3] = 1;
-    rotation[3] = 1;
-
-    const parent = instance.node_parent;
-
-    for (let node = 1; node < node_count; node++) {
-        const joint = node - 1;
-
-        local_position[node * 3] = proxy.rest_position[joint * 3];
-        local_position[node * 3 + 1] = proxy.rest_position[joint * 3 + 1];
-        local_position[node * 3 + 2] = proxy.rest_position[joint * 3 + 2];
-
-        local_rotation[node * 4] = proxy.rest_rotation[joint * 4];
-        local_rotation[node * 4 + 1] = proxy.rest_rotation[joint * 4 + 1];
-        local_rotation[node * 4 + 2] = proxy.rest_rotation[joint * 4 + 2];
-        local_rotation[node * 4 + 3] = proxy.rest_rotation[joint * 4 + 3];
-
-        const p = parent[node];
-
-        const pqx = rotation[p * 4];
-        const pqy = rotation[p * 4 + 1];
-        const pqz = rotation[p * 4 + 2];
-        const pqw = rotation[p * 4 + 3];
-
-        v3_quaternion_apply(
-            COMPOSE, 0,
-            local_position[node * 3], local_position[node * 3 + 1], local_position[node * 3 + 2],
-            pqx, pqy, pqz, pqw
-        );
-
-        position[node * 3] = position[p * 3] + COMPOSE[0];
-        position[node * 3 + 1] = position[p * 3 + 1] + COMPOSE[1];
-        position[node * 3 + 2] = position[p * 3 + 2] + COMPOSE[2];
-
-        quat3_multiply(
-            rotation, node * 4,
-            pqx, pqy, pqz, pqw,
-            local_rotation[node * 4], local_rotation[node * 4 + 1],
-            local_rotation[node * 4 + 2], local_rotation[node * 4 + 3]
-        );
-    }
-
-    instance.rest_local_position = local_position;
-    instance.rest_local_rotation = local_rotation;
-
-    instance.animated_position = position;
-    instance.animated_rotation = rotation;
-}
-
-const COMPOSE = new Float64Array(3);
+import { assert } from "../../../../core/assert.js";
+import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { GPUStateAuthorityFlags } from "../../../ecs/gpu/GPUStateAuthorityFlags.js";
+import { gpu_authority_grant } from "../../../ecs/gpu/gpu_authority_grant.js";
+import { gpu_authority_revoke } from "../../../ecs/gpu/gpu_authority_revoke.js";
+import { TransformAttachment } from "../../../ecs/transform-attachment/TransformAttachment.js";
+import { cloth_build_children, cloth_build_rows } from "./cloth_build_rows.js";
+
+/**
+ * # 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.
+ *
+ * ## The joints are entities, and cloth takes them back from the GPU
+ *
+ * A skinned model is a prefab spawned as entities, so a joint is an entity with
+ * a `TransformAttachment` — the offset from its parent joint — and a
+ * `GPUStateAuthority` saying who writes that offset's row. A joint a clip
+ * drives is the GPU's: the clip resolves the row on the GPU and the CPU never
+ * writes it, so the attachment's offset stops describing it. Cloth writing that
+ * offset on such a joint would be writing to something nothing reads.
+ *
+ * So the seed **revokes** the GPU's authority over 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 component 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, whose pose the
+ * system evaluates exactly (`t64_evaluate_world`).
+ *
+ * @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 {number[]} joints the skin's joints as entities, in the order the proxy indexes
+ * @param {EntityComponentDataset} ecd
+ * @param {number} dt
+ */
+export function cloth_seed_rig(instance, proxy, joints, ecd, dt) {
+    assert.ok(proxy.isClothProxy === true, 'proxy must be a ClothProxy');
+
+    const joint_count = proxy.joint_count;
+
+    // Node 0 is the anchor, exactly as it is for the entity path: the fixed
+    // set, the origin of the local frame, and `d_geo = 0`.
+    const node_count = joint_count + 1;
+
+    instance.node_count = node_count;
+
+    const node_parent = new Int32Array(node_count);
+
+    node_parent[0] = -1;
+
+    for (let i = 0; i < joint_count; i++) {
+        node_parent[i + 1] = proxy.joint_parent[i] + 1;
+    }
+
+    instance.node_parent = node_parent;
+
+    const node_joint = new Int32Array(node_count);
+
+    node_joint[0] = joints[proxy.anchor];
+
+    const node_attachment = new Array(node_count);
+
+    node_attachment[0] = null;
+
+    // What this seeding took, so that giving it back is possible. A revoke that
+    // nothing can undo is half a transaction, and the half that is missing is
+    // the one that runs when the garment is removed.
+    const revoked = [];
+
+    for (let i = 0; i < joint_count; i++) {
+        const joint = joints[proxy.joint[i]];
+
+        assert.defined(joint, `joint ${proxy.joint[i]} of the skin`);
+        assert.ok(ecd.entityExists(joint), `joint ${proxy.joint[i]} of the skin, entity ${joint}, does not exist`);
+
+        node_joint[i + 1] = joint;
+
+        const attachment = ecd.getComponent(joint, TransformAttachment);
+
+        assert.defined(attachment, `joint entity ${joint} carries no TransformAttachment to write`);
+
+        node_attachment[i + 1] = attachment;
+
+        // See the module docblock. A clip-driven joint's offset is the GPU's, and taking it back
+        // is what makes the write-back reach the row at all. An entity that never declared has
+        // nothing to take back.
+        if (gpu_authority_revoke(ecd, joint, GPUStateAuthorityFlags.TransformAttachment)) {
+            revoked.push(joint);
+        }
+    }
+
+    instance.revoked_joints = revoked;
+
+    instance.node_joint = node_joint;
+    instance.node_attachment = node_attachment;
+
+    // The entity path's arrays have no meaning here and holding stale ones is
+    // how a write-back reaches into a previous seeding's entities.
+    instance.node_entity = null;
+    instance.node_transform = [];
+    instance.pruned_count = 0;
+    instance.pruned_entity = null;
+    instance.pruned_parent = null;
+    instance.pruned_transform = [];
+    instance.pruned_attachment = [];
+
+    cloth_build_children(instance);
+
+    read_bind_pose(instance, proxy);
+
+    instance.dynamics_seen.copy(instance.cloth.dynamics);
+
+    cloth_build_rows(instance, dt);
+
+    instance.seeded = true;
+}
+
+/**
+ * The proxy's bind pose, composed: local offsets per node and the position and
+ * rotation of every node in the anchor's frame.
+ *
+ * @param {ClothInstance} instance
+ * @param {ClothProxy} proxy
+ */
+function read_bind_pose(instance, proxy) {
+    const node_count = instance.node_count;
+
+    const local_position = new Float32Array(node_count * 3);
+    const local_rotation = new Float32Array(node_count * 4);
+
+    const position = new Float32Array(node_count * 3);
+    const rotation = new Float32Array(node_count * 4);
+
+    // The anchor is the origin of the frame it anchors.
+    local_rotation[3] = 1;
+    rotation[3] = 1;
+
+    const parent = instance.node_parent;
+
+    for (let node = 1; node < node_count; node++) {
+        const joint = node - 1;
+
+        local_position[node * 3] = proxy.rest_position[joint * 3];
+        local_position[node * 3 + 1] = proxy.rest_position[joint * 3 + 1];
+        local_position[node * 3 + 2] = proxy.rest_position[joint * 3 + 2];
+
+        local_rotation[node * 4] = proxy.rest_rotation[joint * 4];
+        local_rotation[node * 4 + 1] = proxy.rest_rotation[joint * 4 + 1];
+        local_rotation[node * 4 + 2] = proxy.rest_rotation[joint * 4 + 2];
+        local_rotation[node * 4 + 3] = proxy.rest_rotation[joint * 4 + 3];
+
+        const p = parent[node];
+
+        const pqx = rotation[p * 4];
+        const pqy = rotation[p * 4 + 1];
+        const pqz = rotation[p * 4 + 2];
+        const pqw = rotation[p * 4 + 3];
+
+        v3_quaternion_apply(
+            COMPOSE, 0,
+            local_position[node * 3], local_position[node * 3 + 1], local_position[node * 3 + 2],
+            pqx, pqy, pqz, pqw
+        );
+
+        position[node * 3] = position[p * 3] + COMPOSE[0];
+        position[node * 3 + 1] = position[p * 3 + 1] + COMPOSE[1];
+        position[node * 3 + 2] = position[p * 3 + 2] + COMPOSE[2];
+
+        quat3_multiply(
+            rotation, node * 4,
+            pqx, pqy, pqz, pqw,
+            local_rotation[node * 4], local_rotation[node * 4 + 1],
+            local_rotation[node * 4 + 2], local_rotation[node * 4 + 3]
+        );
+    }
+
+    instance.rest_local_position = local_position;
+    instance.rest_local_rotation = local_rotation;
+
+    instance.animated_position = position;
+    instance.animated_rotation = rotation;
+}
+
+/**
+ * Give back every joint's `TransformAttachment` authority that this cloth's
+ * seeding took from the GPU.
+ *
+ * The seed revokes so that the write-back reaches the row at all, and the
+ * consequence the module docblock states — "a joint cloth simulates stops being
+ * animatable by a clip" — is only the right trade while the cloth is *there*.
+ * A garment removed and nothing re-granting leaves its joints owned by a CPU
+ * that is no longer writing them: neither animated nor simulated, and stuck in
+ * the pose the solver stopped in.
+ *
+ * Only the joints the revoke actually changed are given back, so a joint that
+ * was already the CPU's before cloth arrived stays the CPU's.
+ *
+ * @param {ClothInstance} instance
+ * @param {EntityComponentDataset} ecd
+ * @returns {void}
+ */
+export function cloth_release_rig(instance, ecd) {
+    const revoked = instance.revoked_joints;
+
+    if (revoked === null) {
+        return;
+    }
+
+    for (let i = 0; i < revoked.length; i++) {
+        const joint = revoked[i];
+
+        if (!ecd.entityExists(joint)) {
+            continue;
+        }
+
+        gpu_authority_grant(ecd, joint, GPUStateAuthorityFlags.TransformAttachment);
+    }
+
+    instance.revoked_joints = null;
+}
+
+const COMPOSE = new Float64Array(3);

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

@@ -55,5 +55,26 @@
  * @returns {void}
  */
 export function cloth_seed_subtree(instance: ClothInstance, ecd: EntityComponentDataset, attachments: TransformAttachmentSystem, dt: number): void;
+/**
+ * Put the authored local transforms back on the subtree and announce, so a
+ * cloth that is taken away leaves the hierarchy the way it found it.
+ *
+ * `cloth_write_back` overwrites every simulated node's
+ * `TransformAttachment#transform` with the solved local pose, every step. That
+ * is what makes a recomposition reproduce the simulation rather than undo it —
+ * and it means the authored pose exists nowhere but inside the cloth. Removing
+ * the component without this leaves the subtree frozen in whatever shape the
+ * solver stopped in, and a `Cloth` added back seeds *that* as the pose it is
+ * supposed to return to at `blend = 0`.
+ *
+ * One announcement, on the anchor, which is the same shape the write-back's own
+ * pruned-boundary pass uses: everything below is composed by the attachment
+ * cascade rather than by a second walk here.
+ *
+ * @param {ClothInstance} instance
+ * @param {EntityComponentDataset} ecd
+ * @returns {void}
+ */
+export function cloth_release_subtree(instance: ClothInstance, ecd: EntityComponentDataset): void;
 import { ClothInstance } from "./ClothInstance.js";
 //# sourceMappingURL=cloth_seed_subtree.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_seed_subtree.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_seed_subtree.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;;GASG;AACH,6CAPW,aAAa,2EAGb,MAAM,GAEJ,IAAI,CAwGhB;8BAlK6B,oBAAoB"}
+{"version":3,"file":"cloth_seed_subtree.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_seed_subtree.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;;GASG;AACH,6CAPW,aAAa,2EAGb,MAAM,GAEJ,IAAI,CAwGhB;AA6GD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAJW,aAAa,gCAEX,IAAI,CAkChB;8BAnU6B,oBAAoB"}

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

@@ -4,6 +4,7 @@ import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_ap
 import { GPUStateAuthorityFlags } from "../../../ecs/gpu/GPUStateAuthorityFlags.js";
 import { gpu_authority_assert_cpu } from "../../../ecs/gpu/gpu_authority_assert_cpu.js";
 import { TransformAttachment } from "../../../ecs/transform-attachment/TransformAttachment.js";
+import { t64_announce_change } from "../../../ecs/transform/t64_announce_change.js";
 import {
     TRANSFORM64_ROTATION_OFFSET,
     TRANSFORM64_TRANSLATION_OFFSET,
@@ -282,6 +283,60 @@ function read_rest_pose(instance, remembered) {
     instance.animated_rotation = rotation;
 }
 
+/**
+ * Put the authored local transforms back on the subtree and announce, so a
+ * cloth that is taken away leaves the hierarchy the way it found it.
+ *
+ * `cloth_write_back` overwrites every simulated node's
+ * `TransformAttachment#transform` with the solved local pose, every step. That
+ * is what makes a recomposition reproduce the simulation rather than undo it —
+ * and it means the authored pose exists nowhere but inside the cloth. Removing
+ * the component without this leaves the subtree frozen in whatever shape the
+ * solver stopped in, and a `Cloth` added back seeds *that* as the pose it is
+ * supposed to return to at `blend = 0`.
+ *
+ * One announcement, on the anchor, which is the same shape the write-back's own
+ * pruned-boundary pass uses: everything below is composed by the attachment
+ * cascade rather than by a second walk here.
+ *
+ * @param {ClothInstance} instance
+ * @param {EntityComponentDataset} ecd
+ * @returns {void}
+ */
+export function cloth_release_subtree(instance, ecd) {
+    const rest_position = instance.rest_local_position;
+    const rest_rotation = instance.rest_local_rotation;
+
+    if (rest_position === null || instance.node_entity === null) {
+        return;
+    }
+
+    const node_count = instance.node_count;
+
+    for (let node = 1; node < node_count; node++) {
+        const attachment = instance.node_attachment[node];
+
+        if (attachment === undefined || attachment === null) {
+            continue;
+        }
+
+        const transform = attachment.transform;
+
+        transform.setTranslation(
+            rest_position[node * 3], rest_position[node * 3 + 1], rest_position[node * 3 + 2]
+        );
+
+        transform.setRotation(
+            rest_rotation[node * 4], rest_rotation[node * 4 + 1],
+            rest_rotation[node * 4 + 2], rest_rotation[node * 4 + 3]
+        );
+
+        transform.updateMatrix();
+    }
+
+    t64_announce_change(ecd, instance.node_entity[0]);
+}
+
 /**
  * @type {Float64Array}
  * @private
@@ -300,7 +355,13 @@ const COMPOSE = new Float64Array(3);
 function remember_rest_pose(instance) {
     const remembered = new Map();
 
-    if (!instance.seeded || instance.rest_local_position === null) {
+    // Keyed on there *being* a previous capture rather than on
+    // {@link ClothInstance#seeded}, because `ClothWorld#reseed` clears `seeded`
+    // before this runs — which made the one path that exists to re-walk a live
+    // cloth the one path that could not remember anything. `node_entity` is
+    // null for a cloth that was previously seeded as a rig, whose captured pose
+    // is a joint's and not this walk's.
+    if (instance.rest_local_position === null || instance.node_entity === null) {
         return remembered;
     }
 

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_write_back.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;GAMG;AACH,wFAFa,IAAI,CAmDhB;AAyBD;;;;;;;;;GASG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CA4BhB"}
+{"version":3,"file":"cloth_write_back.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;GAMG;AACH,wFAFa,IAAI,CA2DhB;AAyBD;;;;;;;;;GASG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CA4BhB"}

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

@@ -76,16 +76,24 @@ export function cloth_write_back(instance, ecd) {
     const blended = instance.blended_position;
     const reconstructed = instance.blended_rotation;
 
-    const anchor = instance.node_transform[0];
-
-    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];
+    // The anchor pose the particles were carried into **this step**, not the
+    // live component. For `ClothSystem` those are the same value, because the
+    // step happened between them. For `WorkerClothSystem` they are not: it
+    // writes step T−1 back at the top of tick T, by which time the anchor has
+    // moved on, and composing last step's shape against this tick's anchor
+    // produces a world pose that describes neither. Nothing rendered can tell —
+    // the attachment cascade re-derives position from the anchor and the local
+    // transforms either way (§4.1) — but a **nested** cloth reads this pose as
+    // its own anchor, and then the two systems hand it different numbers.
+    // `MEASUREMENTS.md` §56.
+    const ax = instance.anchor_translation[0];
+    const ay = instance.anchor_translation[1];
+    const az = instance.anchor_translation[2];
+
+    const aqx = instance.anchor_rotation[0];
+    const aqy = instance.anchor_rotation[1];
+    const aqz = instance.anchor_rotation[2];
+    const aqw = instance.anchor_rotation[3];
 
     const parent = instance.node_parent;
 

package/src/engine/physics/cloth/playground/collide_main.js

@@ -173,7 +173,7 @@ function step_once() {
 
     const started = performance.now();
 
-    contact_rows = cloth_contact_find(state, colliders.table, colliders.keys, colliders.count);
+    contact_rows = cloth_contact_find(state, colliders.table, colliders.keys, colliders.count, FIXED_STEP);
 
     cloth_step(
         state, FIXED_STEP, 0, -9.81, 0,