@woosh/meep-engine 3.25.0 → 3.27.0

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

@@ -46,13 +46,6 @@ export class ClothInstance {
      * @type {Transform64|null}
      */
     transform: Transform64 | null;
-    /**
-     * How deep the anchor sits in the transform hierarchy. Instances step in
-     * ascending depth so that a `Cloth` nested inside another one reads an
-     * anchor the outer solve has already written this step.
-     * @type {number}
-     */
-    depth: number;
     /**
      * `false` until the subtree has been walked. Seeding is deferred to the
      * first step rather than done at link, because a rope's links arrive as
@@ -428,6 +421,71 @@ export class ClothInstance {
      * @type {boolean}
      */
     air_varies: boolean;
+    /**
+     * Seconds of fixed step **this instance** has taken, which is the clock
+     * §10's gust is a function of.
+     *
+     * Per cloth rather than per world, and the difference only shows with more
+     * than one of them. A cloth registered with the worker while another is
+     * already running waits for its memory, and the world's clock moves during
+     * that wait because the other cloth is still being advanced — so the two
+     * systems reach *this* cloth's first step at different world times and hand
+     * it different weather. An age counted in its own steps is the same number
+     * on both sides by construction. `MEASUREMENTS.md` §57.
+     *
+     * Advanced on every step the instance is *offered*, including ones it
+     * sleeps through, because a sleeping cloth still has to be able to ask
+     * whether the air has changed enough to wake it.
+     * @type {number}
+     */
+    age: number;
+    /**
+     * The index handles this cloth last **stepped against**, in the order the
+     * broadphase returned them, and how many of them are meaningful.
+     *
+     * §7 P5's wake test compares each overlapping collider's previous pose with
+     * its current one, and `ClothColliderSystem#link` *places* a new collider —
+     * previous equals current — so a collider spawned around a sleeping cloth
+     * is one that has not moved and never woke it. The set is the other half of
+     * that question: a handle appearing or leaving is a change to the world the
+     * cloth went to sleep in, whatever the poses say.
+     * @type {Int32Array}
+     */
+    collider_keys: Int32Array;
+    /**
+     * @type {number}
+     */
+    collider_key_count: number;
+    /**
+     * The broadphase margin the last gather used, metres. The wake test has to
+     * query with the same one, or it compares a set built under one reach with
+     * a set built under another and wakes on the difference between the two
+     * questions rather than on a change in the world.
+     * @type {number}
+     */
+    gather_reach: number;
+    /**
+     * The joint entities this cloth's rig seeding took `TransformAttachment`
+     * authority from, so that removing the cloth can give it back. `null` on
+     * the entity path and before the first rig seeding.
+     *
+     * Only the ones the revoke actually changed: a joint that was already the
+     * CPU's is not one cloth has anything to hand back.
+     * @type {number[]|null}
+     */
+    revoked_joints: number[] | null;
+    /**
+     * Where every particle was when the current sleep window opened, or `null`
+     * before the first step — §7 P5's sleep test measures displacement from
+     * this rather than an instantaneous speed, because a cloth resting on a
+     * collider sits in a bounded limit cycle whose speed is not small.
+     *
+     * Re-anchored to the live positions whenever a particle leaves the
+     * threshold, so the window is "how far has anything moved since the cloth
+     * last moved" rather than a fixed grid of epochs.
+     * @type {Float32Array|null}
+     */
+    sleep_reference: Float32Array | null;
     /**
      * How many times this cloth has been re-seeded by a teleport. Diagnostic:
      * a cloth resetting every few seconds is being driven by something that

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

@@ -1 +1 @@
-{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"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"}

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

@@ -1,4 +1,5 @@
 import { Transform64 } from "../../../ecs/transform/Transform64.js";
+import { CLOTH_COLLIDER_SLOTS } from "../solver/cloth_solver_constants.js";
 import { ClothDynamics } from "./ClothDynamics.js";
 
 /**
@@ -53,14 +54,6 @@ export class ClothInstance {
      */
     transform = null;
 
-    /**
-     * How deep the anchor sits in the transform hierarchy. Instances step in
-     * ascending depth so that a `Cloth` nested inside another one reads an
-     * anchor the outer solve has already written this step.
-     * @type {number}
-     */
-    depth = 0;
-
     /**
      * `false` until the subtree has been walked. Seeding is deferred to the
      * first step rather than done at link, because a rope's links arrive as
@@ -482,6 +475,77 @@ export class ClothInstance {
      */
     air_varies = false;
 
+    /**
+     * Seconds of fixed step **this instance** has taken, which is the clock
+     * §10's gust is a function of.
+     *
+     * Per cloth rather than per world, and the difference only shows with more
+     * than one of them. A cloth registered with the worker while another is
+     * already running waits for its memory, and the world's clock moves during
+     * that wait because the other cloth is still being advanced — so the two
+     * systems reach *this* cloth's first step at different world times and hand
+     * it different weather. An age counted in its own steps is the same number
+     * on both sides by construction. `MEASUREMENTS.md` §57.
+     *
+     * Advanced on every step the instance is *offered*, including ones it
+     * sleeps through, because a sleeping cloth still has to be able to ask
+     * whether the air has changed enough to wake it.
+     * @type {number}
+     */
+    age = 0;
+
+    /**
+     * The index handles this cloth last **stepped against**, in the order the
+     * broadphase returned them, and how many of them are meaningful.
+     *
+     * §7 P5's wake test compares each overlapping collider's previous pose with
+     * its current one, and `ClothColliderSystem#link` *places* a new collider —
+     * previous equals current — so a collider spawned around a sleeping cloth
+     * is one that has not moved and never woke it. The set is the other half of
+     * that question: a handle appearing or leaving is a change to the world the
+     * cloth went to sleep in, whatever the poses say.
+     * @type {Int32Array}
+     */
+    collider_keys = new Int32Array(CLOTH_COLLIDER_SLOTS);
+
+    /**
+     * @type {number}
+     */
+    collider_key_count = 0;
+
+    /**
+     * The broadphase margin the last gather used, metres. The wake test has to
+     * query with the same one, or it compares a set built under one reach with
+     * a set built under another and wakes on the difference between the two
+     * questions rather than on a change in the world.
+     * @type {number}
+     */
+    gather_reach = 0;
+
+    /**
+     * The joint entities this cloth's rig seeding took `TransformAttachment`
+     * authority from, so that removing the cloth can give it back. `null` on
+     * the entity path and before the first rig seeding.
+     *
+     * Only the ones the revoke actually changed: a joint that was already the
+     * CPU's is not one cloth has anything to hand back.
+     * @type {number[]|null}
+     */
+    revoked_joints = null;
+
+    /**
+     * Where every particle was when the current sleep window opened, or `null`
+     * before the first step — §7 P5's sleep test measures displacement from
+     * this rather than an instantaneous speed, because a cloth resting on a
+     * collider sits in a bounded limit cycle whose speed is not small.
+     *
+     * Re-anchored to the live positions whenever a particle leaves the
+     * threshold, so the window is "how far has anything moved since the cloth
+     * last moved" rather than a fixed grid of epochs.
+     * @type {Float32Array|null}
+     */
+    sleep_reference = null;
+
     /**
      * How many times this cloth has been re-seeded by a teleport. Diagnostic:
      * a cloth resetting every few seconds is being driven by something that

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

@@ -53,16 +53,27 @@ export class ClothSystem extends System<any> {
      */
     world: ClothWorld;
     /**
-     * One cloth's step parameters, reused for every cloth in turn because the
-     * step follows immediately.
+     * Every nominated cloth's step parameters, one block each, grown as the
+     * scene grows.
      *
-     * The same block {@link WorkerClothSystem} writes into the shared command
+     * 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.
+     * 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
      */
     private __params;
+    /**
+     * 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
+     */
+    private __dispatched;
     /**
      * @param {Float64Array} value
      */
@@ -106,6 +117,16 @@ export class ClothSystem extends System<any> {
      * @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

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":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;;IAEI,oDAAoC;IAEpC,iUAOE;IAEF;;OAEG;IACH,OAFU,UAAU,CAEK;IAEzB;;;;;;;;;OASG;IACH,iBAAqD;IAUrD;;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;;;;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;CAoCJ;uBArOsB,wBAAwB;4BAInB,uCAAuC;sBAE7C,YAAY;4CAPU,uDAAuD;oCAI5F,0DAA0D;8BAInC,oBAAoB;6BACrB,mBAAmB;yBACvB,eAAe;2BACb,iBAAiB"}
+{"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"}

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

@@ -77,16 +77,28 @@ export class ClothSystem extends System {
     world = new ClothWorld();
 
     /**
-     * One cloth's step parameters, reused for every cloth in turn because the
-     * step follows immediately.
+     * Every nominated cloth's step parameters, one block each, grown as the
+     * scene grows.
      *
-     * The same block {@link WorkerClothSystem} writes into the shared command
+     * 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.
+     * 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
      */
-    __params = new Float64Array(CLOTH_STEP_PARAM_STRIDE);
+    __params = new Float64Array(CLOTH_STEP_PARAM_STRIDE * 8);
+
+    /**
+     * 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
+     */
+    __dispatched = [];
 
     /**
      * World gravity, m/s². Rotated into each cloth's local frame per step.
@@ -151,6 +163,22 @@ export class ClothSystem extends System {
         this.world.attach(entityManager);
     }
 
+    /**
+     * @param {EntityComponentDataset} dataset
+     * @returns {void}
+     */
+    handleDatasetAttached(dataset) {
+        this.world.attach_dataset(dataset);
+    }
+
+    /**
+     * @param {EntityComponentDataset} dataset
+     * @returns {void}
+     */
+    handleDatasetDetached(dataset) {
+        this.world.detach_dataset(dataset);
+    }
+
     /**
      * @param {Cloth} cloth
      * @param {Transform64} transform
@@ -196,6 +224,25 @@ export class ClothSystem extends System {
     }
 
     /**
+     * Advance every cloth, then step every cloth, then finish every cloth.
+     *
+     * **Three loops rather than one**, and the reason is §12's parity gate.
+     * `WorkerClothSystem` cannot interleave them: its `apply` writes step T−1
+     * back at the top of the tick and its `collect` then advances everything for
+     * step T, because the step in between happened on another thread. So a
+     * nested cloth there reads its parent's **previous** step's pose, and a
+     * nested cloth here used to read the pose the cloth above it had written
+     * *this* step — `ClothWorld` sorted the instances by hierarchy depth
+     * specifically so that it would. Measured on a 4-link rope hung from link 3
+     * of a 6-link rope, no wind, 120 steps: the parent identical, the child
+     * differing at **step 1, byte 24**.
+     *
+     * Both readings are defensible and only one of them can be the contract.
+     * This is the one that costs nothing to make true on both sides — and once
+     * it is, the depth sort does nothing, so it is gone. What a nested cloth
+     * reads is its parent one fixed step stale, which is the same trade §4.1
+     * already makes for the anchor and measures at a few centimetres.
+     *
      * @param {number} dt seconds
      */
     fixedUpdate(dt) {
@@ -211,6 +258,14 @@ export class ClothSystem extends System {
 
         const instances = world.instances;
 
+        const dispatched = this.__dispatched;
+
+        dispatched.length = 0;
+
+        if (this.__params.length < instances.length * CLOTH_STEP_PARAM_STRIDE) {
+            this.__params = new Float64Array(instances.length * CLOTH_STEP_PARAM_STRIDE);
+        }
+
         const params = this.__params;
 
         for (let i = 0; i < instances.length; i++) {
@@ -220,13 +275,25 @@ export class ClothSystem extends System {
                 continue;
             }
 
-            if (!world.advance(instance, dt, params, 0)) {
+            if (!world.advance(instance, dt, params, dispatched.length * CLOTH_STEP_PARAM_STRIDE)) {
                 continue;
             }
 
-            cloth_step_instance(instance.state, instance.self_exclusions, params, 0);
+            dispatched.push(instance);
+        }
+
+        for (let i = 0; i < dispatched.length; i++) {
+            const instance = dispatched[i];
 
-            world.finish(instance, ecd);
+            cloth_step_instance(
+                instance.state, instance.self_exclusions, params, i * CLOTH_STEP_PARAM_STRIDE
+            );
         }
+
+        for (let i = 0; i < dispatched.length; i++) {
+            world.finish(dispatched[i], ecd);
+        }
+
+        dispatched.length = 0;
     }
 }

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

@@ -87,8 +87,16 @@ export class ClothWorld {
      */
     gravity: Float64Array;
     /**
-     * Live cloths, ordered so that an instance whose anchor sits inside another
-     * instance's subtree steps after it.
+     * Live cloths, in the order they were linked.
+     *
+     * **Not sorted by hierarchy depth**, and it used to be. The sort existed so
+     * that a nested cloth advanced against an anchor the cloth above it had
+     * already written this step — which `WorkerClothSystem` cannot do, because
+     * the step it is writing back happened on another thread a tick ago. Both
+     * systems now advance every cloth, then step every cloth, then finish every
+     * cloth, so a nested cloth reads its parent one fixed step stale on both
+     * sides and the sort has nothing left to decide. `ClothSystem#fixedUpdate`
+     * carries the argument; `MEASUREMENTS.md` §56 carries the measurement.
      * @type {ClothInstance[]}
      */
     instances: ClothInstance[];
@@ -188,10 +196,23 @@ export class ClothWorld {
      */
     private __by_entity;
     /**
-     * @type {boolean}
+     * Watches `Cloth` + {@link ClothRig} so the rig path is a **live**
+     * discriminator rather than one read once.
+     *
+     * `ClothSystem#dependencies` is `[Cloth, Transform64]` — the tuple that
+     * makes something a cloth — so a `ClothRig` added to a live cloth completes
+     * no tuple the system observes and a `ClothRig` removed from one breaks
+     * none. §3.1's "the discriminator is a component's presence" then holds only
+     * for a character spawned whole, which is the one case a spec constructs and
+     * the least likely one in a scene where a model loads asynchronously.
+     *
+     * Both edges re-seed. The removing edge also gives the joints back first,
+     * because the instance that knows which they were is about to stop being a
+     * rig.
+     * @type {EntityObserver}
      * @private
      */
-    private __order_dirty;
+    private __rig_observer;
     /**
      * Resolve the systems a cloth world reads. Called from the owning system's
      * `startup`.
@@ -206,6 +227,21 @@ export class ClothWorld {
      * @returns {ClothInstance}
      */
     link(cloth: Cloth, transform: Transform64, entity: number): ClothInstance;
+    /**
+     * Watch this dataset for a {@link ClothRig} arriving at or leaving a live
+     * cloth. Called from the owning system's `handleDatasetAttached`; see
+     * {@link ClothWorld#__rig_observer} for why the system's own dependency
+     * tuple cannot answer this.
+     *
+     * @param {EntityComponentDataset} dataset
+     * @returns {void}
+     */
+    attach_dataset(dataset: EntityComponentDataset): void;
+    /**
+     * @param {EntityComponentDataset} dataset
+     * @returns {void}
+     */
+    detach_dataset(dataset: EntityComponentDataset): void;
     /**
      * @param {number} entity
      * @returns {ClothInstance|undefined} the instance that was removed
@@ -283,4 +319,5 @@ export class ClothWorld {
 import { ClothInstance } from "./ClothInstance.js";
 import { TransformAttachmentSystem } from "../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 import { ClothColliderSystem } from "./ClothColliderSystem.js";
+import { Cloth } from "./Cloth.js";
 //# sourceMappingURL=ClothWorld.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;OAIG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;;;;;;;;;;;;;;OAeG;IACH,QAFU;QAAC,WAAW,SAAW,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC,CAAA;KAAC,GAAC,IAAI,CAEvD;IAEd;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;OAGG;IACH,sBAAsB;IAEtB;;;;;OAKG;IACH,2CAiBC;IAED;;;;;OAKG;IACH,mDAHW,MAAM,GACJ,aAAa,CAgBzB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAkBnC;IAED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAenC;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAoBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA6BhB;IAmHD;;;;;;;;;;;OAWG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CA+NnB;;CA8EJ;8BA92B6B,oBAAoB;0CAjB3C,gEAAgE;oCAcnC,0BAA0B"}
+{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;;;;;;;;;;;;;;OAeG;IACH,QAFU;QAAC,WAAW,SAAW,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC,CAAA;KAAC,GAAC,IAAI,CAEvD;IAEd;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;OAgBG;IACH,uBAKE;IAEF;;;;;OAKG;IACH,2CAiBC;IAED;;;;;OAKG;IACH,YALW,KAAK,kCAEL,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IA+CD;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAanC;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA2BhB;IAwFD;;;;;;;;;;;OAWG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CAgPnB;;CA8EJ;8BAl8B6B,oBAAoB;0CAjB3C,gEAAgE;oCAcnC,0BAA0B;sBA4BxC,YAAY"}