@woosh/meep-engine 3.43.0 → 3.45.0

package/src/engine/physics/cloth/solver/constraint/cloth_self_row.d.ts

@@ -56,11 +56,13 @@ export function cloth_self_accumulate(accumulator: Float64Array, state: ClothSta
  *
  * A self-collision row carries nothing of the kind. What it holds apart is cloth
  * against cloth — grams, moving at the speed cloth moves relative to itself — and
- * a penalty at the top of the band produces newtons per millimetre against a
- * load of fractions of a newton. So it is a plain penalty with no multiplier, no
- * warm start and no identity across steps, which is also what makes a pair list
- * that is rebuilt from scratch every step affordable: there is nothing on a pair
- * worth carrying. `MEASUREMENTS.md` §33.
+ * at a quarter of the way up the band the penalty still produces 0.29 N per
+ * millimetre against a particle's weight of 0.2 N: a fold resting on a fold
+ * sinks into it by under a millimetre per particle it carries. So it is a plain
+ * penalty with no multiplier, no warm start and no identity across steps, which
+ * is also what makes a pair list that is rebuilt from scratch every step
+ * affordable: there is nothing on a pair worth carrying. `MEASUREMENTS.md` §33,
+ * and §65 for the stiffness.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_self_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_self_row.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;GAUG;AACH,4EAJW,MAAM,GAEJ,MAAM,CA4FlB;AAED;;;;;;GAMG;AACH,mDAJW,YAAY,+BAEZ,MAAM,QAyBhB;AA7LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;GAKG;AACH,iCAFU,MAAM,CAEuB"}
+{"version":3,"file":"cloth_self_row.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/cloth/solver/constraint/cloth_self_row.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;GAUG;AACH,4EAJW,MAAM,GAEJ,MAAM,CA4FlB;AAED;;;;;;GAMG;AACH,mDAJW,YAAY,+BAEZ,MAAM,QAyBhB;AA/LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH;;;;;GAKG;AACH,iCAFU,MAAM,CAEuB"}

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

@@ -48,11 +48,13 @@ import {
  *
  * A self-collision row carries nothing of the kind. What it holds apart is cloth
  * against cloth — grams, moving at the speed cloth moves relative to itself — and
- * a penalty at the top of the band produces newtons per millimetre against a
- * load of fractions of a newton. So it is a plain penalty with no multiplier, no
- * warm start and no identity across steps, which is also what makes a pair list
- * that is rebuilt from scratch every step affordable: there is nothing on a pair
- * worth carrying. `MEASUREMENTS.md` §33.
+ * at a quarter of the way up the band the penalty still produces 0.29 N per
+ * millimetre against a particle's weight of 0.2 N: a fold resting on a fold
+ * sinks into it by under a millimetre per particle it carries. So it is a plain
+ * penalty with no multiplier, no warm start and no identity across steps, which
+ * is also what makes a pair list that is rebuilt from scratch every step
+ * affordable: there is nothing on a pair worth carrying. `MEASUREMENTS.md` §33,
+ * and §65 for the stiffness.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

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

@@ -43,15 +43,15 @@
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation the cloth frame's world origin
- * @param {Float64Array} anchor_rotation the cloth frame's world rotation, xyzw
+ * @param {Float64Array} frame_translation the cloth frame's world origin
+ * @param {Float64Array} frame_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
  * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
  *   function of — see {@link AbstractClothWind}
  * @returns {boolean} whether the source was sampled per particle
  */
-export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, centre?: Float64Array, time?: number): boolean;
+export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, frame_translation: Float64Array, frame_rotation: Float64Array, centre?: Float64Array, time?: number): boolean;
 /**
  * Whether the air at the cloth's centre has moved far enough since the last step
  * that actually applied it to be worth waking for — §10's "sleep wakes on a wind
@@ -78,8 +78,8 @@ export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anc
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
  * @param {number} time seconds the cloth has stepped — the clock its gust is a
@@ -87,20 +87,22 @@ export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, anc
  *   have, because it has to be asking about the air that step would feel
  * @returns {boolean}
  */
-export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, anchor_translation: Float64Array, anchor_rotation: Float64Array, previous: Float64Array, threshold: number, time: number): boolean;
+export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, frame_translation: Float64Array, frame_rotation: Float64Array, previous: Float64Array, threshold: number, time: number): boolean;
 /**
  * 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} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} out six words, min then max
  * @returns {void}
  */
-export function cloth_air_bounds(state: ClothState, anchor_translation: Float64Array, anchor_rotation: Float64Array, out: Float64Array): void;
+export function cloth_air_bounds(state: ClothState, frame_translation: Float64Array, frame_rotation: Float64Array, out: Float64Array): void;
 //# sourceMappingURL=cloth_sample_air.d.ts.map

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,iGARW,YAAY,mBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAEJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,kGATW,YAAY,mBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;GAaG;AACH,wEALW,YAAY,mBACZ,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";
 
@@ -47,15 +49,15 @@ import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quate
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation the cloth frame's world origin
- * @param {Float64Array} anchor_rotation the cloth frame's world rotation, xyzw
+ * @param {Float64Array} frame_translation the cloth frame's world origin
+ * @param {Float64Array} frame_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
  * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
  *   function of — see {@link AbstractClothWind}
  * @returns {boolean} whether the source was sampled per particle
  */
-export function cloth_sample_air(state, wind, anchor_translation, anchor_rotation, centre = undefined, time = 0) {
+export function cloth_sample_air(state, wind, frame_translation, frame_rotation, centre = undefined, time = 0) {
     const particle_count = state.particle_count;
 
     const air = state.air_velocity;
@@ -66,16 +68,16 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
 
     const position = state.position;
 
-    const anchor_x = anchor_translation[0];
-    const anchor_y = anchor_translation[1];
-    const anchor_z = anchor_translation[2];
+    const frame_x = frame_translation[0];
+    const frame_y = frame_translation[1];
+    const frame_z = frame_translation[2];
 
-    const qx = anchor_rotation[0];
-    const qy = anchor_rotation[1];
-    const qz = anchor_rotation[2];
-    const qw = anchor_rotation[3];
+    const qx = frame_rotation[0];
+    const qy = frame_rotation[1];
+    const qz = frame_rotation[2];
+    const qw = frame_rotation[3];
 
-    cloth_air_bounds(state, anchor_translation, anchor_rotation, BOUNDS);
+    cloth_air_bounds(state, frame_translation, frame_rotation, BOUNDS);
 
     const varies = wind.varies(BOUNDS[0], BOUNDS[1], BOUNDS[2], BOUNDS[3], BOUNDS[4], BOUNDS[5]);
 
@@ -121,7 +123,7 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
 
         v3_quaternion_apply(WORLD, 0, position[p], position[p + 1], position[p + 2], qx, qy, qz, qw);
 
-        wind.sample(SAMPLE, WORLD[0] + anchor_x, WORLD[1] + anchor_y, WORLD[2] + anchor_z, time);
+        wind.sample(SAMPLE, WORLD[0] + frame_x, WORLD[1] + frame_y, WORLD[2] + frame_z, time);
 
         v3_quaternion_apply_inverse(LOCAL, 0, SAMPLE[0], SAMPLE[1], SAMPLE[2], qx, qy, qz, qw);
 
@@ -159,8 +161,8 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
  *
  * @param {ClothState} state
  * @param {AbstractClothWind} wind
- * @param {Float64Array} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
  * @param {number} time seconds the cloth has stepped — the clock its gust is a
@@ -168,12 +170,12 @@ export function cloth_sample_air(state, wind, anchor_translation, anchor_rotatio
  *   have, because it has to be asking about the air that step would feel
  * @returns {boolean}
  */
-export function cloth_air_changed(state, wind, anchor_translation, anchor_rotation, previous, threshold, time) {
+export function cloth_air_changed(state, wind, frame_translation, frame_rotation, previous, threshold, time) {
     if (state.particle_count === 0) {
         return false;
     }
 
-    cloth_air_bounds(state, anchor_translation, anchor_rotation, BOUNDS);
+    cloth_air_bounds(state, frame_translation, frame_rotation, BOUNDS);
 
     wind.sample(
         SAMPLE,
@@ -194,82 +196,44 @@ export function cloth_air_changed(state, wind, anchor_translation, anchor_rotati
  * 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} anchor_translation
- * @param {Float64Array} anchor_rotation
+ * @param {Float64Array} frame_translation
+ * @param {Float64Array} frame_rotation
  * @param {Float64Array} out six words, min then max
  * @returns {void}
  */
-export function cloth_air_bounds(state, anchor_translation, anchor_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; }
+export function cloth_air_bounds(state, frame_translation, frame_rotation, out) {
+    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 = anchor_rotation[0];
-    const qy = anchor_rotation[1];
-    const qz = anchor_rotation[2];
-    const qw = anchor_rotation[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] + anchor_translation[0];
-        const y = WORLD[1] + anchor_translation[1];
-        const z = WORLD[2] + anchor_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; }
-    }
+    aabb3_from_v3_array(LOCAL_BOX, state.position, state.particle_count * 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;
+    // 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];
+
+    aabb3_transform_oriented_array(out, 0, LOCAL_BOX, 0, FRAME_POSE, 0);
 }
 
 /**
@@ -278,6 +242,20 @@ export function cloth_air_bounds(state, anchor_translation, anchor_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":"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"}

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/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#430@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#432@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#430@#clear_field"(fluid: FluidComponent): void;
+    static "__#432@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#430@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#432@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#430@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#432@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];