@woosh/meep-engine 3.24.0 → 3.26.0

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

@@ -1,12 +1,16 @@
 /**
- * # The system — gather, step, write back
+ * # The system — gather, step, write back, all on this thread
  *
- * One {@link ClothInstance} per {@link Cloth} component, stepped at the fixed
- * rate. Per step, per cloth: move the local frame with the anchor, point the
- * leash rows at where they measure from, step, and put the result back on the
- * subtree. The animated pose the leashes are measured against is not recomposed
- * per step — in the entity path it is constant in the anchor's own frame, and
- * `cloth_seed_subtree.js` bakes it.
+ * Every cloth in the scene stepped inline at the fixed rate. The work itself
+ * lives in {@link ClothWorld}, which this shares with {@link WorkerClothSystem}
+ * so that §12's "`ClothSystem` and `WorkerClothSystem` must produce bit-identical
+ * results" is a property of there being one copy rather than of two copies
+ * agreeing. What is left here is a `System`'s own surface — what it depends on,
+ * what it accesses, and the loop.
+ *
+ * This is the fallback where `SharedArrayBuffer` is unavailable, and it is **not
+ * a degraded mode**: it is the same solver over the same data in the same
+ * order, and the only thing the worker buys is which thread pays for it.
  *
  * ## Where in the frame this runs
  *
@@ -37,29 +41,6 @@
  * it before `TransformAttachmentSystem`, which is right: cloth writes the local
  * transforms and the attachment system is their reader.
  *
- * ## The local frame and the inertia model — §7 P7
- *
- * Particles live in the anchor's own frame. When the anchor moves, the cloth is
- * asked how much of that motion it would like to feel:
- * `ClothDynamics#inertia = 1` keeps every particle's **world** position and
- * velocity, so a cape trails a sprinting character; `0` keeps their **local**
- * ones, so the cloth rides the anchor as though it were standing still. The
- * blend between the two is a lerp in the local frame, which is all the frame
- * change is.
- *
- * The felt motion is limited before the blend, which is what makes "character
- * sprints, cape behaves" a default rather than a tuning exercise, and the limits
- * are derived from the cloth's own reach rather than authored.
- *
- * ## Teleport — §7 P6
- *
- * Anchor motion past a threshold is not locomotion and is not treated as any
- * amount of it. `ClothFlags.TeleportKeep` carries the shape across, which in a
- * local frame is literally doing nothing; the default re-seeds at the animated
- * pose with zero velocity and opens a stabilisation window in which the
- * velocity limit ramps back from nothing, so the first steps after a reset
- * cannot produce a whip.
- *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -68,64 +49,84 @@ export class ClothSystem extends System<any> {
     dependencies: (typeof Transform64 | typeof Cloth)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof TransformAttachment> | ResourceAccessSpecification<typeof ClothCollider> | ResourceAccessSpecification<typeof Cloth> | ResourceAccessSpecification<typeof ClothExclude> | ResourceAccessSpecification<typeof ClothRig>)[];
     /**
-     * World gravity, m/s². Rotated into each cloth's local frame per step.
+     * @type {ClothWorld}
+     */
+    world: ClothWorld;
+    /**
+     * Every nominated cloth's step parameters, one block each, grown as the
+     * scene grows.
+     *
+     * The same blocks {@link WorkerClothSystem} writes into the shared command
+     * region — one layout, written by one function, so the inline path and the
+     * worker path cannot be handed different numbers. **One block per cloth
+     * rather than one reused block**, because the three phases of a tick are now
+     * three loops and a cloth's parameters have to survive from its `advance` to
+     * its step. See {@link fixedUpdate}.
      * @type {Float64Array}
+     * @private
      */
-    gravity: Float64Array;
+    private __params;
     /**
-     * Live cloths, ordered so that an instance whose anchor sits inside another
-     * instance's subtree steps after it.
+     * The cloths `advance` nominated this tick, in the order it nominated them.
+     * Cleared at the top of every {@link fixedUpdate}; nothing here outlives a
+     * tick.
      * @type {ClothInstance[]}
+     * @private
      */
-    instances: ClothInstance[];
+    private __dispatched;
     /**
-     * @type {Map<number, ClothInstance>}
-     * @private
+     * @param {Float64Array} value
      */
-    private __by_entity;
+    set gravity(value: Float64Array);
     /**
-     * @type {TransformAttachmentSystem|null}
-     * @private
+     * World gravity, m/s². Rotated into each cloth's local frame per step.
+     * @returns {Float64Array}
      */
-    private __attachments;
+    get gravity(): Float64Array;
     /**
-     * Where a skinned model instance comes from. Anything that answers
-     * `instance_of(entity)` with a `PrefabInstance` — skins whose joints
-     * are entities — will do, and {@link MeshSystem} is what does in a
-     * running engine.
-     *
-     * Public and assignable because a garment's joints are a *rendering*
-     * structure and `MeshSystem` needs a graphics engine, a scene and a loader
-     * to exist — so a spec that wants joints without a renderer sets this
-     * instead, and gets exactly the interface the system uses.
-     *
-     * `null` means no rig can seed, which is the same additive shape the
-     * collider index has: a scene without one gets M1's cloth rather than an
-     * error.
-     * @type {{instance_of: function(number): (PrefabInstance|null)}|null}
+     * @param {AbstractClothWind|null} value
      */
-    models: {
-        instance_of: (arg0: number) => (PrefabInstance | null);
-    } | null;
+    set wind(value: any);
     /**
-     * The collider index's owner, or `null` when the manager has none — in
-     * which case cloth simply does not collide, which is exactly M1's
-     * behaviour and is what makes the collision layer additive rather than a
-     * new requirement on every scene.
-     * @type {ClothColliderSystem|null}
-     * @private
+     * Where the air comes from — see {@link ClothWorld#wind}. `null` by default,
+     * which is a scene with no wind in it.
+     * @returns {AbstractClothWind|null}
      */
-    private __colliders;
+    get wind(): any;
     /**
-     * @type {boolean}
-     * @private
+     * Live cloths, ordered so that an instance whose anchor sits inside another
+     * instance's subtree steps after it.
+     * @returns {ClothInstance[]}
+     */
+    get instances(): ClothInstance[];
+    /**
+     * @param {{instance_of: function(number): (PrefabInstance|null)}|null} value
      */
-    private __order_dirty;
+    set models(value: {
+        instance_of: (arg0: number) => (PrefabInstance | null);
+    });
+    /**
+     * Where a skinned model instance comes from — see {@link ClothWorld#models}.
+     * @returns {{instance_of: function(number): (PrefabInstance|null)}|null}
+     */
+    get models(): {
+        instance_of: (arg0: number) => (PrefabInstance | null);
+    };
     /**
      * @param {EntityManager} entityManager
      * @returns {Promise<void>}
      */
     startup(entityManager: EntityManager): Promise<void>;
+    /**
+     * @param {EntityComponentDataset} dataset
+     * @returns {void}
+     */
+    handleDatasetAttached(dataset: EntityComponentDataset): void;
+    /**
+     * @param {EntityComponentDataset} dataset
+     * @returns {void}
+     */
+    handleDatasetDetached(dataset: EntityComponentDataset): void;
     /**
      * @param {Cloth} cloth
      * @param {Transform64} transform
@@ -140,22 +141,12 @@ export class ClothSystem extends System<any> {
     unlink(cloth: Cloth, transform: Transform64, entity: number): void;
     /**
      * Throw away a cloth's binding so the next step walks its subtree again.
-     *
-     * The walk is done once, because a rope's links do not come and go. When
-     * they do — a chain gains a link, a rig is rebuilt — this is how you say so,
-     * and it is the same contract `TransformAttachment#parent` already carries:
-     * the structure is immutable while it is attached, and changing it is an
-     * explicit act rather than something the engine polls for.
-     *
      * @param {number} entity
      * @returns {void}
      */
     reseed(entity: number): void;
     /**
-     * Wake a sleeping cloth. Anchor motion and a `ClothDynamics` change do this
-     * on their own; a caller that has changed the world in some way the cloth
-     * cannot see — M6's wind, for one — says so here.
-     *
+     * Wake a sleeping cloth.
      * @param {number} entity
      * @returns {void}
      */
@@ -165,7 +156,6 @@ export class ClothSystem extends System<any> {
      * @returns {ClothInstance|undefined}
      */
     instanceOf(entity: number): ClothInstance | undefined;
-    #private;
 }
 import { System } from "../../../ecs/System.js";
 import { Transform64 } from "../../../ecs/transform/Transform64.js";
@@ -175,5 +165,5 @@ import { TransformAttachment } from "../../../ecs/transform-attachment/Transform
 import { ClothCollider } from "./ClothCollider.js";
 import { ClothExclude } from "./ClothExclude.js";
 import { ClothRig } from "./ClothRig.js";
-import { ClothInstance } from "./ClothInstance.js";
+import { ClothWorld } from "./ClothWorld.js";
 //# sourceMappingURL=ClothSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothSystem.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH;;IAEI,oDAAoC;IAEpC,iUAOE;IAEF;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;OAIG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;;OAGG;IACH,oBAAwB;IAExB;;;OAGG;IACH,sBAAqB;IAErB;;;;;;;;;;;;;;;OAeG;IACH,QAFU;QAAC,WAAW,SAAW,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC,CAAA;KAAC,GAAC,IAAI,CAEvD;IAEd;;;;;;;OAOG;IACH,oBAAmB;IAEnB;;;OAGG;IACH,sBAAsB;IAEtB;;;OAGG;IACH,uCAFa,QAAQ,IAAI,CAAC,CAiBzB;IAED;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAahB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAgBhB;IAED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,IAAI,CAahB;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;;CAibJ;uBA3tBsB,wBAAwB;4BAWxC,uCAAuC;sBAUxB,YAAY;4CAtBU,uDAAuD;oCAI5F,0DAA0D;8BAmBnC,oBAAoB;6BAErB,mBAAmB;yBAIvB,eAAe;8BADV,oBAAoB"}
+{"version":3,"file":"ClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;;IAEI,oDAAoC;IAEpC,iUAOE;IAEF;;OAEG;IACH,OAFU,UAAU,CAEK;IAEzB;;;;;;;;;;;;OAYG;IACH,iBAAyD;IAEzD;;;;;;OAMG;IACH,qBAAkB;IAUlB;;OAEG;IACH,iCAEC;IAbD;;;OAGG;IACH,4BAEC;IAkBD;;OAEG;IACH,qBAEC;IAdD;;;;OAIG;IACH,gBAEC;IASD;;;;OAIG;IACH,iCAEC;IAUD;;OAEG;IACH;4BAToC,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC;OAWjE;IAbD;;;OAGG;IACH;4BAFoC,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC;MAIjE;IASD;;;OAGG;IACH,uCAFa,QAAQ,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,gBAAc,SAAS,CAInC;CA2EJ;uBAxSsB,wBAAwB;4BAInB,uCAAuC;sBAE7C,YAAY;4CAPU,uDAAuD;oCAI5F,0DAA0D;8BAInC,oBAAoB;6BACrB,mBAAmB;yBACvB,eAAe;2BACb,iBAAiB"}