@woosh/meep-engine 3.44.0 → 3.45.0

package/src/engine/physics/cloth/solver/cloth_worst_tether_ratio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_worst_tether_ratio.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_worst_tether_ratio.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDATW,YAAY,GAAC,YAAY,oBACzB,UAAU,GAAC,WAAW,GAAC,MAAM,EAAE,YAC/B,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,GACJ,MAAM,CA6BlB"}

package/src/engine/physics/cloth/solver/cloth_worst_tether_ratio.js

@@ -0,0 +1,56 @@
+import { v3_length } from "../../../../core/geom/vec3/v3_length.js";
+import { max2_exact } from "../../../../core/math/max2_exact.js";
+
+/**
+ * How far the cloth has stretched away from its root, as the worst ratio over
+ * nodes of straight-line distance from node 0 to the fabric between them:
+ * `max ‖x_node − x_0‖ / d_geo(node)` over nodes `1 .. node_count − 1` — §7 P2's
+ * measure. At most 1 for a cloth that has not over-stretched anywhere, since no
+ * straight line is longer than the fabric it spans; `1.05` is a node five
+ * percent further out than the cloth reaches.
+ *
+ * Everything is measured from node 0, the root of the seeder's tree, which is
+ * where the rigs this was written for are held. A cloth held in several places
+ * wants each node measured from its own hold instead, and this is not that
+ * measure.
+ *
+ * A node at a NaN position reads NaN and so does the answer, whatever the other
+ * nodes say, so a broken state cannot pass for a well-behaved one.
+ *
+ * Takes the arrays rather than a `ClothInstance` so the solver side does not
+ * depend on the ECS one.
+ *
+ * @param {Float32Array|Float64Array} position 3 per particle
+ * @param {Int32Array|Uint32Array|number[]} particle_of_node particle index per node
+ * @param {Float32Array|Float64Array|number[]} geodesic fabric distance from node 0 per node, metres
+ * @param {number} node_count
+ * @returns {number} dimensionless; 0 for a cloth of fewer than two nodes
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function cloth_worst_tether_ratio(position, particle_of_node, geodesic, node_count) {
+    const root = particle_of_node[0] * 3;
+
+    const root_x = position[root];
+    const root_y = position[root + 1];
+    const root_z = position[root + 2];
+
+    let worst = 0;
+
+    for (let node = 1; node < node_count; node++) {
+        const p = particle_of_node[node] * 3;
+
+        const distance = v3_length(
+            position[p] - root_x,
+            position[p + 1] - root_y,
+            position[p + 2] - root_z
+        );
+
+        const ratio = distance / geodesic[node];
+
+        worst = max2_exact(worst, ratio);
+    }
+
+    return worst;
+}

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AAuHA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QA+LnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA8ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAqGhB;AAxdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}
+{"version":3,"file":"cloth_contact_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_contact_row.js"],"names":[],"mappings":"AAwHA;;;;;;;;GAQG;AACH,sDANW,YAAY,+BAEZ,MAAM,SACN,YAAY,GAAC,YAAY,QA+LnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mEANW,MAAM,SACN,MAAM,eACN,MAAM,eACN,MAAM,qBACN,MAAM,QA8ChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oEALW,YAAY,GAAC,YAAY,QACzB,MAAM,eACN,MAAM,qBACN,MAAM,QAqGhB;AAxdD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;GAKG;AACH,qCAFU,MAAM,CAE2B"}

package/src/engine/physics/cloth/solver/constraint/cloth_contact_row.js

@@ -1,3 +1,4 @@
+import { clamp } from "../../../../../core/math/clamp.js";
 import {
     CCR_FEATURE,
     CCR_FRICTION,
@@ -373,8 +374,8 @@ export function cloth_contact_warm_start(state, alpha, gamma, k_min_ratio, k_max
             lambda[slot] *= decay;
             friction_lambda[slot] *= decay;
 
-            penalty[slot] = clamp_band(penalty[slot] * gamma, lo, hi);
-            friction_penalty[slot] = clamp_band(friction_penalty[slot] * gamma, lo, hi);
+            penalty[slot] = clamp(penalty[slot] * gamma, lo, hi);
+            friction_penalty[slot] = clamp(friction_penalty[slot] * gamma, lo, hi);
         }
     }
 }
@@ -496,21 +497,6 @@ export function cloth_contact_dual_update(state, table, beta, k_max_ratio, inver
     }
 }
 
-/**
- * @param {number} value
- * @param {number} lo
- * @param {number} hi
- * @returns {number}
- * @private
- */
-function clamp_band(value, lo, hi) {
-    if (value < lo) {
-        return lo;
-    }
-
-    return value > hi ? hi : value;
-}
-
 /**
  * @type {Float64Array}
  * @private

package/src/engine/physics/cloth/wind/ClothFluidWind.d.ts

@@ -21,7 +21,8 @@
  *   callers (vegetation sway, dust drift) interpret the field as a direction ×
  *   magnitude wind". Cloth's drag row is a relaxation toward a **velocity**, so
  *   the same wind voxelised at 0.25 m instead of 1 m would blow a garment four
- *   times as hard. The multiply by `cell_size` is here. `MEASUREMENTS.md` §45.
+ *   times as hard. The multiply by `cell_size` is
+ *   {@link fluid_sample_velocity_world_mps}'s. `MEASUREMENTS.md` §45.
  * - **Unbuilt fields read as null.** A `FluidComponent` exists from the moment
  *   the entity is spawned and its field's buffers arrive at `build()`. Sampling
  *   before that is a null dereference rather than a zero, so an unbuilt field is

package/src/engine/physics/cloth/wind/ClothFluidWind.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothFluidWind.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IAEI;;;;OAIG;IACH,SAFU,gBAAgB,CAEO;IAEjC;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;CAkIf;kCAnNiC,wBAAwB;iCACzB,uBAAuB"}
+{"version":3,"file":"ClothFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothFluidWind.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH;IAEI;;;;OAIG;IACH,SAFU,gBAAgB,CAEO;IAEjC;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;CA6Gf;kCA/LiC,wBAAwB;iCACzB,uBAAuB"}

package/src/engine/physics/cloth/wind/ClothFluidWind.js

@@ -1,4 +1,6 @@
 import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
+import { fluid_sample_domain_bounds } from "../../fluid/ecs/fluid_sample_domain_bounds.js";
+import { fluid_sample_velocity_world_mps } from "../../fluid/ecs/fluid_sample_velocity_world_mps.js";
 import { AbstractClothWind } from "./AbstractClothWind.js";
 import { ClothAmbientWind } from "./ClothAmbientWind.js";
 
@@ -25,7 +27,8 @@ import { ClothAmbientWind } from "./ClothAmbientWind.js";
  *   callers (vegetation sway, dust drift) interpret the field as a direction ×
  *   magnitude wind". Cloth's drag row is a relaxation toward a **velocity**, so
  *   the same wind voxelised at 0.25 m instead of 1 m would blow a garment four
- *   times as hard. The multiply by `cell_size` is here. `MEASUREMENTS.md` §45.
+ *   times as hard. The multiply by `cell_size` is
+ *   {@link fluid_sample_velocity_world_mps}'s. `MEASUREMENTS.md` §45.
  * - **Unbuilt fields read as null.** A `FluidComponent` exists from the moment
  *   the entity is spawned and its field's buffers arrive at `build()`. Sampling
  *   before that is a null dereference rather than a zero, so an unbuilt field is
@@ -109,20 +112,7 @@ export class ClothFluidWind extends AbstractClothWind {
                     return;
                 }
 
-                const resolution = field.getResolution();
-
-                const cell_size = component.cell_size;
-
-                const origin = component.origin;
-
-                const b = count * 6;
-
-                bounds[b] = origin[0];
-                bounds[b + 1] = origin[1];
-                bounds[b + 2] = origin[2];
-                bounds[b + 3] = origin[0] + resolution[0] * cell_size;
-                bounds[b + 4] = origin[1] + resolution[1] * cell_size;
-                bounds[b + 5] = origin[2] + resolution[2] * cell_size;
+                fluid_sample_domain_bounds(bounds, count * 6, component);
 
                 components[count] = component;
 
@@ -194,16 +184,8 @@ export class ClothFluidWind extends AbstractClothWind {
                 continue;
             }
 
-            const component = this.__components[i];
-
-            component.sampleVelocityAtWorld(out, x, y, z);
-
-            // Cells per second to metres per second. See the header.
-            const cell_size = component.cell_size;
-
-            out[0] *= cell_size;
-            out[1] *= cell_size;
-            out[2] *= cell_size;
+            // In metres per second, not the field's cells per second. See the header.
+            fluid_sample_velocity_world_mps(out, 0, this.__components[i], x, y, z);
 
             return out;
         }

package/src/engine/physics/cloth/wind/cloth_sample_air.d.ts

@@ -92,10 +92,12 @@ export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, fr
  * The cloth's world-space axis-aligned bounds.
  *
  * The particles are local, so this is the bounds of the **rotated** local box
- * rather than the rotation of its bounds — the same eight-corner argument
+ * rather than the rotation of its bounds — the same argument
  * `cloth_gather_colliders` makes for its own query volume, and the same reason:
  * a rotated box is not a box.
  *
+ * A cloth with no particles has the empty box, `+∞` below and `−∞` above.
+ *
  * @param {ClothState} state
  * @param {Float64Array} frame_translation
  * @param {Float64Array} frame_rotation

package/src/engine/physics/cloth/wind/cloth_sample_air.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;;GAaG;AACH,gGARW,YAAY,kBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAEJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iGATW,YAAY,kBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;GAaG;AACH,uEALW,YAAY,kBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CAoEhB"}
+{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;;GAaG;AACH,gGARW,YAAY,kBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAEJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iGATW,YAAY,kBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,uEALW,YAAY,kBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CA4BhB"}

package/src/engine/physics/cloth/wind/cloth_sample_air.js

@@ -1,3 +1,5 @@
+import { aabb3_from_v3_array } from "../../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
+import { aabb3_transform_oriented_array } from "../../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
 import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 
@@ -194,10 +196,12 @@ export function cloth_air_changed(state, wind, frame_translation, frame_rotation
  * The cloth's world-space axis-aligned bounds.
  *
  * The particles are local, so this is the bounds of the **rotated** local box
- * rather than the rotation of its bounds — the same eight-corner argument
+ * rather than the rotation of its bounds — the same argument
  * `cloth_gather_colliders` makes for its own query volume, and the same reason:
  * a rotated box is not a box.
  *
+ * A cloth with no particles has the empty box, `+∞` below and `−∞` above.
+ *
  * @param {ClothState} state
  * @param {Float64Array} frame_translation
  * @param {Float64Array} frame_rotation
@@ -205,71 +209,31 @@ export function cloth_air_changed(state, wind, frame_translation, frame_rotation
  * @returns {void}
  */
 export function cloth_air_bounds(state, frame_translation, frame_rotation, out) {
-    const particle_count = state.particle_count;
-
-    const position = state.position;
-
-    let min_x = Infinity;
-    let min_y = Infinity;
-    let min_z = Infinity;
-    let max_x = -Infinity;
-    let max_y = -Infinity;
-    let max_z = -Infinity;
-
-    for (let i = 0; i < particle_count; i++) {
-        const p = i * 3;
-
-        const x = position[p];
-        const y = position[p + 1];
-        const z = position[p + 2];
-
-        if (x < min_x) { min_x = x; }
-        if (y < min_y) { min_y = y; }
-        if (z < min_z) { min_z = z; }
-        if (x > max_x) { max_x = x; }
-        if (y > max_y) { max_y = y; }
-        if (z > max_z) { max_z = z; }
+    if (state.particle_count === 0) {
+        // Rotating the empty box would subtract infinities and read NaN.
+        out[0] = Infinity;
+        out[1] = Infinity;
+        out[2] = Infinity;
+        out[3] = -Infinity;
+        out[4] = -Infinity;
+        out[5] = -Infinity;
+
+        return;
     }
 
-    const qx = frame_rotation[0];
-    const qy = frame_rotation[1];
-    const qz = frame_rotation[2];
-    const qw = frame_rotation[3];
+    aabb3_from_v3_array(LOCAL_BOX, state.position, state.particle_count * 3);
 
-    let world_min_x = Infinity;
-    let world_min_y = Infinity;
-    let world_min_z = Infinity;
-    let world_max_x = -Infinity;
-    let world_max_y = -Infinity;
-    let world_max_z = -Infinity;
-
-    for (let corner = 0; corner < 8; corner++) {
-        v3_quaternion_apply(
-            WORLD, 0,
-            (corner & 1) === 0 ? min_x : max_x,
-            (corner & 2) === 0 ? min_y : max_y,
-            (corner & 4) === 0 ? min_z : max_z,
-            qx, qy, qz, qw
-        );
-
-        const x = WORLD[0] + frame_translation[0];
-        const y = WORLD[1] + frame_translation[1];
-        const z = WORLD[2] + frame_translation[2];
-
-        if (x < world_min_x) { world_min_x = x; }
-        if (y < world_min_y) { world_min_y = y; }
-        if (z < world_min_z) { world_min_z = z; }
-        if (x > world_max_x) { world_max_x = x; }
-        if (y > world_max_y) { world_max_y = y; }
-        if (z > world_max_z) { world_max_z = z; }
-    }
+    // The frame pose as the seven contiguous numbers the transform reads,
+    // translation then rotation.
+    FRAME_POSE[0] = frame_translation[0];
+    FRAME_POSE[1] = frame_translation[1];
+    FRAME_POSE[2] = frame_translation[2];
+    FRAME_POSE[3] = frame_rotation[0];
+    FRAME_POSE[4] = frame_rotation[1];
+    FRAME_POSE[5] = frame_rotation[2];
+    FRAME_POSE[6] = frame_rotation[3];
 
-    out[0] = world_min_x;
-    out[1] = world_min_y;
-    out[2] = world_min_z;
-    out[3] = world_max_x;
-    out[4] = world_max_y;
-    out[5] = world_max_z;
+    aabb3_transform_oriented_array(out, 0, LOCAL_BOX, 0, FRAME_POSE, 0);
 }
 
 /**
@@ -278,6 +242,20 @@ export function cloth_air_bounds(state, frame_translation, frame_rotation, out)
  */
 const BOUNDS = new Float64Array(6);
 
+/**
+ * The cloth's particle bounds in its local frame.
+ * @type {Float64Array}
+ * @private
+ */
+const LOCAL_BOX = new Float64Array(6);
+
+/**
+ * The cloth's frame pose, `[px, py, pz, qx, qy, qz, qw]`, for {@link aabb3_transform_oriented_array}.
+ * @type {Float64Array}
+ * @private
+ */
+const FRAME_POSE = new Float64Array(7);
+
 /**
  * @type {Float64Array}
  * @private

package/src/engine/physics/ecs/ContactProbeSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContactProbeSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/ContactProbeSystem.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;GAaG;AACH;;IAEI,mEAAmD;IAEnD,2bASE;IAyCF;;;;OAIG;IACH,YAJW,YAAY,cACZ,mBAAmB,UACnB,MAAM,QAUhB;IAED;;;;OAIG;IACH,cAJW,YAAY,cACZ,mBAAmB,UACnB,MAAM,QAWhB;IAED,sCA2BC;;CAiKJ;uBA1VsB,qBAAqB;oCAER,uDAAuD;6BAY9D,mBAAmB;4BALzC,oCAAoC;4CAbC,oDAAoD;yBAiBvE,eAAe;yCAHC,uDAAuD;0BAbtE,kCAAkC;kCAC1B,oCAAoC;6BACzC,kCAAkC"}
+{"version":3,"file":"ContactProbeSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/ContactProbeSystem.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;;GAaG;AACH;;IAEI,mEAAmD;IAEnD,2bASE;IAyCF;;;;OAIG;IACH,YAJW,YAAY,cACZ,mBAAmB,UACnB,MAAM,QAUhB;IAED;;;;OAIG;IACH,cAJW,YAAY,cACZ,mBAAmB,UACnB,MAAM,QAWhB;IAED,sCA2BC;;CAiKJ;uBA1VsB,qBAAqB;oCAER,uDAAuD;6BAY9D,mBAAmB;4BALzC,oCAAoC;4CAdC,oDAAoD;yBAkBvE,eAAe;yCAHC,uDAAuD;0BAdtE,kCAAkC;kCAC1B,oCAAoC;6BACzC,kCAAkC"}

package/src/engine/physics/ecs/ContactProbeSystem.js

@@ -8,6 +8,7 @@ import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessS
 import { Animation } from "../../ecs/animation/Animation.js";
 import { GPUStateAuthority } from "../../ecs/gpu/GPUStateAuthority.js";
 import { ParentEntity } from "../../ecs/parent/ParentEntity.js";
+import { parent_entity_model_of } from "../../ecs/parent/parent_entity_model_of.js";
 import { System } from "../../ecs/System.js";
 import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "../../ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
 import { TransformAttachment } from "../../ecs/transform-attachment/TransformAttachment.js";
@@ -327,7 +328,7 @@ export class ContactProbeSystem extends System {
     #world_of(result, entity) {
         const dataset = this.entityManager.dataset;
 
-        const model = model_of(dataset, entity);
+        const model = parent_entity_model_of(dataset, entity);
 
         let cache = this.#caches.get(model);
 
@@ -356,23 +357,6 @@ export class ContactProbeSystem extends System {
     }
 }
 
-/**
- * The entity whose clips drive `entity`: the model its lifetime belongs to, or itself.
- *
- * @param {EntityComponentDataset} dataset
- * @param {number} entity
- * @returns {number}
- */
-function model_of(dataset, entity) {
-    const owner = dataset.getComponent(entity, ParentEntity);
-
-    if (owner === undefined || owner === null) {
-        return entity;
-    }
-
-    return owner.entity;
-}
-
 /**
  * The top of the lifetime chain an entity belongs to.
  *

package/src/engine/physics/ecs/PhysicsSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"AAuJA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;IAEI,wDAAwC;IACxC,oKAIE;IAEF;;;;OAIG;IACH,kBAHU,WAAW,CAGO;IAE5B;;;;OAIG;IACH,WAFU,GAAG,CAES;IAEtB;;;;OAIG;IACH,YAFU,GAAG,CAEU;IAEvB;;;;OAIG;IACH,oBAHU,aAAa,CAGS;IAEhC;;;;;OAKG;IACH,OAFU,QAAQ,CAEK;IAEvB;;;;OAIG;IACH,eAFU,kBAAkB,CAEa;IAEzC;;;;;OAKG;IACH,SAFU,aAAa,CAEO;IAE9B;;;;;;;;;OASG;IACH,gBAFU,eAAe,CAEc;IAEvC;;;;;;;;;;;;;;;;OAgBG;IACH,2BAFU,MAAM,CAEiB;IAEjC;;;;OAIG;IACH,oBAFU,MAAM,CAES;IAEzB;;;;;;OAMG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;;OAKG;IACH,sBAFU,MAAM,CAEsC;IAEtD;;;;;;;OAOG;IACH,cAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,qBAFU,MAAM,CAES;IAEzB;;;;;OAKG;IACH,0BAOE;IAEF;;;;;;;OAOG;IACH,kBAFU,YAAY,CAEiB;IAEvC;;;;;OAKG;IACH,yBAAwB;IAExB;;;;;OAKG;IACH,UAFU,SAAS,EAAE,CAEP;IAEd;;;OAGG;IACH,uBAHU,WAAW,EAAE,CAGL;IAElB;;;;;;;;OAQG;IACH,uBAFU,MAAM,MAAM;QAAC,QAAQ,EAAE,QAAQ,CAAC;QAAC,SAAS,EAAE,WAAW,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,CAE1E;IAE3B;;;;;OAKG;IACH,UAFU,OAAO,CAEH;IAEd;;;;;;OAMG;IACH,qBAAkB;IAElB;;;;;;;;;;;;;OAaG;IACH,wBAAqB;IAErB;;;;;;;;;;OAUG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;;;;;;OAgBG;IACH,mBAFU,YAAY,CAEkB;IAExC;;;;;;;;;;;;OAYG;IACH,gCAA4B;IAE5B;;;;OAIG;IACH,YAFU,OAAO,CAEC;IAElB;;;;;;;OAOG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;;;;;;OAQG;IACH,iBAFU,YAAY,CAEgB;IAEtC;;;;;;;OAOG;IACH,cAFU,WAAW,CAEc;IAEnC;;;;;OAKG;IACH,uBAFU,MAAM,QAAQ,GAAC,IAAI,CAAC,CAEH;IAE3B;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;;;;;;;;;;;OAaG;IACH,eAFU,YAAY,CAEc;IAEpC;;;;;;;;OAQG;IACH,uBAAqC;IAErC;;;;;;;OAOG;IACH,6BAA0B;IAE1B;;;;OAIG;IACH,4BAAwB;IA2BxB,+BAMC;IA1BD;;;;;;;;;;;;;;;OAeG;IACH,4BAEC;IAUD;;;;;;;;;;;;;OAaG;IACH,sBA6BC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2BAGC;IAED;;;;;;;;;;;;OAYG;IACH,gCAQC;IAED;;;;OAIG;IACH,gCAMC;IAED;;;OAGG;IACH,cAFW,OAAO,GAAC,UAAU,MAAM,CAAC,QASnC;IAED;;;;;;;;;;;OAWG;IACH,qBAFW,CAAC,CAAC,OAAO,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,EAAE,SAAS,EAAC,QAAQ,EAAE,SAAS,EAAC,QAAQ,KAAK,OAAO,CAAC,GAAG,IAAI,QAItG;IAED;;OAEG;IACH,oBAFa,CAAC,CAAC,OAAO,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,EAAE,SAAS,EAAC,QAAQ,EAAE,SAAS,EAAC,QAAQ,KAAK,OAAO,CAAC,GAAG,IAAI,CAIxG;IAED;;;;;;OAMG;IACH,iCA+BC;IAED;;;;OAIG;IACH,iCAIC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAmBC;IAED;;;;;;;;;;OAUG;IACH,gBAJW,SAAS,aACT,WAAW,UACX,MAAM,QAyChB;IAED;;;;;;;OAOG;IACH,kBAJW,SAAS,aACT,WAAW,UACX,MAAM,QAyDhB;IAED;;;;;;;;;;;;;OAaG;IACH,6BALW,MAAM,YACN,QAAQ,aACR,WAAW,oBACX,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,YACN,QAAQ,QAiClB;IAED;;;;;;;;OAQG;IACH,oCAEC;IAED;;;;;;;;;OASG;IACH,+BAyCC;IAED;;;;OAIG;IACH,iCAUC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,uBAHW,MAAM,GACJ,SAAS,GAAC,SAAS,CAK/B;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,4BAHW,MAAM,GACJ,cAAc;QAAC,QAAQ,EAAE,QAAQ,CAAC;QAAC,SAAS,EAAE,WAAW,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAMvF;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;;;;;OASG;IACH,wBAHW,SAAS,WACT,OAAO,GAAC,UAAU,MAAM,CAAC,QAenC;IAED;;;;;;;;;;;OAWG;IACH,0BALW,SAAS,aACT,WAAW,WACX,OAAO,GAAC,UAAU,MAAM,CAAC,cACzB,OAAO,GAAC,UAAU,MAAM,CAAC,QA8DnC;IAED;;;;;;;;;;;OAWG;IACH,uBAHW,SAAS,UACT,OAAO,GAAC,UAAU,MAAM,CAAC,QAanC;IAED;;;;;;;;;;;;;;OAcG;IACH,wBALW,SAAS,aACT,WAAW,SACX,OAAO,GAAC,UAAU,MAAM,CAAC,cACzB,OAAO,GAAC,UAAU,MAAM,CAAC,QA+BnC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAHW,SAAS,SACT,OAAO,GAAC,UAAU,MAAM,CAAC,QAanC;IAED;;;;;OAKG;IACH,6BAHW,SAAS,KACT,OAAO,GAAC,UAAU,MAAM,CAAC,QAYnC;IAED;;;;;;;;OAQG;IACH,8BAHW,SAAS,KACT,OAAO,GAAC,UAAU,MAAM,CAAC,QAYnC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,mBAJW,SAAS,YACT,OAAO,GAAC,UAAU,MAAM,CAAC,YACzB,aAAW,UAAU,MAAM,CAAC,QAuFtC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,yBANW,SAAS,YACT,OAAO,GAAC,UAAU,MAAM,CAAC,YACzB,aAAW,UAAU,MAAM,CAAC,QA0DtC;IAED;;;;;;;OAOG;IACH,mCAwDC;IAED;;;;;;;OAOG;IACH,4BAqCC;IAED;;;OAGG;IACH,gBAFW,SAAS,QAInB;IAED;;;;;;;;;;;;;OAaG;IACH,iBAFW,SAAS,QAwBnB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAmCC;IAED;;;;;;;;;;;;;;OAcG;IACH,oCAwCC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yDAJW,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,QAAQ,KAAG,OAAO,GAEzC,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,uDATW,UAAU,MAAM,CAAC,wCAMjB,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,QAAQ,KAAG,OAAO,GACzC,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,0CATW,UAAU,MAAM,CAAC,YAEjB,UAAU,MAAM,CAAC,UACjB,WAAW,GAAC,MAAM,EAAE,iBACpB,MAAM,WACN,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,QAAQ,KAAG,OAAO,GAEzC,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,YAFa,IAAI,CAMhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,qBA+DC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,0BAiCC;IAED;;;;;;;;;;;;OAYG;IACH,sBAoCC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,qBA4EC;IAED;;;;;;;;;;OAUG;IACH,kCAwFC;IA6gBL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;uBA/1FsB,qBAAqB;4BAQrC,oCAAoC;0BAsCO,gBAAgB;4CA/CtB,oDAAoD;yBA0CrD,eAAe;4BA/Bf,wBAAwB;oBA3B/C,gCAAgC;8BAkCtB,6BAA6B;yBAHlC,2BAA2B;mCAIC,iCAAiC;8BAOxD,4BAA4B;gCAdd,4BAA4B;oBAdpD,+BAA+B;yBA2C1B,eAAe;+BAOT,qBAAqB"}

package/src/engine/physics/ecs/PhysicsSystem.js

@@ -5,18 +5,20 @@ import {
     bvh_query_user_data_intersects_aabb
 } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
 import { returnTrue } from "../../../core/function/returnTrue.js";
+import { aabb3_array_round_outward_f32 } from "../../../core/geom/3d/aabb/aabb3_array_round_outward_f32.js";
 import {
     aabb3_transform_oriented,
     aabb3_transform_oriented_array
 } from "../../../core/geom/3d/aabb/aabb3_transform_oriented.js";
-import { quat3_multiply_array } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
+import {
+    quat3_multiply_conjugate_right_array
+} from "../../../core/geom/3d/quaternion/quat3_multiply_conjugate_right_array.js";
 import Vector3 from "../../../core/geom/Vector3.js";
-import { f32_next_down } from "../../../core/math/f32_next_down.js";
-import { f32_next_up } from "../../../core/math/f32_next_up.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { System } from "../../ecs/System.js";
 import { t64_announce_change } from "../../ecs/transform/t64_announce_change.js";
+import { t64_read_pose_array } from "../../ecs/transform/t64_read_pose_array.js";
 import { TRANSFORM64_EVENT_PLACED } from "../../ecs/transform/TRANSFORM64_EVENT_PLACED.js";
 import {
     Transform64,
@@ -134,13 +136,6 @@ const TARGET_POSE_STRIDE = 8;
  */
 const scratch_target_dq = new Float64Array(4);
 
-/**
- * Scratch for {@link PhysicsSystem#__derive_target_velocities}: the conjugate of the body's current
- * orientation, `[x, y, z, w]`, the second operand of that rotation.
- * @type {Float64Array}
- */
-const scratch_target_conjugate = new Float64Array(4);
-
 /**
  * What {@link PhysicsSystem#collidersOf} answers for a body that has none: one shared, frozen
  * empty list.
@@ -154,31 +149,6 @@ const NO_COLLIDERS = Object.freeze([]);
  */
 let interpolation_log_deprecation_warned = false;
 
-/**
- * Round a world box outward to float32, in place: each lower bound down and each upper bound up
- * to a float32 value, so the box keeps containing what it bounded once the broadphase stores it.
- *
- * The BVHs store float32, and a plain write rounds to the NEAREST float32 — inward on any side
- * that rounds that way, by up to half a float32 step: 3 cm at 1e6 m. A static leaf is its body's
- * tight box, so a query reaching the body through its leaf missed whatever of the body lay
- * outside it. A ray dropped onto a 2 mm plate 1e6 m out missed it; so did rays a millimetre inside
- * a 1 m crate's faces 1e5 m out. The refit skip in stage 2 also leans on it: a stationary body's
- * box is contained by its own stored leaf only if that leaf did not shrink.
- *
- * @param {Float64Array} aabb `[x0, y0, z0, x1, y1, z1]`
- */
-function aabb3_round_outward_f32(aabb) {
-    for (let i = 0; i < 3; i++) {
-        const lower = aabb[i];
-        const lower_f32 = Math.fround(lower);
-        aabb[i] = lower_f32 > lower ? f32_next_down(lower_f32) : lower_f32;
-
-        const upper = aabb[i + 3];
-        const upper_f32 = Math.fround(upper);
-        aabb[i + 3] = upper_f32 < upper ? f32_next_up(upper_f32) : upper_f32;
-    }
-}
-
 /**
  * Rigid-body physics system.
  *
@@ -815,7 +785,7 @@ export class PhysicsSystem extends System {
             transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
         );
 
-        aabb3_round_outward_f32(scratch_world_aabb);
+        aabb3_array_round_outward_f32(scratch_world_aabb, 0, scratch_world_aabb, 0);
 
         const bvh = rb.kind === BodyKind.Static ? this.staticBvh : this.dynamicBvh;
         const node = bvh.allocate_node();
@@ -1693,12 +1663,7 @@ export class PhysicsSystem extends System {
             // the one a world angular velocity integrates (dq/dt = ½ ω ⊗ q). Its axis × angle over
             // dt is the angular velocity; the shorter of the two arcs a quaternion pair describes.
             // Both operands go in as arrays, the target straight from its slot.
-            scratch_target_conjugate[0] = -tr[TRANSFORM64_ROTATION_OFFSET];
-            scratch_target_conjugate[1] = -tr[TRANSFORM64_ROTATION_OFFSET + 1];
-            scratch_target_conjugate[2] = -tr[TRANSFORM64_ROTATION_OFFSET + 2];
-            scratch_target_conjugate[3] = tr[TRANSFORM64_ROTATION_OFFSET + 3];
-
-            quat3_multiply_array(scratch_target_dq, 0, poses, base + 4, scratch_target_conjugate, 0);
+            quat3_multiply_conjugate_right_array(scratch_target_dq, 0, poses, base + 4, tr, TRANSFORM64_ROTATION_OFFSET);
 
             let dx = scratch_target_dq[0];
             let dy = scratch_target_dq[1];
@@ -2544,13 +2509,7 @@ export class PhysicsSystem extends System {
                 // their accessors, which this step does not inline either and which return their
                 // numbers boxed.
                 const pose = scratch_refit_pose;
-                pose[0] = collider_transform[TRANSFORM64_TRANSLATION_OFFSET];
-                pose[1] = collider_transform[TRANSFORM64_TRANSLATION_OFFSET + 1];
-                pose[2] = collider_transform[TRANSFORM64_TRANSLATION_OFFSET + 2];
-                pose[3] = collider_transform[TRANSFORM64_ROTATION_OFFSET];
-                pose[4] = collider_transform[TRANSFORM64_ROTATION_OFFSET + 1];
-                pose[5] = collider_transform[TRANSFORM64_ROTATION_OFFSET + 2];
-                pose[6] = collider_transform[TRANSFORM64_ROTATION_OFFSET + 3];
+                t64_read_pose_array(pose, 0, collider_transform);
 
                 aabb3_transform_oriented_array(scratch_world_aabb, 0, scratch_local_aabb, 0, pose, 0);
 
@@ -2600,7 +2559,7 @@ export class PhysicsSystem extends System {
                 // Outward, so the stored leaf still contains this fat box: the
                 // next step's skip test is then exact for a body that has not
                 // moved, as well as conservative for every query in between.
-                aabb3_round_outward_f32(scratch_world_aabb);
+                aabb3_array_round_outward_f32(scratch_world_aabb, 0, scratch_world_aabb, 0);
                 this.dynamicBvh.node_move_aabb(node, scratch_world_aabb);
             }
 

package/src/engine/physics/fluid/ecs/fluid_sample_domain_bounds.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The world-space box a {@link FluidComponent}'s cells occupy, written as `[min_x, min_y, min_z, max_x,
+ * max_y, max_z]` into `out` at `out_offset`.
+ *
+ * Inside it, each velocity component is read from the simulation along its own axis; across the other
+ * two, and for the scalars, the outer half-cell shell already reads the clamped edge cell, since those
+ * live at the cell centres. The box is the cells, not the region free of clamping.
+ *
+ * `origin` is cell `(0,0,0)`'s CENTRE, so the cells run from `origin - cell_size/2` to
+ * `origin + (res - 1/2)·cell_size` on each axis. A point outside this box still gets an answer from
+ * {@link fluid_sample_velocity_world_mps} - the nearest edge's - and a consumer deciding whether a point
+ * is in the field or out in the world beyond it asks this box.
+ *
+ * Not {@link FluidComponent#getBoundingBox}: that box is the splat broad phase, deliberately one more
+ * cell wider on every side so a sub-cell effector near a face is not dropped. It answers "can a source
+ * here write into the field", this answers "does the field describe this point".
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {FluidComponent} component
+ * @returns {void}
+ */
+export function fluid_sample_domain_bounds(out: Float32Array | Float64Array | number[], out_offset: number, component: FluidComponent): void;
+//# sourceMappingURL=fluid_sample_domain_bounds.d.ts.map

package/src/engine/physics/fluid/ecs/fluid_sample_domain_bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_sample_domain_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_sample_domain_bounds.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gDALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,8BAEJ,IAAI,CAqBhB"}

package/src/engine/physics/fluid/ecs/fluid_sample_domain_bounds.js

@@ -0,0 +1,42 @@
+/**
+ * The world-space box a {@link FluidComponent}'s cells occupy, written as `[min_x, min_y, min_z, max_x,
+ * max_y, max_z]` into `out` at `out_offset`.
+ *
+ * Inside it, each velocity component is read from the simulation along its own axis; across the other
+ * two, and for the scalars, the outer half-cell shell already reads the clamped edge cell, since those
+ * live at the cell centres. The box is the cells, not the region free of clamping.
+ *
+ * `origin` is cell `(0,0,0)`'s CENTRE, so the cells run from `origin - cell_size/2` to
+ * `origin + (res - 1/2)·cell_size` on each axis. A point outside this box still gets an answer from
+ * {@link fluid_sample_velocity_world_mps} - the nearest edge's - and a consumer deciding whether a point
+ * is in the field or out in the world beyond it asks this box.
+ *
+ * Not {@link FluidComponent#getBoundingBox}: that box is the splat broad phase, deliberately one more
+ * cell wider on every side so a sub-cell effector near a face is not dropped. It answers "can a source
+ * here write into the field", this answers "does the field describe this point".
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {FluidComponent} component
+ * @returns {void}
+ */
+export function fluid_sample_domain_bounds(out, out_offset, component) {
+    const resolution = component.field.getResolution();
+
+    const cell_size = component.cell_size;
+    const half = cell_size * 0.5;
+
+    const origin = component.origin;
+
+    const ox = origin[0];
+    const oy = origin[1];
+    const oz = origin[2];
+
+    out[out_offset] = ox - half;
+    out[out_offset + 1] = oy - half;
+    out[out_offset + 2] = oz - half;
+
+    out[out_offset + 3] = ox + resolution[0] * cell_size - half;
+    out[out_offset + 4] = oy + resolution[1] * cell_size - half;
+    out[out_offset + 5] = oz + resolution[2] * cell_size - half;
+}

package/src/engine/physics/fluid/ecs/fluid_sample_velocity_world_mps.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Sample a {@link FluidComponent}'s velocity at a world-space point, in **world units per second**,
+ * into `out` at `out_offset`.
+ *
+ * {@link FluidComponent#sampleVelocityAtWorld} answers in grid cells per second and says so: it
+ * leaves the field unscaled for callers that read it as a direction-times-strength wind and want the
+ * same strength at any cell size. A caller that treats the answer as a velocity - a drag that relaxes
+ * toward it, a particle carried by it - needs it multiplied by `cell_size`, or the same wind voxelised
+ * at a quarter of the cell size blows four times as hard. This is that multiply, in one place.
+ *
+ * The point is clamped to the grid exactly as the field's own sample is; see
+ * {@link fluid_sample_domain_bounds} for the box inside which it is not.
+ *
+ * The field must be built.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {FluidComponent} component
+ * @param {number} x world
+ * @param {number} y world
+ * @param {number} z world
+ * @returns {void}
+ */
+export function fluid_sample_velocity_world_mps(out: Float32Array | Float64Array | number[], out_offset: number, component: FluidComponent, x: number, y: number, z: number): void;
+//# sourceMappingURL=fluid_sample_velocity_world_mps.d.ts.map

package/src/engine/physics/fluid/ecs/fluid_sample_velocity_world_mps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_sample_velocity_world_mps.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_sample_velocity_world_mps.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,gCAEN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAUhB"}