@woosh/meep-engine 3.22.0 → 3.23.0

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

@@ -0,0 +1,90 @@
+/**
+ * CSR children per node, from the parent array.
+ * @param {ClothInstance} instance
+ * @returns {void}
+ */
+export function cloth_build_children(instance: ClothInstance): void;
+/**
+ * Rows, geodesics and the `ClothState` itself, from a seeded
+ * `node_parent` / `animated_position` pair.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} dt
+ * @returns {void}
+ */
+export function cloth_build_rows(instance: ClothInstance, dt: number): void;
+/**
+ * Re-parameterise the rows of an already-seeded cloth from its current
+ * {@link ClothDynamics}, without walking the subtree again.
+ *
+ * This is what makes `cloth.dynamics.slack = 0.2` work live: the topology, the
+ * rest lengths and the geodesics are properties of the authored pose and do not
+ * move, and everything that does move is a number in a row table.
+ *
+ * The multipliers are **not** reset. A row whose radius has just changed is
+ * carrying a force appropriate to the radius it had, and it is one warm start
+ * away from carrying the right one; zeroing them would put a visible jolt into
+ * every parameter change instead.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} dt
+ * @returns {void}
+ */
+export function cloth_reparameterise(instance: ClothInstance, dt: number): void;
+/**
+ * Whether a dynamics change needs the subtree walked again rather than merely
+ * re-parameterised.
+ *
+ * Two fields do: turning the strain limit on or off adds or removes rows, and
+ * so does moving `slack` across the bound at which its row is provably
+ * inactive. Everything else is a number in a table that already exists.
+ *
+ * @param {ClothDynamics} before
+ * @param {ClothDynamics} after
+ * @returns {boolean}
+ */
+export function cloth_dynamics_change_needs_reseed(before: ClothDynamics, after: ClothDynamics): boolean;
+/**
+ * # The rows, and everything that is a number rather than a walk
+ *
+ * Two seeders reach this module: `cloth_seed_subtree.js` for §11.1's entity
+ * hierarchies and `cloth_seed_rig.js` for §11.2's skinned garments. What they
+ * do differently is find the particles — a transform-attachment walk against a
+ * proxy's baked joint list — and what they do identically is everything after
+ * that, because a row does not care what a node was made of.
+ *
+ * So the split is: a seeder produces `node_parent` and `animated_position`, and
+ * {@link cloth_build_rows} turns those into geodesics, link rows, strain-limit
+ * rows, skip rows, leashes and the `ClothState` itself. M3 moved this out of
+ * `cloth_seed_subtree.js` unchanged rather than writing a second copy for the
+ * rig path, which is the whole reason §11 could say "the solver is identical
+ * either way; only seeding and write-back differ" and mean it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Mass of one particle, kg. Arbitrary and uniform — see the module docblock for
+ * why "arbitrary" is a statement about the solver rather than a shrug.
+ * @type {number}
+ */
+export const CLOTH_PARTICLE_MASS: number;
+/**
+ * Slack radius at `ClothDynamics#slack = 1`, as a multiple of `d_geo`.
+ *
+ * It is **2**, and that is a derivation rather than a taste. The tether row
+ * already holds every particle within `d_geo` of the anchor, and the animated
+ * position it is leashed to is itself within `d_geo` of the anchor — a chord is
+ * never longer than the arc it subtends. By the triangle inequality the two can
+ * therefore never be more than `2·d_geo` apart, so a slack radius of `2·d_geo`
+ * is **provably inactive** and `slack = 1` means exactly "no leash" with no
+ * sentinel value and no discontinuity to code around.
+ *
+ * §3.4 writes `r_i = slack · d_geo,i`, which makes `slack = 1` a real and
+ * fairly tight constraint instead: a rope hanging straight down cannot swing
+ * through 90°, because its tip would move `√2·d_geo` to get there. That is a
+ * bound nobody asked for at the setting that is supposed to ask for none.
+ * @type {number}
+ */
+export const CLOTH_SLACK_REACH: number;
+//# sourceMappingURL=cloth_build_rows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAuDA;;;;GAIG;AACH,+DAFa,IAAI,CAyBhB;AAID;;;;;;;GAOG;AACH,8DAHW,MAAM,GACJ,IAAI,CA4LhB;AAWD;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAoChB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AAhXD;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;GAgBG;AACH,gCAFU,MAAM,CAEmB"}

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

@@ -0,0 +1,374 @@
+import { ClothState } from "../solver/ClothState.js";
+import { ClothDynamicsFlags } from "./ClothDynamicsFlags.js";
+import { cloth_self_closest_free_pair, cloth_self_exclusions } from "../solver/cloth_self_find.js";
+import { cloth_bend_ratio, cloth_strain_allowance } from "./cloth_dynamics_map.js";
+
+/**
+ * # The rows, and everything that is a number rather than a walk
+ *
+ * Two seeders reach this module: `cloth_seed_subtree.js` for §11.1's entity
+ * hierarchies and `cloth_seed_rig.js` for §11.2's skinned garments. What they
+ * do differently is find the particles — a transform-attachment walk against a
+ * proxy's baked joint list — and what they do identically is everything after
+ * that, because a row does not care what a node was made of.
+ *
+ * So the split is: a seeder produces `node_parent` and `animated_position`, and
+ * {@link cloth_build_rows} turns those into geodesics, link rows, strain-limit
+ * rows, skip rows, leashes and the `ClothState` itself. M3 moved this out of
+ * `cloth_seed_subtree.js` unchanged rather than writing a second copy for the
+ * rig path, which is the whole reason §11 could say "the solver is identical
+ * either way; only seeding and write-back differ" and mean it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Mass of one particle, kg. Arbitrary and uniform — see the module docblock for
+ * why "arbitrary" is a statement about the solver rather than a shrug.
+ * @type {number}
+ */
+export const CLOTH_PARTICLE_MASS = 0.02;
+
+
+
+/**
+ * Slack radius at `ClothDynamics#slack = 1`, as a multiple of `d_geo`.
+ *
+ * It is **2**, and that is a derivation rather than a taste. The tether row
+ * already holds every particle within `d_geo` of the anchor, and the animated
+ * position it is leashed to is itself within `d_geo` of the anchor — a chord is
+ * never longer than the arc it subtends. By the triangle inequality the two can
+ * therefore never be more than `2·d_geo` apart, so a slack radius of `2·d_geo`
+ * is **provably inactive** and `slack = 1` means exactly "no leash" with no
+ * sentinel value and no discontinuity to code around.
+ *
+ * §3.4 writes `r_i = slack · d_geo,i`, which makes `slack = 1` a real and
+ * fairly tight constraint instead: a rope hanging straight down cannot swing
+ * through 90°, because its tip would move `√2·d_geo` to get there. That is a
+ * bound nobody asked for at the setting that is supposed to ask for none.
+ * @type {number}
+ */
+export const CLOTH_SLACK_REACH = 2;
+
+
+
+/**
+ * CSR children per node, from the parent array.
+ * @param {ClothInstance} instance
+ * @returns {void}
+ */
+export function cloth_build_children(instance) {
+    const node_count = instance.node_count;
+    const parent = instance.node_parent;
+
+    const offset = new Int32Array(node_count + 1);
+
+    for (let node = 1; node < node_count; node++) {
+        offset[parent[node] + 1]++;
+    }
+
+    for (let node = 0; node < node_count; node++) {
+        offset[node + 1] += offset[node];
+    }
+
+    const child = new Int32Array(node_count > 0 ? node_count - 1 : 0);
+    const cursor = offset.slice(0, node_count);
+
+    for (let node = 1; node < node_count; node++) {
+        child[cursor[parent[node]]++] = node;
+    }
+
+    instance.node_child_offset = offset;
+    instance.node_child = child;
+}
+
+
+
+/**
+ * Rows, geodesics and the `ClothState` itself, from a seeded
+ * `node_parent` / `animated_position` pair.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} dt
+ * @returns {void}
+ */
+export function cloth_build_rows(instance, dt) {
+    const node_count = instance.node_count;
+
+    const parent = instance.node_parent;
+    const rest = instance.animated_position;
+
+    const dynamics = instance.cloth.dynamics;
+
+    const strain_limited = (dynamics.flags & ClothDynamicsFlags.StrainLimit) !== 0;
+
+    const geodesic = new Float32Array(node_count);
+
+    const mass_inverse = new Float32Array(node_count);
+
+    // The anchor is the fixed set: zero inverse mass, and a geodesic of zero,
+    // which is what makes every derived radius collapse onto it correctly.
+    for (let node = 1; node < node_count; node++) {
+        mass_inverse[node] = 1 / CLOTH_PARTICLE_MASS;
+    }
+
+    const stretch_particle = [];
+    const stretch_rest = [];
+    const stretch_stiffness = [];
+    const stretch_force_min = [];
+    const stretch_force_max = [];
+
+    const link_row = new Int32Array(node_count).fill(-1);
+    const strain_row = new Int32Array(node_count).fill(-1);
+    const skip_row = new Int32Array(node_count).fill(-1);
+
+    const strain = cloth_strain_allowance(dynamics.stretch);
+
+    // A skip row spans two links and both of its ends are free, so its
+    // effective inertia along the constraint is half a particle's.
+    const bend_stiffness = cloth_bend_ratio(dynamics.bend)
+        * (CLOTH_PARTICLE_MASS * 0.5) / (dt * dt);
+
+    let reach = 0;
+
+    for (let node = 1; node < node_count; node++) {
+        const p = parent[node];
+
+        const length = Math.hypot(
+            rest[node * 3] - rest[p * 3],
+            rest[node * 3 + 1] - rest[p * 3 + 1],
+            rest[node * 3 + 2] - rest[p * 3 + 2]
+        );
+
+        geodesic[node] = geodesic[p] + length;
+
+        if (geodesic[node] > reach) {
+            reach = geodesic[node];
+        }
+
+        link_row[node] = stretch_rest.length;
+
+        // Hard, bilateral: the fabric row. It is hard because a *penalty* stiff
+        // enough to be fabric adds energy rather than dissipating it — see
+        // `cloth_dynamics_map.js`, and `MEASUREMENTS.md` §6 for the +6.8 J.
+        stretch_particle.push(p, node);
+        stretch_rest.push(length);
+        stretch_stiffness.push(Infinity);
+        stretch_force_min.push(-Infinity);
+        stretch_force_max.push(Infinity);
+
+        if (strain_limited) {
+            strain_row[node] = stretch_rest.length;
+
+            // Hard, one-sided: §6's strain limit, and note the clamp. A row
+            // that bounds a distance from ABOVE may only apply force that
+            // reduces `C`, which for a distance row is the positive half —
+            // `[0, +∞)`. §6's table has this row at `(−∞, 0]`, which is the
+            // force that pushes the two ends apart; `cloth_leash_row.js`
+            // carries the derivation and a spec that shows it directly.
+            stretch_particle.push(p, node);
+            stretch_rest.push(length * (1 + strain));
+            stretch_stiffness.push(Infinity);
+            stretch_force_min.push(0);
+            stretch_force_max.push(Infinity);
+        }
+
+        const grandparent = parent[p];
+
+        if (grandparent >= 0 && bend_stiffness > 0) {
+            const span = Math.hypot(
+                rest[node * 3] - rest[grandparent * 3],
+                rest[node * 3 + 1] - rest[grandparent * 3 + 1],
+                rest[node * 3 + 2] - rest[grandparent * 3 + 2]
+            );
+
+            skip_row[node] = stretch_rest.length;
+
+            // Soft, bilateral: the bending model. Its rest length is read from
+            // the authored pose, so a chain authored with a curve holds it.
+            stretch_particle.push(grandparent, node);
+            stretch_rest.push(span);
+            stretch_stiffness.push(bend_stiffness);
+            stretch_force_min.push(-Infinity);
+            stretch_force_max.push(Infinity);
+        }
+    }
+
+    const leash_particle = [];
+    const leash_radius = [];
+
+    const slack_row = new Int32Array(node_count).fill(-1);
+    const tether_row = new Int32Array(node_count).fill(-1);
+
+    const slack_scale = CLOTH_SLACK_REACH * clamp01(dynamics.slack);
+
+    for (let node = 1; node < node_count; node++) {
+        // Tether first: §7 P2's long-range attachment, and the row that makes a
+        // low iteration budget viable at all, because being hard it is enforced
+        // almost exactly in one iteration however deep the chain is.
+        tether_row[node] = leash_radius.length;
+
+        leash_particle.push(node);
+        leash_radius.push(geodesic[node]);
+
+        if (slack_scale < CLOTH_SLACK_REACH) {
+            slack_row[node] = leash_radius.length;
+
+            leash_particle.push(node);
+            leash_radius.push(slack_scale * geodesic[node]);
+        }
+    }
+
+    let shortest_row = Infinity;
+
+    for (let row = 0; row < stretch_rest.length; row++) {
+        if (stretch_rest[row] > 0 && stretch_rest[row] < shortest_row) {
+            shortest_row = stretch_rest[row];
+        }
+    }
+
+    // A cloth of one particle has no rows at all, so it has no correction
+    // authority to speak of and its reach is the only length it carries.
+    instance.shortest_row = shortest_row < Infinity ? shortest_row : reach;
+
+    instance.geodesic = geodesic;
+    instance.reach = reach;
+    instance.link_row = link_row;
+    instance.strain_row = strain_row;
+    instance.skip_row = skip_row;
+    instance.slack_row = slack_row;
+    instance.tether_row = tether_row;
+
+    const state = ClothState.from({
+        position: rest,
+        mass_inverse,
+        stretch_particle: Int32Array.from(stretch_particle),
+        stretch_rest: Float32Array.from(stretch_rest),
+        stretch_stiffness: Float32Array.from(stretch_stiffness),
+        stretch_force_min: Float32Array.from(stretch_force_min),
+        stretch_force_max: Float32Array.from(stretch_force_max),
+        leash_particle: Int32Array.from(leash_particle),
+        leash_radius: Float32Array.from(leash_radius)
+    });
+
+    const particle_of_node = new Int32Array(node_count);
+
+    for (let particle = 0; particle < node_count; particle++) {
+        particle_of_node[state.source_of_particle[particle]] = particle;
+    }
+
+    // Everything derived from the rows, derived again — and from the bind pose,
+    // which is what `closest_free_pair` has to be measured in: the answer is a
+    // property of how the proxy was authored, not of whatever shape the solver
+    // happens to have the cloth in when self-collision is first switched on.
+    const exclusions = cloth_self_exclusions(state);
+
+    instance.self_exclusions = exclusions;
+
+    // Bounded at twice the shortest row, which is where a sheet's answer lies,
+    // so the walk is 27 cells rather than the whole cloth. A proxy with nothing
+    // that close gets `Infinity`, and then no radius inside the floor can reach
+    // anything either.
+    instance.closest_free_pair = cloth_self_closest_free_pair(
+        state, exclusions, instance.shortest_row * 2
+    );
+
+    instance.particle_of_node = particle_of_node;
+    instance.blended_position = new Float64Array(node_count * 3);
+    instance.blended_rotation = new Float64Array(node_count * 4);
+    instance.state = state;
+    instance.seeded = true;
+}
+
+/**
+ * @param {number} v
+ * @returns {number}
+ * @private
+ */
+function clamp01(v) {
+    return v < 0 ? 0 : (v > 1 ? 1 : v);
+}
+
+/**
+ * Re-parameterise the rows of an already-seeded cloth from its current
+ * {@link ClothDynamics}, without walking the subtree again.
+ *
+ * This is what makes `cloth.dynamics.slack = 0.2` work live: the topology, the
+ * rest lengths and the geodesics are properties of the authored pose and do not
+ * move, and everything that does move is a number in a row table.
+ *
+ * The multipliers are **not** reset. A row whose radius has just changed is
+ * carrying a force appropriate to the radius it had, and it is one warm start
+ * away from carrying the right one; zeroing them would put a visible jolt into
+ * every parameter change instead.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} dt
+ * @returns {void}
+ */
+export function cloth_reparameterise(instance, dt) {
+    const dynamics = instance.cloth.dynamics;
+
+    const state = instance.state;
+
+    const node_count = instance.node_count;
+
+    const strain = cloth_strain_allowance(dynamics.stretch);
+
+    const bend_stiffness = cloth_bend_ratio(dynamics.bend)
+        * (CLOTH_PARTICLE_MASS * 0.5) / (dt * dt);
+
+    const slack_scale = CLOTH_SLACK_REACH * clamp01(dynamics.slack);
+
+    for (let node = 1; node < node_count; node++) {
+        const link = instance.link_row[node];
+        const strain_limit = instance.strain_row[node];
+        const skip = instance.skip_row[node];
+        const slack = instance.slack_row[node];
+
+        if (strain_limit >= 0) {
+            state.stretch_rest[strain_limit] = state.stretch_rest[link] * (1 + strain);
+        }
+
+        if (skip >= 0) {
+            state.stretch_stiffness[skip] = bend_stiffness;
+        }
+
+        if (slack >= 0) {
+            state.leash_radius[slack] = slack_scale * instance.geodesic[node];
+        }
+    }
+
+    instance.dynamics_seen.copy(dynamics);
+}
+
+/**
+ * Whether a dynamics change needs the subtree walked again rather than merely
+ * re-parameterised.
+ *
+ * Two fields do: turning the strain limit on or off adds or removes rows, and
+ * so does moving `slack` across the bound at which its row is provably
+ * inactive. Everything else is a number in a table that already exists.
+ *
+ * @param {ClothDynamics} before
+ * @param {ClothDynamics} after
+ * @returns {boolean}
+ */
+export function cloth_dynamics_change_needs_reseed(before, after) {
+    const strain_before = (before.flags & ClothDynamicsFlags.StrainLimit) !== 0;
+    const strain_after = (after.flags & ClothDynamicsFlags.StrainLimit) !== 0;
+
+    if (strain_before !== strain_after) {
+        return true;
+    }
+
+    const leashed_before = clamp01(before.slack) < 1;
+    const leashed_after = clamp01(after.slack) < 1;
+
+    if (leashed_before !== leashed_after) {
+        return true;
+    }
+
+    return (before.bend > 0) !== (after.bend > 0);
+}

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

@@ -40,6 +40,21 @@
  * leather is at the ceiling rather than above it. `cloth_dynamics_map.js`
  * carries both derivations.
  *
+ * ## Which entries collide with themselves, and why the list moved
+ *
+ * §9 said the flag belongs on "skirts, long coats, hair" — a list of what the
+ * garment *is*. **M4 measured that what decides is `bend`.** On a folding sheet
+ * at each entry's own bending: silk, hair and cotton pass through themselves 8
+ * to 11 times a sample unaided and the row removes 71% to 81% of it; denim
+ * tangles a third as much; leather does not tangle at all — 0.18 crossings a
+ * sample — and the row makes it marginally worse, because the handful of pairs
+ * it finds on a fabric that will not fold are noise it is adding.
+ *
+ * So `CLOTH_SILK`, `CLOTH_COTTON` and `CLOTH_HAIR` set it and nothing else
+ * does. It costs each of them about a fifth of their frame and all three stay
+ * inside 2 ms. The chains have no surface to pass through and a coiling rope is
+ * a case that measurement does not cover. `MEASUREMENTS.md` §33.
+ *
  * `stretch` is also the weakest field in the set, and the entries say so by
  * which of them set `ClothDynamicsFlags.StrainLimit`. Measured on a 24-link
  * rope dropped through ninety degrees, the strain-limit row removes about a
@@ -64,6 +79,11 @@
  * and iterations, so it keeps both and pays for them everywhere else; at 2×4
  * the fabric row is inside 1.4% of strain unaided and the strain-limit row
  * would buy half a per cent of that for 15% of the frame.
+ *
+ * *Self-collision:* **on, and it is the third lever's worth.** 1.46 ms to
+ * 1.78 ms, +22%, still inside. Silk is the floppiest fabric in the set and a
+ * folding sheet of it passes through itself 8 times a sample without the row;
+ * with it, 2.4. `MEASUREMENTS.md` §33.
  * @type {Readonly<ClothDynamics>}
  */
 export const CLOTH_SILK: Readonly<ClothDynamics>;
@@ -73,6 +93,11 @@ export const CLOTH_SILK: Readonly<ClothDynamics>;
  *
  * *Budget:* **400 particles at 2×4 — 1.49 ms.** Fewer particles, and no
  * strain-limit row, for the same reason silk drops it.
+ *
+ * *Self-collision:* **on.** 1.51 ms to 1.82 ms, +21%, still inside. This is
+ * the entry every other one is a deviation from, and a default that passes
+ * through itself nine times a sample while it moves is a bad default.
+ * `MEASUREMENTS.md` §33.
  * @type {Readonly<ClothDynamics>}
  */
 export const CLOTH_COTTON: Readonly<ClothDynamics>;
@@ -132,9 +157,13 @@ export const CLOTH_CHAIN: Readonly<ClothDynamics>;
  * does.
  *
  * *Budget:* **400 particles across all strands at 2×4 — 1.49 ms**, the same
- * two levers silk takes. `ClothDynamicsFlags.SelfCollision` is a claim about
- * the fabric that M4 will have to re-price when it can honour it, and it is
- * the reason this entry has the least headroom in the library.
+ * two levers silk takes.
+ *
+ * *Self-collision:* **on, and M4 priced it.** 1.53 ms to 1.81 ms, +19%, still
+ * inside. This was the only entry that set the flag before there was anything
+ * to honour it, and the measurement agrees with the claim: hair passes through
+ * itself 10.6 times a sample unaided, the most of any entry, and the row
+ * removes 81% of that. `MEASUREMENTS.md` §33.
  * @type {Readonly<ClothDynamics>}
  */
 export const CLOTH_HAIR: Readonly<ClothDynamics>;

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_dynamics_library.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_dynamics_library.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;;;GAUG;AACH,yBAFU,SAAS,aAAa,CAAC,CAa7B;AAEJ;;;;;;;GAOG;AACH,2BAFU,SAAS,aAAa,CAAC,CAa7B;AAEJ;;;;;;;;;;;GAWG;AACH,0BAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;GAQG;AACH,4BAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;;;;;GAYG;AACH,yBAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;;;GAUG;AACH,0BAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;;;;GAWG;AACH,yBAFU,SAAS,aAAa,CAAC,CAa7B;AAEJ;;;;;GAKG;AACH,qCAFU,cAAc,SAAS,aAAa,CAAC,CAAC,CAU7C;AAEH;;;;GAIG;AACH,qCAFU;QAAgB,MAAM,GAAE,SAAS,aAAa,CAAC;EAAE,CAUxD;8BA7P2B,oBAAoB"}
+{"version":3,"file":"cloth_dynamics_library.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_dynamics_library.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,yBAFU,SAAS,aAAa,CAAC,CAa7B;AAEJ;;;;;;;;;;;;GAYG;AACH,2BAFU,SAAS,aAAa,CAAC,CAa7B;AAEJ;;;;;;;;;;;GAWG;AACH,0BAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;GAQG;AACH,4BAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;;;;;GAYG;AACH,yBAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;;;GAUG;AACH,0BAFU,SAAS,aAAa,CAAC,CAY7B;AAEJ;;;;;;;;;;;;;;;GAeG;AACH,yBAFU,SAAS,aAAa,CAAC,CAa7B;AAEJ;;;;;GAKG;AACH,qCAFU,cAAc,SAAS,aAAa,CAAC,CAAC,CAU7C;AAEH;;;;GAIG;AACH,qCAFU;QAAgB,MAAM,GAAE,SAAS,aAAa,CAAC;EAAE,CAUxD;8BA1R2B,oBAAoB"}