@woosh/meep-engine 3.44.0 → 3.46.0

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

@@ -0,0 +1,66 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Limit a rotation's angle: `out` turns about the same axis as `q` by `min(θ, max_angle)`, exactly.
+ *
+ * The rotation is read as an axis and an angle and the angle is replaced, so the answer is the
+ * limit itself and not an approximation of it. The alternative it exists to replace — nlerp from
+ * the identity towards `q` by `max_angle / θ` — follows the chord rather than the arc and
+ * undershoots more the larger `θ` is: at `θ = π` asked for `π/4` it turns `0.64` rad, not `0.785`.
+ *
+ * `q` and `-q` name the same rotation; the angle is measured on the one with `w ≥ 0`, so `θ` is
+ * the shorter turn, in `[0, π]`. A rotation within the limit is passed through unchanged, sign
+ * included; one beyond it is written with `w ≥ 0`. The identity (no axis) is within any limit.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `q`: every component is read before the first write.
+ *
+ * **Precondition: `q` is a unit quaternion.** The angle is `2·atan2(|v|, w)`, which does not care,
+ * but a limited rotation is written unit and an unlimited one as it came.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} q `[x, y, z, w]`
+ * @param {number} q_offset
+ * @param {number} max_angle radians, `≥ 0`
+ */
+export function quat3_clamp_angle_array(out, out_offset, q, q_offset, max_angle) {
+    assert.isNumber(max_angle, 'max_angle');
+    assert.greaterThanOrEqual(max_angle, 0, 'max_angle must be non-negative');
+
+    let x = q[q_offset], y = q[q_offset + 1], z = q[q_offset + 2], w = q[q_offset + 3];
+
+    const pass_x = x, pass_y = y, pass_z = z, pass_w = w;
+
+    if (w < 0) {
+        x = -x;
+        y = -y;
+        z = -z;
+        w = -w;
+    }
+
+    const sin_half = Math.sqrt(x * x + y * y + z * z);
+
+    // atan2 rather than acos(w): accurate near the identity, where acos loses half the digits
+    const angle = 2 * Math.atan2(sin_half, w);
+
+    if (angle <= max_angle) {
+        out[out_offset] = pass_x;
+        out[out_offset + 1] = pass_y;
+        out[out_offset + 2] = pass_z;
+        out[out_offset + 3] = pass_w;
+
+        return;
+    }
+
+    // sin_half > 0 here: a zero vector part has angle 0, within any limit
+    const half = max_angle * 0.5;
+    const k = Math.sin(half) / sin_half;
+
+    out[out_offset] = x * k;
+    out[out_offset + 1] = y * k;
+    out[out_offset + 2] = z * k;
+    out[out_offset + 3] = Math.cos(half);
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Hamilton product with the left operand conjugated, `out = a* ⊗ b`, both read from arrays.
+ *
+ * For unit quaternions the conjugate is the inverse, so this is `a⁻¹ ⊗ b`: the rotation `b` expressed
+ * in the frame `a` rotates into — a world orientation written in a parent's or a body's frame. Callers
+ * used to build `a*` in a scratch array and hand it to {@link quat3_multiply_array}; the conjugate's
+ * signs are folded into the product here instead, so there is no scratch and no extra pass.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `a` or `b`: all eight components are read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`, the operand that is conjugated
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`
+ * @param {number} b_offset
+ */
+export function quat3_multiply_conjugate_left_array(out: number[] | Float32Array | Float64Array, out_offset: number, a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number): void;
+//# sourceMappingURL=quat3_multiply_conjugate_left_array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_multiply_conjugate_left_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply_conjugate_left_array.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yDAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAWhB"}

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

@@ -0,0 +1,30 @@
+/**
+ * Hamilton product with the left operand conjugated, `out = a* ⊗ b`, both read from arrays.
+ *
+ * For unit quaternions the conjugate is the inverse, so this is `a⁻¹ ⊗ b`: the rotation `b` expressed
+ * in the frame `a` rotates into — a world orientation written in a parent's or a body's frame. Callers
+ * used to build `a*` in a scratch array and hand it to {@link quat3_multiply_array}; the conjugate's
+ * signs are folded into the product here instead, so there is no scratch and no extra pass.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `a` or `b`: all eight components are read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`, the operand that is conjugated
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`
+ * @param {number} b_offset
+ */
+export function quat3_multiply_conjugate_left_array(out, out_offset, a, a_offset, b, b_offset) {
+    const ax = a[a_offset], ay = a[a_offset + 1], az = a[a_offset + 2], aw = a[a_offset + 3];
+    const bx = b[b_offset], by = b[b_offset + 1], bz = b[b_offset + 2], bw = b[b_offset + 3];
+
+    // quat3_multiply with (ax, ay, az) negated
+    out[out_offset]     = aw * bx - ax * bw - ay * bz + az * by;
+    out[out_offset + 1] = aw * by + ax * bz - ay * bw - az * bx;
+    out[out_offset + 2] = aw * bz - ax * by + ay * bx - az * bw;
+    out[out_offset + 3] = aw * bw + ax * bx + ay * by + az * bz;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Hamilton product with the right operand conjugated, `out = a ⊗ b*`, both read from arrays.
+ *
+ * For unit quaternions the conjugate is the inverse, so this is `a ⊗ b⁻¹`: the world-frame rotation
+ * that takes orientation `b` to orientation `a` — the turn a holder made since a hold began, the
+ * rotation a body must make to reach a target. Callers used to build `b*` in a scratch array, or pass
+ * its components negated, to {@link quat3_multiply_array}; the conjugate's signs are folded into the
+ * product here instead.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `a` or `b`: all eight components are read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`, the operand that is conjugated
+ * @param {number} b_offset
+ */
+export function quat3_multiply_conjugate_right_array(out: number[] | Float32Array | Float64Array, out_offset: number, a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number): void;
+//# sourceMappingURL=quat3_multiply_conjugate_right_array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_multiply_conjugate_right_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply_conjugate_right_array.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,0DAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,QAWhB"}

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

@@ -0,0 +1,31 @@
+/**
+ * Hamilton product with the right operand conjugated, `out = a ⊗ b*`, both read from arrays.
+ *
+ * For unit quaternions the conjugate is the inverse, so this is `a ⊗ b⁻¹`: the world-frame rotation
+ * that takes orientation `b` to orientation `a` — the turn a holder made since a hold began, the
+ * rotation a body must make to reach a target. Callers used to build `b*` in a scratch array, or pass
+ * its components negated, to {@link quat3_multiply_array}; the conjugate's signs are folded into the
+ * product here instead.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * `out` may be `a` or `b`: all eight components are read before the first write.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number[]|Float32Array|Float64Array} a `[x, y, z, w]`
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b `[x, y, z, w]`, the operand that is conjugated
+ * @param {number} b_offset
+ */
+export function quat3_multiply_conjugate_right_array(out, out_offset, a, a_offset, b, b_offset) {
+    const ax = a[a_offset], ay = a[a_offset + 1], az = a[a_offset + 2], aw = a[a_offset + 3];
+    const bx = b[b_offset], by = b[b_offset + 1], bz = b[b_offset + 2], bw = b[b_offset + 3];
+
+    // quat3_multiply with (bx, by, bz) negated
+    out[out_offset]     = ax * bw - aw * bx - ay * bz + az * by;
+    out[out_offset + 1] = ay * bw - aw * by + ax * bz - az * bx;
+    out[out_offset + 2] = az * bw - aw * bz - ax * by + ay * bx;
+    out[out_offset + 3] = aw * bw + ax * bx + ay * by + az * bz;
+}

package/src/core/geom/3d/triangle/tri3_compute_normal_area_weighted_array.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The face normal of triangle `abc`, NOT normalised: the raw cross product `(c − b) × (a − b)`, whose
+ * magnitude is twice the triangle's area and whose direction follows the counter-clockwise winding
+ * `a → b → c`, the same winding {@link tri3_compute_normal} uses.
+ *
+ * The magnitude is the point. A pass that accumulates one normal per incident face and normalises at
+ * the end wants each face to pull in proportion to how much surface it is, so that a sliver beside a
+ * large face hardly moves the result and retriangulating the same surface does not change it. A
+ * triangle with no area contributes a zero vector, which is the right vote for nothing, where a
+ * normalising helper has to invent some unit vector.
+ *
+ * Each corner is its own array and offset, so corners may live in one shared position buffer
+ * (`positions, index * 3`) or anywhere else. `out` may alias any of them.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} b_offset
+ * @param {number[]|Float32Array|Float64Array} c
+ * @param {number} c_offset
+ * @returns {void}
+ */
+export function tri3_compute_normal_area_weighted_array(out: number[] | Float32Array | Float64Array, out_offset: number, a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number, c: number[] | Float32Array | Float64Array, c_offset: number): void;
+//# sourceMappingURL=tri3_compute_normal_area_weighted_array.d.ts.map

package/src/core/geom/3d/triangle/tri3_compute_normal_area_weighted_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_compute_normal_area_weighted_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_compute_normal_area_weighted_array.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6DAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,GACJ,IAAI,CAuBhB"}

package/src/core/geom/3d/triangle/tri3_compute_normal_area_weighted_array.js

@@ -0,0 +1,46 @@
+/**
+ * The face normal of triangle `abc`, NOT normalised: the raw cross product `(c − b) × (a − b)`, whose
+ * magnitude is twice the triangle's area and whose direction follows the counter-clockwise winding
+ * `a → b → c`, the same winding {@link tri3_compute_normal} uses.
+ *
+ * The magnitude is the point. A pass that accumulates one normal per incident face and normalises at
+ * the end wants each face to pull in proportion to how much surface it is, so that a sliver beside a
+ * large face hardly moves the result and retriangulating the same surface does not change it. A
+ * triangle with no area contributes a zero vector, which is the right vote for nothing, where a
+ * normalising helper has to invent some unit vector.
+ *
+ * Each corner is its own array and offset, so corners may live in one shared position buffer
+ * (`positions, index * 3`) or anywhere else. `out` may alias any of them.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} b_offset
+ * @param {number[]|Float32Array|Float64Array} c
+ * @param {number} c_offset
+ * @returns {void}
+ */
+export function tri3_compute_normal_area_weighted_array(
+    out, out_offset,
+    a, a_offset,
+    b, b_offset,
+    c, c_offset
+) {
+    const bx = b[b_offset];
+    const by = b[b_offset + 1];
+    const bz = b[b_offset + 2];
+
+    const cb_x = c[c_offset] - bx;
+    const cb_y = c[c_offset + 1] - by;
+    const cb_z = c[c_offset + 2] - bz;
+
+    const ab_x = a[a_offset] - bx;
+    const ab_y = a[a_offset + 1] - by;
+    const ab_z = a[a_offset + 2] - bz;
+
+    out[out_offset] = cb_y * ab_z - cb_z * ab_y;
+    out[out_offset + 1] = cb_z * ab_x - cb_x * ab_z;
+    out[out_offset + 2] = cb_x * ab_y - cb_y * ab_x;
+}

package/src/core/geom/ConicRay.js

@@ -1,5 +1,5 @@
 import { assert } from "../assert.js";
-import { combine_hash } from "../collection/array/combine_hash.js";
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
 import { EPSILON } from "../math/EPSILON.js";
 import { epsilonEquals } from "../math/epsilonEquals.js";
 import { PI2 } from "../math/PI2.js";
@@ -90,7 +90,7 @@ export class ConicRay {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeHashFloat(this.angle),
             this.direction.hash()
         );

package/src/core/geom/Vector4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAMA;;;GAGG;AAGH;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,8DAFwB,MAAM;IAuc1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IApbD;;;;OAIG;IACH,uDAEC;IArCD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAuBhB;IAXG,UAAW;IACX,UAAW;IACX,UAAW;IACX,UAAW;IAEX;;;;OAIG;IACH,wBAA6B;IAoBjC;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,iBAJW,OAAO,SACP,MAAM,GACJ,IAAI,CAShB;IAED;;;;OAIG;IACH,qBAHW;QAAC,QAAQ,EAAE,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC/B,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAGD;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IAmBL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBAlXe,MAAM,EAAE,WACR,MAAM,UAiXM;IAC3B,iBArWe,MAAM,EAAE,WACR,MAAM,UAoWI;CATxB;;kBAaS,MAAM;;;yBAvfH,OAAO,iBAAiB,EAAE,UAAU;sBACpC,OAAO,cAAc,EAAE,OAAO;2BAK9B,OAAO,2BAA2B,EAAE,YAAY"}
+{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAOA;;;GAGG;AAGH;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,8DAFwB,MAAM;IAyc1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IAtbD;;;;OAIG;IACH,uDAEC;IArCD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAuBhB;IAXG,UAAW;IACX,UAAW;IACX,UAAW;IACX,UAAW;IAEX;;;;OAIG;IACH,wBAA6B;IAoBjC;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,iBAJW,OAAO,SACP,MAAM,GACJ,IAAI,CAShB;IAED;;;;OAIG;IACH,qBAHW;QAAC,QAAQ,EAAE,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC/B,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAWjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAGD;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IAmBL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBApXe,MAAM,EAAE,WACR,MAAM,UAmXM;IAC3B,iBAvWe,MAAM,EAAE,WACR,MAAM,UAsWI;CATxB;;kBAaS,MAAM;;;yBAzfH,OAAO,iBAAiB,EAAE,UAAU;sBACpC,OAAO,cAAc,EAAE,OAAO;2BAK9B,OAAO,2BAA2B,EAAE,YAAY"}

package/src/core/geom/Vector4.js

@@ -1,5 +1,6 @@
 import { assert } from "../assert.js";
-import { combine_hash } from "../collection/array/combine_hash.js";
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
+import { hash_mix3 } from "../math/hash/hash_mix3.js";
 import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
@@ -405,10 +406,12 @@ export class Vector4 extends Float64Array {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this[0]),
-            computeHashFloat(this[1]),
-            computeHashFloat(this[2]),
+        return hash_mix2(
+            hash_mix3(
+                computeHashFloat(this[0]),
+                computeHashFloat(this[1]),
+                computeHashFloat(this[2])
+            ),
             computeHashFloat(this[3])
         );
     }

package/src/core/geom/vec3/v3_distance_array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Euclidean distance between two 3-vectors stored in arrays.
+ *
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} b_offset
+ * @returns {number}
+ */
+export function v3_distance_array(a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number): number;
+//# sourceMappingURL=v3_distance_array.d.ts.map

package/src/core/geom/vec3/v3_distance_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_distance_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_distance_array.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,GACJ,MAAM,CAWlB"}

package/src/core/geom/vec3/v3_distance_array.js

@@ -0,0 +1,19 @@
+/**
+ * Euclidean distance between two 3-vectors stored in arrays.
+ *
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number} a_offset
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} b_offset
+ * @returns {number}
+ */
+export function v3_distance_array(
+    a, a_offset,
+    b, b_offset
+) {
+    const dx = b[b_offset] - a[a_offset];
+    const dy = b[b_offset + 1] - a[a_offset + 1];
+    const dz = b[b_offset + 2] - a[a_offset + 2];
+
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}

package/src/core/geom/vec3/v3_normalize_array_checked.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Normalise a vector, reporting whether it had a direction to normalise.
+ *
+ * Unlike {@link v3_normalize_array}, which passes a zero vector through and scales anything else, a
+ * vector whose squared length is below `epsilon_sqr` is refused: `false` is returned and `output` is
+ * not written at all, so with `output === input` the vector is left as it was. A vector that short
+ * has a direction made of rounding, and a caller that builds a rotation from it wants to know.
+ *
+ * So is a vector with no finite squared length — a NaN component, an infinite one, or one so long
+ * its square overflows — since none of those leaves a unit vector to write.
+ *
+ * `output` may alias `input`.
+ *
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_offset
+ * @param {number} epsilon_sqr squared length below which the vector has no direction; positive, since at
+ * zero a zero vector would pass and normalise to NaN
+ * @returns {boolean} true when `output` received the unit vector, false when it was not written
+ */
+export function v3_normalize_array_checked(output: number[] | Float32Array | Float64Array, output_offset: number, input: number[] | Float32Array | Float64Array, input_offset: number, epsilon_sqr: number): boolean;
+//# sourceMappingURL=v3_normalize_array_checked.d.ts.map

package/src/core/geom/vec3/v3_normalize_array_checked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_normalize_array_checked.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_normalize_array_checked.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,eACN,MAAM,GAEJ,OAAO,CA2BnB"}

package/src/core/geom/vec3/v3_normalize_array_checked.js

@@ -0,0 +1,49 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Normalise a vector, reporting whether it had a direction to normalise.
+ *
+ * Unlike {@link v3_normalize_array}, which passes a zero vector through and scales anything else, a
+ * vector whose squared length is below `epsilon_sqr` is refused: `false` is returned and `output` is
+ * not written at all, so with `output === input` the vector is left as it was. A vector that short
+ * has a direction made of rounding, and a caller that builds a rotation from it wants to know.
+ *
+ * So is a vector with no finite squared length — a NaN component, an infinite one, or one so long
+ * its square overflows — since none of those leaves a unit vector to write.
+ *
+ * `output` may alias `input`.
+ *
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_offset
+ * @param {number} epsilon_sqr squared length below which the vector has no direction; positive, since at
+ * zero a zero vector would pass and normalise to NaN
+ * @returns {boolean} true when `output` received the unit vector, false when it was not written
+ */
+export function v3_normalize_array_checked(
+    output, output_offset,
+    input, input_offset,
+    epsilon_sqr
+) {
+    assert.greaterThan(epsilon_sqr, 0, 'epsilon_sqr');
+
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    const length_sqr = x * x + y * y + z * z;
+
+    // Written so that NaN, which fails every comparison, lands on the refusing side.
+    if (!(length_sqr >= epsilon_sqr && length_sqr < Infinity)) {
+        return false;
+    }
+
+    const inverse = 1 / Math.sqrt(length_sqr);
+
+    output[output_offset] = x * inverse;
+    output[output_offset + 1] = y * inverse;
+    output[output_offset + 2] = z * inverse;
+
+    return true;
+}

package/src/core/geom/vec3/v3_reject_array.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Vector rejection: the part of `v` square to the unit vector `n`, `v − (v·n) n`. Equivalently, `v`
+ * projected onto the plane through the origin whose normal is `n`.
+ *
+ * `n` must be of unit length; nothing here normalises it. `output` may alias `input` or `normal`.
+ *
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input `v`
+ * @param {number} input_offset
+ * @param {number[]|Float32Array|Float64Array} normal `n`, unit length
+ * @param {number} normal_offset
+ */
+export function v3_reject_array(output: number[] | Float32Array | Float64Array, output_offset: number, input: number[] | Float32Array | Float64Array, input_offset: number, normal: number[] | Float32Array | Float64Array, normal_offset: number): void;
+//# sourceMappingURL=v3_reject_array.d.ts.map

package/src/core/geom/vec3/v3_reject_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_reject_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_reject_array.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QAoBhB"}

package/src/core/geom/vec3/v3_reject_array.js

@@ -0,0 +1,32 @@
+/**
+ * Vector rejection: the part of `v` square to the unit vector `n`, `v − (v·n) n`. Equivalently, `v`
+ * projected onto the plane through the origin whose normal is `n`.
+ *
+ * `n` must be of unit length; nothing here normalises it. `output` may alias `input` or `normal`.
+ *
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input `v`
+ * @param {number} input_offset
+ * @param {number[]|Float32Array|Float64Array} normal `n`, unit length
+ * @param {number} normal_offset
+ */
+export function v3_reject_array(
+    output, output_offset,
+    input, input_offset,
+    normal, normal_offset
+) {
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    const nx = normal[normal_offset];
+    const ny = normal[normal_offset + 1];
+    const nz = normal[normal_offset + 2];
+
+    const d = x * nx + y * ny + z * nz;
+
+    output[output_offset] = x - d * nx;
+    output[output_offset + 1] = y - d * ny;
+    output[output_offset + 2] = z - d * nz;
+}

package/src/core/graph/csr/csr_build_incidence.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Group the indices of a key array by key, as CSR: for every bucket `k`, the items
+ * `out_items[out_offset[k] .. out_offset[k + 1])` are the indices `i` with `keys[i] === k`, in ascending order.
+ *
+ * This is the counting sort behind every "which rows touch this vertex" table — count each key into
+ * `out_offset[k + 1]`, prefix-sum, then scatter each index through a per-bucket cursor. A key array with a
+ * fixed arity (two vertices per edge, three per triangle) is passed flat, and an item is then the flat index
+ * `element · arity + slot`; a caller that wants the element divides by the arity. Ascending order within a
+ * bucket is what makes the result a function of the keys alone, and what lets a consumer walking a bucket
+ * read its elements' tables forwards.
+ *
+ * A negative key is skipped: it is in no bucket and its index appears nowhere — the form a parent array takes
+ * at its roots.
+ *
+ * Allocation-free: `out_offset` itself is the scatter cursor. After the scatter every `out_offset[k]` has
+ * advanced to the start of bucket `k + 1`, so one shift down by a slot restores the starts.
+ *
+ * @param {Int32Array|Uint32Array|number[]} out_offset written whole, `bucket_count + 1` entries; the last is the
+ *   number of items written
+ * @param {Int32Array|Uint32Array|number[]} out_items at least as long as the number of non-negative keys
+ * @param {ArrayLike<number>} keys bucket of each index, in `[0, bucket_count)`, or negative for none
+ * @param {number} key_count how many leading entries of `keys` to group
+ * @param {number} bucket_count
+ */
+export function csr_build_incidence(out_offset: Int32Array | Uint32Array | number[], out_items: Int32Array | Uint32Array | number[], keys: ArrayLike<number>, key_count: number, bucket_count: number): void;
+//# sourceMappingURL=csr_build_incidence.d.ts.map

package/src/core/graph/csr/csr_build_incidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csr_build_incidence.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/csr_build_incidence.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,gDAPW,UAAU,GAAC,WAAW,GAAC,MAAM,EAAE,aAE/B,UAAU,GAAC,WAAW,GAAC,MAAM,EAAE,QAC/B,UAAU,MAAM,CAAC,aACjB,MAAM,gBACN,MAAM,QA8ChB"}

package/src/core/graph/csr/csr_build_incidence.js

@@ -0,0 +1,71 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Group the indices of a key array by key, as CSR: for every bucket `k`, the items
+ * `out_items[out_offset[k] .. out_offset[k + 1])` are the indices `i` with `keys[i] === k`, in ascending order.
+ *
+ * This is the counting sort behind every "which rows touch this vertex" table — count each key into
+ * `out_offset[k + 1]`, prefix-sum, then scatter each index through a per-bucket cursor. A key array with a
+ * fixed arity (two vertices per edge, three per triangle) is passed flat, and an item is then the flat index
+ * `element · arity + slot`; a caller that wants the element divides by the arity. Ascending order within a
+ * bucket is what makes the result a function of the keys alone, and what lets a consumer walking a bucket
+ * read its elements' tables forwards.
+ *
+ * A negative key is skipped: it is in no bucket and its index appears nowhere — the form a parent array takes
+ * at its roots.
+ *
+ * Allocation-free: `out_offset` itself is the scatter cursor. After the scatter every `out_offset[k]` has
+ * advanced to the start of bucket `k + 1`, so one shift down by a slot restores the starts.
+ *
+ * @param {Int32Array|Uint32Array|number[]} out_offset written whole, `bucket_count + 1` entries; the last is the
+ *   number of items written
+ * @param {Int32Array|Uint32Array|number[]} out_items at least as long as the number of non-negative keys
+ * @param {ArrayLike<number>} keys bucket of each index, in `[0, bucket_count)`, or negative for none
+ * @param {number} key_count how many leading entries of `keys` to group
+ * @param {number} bucket_count
+ */
+export function csr_build_incidence(out_offset, out_items, keys, key_count, bucket_count) {
+    assert.isNonNegativeInteger(key_count, 'key_count');
+    assert.isNonNegativeInteger(bucket_count, 'bucket_count');
+    assert.greaterThanOrEqual(out_offset.length, bucket_count + 1, 'out_offset shorter than bucket_count + 1');
+    assert.greaterThanOrEqual(keys.length, key_count, 'keys shorter than key_count');
+
+    for (let k = 0; k <= bucket_count; k++) {
+        out_offset[k] = 0;
+    }
+
+    for (let i = 0; i < key_count; i++) {
+        const key = keys[i];
+
+        if (key < 0) {
+            continue;
+        }
+
+        assert.lessThan(key, bucket_count, 'key out of range');
+
+        out_offset[key + 1]++;
+    }
+
+    for (let k = 0; k < bucket_count; k++) {
+        out_offset[k + 1] += out_offset[k];
+    }
+
+    assert.greaterThanOrEqual(out_items.length, out_offset[bucket_count], 'out_items shorter than the item count');
+
+    // `out_offset[k]` is bucket `k`'s write cursor; it ends at the start of bucket `k + 1`
+    for (let i = 0; i < key_count; i++) {
+        const key = keys[i];
+
+        if (key < 0) {
+            continue;
+        }
+
+        out_items[out_offset[key]++] = i;
+    }
+
+    for (let k = bucket_count; k > 0; k--) {
+        out_offset[k] = out_offset[k - 1];
+    }
+
+    out_offset[0] = 0;
+}

package/src/core/graph/csr/csr_graph_color_greedy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Greedy graph colouring over a CSR adjacency: visit the vertices in `order`, and give each the lowest colour
+ * none of its already-coloured neighbours holds.
+ *
+ * Greedy colouring is order-sensitive, and the order is the caller's — Welsh–Powell's largest-degree-first
+ * is the usual choice, and the reason it is a parameter rather than a policy. For a given order the result
+ * is fully determined: the order of neighbours within a row, and duplicate entries in a row, do not change
+ * it. A vertex's colour is at most its degree, so the colour count is at most the largest degree plus one.
+ *
+ * Works on the raw CSR arrays rather than a {@link CSRGraph}, so any row-pointer/column-index pair can be
+ * coloured without being copied into one; for a `CSRGraph` pass `graph.edge_addresses, graph.adjacency`.
+ * A self-loop is ignored, since a vertex is uncoloured while its own colour is being chosen.
+ *
+ * Allocation-free per call, beyond growing the module scratch to `vertex_count + 1`; not reentrant.
+ *
+ * @param {Uint32Array|Int32Array|number[]} out_colors colour of every vertex, written for `[0, vertex_count)`
+ * @param {Uint32Array|Int32Array|ArrayLike<number>} edge_addresses row offsets, `vertex_count + 1` entries
+ * @param {Uint32Array|Int32Array|ArrayLike<number>} adjacency neighbour ids, rows
+ *   `adjacency[edge_addresses[v] .. edge_addresses[v + 1])`
+ * @param {ArrayLike<number>} order a permutation of `[0, vertex_count)`, the visit order
+ * @param {number} vertex_count
+ * @returns {number} number of colours used; colours are `[0, count)`
+ */
+export function csr_graph_color_greedy(out_colors: Uint32Array | Int32Array | number[], edge_addresses: Uint32Array | Int32Array | ArrayLike<number>, adjacency: Uint32Array | Int32Array | ArrayLike<number>, order: ArrayLike<number>, vertex_count: number): number;
+//# sourceMappingURL=csr_graph_color_greedy.d.ts.map

package/src/core/graph/csr/csr_graph_color_greedy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csr_graph_color_greedy.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/csr_graph_color_greedy.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mDARW,WAAW,GAAC,UAAU,GAAC,MAAM,EAAE,kBAC/B,WAAW,GAAC,UAAU,GAAC,UAAU,MAAM,CAAC,aACxC,WAAW,GAAC,UAAU,GAAC,UAAU,MAAM,CAAC,SAExC,UAAU,MAAM,CAAC,gBACjB,MAAM,GACJ,MAAM,CAmDlB"}