@woosh/meep-engine 3.21.0 → 3.23.0

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

@@ -0,0 +1,288 @@
+import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { quat3_nlerp } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
+import { quat3_shortest_arc } from "../../../../core/geom/3d/quaternion/quat3_shortest_arc.js";
+
+/**
+ * # From particles to a pose — the half of the write-back that is arithmetic
+ *
+ * A particle has a position and no orientation, so a node's rotation has to be
+ * reconstructed. This module does that, in the cloth's own frame, into
+ * {@link ClothInstance#blended_position} and
+ * {@link ClothInstance#blended_rotation} — and then stops. What is done with the
+ * result is the *writer's* business, and there are two of them: the entity path
+ * writes a `Transform64` and a `TransformAttachment`, the rig path writes a
+ * `Node3D`.
+ *
+ * M3 split it out for exactly that reason. §11 claims "the solver is identical
+ * either way; only seeding and write-back differ", and a second copy of the
+ * swing reconstruction would have made that claim true of the solver and false
+ * of everything above it.
+ *
+ * ## Rotation is a swing on top of the animated orientation
+ *
+ *     q_node = swing(d_animated → d_simulated) ⊗ q_animated
+ *
+ * Twist about the link is inherited from the animation rather than invented,
+ * which is right: a chain of particles carries no twist degree of freedom and
+ * any twist this code produced would be a fabrication. And it degenerates
+ * correctly — at `blend = 0` the simulated direction *is* the animated one, the
+ * swing is the identity, and the reconstruction reproduces the authored pose
+ * exactly.
+ *
+ * A node with a parent and children has two links and two swings, and takes the
+ * half-way rotation between them. A leaf has only its parent's. Without that,
+ * every link points at its child and a two-link chain reads as a hinge with a
+ * corner in it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Scratch for one node's swing quaternions. Module-level: the reconstruction
+ * allocates nothing.
+ * @type {Float64Array}
+ * @private
+ */
+const SWING = new Float64Array(12);
+
+/** Where the parent-driven swing sits in {@link SWING}. @private */
+const SWING_PARENT = 0;
+/** Where the child-driven swing sits in {@link SWING}. @private */
+const SWING_CHILD = 4;
+/** Where the blended swing sits. @private */
+const SWING_OUT = 8;
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const DIRECTION = new Float64Array(12);
+
+/**
+ * Fill `blended_position` and `blended_rotation` from the solved particles.
+ *
+ * Both are in the **cloth's own frame**: the position is the particle lerped
+ * towards its animated one by `Cloth#blend`, and the rotation is the swing
+ * composed onto the animated orientation. Node 0 — the anchor — is the origin of
+ * that frame, so its rotation is the identity rather than anything read off it.
+ *
+ * @param {ClothInstance} instance
+ * @returns {void}
+ */
+export function cloth_reconstruct_pose(instance) {
+    const node_count = instance.node_count;
+
+    const state = instance.state;
+    const particle_of_node = instance.particle_of_node;
+
+    const blended = instance.blended_position;
+    const animated = instance.animated_position;
+
+    let blend = instance.cloth.blend;
+
+    if (blend < 0) {
+        blend = 0;
+    } else if (blend > 1) {
+        blend = 1;
+    }
+
+    const position = state.position;
+
+    for (let node = 0; node < node_count; node++) {
+        const p = particle_of_node[node] * 3;
+        const n = node * 3;
+
+        blended[n] = animated[n] + blend * (position[p] - animated[n]);
+        blended[n + 1] = animated[n + 1] + blend * (position[p + 1] - animated[n + 1]);
+        blended[n + 2] = animated[n + 2] + blend * (position[p + 2] - animated[n + 2]);
+    }
+
+    const parent = instance.node_parent;
+    const rotation = instance.animated_rotation;
+
+    const reconstructed = instance.blended_rotation;
+
+    reconstructed[0] = 0;
+    reconstructed[1] = 0;
+    reconstructed[2] = 0;
+    reconstructed[3] = 1;
+
+    for (let node = 1; node < node_count; node++) {
+        const has_parent_swing = link_swing(instance, parent[node], node, SWING_PARENT);
+        const has_child_swing = children_swing(instance, node, SWING_CHILD);
+
+        let swing = SWING_OUT;
+
+        if (has_parent_swing && has_child_swing) {
+            quat3_nlerp(
+                SWING, SWING_OUT,
+                SWING[SWING_PARENT], SWING[SWING_PARENT + 1], SWING[SWING_PARENT + 2], SWING[SWING_PARENT + 3],
+                SWING[SWING_CHILD], SWING[SWING_CHILD + 1], SWING[SWING_CHILD + 2], SWING[SWING_CHILD + 3],
+                0.5
+            );
+        } else if (has_child_swing) {
+            swing = SWING_CHILD;
+        } else {
+            // A leaf, or a link so short its direction is meaningless — in
+            // which case `link_swing` left the identity there.
+            swing = SWING_PARENT;
+        }
+
+        // Animated orientation first, then the swing: the swing is expressed in
+        // the cloth's local frame.
+        quat3_multiply(
+            reconstructed, node * 4,
+            SWING[swing], SWING[swing + 1], SWING[swing + 2], SWING[swing + 3],
+            rotation[node * 4], rotation[node * 4 + 1], rotation[node * 4 + 2], rotation[node * 4 + 3]
+        );
+    }
+}
+
+/**
+ * Swing of the link from `from` to `to`, into `SWING` at `out`.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} from node
+ * @param {number} to node
+ * @param {number} out
+ * @returns {boolean} false when the link is too short to carry a direction, in
+ *   which case the identity was written
+ * @private
+ */
+function link_swing(instance, from, to, out) {
+    const animated = instance.animated_position;
+    const blended = instance.blended_position;
+
+    const a = from * 3;
+    const b = to * 3;
+
+    const has_animated = unit(DIRECTION, 0,
+        animated[b] - animated[a], animated[b + 1] - animated[a + 1], animated[b + 2] - animated[a + 2]);
+
+    const has_blended = unit(DIRECTION, 3,
+        blended[b] - blended[a], blended[b + 1] - blended[a + 1], blended[b + 2] - blended[a + 2]);
+
+    if (!has_animated || !has_blended) {
+        identity(out);
+
+        return false;
+    }
+
+    quat3_shortest_arc(
+        SWING, out,
+        DIRECTION[0], DIRECTION[1], DIRECTION[2],
+        DIRECTION[3], DIRECTION[4], DIRECTION[5]
+    );
+
+    return true;
+}
+
+/**
+ * Swing of a node's outgoing links, averaged over its simulated children.
+ *
+ * The average is over **unit** directions rather than over child positions, so
+ * a fork whose two branches are of different lengths is not dominated by the
+ * longer one.
+ *
+ * @param {ClothInstance} instance
+ * @param {number} node
+ * @param {number} out
+ * @returns {boolean}
+ * @private
+ */
+function children_swing(instance, node, out) {
+    const start = instance.node_child_offset[node];
+    const end = instance.node_child_offset[node + 1];
+
+    if (start === end) {
+        identity(out);
+
+        return false;
+    }
+
+    const animated = instance.animated_position;
+    const blended = instance.blended_position;
+    const child = instance.node_child;
+
+    const a = node * 3;
+
+    let anim_x = 0, anim_y = 0, anim_z = 0;
+    let sim_x = 0, sim_y = 0, sim_z = 0;
+
+    for (let i = start; i < end; i++) {
+        const b = child[i] * 3;
+
+        if (unit(DIRECTION, 6,
+            animated[b] - animated[a], animated[b + 1] - animated[a + 1], animated[b + 2] - animated[a + 2])) {
+            anim_x += DIRECTION[6];
+            anim_y += DIRECTION[7];
+            anim_z += DIRECTION[8];
+        }
+
+        if (unit(DIRECTION, 9,
+            blended[b] - blended[a], blended[b + 1] - blended[a + 1], blended[b + 2] - blended[a + 2])) {
+            sim_x += DIRECTION[9];
+            sim_y += DIRECTION[10];
+            sim_z += DIRECTION[11];
+        }
+    }
+
+    const has_animated = unit(DIRECTION, 0, anim_x, anim_y, anim_z);
+    const has_blended = unit(DIRECTION, 3, sim_x, sim_y, sim_z);
+
+    if (!has_animated || !has_blended) {
+        // Branches that cancel — a node with two children pointing opposite
+        // ways has no outgoing direction to speak of, and the parent link is a
+        // better answer than an arbitrary one.
+        identity(out);
+
+        return false;
+    }
+
+    quat3_shortest_arc(
+        SWING, out,
+        DIRECTION[0], DIRECTION[1], DIRECTION[2],
+        DIRECTION[3], DIRECTION[4], DIRECTION[5]
+    );
+
+    return true;
+}
+
+/**
+ * Normalise into `out`, reporting whether there was a direction to find.
+ *
+ * @param {Float64Array} out
+ * @param {number} offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {boolean}
+ * @private
+ */
+function unit(out, offset, x, y, z) {
+    const length_squared = x * x + y * y + z * z;
+
+    if (length_squared < 1e-24) {
+        return false;
+    }
+
+    const inverse = 1 / Math.sqrt(length_squared);
+
+    out[offset] = x * inverse;
+    out[offset + 1] = y * inverse;
+    out[offset + 2] = z * inverse;
+
+    return true;
+}
+
+/**
+ * @param {number} offset
+ * @private
+ */
+function identity(offset) {
+    SWING[offset] = 0;
+    SWING[offset + 1] = 0;
+    SWING[offset + 2] = 0;
+    SWING[offset + 3] = 1;
+}

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

@@ -0,0 +1,58 @@
+/**
+ * # Seeding a cloth from a skinned model's joints — §11.2
+ *
+ * One particle per joint the proxy names, with the anchor as the fixed set, and
+ * everything after that is `cloth_build_rows.js` — the same rows, the same
+ * geodesics, the same leashes the entity path gets. §11 says "the solver is
+ * identical either way; only seeding and write-back differ", and this file plus
+ * `cloth_write_back_rig.js` is the whole of the difference.
+ *
+ * ## Cloth takes authority, and that is a real claim
+ *
+ * §11.2 says the writable handle is "the joint's `Node3D.transform_local` — the
+ * same handle the animation systems write". **The animation systems do not
+ * write it.** `TransformAuthority` is explicit: a node a clip drives is
+ * `GPU`, and "the CPU allocates and seeds the row, then never writes to it
+ * again, so the node's own `transform_local` stops describing it and should not
+ * be read as if it did". Cloth writing `transform_local` on such a node would
+ * be writing to something nothing reads.
+ *
+ * So the seed **claims** `TransformAuthority.CPU` on every joint it drives. The
+ * consequence is stated rather than hidden: a joint cloth simulates stops being
+ * animatable by a clip, because two writers of one row is the race the authority
+ * enum exists to prevent. That is the right trade for a cape — the whole point
+ * of simulating it is that nobody keyframes it — and it is an authoring error
+ * for a garment whose joints are also keyed, which is why the seed says so.
+ *
+ * ## The animated pose is constant, exactly as it is for a rope
+ *
+ * §11.1 says a subtree's authored pose is rigid relative to its anchor, so in
+ * the anchor's own frame it does not move, and then says "a subtree whose links
+ * are themselves animated is not an M1 case — that is the rig path, where the
+ * animated pose comes from the skeleton and is live".
+ *
+ * For a **rigged** garment it is not live either, and the reason is the
+ * authority claim above: cloth owns those joints, so nothing else poses them,
+ * so their authored pose is the proxy's baked bind pose — constant in the
+ * anchor's frame, exactly as a rope's is. What moves is the anchor, and the
+ * anchor is a joint of the character's own animated skeleton.
+ *
+ * The live case is the **unrigged** path, where the animated targets are mesh
+ * vertices skinned to the character's skeleton by
+ * `mesh_apply_skeletal_vertex_skinning` and genuinely move under the animation.
+ * That path is not in M3.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Seed `instance` from a proxy and the joints of a skin.
+ *
+ * @param {ClothInstance} instance seeded in place
+ * @param {ClothProxy} proxy
+ * @param {Node3D[]} joints the skin's joints, in the order the proxy indexes
+ * @param {number} dt fixed step, seconds
+ * @returns {void}
+ */
+export function cloth_seed_rig(instance: ClothInstance, proxy: ClothProxy, joints: Node3D[], dt: number): void;
+//# sourceMappingURL=cloth_seed_rig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_seed_rig.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_seed_rig.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;GAQG;AACH,mFAJW,QAAQ,MACR,MAAM,GACJ,IAAI,CA6DhB"}

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

@@ -0,0 +1,199 @@
+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 { TransformAuthority } from "../../../../shade/renderer/scene/TransformAuthority.js";
+import { cloth_build_children, cloth_build_rows } from "./cloth_build_rows.js";
+
+/**
+ * # Seeding a cloth from a skinned model's joints — §11.2
+ *
+ * One particle per joint the proxy names, with the anchor as the fixed set, and
+ * everything after that is `cloth_build_rows.js` — the same rows, the same
+ * geodesics, the same leashes the entity path gets. §11 says "the solver is
+ * identical either way; only seeding and write-back differ", and this file plus
+ * `cloth_write_back_rig.js` is the whole of the difference.
+ *
+ * ## Cloth takes authority, and that is a real claim
+ *
+ * §11.2 says the writable handle is "the joint's `Node3D.transform_local` — the
+ * same handle the animation systems write". **The animation systems do not
+ * write it.** `TransformAuthority` is explicit: a node a clip drives is
+ * `GPU`, and "the CPU allocates and seeds the row, then never writes to it
+ * again, so the node's own `transform_local` stops describing it and should not
+ * be read as if it did". Cloth writing `transform_local` on such a node would
+ * be writing to something nothing reads.
+ *
+ * So the seed **claims** `TransformAuthority.CPU` on every joint it drives. The
+ * consequence is stated rather than hidden: a joint cloth simulates stops being
+ * animatable by a clip, because two writers of one row is the race the authority
+ * enum exists to prevent. That is the right trade for a cape — the whole point
+ * of simulating it is that nobody keyframes it — and it is an authoring error
+ * for a garment whose joints are also keyed, which is why the seed says so.
+ *
+ * ## The animated pose is constant, exactly as it is for a rope
+ *
+ * §11.1 says a subtree's authored pose is rigid relative to its anchor, so in
+ * the anchor's own frame it does not move, and then says "a subtree whose links
+ * are themselves animated is not an M1 case — that is the rig path, where the
+ * animated pose comes from the skeleton and is live".
+ *
+ * For a **rigged** garment it is not live either, and the reason is the
+ * authority claim above: cloth owns those joints, so nothing else poses them,
+ * so their authored pose is the proxy's baked bind pose — constant in the
+ * anchor's frame, exactly as a rope's is. What moves is the anchor, and the
+ * anchor is a joint of the character's own animated skeleton.
+ *
+ * The live case is the **unrigged** path, where the animated targets are mesh
+ * vertices skinned to the character's skeleton by
+ * `mesh_apply_skeletal_vertex_skinning` and genuinely move under the animation.
+ * That path is not in M3.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Seed `instance` from a proxy and the joints of a skin.
+ *
+ * @param {ClothInstance} instance seeded in place
+ * @param {ClothProxy} proxy
+ * @param {Node3D[]} joints the skin's joints, in the order the proxy indexes
+ * @param {number} dt fixed step, seconds
+ * @returns {void}
+ */
+export function cloth_seed_rig(instance, proxy, joints, dt) {
+    assert.ok(proxy.isClothProxy === true, 'proxy must be a ClothProxy');
+
+    const joint_count = proxy.joint_count;
+
+    // Node 0 is the anchor, exactly as it is for the entity path: the fixed
+    // set, the origin of the local frame, and `d_geo = 0`.
+    const node_count = joint_count + 1;
+
+    instance.node_count = node_count;
+
+    const node_parent = new Int32Array(node_count);
+
+    node_parent[0] = -1;
+
+    for (let i = 0; i < joint_count; i++) {
+        node_parent[i + 1] = proxy.joint_parent[i] + 1;
+    }
+
+    instance.node_parent = node_parent;
+
+    const node_joint = new Array(node_count);
+
+    node_joint[0] = joints[proxy.anchor];
+
+    for (let i = 0; i < joint_count; i++) {
+        const node = joints[proxy.joint[i]];
+
+        assert.defined(node, `joint ${proxy.joint[i]} of the skin`);
+
+        node_joint[i + 1] = node;
+
+        // See the module docblock. A clip-driven joint reads as GPU here, and
+        // taking it is what makes the write-back visible at all.
+        node.transform_authority = TransformAuthority.CPU;
+    }
+
+    instance.node_joint = node_joint;
+
+    // The entity path's arrays have no meaning here and holding stale ones is
+    // how a write-back reaches into a previous seeding's entities.
+    instance.node_entity = null;
+    instance.node_transform = [];
+    instance.node_attachment = [];
+    instance.pruned_count = 0;
+    instance.pruned_entity = null;
+    instance.pruned_parent = null;
+    instance.pruned_transform = [];
+    instance.pruned_attachment = [];
+
+    cloth_build_children(instance);
+
+    read_bind_pose(instance, proxy);
+
+    instance.dynamics_seen.copy(instance.cloth.dynamics);
+
+    cloth_build_rows(instance, dt);
+
+    instance.seeded = true;
+}
+
+/**
+ * Compose the proxy's baked bind pose into the anchor's frame.
+ *
+ * The proxy's parents come before its children, so one forward pass is the whole
+ * hierarchy — the same property `cloth_seed_subtree` gets from a breadth-first
+ * walk and relies on for the same reason.
+ *
+ * @param {ClothInstance} instance
+ * @param {ClothProxy} proxy
+ * @private
+ */
+function read_bind_pose(instance, proxy) {
+    const node_count = instance.node_count;
+
+    const local_position = new Float32Array(node_count * 3);
+    const local_rotation = new Float32Array(node_count * 4);
+
+    const position = new Float32Array(node_count * 3);
+    const rotation = new Float32Array(node_count * 4);
+
+    // The anchor is the origin of the frame it anchors.
+    local_rotation[3] = 1;
+    rotation[3] = 1;
+
+    const parent = instance.node_parent;
+
+    for (let node = 1; node < node_count; node++) {
+        const joint = node - 1;
+
+        local_position[node * 3] = proxy.rest_position[joint * 3];
+        local_position[node * 3 + 1] = proxy.rest_position[joint * 3 + 1];
+        local_position[node * 3 + 2] = proxy.rest_position[joint * 3 + 2];
+
+        local_rotation[node * 4] = proxy.rest_rotation[joint * 4];
+        local_rotation[node * 4 + 1] = proxy.rest_rotation[joint * 4 + 1];
+        local_rotation[node * 4 + 2] = proxy.rest_rotation[joint * 4 + 2];
+        local_rotation[node * 4 + 3] = proxy.rest_rotation[joint * 4 + 3];
+
+        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(
+            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]
+        );
+    }
+
+    instance.rest_local_position = local_position;
+    instance.rest_local_rotation = local_rotation;
+
+    instance.animated_position = position;
+    instance.animated_rotation = rotation;
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const COMPOSE = new Float64Array(3);

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

@@ -0,0 +1,59 @@
+/**
+ * # 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.
+ *
+ * ## What "bend rows along each chain" turned out to mean
+ *
+ * §11.1 asks for bend rows and the row model has one — the quadratic hinge of
+ * §6, four particles across the diamond either side of a shared edge. **A chain
+ * has no diamond.** `bt_edge_read_diamond` declines a wire edge for exactly
+ * that reason, and it is right to: the stencil is a discrete mean curvature over
+ * a surface and a rope is not one.
+ *
+ * The bending model here is instead a **skip row** — an ordinary stretch row
+ * between a node and its grandparent, at whatever distance the authored pose
+ * puts them. It is §6's own doctrine applied once more ("one row model,
+ * parameterised by mode"), it costs no new row kind, and it has the two
+ * properties §6 wanted from quadratic bending: there is no normal, no angle and
+ * no sign, so nothing degenerates at 0° or 180°, and a fold is high energy
+ * rather than a singular configuration. It also does something the quadratic
+ * stencil explicitly cannot (§18): because its rest length is read from the
+ * authored pose rather than assumed flat, **it holds a curved rest shape**.
+ *
+ * The row is soft, so its stiffness has to stay inside the dissipative band
+ * M0 measured; `cloth_dynamics_map.js` is where that is arranged and why.
+ *
+ * ## Mass is uniform, and the answer does not depend on it
+ *
+ * {@link ClothDynamics} carries no mass or density, and it does not need to.
+ * Every row scale in this system is a **ratio** of the row's own `m/h²` — the
+ * hard rows through the penalty band (`MEASUREMENTS.md` §4 held a chain at a
+ * fixed ratio across five decades of particle mass and got the same residual
+ * column every time), the soft ones through `cloth_bend_ratio` — and gravity is
+ * an acceleration. So the constant below is arbitrary in the strict sense that
+ * changing it changes no trajectory, and what matters about it is only that it
+ * is the same for every particle.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Walk the subtree and build everything {@link ClothSystem} needs to step it.
+ *
+ * @param {ClothInstance} instance seeded in place
+ * @param {EntityComponentDataset} ecd
+ * @param {TransformAttachmentSystem} attachments
+ * @param {number} dt fixed step, seconds — the bend row's scale is a ratio of
+ *   `m/dt²`, so the step length is part of the rest data
+ * @returns {void}
+ */
+export function cloth_seed_subtree(instance: ClothInstance, ecd: EntityComponentDataset, attachments: TransformAttachmentSystem, dt: number): void;
+import { ClothInstance } from "./ClothInstance.js";
+//# sourceMappingURL=cloth_seed_subtree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_seed_subtree.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_seed_subtree.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;;;;;GASG;AACH,6CAPW,aAAa,2EAGb,MAAM,GAEJ,IAAI,CAkGhB;8BA5J6B,oBAAoB"}