@woosh/meep-engine 3.44.0 → 3.46.0

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

@@ -1,16 +1,21 @@
 import { assert } from "../../../../core/assert.js";
-import { quat3_multiply, quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { quat3_nlerp_array } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
+import { array_range_equal_strict } from "../../../../core/collection/array/array_range_equal_strict.js";
+import { pose3_apply_point_array } from "../../../../core/geom/3d/pose/pose3_apply_point_array.js";
+import { pose3_to_local_array } from "../../../../core/geom/3d/pose/pose3_to_local_array.js";
+import { quat3_clamp_angle_array } from "../../../../core/geom/3d/quaternion/quat3_clamp_angle_array.js";
+import {
+    quat3_multiply_conjugate_right_array
+} from "../../../../core/geom/3d/quaternion/quat3_multiply_conjugate_right_array.js";
 import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import { v3_quaternion_apply_inverse_array } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import { EntityObserver } from "../../../ecs/EntityObserver.js";
 import { EventType } from "../../../ecs/EventType.js";
 import { GPUStateAuthorityFlags } from "../../../ecs/gpu/GPUStateAuthorityFlags.js";
 import { gpu_authority_has } from "../../../ecs/gpu/gpu_authority_has.js";
-import { ParentEntity } from "../../../ecs/parent/ParentEntity.js";
+import { parent_entity_model_of } from "../../../ecs/parent/parent_entity_model_of.js";
 import {
-    TransformAttachment
-} from "../../../ecs/transform-attachment/TransformAttachment.js";
+    transform_attachment_parent_of
+} from "../../../ecs/transform-attachment/transform_attachment_parent_of.js";
 import {
     TransformAttachmentSystem
 } from "../../../ecs/transform-attachment/TransformAttachmentSystem.js";
@@ -20,6 +25,7 @@ import {
     Transform64
 } from "../../../ecs/transform/Transform64.js";
 import { t64_evaluate_world } from "../../../ecs/transform/t64_evaluate_world.js";
+import { t64_read_pose_array } from "../../../ecs/transform/t64_read_pose_array.js";
 import {
     collect_entity_playbacks
 } from "../../../graphics3/pose/collect_entity_playbacks.js";
@@ -551,9 +557,7 @@ export class ClothWorld {
                 return `entity ${hold.holder} holds cloth ${instance.entity} and hangs from entity ${entity}, which that cloth moves`;
             }
 
-            const attachment = ecd.getComponent(entity, TransformAttachment);
-
-            entity = attachment === undefined ? -1 : attachment.parent;
+            entity = transform_attachment_parent_of(ecd, entity);
         }
 
         const particles = hold.pin.particles;
@@ -695,18 +699,7 @@ export class ClothWorld {
             const pose = hold.pose;
 
             // in the frame: q_f⁻¹ · (t − t_f), q_f⁻¹ ⊗ q
-            HOLD_SCRATCH[0] = world[0] - frame_translation[0];
-            HOLD_SCRATCH[1] = world[1] - frame_translation[1];
-            HOLD_SCRATCH[2] = world[2] - frame_translation[2];
-
-            v3_quaternion_apply_inverse_array(pose, 0, HOLD_SCRATCH, 0, frame_rotation, 0);
-
-            FRAME_CONJUGATE[0] = -frame_rotation[0];
-            FRAME_CONJUGATE[1] = -frame_rotation[1];
-            FRAME_CONJUGATE[2] = -frame_rotation[2];
-            FRAME_CONJUGATE[3] = frame_rotation[3];
-
-            quat3_multiply_array(pose, 3, FRAME_CONJUGATE, 0, world, 3);
+            pose3_to_local_array(pose, 0, pose, 3, frame_translation, 0, frame_rotation, 0, world, 0, world, 3);
 
             if (!hold.has_previous) {
                 moved = true;
@@ -714,14 +707,8 @@ export class ClothWorld {
                 continue;
             }
 
-            const before = hold.world_previous;
-
-            for (let i = 0; i < 7; i++) {
-                if (world[i] !== before[i]) {
-                    moved = true;
-
-                    break;
-                }
+            if (!array_range_equal_strict(world, 0, hold.world_previous, 0, 7)) {
+                moved = true;
             }
         }
 
@@ -776,8 +763,7 @@ export class ClothWorld {
                     return false;
                 }
 
-                const owner = ecd.getComponent(e, ParentEntity);
-                const model = owner === undefined || owner === null ? e : owner.entity;
+                const model = parent_entity_model_of(ecd, e);
 
                 if (MODELS.indexOf(model) === -1) {
                     MODELS.push(model);
@@ -785,9 +771,7 @@ export class ClothWorld {
                     collect_entity_playbacks(playbacks, this.entityManager, model);
                 }
 
-                const attachment = ecd.getComponent(e, TransformAttachment);
-
-                e = attachment === undefined ? -1 : attachment.parent;
+                e = transform_attachment_parent_of(ecd, e);
             }
 
             t64_evaluate_world(EVALUATED, ecd, entity, playbacks);
@@ -797,13 +781,7 @@ export class ClothWorld {
             source = EVALUATED;
         }
 
-        out[0] = source[TRANSFORM64_TRANSLATION_OFFSET];
-        out[1] = source[TRANSFORM64_TRANSLATION_OFFSET + 1];
-        out[2] = source[TRANSFORM64_TRANSLATION_OFFSET + 2];
-        out[3] = source[TRANSFORM64_ROTATION_OFFSET];
-        out[4] = source[TRANSFORM64_ROTATION_OFFSET + 1];
-        out[5] = source[TRANSFORM64_ROTATION_OFFSET + 2];
-        out[6] = source[TRANSFORM64_ROTATION_OFFSET + 3];
+        t64_read_pose_array(out, 0, source);
 
         return true;
     }
@@ -1389,17 +1367,7 @@ export class ClothWorld {
                 reset = true;
             }
         } else if (moved) {
-            // the new pose goes in as an array: handed over as seven numbers, each was boxed
-            // wherever the call was not inlined
-            FRAME_POSE[0] = tx;
-            FRAME_POSE[1] = ty;
-            FRAME_POSE[2] = tz;
-            FRAME_POSE[3] = qx;
-            FRAME_POSE[4] = qy;
-            FRAME_POSE[5] = qz;
-            FRAME_POSE[6] = qw;
-
-            move_local_frame(instance, FRAME_POSE, previous_translation, previous_rotation);
+            move_local_frame(instance, FRAME_TRANSLATION, FRAME_ROTATION, previous_translation, previous_rotation);
         }
 
         previous_translation[0] = tx;
@@ -1585,18 +1553,14 @@ export class ClothWorld {
 
             const b = node * 7;
 
-            HOLD_SCRATCH[0] = EVALUATED[TRANSFORM64_TRANSLATION_OFFSET] - frame[TRANSFORM64_TRANSLATION_OFFSET];
-            HOLD_SCRATCH[1] = EVALUATED[TRANSFORM64_TRANSLATION_OFFSET + 1] - frame[TRANSFORM64_TRANSLATION_OFFSET + 1];
-            HOLD_SCRATCH[2] = EVALUATED[TRANSFORM64_TRANSLATION_OFFSET + 2] - frame[TRANSFORM64_TRANSLATION_OFFSET + 2];
-
-            v3_quaternion_apply_inverse_array(boundary, b, HOLD_SCRATCH, 0, frame, TRANSFORM64_ROTATION_OFFSET);
-
-            FRAME_CONJUGATE[0] = -frame[TRANSFORM64_ROTATION_OFFSET];
-            FRAME_CONJUGATE[1] = -frame[TRANSFORM64_ROTATION_OFFSET + 1];
-            FRAME_CONJUGATE[2] = -frame[TRANSFORM64_ROTATION_OFFSET + 2];
-            FRAME_CONJUGATE[3] = frame[TRANSFORM64_ROTATION_OFFSET + 3];
-
-            quat3_multiply_array(boundary, b + 3, FRAME_CONJUGATE, 0, EVALUATED, TRANSFORM64_ROTATION_OFFSET);
+            pose3_to_local_array(
+                boundary, b,
+                boundary, b + 3,
+                frame, TRANSFORM64_TRANSLATION_OFFSET,
+                frame, TRANSFORM64_ROTATION_OFFSET,
+                EVALUATED, TRANSFORM64_TRANSLATION_OFFSET,
+                EVALUATED, TRANSFORM64_ROTATION_OFFSET
+            );
         }
 
         playbacks.length = 0;
@@ -1671,14 +1635,8 @@ const LOCAL_GRAVITY = new Float64Array(3);
 const FRAME = new Float64Array(8);
 
 /**
- * The frame's pose this step, `[tx, ty, tz, qx, qy, qz, qw]`, as {@link move_local_frame} takes it.
- * @type {Float64Array}
- * @private
- */
-const FRAME_POSE = new Float64Array(7);
-
-/**
- * The frame's translation and rotation this step, apart, as the holds take them.
+ * The frame's translation and rotation this step, apart, as the holds and {@link move_local_frame}
+ * take them: the transform read once, before anything this step could write it.
  * @type {Float64Array}
  * @private
  */
@@ -1690,18 +1648,6 @@ const FRAME_TRANSLATION = new Float64Array(3);
  */
 const FRAME_ROTATION = new Float64Array(4);
 
-/**
- * @type {Float64Array}
- * @private
- */
-const FRAME_CONJUGATE = new Float64Array(4);
-
-/**
- * @type {Float64Array}
- * @private
- */
-const HOLD_SCRATCH = new Float64Array(4);
-
 /**
  * An exactly evaluated world pose: a holder a clip drives, a bone a garment
  * hangs from.
@@ -1717,21 +1663,6 @@ const EVALUATED = new Transform64();
  */
 const MODELS = [];
 
-/**
- * {@link move_local_frame}'s `q_now⁻¹`, `[-qx, -qy, -qz, qw]`.
- * @type {Float64Array}
- * @private
- */
-const POSE_CONJUGATE = new Float64Array(4);
-
-/**
- * The identity rotation, `[0, 0, 0, 1]`, which {@link move_local_frame} limits a turn towards. Never
- * written.
- * @type {Float64Array}
- * @private
- */
-const IDENTITY_ROTATION = new Float64Array([0, 0, 0, 1]);
-
 /**
  * Carry the free particles across a change of frame pose, by however much of it the
  * fabric is willing to feel. §7 P7.
@@ -1753,12 +1684,13 @@ const IDENTITY_ROTATION = new Float64Array([0, 0, 0, 1]);
  * is every call, twice per particle per step of a moving frame.
  *
  * @param {ClothInstance} instance
- * @param {Float64Array} pose the frame's pose now, `[tx, ty, tz, qx, qy, qz, qw]`
+ * @param {Float64Array} translation the frame's translation now
+ * @param {Float64Array} rotation the frame's rotation now
  * @param {Float64Array} previous_translation
  * @param {Float64Array} previous_rotation
  * @private
  */
-function move_local_frame(instance, pose, previous_translation, previous_rotation) {
+function move_local_frame(instance, translation, rotation, previous_translation, previous_rotation) {
     let inertia = instance.cloth.dynamics.inertia;
 
     if (inertia <= 0) {
@@ -1769,11 +1701,8 @@ function move_local_frame(instance, pose, previous_translation, previous_rotatio
         inertia = 1;
     }
 
-    FRAME[0] = previous_translation[0] - pose[0];
-    FRAME[1] = previous_translation[1] - pose[1];
-    FRAME[2] = previous_translation[2] - pose[2];
-
-    v3_quaternion_apply_inverse_array(FRAME, 0, FRAME, 0, pose, 3);
+    // the previous pose in the frame now: D and Q
+    pose3_to_local_array(FRAME, 0, FRAME, 4, translation, 0, rotation, 0, previous_translation, 0, previous_rotation, 0);
 
     const travel_limit = CLOTH_FRAME_TRAVEL_REACH * instance.reach;
 
@@ -1787,21 +1716,10 @@ function move_local_frame(instance, pose, previous_translation, previous_rotatio
         FRAME[2] *= scale;
     }
 
-    POSE_CONJUGATE[0] = -pose[3];
-    POSE_CONJUGATE[1] = -pose[4];
-    POSE_CONJUGATE[2] = -pose[5];
-    POSE_CONJUGATE[3] = pose[6];
-
-    quat3_multiply_array(FRAME, 4, POSE_CONJUGATE, 0, previous_rotation, 0);
-
-    // `|w|` is `cos(θ/2)`, so this is the angle test without an `acos`.
-    const half_angle_cos = FRAME[7] < 0 ? -FRAME[7] : FRAME[7];
-
-    if (half_angle_cos < Math.cos(CLOTH_FRAME_ROTATION_LIMIT * 0.5)) {
-        const angle = 2 * Math.acos(half_angle_cos > 1 ? 1 : half_angle_cos);
-
-        quat3_nlerp_array(FRAME, 4, IDENTITY_ROTATION, 0, FRAME, 4, CLOTH_FRAME_ROTATION_LIMIT / angle);
-    }
+    // Exactly the limit about the same axis. An nlerp from the identity by `limit / θ` follows the
+    // chord and turned less than the limit the further past it the frame spun: three quarters of it
+    // at a half turn.
+    quat3_clamp_angle_array(FRAME, 4, FRAME, 4, CLOTH_FRAME_ROTATION_LIMIT);
 
     const state = instance.state;
 
@@ -1857,11 +1775,7 @@ function carry_with_holder(instance, h) {
     const before = hold.pose_previous;
 
     // the jump's rotation, q_now ⊗ q_before⁻¹
-    quat3_multiply(
-        JUMP, 0,
-        now[3], now[4], now[5], now[6],
-        -before[3], -before[4], -before[5], before[6]
-    );
+    quat3_multiply_conjugate_right_array(JUMP, 0, now, 3, before, 3);
 
     const state = instance.state;
     const position = state.position;
@@ -1884,11 +1798,7 @@ function carry_with_holder(instance, h) {
         CARRIED[1] = position[p + 1] - before[1];
         CARRIED[2] = position[p + 2] - before[2];
 
-        v3_quaternion_apply_array(position, p, CARRIED, 0, JUMP, 0);
-
-        position[p] += now[0];
-        position[p + 1] += now[1];
-        position[p + 2] += now[2];
+        pose3_apply_point_array(position, p, now, 0, JUMP, 0, CARRIED, 0);
 
         v3_quaternion_apply_array(velocity, p, velocity, p, JUMP, 0);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAiEA;;;;GAIG;AACH,+DAFa,IAAI,CA6BhB;AAED;;;;;;;;;;GAUG;AACH,2DAFa,IAAI,CA6BhB;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CA2DhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAkBD;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CAoOhB;AAWD;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AA5lBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}
+{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAqEA;;;;GAIG;AACH,+DAFa,IAAI,CAsBhB;AAED;;;;;;;;;;GAUG;AACH,2DAFa,IAAI,CA6BhB;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CAgDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CAkOhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AA/iBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}

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

@@ -1,9 +1,13 @@
+import { v3_distance_array } from "../../../../core/geom/vec3/v3_distance_array.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+import { csr_build_incidence } from "../../../../core/graph/csr/csr_build_incidence.js";
 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";
+import { cloth_particle_of_source } from "../solver/cloth_particle_of_source.js";
 
 /**
  * # The rows, and everything that is a number rather than a walk
@@ -72,26 +76,19 @@ export function cloth_build_children(instance) {
     const node_count = instance.node_count;
     const parent = instance.node_parent;
 
-    const offset = new Int32Array(node_count + 1);
+    let child_count = 0;
 
     for (let node = 0; node < node_count; node++) {
         if (parent[node] >= 0) {
-            offset[parent[node] + 1]++;
+            child_count++;
         }
     }
 
-    for (let node = 0; node < node_count; node++) {
-        offset[node + 1] += offset[node];
-    }
-
-    const child = new Int32Array(offset[node_count]);
-    const cursor = offset.slice(0, node_count);
+    const offset = new Int32Array(node_count + 1);
+    const child = new Int32Array(child_count);
 
-    for (let node = 0; node < node_count; node++) {
-        if (parent[node] >= 0) {
-            child[cursor[parent[node]]++] = node;
-        }
-    }
+    // a root's parent is −1, which is in no bucket
+    csr_build_incidence(offset, child, parent, node_count, node_count);
 
     instance.node_child_offset = offset;
     instance.node_child = child;
@@ -161,24 +158,13 @@ export function cloth_build_surface(instance) {
     }
 
     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];
+    csr_build_incidence(offset, surface, triangle, triangle_count * 3, node_count);
 
-            surface[cursor[node]++] = t;
-        }
+    // a corner's flat index `t·3 + k` to its triangle `t`
+    for (let i = 0; i < triangle_count * 3; i++) {
+        surface[i] = (surface[i] / 3) | 0;
     }
 
     // the first edge each node has: fixed for the life of the seed, which is all
@@ -232,22 +218,6 @@ export function cloth_hinge_inertia(weight, hinge) {
     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.
@@ -300,7 +270,7 @@ export function cloth_build_rows(instance, dt) {
         const a = edge[e * 2];
         const b = edge[e * 2 + 1];
 
-        const length = rest_distance(rest, a, b);
+        const length = v3_distance_array(rest, a * 3, rest, b * 3);
 
         edge_length[e] = length;
 
@@ -347,7 +317,7 @@ export function cloth_build_rows(instance, dt) {
             // 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(a, b);
-            stretch_rest.push(rest_distance(rest, a, b));
+            stretch_rest.push(v3_distance_array(rest, a * 3, rest, b * 3));
             stretch_stiffness.push(bend_stiffness);
             stretch_force_min.push(-Infinity);
             stretch_force_max.push(Infinity);
@@ -452,9 +422,7 @@ export function cloth_build_rows(instance, dt) {
 
     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;
-    }
+    cloth_particle_of_source(particle_of_node, state.source_of_particle, node_count);
 
     // 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
@@ -490,15 +458,6 @@ export function cloth_build_rows(instance, dt) {
     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.

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":"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"}
+{"version":3,"file":"cloth_dynamics_map.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_dynamics_map.js"],"names":[],"mappings":"AAuQA;;;;;;;;GAQG;AACH,gDAHW,MAAM,GACJ,MAAM,CAIlB;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;;;;;;;;;;;;;;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

@@ -1,3 +1,5 @@
+import { clamp01 } from "../../../../core/math/clamp01.js";
+
 /**
  * # Normalised coordinates → row parameters
  *
@@ -269,9 +271,7 @@ export const CLOTH_SLEEP_STEPS = 30;
  * @returns {number} strain, `L_max = L₀·(1 + ε)`
  */
 export function cloth_strain_allowance(stretch) {
-    const t = stretch < 0 ? 0 : (stretch > 1 ? 1 : stretch);
-
-    return CLOTH_STRAIN_MAX * Math.pow(CLOTH_STRAIN_MIN / CLOTH_STRAIN_MAX, t);
+    return CLOTH_STRAIN_MAX * Math.pow(CLOTH_STRAIN_MIN / CLOTH_STRAIN_MAX, clamp01(stretch));
 }
 
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_gather_colliders.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_gather_colliders.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qFAHW,MAAM,GACJ,MAAM,CAsBlB;AAyJD;;;;;;GAMG;AACH,kGAHW,MAAM,GACJ,MAAM,CAmBlB;AAwFD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2FAFa,OAAO,CAkBnB;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,IAAI,CAgBhB"}
+{"version":3,"file":"cloth_gather_colliders.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_gather_colliders.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qFAHW,MAAM,GACJ,MAAM,CAsBlB;AA2HD;;;;;;GAMG;AACH,kGAHW,MAAM,GACJ,MAAM,CAmBlB;AA2ED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2FAFa,OAAO,CAkBnB;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,IAAI,CAgBhB"}