@woosh/meep-engine 3.43.0 → 3.44.0

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

@@ -2,6 +2,8 @@ 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";
+import { cloth_edge_incidence } from "./cloth_geodesic.js";
+import { cloth_bend_stencil_weights } from "../solver/constraint/cloth_bend_row.js";
 
 /**
  * # The rows, and everything that is a number rather than a walk
@@ -12,12 +14,19 @@ import { cloth_bend_ratio, cloth_strain_allowance } from "./cloth_dynamics_map.j
  * 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.
+ * So the split is: a seeder produces the particles' rest pose and the **graph**
+ * joining them — {@link ClothInstance#edge}, {@link ClothInstance#skip},
+ * {@link ClothInstance#hinge} — and {@link cloth_build_rows} turns those into
+ * geodesics, fabric rows, strain-limit rows, bending 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.
+ *
+ * The rows are built from a graph rather than from a parent array because a row
+ * is a pair or a quad and has no use for a parent. A tree hands over its parent
+ * links and its skip pairs ({@link cloth_tree_graph}); a mesh would hand over
+ * its edges and hinges; the rows below are the same code either way.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -36,9 +45,10 @@ 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
+ * already holds every particle within `d_geo` of the held particle it hangs
+ * from, and the animated position it is leashed to is itself within `d_geo` of
+ * that particle — a chord is never longer than the arc it subtends, and the
+ * animated pose is the rest pose hung from it (`ClothInstance#animated_position`). 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.
@@ -64,30 +74,189 @@ export function cloth_build_children(instance) {
 
     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++) {
+        if (parent[node] >= 0) {
+            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 child = new Int32Array(offset[node_count]);
     const cursor = offset.slice(0, node_count);
 
-    for (let node = 1; node < node_count; node++) {
-        child[cursor[parent[node]]++] = node;
+    for (let node = 0; node < node_count; node++) {
+        if (parent[node] >= 0) {
+            child[cursor[parent[node]]++] = node;
+        }
     }
 
     instance.node_child_offset = offset;
     instance.node_child = child;
 }
 
+/**
+ * The particle graph of a tree: a fabric edge from every node to its parent,
+ * and a skip pair from every node to its grandparent.
+ *
+ * The skip pair is a chain's bending model (`cloth_seed_subtree.js` carries the
+ * argument), and it is part of the graph rather than something the row builder
+ * derives from a parent array, so that the row builder never needs one.
+ *
+ * @param {ClothInstance} instance with {@link ClothInstance#node_parent} set
+ * @returns {void}
+ */
+export function cloth_tree_graph(instance) {
+    const node_count = instance.node_count;
+    const parent = instance.node_parent;
+
+    const edge = [];
+    const skip = [];
+
+    for (let node = 0; node < node_count; node++) {
+        const p = parent[node];
+
+        if (p < 0) {
+            continue;
+        }
+
+        edge.push(p, node);
+
+        const grandparent = parent[p];
+
+        if (grandparent >= 0) {
+            skip.push(grandparent, node);
+        }
+    }
+
+    instance.edge = Int32Array.from(edge);
+    instance.skip = Int32Array.from(skip);
+    instance.hinge = new Int32Array(0);
+    instance.triangle = new Int32Array(0);
+}
+
+/**
+ * The triangles around each node, CSR, and one neighbour per node to measure a
+ * tangent by — what `cloth_reconstruct_pose` turns a sheet's joints with. A
+ * cloth with no triangles gets none.
+ *
+ * @param {ClothInstance} instance with {@link ClothInstance#triangle} and
+ *   {@link ClothInstance#edge} set
+ * @returns {void}
+ */
+export function cloth_build_surface(instance) {
+    const node_count = instance.node_count;
+    const triangle = instance.triangle;
+
+    const triangle_count = triangle.length / 3;
+
+    if (triangle_count === 0) {
+        instance.surface_offset = null;
+        instance.surface_triangle = null;
+        instance.surface_neighbour = null;
+
+        return;
+    }
+
+    const offset = new Int32Array(node_count + 1);
+
+    for (let i = 0; i < triangle_count * 3; i++) {
+        offset[triangle[i] + 1]++;
+    }
+
+    for (let node = 0; node < node_count; node++) {
+        offset[node + 1] += offset[node];
+    }
+
+    const surface = new Int32Array(triangle_count * 3);
+    const cursor = offset.slice(0, node_count);
+
+    for (let t = 0; t < triangle_count; t++) {
+        for (let k = 0; k < 3; k++) {
+            const node = triangle[t * 3 + k];
+
+            surface[cursor[node]++] = t;
+        }
+    }
+
+    // the first edge each node has: fixed for the life of the seed, which is all
+    // a reference direction has to be
+    const neighbour = new Int32Array(node_count).fill(-1);
+
+    const edge = instance.edge;
+
+    for (let e = 0; e < edge.length; e += 2) {
+        const a = edge[e];
+        const b = edge[e + 1];
+
+        if (neighbour[a] === -1) {
+            neighbour[a] = b;
+        }
 
+        if (neighbour[b] === -1) {
+            neighbour[b] = a;
+        }
+    }
+
+    instance.surface_offset = offset;
+    instance.surface_triangle = surface;
+    instance.surface_neighbour = neighbour;
+}
 
 /**
- * Rows, geodesics and the `ClothState` itself, from a seeded
- * `node_parent` / `animated_position` pair.
+ * How much a hinge resists, as a stiffness, for a fabric's `bend` ratio.
+ *
+ * The same rule the skip row follows: a ratio of the row's own effective
+ * inertia over the fixed step squared. A hinge's gradient on particle `k` is
+ * `w_k` along each axis, so its effective inertia is `1 / Σ (w_k² / m_k)` —
+ * `m / Σ w_k²` with one mass — and a hinge across a sliver, whose cotangents are
+ * large, is softer per unit `C` for exactly the reason its `C` is larger. A
+ * stiffness in newtons per metre, which is what Bergou's `6·modulus/A` is,
+ * would leave M0's dissipative band wherever the triangles are thin.
+ *
+ * @param {Float32Array} weight 4 per hinge
+ * @param {number} hinge
+ * @returns {number} the hinge's effective inertia, kg
+ */
+export function cloth_hinge_inertia(weight, hinge) {
+    let sum = 0;
+
+    for (let k = 0; k < 4; k++) {
+        const w = weight[hinge * 4 + k];
+
+        sum += w * w;
+    }
+
+    return sum > 0 ? CLOTH_PARTICLE_MASS / sum : 0;
+}
+
+/**
+ * Distance between two nodes of the rest pose.
+ * @param {Float32Array} rest
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ * @private
+ */
+function rest_distance(rest, a, b) {
+    return Math.hypot(
+        rest[b * 3] - rest[a * 3],
+        rest[b * 3 + 1] - rest[a * 3 + 1],
+        rest[b * 3 + 2] - rest[a * 3 + 2]
+    );
+}
+
+/**
+ * Rows and the `ClothState` itself, from a seeded rest pose and the graph over
+ * it.
+ *
+ * **Nothing is held here.** Every particle is built free, with a tether row and
+ * — when the fabric is leashed at all — a slack row of radius `Infinity`, which
+ * say nothing until `cloth_apply_holds` points them at what the particle hangs
+ * from. The shape of the leash table is fixed by the particle count, so holding
+ * and letting go rewrite numbers in it rather than building it again.
  *
  * @param {ClothInstance} instance
  * @param {number} dt
@@ -96,22 +265,22 @@ export function cloth_build_children(instance) {
 export function cloth_build_rows(instance, dt) {
     const node_count = instance.node_count;
 
-    const parent = instance.node_parent;
-    const rest = instance.animated_position;
+    const rest = instance.rest_position;
 
-    const dynamics = instance.cloth.dynamics;
+    const edge = instance.edge;
+    const skip = instance.skip;
+    const hinge = instance.hinge;
 
-    const strain_limited = (dynamics.flags & ClothDynamicsFlags.StrainLimit) !== 0;
+    const edge_count = edge.length >> 1;
+    const skip_count = skip.length >> 1;
+    const hinge_count = hinge.length >> 2;
 
-    const geodesic = new Float32Array(node_count);
+    const dynamics = instance.cloth.dynamics;
 
-    const mass_inverse = new Float32Array(node_count);
+    const strain_limited = (dynamics.flags & ClothDynamicsFlags.StrainLimit) !== 0;
 
-    // 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;
-    }
+    // Free, every one: what is held is the holds' business.
+    const mass_inverse = new Float32Array(node_count).fill(1 / CLOTH_PARTICLE_MASS);
 
     const stretch_particle = [];
     const stretch_rest = [];
@@ -119,47 +288,35 @@ export function cloth_build_rows(instance, dt) {
     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);
+    const edge_length = new Float64Array(edge_count);
 
-    let reach = 0;
+    const edge_row = new Int32Array(edge_count).fill(-1);
+    const strain_row = new Int32Array(edge_count).fill(-1);
+    const skip_row = new Int32Array(skip_count).fill(-1);
 
-    for (let node = 1; node < node_count; node++) {
-        const p = parent[node];
+    const strain = cloth_strain_allowance(dynamics.stretch);
 
-        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]
-        );
+    for (let e = 0; e < edge_count; e++) {
+        const a = edge[e * 2];
+        const b = edge[e * 2 + 1];
 
-        geodesic[node] = geodesic[p] + length;
+        const length = rest_distance(rest, a, b);
 
-        if (geodesic[node] > reach) {
-            reach = geodesic[node];
-        }
+        edge_length[e] = length;
 
-        link_row[node] = stretch_rest.length;
+        edge_row[e] = 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_particle.push(a, b);
         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;
+            strain_row[e] = 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
@@ -167,56 +324,89 @@ export function cloth_build_rows(instance, dt) {
             // `[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_particle.push(a, b);
             stretch_rest.push(length * (1 + strain));
             stretch_stiffness.push(Infinity);
             stretch_force_min.push(0);
             stretch_force_max.push(Infinity);
         }
+    }
 
-        const grandparent = parent[p];
+    // 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);
 
-        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]
-            );
+    if (bend_stiffness > 0) {
+        for (let s = 0; s < skip_count; s++) {
+            const a = skip[s * 2];
+            const b = skip[s * 2 + 1];
 
-            skip_row[node] = stretch_rest.length;
+            skip_row[s] = 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_particle.push(a, b);
+            stretch_rest.push(rest_distance(rest, a, b));
             stretch_stiffness.push(bend_stiffness);
             stretch_force_min.push(-Infinity);
             stretch_force_max.push(Infinity);
         }
     }
 
+    // A surface bends through its hinges: §6's quadratic stencil, its weights
+    // read from the rest pose, its stiffness a ratio of its own inertia.
+    const bend_ratio = cloth_bend_ratio(dynamics.bend);
+
+    const hinge_built = bend_ratio > 0 ? hinge_count : 0;
+
+    const bend_weight = new Float32Array(hinge_built * 4);
+    const hinge_stiffness = new Float32Array(hinge_built);
+    const hinge_inertia = new Float32Array(hinge_built);
+
+    for (let h = 0; h < hinge_built; h++) {
+        cloth_bend_stencil_weights(
+            bend_weight, h * 4, rest,
+            hinge[h * 4], hinge[h * 4 + 1], hinge[h * 4 + 2], hinge[h * 4 + 3]
+        );
+
+        hinge_inertia[h] = cloth_hinge_inertia(bend_weight, h);
+        hinge_stiffness[h] = bend_ratio * hinge_inertia[h] / (dt * dt);
+    }
+
     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);
+    const leashed = clamp01(dynamics.slack) < 1;
 
-    for (let node = 1; node < node_count; node++) {
+    for (let node = 0; 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]);
+        leash_radius.push(Infinity);
 
-        if (slack_scale < CLOTH_SLACK_REACH) {
+        if (leashed) {
             slack_row[node] = leash_radius.length;
 
             leash_particle.push(node);
-            leash_radius.push(slack_scale * geodesic[node]);
+            leash_radius.push(Infinity);
+        }
+    }
+
+    // Until the holds say otherwise, everything hangs from the frame.
+    let reach = 0;
+
+    for (let node = 0; node < node_count; node++) {
+        const r = Math.hypot(rest[node * 3], rest[node * 3 + 1], rest[node * 3 + 2]);
+
+        if (r > reach) {
+            reach = r;
         }
     }
 
@@ -232,9 +422,13 @@ export function cloth_build_rows(instance, dt) {
     // 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.geodesic = new Float32Array(node_count).fill(Infinity);
+    instance.tether_source = new Int32Array(node_count).fill(-1);
+    instance.edge_length = edge_length;
+    instance.edge_incidence = cloth_edge_incidence(node_count, edge);
+    instance.hinge_inertia = hinge_inertia;
     instance.reach = reach;
-    instance.link_row = link_row;
+    instance.edge_row = edge_row;
     instance.strain_row = strain_row;
     instance.skip_row = skip_row;
     instance.slack_row = slack_row;
@@ -248,6 +442,9 @@ export function cloth_build_rows(instance, dt) {
         stretch_stiffness: Float32Array.from(stretch_stiffness),
         stretch_force_min: Float32Array.from(stretch_force_min),
         stretch_force_max: Float32Array.from(stretch_force_max),
+        bend_particle: hinge.subarray(0, hinge_built * 4),
+        bend_weight,
+        bend_stiffness: hinge_stiffness,
         leash_particle: Int32Array.from(leash_particle),
         leash_radius: Float32Array.from(leash_radius),
         shared: instance.shared_state
@@ -278,6 +475,17 @@ export function cloth_build_rows(instance, dt) {
     instance.particle_of_node = particle_of_node;
     instance.blended_position = new Float64Array(node_count * 3);
     instance.blended_rotation = new Float64Array(node_count * 4);
+
+    instance.node_hold = new Int32Array(node_count).fill(-1);
+    instance.tether_loose = new Uint8Array(node_count);
+    instance.tether_loose_count = 0;
+    instance.node_hold_slot = new Int32Array(node_count).fill(-1);
+    instance.held_target = new Float64Array(node_count * 3);
+
+    // Nothing held yet, so the animated pose is the rest pose.
+    instance.animated_position = Float64Array.from(rest);
+    instance.animated_rotation = Float64Array.from(instance.rest_rotation);
+
     instance.state = state;
     instance.seeded = true;
 }
@@ -313,32 +521,61 @@ export function cloth_reparameterise(instance, dt) {
 
     const state = instance.state;
 
-    const node_count = instance.node_count;
-
     const strain = cloth_strain_allowance(dynamics.stretch);
 
+    const edge_row = instance.edge_row;
+    const strain_row = instance.strain_row;
+
+    for (let e = 0; e < strain_row.length; e++) {
+        const strain_limit = strain_row[e];
+
+        if (strain_limit >= 0) {
+            state.stretch_rest[strain_limit] = state.stretch_rest[edge_row[e]] * (1 + strain);
+        }
+    }
+
     const bend_stiffness = cloth_bend_ratio(dynamics.bend)
         * (CLOTH_PARTICLE_MASS * 0.5) / (dt * dt);
 
+    const skip_row = instance.skip_row;
+
+    for (let s = 0; s < skip_row.length; s++) {
+        const row = skip_row[s];
+
+        if (row >= 0) {
+            state.stretch_stiffness[row] = bend_stiffness;
+        }
+    }
+
+    // A hinge is bend row `h`, in the order they were built.
+    const bend_ratio = cloth_bend_ratio(dynamics.bend);
+    const hinge_inertia = instance.hinge_inertia;
+
+    for (let h = 0; h < state.bend_count; h++) {
+        const stiffness = bend_ratio * hinge_inertia[h] / (dt * dt);
+
+        state.bend_stiffness[h] = stiffness;
+        state.bend_penalty[h] = stiffness;
+    }
+
     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 node_count = instance.node_count;
+
+    for (let node = 0; node < node_count; node++) {
         const slack = instance.slack_row[node];
 
-        if (strain_limit >= 0) {
-            state.stretch_rest[strain_limit] = state.stretch_rest[link] * (1 + strain);
+        if (slack < 0) {
+            continue;
         }
 
-        if (skip >= 0) {
-            state.stretch_stiffness[skip] = bend_stiffness;
-        }
+        const d = instance.geodesic[node];
 
-        if (slack >= 0) {
-            state.leash_radius[slack] = slack_scale * instance.geodesic[node];
-        }
+        // A free particle something holds; anything else has no bound to scale,
+        // and `0 · Infinity` would be a NaN where `Infinity` is meant.
+        state.leash_radius[slack] = d < Infinity && instance.node_hold[node] === -1
+            ? slack_scale * d
+            : Infinity;
     }
 
     instance.dynamics_seen.copy(dynamics);

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

@@ -195,9 +195,10 @@ export const CLOTH_VELOCITY_CORRECTION_MARGIN: number;
  */
 export const CLOTH_DAMPING_RATE: number;
 /**
- * How far a cloth's anchor may carry it in one fixed step, as a multiple of the
+ * How far a cloth's frame may carry it in one fixed step, as a multiple of the
  * cloth's own reach. Motion above this is felt as though it were exactly this,
- * which is what "anchor speed limit" means in §7 P7.
+ * which is what "anchor speed limit" means in §7 P7 — the frame being what the
+ * cloth rides.
  *
  * Expressing it as a fraction of reach rather than in metres per second is what
  * makes it work for a 3 cm pendant and a 30 m mooring line at the same time: a
@@ -208,9 +209,9 @@ export const CLOTH_DAMPING_RATE: number;
  * badly-keyed cut does exceed.
  * @type {number}
  */
-export const CLOTH_ANCHOR_TRAVEL_REACH: number;
+export const CLOTH_FRAME_TRAVEL_REACH: number;
 /**
- * How far a cloth's anchor may rotate in one fixed step, radians. Rotation
+ * How far a cloth's frame may rotate in one fixed step, radians. Rotation
  * above this is felt as though it were exactly this.
  *
  * Unlike the travel limit this has no length scale to hang off — an angle is
@@ -218,10 +219,11 @@ export const CLOTH_ANCHOR_TRAVEL_REACH: number;
  * about 1,700 degrees a second, which is a spin rather than a turn.
  * @type {number}
  */
-export const CLOTH_ANCHOR_ROTATION_LIMIT: number;
+export const CLOTH_FRAME_ROTATION_LIMIT: number;
 /**
- * Anchor displacement in one fixed step, as a multiple of the cloth's reach,
- * above which the motion is a **teleport** rather than locomotion (§7 P6).
+ * Displacement of the frame, or of a holder in the frame, in one fixed step, as
+ * a multiple of the cloth's reach, above which the motion is a **teleport**
+ * rather than locomotion (§7 P6).
  *
  * Four reaches in one step is 240 reaches a second: for a 1 m rope that is
  * 240 m/s, well past anything the world moves at and well short of the values a

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_dynamics_map.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_dynamics_map.js"],"names":[],"mappings":"AAmQA;;;;;;;;GAQG;AACH,gDAHW,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;GAQG;AACH,uCAHW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;GAWG;AACH,mDAPW,MAAM,YAEN,MAAM,cACN,MAAM,MACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0CAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;GAQG;AACH,kDAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAQlB;AA7WD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;GAKG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;;;;;;GAWG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;GAKG;AACH,mCAFU,MAAM,CAEyB;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,+CAFU,MAAM,CAEkC;AAElD;;;;;;;;GAQG;AACH,iCAFU,MAAM,CAEqB;AAErC;;;;;;;;;;;;;GAaG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;;;;GAQG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;;;;;GAQG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;;;;GAQG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH,sCAFU,MAAM,CAE4B;AAE5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6CAFU,MAAM,CAEmC;AAEnD;;;;;GAKG;AACH,gCAFU,MAAM,CAEoB"}
+{"version":3,"file":"cloth_dynamics_map.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_dynamics_map.js"],"names":[],"mappings":"AAqQA;;;;;;;;GAQG;AACH,gDAHW,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;GAQG;AACH,uCAHW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;GAWG;AACH,mDAPW,MAAM,YAEN,MAAM,cACN,MAAM,MACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0CAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;GAQG;AACH,kDAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAQlB;AA/WD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;GAKG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;;;;;;GAWG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;GAKG;AACH,mCAFU,MAAM,CAEyB;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,+CAFU,MAAM,CAEkC;AAElD;;;;;;;;GAQG;AACH,iCAFU,MAAM,CAEqB;AAErC;;;;;;;;;;;;;;GAcG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;;;GAQG;AACH,yCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;GASG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;;;;GAQG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH,sCAFU,MAAM,CAE4B;AAE5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6CAFU,MAAM,CAEmC;AAEnD;;;;;GAKG;AACH,gCAFU,MAAM,CAEoB"}

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

@@ -129,9 +129,10 @@ export const CLOTH_VELOCITY_CORRECTION_MARGIN = 4;
 export const CLOTH_DAMPING_RATE = 20;
 
 /**
- * How far a cloth's anchor may carry it in one fixed step, as a multiple of the
+ * How far a cloth's frame may carry it in one fixed step, as a multiple of the
  * cloth's own reach. Motion above this is felt as though it were exactly this,
- * which is what "anchor speed limit" means in §7 P7.
+ * which is what "anchor speed limit" means in §7 P7 — the frame being what the
+ * cloth rides.
  *
  * Expressing it as a fraction of reach rather than in metres per second is what
  * makes it work for a 3 cm pendant and a 30 m mooring line at the same time: a
@@ -142,10 +143,10 @@ export const CLOTH_DAMPING_RATE = 20;
  * badly-keyed cut does exceed.
  * @type {number}
  */
-export const CLOTH_ANCHOR_TRAVEL_REACH = 0.5;
+export const CLOTH_FRAME_TRAVEL_REACH = 0.5;
 
 /**
- * How far a cloth's anchor may rotate in one fixed step, radians. Rotation
+ * How far a cloth's frame may rotate in one fixed step, radians. Rotation
  * above this is felt as though it were exactly this.
  *
  * Unlike the travel limit this has no length scale to hang off — an angle is
@@ -153,11 +154,12 @@ export const CLOTH_ANCHOR_TRAVEL_REACH = 0.5;
  * about 1,700 degrees a second, which is a spin rather than a turn.
  * @type {number}
  */
-export const CLOTH_ANCHOR_ROTATION_LIMIT = 0.5;
+export const CLOTH_FRAME_ROTATION_LIMIT = 0.5;
 
 /**
- * Anchor displacement in one fixed step, as a multiple of the cloth's reach,
- * above which the motion is a **teleport** rather than locomotion (§7 P6).
+ * Displacement of the frame, or of a holder in the frame, in one fixed step, as
+ * a multiple of the cloth's reach, above which the motion is a **teleport**
+ * rather than locomotion (§7 P6).
  *
  * Four reaches in one step is 240 reaches a second: for a 1 m rope that is
  * 240 m/s, well past anything the world moves at and well short of the values a