@woosh/meep-engine 3.37.0 → 3.39.0

package/src/engine/physics/fluid/FluidField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"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"}

package/src/engine/physics/fluid/FluidField.js

@@ -651,7 +651,11 @@ export class FluidField {
      */
     sampleScalar(name, x, y, z) {
         const data = this.getScalarData(name);
-        assert.notNull(data, `scalar attribute '${name}'`);
+
+        // the message is built only when the check fails: as an argument it was a string per call
+        if (data === null) {
+            assert.notNull(data, `scalar attribute '${name}'`);
+        }
         return scs3d_sample_linear(data, this.#resolution[0], this.#resolution[1], this.#resolution[2], x, y, z);
     }
 

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

@@ -32,11 +32,13 @@
  *   - Pose is still read from `Transform64`; velocity is NOT derived from
  *     pose deltas. A teleported body (spawn snap, network correction)
  *     relocates its walls but stamps no velocity — no one-tick air blast.
- *     This mirrors the engine's own contact-solver rule: see
- *     {@link BodyKind}.KinematicPosition, deferred for exactly this reason.
- *     Consequently pose-animated colliders read as stationary walls that
- *     teleport, for air just as for contacts — drive movers through
- *     `BodyKind.KinematicVelocity` (or Dynamic) to displace air.
+ *     This mirrors the engine's own contact-solver rule (see
+ *     {@link BodyKind}.KinematicPosition): a pose written directly is a
+ *     teleport, for air just as for contacts. A mover that should displace
+ *     air needs a velocity — a `BodyKind.KinematicVelocity` body (or a Dynamic
+ *     one), or a `KinematicPosition` body moved by
+ *     `PhysicsSystem.setTargetPose`, whose step derives the velocity that
+ *     reaches the target and leaves it on the body.
  *   - `BodyKind.Static` bodies have zero velocity and stamp nothing.
  *     Sleeping bodies stamp nothing either — the solver zeroes velocities
  *     on sleep.
@@ -64,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#418@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#422@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#418@#clear_field"(fluid: FluidComponent): void;
+    static "__#422@#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
@@ -80,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#418@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#422@#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
@@ -100,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#418@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#422@#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>)[];

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

@@ -1 +1 @@
-{"version":3,"file":"FluidObstacleSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidObstacleSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH;IAuHI;;OAEG;IACH,sCAFW,cAAc,QAIxB;IAED;;OAEG;IACH,oCAFW,cAAc,QAOxB;IAED;;;;;;;;;;OAUG;IACH,iCANW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,QAiDtB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,4CATW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,OACZ,MAAM,OACN,MAAM,OACN,MAAM,QAqEhB;;IAxRD,uCAA+B;IAE/B,6QAOE;;CAgRL;uBAhWsB,wBAAwB;8BAKjB,oBAAoB;4BAJtB,uCAAuC;4CAFvB,uDAAuD;0BAIzE,wBAAwB;yBADzB,uBAAuB;+BAEjB,qBAAqB;6BAPvB,gDAAgD"}
+{"version":3,"file":"FluidObstacleSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidObstacleSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH;IAuHI;;OAEG;IACH,sCAFW,cAAc,QAIxB;IAED;;OAEG;IACH,oCAFW,cAAc,QAOxB;IAED;;;;;;;;;;OAUG;IACH,iCANW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,QAiDtB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,4CATW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,OACZ,MAAM,OACN,MAAM,OACN,MAAM,QAqEhB;;IAxRD,uCAA+B;IAE/B,6QAOE;;CAgRL;uBAlWsB,wBAAwB;8BAKjB,oBAAoB;4BAJtB,uCAAuC;4CAFvB,uDAAuD;0BAIzE,wBAAwB;yBADzB,uBAAuB;+BAEjB,qBAAqB;6BAPvB,gDAAgD"}

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

@@ -42,11 +42,13 @@ import { FluidObstacle } from "./FluidObstacle.js";
  *   - Pose is still read from `Transform64`; velocity is NOT derived from
  *     pose deltas. A teleported body (spawn snap, network correction)
  *     relocates its walls but stamps no velocity — no one-tick air blast.
- *     This mirrors the engine's own contact-solver rule: see
- *     {@link BodyKind}.KinematicPosition, deferred for exactly this reason.
- *     Consequently pose-animated colliders read as stationary walls that
- *     teleport, for air just as for contacts — drive movers through
- *     `BodyKind.KinematicVelocity` (or Dynamic) to displace air.
+ *     This mirrors the engine's own contact-solver rule (see
+ *     {@link BodyKind}.KinematicPosition): a pose written directly is a
+ *     teleport, for air just as for contacts. A mover that should displace
+ *     air needs a velocity — a `BodyKind.KinematicVelocity` body (or a Dynamic
+ *     one), or a `KinematicPosition` body moved by
+ *     `PhysicsSystem.setTargetPose`, whose step derives the velocity that
+ *     reaches the target and leaves it on the body.
  *   - `BodyKind.Static` bodies have zero velocity and stamp nothing.
  *     Sleeping bodies stamp nothing either — the solver zeroes velocities
  *     on sleep.

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

@@ -1 +1 @@
-{"version":3,"file":"fluid_reanchor_field.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_reanchor_field.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8FA0DC"}
+{"version":3,"file":"fluid_reanchor_field.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_reanchor_field.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8FA4DC"}

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

@@ -26,7 +26,9 @@
  */
 export function fluid_reanchor_field(component, transform) {
     const cs = component.cell_size;
-    const p = transform.translation;
+    const px = transform.translation_x;
+    const py = transform.translation_y;
+    const pz = transform.translation_z;
     const offset = component.offset;
     const hyst = component.hysteresis;
 
@@ -40,9 +42,9 @@ export function fluid_reanchor_field(component, transform) {
     if (!component.anchored) {
         // First sync — adopt the freshly-quantized origin without shifting.
         // Subsequent frames will see integer-cs differences and shift instead.
-        const q_x = Math.round(p[0] / cs);
-        const q_y = Math.round(p[1] / cs);
-        const q_z = Math.round(p[2] / cs);
+        const q_x = Math.round(px / cs);
+        const q_y = Math.round(py / cs);
+        const q_z = Math.round(pz / cs);
         origin[0] = q_x * cs + offset[0] - half_extent_x;
         origin[1] = q_y * cs + offset[1] - half_extent_y;
         origin[2] = q_z * cs + offset[2] - half_extent_z;
@@ -59,9 +61,9 @@ export function fluid_reanchor_field(component, transform) {
     const q_curr_z = Math.round((origin[2] + half_extent_z - offset[2]) / cs);
 
     // Raw (fractional) cell coordinate the Transform64 sits at right now.
-    const raw_x = p[0] / cs;
-    const raw_y = p[1] / cs;
-    const raw_z = p[2] / cs;
+    const raw_x = px / cs;
+    const raw_y = py / cs;
+    const raw_z = pz / cs;
 
     // Hysteretic re-quantize: only adopt a new cell when raw has drifted past
     // 0.5 + hyst from the current one. Snap to the new nearest, not the threshold.

package/src/engine/physics/fluid/effector/ImpulseFluidEffector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpulseFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/ImpulseFluidEffector.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;;OAGG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;;OAMG;IACH,QAFU,MAAM,CAEL;CA+Md;sCA7PqC,4BAA4B"}
+{"version":3,"file":"ImpulseFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/ImpulseFluidEffector.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;;OAGG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;;OAMG;IACH,QAFU,MAAM,CAEL;CA8Md;sCA5PqC,4BAA4B"}

package/src/engine/physics/fluid/effector/ImpulseFluidEffector.js

@@ -196,10 +196,9 @@ export class ImpulseFluidEffector extends AbstractFluidEffector {
      * @param {Transform64} transform
      */
     syncFromTransform(transform) {
-        const p = transform.translation;
-        this.position[0] = p[0];
-        this.position[1] = p[1];
-        this.position[2] = p[2];
+        this.position[0] = transform.translation_x;
+        this.position[1] = transform.translation_y;
+        this.position[2] = transform.translation_z;
     }
 
     /**

package/src/engine/physics/fluid/effector/WakeFluidEffector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WakeFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/WakeFluidEffector.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAEI;;;;;OAKG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,mBAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEJ;IAE9B;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAoBb;;;;;OAKG;IACH,oBAKC;;CA8RJ;sCAjZqC,4BAA4B"}
+{"version":3,"file":"WakeFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/WakeFluidEffector.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAEI;;;;;OAKG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,mBAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEJ;IAE9B;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAoBb;;;;;OAKG;IACH,oBAKC;;CAgSJ;sCAnZqC,4BAA4B"}

package/src/engine/physics/fluid/effector/WakeFluidEffector.js

@@ -132,20 +132,22 @@ export class WakeFluidEffector extends AbstractFluidEffector {
      * @param {Transform64} transform
      */
     syncFromTransform(transform) {
-        const p = transform.translation;
+        const px = transform.translation_x;
+        const py = transform.translation_y;
+        const pz = transform.translation_z;
         this.#transform_managed = true;
         if (this.#initialized) {
             this.previous_position[0] = this.position[0];
             this.previous_position[1] = this.position[1];
             this.previous_position[2] = this.position[2];
         }
-        this.position[0] = p[0];
-        this.position[1] = p[1];
-        this.position[2] = p[2];
+        this.position[0] = px;
+        this.position[1] = py;
+        this.position[2] = pz;
         if (!this.#initialized) {
-            this.previous_position[0] = p[0];
-            this.previous_position[1] = p[1];
-            this.previous_position[2] = p[2];
+            this.previous_position[0] = px;
+            this.previous_position[1] = py;
+            this.previous_position[2] = pz;
             this.#initialized = true;
         }
     }

package/src/engine/physics/fluid/solver/v3_mac_advect_maccormack_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_mac_advect_maccormack_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_maccormack_velocity.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,2DAbW,YAAY,EAAE,WACd,YAAY,EAAE,WACd,YAAY,EAAE,mBACd,YAAY,EAAE,SACd,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,gBACN,UAAU,gBACV,UAAU,gBACV,UAAU,SACV,UAAU,QA0MpB"}
+{"version":3,"file":"v3_mac_advect_maccormack_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_maccormack_velocity.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,2DAbW,YAAY,EAAE,WACd,YAAY,EAAE,WACd,YAAY,EAAE,mBACd,YAAY,EAAE,SACd,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,gBACN,UAAU,gBACV,UAAU,gBACV,UAAU,SACV,UAAU,QAwNpB"}

package/src/engine/physics/fluid/solver/v3_mac_advect_maccormack_velocity.js

@@ -1,11 +1,21 @@
 import { v3_grid_limit8_at_indices } from "./v3_grid_limit8_at_indices.js";
 import { assert } from "../../../../core/assert.js";
 import { clamp } from "../../../../core/math/clamp.js";
-import { scs3d_sample_linear } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
+import { scs3d_sample_linear_array } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
 import { v3_mac_clip_trace } from "./v3_mac_clip_trace.js";
 
 const scratch_clip = new Float32Array(3);
 
+/**
+ * Positions and values crossing calls, in arrays: a trace's end (`scratch_at`), the backward sample
+ * and the corrected value. The kernel's six samples, six solid tests and three limiter calls per face
+ * are more than it can inline, and a call that is not inlined boxes each number passed to it or
+ * returned, about nine per face.
+ */
+const scratch_at = new Float64Array(3);
+const scratch_backward = new Float64Array(1);
+const scratch_corrected = new Float64Array(1);
+
 /**
  * Straight-line (loop-free, inlinable) test: is the cell containing the
  * point solid? Same rounding/clamping as v3_mac_clip_trace. Kernels use this
@@ -16,15 +26,13 @@ const scratch_clip = new Float32Array(3);
  * @param {number} res_x
  * @param {number} res_y
  * @param {number} res_z
- * @param {number} px
- * @param {number} py
- * @param {number} pz
+ * @param {Float64Array} point `[x, y, z]`, in cell index space
  * @return {boolean}
  */
-function end_in_solid(solid, res_x, res_y, res_z, px, py, pz) {
-    let x = (px + 0.5) | 0;
-    let y = (py + 0.5) | 0;
-    let z = (pz + 0.5) | 0;
+function end_in_solid(solid, res_x, res_y, res_z, point) {
+    let x = (point[0] + 0.5) | 0;
+    let y = (point[1] + 0.5) | 0;
+    let z = (point[2] + 0.5) | 0;
     if (x < 0) x = 0; else if (x >= res_x) x = res_x - 1;
     if (y < 0) y = 0; else if (y >= res_y) y = res_y - 1;
     if (z < 0) z = 0; else if (z >= res_z) z = res_z - 1;
@@ -97,6 +105,8 @@ export function v3_mac_advect_maccormack_velocity(outputs, sources, carrier, for
     const last_cy = res_y - 1;
     const last_cz = res_z - 1;
     const dt = time_delta;
+    const at = scratch_at;
+    const corrected = scratch_corrected;
 
     // ─── u (x-faces): face (x,y,z) sits at (x − 0.5, y, z) ──────────────────
     for (let pass = 0; pass < 2; pass++) {
@@ -128,13 +138,15 @@ export function v3_mac_advect_maccormack_velocity(outputs, sources, carrier, for
                     let bx = px - cu * dt;
                     let by = y - cv * dt;
                     let bz = z - cw * dt;
-                    if (end_in_solid(solid, res_x, res_y, res_z, bx, by, bz)) {
+                    at[0] = bx; at[1] = by; at[2] = bz;
+                    if (end_in_solid(solid, res_x, res_y, res_z, at)) {
                         v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z, px, y, z, bx, by, bz);
                         bx = scratch_clip[0]; by = scratch_clip[1]; bz = scratch_clip[2];
                     }
 
                     if (pass === 0) {
-                        fwd_u[f] = scs3d_sample_linear(src_u, sx, res_y, res_z, bx + 0.5, by, bz);
+                        at[0] = bx + 0.5; at[1] = by; at[2] = bz;
+                        scs3d_sample_linear_array(fwd_u, f, src_u, sx, res_y, res_z, at, 0);
                         continue;
                     }
 
@@ -142,15 +154,17 @@ export function v3_mac_advect_maccormack_velocity(outputs, sources, carrier, for
                     let qx = px + cu * dt;
                     let qy = y + cv * dt;
                     let qz = z + cw * dt;
-                    if (end_in_solid(solid, res_x, res_y, res_z, qx, qy, qz)) {
+                    at[0] = qx; at[1] = qy; at[2] = qz;
+                    if (end_in_solid(solid, res_x, res_y, res_z, at)) {
                         v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z, px, y, z, qx, qy, qz);
                         qx = scratch_clip[0]; qy = scratch_clip[1]; qz = scratch_clip[2];
                     }
-                    const backward = scs3d_sample_linear(fwd_u, sx, res_y, res_z, qx + 0.5, qy, qz);
-                    const corrected = fwd_u[f] + 0.5 * (src_u[f] - backward);
+                    at[0] = qx + 0.5; at[1] = qy; at[2] = qz;
+                    scs3d_sample_linear_array(scratch_backward, 0, fwd_u, sx, res_y, res_z, at, 0);
+                    corrected[0] = fwd_u[f] + 0.5 * (src_u[f] - scratch_backward[0]);
 
-                    out_u[f] = limit8_at_position(corrected, src_u,
-                        bx + 0.5, by, bz,
+                    at[0] = bx + 0.5; at[1] = by; at[2] = bz;
+                    limit8_at_position(out_u, f, corrected, src_u, at,
                         sx, res_y, res_z, sx, u_slice);
                 }
             }
@@ -186,28 +200,32 @@ export function v3_mac_advect_maccormack_velocity(outputs, sources, carrier, for
                     let bx = x - cu * dt;
                     let by = py - cv * dt;
                     let bz = z - cw * dt;
-                    if (end_in_solid(solid, res_x, res_y, res_z, bx, by, bz)) {
+                    at[0] = bx; at[1] = by; at[2] = bz;
+                    if (end_in_solid(solid, res_x, res_y, res_z, at)) {
                         v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z, x, py, z, bx, by, bz);
                         bx = scratch_clip[0]; by = scratch_clip[1]; bz = scratch_clip[2];
                     }
 
                     if (pass === 0) {
-                        fwd_v[f] = scs3d_sample_linear(src_v, res_x, sy, res_z, bx, by + 0.5, bz);
+                        at[0] = bx; at[1] = by + 0.5; at[2] = bz;
+                        scs3d_sample_linear_array(fwd_v, f, src_v, res_x, sy, res_z, at, 0);
                         continue;
                     }
 
                     let qx = x + cu * dt;
                     let qy = py + cv * dt;
                     let qz = z + cw * dt;
-                    if (end_in_solid(solid, res_x, res_y, res_z, qx, qy, qz)) {
+                    at[0] = qx; at[1] = qy; at[2] = qz;
+                    if (end_in_solid(solid, res_x, res_y, res_z, at)) {
                         v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z, x, py, z, qx, qy, qz);
                         qx = scratch_clip[0]; qy = scratch_clip[1]; qz = scratch_clip[2];
                     }
-                    const backward = scs3d_sample_linear(fwd_v, res_x, sy, res_z, qx, qy + 0.5, qz);
-                    const corrected = fwd_v[f] + 0.5 * (src_v[f] - backward);
+                    at[0] = qx; at[1] = qy + 0.5; at[2] = qz;
+                    scs3d_sample_linear_array(scratch_backward, 0, fwd_v, res_x, sy, res_z, at, 0);
+                    corrected[0] = fwd_v[f] + 0.5 * (src_v[f] - scratch_backward[0]);
 
-                    out_v[f] = limit8_at_position(corrected, src_v,
-                        bx, by + 0.5, bz,
+                    at[0] = bx; at[1] = by + 0.5; at[2] = bz;
+                    limit8_at_position(out_v, f, corrected, src_v, at,
                         res_x, sy, res_z, res_x, v_slice);
                 }
             }
@@ -245,28 +263,32 @@ export function v3_mac_advect_maccormack_velocity(outputs, sources, carrier, for
                     let bx = x - cu * dt;
                     let by = y - cv * dt;
                     let bz = pz - cw * dt;
-                    if (end_in_solid(solid, res_x, res_y, res_z, bx, by, bz)) {
+                    at[0] = bx; at[1] = by; at[2] = bz;
+                    if (end_in_solid(solid, res_x, res_y, res_z, at)) {
                         v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z, x, y, pz, bx, by, bz);
                         bx = scratch_clip[0]; by = scratch_clip[1]; bz = scratch_clip[2];
                     }
 
                     if (pass === 0) {
-                        fwd_w[f] = scs3d_sample_linear(src_w, res_x, res_y, sz, bx, by, bz + 0.5);
+                        at[0] = bx; at[1] = by; at[2] = bz + 0.5;
+                        scs3d_sample_linear_array(fwd_w, f, src_w, res_x, res_y, sz, at, 0);
                         continue;
                     }
 
                     let qx = x + cu * dt;
                     let qy = y + cv * dt;
                     let qz = pz + cw * dt;
-                    if (end_in_solid(solid, res_x, res_y, res_z, qx, qy, qz)) {
+                    at[0] = qx; at[1] = qy; at[2] = qz;
+                    if (end_in_solid(solid, res_x, res_y, res_z, at)) {
                         v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z, x, y, pz, qx, qy, qz);
                         qx = scratch_clip[0]; qy = scratch_clip[1]; qz = scratch_clip[2];
                     }
-                    const backward = scs3d_sample_linear(fwd_w, res_x, res_y, sz, qx, qy, qz + 0.5);
-                    const corrected = fwd_w[f] + 0.5 * (src_w[f] - backward);
+                    at[0] = qx; at[1] = qy; at[2] = qz + 0.5;
+                    scs3d_sample_linear_array(scratch_backward, 0, fwd_w, res_x, res_y, sz, at, 0);
+                    corrected[0] = fwd_w[f] + 0.5 * (src_w[f] - scratch_backward[0]);
 
-                    out_w[f] = limit8_at_position(corrected, src_w,
-                        bx, by, bz + 0.5,
+                    at[0] = bx; at[1] = by; at[2] = bz + 0.5;
+                    limit8_at_position(out_w, f, corrected, src_w, at,
                         res_x, res_y, sz, res_x, cell_slice);
                 }
             }
@@ -275,26 +297,26 @@ export function v3_mac_advect_maccormack_velocity(outputs, sources, carrier, for
 }
 
 /**
- * Clamp `value` to the min/max of the 8 lattice taps around the fractional
- * position `(lx, ly, lz)` in the lattice's own index space (clamped to its
- * bounds — the same corner set the trilinear sampler interpolates from).
+ * Clamp `value[0]` to the min/max of the 8 lattice taps around the fractional
+ * position `position` in the lattice's own index space (clamped to its
+ * bounds — the same corner set the trilinear sampler interpolates from), into
+ * `out[out_offset]`.
  *
- * @param {number} value
+ * @param {Float32Array} out
+ * @param {number} out_offset
+ * @param {Float64Array} value the candidate value, at 0
  * @param {Float32Array} data
- * @param {number} lx
- * @param {number} ly
- * @param {number} lz
+ * @param {Float64Array} position `[x, y, z]`
  * @param {number} dim_x
  * @param {number} dim_y
  * @param {number} dim_z
  * @param {number} row    lattice row stride
  * @param {number} slice  lattice slice stride
- * @return {number}
  */
-function limit8_at_position(value, data, lx, ly, lz, dim_x, dim_y, dim_z, row, slice) {
-    const bx = clamp(lx, 0, dim_x - 1);
-    const by = clamp(ly, 0, dim_y - 1);
-    const bz = clamp(lz, 0, dim_z - 1);
+function limit8_at_position(out, out_offset, value, data, position, dim_x, dim_y, dim_z, row, slice) {
+    const bx = clamp(position[0], 0, dim_x - 1);
+    const by = clamp(position[1], 0, dim_y - 1);
+    const bz = clamp(position[2], 0, dim_z - 1);
     const x0 = bx | 0;
     const y0 = by | 0;
     const z0 = bz | 0;
@@ -307,8 +329,8 @@ function limit8_at_position(value, data, lx, ly, lz, dim_x, dim_y, dim_z, row, s
     const y0_off = y0 * row;
     const y1_off = y1 * row;
 
-    return v3_grid_limit8_at_indices(
-        value, data,
+    out[out_offset] = v3_grid_limit8_at_indices(
+        value[0], data,
         z0_off + y0_off + x0, z0_off + y0_off + x1,
         z0_off + y1_off + x0, z0_off + y1_off + x1,
         z1_off + y0_off + x0, z1_off + y0_off + x1,

package/src/engine/physics/inertia/MASS_PROPERTIES_SIZE.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Doubles in a mass-properties record: the mass, centre of mass and inertia tensor of a solid, as
+ * written by the shape functions ({@link sphere_mass_properties}, {@link box_mass_properties},
+ * {@link capsule_mass_properties}, {@link cylinder_mass_properties},
+ * {@link convex_hull_mass_properties}), combined by {@link mass_properties_accumulate} and applied
+ * to a body by {@link rigid_body_set_mass_properties}. Records are caller-owned, typically a
+ * `Float64Array` of this length; one of all zeros is the empty solid, the starting point of an
+ * accumulation.
+ *
+ * Layout, in the frame the record is expressed in (a shape's own frame for a shape, the body's
+ * frame for an accumulated compound):
+ *
+ *   [0]      mass, kg
+ *   [1..3]   centre of mass, x y z
+ *   [4..6]   moments of inertia about the centre of mass: Ixx, Iyy, Izz, kg·m²
+ *   [7..9]   the tensor's off-diagonal entries about the centre of mass: Ixy, Ixz, Iyz. These are
+ *            the entries of the tensor itself, so each is MINUS the product of inertia:
+ *            Ixy = -∫(x - cx)(y - cy) dm.
+ *
+ * @type {number}
+ */
+export const MASS_PROPERTIES_SIZE: number;
+//# sourceMappingURL=MASS_PROPERTIES_SIZE.d.ts.map

package/src/engine/physics/inertia/MASS_PROPERTIES_SIZE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MASS_PROPERTIES_SIZE.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/inertia/MASS_PROPERTIES_SIZE.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mCAFU,MAAM,CAEuB"}

package/src/engine/physics/inertia/MASS_PROPERTIES_SIZE.js

@@ -0,0 +1,22 @@
+/**
+ * Doubles in a mass-properties record: the mass, centre of mass and inertia tensor of a solid, as
+ * written by the shape functions ({@link sphere_mass_properties}, {@link box_mass_properties},
+ * {@link capsule_mass_properties}, {@link cylinder_mass_properties},
+ * {@link convex_hull_mass_properties}), combined by {@link mass_properties_accumulate} and applied
+ * to a body by {@link rigid_body_set_mass_properties}. Records are caller-owned, typically a
+ * `Float64Array` of this length; one of all zeros is the empty solid, the starting point of an
+ * accumulation.
+ *
+ * Layout, in the frame the record is expressed in (a shape's own frame for a shape, the body's
+ * frame for an accumulated compound):
+ *
+ *   [0]      mass, kg
+ *   [1..3]   centre of mass, x y z
+ *   [4..6]   moments of inertia about the centre of mass: Ixx, Iyy, Izz, kg·m²
+ *   [7..9]   the tensor's off-diagonal entries about the centre of mass: Ixy, Ixz, Iyz. These are
+ *            the entries of the tensor itself, so each is MINUS the product of inertia:
+ *            Ixy = -∫(x - cx)(y - cy) dm.
+ *
+ * @type {number}
+ */
+export const MASS_PROPERTIES_SIZE = 10;

package/src/engine/physics/inertia/convex_hull_mass_properties.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Mass properties of a solid convex hull, in its own frame (see {@link MASS_PROPERTIES_SIZE}).
+ *
+ * The solid is cut into one tetrahedron per surface triangle, each fanned from a common reference
+ * point: the hull's first vertex. Over a closed, outward-wound surface the signed tetrahedra sum
+ * to the solid whatever point they share, so the point is chosen for round-off — on the hull, the
+ * coordinates entering the products stay on the scale of the hull rather than of its distance
+ * from the frame's origin. For a tetrahedron with a vertex at the reference and the others at
+ * v1, v2, v3 (relative), with D = v1 · (v2 × v3) six times its signed volume and v4 = v1 + v2 + v3:
+ *
+ *   volume  D / 6,   centroid  v4 / 4,   ∫ x_i x_j dV = D / 120 · (Σ_k v_k,i · v_k,j over v1..v4)
+ *
+ * The second moments about the reference are then moved to the centre of mass by the parallel
+ * axis theorem. The construction is Box3D's hull mass (hull.c, `b3ComputeHullMass` and the hull
+ * builder's inertia pass; MIT, Erin Catto), applied to the hull's triangles.
+ *
+ * The vertices are read as stored (`Float32Array`) and every product is formed in float64.
+ *
+ * A hull with no volume (flat, or no triangles) is the empty solid: all zeros. A hull wound inward
+ * sums to minus its volume and is refused (dev assert); with asserts stripped it too reads as all
+ * zeros.
+ *
+ * @param {Float64Array|number[]} out receives {@link MASS_PROPERTIES_SIZE} doubles
+ * @param {import("../../../core/geom/3d/shape/ConvexHullShape3D.js").ConvexHullShape3D} shape a
+ *   closed, outward-CCW hull, as {@link ConvexHullShape3D.from} builds
+ * @param {number} density kg/m³
+ */
+export function convex_hull_mass_properties(out: Float64Array | number[], shape: import("../../../core/geom/3d/shape/ConvexHullShape3D.js").ConvexHullShape3D, density: number): void;
+//# sourceMappingURL=convex_hull_mass_properties.d.ts.map

package/src/engine/physics/inertia/convex_hull_mass_properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convex_hull_mass_properties.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/inertia/convex_hull_mass_properties.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iDALW,YAAY,GAAC,MAAM,EAAE,SACrB,OAAO,kDAAkD,EAAE,iBAAiB,WAE5E,MAAM,QAkFhB"}