@woosh/meep-engine 3.44.0 → 3.46.0

package/src/core/math/linalg/matrix_symmetric_3x3_solve_ldlt.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Solve `M·x = b` for a symmetric positive definite 3×3 `M`, by LDLᵀ factorisation.
+ *
+ * `M` is read as its six distinct entries, diagonal first: `[m00, m11, m22, m01, m02, m12]`.
+ *
+ * LDLᵀ rather than a cofactor inverse. The two agree in exact arithmetic and do not agree in Float64: an SPD
+ * matrix with a condition number in the billions has a cofactor determinant — a sum of triple products that
+ * has to cancel down by that ratio squared — that can come out *negative* although every eigenvalue is
+ * positive. The factorisation never forms those products, so its pivots stay positive where the determinant
+ * does not, and their product is the determinant to full precision.
+ *
+ * The pivots of an SPD matrix are `M` restricted to nested subspaces, so all three positive *is* positive
+ * definiteness: the function checks exactly that, and returns `false` without writing `out` when a pivot is
+ * not positive and finite — an indefinite, singular or non-finite `M`. An infinite pivot needs refusing
+ * explicitly: it is positive, and dividing by it reads as a finite solution, zero along that axis.
+ *
+ * @param {Float64Array|Float32Array|number[]} out solution `x`, 3 entries at `out_offset`
+ * @param {number} out_offset
+ * @param {Float64Array|Float32Array|number[]} m `[m00, m11, m22, m01, m02, m12]` at `m_offset`
+ * @param {number} m_offset
+ * @param {Float64Array|Float32Array|number[]} b right-hand side, 3 entries at `b_offset`
+ * @param {number} b_offset
+ * @returns {boolean} true when `M` was positive definite and `out` holds the solution
+ */
+export function matrix_symmetric_3x3_solve_ldlt(out: Float64Array | Float32Array | number[], out_offset: number, m: Float64Array | Float32Array | number[], m_offset: number, b: Float64Array | Float32Array | number[], b_offset: number): boolean;
+//# sourceMappingURL=matrix_symmetric_3x3_solve_ldlt.d.ts.map

package/src/core/math/linalg/matrix_symmetric_3x3_solve_ldlt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_symmetric_3x3_solve_ldlt.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/matrix_symmetric_3x3_solve_ldlt.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAClC,MAAM,KACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAClC,MAAM,GACJ,OAAO,CAgDnB"}

package/src/core/math/linalg/matrix_symmetric_3x3_solve_ldlt.js

@@ -0,0 +1,71 @@
+/**
+ * Solve `M·x = b` for a symmetric positive definite 3×3 `M`, by LDLᵀ factorisation.
+ *
+ * `M` is read as its six distinct entries, diagonal first: `[m00, m11, m22, m01, m02, m12]`.
+ *
+ * LDLᵀ rather than a cofactor inverse. The two agree in exact arithmetic and do not agree in Float64: an SPD
+ * matrix with a condition number in the billions has a cofactor determinant — a sum of triple products that
+ * has to cancel down by that ratio squared — that can come out *negative* although every eigenvalue is
+ * positive. The factorisation never forms those products, so its pivots stay positive where the determinant
+ * does not, and their product is the determinant to full precision.
+ *
+ * The pivots of an SPD matrix are `M` restricted to nested subspaces, so all three positive *is* positive
+ * definiteness: the function checks exactly that, and returns `false` without writing `out` when a pivot is
+ * not positive and finite — an indefinite, singular or non-finite `M`. An infinite pivot needs refusing
+ * explicitly: it is positive, and dividing by it reads as a finite solution, zero along that axis.
+ *
+ * @param {Float64Array|Float32Array|number[]} out solution `x`, 3 entries at `out_offset`
+ * @param {number} out_offset
+ * @param {Float64Array|Float32Array|number[]} m `[m00, m11, m22, m01, m02, m12]` at `m_offset`
+ * @param {number} m_offset
+ * @param {Float64Array|Float32Array|number[]} b right-hand side, 3 entries at `b_offset`
+ * @param {number} b_offset
+ * @returns {boolean} true when `M` was positive definite and `out` holds the solution
+ */
+export function matrix_symmetric_3x3_solve_ldlt(
+    out, out_offset,
+    m, m_offset,
+    b, b_offset
+) {
+    const m00 = m[m_offset];
+    const m11 = m[m_offset + 1];
+    const m22 = m[m_offset + 2];
+    const m01 = m[m_offset + 3];
+    const m02 = m[m_offset + 4];
+    const m12 = m[m_offset + 5];
+
+    const pivot_0 = m00;
+    const lower_10 = m01 / pivot_0;
+    const lower_20 = m02 / pivot_0;
+
+    const pivot_1 = m11 - lower_10 * m01;
+    const lower_21 = (m12 - lower_20 * m01) / pivot_1;
+
+    const pivot_2 = m22 - lower_20 * m02 - lower_21 * lower_21 * pivot_1;
+
+    if (!(
+        pivot_0 > 0 && pivot_0 < Infinity
+        && pivot_1 > 0 && pivot_1 < Infinity
+        && pivot_2 > 0 && pivot_2 < Infinity
+    )) {
+        return false;
+    }
+
+    const b0 = b[b_offset];
+    const b1 = b[b_offset + 1];
+    const b2 = b[b_offset + 2];
+
+    // Forward substitution through L, scale by D, back substitution through Lᵀ.
+    const forward_1 = b1 - lower_10 * b0;
+    const forward_2 = b2 - lower_20 * b0 - lower_21 * forward_1;
+
+    const x2 = forward_2 / pivot_2;
+    const x1 = forward_1 / pivot_1 - lower_21 * x2;
+    const x0 = b0 / pivot_0 - lower_10 * x1 - lower_20 * x2;
+
+    out[out_offset] = x0;
+    out[out_offset + 1] = x1;
+    out[out_offset + 2] = x2;
+
+    return true;
+}

package/src/core/math/lookup/ParameterLookupTable.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { combine_hash } from "../../collection/array/combine_hash.js";
+import { hash_mix3 } from "../hash/hash_mix3.js";
 import { isArrayEqualStrict } from "../../collection/array/isArrayEqualStrict.js";
 import { computeHashFloatArray } from "../hash/computeHashFloatArray.js";
 import { inverseLerp } from "../inverseLerp.js";
@@ -377,7 +377,7 @@ export class ParameterLookupTable {
             const dataHash = computeHashFloatArray(this.data);
             const positionHash = computeHashFloatArray(this.positions);
 
-            return combine_hash(
+            return hash_mix3(
                 dataHash,
                 positionHash,
                 this.itemSize

package/src/core/math/max2_exact.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `Math.max(a, b)` without the call, as {@link min2_exact}: the larger, NaN if either is, and `+0`
+ * above `-0`.
+ *
+ * {@link max2} drops a NaN in `b` and lets the first of two zeros win; this does neither.
+ *
+ * The same as `Math.max` under `Object.is` for every pair of numbers, except that a NaN answer is the
+ * canonical NaN.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function max2_exact(a: number, b: number): number;
+//# sourceMappingURL=max2_exact.d.ts.map

package/src/core/math/max2_exact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max2_exact.d.ts","sourceRoot":"","sources":["../../../../src/core/math/max2_exact.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,8BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAkBlB"}

package/src/core/math/max2_exact.js

@@ -0,0 +1,30 @@
+/**
+ * `Math.max(a, b)` without the call, as {@link min2_exact}: the larger, NaN if either is, and `+0`
+ * above `-0`.
+ *
+ * {@link max2} drops a NaN in `b` and lets the first of two zeros win; this does neither.
+ *
+ * The same as `Math.max` under `Object.is` for every pair of numbers, except that a NaN answer is the
+ * canonical NaN.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function max2_exact(a, b) {
+    if (a > b) {
+        return a;
+    }
+
+    if (b > a) {
+        return b;
+    }
+
+    if (a === b) {
+        // equal, and of two zeros the positive one if either is
+        return a === 0 && 1 / a < 0 ? b : a;
+    }
+
+    // one of them is NaN
+    return NaN;
+}

package/src/core/math/min2_exact.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `Math.min(a, b)` without the call: the smaller, NaN if either is, and `-0` below `+0`.
+ *
+ * {@link min2} is `a < b ? a : b`, which answers `b` whenever the comparison is false — a NaN in `a`
+ * is dropped, and of two zeros the second one wins. That is right for a running minimum over values
+ * known to be numbers, and wrong for a bound that has to stay poisoned when its input was.
+ *
+ * Why not `Math.min` itself: in code V8 has not optimised yet (a function run a few times a step can
+ * stay unoptimised for thousands of steps), `Math.min` is a call into a builtin that hands its answer
+ * back boxed into a heap object. This is comparisons only.
+ *
+ * The same as `Math.min` under `Object.is` for every pair of numbers. A NaN answer is the canonical
+ * NaN; which NaN `Math.min` answers is the platform's (on x64, the one with the sign bit set).
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function min2_exact(a: number, b: number): number;
+//# sourceMappingURL=min2_exact.d.ts.map

package/src/core/math/min2_exact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"min2_exact.d.ts","sourceRoot":"","sources":["../../../../src/core/math/min2_exact.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,8BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAkBlB"}

package/src/core/math/min2_exact.js

@@ -0,0 +1,35 @@
+/**
+ * `Math.min(a, b)` without the call: the smaller, NaN if either is, and `-0` below `+0`.
+ *
+ * {@link min2} is `a < b ? a : b`, which answers `b` whenever the comparison is false — a NaN in `a`
+ * is dropped, and of two zeros the second one wins. That is right for a running minimum over values
+ * known to be numbers, and wrong for a bound that has to stay poisoned when its input was.
+ *
+ * Why not `Math.min` itself: in code V8 has not optimised yet (a function run a few times a step can
+ * stay unoptimised for thousands of steps), `Math.min` is a call into a builtin that hands its answer
+ * back boxed into a heap object. This is comparisons only.
+ *
+ * The same as `Math.min` under `Object.is` for every pair of numbers. A NaN answer is the canonical
+ * NaN; which NaN `Math.min` answers is the platform's (on x64, the one with the sign bit set).
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function min2_exact(a, b) {
+    if (a < b) {
+        return a;
+    }
+
+    if (b < a) {
+        return b;
+    }
+
+    if (a === b) {
+        // equal, and of two zeros the negative one if either is
+        return a === 0 && 1 / a > 0 ? b : a;
+    }
+
+    // one of them is NaN
+    return NaN;
+}

package/src/core/model/node-graph/node/NodeInstancePortReference.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";
 
 /**
  * @typedef {import("../Connection.js").Connection} Connection
@@ -137,7 +137,7 @@ export class NodeInstancePortReference {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.instance.hash(),
             this.port.hash()
         );

package/src/core/model/reactive/model/ReactiveBinaryExpression.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import { combine_hash } from "../../../collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../math/hash/hash_mix3.js";
 import { ReactiveExpression } from "./ReactiveExpression.js";
 
 /**
@@ -60,7 +60,7 @@ export class ReactiveBinaryExpression extends ReactiveExpression {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix3(
             this.left.hash(),
             this.right.hash(),
             super.hash()

package/src/core/model/reactive/model/terminal/ReactiveReference.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 DataType from "../../../../parser/simple/DataType.js";
 import { computeStringHash } from "../../../../primitives/strings/computeStringHash.js";
 import { ReactiveExpression } from "../ReactiveExpression.js";
@@ -124,7 +124,7 @@ export class ReactiveReference extends ReactiveExpression {
 
 
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeStringHash(this.name),
             super.hash()
         );

package/src/engine/asset/AssetDescription.js

@@ -1,5 +1,5 @@
 import { assert } from "../../core/assert.js";
-import { combine_hash } from "../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../core/math/hash/hash_mix2.js";
 import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
 
 export class AssetDescription {
@@ -39,7 +39,7 @@ export class AssetDescription {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeStringHash(this.path),
             computeStringHash(this.type)
         );

package/src/engine/ecs/animation/Animation.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
 import List from '../../../core/collection/list/List.js';
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 import { AnimationClip } from "./AnimationClip.js";
@@ -139,7 +139,7 @@ export class Animation {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.clips.hash(),
             computeHashFloat(this.debtTime)
         );

package/src/engine/ecs/animation/AnimationClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/AnimationClip.js"],"names":[],"mappings":"AAKA;IA2DI;;;;OAIG;IACH,yBAFa,aAAa,CAQzB;IApED,qBAA8B;IAC9B,6BAAqC;IAErC;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,WAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAQnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAUlB;IAED;;;;OAIG;IACH,WAHW,MAAM,oBAAkB,GACtB,OAAO,CAInB;IAeD,0BA4BC;IAED;;;;;;MAQC;IAED;;;OAGG;IACH,2CAQC;IAED;;;OAGG;IACH,6CAOC;CACJ;2BA5I0B,uCAAuC;4BADtC,wCAAwC;oBADhD,+BAA+B"}
+{"version":3,"file":"AnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/AnimationClip.js"],"names":[],"mappings":"AAKA;IA6DI;;;;OAIG;IACH,yBAFa,aAAa,CAQzB;IAtED,qBAA8B;IAC9B,6BAAqC;IAErC;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,WAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAQnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAYlB;IAED;;;;OAIG;IACH,WAHW,MAAM,oBAAkB,GACtB,OAAO,CAInB;IAeD,0BA4BC;IAED;;;;;;MAQC;IAED;;;OAGG;IACH,2CAQC;IAED;;;OAGG;IACH,6CAOC;CACJ;2BA9I0B,uCAAuC;4BADtC,wCAAwC;oBADhD,+BAA+B"}

package/src/engine/ecs/animation/AnimationClip.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 Vector1 from "../../../core/geom/Vector1.js";
 import ObservedInteger from "../../../core/model/ObservedInteger.js";
 import ObservedString from "../../../core/model/ObservedString.js";
@@ -44,10 +44,12 @@ export class AnimationClip {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
-            this.name.hash(),
-            this.repeatCount.hash(),
-            this.weight.hash(),
+        return hash_mix3(
+            hash_mix3(
+                this.name.hash(),
+                this.repeatCount.hash(),
+                this.weight.hash()
+            ),
             this.timeScale.hash(),
             this.flags
         );

package/src/engine/ecs/gui/GUIElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GUIElement.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElement.js"],"names":[],"mappings":"6BASU,MAAM;;;;;;AAahB;IAyII;;;;OAIG;IACH,6BAFa,UAAU,CAYtB;IAED;;;;OAIG;IACH,yBAFY,UAAU,CAQrB;IApKD;;;OAGG;IACH,WAAY;IAEZ;;;OAGG;IACH,cAAa;IAEb;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,gBAFU,SAAO,IAAI,CAER;IAEb;;;OAGG;IACH,cAA+B;IAG/B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAGpC;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACR,OAAO,CAgCnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAUjB;IAgCD;;;;;;aAUC;IAED;;;;;;;;;MAQC;CAEJ;;;;;oBAjNmB,+BAA+B;4BAEvB,wCAAwC"}
+{"version":3,"file":"GUIElement.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElement.js"],"names":[],"mappings":"6BASU,MAAM;;;;;;AAahB;IA2II;;;;OAIG;IACH,6BAFa,UAAU,CAYtB;IAED;;;;OAIG;IACH,yBAFY,UAAU,CAQrB;IAtKD;;;OAGG;IACH,WAAY;IAEZ;;;OAGG;IACH,cAAa;IAEb;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,gBAFU,SAAO,IAAI,CAER;IAEb;;;OAGG;IACH,cAA+B;IAG/B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAGpC;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACR,OAAO,CAgCnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAYjB;IAgCD;;;;;;aAUC;IAED;;;;;;;;;MAQC;CAEJ;;;;;oBAnNmB,+BAA+B;4BAEvB,wCAAwC"}

package/src/engine/ecs/gui/GUIElement.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import Vector2 from '../../../core/geom/Vector2.js';
 import { objectDeepEquals } from "../../../core/model/object/objectDeepEquals.js";
 import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
@@ -148,10 +148,12 @@ class GUIElement {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            this.flags,
-            computeStringHash(this.klass),
-            this.anchor.hash(),
+        return hash_mix3(
+            hash_mix3(
+                this.flags,
+                computeStringHash(this.klass),
+                this.anchor.hash()
+            ),
             computeStringHash(this.group),
             this.visible.hash()
         )

package/src/engine/ecs/gui/hud/HeadsUpDisplay.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { HeadsUpDisplayFlag } from "./HeadsUpDisplayFlag.js";
 
@@ -73,7 +73,7 @@ class HeadsUpDisplay {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.flags,
             this.worldOffset.hash()
         );

package/src/engine/ecs/gui/position/ViewportPosition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewportPosition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPosition.js"],"names":[],"mappings":"oCAOU,MAAM;;;;;;AAOhB;IA0GI,4CAMC;IA/GD;;;OAGG;IACH,UAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,QAFU,OAAO,CAEM;IACvB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAG3B;;;;OAIG;IACH,sBAFU,OAAO,CAEY;IAE7B;;;;OAIG;IACH,iBAFU,MAAM,CAEK;IAGrB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAEpC;;;;OAIG;IACH,cAHW,gBAAgB,GACd,OAAO,CAWnB;IAED,eAUC;IAED;;;;;;;;aAkBC;IAED;;;;;;;;;;;;;;;;;MAUC;CASJ;;;;;oBA9HmB,kCAAkC;4BAC1B,2CAA2C"}
+{"version":3,"file":"ViewportPosition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPosition.js"],"names":[],"mappings":"oCAOU,MAAM;;;;;;AAOhB;IA8GI,4CAMC;IAnHD;;;OAGG;IACH,UAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,QAFU,OAAO,CAEM;IACvB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAG3B;;;;OAIG;IACH,sBAFU,OAAO,CAEY;IAE7B;;;;OAIG;IACH,iBAFU,MAAM,CAEK;IAGrB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAEpC;;;;OAIG;IACH,cAHW,gBAAgB,GACd,OAAO,CAWnB;IAED,eAcC;IAED;;;;;;;;aAkBC;IAED;;;;;;;;;;;;;;;;;MAUC;CASJ;;;;;oBAlImB,kCAAkC;4BAC1B,2CAA2C"}

package/src/engine/ecs/gui/position/ViewportPosition.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 Vector2 from "../../../../core/geom/Vector2.js";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
@@ -75,12 +75,16 @@ class ViewportPosition {
     }
 
     hash() {
-        return combine_hash(
-            this.position.hash(),
-            this.offset.hash(),
-            this.anchor.hash(),
-            this.resolveGuiCollisions ? 1 : 0,
-            computeHashFloat(this.screenEdgeWidth),
+        return hash_mix3(
+            hash_mix3(
+                hash_mix3(
+                    this.position.hash(),
+                    this.offset.hash(),
+                    this.anchor.hash()
+                ),
+                this.resolveGuiCollisions ? 1 : 0,
+                computeHashFloat(this.screenEdgeWidth)
+            ),
             this.stickToScreenEdge ? 1 : 0,
             this.enabled.hash()
         );

package/src/engine/ecs/ik/IKGoalSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IKGoalSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKGoalSystem.js"],"names":[],"mappings":"AAyOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;;IAEI,6DAA6C;IAE7C,kbASE;IAEF;;;OAGG;IACH,gBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,WAFU,MAAM,CAEC;IAkDjB;;;;OAIG;IACH,WAJW,MAAM,cACN,mBAAmB,UACnB,MAAM,QAgChB;IAED;;;;OAIG;IACH,aAJW,MAAM,cACN,mBAAmB,UACnB,MAAM,QAkBhB;IAED,sCA+BC;;CA6nBJ;uBA1hCsB,cAAc;oCAED,gDAAgD;uBAQ7D,aAAa;4BAD7B,6BAA6B;4CA1BQ,oDAAoD;yCAEvD,uDAAuD;0BAQtE,2BAA2B;kCAEnB,6BAA6B;6BAIlC,2BAA2B;sBAPlC,4BAA4B"}
+{"version":3,"file":"IKGoalSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKGoalSystem.js"],"names":[],"mappings":"AA0OA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;;IAEI,6DAA6C;IAE7C,kbASE;IAEF;;;OAGG;IACH,gBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,WAFU,MAAM,CAEC;IAkDjB;;;;OAIG;IACH,WAJW,MAAM,cACN,mBAAmB,UACnB,MAAM,QAgChB;IAED;;;;OAIG;IACH,aAJW,MAAM,cACN,mBAAmB,UACnB,MAAM,QAkBhB;IAED,sCA+BC;;CA6nBJ;uBA1hCsB,cAAc;oCAED,gDAAgD;uBAQ7D,aAAa;4BAD7B,6BAA6B;4CA3BQ,oDAAoD;yCAEvD,uDAAuD;0BAQtE,2BAA2B;kCAEnB,6BAA6B;6BAIlC,2BAA2B;sBAPlC,4BAA4B"}

package/src/engine/ecs/ik/IKGoalSystem.js

@@ -19,6 +19,7 @@ import { GPUStateAuthorityFlags } from "../gpu/GPUStateAuthorityFlags.js";
 import { gpu_authority_hold } from "../gpu/gpu_authority_hold.js";
 import { gpu_authority_unhold } from "../gpu/gpu_authority_unhold.js";
 import { ParentEntity } from "../parent/ParentEntity.js";
+import { parent_entity_model_of } from "../parent/parent_entity_model_of.js";
 import { System } from "../System.js";
 import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "../transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
 import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
@@ -354,8 +355,8 @@ export class IKGoalSystem extends System {
         record.entity = entity;
         record.goal = goal;
         record.system = this;
-        record.model = model_of(dataset, entity);
-        record.target_model = dataset.entityExists(goal.target) ? model_of(dataset, goal.target) : -1;
+        record.model = parent_entity_model_of(dataset, entity);
+        record.target_model = dataset.entityExists(goal.target) ? parent_entity_model_of(dataset, goal.target) : -1;
 
         this.#records.set(entity, record);
 
@@ -1071,23 +1072,6 @@ export class IKGoalSystem extends System {
     }
 }
 
-/**
- * The entity whose clips drive `entity`: the model its lifetime belongs to, or itself.
- *
- * @param {EntityComponentDataset} dataset
- * @param {number} entity
- * @returns {number}
- */
-function model_of(dataset, entity) {
-    const owner = dataset.getComponent(entity, ParentEntity);
-
-    if (owner === undefined || owner === null) {
-        return entity;
-    }
-
-    return owner.entity;
-}
-
 /**
  * Goals grouped by connected paths: two goals whose paths share a bone are solved together.
  *

package/src/engine/ecs/parent/parent_entity_model_of.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The entity whose clips drive `entity`: the model its lifetime belongs to, or itself.
+ *
+ * A placed model's bones each carry a {@link ParentEntity} naming the model's root, and the root is
+ * where the model's clips and animation drivers live. So the model of a bone is one step up the
+ * lifetime edge, and an entity without one — a root, a prop, a hand-made rig — is its own model.
+ *
+ * One step, not a walk to the top: a model placed under another model is still its own model, with
+ * its own clips.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @returns {number} the model entity; `entity` itself when it has no {@link ParentEntity}, or one
+ * naming no entity yet (`-1`)
+ */
+export function parent_entity_model_of(dataset: EntityComponentDataset, entity: number): number;
+//# sourceMappingURL=parent_entity_model_of.d.ts.map

package/src/engine/ecs/parent/parent_entity_model_of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent_entity_model_of.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/parent/parent_entity_model_of.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,gFAJW,MAAM,GACJ,MAAM,CAWlB"}

package/src/engine/ecs/parent/parent_entity_model_of.js

@@ -0,0 +1,26 @@
+import { ParentEntity } from "./ParentEntity.js";
+
+/**
+ * The entity whose clips drive `entity`: the model its lifetime belongs to, or itself.
+ *
+ * A placed model's bones each carry a {@link ParentEntity} naming the model's root, and the root is
+ * where the model's clips and animation drivers live. So the model of a bone is one step up the
+ * lifetime edge, and an entity without one — a root, a prop, a hand-made rig — is its own model.
+ *
+ * One step, not a walk to the top: a model placed under another model is still its own model, with
+ * its own clips.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @returns {number} the model entity; `entity` itself when it has no {@link ParentEntity}, or one
+ * naming no entity yet (`-1`)
+ */
+export function parent_entity_model_of(dataset, entity) {
+    const owner = dataset.getComponent(entity, ParentEntity);
+
+    if (owner === undefined || owner === null || owner.entity < 0) {
+        return entity;
+    }
+
+    return owner.entity;
+}

package/src/engine/ecs/transform/Transform64.d.ts

@@ -5,7 +5,7 @@
  * Index of the first element of the 4x4 affine matrix inside a {@link Transform64}.
  *
  * It is 0, which means a `Transform64` can be passed to any `mat4` function directly,
- * in place of the matrix - `m4_multiply(out, a_transform, b_transform)` and the like.
+ * in place of the matrix - `m4_multiply_f64(out, a_transform, b_transform)` and the like.
  * @type {number}
  */
 export const TRANSFORM64_MATRIX_OFFSET: number;

package/src/engine/ecs/transform/Transform64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transform64.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform64.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Transform64.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform64.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;GAOG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,0CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,+BAFU,MAAM,CAEmB;AASnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAmqBI;;;;;;;;;;;;;OAaG;IACH,2BAZW,MAAM,iBACN,MAAM,iBACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,WAAW,CAgBvB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,WAAW,CAQvB;IAED;;;;OAIG;IACH,4BAFa,WAAW,CAQvB;IAvtBD;;;OAGG;IACH,uDAIC;IAED,cAIC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,2BAEC;IAgBD;;;;OAIG;IACH,iCAEC;IArBD;;;;;;;;;OASG;IACH,gCAEC;IAWD,4BAEC;IAED,4BAEC;IAED,4BAEC;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAWD;;;OAGG;IACH,8BAEC;IAfD;;;;OAIG;IACH,6BAEC;IAUD,yBAEC;IAED,yBAEC;IAED,yBAEC;IAED,yBAEC;IAED;;;;;;;OAOG;IACH,eALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAYhB;IAgCD;;;;;;;;;;;;;;OAcG;IACH,6BAIC;IAjDD;;;;;;;;;;;;;;OAcG;IACH,4BAaC;IA4CD;;;;;;;;;;OAUG;IACH,2BAmBC;IAnDD;;;;;OAKG;IACH,0BAaC;IAuDD;;;;;;;;;;;;;OAaG;IACH,wBAkBC;IArDD;;;;;OAKG;IACH,uBAaC;IAoCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAPW,MAAM,YACN,MAAM,YACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAwBhB;IAED;;;;OAIG;IACH,eAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,OAAO,OAC1C,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,OAAO,QAOpD;IAWD;;;OAGG;IACH,2BAEC;IAfD;;;;OAIG;IACH,0BAEC;IAUD,sBAEC;IAED,sBAEC;IAED,sBAEC;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,qBAQC;IAED;;;;;;;;;OASG;IACH,yBAOC;IAED;;;;;OAKG;IACH,eAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,IAAI,CAahB;IAED;;;;OAIG;IACH,gBAHW,WAAW,GACT,IAAI,CAIhB;IAED;;;;;;;;;;OAUG;IACH,sBAJW,WAAW,KACX,WAAW,GACT,IAAI,CAahB;IAED;;;;;OAKG;IACH,qBAcC;IAVG,UAAW;IACX,UAAW;IACX,WAAY;IACZ,WAAY;IAShB;;;;;OAKG;IACH,cAFa,OAAO,CAanB;IAED;;;OAGG;IACH,YAFW,WAAW,QAIrB;IAED;;;OAGG;IACH,SAFa,WAAW,CAQvB;IAED;;;;;OAKG;IACH,cAHW,WAAW,GACT,OAAO,CAInB;IAED;;;;;;OAMG;IACH,QAFa,MAAM,CAwBlB;IAED;;;;;;;OAOG;IACH,0BA0BC;IAED;;;OAGG;IACH,UAFa;QAAC,WAAW,EAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC,CAAC;QAAC,QAAQ,EAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC,CAAC;QAAC,KAAK,EAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC,CAAA;KAAC,CAqB1I;IA2EL;;;;;;;;OAQG;IACH,wBANU,OAAO,CAMkB;CAjBlC;;kBAIS,MAAM;;sBA3zBH,OAAO,+BAA+B,EAAE,OAAO"}

package/src/engine/ecs/transform/Transform64.js

@@ -3,7 +3,7 @@ import { array_copy } from "../../../core/collection/array/array_copy.js";
 import { array_range_equal_strict } from "../../../core/collection/array/array_range_equal_strict.js";
 import { m4_decompose_array } from "../../../core/geom/3d/mat4/m4_decompose_array.js";
 import { m4_from_rotation_translation_scale_array } from "../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_array.js";
-import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
+import { m4_multiply_f64 } from "../../../core/geom/3d/mat4/m4_multiply_f64.js";
 import { quat3_multiply } from "../../../core/geom/3d/quaternion/quat3_multiply.js";
 import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
 import { t64_look_rotation } from "./t64_look_rotation.js";
@@ -16,7 +16,7 @@ import { t64_look_rotation } from "./t64_look_rotation.js";
  * Index of the first element of the 4x4 affine matrix inside a {@link Transform64}.
  *
  * It is 0, which means a `Transform64` can be passed to any `mat4` function directly,
- * in place of the matrix - `m4_multiply(out, a_transform, b_transform)` and the like.
+ * in place of the matrix - `m4_multiply_f64(out, a_transform, b_transform)` and the like.
  * @type {number}
  */
 export const TRANSFORM64_MATRIX_OFFSET = 0;
@@ -595,8 +595,9 @@ export class Transform64 extends Float64Array {
         assert.equal(a.isTransform64, true, 'a.isTransform64 !== true');
         assert.equal(b.isTransform64, true, 'b.isTransform64 !== true');
 
-        // both operands are fully read into locals before the first write, so aliasing is safe
-        m4_multiply(this, a, b);
+        // every element is read before the write that could replace it, so aliasing is safe; the
+        // Float64Array-only copy, because the shared m4_multiply boxes every element it writes
+        m4_multiply_f64(this, a, b);
 
         this.updateComponents();
 

package/src/engine/ecs/transform/t64_read_pose_array.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pack a transform's rigid pose, `[tx, ty, tz, qx, qy, qz, qw]`, into an array: the translation and
+ * the rotation, without the scale or the matrix.
+ *
+ * Seven floats is the shape a contact kernel, an oriented box transform or a cloth holder takes a
+ * pose in. Read off the transform's lanes (a {@link Transform64} is a `Float64Array`) rather than
+ * through `translation_x` and the rest: a hot caller that does not inline those accessor calls gets
+ * each number back boxed, and the vector getters allocate outright.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 7 floats
+ * @param {Transform64|Float64Array} transform a `Transform64`, or an array in its layout
+ */
+export function t64_read_pose_array(out: number[] | Float32Array | Float64Array, out_offset: number, transform: Transform64 | Float64Array): void;
+//# sourceMappingURL=t64_read_pose_array.d.ts.map

package/src/engine/ecs/transform/t64_read_pose_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"t64_read_pose_array.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_read_pose_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,yCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,aACN,cAAY,YAAY,QAUlC"}

package/src/engine/ecs/transform/t64_read_pose_array.js

@@ -0,0 +1,24 @@
+import { TRANSFORM64_ROTATION_OFFSET, TRANSFORM64_TRANSLATION_OFFSET } from "./Transform64.js";
+
+/**
+ * Pack a transform's rigid pose, `[tx, ty, tz, qx, qy, qz, qw]`, into an array: the translation and
+ * the rotation, without the scale or the matrix.
+ *
+ * Seven floats is the shape a contact kernel, an oriented box transform or a cloth holder takes a
+ * pose in. Read off the transform's lanes (a {@link Transform64} is a `Float64Array`) rather than
+ * through `translation_x` and the rest: a hot caller that does not inline those accessor calls gets
+ * each number back boxed, and the vector getters allocate outright.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset receives 7 floats
+ * @param {Transform64|Float64Array} transform a `Transform64`, or an array in its layout
+ */
+export function t64_read_pose_array(out, out_offset, transform) {
+    out[out_offset] = transform[TRANSFORM64_TRANSLATION_OFFSET];
+    out[out_offset + 1] = transform[TRANSFORM64_TRANSLATION_OFFSET + 1];
+    out[out_offset + 2] = transform[TRANSFORM64_TRANSLATION_OFFSET + 2];
+    out[out_offset + 3] = transform[TRANSFORM64_ROTATION_OFFSET];
+    out[out_offset + 4] = transform[TRANSFORM64_ROTATION_OFFSET + 1];
+    out[out_offset + 5] = transform[TRANSFORM64_ROTATION_OFFSET + 2];
+    out[out_offset + 6] = transform[TRANSFORM64_ROTATION_OFFSET + 3];
+}