@woosh/meep-engine 3.44.0 → 3.46.0

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/fluid/effector/AbstractFluidEffector.d.ts

@@ -53,8 +53,8 @@ export class AbstractFluidEffector {
     equals(other: AbstractFluidEffector): boolean;
     /**
      * Fast hash. The base implementation returns a constant — concrete effectors
-     * override to hash their own state. Should stay cheap (a few `combine_hash` calls
-     * over scalar fields).
+     * override to hash their own state. Should stay cheap (a few `hash_mix2` / `hash_mix3`
+     * calls over scalar fields).
      * @return {number}
      */
     hash(): number;

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

@@ -63,8 +63,8 @@ export class AbstractFluidEffector {
 
     /**
      * Fast hash. The base implementation returns a constant — concrete effectors
-     * override to hash their own state. Should stay cheap (a few `combine_hash` calls
-     * over scalar fields).
+     * override to hash their own state. Should stay cheap (a few `hash_mix2` / `hash_mix3`
+     * calls over scalar fields).
      * @return {number}
      */
     hash() {

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

@@ -1 +1 @@
-{"version":3,"file":"GlobalFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IAEI;;;;;OAKG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;OAKG;IACH,MAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEjB;IAEjB;;;;;;;OAOG;IACH,MAFU,MAAM,CAEP;CA2HZ;sCAvMqC,4BAA4B"}
+{"version":3,"file":"GlobalFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IAEI;;;;;OAKG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;OAKG;IACH,MAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEjB;IAEjB;;;;;;;OAOG;IACH,MAFU,MAAM,CAEP;CA+HZ;sCA3MqC,4BAA4B"}

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

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
 
@@ -180,12 +180,16 @@ export class GlobalFluidEffector extends AbstractFluidEffector {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.force[0]),
-            computeHashFloat(this.force[1]),
-            computeHashFloat(this.force[2]),
-            computeHashFloat(this.wind[0]),
-            computeHashFloat(this.wind[1]),
+        return hash_mix3(
+            hash_mix3(
+                hash_mix3(
+                    computeHashFloat(this.force[0]),
+                    computeHashFloat(this.force[1]),
+                    computeHashFloat(this.force[2])
+                ),
+                computeHashFloat(this.wind[0]),
+                computeHashFloat(this.wind[1])
+            ),
             computeHashFloat(this.wind[2]),
             computeHashFloat(this.drag)
         );

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;CA8Md;sCA5PqC,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;CAkNd;sCAhQqC,4BAA4B"}

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

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
@@ -225,12 +225,16 @@ export class ImpulseFluidEffector extends AbstractFluidEffector {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.position[0]),
-            computeHashFloat(this.position[1]),
-            computeHashFloat(this.position[2]),
-            computeHashFloat(this.force[0]),
-            computeHashFloat(this.force[1]),
+        return hash_mix3(
+            hash_mix3(
+                hash_mix3(
+                    computeHashFloat(this.position[0]),
+                    computeHashFloat(this.position[1]),
+                    computeHashFloat(this.position[2])
+                ),
+                computeHashFloat(this.force[0]),
+                computeHashFloat(this.force[1])
+            ),
             computeHashFloat(this.force[2]),
             computeHashFloat(this.radius)
         );

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;;CAgSJ;sCAnZqC,4BAA4B"}
+{"version":3,"file":"WakeFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/WakeFluidEffector.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;CAsSJ;sCAzZqC,4BAA4B"}

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

@@ -1,4 +1,5 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
@@ -368,14 +369,20 @@ export class WakeFluidEffector extends AbstractFluidEffector {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.position[0]),
-            computeHashFloat(this.position[1]),
-            computeHashFloat(this.position[2]),
-            computeHashFloat(this.previous_position[0]),
-            computeHashFloat(this.previous_position[1]),
-            computeHashFloat(this.previous_position[2]),
-            computeHashFloat(this.radius),
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    hash_mix3(
+                        computeHashFloat(this.position[0]),
+                        computeHashFloat(this.position[1]),
+                        computeHashFloat(this.position[2])
+                    ),
+                    computeHashFloat(this.previous_position[0]),
+                    computeHashFloat(this.previous_position[1])
+                ),
+                computeHashFloat(this.previous_position[2]),
+                computeHashFloat(this.radius)
+            ),
             computeHashFloat(this.strength)
         );
     }

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