@woosh/meep-engine 2.169.1 → 2.169.3

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a (non-uniform) scale,
+ * taking every operand as a loose scalar. `out = T * R * S`.
+ *
+ * This is the shared core of {@link m4_compose} (object operands) and
+ * {@link m4_from_rotation_translation_scale} (array operands) — those two differ only in how they read
+ * their inputs, and previously each carried its own copy of the quaternion→matrix expansion.
+ *
+ * The quaternion is assumed to be of unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} tx
+ * @param {number} ty
+ * @param {number} tz
+ * @param {number} sx
+ * @param {number} sy
+ * @param {number} sz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale_scalar(out: number[] | Float32Array | Float64Array, qx: number, qy: number, qz: number, qw: number, tx: number, ty: number, tz: number, sx: number, sy: number, sz: number): void;
+//# sourceMappingURL=m4_from_rotation_translation_scale_scalar.d.ts.map

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_from_rotation_translation_scale_scalar.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+DAfW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,MAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA8ChB"}

package/src/core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js

@@ -0,0 +1,67 @@
+/**
+ * Compose a 4x4 transform matrix from a rotation quaternion, a translation and a (non-uniform) scale,
+ * taking every operand as a loose scalar. `out = T * R * S`.
+ *
+ * This is the shared core of {@link m4_compose} (object operands) and
+ * {@link m4_from_rotation_translation_scale} (array operands) — those two differ only in how they read
+ * their inputs, and previously each carried its own copy of the quaternion→matrix expansion.
+ *
+ * The quaternion is assumed to be of unit length. Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw
+ * @param {number} tx
+ * @param {number} ty
+ * @param {number} tz
+ * @param {number} sx
+ * @param {number} sy
+ * @param {number} sz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_from_rotation_translation_scale_scalar(
+    out,
+    qx, qy, qz, qw,
+    tx, ty, tz,
+    sx, sy, sz
+) {
+    const x2 = qx + qx;
+    const y2 = qy + qy;
+    const z2 = qz + qz;
+
+    const xx = qx * x2;
+    const xy = qx * y2;
+    const xz = qx * z2;
+
+    const yy = qy * y2;
+    const yz = qy * z2;
+    const zz = qz * z2;
+
+    const wx = qw * x2;
+    const wy = qw * y2;
+    const wz = qw * z2;
+
+    out[0] = (1 - (yy + zz)) * sx;
+    out[1] = (xy + wz) * sx;
+    out[2] = (xz - wy) * sx;
+    out[3] = 0;
+
+    out[4] = (xy - wz) * sy;
+    out[5] = (1 - (xx + zz)) * sy;
+    out[6] = (yz + wx) * sy;
+    out[7] = 0;
+
+    out[8] = (xz + wy) * sz;
+    out[9] = (yz - wx) * sz;
+    out[10] = (1 - (xx + yy)) * sz;
+    out[11] = 0;
+
+    out[12] = tx;
+    out[13] = ty;
+    out[14] = tz;
+    out[15] = 1;
+}

package/src/core/geom/3d/plane/orient3d_fast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orient3d_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/orient3d_fast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA2BlB"}
+{"version":3,"file":"orient3d_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/orient3d_fast.js"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB"}

package/src/core/geom/3d/plane/orient3d_fast.js

@@ -1,3 +1,4 @@
+import { orient3d_fast_point } from "./orient3d_fast_point.js";
 /**
  * Non-robust
  *
@@ -20,29 +21,8 @@
  * @returns {number}
  */
 export function orient3d_fast(points, a, b, c, d) {
-    const a3 = a * 3;
     const d3 = d * 3;
-    const b3 = b * 3;
-    const c3 = c * 3;
 
-    const d_x = points[d3];
-    const d_y = points[d3 + 1];
-    const d_z = points[d3 + 2];
-
-    const adx = points[a3] - d_x;
-    const ady = points[a3 + 1] - d_y;
-    const adz = points[a3 + 2] - d_z;
-
-    const bdx = points[b3] - d_x;
-    const bdy = points[b3 + 1] - d_y;
-    const bdz = points[b3 + 2] - d_z;
-
-    const cdx = points[c3] - d_x;
-    const cdy = points[c3 + 1] - d_y;
-    const cdz = points[c3 + 2] - d_z;
-
-    return adx * (bdy * cdz - bdz * cdy)
-        + bdx * (cdy * adz - cdz * ady)
-        + cdx * (ady * bdz - adz * bdy);
+    return orient3d_fast_point(points, a, b, c, points[d3], points[d3 + 1], points[d3 + 2]);
 }
 

package/src/core/geom/3d/plane/orient3d_fast_point.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Non-robust `orient3d`: the signed volume (x6) of the tetrahedron `(a, b, c, e)`, where `a`/`b`/`c` are
+ * INDICES into a flat `(x, y, z)`-per-point buffer and `e` is given as loose coordinates.
+ *
+ * Sign convention matches {@link orient3d_fast}: positive when `e` is below the plane of `a`, `b`, `c`
+ * with respect to their winding.
+ *
+ * This is the shared core of {@link orient3d_fast} — that one simply reads its fourth point out of the
+ * same buffer first. Use this flavour when the query point is not stored in the buffer, which is the
+ * common case for point-in-solid tests.
+ *
+ * NON-ROBUST: this is the floating-point determinant, not the adaptive-precision predicate. Use
+ * `orient3d_robust` when the sign must be exact for nearly-degenerate configurations.
+ *
+ * @param {number[]|Float32Array|Float64Array} points flat `(x, y, z)` per point
+ * @param {number} a index of the first plane point
+ * @param {number} b index of the second plane point
+ * @param {number} c index of the third plane point
+ * @param {number} ex query point x
+ * @param {number} ey query point y
+ * @param {number} ez query point z
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function orient3d_fast_point(points: number[] | Float32Array | Float64Array, a: number, b: number, c: number, ex: number, ey: number, ez: number): number;
+//# sourceMappingURL=orient3d_fast_point.d.ts.map

package/src/core/geom/3d/plane/orient3d_fast_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orient3d_fast_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/orient3d_fast_point.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4CAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyBlB"}

package/src/core/geom/3d/plane/orient3d_fast_point.js

@@ -0,0 +1,47 @@
+/**
+ * Non-robust `orient3d`: the signed volume (x6) of the tetrahedron `(a, b, c, e)`, where `a`/`b`/`c` are
+ * INDICES into a flat `(x, y, z)`-per-point buffer and `e` is given as loose coordinates.
+ *
+ * Sign convention matches {@link orient3d_fast}: positive when `e` is below the plane of `a`, `b`, `c`
+ * with respect to their winding.
+ *
+ * This is the shared core of {@link orient3d_fast} — that one simply reads its fourth point out of the
+ * same buffer first. Use this flavour when the query point is not stored in the buffer, which is the
+ * common case for point-in-solid tests.
+ *
+ * NON-ROBUST: this is the floating-point determinant, not the adaptive-precision predicate. Use
+ * `orient3d_robust` when the sign must be exact for nearly-degenerate configurations.
+ *
+ * @param {number[]|Float32Array|Float64Array} points flat `(x, y, z)` per point
+ * @param {number} a index of the first plane point
+ * @param {number} b index of the second plane point
+ * @param {number} c index of the third plane point
+ * @param {number} ex query point x
+ * @param {number} ey query point y
+ * @param {number} ez query point z
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function orient3d_fast_point(points, a, b, c, ex, ey, ez) {
+    const a3 = a * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
+
+    const adx = points[a3] - ex;
+    const ady = points[a3 + 1] - ey;
+    const adz = points[a3 + 2] - ez;
+
+    const bdx = points[b3] - ex;
+    const bdy = points[b3 + 1] - ey;
+    const bdz = points[b3 + 2] - ez;
+
+    const cdx = points[c3] - ex;
+    const cdy = points[c3 + 1] - ey;
+    const cdz = points[c3 + 2] - ez;
+
+    return adx * (bdy * cdz - bdz * cdy)
+        + bdx * (cdy * adz - cdz * ady)
+        + cdx * (ady * bdz - adz * bdy);
+}

package/src/core/geom/3d/quaternion/quat3_nlerp.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Shortest-path normalized linear interpolation between two unit quaternions:
+ * `out = normalize(a + (b' - a) * t)`, where `b'` is `b` negated when the two
+ * point into opposite hemispheres.
+ *
+ * The hemisphere flip is what makes this "shortest path". `q` and `-q` name the
+ * same rotation, so a raw componentwise lerp between two quaternions whose dot
+ * product is negative travels the long way round — a visible backwards spin at
+ * playback. Testing `a · b < 0` and negating `b` costs four multiplies and
+ * removes the failure mode entirely.
+ *
+ * nlerp, not slerp: the path is the same, only the angular *rate* differs, and
+ * the error is bounded by a few degrees for the per-tick steps this is built
+ * for (network interpolation between adjacent snapshots, render smoothing).
+ * Slerp's `acos`/`sin` pair costs far more than the visual difference is worth
+ * at those step sizes. Reach for {@link Quaternion#slerpQuaternions} instead
+ * when blending across wide angles, e.g. animation keyframes seconds apart.
+ *
+ * Exists because this was hand-inlined at three separate interpolation sites
+ * with no primitive to call — the `quat3_*` family had `multiply`, `integrate`
+ * and the uint32 codecs but no blend.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and
+ * the rest of the `core/geom/3d/quaternion/` family.
+ *
+ * All eight components are read from the argument list before anything is
+ * written, so `out` may safely be the same backing array the inputs were read
+ * from, at any offset.
+ *
+ * **Precondition: `a` and `b` are non-zero.** The blend cannot otherwise
+ * cancel to the zero quaternion — the hemisphere flip guarantees the endpoints
+ * are never antipodal by the time they are mixed, so the only way to reach a
+ * zero-length result is to hand in a zero-length input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} aw
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} bw
+ * @param {number} t blend factor; 0 yields `a`, 1 yields `b` (or `-b`)
+ */
+export function quat3_nlerp(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number, t: number): void;
+//# sourceMappingURL=quat3_nlerp.d.ts.map

package/src/core/geom/3d/quaternion/quat3_nlerp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_nlerp.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_nlerp.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,iCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,KACN,MAAM,QAyBhB"}

package/src/core/geom/3d/quaternion/quat3_nlerp.js

@@ -0,0 +1,72 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Shortest-path normalized linear interpolation between two unit quaternions:
+ * `out = normalize(a + (b' - a) * t)`, where `b'` is `b` negated when the two
+ * point into opposite hemispheres.
+ *
+ * The hemisphere flip is what makes this "shortest path". `q` and `-q` name the
+ * same rotation, so a raw componentwise lerp between two quaternions whose dot
+ * product is negative travels the long way round — a visible backwards spin at
+ * playback. Testing `a · b < 0` and negating `b` costs four multiplies and
+ * removes the failure mode entirely.
+ *
+ * nlerp, not slerp: the path is the same, only the angular *rate* differs, and
+ * the error is bounded by a few degrees for the per-tick steps this is built
+ * for (network interpolation between adjacent snapshots, render smoothing).
+ * Slerp's `acos`/`sin` pair costs far more than the visual difference is worth
+ * at those step sizes. Reach for {@link Quaternion#slerpQuaternions} instead
+ * when blending across wide angles, e.g. animation keyframes seconds apart.
+ *
+ * Exists because this was hand-inlined at three separate interpolation sites
+ * with no primitive to call — the `quat3_*` family had `multiply`, `integrate`
+ * and the uint32 codecs but no blend.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and
+ * the rest of the `core/geom/3d/quaternion/` family.
+ *
+ * All eight components are read from the argument list before anything is
+ * written, so `out` may safely be the same backing array the inputs were read
+ * from, at any offset.
+ *
+ * **Precondition: `a` and `b` are non-zero.** The blend cannot otherwise
+ * cancel to the zero quaternion — the hemisphere flip guarantees the endpoints
+ * are never antipodal by the time they are mixed, so the only way to reach a
+ * zero-length result is to hand in a zero-length input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} aw
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} bw
+ * @param {number} t blend factor; 0 yields `a`, 1 yields `b` (or `-b`)
+ */
+export function quat3_nlerp(out, out_offset, ax, ay, az, aw, bx, by, bz, bw, t) {
+    if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+        bx = -bx;
+        by = -by;
+        bz = -bz;
+        bw = -bw;
+    }
+
+    const qx = ax + (bx - ax) * t;
+    const qy = ay + (by - ay) * t;
+    const qz = az + (bz - az) * t;
+    const qw = aw + (bw - aw) * t;
+
+    const len2 = qx * qx + qy * qy + qz * qz + qw * qw;
+
+    assert.ok(len2 > 0, 'quat3_nlerp: blend cancelled to the zero quaternion; a or b was not a rotation');
+
+    const inv_len = 1 / Math.sqrt(len2);
+
+    out[out_offset] = qx * inv_len;
+    out[out_offset + 1] = qy * inv_len;
+    out[out_offset + 2] = qz * inv_len;
+    out[out_offset + 3] = qw * inv_len;
+}

package/src/core/geom/3d/shape/AbstractShape3D.d.ts

@@ -20,6 +20,15 @@ export class AbstractShape3D {
      */
     nearest_point_on_surface(result: number[], reference: number[]): void;
     /**
+     * Uniformly sample a point inside the shape's volume.
+     *
+     * Generic implementation: rejection-sample the bounding box until a probe lands inside. Requires only
+     * {@link compute_bounding_box} and {@link contains_point}, so every shape gets it for free; shapes with
+     * a closed-form sampler (sphere, box) override it.
+     *
+     * After {@link SAMPLE_VOLUME_MAX_ATTEMPTS} misses it falls back to the bounding-box centre. That bound
+     * matters for shapes whose volume is a small fraction of their bounds (a thin diagonal capsule, a torus
+     * with a large hole) where rejection sampling can otherwise run unbounded.
      *
      * @param {number[]} result
      * @param {number} result_offset

package/src/core/geom/3d/shape/AbstractShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/AbstractShape3D.js"],"names":[],"mappings":"AAAA;IACI;;;;OAIG;IACH,gCAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAJW,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;;;OAMG;IACH,sCALW,MAAM,EAAE,iBACR,MAAM,qBAEJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAInB;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAClD,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;;;;;OAWG;IACH,aAJW,YAAY,GAAC,MAAM,EAAE,cAEnB,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAGL;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oBAFU,OAAO,CAEkB;CAvBlC"}
+{"version":3,"file":"AbstractShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/AbstractShape3D.js"],"names":[],"mappings":"AASA;IACI;;;;OAIG;IACH,gCAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAJW,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,sCALW,MAAM,EAAE,iBACR,MAAM,qBAEJ,IAAI,CA6BhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAInB;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAClD,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;;;;;OAWG;IACH,aAJW,YAAY,GAAC,MAAM,EAAE,cAEnB,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAGL;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oBAFU,OAAO,CAEkB;CAvBlC"}

package/src/core/geom/3d/shape/AbstractShape3D.js

@@ -1,3 +1,12 @@
+/**
+ * Rejection-sampling budget for the generic {@link AbstractShape3D#sample_random_point_in_volume}.
+ * @type {number}
+ */
+const SAMPLE_VOLUME_MAX_ATTEMPTS = 256;
+
+const scratch_sample_bounds = new Float64Array(6);
+const scratch_sample_probe = new Float64Array(3);
+
 export class AbstractShape3D {
     /**
      * Signed distance to boundary of the shape from the given point
@@ -29,6 +38,15 @@ export class AbstractShape3D {
     }
 
     /**
+     * Uniformly sample a point inside the shape's volume.
+     *
+     * Generic implementation: rejection-sample the bounding box until a probe lands inside. Requires only
+     * {@link compute_bounding_box} and {@link contains_point}, so every shape gets it for free; shapes with
+     * a closed-form sampler (sphere, box) override it.
+     *
+     * After {@link SAMPLE_VOLUME_MAX_ATTEMPTS} misses it falls back to the bounding-box centre. That bound
+     * matters for shapes whose volume is a small fraction of their bounds (a thin diagonal capsule, a torus
+     * with a large hole) where rejection sampling can otherwise run unbounded.
      *
      * @param {number[]} result
      * @param {number} result_offset
@@ -36,7 +54,32 @@ export class AbstractShape3D {
      * @returns {void}
      */
     sample_random_point_in_volume(result, result_offset, random) {
-        throw new Error('Not Implemented');
+        const bounds = scratch_sample_bounds;
+
+        this.compute_bounding_box(bounds);
+
+        const lx = bounds[0], ly = bounds[1], lz = bounds[2];
+        const sx = bounds[3] - lx, sy = bounds[4] - ly, sz = bounds[5] - lz;
+
+        const probe = scratch_sample_probe;
+
+        for (let attempt = 0; attempt < SAMPLE_VOLUME_MAX_ATTEMPTS; attempt++) {
+            probe[0] = lx + random() * sx;
+            probe[1] = ly + random() * sy;
+            probe[2] = lz + random() * sz;
+
+            if (this.contains_point(probe)) {
+                result[result_offset] = probe[0];
+                result[result_offset + 1] = probe[1];
+                result[result_offset + 2] = probe[2];
+
+                return;
+            }
+        }
+
+        result[result_offset] = lx + sx * 0.5;
+        result[result_offset + 1] = ly + sy * 0.5;
+        result[result_offset + 2] = lz + sz * 0.5;
     }
 
     /**

package/src/core/geom/3d/shape/BoxShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BoxShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/BoxShape3D.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH;IAYI;;;;;;OAMG;IACH,gBALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,UACN,MAAM,SACN,MAAM,GACJ,UAAU,CAItB;IA/BG;;;;OAIG;IACH,uBAFU,OAAO,CAE6B;IAsClD,wCAIC;IAED,4DAQC;IAED,qGAKC;IAED,qCAaC;IAED,mEAEC;IAED,6CAaC;IAED,oCAQC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAWL;;;;;;OAMG;IACH,uBAFU,OAAO,CAEgB;CAThC;gCA1J+B,sBAAsB;oBAVlC,kBAAkB"}
+{"version":3,"file":"BoxShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/BoxShape3D.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;GAYG;AACH;IAYI;;;;;;OAMG;IACH,gBALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,UACN,MAAM,SACN,MAAM,GACJ,UAAU,CAItB;IA/BG;;;;OAIG;IACH,uBAFU,OAAO,CAE6B;IAsClD,wCAIC;IAED,4DAQC;IAED,qGAKC;IAED,qCAaC;IAED,mEAEC;IAED,6CAaC;IAED,oCAQC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAWL;;;;;;OAMG;IACH,uBAFU,OAAO,CAEgB;CAThC;gCA1J+B,sBAAsB;oBAVlC,kBAAkB"}

package/src/core/geom/3d/shape/BoxShape3D.js

@@ -1,3 +1,4 @@
+import { hash_mix3 } from "../../../math/hash/hash_mix3.js";
 import Vector3 from "../../Vector3.js";
 import { max2 } from "../../../math/max2.js";
 import { max3 } from "../../../math/max3.js";
@@ -160,7 +161,7 @@ export class BoxShape3D extends AbstractShape3D {
         const a = computeHashFloat(h.x);
         const b = computeHashFloat(h.y);
         const c = computeHashFloat(h.z);
-        return ((a * 31 + b) * 31 + c) | 0;
+        return hash_mix3(a, b, c);
     }
 }
 

package/src/core/geom/3d/shape/CapsuleShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CapsuleShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/CapsuleShape3D.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH;IAiBI;;;;OAIG;IACH,oBAJW,MAAM,UACN,MAAM,GACJ,cAAc,CAa1B;IA7BG;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,QAFU,MAAM,CAED;IAqCnB,wCAUC;IAED,qCAgBC;IAED,6CAaC;IAED,mEAEC;IAED,oCAcC;IAED,4DA+BC;IAED,qGAUC;IAED,kFA+BC;IAED;;;OAGG;IACH,cAHW,cAAc,GACZ,OAAO,CAMnB;IAUL;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEwB;CAZxC;gCA5N+B,sBAAsB"}
+{"version":3,"file":"CapsuleShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/CapsuleShape3D.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH;IAiBI;;;;OAIG;IACH,oBAJW,MAAM,UACN,MAAM,GACJ,cAAc,CAa1B;IA7BG;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,QAFU,MAAM,CAED;IAqCnB,wCAUC;IAED,qCAgBC;IAED,6CAaC;IAED,mEAEC;IAED,oCAcC;IAED,4DA+BC;IAED,qGAUC;IAED,kFA+BC;IAED;;;OAGG;IACH,cAHW,cAAc,GACZ,OAAO,CAMnB;IAUL;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEwB;CAZxC;gCA5N+B,sBAAsB"}

package/src/core/geom/3d/shape/CapsuleShape3D.js

@@ -1,3 +1,4 @@
+import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
 import { sign_not_zero } from "../../../math/sign_not_zero.js";
@@ -224,7 +225,7 @@ export class CapsuleShape3D extends AbstractShape3D {
         const a = computeHashFloat(this.radius);
         const b = computeHashFloat(this.height);
 
-        return ((a << 5) - a + b) | 0;
+        return hash_mix2(a, b);
     }
 }
 

package/src/core/geom/3d/shape/ConvexHullShape3D.d.ts

@@ -95,7 +95,6 @@ export class ConvexHullShape3D extends AbstractShape3D {
     signed_distance_at_point(point: any): number;
     signed_distance_gradient_at_point(result: any, point: any): number;
     nearest_point_on_surface(result: any, reference: any): void;
-    sample_random_point_in_volume(result: any, result_offset: any, random: any): void;
     /**
      * @param {ConvexHullShape3D} other
      * @returns {boolean}

package/src/core/geom/3d/shape/ConvexHullShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA+CI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IAxDG;;;;OAIG;IACH,UAFU,YAAY,CAEa;IAEnC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;OAMG;IACH,cAFU,WAAW,CAEiB;IACtC,0BAA0B;IAC1B,YADW,WAAW,CACc;IAEpC;;;;;;OAMG;IACH,iBAAmC;IAEnC,oCAAoC;IACpC,eAAiC;IACjC,8BAA8B;IAC9B,iBAAiB;IACjB,8BAA8B;IAC9B,uBAAuB;IAmB3B;;;OAGG;IACH,kBAiFC;IAKD,wCAIC;IAED;;;;;OAKG;IACH,qGAgBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAwBC;IAED,mEAEC;IAED,4DAwBC;IAED,kFAmBC;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCAtV+B,sBAAsB"}
+{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA+CI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IAxDG;;;;OAIG;IACH,UAFU,YAAY,CAEa;IAEnC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;OAMG;IACH,cAFU,WAAW,CAEiB;IACtC,0BAA0B;IAC1B,YADW,WAAW,CACc;IAEpC;;;;;;OAMG;IACH,iBAAmC;IAEnC,oCAAoC;IACpC,eAAiC;IACjC,8BAA8B;IAC9B,iBAAiB;IACjB,8BAA8B;IAC9B,uBAAuB;IAmB3B;;;OAGG;IACH,kBA8EC;IAKD,wCAIC;IAED;;;;;OAKG;IACH,qGAgBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAiBC;IAED,mEAEC;IAED,4DAoBC;IAGD;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCArT+B,sBAAsB"}

package/src/core/geom/3d/shape/ConvexHullShape3D.js

@@ -1,7 +1,9 @@
+import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
-import { tri3_closest_point_barycentric } from "../triangle/tri3_closest_point_barycentric.js";
+import { tri3_closest_point } from "../triangle/tri3_closest_point.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+import { aabb3_from_v3_array } from "../aabb/aabb3_from_v3_array.js";
 
 /**
  * Convex polyhedron collider.
@@ -100,18 +102,15 @@ export class ConvexHullShape3D extends AbstractShape3D {
         const v = this.vertices;
         const idx = this.indices;
 
-        let mnx = Infinity, mny = Infinity, mnz = Infinity;
-        let mxx = -Infinity, mxy = -Infinity, mxz = -Infinity;
         const vc = v.length / 3;
-        for (let i = 0; i < vc; i++) {
-            const x = v[i * 3], y = v[i * 3 + 1], z = v[i * 3 + 2];
-            if (x < mnx) mnx = x; if (x > mxx) mxx = x;
-            if (y < mny) mny = y; if (y > mxy) mxy = y;
-            if (z < mnz) mnz = z; if (z > mxz) mxz = z;
-        }
-        if (vc === 0) { mnx = mny = mnz = mxx = mxy = mxz = 0; }
         const b = this.__bbox;
-        b[0] = mnx; b[1] = mny; b[2] = mnz; b[3] = mxx; b[4] = mxy; b[5] = mxz;
+
+        aabb3_from_v3_array(b, v, v.length);
+
+        if (vc === 0) {
+            // empty hull collapses to a degenerate box at the origin; the reduction leaves ±Infinity
+            b[0] = b[1] = b[2] = b[3] = b[4] = b[5] = 0;
+        }
 
         // Volume is accumulated about the hull's own bbox centre, not the
         // origin. Σ a·(b×c) is translation invariant over a closed surface --
@@ -133,9 +132,9 @@ export class ConvexHullShape3D extends AbstractShape3D {
         // read a plausible 1.0 at the origin and something else entirely once
         // translated. This number is at least a property of the surface rather
         // than of where it sits.
-        const ox = (mnx + mxx) * 0.5;
-        const oy = (mny + mxy) * 0.5;
-        const oz = (mnz + mxz) * 0.5;
+        const ox = (b[0] + b[3]) * 0.5;
+        const oy = (b[1] + b[4]) * 0.5;
+        const oz = (b[2] + b[5]) * 0.5;
 
         const tri = idx.length / 3;
         const planes = new Float64Array(tri * 4);
@@ -245,19 +244,12 @@ export class ConvexHullShape3D extends AbstractShape3D {
         const px = point[0], py = point[1], pz = point[2];
 
         let best_d2 = Infinity;
-        const baryc = scratch_barycentric;
         for (let i = 0; i < tri; i++) {
             const ia = idx[i * 3] * 3, ib = idx[i * 3 + 1] * 3, ic = idx[i * 3 + 2] * 3;
             const ax = v[ia], ay = v[ia + 1], az = v[ia + 2];
             const bx = v[ib], by = v[ib + 1], bz = v[ib + 2];
             const cx = v[ic], cy = v[ic + 1], cz = v[ic + 2];
-            tri3_closest_point_barycentric(baryc, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
-            const u = baryc[0], w = baryc[1], t = 1 - u - w;
-            const qx = u * ax + w * bx + t * cx;
-            const qy = u * ay + w * by + t * cy;
-            const qz = u * az + w * bz + t * cz;
-            const dx = qx - px, dy = qy - py, dz = qz - pz;
-            const d2 = dx * dx + dy * dy + dz * dz;
+            const d2 = tri3_closest_point(scratch_closest, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
             if (d2 < best_d2) best_d2 = d2;
         }
         const dist = Math.sqrt(best_d2);
@@ -276,44 +268,20 @@ export class ConvexHullShape3D extends AbstractShape3D {
 
         let best_d2 = Infinity;
         let bx_ = 0, by_ = 0, bz_ = 0;
-        const baryc = scratch_barycentric;
         for (let i = 0; i < tri; i++) {
             const ia = idx[i * 3] * 3, ib = idx[i * 3 + 1] * 3, ic = idx[i * 3 + 2] * 3;
             const ax = v[ia], ay = v[ia + 1], az = v[ia + 2];
             const bx = v[ib], by = v[ib + 1], bz = v[ib + 2];
             const cx = v[ic], cy = v[ic + 1], cz = v[ic + 2];
-            tri3_closest_point_barycentric(baryc, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
-            const u = baryc[0], w = baryc[1], t = 1 - u - w;
-            const qx = u * ax + w * bx + t * cx;
-            const qy = u * ay + w * by + t * cy;
-            const qz = u * az + w * bz + t * cz;
-            const dx = qx - px, dy = qy - py, dz = qz - pz;
-            const d2 = dx * dx + dy * dy + dz * dz;
-            if (d2 < best_d2) { best_d2 = d2; bx_ = qx; by_ = qy; bz_ = qz; }
+            const d2 = tri3_closest_point(scratch_closest, 0, px, py, pz, ax, ay, az, bx, by, bz, cx, cy, cz);
+            if (d2 < best_d2) {
+                best_d2 = d2;
+                bx_ = scratch_closest[0]; by_ = scratch_closest[1]; bz_ = scratch_closest[2];
+            }
         }
         result[0] = bx_; result[1] = by_; result[2] = bz_;
     }
 
-    sample_random_point_in_volume(result, result_offset, random) {
-        const b = this.__bbox;
-        const lx = b[0], ly = b[1], lz = b[2];
-        const sx = b[3] - b[0], sy = b[4] - b[1], sz = b[5] - b[2];
-        const probe = scratch_point;
-        for (let attempt = 0; attempt < 256; attempt++) {
-            probe[0] = lx + random() * sx;
-            probe[1] = ly + random() * sy;
-            probe[2] = lz + random() * sz;
-            if (this.contains_point(probe)) {
-                result[result_offset] = probe[0];
-                result[result_offset + 1] = probe[1];
-                result[result_offset + 2] = probe[2];
-                return;
-            }
-        }
-        result[result_offset] = lx + sx * 0.5;
-        result[result_offset + 1] = ly + sy * 0.5;
-        result[result_offset + 2] = lz + sz * 0.5;
-    }
 
     /**
      * @param {ConvexHullShape3D} other
@@ -335,12 +303,12 @@ export class ConvexHullShape3D extends AbstractShape3D {
     hash() {
         const v_count = this.vertices.length / 3 | 0;
         const t_count = this.indices.length / 3 | 0;
-        let h = (v_count * 31 + t_count) | 0;
+        let h = hash_mix2(v_count, t_count);
         if (this.vertices.length >= 3) {
-            h = (h * 31 + (computeHashFloat(this.vertices[0]))) | 0;
-            h = (h * 31 + (computeHashFloat(this.vertices[this.vertices.length - 1]))) | 0;
+            h = hash_mix2(h, computeHashFloat(this.vertices[0]));
+            h = hash_mix2(h, computeHashFloat(this.vertices[this.vertices.length - 1]));
         }
-        return h | 0;
+        return h;
     }
 }
 
@@ -351,5 +319,6 @@ export class ConvexHullShape3D extends AbstractShape3D {
  */
 ConvexHullShape3D.prototype.isConvexHullShape3D = true;
 
-const scratch_barycentric = new Float64Array(2);
+// closest-point-on-triangle output for the surface-scan query helpers
+const scratch_closest = new Float64Array(3);
 const scratch_point = new Float64Array(3);

package/src/core/geom/3d/shape/CylinderShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CylinderShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/CylinderShape3D.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AACH;IAkBI;;;;OAIG;IACH,oBAJW,MAAM,UACN,MAAM,GACJ,eAAe,CAa3B;IA9BG;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,QAFU,MAAM,CAED;IAgCnB,wCAUC;IAED,qGAqBC;IAED,6CAoBC;IAED,mEAEC;IAED,oCASC;IAED,4DA0CC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,eAAe,GACb,OAAO,CAMnB;IAUL;;;;;;;OAOG;IACH,4BAFU,OAAO,CAE0B;CAV1C;gCA/M+B,sBAAsB"}
+{"version":3,"file":"CylinderShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/CylinderShape3D.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;GAaG;AACH;IAkBI;;;;OAIG;IACH,oBAJW,MAAM,UACN,MAAM,GACJ,eAAe,CAa3B;IA9BG;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,QAFU,MAAM,CAED;IAgCnB,wCAUC;IAED,qGAqBC;IAED,6CAoBC;IAED,mEAEC;IAED,oCASC;IAED,4DA0CC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,eAAe,GACb,OAAO,CAMnB;IAUL;;;;;;;OAOG;IACH,4BAFU,OAAO,CAE0B;CAV1C;gCA/M+B,sBAAsB"}