@woosh/meep-engine 3.43.0 → 3.45.0

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

@@ -1,6 +1,5 @@
 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 { pose3_compose_array } from "../../../../core/geom/3d/pose/pose3_compose_array.js";
 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";
@@ -13,18 +12,33 @@ import {
 import { Cloth } from "./Cloth.js";
 import { ClothExclude } from "./ClothExclude.js";
 import { ClothInstance } from "./ClothInstance.js";
-import { cloth_build_children, cloth_build_rows } from "./cloth_build_rows.js";
+import { cloth_build_children, cloth_build_rows, cloth_build_surface, cloth_tree_graph } from "./cloth_build_rows.js";
 
 /**
  * # Seeding a cloth from an entity subtree — §11.1
  *
  * One particle per entity in the transform subtree of the entity the
- * {@link Cloth} is on, walked breadth-first through
- * `TransformAttachmentSystem#findChildrenOf`, stopping at a nested `Cloth` or a
- * {@link ClothExclude}. Stretch rows along the parent-child links, a bending
- * model along each chain, and the anchor itself as the fixed set — so `d_geo`
- * is distance along the chain from the anchor and every derived quantity in
- * §3.4 works unchanged.
+ * {@link Cloth} is on — that entity included, as node 0 — walked breadth-first
+ * through `TransformAttachmentSystem#findChildrenOf`, stopping at a nested
+ * `Cloth` or a {@link ClothExclude}. Stretch rows along the parent-child links
+ * and a bending model along each chain.
+ *
+ * **Node 0 is the cloth's frame and nothing holds it.** It is a particle like
+ * any other — links run from it, a {@link ClothPin} can hold it — but its
+ * entity is the frame, which cloth reads and never writes, so it has no output.
+ * A rope hung from its own top is a rope whose top entity pins particle 0:
+ *
+ * ```js
+ * rope_top.add(Cloth.from(ClothDynamics.ROPE));
+ * rope_top.add(ClothPin.from({ cloth: rope_top, particles: [0] }));
+ * ```
+ *
+ * **The particles are numbered by the walk**: breadth-first from node 0,
+ * siblings in the order `findChildrenOf` gives them, which is ascending entity
+ * id. A single chain is therefore numbered by depth whatever the ids; a pin on a
+ * branching subtree names a node of a walk that depends on how its siblings'
+ * ids were allocated, and `ClothSystem#particle_of` is how code that has the
+ * entity asks for the number.
  *
  * ## What "bend rows along each chain" turned out to mean
  *
@@ -158,8 +172,8 @@ export function cloth_seed_subtree(instance, ecd, attachments, dt) {
 
         assert.defined(transform, `Transform64 of cloth node ${node} (entity ${entity})`);
 
-        // A subtree cloth is a CPU chain from its anchor down; a garment hanging off a GPU-driven
-        // joint is the rig path's, which evaluates the anchor exactly instead of reading it.
+        // A subtree cloth is a CPU chain from its frame down; a garment hanging off a GPU-driven
+        // joint is the rig path's, which evaluates its frame exactly instead of reading it.
         gpu_authority_assert_cpu(ecd, entity, GPUStateAuthorityFlags.Transform64);
 
         instance.node_transform[node] = transform;
@@ -168,7 +182,20 @@ export function cloth_seed_subtree(instance, ecd, attachments, dt) {
             : ecd.getComponent(entity, TransformAttachment);
     }
 
+    // The root is the frame: read, never written. Its pose in its own frame is
+    // the identity, which is what its children's local transforms are written
+    // against.
+    instance.frame_entity = anchor;
+
+    instance.node_output = new Uint8Array(node_count).fill(1);
+    instance.node_output[0] = 0;
+
+    instance.boundary_pose = new Float64Array(node_count * 7);
+    instance.boundary_pose[6] = 1;
+
     cloth_build_children(instance);
+    cloth_tree_graph(instance);
+    cloth_build_surface(instance);
     read_rest_pose(instance, remembered);
 
     instance.dynamics_seen.copy(instance.cloth.dynamics);
@@ -177,7 +204,7 @@ export function cloth_seed_subtree(instance, ecd, attachments, dt) {
 }
 
 /**
- * Capture the authored pose, and compose it into the anchor's frame.
+ * Capture the authored pose, and compose it into the cloth's frame.
  *
  * The **local** transforms are the source, not the world ones. That is not a
  * preference: the write-back takes ownership of `TransformAttachment#transform`
@@ -190,8 +217,9 @@ export function cloth_seed_subtree(instance, ecd, attachments, dt) {
  * every node that was already in it.
  *
  * The composed result is constant — the subtree's authored pose is rigid
- * relative to its anchor, so in the anchor's own frame it does not move — which
- * is why nothing recomposes it per step.
+ * relative to its root, so in the root's own frame it does not move. What moves
+ * is the pose hung from the holds (`ClothInstance#animated_position`), which is
+ * built from this.
  *
  * @param {ClothInstance} instance
  * @param {Map<number, {position: number[], rotation: number[]}>} remembered
@@ -206,7 +234,7 @@ function read_rest_pose(instance, remembered) {
     const position = new Float32Array(node_count * 3);
     const rotation = new Float32Array(node_count * 4);
 
-    // The anchor is the origin of the frame it anchors: no offset, no rotation.
+    // The root is the origin of the frame it is: no offset, no rotation.
     local_rotation[3] = 1;
     rotation[3] = 1;
 
@@ -253,34 +281,21 @@ function read_rest_pose(instance, remembered) {
         // always already done, so one forward pass is the whole hierarchy.
         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(
+        pose3_compose_array(
+            position, node * 3,
             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]
+            position, p * 3,
+            rotation, p * 4,
+            local_position, node * 3,
+            local_rotation, node * 4
         );
     }
 
     instance.rest_local_position = local_position;
     instance.rest_local_rotation = local_rotation;
 
-    instance.animated_position = position;
-    instance.animated_rotation = rotation;
+    instance.rest_position = position;
+    instance.rest_rotation = rotation;
 }
 
 /**
@@ -337,12 +352,6 @@ export function cloth_release_subtree(instance, ecd) {
     t64_announce_change(ecd, instance.node_entity[0]);
 }
 
-/**
- * @type {Float64Array}
- * @private
- */
-const COMPOSE = new Float64Array(3);
-
 /**
  * The authored pose a previous seeding captured, keyed by entity, so a re-seed
  * of a live cloth does not mistake the shape the solver left behind for the

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

@@ -60,6 +60,11 @@ export function cloth_write_back(instance: ClothInstance, ecd: EntityComponentDa
  * One node's pose relative to its parent's, in whatever `Transform64` the
  * caller holds. Both writers need it and neither owns it.
  *
+ * The parent's pose is the one its **entity** will have: the reconstructed pose
+ * when cloth writes the parent too, and when it does not — a subtree's frame, a
+ * bone a garment hangs from — the pose that entity's owner gave it this step
+ * (`ClothInstance#boundary_pose`), whatever its particle is doing.
+ *
  * @param {Transform64} local written in place, matrix included
  * @param {ClothInstance} instance
  * @param {number} node

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,CAiDhB;AAyBD;;;;;;;;;GASG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CA6BhB"}
+{"version":3,"file":"cloth_write_back.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;GAMG;AACH,wFAFa,IAAI,CAqDhB;AAyBD;;;;;;;;;;;;;;GAcG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAiDhB"}

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

@@ -1,8 +1,5 @@
-import { quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
-import {
-    v3_quaternion_apply_inverse_array
-} from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { pose3_compose_array } from "../../../../core/geom/3d/pose/pose3_compose_array.js";
+import { pose3_to_local_array } from "../../../../core/geom/3d/pose/pose3_to_local_array.js";
 import { t64_announce_change } from "../../../ecs/transform/t64_announce_change.js";
 import {
     TRANSFORM64_ROTATION_OFFSET,
@@ -86,28 +83,32 @@ export function cloth_write_back(instance, ecd) {
     // 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];
-
-    // The rotations go in as arrays, read where they sit: handed over as seven and eight numbers,
-    // each was boxed into a heap object wherever the call was not inlined.
-    const anchor_rotation = instance.anchor_rotation;
+    //
+    // The frame goes in as arrays, read where it sits: handed over as seven and eight numbers, each
+    // was boxed into a heap object wherever the call was not inlined.
+    const frame_translation = instance.frame_translation;
+    const frame_rotation = instance.frame_rotation;
 
     const parent = instance.node_parent;
 
-    for (let node = 1; node < node_count; node++) {
-        const transform = instance.node_transform[node];
-
-        const n = node * 3;
+    const node_output = instance.node_output;
 
-        v3_quaternion_apply_array(transform, TRANSFORM64_TRANSLATION_OFFSET, blended, n, anchor_rotation, 0);
+    for (let node = 0; node < node_count; node++) {
+        if (node_output[node] === 0) {
+            // the frame itself: read, never written
+            continue;
+        }
 
-        transform[TRANSFORM64_TRANSLATION_OFFSET] += ax;
-        transform[TRANSFORM64_TRANSLATION_OFFSET + 1] += ay;
-        transform[TRANSFORM64_TRANSLATION_OFFSET + 2] += az;
+        const transform = instance.node_transform[node];
 
-        quat3_multiply_array(transform, TRANSFORM64_ROTATION_OFFSET, anchor_rotation, 0, reconstructed, node * 4);
+        pose3_compose_array(
+            transform, TRANSFORM64_TRANSLATION_OFFSET,
+            transform, TRANSFORM64_ROTATION_OFFSET,
+            frame_translation, 0,
+            frame_rotation, 0,
+            blended, node * 3,
+            reconstructed, node * 4
+        );
 
         transform.updateMatrix();
 
@@ -144,6 +145,11 @@ function write_local(instance, node, parent) {
  * One node's pose relative to its parent's, in whatever `Transform64` the
  * caller holds. Both writers need it and neither owns it.
  *
+ * The parent's pose is the one its **entity** will have: the reconstructed pose
+ * when cloth writes the parent too, and when it does not — a subtree's frame, a
+ * bone a garment hangs from — the pose that entity's owner gave it this step
+ * (`ClothInstance#boundary_pose`), whatever its particle is doing.
+ *
  * @param {Transform64} local written in place, matrix included
  * @param {ClothInstance} instance
  * @param {number} node
@@ -154,25 +160,45 @@ export function cloth_write_local_pose(local, instance, node, parent) {
     const blended = instance.blended_position;
     const rotation = instance.blended_rotation;
 
-    // Operands go in as arrays, the parent's rotation and the node's straight from the instance, the
-    // offset and the conjugate through scratch: handed over as seven and eight numbers, each was
-    // boxed into a heap object wherever the call was not inlined.
-    const offset = scratch_local_offset;
+    if (parent < 0) {
+        // A joint hanging straight off the frame — every joint of a generated
+        // skin — is written in the frame, which is the identity in itself.
+        local[TRANSFORM64_TRANSLATION_OFFSET] = blended[node * 3];
+        local[TRANSFORM64_TRANSLATION_OFFSET + 1] = blended[node * 3 + 1];
+        local[TRANSFORM64_TRANSLATION_OFFSET + 2] = blended[node * 3 + 2];
 
-    offset[0] = blended[node * 3] - blended[parent * 3];
-    offset[1] = blended[node * 3 + 1] - blended[parent * 3 + 1];
-    offset[2] = blended[node * 3 + 2] - blended[parent * 3 + 2];
+        local[TRANSFORM64_ROTATION_OFFSET] = rotation[node * 4];
+        local[TRANSFORM64_ROTATION_OFFSET + 1] = rotation[node * 4 + 1];
+        local[TRANSFORM64_ROTATION_OFFSET + 2] = rotation[node * 4 + 2];
+        local[TRANSFORM64_ROTATION_OFFSET + 3] = rotation[node * 4 + 3];
 
-    v3_quaternion_apply_inverse_array(local, TRANSFORM64_TRANSLATION_OFFSET, offset, 0, rotation, parent * 4);
+        local.updateMatrix();
 
-    const conjugate = scratch_parent_conjugate;
-
-    conjugate[0] = -rotation[parent * 4];
-    conjugate[1] = -rotation[parent * 4 + 1];
-    conjugate[2] = -rotation[parent * 4 + 2];
-    conjugate[3] = rotation[parent * 4 + 3];
+        return;
+    }
 
-    quat3_multiply_array(local, TRANSFORM64_ROTATION_OFFSET, conjugate, 0, rotation, node * 4);
+    if (instance.node_output[parent] !== 0) {
+        pose3_to_local_array(
+            local, TRANSFORM64_TRANSLATION_OFFSET,
+            local, TRANSFORM64_ROTATION_OFFSET,
+            blended, parent * 3,
+            rotation, parent * 4,
+            blended, node * 3,
+            rotation, node * 4
+        );
+    } else {
+        const boundary = instance.boundary_pose;
+        const b = parent * 7;
+
+        pose3_to_local_array(
+            local, TRANSFORM64_TRANSLATION_OFFSET,
+            local, TRANSFORM64_ROTATION_OFFSET,
+            boundary, b,
+            boundary, b + 3,
+            blended, node * 3,
+            rotation, node * 4
+        );
+    }
 
     // `multiplyTransforms` reads the matrix, not the components, so a local
     // transform that is not refreshed here composes the pose it had last time.
@@ -209,17 +235,3 @@ function pose_pruned(instance, ecd) {
         t64_announce_change(ecd, instance.pruned_entity[i]);
     }
 }
-
-/**
- * {@link cloth_write_local_pose}'s node position less its parent's, in the cloth's frame.
- * @type {Float64Array}
- * @private
- */
-const scratch_local_offset = new Float64Array(3);
-
-/**
- * {@link cloth_write_local_pose}'s parent rotation, conjugated: `[-x, -y, -z, w]`.
- * @type {Float64Array}
- * @private
- */
-const scratch_parent_conjugate = new Float64Array(4);

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_write_back_rig.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back_rig.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;GAKG;AACH,iGAqBC"}
+{"version":3,"file":"cloth_write_back_rig.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_write_back_rig.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;GAKG;AACH,iGA4BC"}

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

@@ -1,58 +1,65 @@
-import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "../../../ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
-import { cloth_reconstruct_pose } from "./cloth_reconstruct_pose.js";
-import { cloth_write_local_pose } from "./cloth_write_back.js";
-
-/**
- * # Putting the answer back onto a skinned model's joints — §11.2
- *
- * The same reconstruction the entity path uses, written onto the joint entities' offsets.
- * **Cloth moves joints; it does not produce vertices** — the mapping from a simulated joint to a
- * render vertex already exists in this engine and it is the skin, so the existing skinning pass
- * does the rest, including bounds refresh and BLAS refit that a bespoke vertex-deformation path
- * would have to reimplement.
- *
- * ## The offset is the output
- *
- * A joint's `TransformAttachment` offset is its own truth and the handle §11.2 names: it is what
- * the joint's row holds, and the GPU composes the world from it under the anchor's animated
- * row. Writing it is announced on the joint, which is what carries it to the row — the model
- * marks the row on that announcement — and what lets the attachment system recompose the CPU's
- * copy of the world below it. That copy is composed under the anchor as the CPU knows it, which
- * for a GPU-driven anchor is its rest pose: what the simulation may read about a cape joint is
- * its offset, or an exact evaluation, never that composed world.
- *
- * Nothing above the anchor is touched: the anchor is the character's, animated by its clips,
- * and this pass hangs a cape from it.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/**
- * Write the reconstructed pose onto the rig's joints.
- *
- * @param {ClothInstance} instance
- * @param {EntityComponentDataset} ecd
- */
-export function cloth_write_back_rig(instance, ecd) {
-    cloth_reconstruct_pose(instance);
-
-    const node_count = instance.node_count;
-
-    const parent = instance.node_parent;
-    const node_joint = instance.node_joint;
-    const node_attachment = instance.node_attachment;
-
-    for (let node = 1; node < node_count; node++) {
-        const joint = node_joint[node];
-        const attachment = node_attachment[node];
-
-        if (attachment === undefined || attachment === null || !ecd.entityExists(joint)) {
-            continue;
-        }
-
-        cloth_write_local_pose(attachment.transform, instance, node, parent[node]);
-
-        ecd.sendEvent(joint, TRANSFORM_ATTACHMENT_EVENT_CHANGE);
-    }
-}
+import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "../../../ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
+import { cloth_reconstruct_pose } from "./cloth_reconstruct_pose.js";
+import { cloth_write_local_pose } from "./cloth_write_back.js";
+
+/**
+ * # Putting the answer back onto a skinned model's joints — §11.2
+ *
+ * The same reconstruction the entity path uses, written onto the joint entities' offsets.
+ * **Cloth moves joints; it does not produce vertices** — the mapping from a simulated joint to a
+ * render vertex already exists in this engine and it is the skin, so the existing skinning pass
+ * does the rest, including bounds refresh and BLAS refit that a bespoke vertex-deformation path
+ * would have to reimplement.
+ *
+ * ## The offset is the output
+ *
+ * A joint's `TransformAttachment` offset is its own truth and the handle §11.2 names: it is what
+ * the joint's row holds, and the GPU composes the world from it under the anchor's animated
+ * row. Writing it is announced on the joint, which is what carries it to the row — the model
+ * marks the row on that announcement — and what lets the attachment system recompose the CPU's
+ * copy of the world below it. That copy is composed under the anchor as the CPU knows it, which
+ * for a GPU-driven anchor is its rest pose: what the simulation may read about a cape joint is
+ * its offset, or an exact evaluation, never that composed world.
+ *
+ * Nothing above the anchor is touched: the anchor is the character's, animated by its clips,
+ * and this pass hangs a cape from it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Write the reconstructed pose onto the rig's joints.
+ *
+ * @param {ClothInstance} instance
+ * @param {EntityComponentDataset} ecd
+ */
+export function cloth_write_back_rig(instance, ecd) {
+    cloth_reconstruct_pose(instance);
+
+    const node_count = instance.node_count;
+
+    const parent = instance.node_parent;
+    const node_joint = instance.node_joint;
+    const node_attachment = instance.node_attachment;
+
+    const node_output = instance.node_output;
+
+    for (let node = 0; node < node_count; node++) {
+        if (node_output[node] === 0) {
+            // a bone the garment hangs from: the character's, not cloth's
+            continue;
+        }
+
+        const joint = node_joint[node];
+        const attachment = node_attachment[node];
+
+        if (attachment === undefined || attachment === null || !ecd.entityExists(joint)) {
+            continue;
+        }
+
+        cloth_write_local_pose(attachment.transform, instance, node, parent[node]);
+
+        ecd.sendEvent(joint, TRANSFORM_ATTACHMENT_EVENT_CHANGE);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_playground_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/cloth_playground_build.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAZoC,KAAK,EAA9B,OAAO,GAAC,OAAO;IACC,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,OAAO,EAAvB,MAAM;IACU,IAAI,EAApB,MAAM;IACU,iBAAiB,EAAjC,MAAM;IACU,YAAY,EAA5B,MAAM;IACkC,MAAM,EAA9C,KAAK,GAAC,SAAS,GAAC,OAAO,GAAC,MAAM;IACb,IAAI,EAArB,OAAO;IAEL,oBAAoB,CAgBhC;;WAjCa,UAAU;;;;;cACV,UAAU;;2BAxBG,yBAAyB"}
+{"version":3,"file":"cloth_playground_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/cloth_playground_build.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAZoC,KAAK,EAA9B,OAAO,GAAC,OAAO;IACC,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,OAAO,EAAvB,MAAM;IACU,IAAI,EAApB,MAAM;IACU,iBAAiB,EAAjC,MAAM;IACU,YAAY,EAA5B,MAAM;IACkC,MAAM,EAA9C,KAAK,GAAC,SAAS,GAAC,OAAO,GAAC,MAAM;IACb,IAAI,EAArB,OAAO;IAEL,oBAAoB,CAgBhC;;WAjCa,UAAU;;;;;cACV,UAAU;;2BAzBG,yBAAyB"}

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

@@ -1,5 +1,6 @@
 import { ClothState } from "../solver/ClothState.js";
 import { cloth_bend_stencil_weights } from "../solver/constraint/cloth_bend_row.js";
+import { cloth_particle_of_source } from "../solver/cloth_particle_of_source.js";
 
 /**
  * # Building the playground's cloth
@@ -289,9 +290,7 @@ function extract_edges_and_hinges(triangle) {
 function permute_triangles(triangle, state) {
     const particle_of_source = new Int32Array(state.particle_count);
 
-    for (let i = 0; i < state.particle_count; i++) {
-        particle_of_source[state.source_of_particle[i]] = i;
-    }
+    cloth_particle_of_source(particle_of_source, state.source_of_particle, state.particle_count);
 
     const out = new Int32Array(triangle.length);
 

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

@@ -23,6 +23,7 @@ import { find_non_finite_cloth_state } from "../solver/find_non_finite_cloth_sta
 import { build_cloth_playground_scene } from "./cloth_playground_build.js";
 import { COLLIDER_SCENES, unsweep } from "./collide_build.js";
 import { draw_cloth, PlaygroundCamera, project } from "./cloth_playground_draw.js";
+import { cloth_kinetic_energy } from "../solver/cloth_kinetic_energy.js";
 
 /**
  * # Cloth collision playground — M2
@@ -173,7 +174,7 @@ function step_once() {
 
     const started = performance.now();
 
-    contact_rows = cloth_contact_find(state, colliders.table, colliders.keys, colliders.count, FIXED_STEP);
+    contact_rows = cloth_contact_find(state, colliders.table, colliders.keys, colliders.count, FIXED_STEP, 0);
 
     cloth_step(
         state, FIXED_STEP, 0, -9.81, 0,
@@ -227,33 +228,6 @@ function penetration() {
     return worst;
 }
 
-/**
- * @returns {number} kinetic energy, J
- */
-function kinetic() {
-    const state = cloth.state;
-
-    let total = 0;
-
-    for (let i = 0; i < state.particle_count; i++) {
-        const w = state.mass_inverse[i];
-
-        if (w === 0) {
-            continue;
-        }
-
-        const p = i * 3;
-
-        total += 0.5 * (
-            state.velocity[p] * state.velocity[p] +
-            state.velocity[p + 1] * state.velocity[p + 1] +
-            state.velocity[p + 2] * state.velocity[p + 2]
-        ) / w;
-    }
-
-    return total;
-}
-
 // ------------------------------------------------------------------- draw
 
 /**
@@ -464,7 +438,7 @@ function refresh_readout() {
     element('r_contacts').textContent = String(contact_rows);
     element('r_pen').textContent = `${(worst_penetration * 1000).toFixed(2)} mm`;
     element('r_rest').textContent = `${(penetration() * 1000).toFixed(2)} mm`;
-    element('r_energy').textContent = kinetic().toExponential(2);
+    element('r_energy').textContent = cloth_kinetic_energy(cloth.state).toExponential(2);
 
     const offender = find_non_finite_cloth_state(cloth.state);
 

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

@@ -1 +1 @@
-{"version":3,"file":"garment_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/garment_build.js"],"names":[],"mappings":"AA8FA;;;GAGG;AACH,6FAHW,MAAM,GACJ,QAAQ,YAAY,CAAC,CA6EjC;AAiKD;;;;;;GAMG;AACH,8CAHW,MAAM,GACJ,IAAI,CAyBhB;AAnVD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;IAqCE;;SAjDY,sBAAsB;WACtB,WAAW;eACX,mBAAmB;YACnB,MAAM;;;;;;;;;UAGN,QAAQ;;;;WACR,QAAQ;;;;;UAER,MAAM,EAAE,EAAE;;uCA7Ce,wCAAwC;4BAcnD,uBAAuB;oCAHf,+BAA+B"}
+{"version":3,"file":"garment_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/garment_build.js"],"names":[],"mappings":"AAgGA;;;GAGG;AACH,6FAHW,MAAM,GACJ,QAAQ,YAAY,CAAC,CAuFjC;AAiKD;;;;;;GAMG;AACH,8CAHW,MAAM,GACJ,IAAI,CAyBhB;AA7VD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;IAqCE;;SAjDY,sBAAsB;WACtB,WAAW;eACX,mBAAmB;YACnB,MAAM;;;;;;;;;UAGN,QAAQ;;;;WACR,QAAQ;;;;;UAER,MAAM,EAAE,EAAE;;uCA/Ce,wCAAwC;4BAgBnD,uBAAuB;oCAJf,+BAA+B"}

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

@@ -15,10 +15,12 @@ import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { Collider } from "../../ecs/Collider.js";
 import { cloth_proxy_from_joints } from "../build/cloth_proxy_from_joints.js";
 import { Cloth } from "../ecs/Cloth.js";
+import { ClothPin } from "../ecs/ClothPin.js";
 import { ClothCollider } from "../ecs/ClothCollider.js";
 import { ClothColliderSystem } from "../ecs/ClothColliderSystem.js";
 import { ClothFlags } from "../ecs/ClothFlags.js";
 import { ClothRig } from "../ecs/ClothRig.js";
+import { MeshSkin } from "../../../graphics/ecs/mesh-v2/MeshSkin.js";
 import { ClothSystem } from "../ecs/ClothSystem.js";
 import { ClothDynamicsFlags } from "../ecs/ClothDynamicsFlags.js";
 import { CLOTH_DYNAMICS_BY_NAME } from "../ecs/cloth_dynamics_library.js";
@@ -118,7 +120,7 @@ export async function build_garment({ preset, dynamics, links, spacing, collide,
     const entry = GARMENT_PRESETS.find(p => p.id === preset) ?? GARMENT_PRESETS[0];
 
         const skeleton = build_skeleton(ecd, entry, links, spacing);
-    const { proxy, error } = cloth_proxy_from_joints(skeleton.prefab, skeleton.skin, skeleton.garment_names, {
+    const { proxy, groups, error } = cloth_proxy_from_joints(skeleton.prefab, skeleton.skin, skeleton.garment_names, {
         name: entry.label
     });
 
@@ -132,8 +134,14 @@ export async function build_garment({ preset, dynamics, links, spacing, collide,
 
     transform.updateMatrix();
 
+    // the garment's skin, on an entity of its own: what the rig drives
+    const joints = Int32Array.from(skeleton.skin.joints, joint => skeleton.instance.entities[joint]);
+    const skinned = ecd.createEntity();
+
+    ecd.addComponentToEntity(skinned, MeshSkin.from(joints, skeleton.skin.inverse_bind_matrices));
+
     ecd.addComponentToEntity(entity, transform);
-    ecd.addComponentToEntity(entity, ClothRig.from(proxy));
+    ecd.addComponentToEntity(entity, ClothRig.from(proxy, skinned));
 
     // The library entry is frozen and shared, so a page that wants to switch
     // one flag owns a copy — which is the whole of what `.clone()` is for.
@@ -145,9 +153,13 @@ export async function build_garment({ preset, dynamics, links, spacing, collide,
 
     ecd.addComponentToEntity(entity, Cloth.from(fabric, { flags: ClothFlags.NeverSleep }));
 
-    // the one method `ClothSystem` calls on a model provider: the instance whose skins address the
-    // joints as entities
-    cloth.models = { instance_of: () => skeleton.instance };
+    // held at the bones the garment hangs from, as the build said
+    for (const group of groups) {
+        ecd.addComponentToEntity(
+            joints[group.joint],
+            ClothPin.from({ cloth: entity, particles: group.particles })
+        );
+    }
 
     if (collide) {
         add_body_colliders(ecd, skeleton);