@woosh/meep-engine 3.43.0 → 3.45.0

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"}

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

@@ -0,0 +1,40 @@
+/**
+ * Scratch for the field's own answer, in cells per second. Module-level: the
+ * sample allocates nothing.
+ * @type {Float64Array}
+ * @private
+ */
+const CELLS_PER_SECOND = new Float64Array(3);
+
+/**
+ * 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, out_offset, component, x, y, z) {
+    component.sampleVelocityAtWorld(CELLS_PER_SECOND, x, y, z);
+
+    const cell_size = component.cell_size;
+
+    out[out_offset] = CELLS_PER_SECOND[0] * cell_size;
+    out[out_offset + 1] = CELLS_PER_SECOND[1] * cell_size;
+    out[out_offset + 2] = CELLS_PER_SECOND[2] * cell_size;
+}

package/src/engine/physics/inverse_kinematics/frame_fabrik/frame_fabrik_solve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frame_fabrik_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/frame_fabrik/frame_fabrik_solve.js"],"names":[],"mappings":"AAqtBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,gFAJW,MAAM,aACN,MAAM,GACJ,MAAM,CA4DlB"}
+{"version":3,"file":"frame_fabrik_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/frame_fabrik/frame_fabrik_solve.js"],"names":[],"mappings":"AAmqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,gFAJW,MAAM,aACN,MAAM,GACJ,MAAM,CA4DlB"}

package/src/engine/physics/inverse_kinematics/frame_fabrik/frame_fabrik_solve.js

@@ -1,5 +1,13 @@
 import { assert } from "../../../../core/assert.js";
+import { pose3_apply_inverse_point_array } from "../../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
+import { pose3_apply_point_array } from "../../../../core/geom/3d/pose/pose3_apply_point_array.js";
 import { quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import {
+    quat3_multiply_conjugate_left_array
+} from "../../../../core/geom/3d/quaternion/quat3_multiply_conjugate_left_array.js";
+import {
+    quat3_multiply_conjugate_right_array
+} from "../../../../core/geom/3d/quaternion/quat3_multiply_conjugate_right_array.js";
 import { quat3_shortest_arc } from "../../../../core/geom/3d/quaternion/quat3_shortest_arc.js";
 import { swing_twist_clamp_array } from "../../../../core/geom/3d/quaternion/swing_twist_clamp.js";
 import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
@@ -235,14 +243,7 @@ function limit_rotation(problem, i) {
 
     if (parent < 0) {
         // the parent's fixed frame: R_i = above * L_i, as animated
-        const local = problem.base_local_rotation;
-
-        turn[0] = -local[i4];
-        turn[1] = -local[i4 + 1];
-        turn[2] = -local[i4 + 2];
-        turn[3] = local[i4 + 3];
-
-        quat3_multiply_array(above, 0, problem.base_rotation, i4, turn, 0);
+        quat3_multiply_conjugate_right_array(above, 0, problem.base_rotation, i4, problem.base_local_rotation, i4);
     } else {
         const p4 = parent * 4;
 
@@ -253,20 +254,9 @@ function limit_rotation(problem, i) {
     }
 
     // relative = conj(basis_a) * conj(above) * R_i * basis_b
-    turn[0] = -above[0];
-    turn[1] = -above[1];
-    turn[2] = -above[2];
-    turn[3] = above[3];
-
-    quat3_multiply_array(relative, 0, turn, 0, rotation, i4);
+    quat3_multiply_conjugate_left_array(relative, 0, above, 0, rotation, i4);
     quat3_multiply_array(relative, 0, relative, 0, basis_b, i4);
-
-    turn[0] = -basis_a[i4];
-    turn[1] = -basis_a[i4 + 1];
-    turn[2] = -basis_a[i4 + 2];
-    turn[3] = basis_a[i4 + 3];
-
-    quat3_multiply_array(relative, 0, turn, 0, relative, 0);
+    quat3_multiply_conjugate_left_array(relative, 0, basis_a, i4, relative, 0);
 
     if (!swing_twist_clamp_array(relative, 0, relative, 0, problem.limit_lower, problem.limit_upper, i * 3)) {
         return;
@@ -274,13 +264,7 @@ function limit_rotation(problem, i) {
 
     // R_i = above * basis_a * relative * conj(basis_b)
     quat3_multiply_array(relative, 0, basis_a, i4, relative, 0);
-
-    turn[0] = -basis_b[i4];
-    turn[1] = -basis_b[i4 + 1];
-    turn[2] = -basis_b[i4 + 2];
-    turn[3] = basis_b[i4 + 3];
-
-    quat3_multiply_array(relative, 0, relative, 0, turn, 0);
+    quat3_multiply_conjugate_right_array(relative, 0, relative, 0, basis_b, i4);
 
     quat3_multiply_array(rotation, i4, above, 0, relative, 0);
 }
@@ -361,17 +345,8 @@ function prepare(problem) {
         const p3 = p * 3;
         const p4 = p * 4;
 
-        // conj(parent) applied to the world offset
-        v3[0] = base_position[i3] - base_position[p3];
-        v3[1] = base_position[i3 + 1] - base_position[p3 + 1];
-        v3[2] = base_position[i3 + 2] - base_position[p3 + 2];
-
-        turn[0] = -base_rotation[p4];
-        turn[1] = -base_rotation[p4 + 1];
-        turn[2] = -base_rotation[p4 + 2];
-        turn[3] = base_rotation[p4 + 3];
-
-        v3_quaternion_apply_array(offset, i3, v3, 0, turn, 0);
+        // the joint's position in its parent's frame
+        pose3_apply_inverse_point_array(offset, i3, base_position, p3, base_rotation, p4, base_position, i3);
     }
 
     // children, compressed: counted one slot up, summed into starts, filled with the start as a
@@ -465,65 +440,29 @@ function prepare(problem) {
 
         problem._goal_anchor[g] = anchor;
 
+        // both in the frame of their joint as animated: conj(R_j) (point - P_j)
         if (anchor >= 0) {
-            to_frame(problem._goal_anchor_offset, g * 3, base_position, effector * 3, base_position, base_rotation, anchor);
+            pose3_apply_inverse_point_array(
+                problem._goal_anchor_offset, g * 3,
+                base_position, anchor * 3,
+                base_rotation, anchor * 4,
+                base_position, effector * 3
+            );
         }
 
         const target_joint = problem.goal_target_joint[g];
 
         if (target_joint >= 0) {
-            to_frame(problem._goal_target_local, g * 3, problem.goal_target, g * 3, base_position, base_rotation, target_joint);
+            pose3_apply_inverse_point_array(
+                problem._goal_target_local, g * 3,
+                base_position, target_joint * 3,
+                base_rotation, target_joint * 4,
+                problem.goal_target, g * 3
+            );
         }
     }
 }
 
-/**
- * `out = conj(R_j) (point - P_j)` with the frame of joint `j` as animated.
- *
- * @param {Float64Array} out
- * @param {number} out_offset
- * @param {Float64Array} point
- * @param {number} point_offset
- * @param {Float64Array} base_position
- * @param {Float64Array} base_rotation
- * @param {number} j
- */
-function to_frame(out, out_offset, point, point_offset, base_position, base_rotation, j) {
-    const j3 = j * 3;
-    const j4 = j * 4;
-
-    v3[0] = point[point_offset] - base_position[j3];
-    v3[1] = point[point_offset + 1] - base_position[j3 + 1];
-    v3[2] = point[point_offset + 2] - base_position[j3 + 2];
-
-    turn[0] = -base_rotation[j4];
-    turn[1] = -base_rotation[j4 + 1];
-    turn[2] = -base_rotation[j4 + 2];
-    turn[3] = base_rotation[j4 + 3];
-
-    v3_quaternion_apply_array(out, out_offset, v3, 0, turn, 0);
-}
-
-/**
- * `out = P_j + R_j local` with the frame of joint `j` as solved so far.
- *
- * @param {Float64Array} out
- * @param {number} out_offset
- * @param {FrameFabrikProblem} problem
- * @param {Float64Array} local
- * @param {number} local_offset
- * @param {number} j
- */
-function from_frame(out, out_offset, problem, local, local_offset, j) {
-    const j3 = j * 3;
-
-    v3_quaternion_apply_array(v3, 0, local, local_offset, problem.solved_rotation, j * 4);
-
-    out[out_offset] = problem.solved_position[j3] + v3[0];
-    out[out_offset + 1] = problem.solved_position[j3 + 1] + v3[1];
-    out[out_offset + 2] = problem.solved_position[j3 + 2] + v3[2];
-}
-
 /**
  * This iteration's target for every effector: `lerp(carried, goal, w)`.
  *
@@ -551,7 +490,13 @@ function load_targets(problem) {
             cy = problem.base_position[e3 + 1];
             cz = problem.base_position[e3 + 2];
         } else {
-            from_frame(target, g3, problem, problem._goal_anchor_offset, g3, anchor);
+            // out of the anchor's frame as solved so far: P_j + R_j local
+            pose3_apply_point_array(
+                target, g3,
+                problem.solved_position, anchor * 3,
+                problem.solved_rotation, anchor * 4,
+                problem._goal_anchor_offset, g3
+            );
 
             cx = target[g3];
             cy = target[g3 + 1];
@@ -567,7 +512,12 @@ function load_targets(problem) {
             gy = problem.goal_target[g3 + 1];
             gz = problem.goal_target[g3 + 2];
         } else {
-            from_frame(target, g3, problem, problem._goal_target_local, g3, target_joint);
+            pose3_apply_point_array(
+                target, g3,
+                problem.solved_position, target_joint * 3,
+                problem.solved_rotation, target_joint * 4,
+                problem._goal_target_local, g3
+            );
 
             gx = target[g3];
             gy = target[g3 + 1];

package/src/engine/physics/narrowphase/capsule_contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAMhB;AAED;;;;;;GAMG;AACH,iDAJW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,QAehB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CAYnB;AAED;;;;;;;;;GASG;AACH,kDAPW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAYnB;AAED;;;;;;;;;GASG;AACH,mDAPW,MAAM,EAAE,GAAC,YAAY,aACrB,YAAY,oBACZ,MAAM,aACN,YAAY,oBACZ,MAAM,GACJ,OAAO,CAmEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAYlB;AAED;;;;;;;;;GASG;AACH,0DAPW,MAAM,EAAE,GAAC,YAAY,aACrB,YAAY,oBACZ,MAAM,aACN,YAAY,oBACZ,MAAM,GACJ,MAAM,CAsHlB;AAeD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CAYnB;AAsBD;;;;;;;;;GASG;AACH,+CAPW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CAoGnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAYlB;AAKD;;;;;;;;;GASG;AACH,sDAPW,YAAY,WACZ,YAAY,kBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA4DlB;AA/fD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AA6U9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}
+{"version":3,"file":"capsule_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/capsule_contacts.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;GAeG;AACH,2CAVW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,eACN,MAAM,QAMhB;AAED;;;;;;GAMG;AACH,iDAJW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,QAehB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAhBW,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,GACJ,OAAO,CAYnB;AAED;;;;;;;;;GASG;AACH,kDAPW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,OAAO,CA6CnB;AAMD;;;;;GAKG;AACH,6CAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,OAAO,CAYnB;AAED;;;;;;;;;GASG;AACH,mDAPW,MAAM,EAAE,GAAC,YAAY,aACrB,YAAY,oBACZ,MAAM,aACN,YAAY,oBACZ,MAAM,GACJ,OAAO,CAmEnB;AA8BD;;;;;;;;;GASG;AACH,oDAHW,MAAM,EAAE,GAAC,YAAY,yNACnB,MAAM,CAYlB;AAED;;;;;;;;;GASG;AACH,0DAPW,MAAM,EAAE,GAAC,YAAY,aACrB,YAAY,oBACZ,MAAM,aACN,YAAY,oBACZ,MAAM,GACJ,MAAM,CAsHlB;AAeD;;;;;;;;;;;;;GAaG;AACH,yCAHW,MAAM,EAAE,GAAC,YAAY,4NACnB,OAAO,CAYnB;AAsBD;;;;;;;;;GASG;AACH,+CAPW,MAAM,EAAE,GAAC,YAAY,WACrB,YAAY,kBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CAkGnB;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,gDAtBW,YAAY,QACZ,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,YACN,MAAM,YACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,MAAM,CAYlB;AAKD;;;;;;;;;GASG;AACH,sDAPW,YAAY,WACZ,YAAY,kBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA4DlB;AA7fD;;;;;;;;GAQG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,2CAFU,MAAM,CAE8B;AA2U9C;;;;;;;;;;GAUG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;GAKG;AACH,uCAFU,MAAM,CAE0B"}

package/src/engine/physics/narrowphase/capsule_contacts.js

@@ -4,7 +4,7 @@ import { line3_compute_segment_segment_closest_points } from "../../../core/geom
 import { line3_compute_segment_closest_point_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
 import { line3_compute_segment_closest_point_to_aabb3_t_array } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js";
 import { v3_quaternion_apply_array } from "../../../core/geom/vec3/v3_quaternion_apply.js";
-import { v3_quaternion_apply_inverse_array } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { pose3_apply_inverse_point_array } from "../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
 import { sphere_box_contact_array } from "./sphere_box_contact.js";
 
 /**
@@ -554,10 +554,8 @@ export function capsule_box_contact_array(out, capsule, capsule_offset, box, box
     capsule_world_segment_array(scratch_seg, capsule, capsule_offset);
     // World → box-local: subtract box centre, then rotate by conjugate of box quat.
     const local = scratch_seg_local;
-    local[0] = scratch_seg[0] - b_cx; local[1] = scratch_seg[1] - b_cy; local[2] = scratch_seg[2] - b_cz;
-    local[3] = scratch_seg[3] - b_cx; local[4] = scratch_seg[4] - b_cy; local[5] = scratch_seg[5] - b_cz;
-    v3_quaternion_apply_inverse_array(local, 0, local, 0, box, rotation);
-    v3_quaternion_apply_inverse_array(local, 3, local, 3, box, rotation);
+    pose3_apply_inverse_point_array(local, 0, box, box_offset, box, rotation, scratch_seg, 0);
+    pose3_apply_inverse_point_array(local, 3, box, box_offset, box, rotation, scratch_seg, 3);
 
     const a0lx = local[0], a0ly = local[1], a0lz = local[2];
     const a1lx = local[3], a1ly = local[4], a1lz = local[5];

package/src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh_enumerate_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.js"],"names":[],"mappings":"AAyFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,iDAXW,YAAY,UACZ,MAAM,kCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAalB;AAKD;;;;;;;;;;;GAWG;AACH,uDAPW,YAAY,UACZ,MAAM,4BAEN,YAAY,eACZ,MAAM,GACJ,MAAM,CAqElB"}
+{"version":3,"file":"mesh_enumerate_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,iDAXW,YAAY,UACZ,MAAM,kCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,MAAM,CAalB;AAKD;;;;;;;;;;;GAWG;AACH,uDAPW,YAAY,UACZ,MAAM,4BAEN,YAAY,eACZ,MAAM,GACJ,MAAM,CAqElB"}

package/src/engine/physics/narrowphase/decomposition/mesh_enumerate_triangles.js

@@ -1,4 +1,5 @@
 import { COLUMN_CHILD_1, COLUMN_CHILD_2, COLUMN_USER_DATA, ELEMENT_WORD_COUNT, NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
+import { array_sort_insertion_ascending } from "../../../../core/collection/array/array_sort_insertion_ascending.js";
 import { TRIANGLE_FEATURE_ID_OFFSET, TRIANGLE_FLOAT_STRIDE } from "./triangle_buffer_layout.js";
 
 /**
@@ -359,18 +360,5 @@ function sort_found_triangles(count, max_value) {
         return;
     }
 
-    const a = found_triangles;
-
-    for (let i = 1; i < count; i++) {
-        const v = a[i];
-
-        let j = i - 1;
-
-        while (j >= 0 && a[j] > v) {
-            a[j + 1] = a[j];
-            j--;
-        }
-
-        a[j + 1] = v;
-    }
+    array_sort_insertion_ascending(found_triangles, 0, count);
 }

package/src/engine/physics/narrowphase/hull_sphere_contact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hull_sphere_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/hull_sphere_contact.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,yCAfW,MAAM,EAAE,GAAC,YAAY,+BAErB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,GACJ,OAAO,CAkBnB;AASD;;;;;;;;;;;;;GAaG;AACH,+CARW,MAAM,EAAE,GAAC,YAAY,iCAErB,YAAY,eACZ,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,OAAO,CAsHnB"}
+{"version":3,"file":"hull_sphere_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/hull_sphere_contact.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,yCAfW,MAAM,EAAE,GAAC,YAAY,+BAErB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,GACJ,OAAO,CAkBnB;AASD;;;;;;;;;;;;;GAaG;AACH,+CARW,MAAM,EAAE,GAAC,YAAY,iCAErB,YAAY,eACZ,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,OAAO,CAmHnB"}

package/src/engine/physics/narrowphase/hull_sphere_contact.js

@@ -1,5 +1,5 @@
 import { v3_quaternion_apply_array } from "../../../core/geom/vec3/v3_quaternion_apply.js";
-import { v3_quaternion_apply_inverse_array } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { pose3_apply_inverse_point_array } from "../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
 
 /**
  * Below this distance from the hull's surface the direction from the closest surface point to the
@@ -96,10 +96,7 @@ export function hull_sphere_contact_array(out, hull, pose, pose_offset, sphere,
     const sx = sphere[sphere_offset], sy = sphere[sphere_offset + 1], sz = sphere[sphere_offset + 2];
     const radius = sphere[sphere_offset + 3];
 
-    scratch_centre[0] = sx - px;
-    scratch_centre[1] = sy - py;
-    scratch_centre[2] = sz - pz;
-    v3_quaternion_apply_inverse_array(scratch_centre, 0, scratch_centre, 0, pose, rotation);
+    pose3_apply_inverse_point_array(scratch_centre, 0, pose, pose_offset, pose, rotation, sphere, sphere_offset);
 
     const cx = scratch_centre[0];
     const cy = scratch_centre[1];

package/src/engine/physics/narrowphase/narrowphase_step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAu2FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qDAZW,YAAY,GAAC,MAAM,EAAE,iCAGrB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,iCAGjB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,GAEf,MAAM,CA2ClB;AA2JD;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,CAAC,QAmMpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,UACnD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,QA0K7D;4BA16GM,oCAAoC"}
+{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAo1FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qDAZW,YAAY,GAAC,MAAM,EAAE,iCAGrB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,iCAGjB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,GAEf,MAAM,CA2ClB;AA2JD;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,CAAC,QAmMpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,UACnD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,QA0K7D;4BAv5GM,oCAAoC"}

package/src/engine/physics/narrowphase/narrowphase_step.js

@@ -59,6 +59,7 @@ import {
     TRANSFORM64_ROTATION_OFFSET,
     TRANSFORM64_TRANSLATION_OFFSET
 } from "../../ecs/transform/Transform64.js";
+import { t64_read_pose_array } from "../../ecs/transform/t64_read_pose_array.js";
 import { rigid_subject_pose } from "./rigid_subject_pose.js";
 
 const posed_a = new PosedShape3D();
@@ -1081,7 +1082,7 @@ const tri_plane = new Float64Array(13);
  * @param {Transform64} concave_tr
  */
 function triangle_plane_world(tri, concave_tr) {
-    pose_pack(plane_pose, concave_tr);
+    t64_read_pose_array(plane_pose, 0, concave_tr);
     triangle_vertices_to_world(scratch_tri_world, triangle_buffer, tri, plane_pose);
 
     const w = scratch_tri_world;
@@ -1476,26 +1477,6 @@ const plane_pose = new Float64Array(7);
  */
 const convex_record = new Float64Array(10);
 
-/**
- * Pack a pose, `[px, py, pz, qx, qy, qz, qw]`, from a transform.
- *
- * Read off the transform's lanes (a Transform64 is a Float64Array), not through `translation_x` and
- * the rest: inlined into dispatch_pair, those accessor calls land on a branch too rarely taken for
- * TurboFan to inline them, and each then returns its number boxed.
- *
- * @param {Float64Array} out
- * @param {Transform64} tr
- */
-function pose_pack(out, tr) {
-    out[0] = tr[TRANSFORM64_TRANSLATION_OFFSET];
-    out[1] = tr[TRANSFORM64_TRANSLATION_OFFSET + 1];
-    out[2] = tr[TRANSFORM64_TRANSLATION_OFFSET + 2];
-    out[3] = tr[TRANSFORM64_ROTATION_OFFSET];
-    out[4] = tr[TRANSFORM64_ROTATION_OFFSET + 1];
-    out[5] = tr[TRANSFORM64_ROTATION_OFFSET + 2];
-    out[6] = tr[TRANSFORM64_ROTATION_OFFSET + 3];
-}
-
 // dispatch_pair branches on the shape pair, so each branch runs on a fraction of its calls: too few
 // for TurboFan to inline a call made there, small or not, and a call that is not inlined boxes each
 // number handed to it. The closed-form pair kernels therefore get their bodies packed into these
@@ -1543,7 +1524,7 @@ function sphere_record_pack(out, tr, shape) {
  * @param {CapsuleShape3D} shape
  */
 function capsule_record_pack(out, tr, shape) {
-    pose_pack(out, tr);
+    t64_read_pose_array(out, 0, tr);
     out[7] = shape.radius;
     out[8] = shape.height * 0.5;
 }
@@ -1611,14 +1592,14 @@ function append_manifold_contact(count, result, offset, first_is_a, feature_id)
 
 /**
  * Pack a box record, `[px, py, pz, qx, qy, qz, qw, hx, hy, hz]`: its centre and orientation from the
- * transform, then its half-extents, read off their lanes for {@link pose_pack}'s reason (a Vector3 is
- * a Float64Array).
+ * transform, then its half-extents, read off their lanes for {@link t64_read_pose_array}'s reason (a
+ * Vector3 is a Float64Array).
  * @param {Float64Array} out
  * @param {Transform64} tr
  * @param {Vector3} half_extents
  */
 function box_record_pack(out, tr, half_extents) {
-    pose_pack(out, tr);
+    t64_read_pose_array(out, 0, tr);
     out[7] = half_extents[0];
     out[8] = half_extents[1];
     out[9] = half_extents[2];
@@ -1793,8 +1774,8 @@ function sphere_box_voronoi_fid_array(sphere, sphere_offset, box, box_offset) {
 function hull_pair_contacts(count, hullA, trA, hullB, trB) {
     // Poses go to the posed shapes and the clip in arrays, read off the transforms' lanes: this is
     // called from a dispatch_pair branch, and numbers handed across a call there are boxed.
-    pose_pack(pair_pose_a, trA);
-    pose_pack(pair_pose_b, trB);
+    t64_read_pose_array(pair_pose_a, 0, trA);
+    t64_read_pose_array(pair_pose_b, 0, trB);
     posed_a.setup_pose(hullA, pair_pose_a, 0);
     posed_b.setup_pose(hullB, pair_pose_b, 0);
     const depth = gjk_epa_penetration(epa_result, posed_a, posed_b);
@@ -2163,7 +2144,7 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     if ((shapeA.isConvexHullShape3D === true && isSphereB) || (isSphereA && shapeB.isConvexHullShape3D === true)) {
         const hull_is_a = isSphereB;
 
-        pose_pack(pair_pose, hull_is_a ? trA : trB);
+        t64_read_pose_array(pair_pose, 0, hull_is_a ? trA : trB);
         sphere_record_pack(pair_sphere_b, hull_is_a ? trB : trA, hull_is_a ? shapeB : shapeA);
 
         const ok = hull_sphere_contact_array(closed_form_result, hull_is_a ? shapeA : shapeB, pair_pose, 0, pair_sphere_b, 0);
@@ -2214,8 +2195,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         // The two bodies' poses, packed once for the calls below and the per-triangle kernels: passed
         // as numbers to a call that is not inlined, every one would be boxed (see
         // triangle_vertices_to_world).
-        pose_pack(convex_pose, convex_tr);
-        pose_pack(concave_pose, concave_tr);
+        t64_read_pose_array(convex_pose, 0, convex_tr);
+        t64_read_pose_array(concave_pose, 0, concave_tr);
 
         // 1. Convex shape's world AABB.
         convex_col.shape.compute_bounding_box(concave_local_aabb);
@@ -2310,7 +2291,7 @@ function dispatch_pair(count, colA, trA, colB, trB) {
             convex_record[2] = convex_wz;
             convex_record[3] = sphere_radius;
         } else if (isBoxConvex || isCapsuleConvex) {
-            pose_pack(convex_record, convex_tr);
+            t64_read_pose_array(convex_record, 0, convex_tr);
 
             if (isBoxConvex) {
                 convex_record[7] = box_half_extents.x;
@@ -3130,7 +3111,7 @@ function collider_box(i, entry) {
 
     entry.collider.shape.compute_bounding_box(collider_local_box);
 
-    pose_pack(collider_pose, t);
+    t64_read_pose_array(collider_pose, 0, t);
     aabb3_transform_oriented_array(collider_boxes, i * 6, collider_local_box, 0, collider_pose, 0);
 }
 

package/src/engine/physics/narrowphase/sphere_box_contact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sphere_box_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_box_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAjBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmBnB;AASD;;;;;;;;;;;;GAYG;AACH,8CAPW,MAAM,EAAE,GAAC,YAAY,UACrB,YAAY,iBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CA8FnB"}
+{"version":3,"file":"sphere_box_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_box_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAjBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmBnB;AASD;;;;;;;;;;;;GAYG;AACH,8CAPW,MAAM,EAAE,GAAC,YAAY,UACrB,YAAY,iBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CA2FnB"}

package/src/engine/physics/narrowphase/sphere_box_contact.js

@@ -1,5 +1,5 @@
 import { v3_quaternion_apply_array } from "../../../core/geom/vec3/v3_quaternion_apply.js";
-import { v3_quaternion_apply_inverse_array } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { pose3_apply_inverse_point_array } from "../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
 
 /**
  * Scratch for the world→box-local rotation of the sphere centre at the
@@ -93,10 +93,7 @@ export function sphere_box_contact_array(out, sphere, sphere_offset, box, box_of
 
     // Step 1: bring the sphere centre into box-local space via the conjugate
     // quaternion. v_local = q* · (s - b) · q
-    scratch_local[0] = sx - bx;
-    scratch_local[1] = sy - by;
-    scratch_local[2] = sz - bz;
-    v3_quaternion_apply_inverse_array(scratch_local, 0, scratch_local, 0, box, rotation);
+    pose3_apply_inverse_point_array(scratch_local, 0, box, box_offset, box, rotation, sphere, sphere_offset);
     const lx = scratch_local[0];
     const ly = scratch_local[1];
     const lz = scratch_local[2];

package/src/engine/simulation/Ticker.d.ts

@@ -4,6 +4,10 @@ export default Ticker;
  * Dispatches "tick" every animation frame or "maxDelay" time, whichever happens to be soonest
  * This is essentially the timing bus that all the simulation systems subscribe to for their step advancement
  *
+ * A tick taken in an animation frame runs inside that frame and is measured to the frame's timestamp,
+ * and {@link Ticker#onFrame} follows it, so whatever draws from `onFrame` draws the simulation as of
+ * that frame.
+ *
  *
  * @example
  *      ticker.onTick.add(delta_s => {
@@ -40,6 +44,14 @@ declare class Ticker {
      * @type {Signal<number>}
      */
     readonly onTick: any;
+    /**
+     * Dispatched once per animation frame, after that frame's tick - or with none, while paused or
+     * suspended. The place to draw: the simulation is at the frame's timestamp here.
+     * Not dispatched for the {@link start}'s `maxTimeout` fallback ticks, which are not frames.
+     * @readonly
+     * @type {Signal}
+     */
+    readonly onFrame: Signal;
     /**
      * Whether the update loop is cycling. {@link Ticker#pause} and {@link Ticker#resume} require this,
      * they throw otherwise.
@@ -66,4 +78,5 @@ declare class Ticker {
     #private;
 }
 import Clock from '../Clock.js';
+import Signal from "../../core/events/signal/Signal.js";
 //# sourceMappingURL=Ticker.d.ts.map

package/src/engine/simulation/Ticker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ticker.d.ts","sourceRoot":"","sources":["../../../../src/engine/simulation/Ticker.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,gBAFU,KAAK,CAEK;IAEpB;;;;;;;;;;;;OAYG;IACH,uBAFU,OAAO,CAEY;IAkC7B;;;;OAIG;IACH,qBAAsB;IA2BtB;;;;OAIG;IACH,yBAEC;IAED;;;;OAIG;IACH,yBAEC;IAuGD;;;;OAIG;IACH;QAF4B,UAAU,GAA3B,MAAM;aAkFhB;IAED,cAWC;IAED,eAaC;IAED,aAaC;;CACJ;kBA/ViB,aAAa"}
+{"version":3,"file":"Ticker.d.ts","sourceRoot":"","sources":["../../../../src/engine/simulation/Ticker.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;OAGG;IACH,gBAFU,KAAK,CAEK;IAEpB;;;;;;;;;;;;OAYG;IACH,uBAFU,OAAO,CAEY;IAkC7B;;;;OAIG;IACH,qBAAsB;IAEtB;;;;;;OAMG;IACH,kBAFU,MAAM,CAEO;IA2BvB;;;;OAIG;IACH,yBAEC;IAED;;;;OAIG;IACH,yBAEC;IAuGD;;;;OAIG;IACH;QAF4B,UAAU,GAA3B,MAAM;aAuGhB;IAED,cAWC;IAED,eAaC;IAED,aAaC;;CACJ;kBAjYiB,aAAa;mBAFZ,oCAAoC"}