@woosh/meep-engine 3.42.0 → 3.44.0

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

@@ -13,18 +13,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 +173,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 +183,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 +205,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 +218,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 +235,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;
 
@@ -279,8 +308,8 @@ function read_rest_pose(instance, remembered) {
     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;
 }
 
 /**

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":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;GAMG;AACH,wFAFa,IAAI,CAwDhB;AAyBD;;;;;;;;;;;;;;GAcG;AACH,0FAJW,MAAM,UACN,MAAM,GACJ,IAAI,CA6DhB"}

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

@@ -86,28 +86,35 @@ 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];
+    const ax = instance.frame_translation[0];
+    const ay = instance.frame_translation[1];
+    const az = instance.frame_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;
+    const frame_rotation = instance.frame_rotation;
 
     const parent = instance.node_parent;
 
-    for (let node = 1; node < node_count; node++) {
+    const node_output = instance.node_output;
+
+    for (let node = 0; node < node_count; node++) {
+        if (node_output[node] === 0) {
+            // the frame itself: read, never written
+            continue;
+        }
+
         const transform = instance.node_transform[node];
 
         const n = node * 3;
 
-        v3_quaternion_apply_array(transform, TRANSFORM64_TRANSLATION_OFFSET, blended, n, anchor_rotation, 0);
+        v3_quaternion_apply_array(transform, TRANSFORM64_TRANSLATION_OFFSET, blended, n, frame_rotation, 0);
 
         transform[TRANSFORM64_TRANSLATION_OFFSET] += ax;
         transform[TRANSFORM64_TRANSLATION_OFFSET + 1] += ay;
         transform[TRANSFORM64_TRANSLATION_OFFSET + 2] += az;
 
-        quat3_multiply_array(transform, TRANSFORM64_ROTATION_OFFSET, anchor_rotation, 0, reconstructed, node * 4);
+        quat3_multiply_array(transform, TRANSFORM64_ROTATION_OFFSET, frame_rotation, 0, reconstructed, node * 4);
 
         transform.updateMatrix();
 
@@ -144,6 +151,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
@@ -158,19 +170,51 @@ export function cloth_write_local_pose(local, instance, node, parent) {
     // 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;
+    const conjugate = scratch_parent_conjugate;
 
-    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];
+    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];
 
-    v3_quaternion_apply_inverse_array(local, TRANSFORM64_TRANSLATION_OFFSET, offset, 0, rotation, parent * 4);
+        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];
 
-    const conjugate = scratch_parent_conjugate;
+        local.updateMatrix();
+
+        return;
+    }
+
+    if (instance.node_output[parent] !== 0) {
+        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];
+
+        v3_quaternion_apply_inverse_array(local, TRANSFORM64_TRANSLATION_OFFSET, offset, 0, rotation, parent * 4);
 
-    conjugate[0] = -rotation[parent * 4];
-    conjugate[1] = -rotation[parent * 4 + 1];
-    conjugate[2] = -rotation[parent * 4 + 2];
-    conjugate[3] = rotation[parent * 4 + 3];
+        conjugate[0] = -rotation[parent * 4];
+        conjugate[1] = -rotation[parent * 4 + 1];
+        conjugate[2] = -rotation[parent * 4 + 2];
+        conjugate[3] = rotation[parent * 4 + 3];
+    } else {
+        const boundary = instance.boundary_pose;
+        const b = parent * 7;
+
+        offset[0] = blended[node * 3] - boundary[b];
+        offset[1] = blended[node * 3 + 1] - boundary[b + 1];
+        offset[2] = blended[node * 3 + 2] - boundary[b + 2];
+
+        v3_quaternion_apply_inverse_array(local, TRANSFORM64_TRANSLATION_OFFSET, offset, 0, boundary, b + 3);
+
+        conjugate[0] = -boundary[b + 3];
+        conjugate[1] = -boundary[b + 4];
+        conjugate[2] = -boundary[b + 5];
+        conjugate[3] = boundary[b + 6];
+    }
 
     quat3_multiply_array(local, TRANSFORM64_ROTATION_OFFSET, conjugate, 0, rotation, node * 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/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, 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,

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);

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

@@ -410,7 +410,7 @@ function refresh_readout() {
 
     const state = instance.state;
 
-    element('r_joints').textContent = String(scene.proxy.joint_count);
+    element('r_joints').textContent = String(scene.proxy.particle_count);
     element('r_particles').textContent = String(state.particle_count);
     element('r_rows').textContent = `${state.stretch_count} / ${state.leash_count}`;
     element('r_contacts').textContent = String(instance.contact_count);

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

@@ -1 +1 @@
-{"version":3,"file":"rig_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/rig_build.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;GAaG;AACH;IAN2B,GAAG,EAAnB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,KAAK,EAArB,MAAM;IACU,OAAO,EAAvB,MAAM;IACJ,QAAQ,aAAa,CAAC,CAyClC;AA1HD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;GAQG;AAEH;;;GAGG;AACH,yBAFU,MAAM;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,CAiC3E;;QA3CY,aAAa;SACb,sBAAsB;WACtB,WAAW;;;;YACX,MAAM,EAAE;;;;YACR,MAAM,EAAE,EAAE;;;;cACV,MAAM,EAAE;;8BA1CQ,+BAA+B;uCADtB,wCAAwC;4BAWnD,uBAAuB"}
+{"version":3,"file":"rig_build.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/playground/rig_build.js"],"names":[],"mappings":"AAoFA;;;;;;;;;;;;;GAaG;AACH;IAN2B,GAAG,EAAnB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,KAAK,EAArB,MAAM;IACU,OAAO,EAAvB,MAAM;IACJ,QAAQ,aAAa,CAAC,CAyClC;AA1HD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;GAQG;AAEH;;;GAGG;AACH,yBAFU,MAAM;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,CAiC3E;;QA3CY,aAAa;SACb,sBAAsB;WACtB,WAAW;;;;YACX,MAAM,EAAE;;;;YACR,MAAM,EAAE,EAAE;;;;cACV,MAAM,EAAE;;8BA3CQ,+BAA+B;uCADtB,wCAAwC;4BAYnD,uBAAuB"}