@woosh/meep-engine 2.37.18 → 2.38.0

package/core/geom/Quaternion.spec.js

@@ -162,8 +162,8 @@ test('to/from euler YXZ consistency', () => {
 
         const u = new Vector3();
 
-        r.__setFromEuler(x, y, z, 'YXZ');
-        r.toEulerAnglesYXZ(u);
+        r.fromEulerAnglesXYZ(x, y, z);
+        r.toEulerAnglesXYZ(u);
 
         expect(u.x).toBeCloseTo(x);
         expect(u.y).toBeCloseTo(y);
@@ -177,4 +177,73 @@ test('to/from euler YXZ consistency', () => {
     check(1, 0, 1);
     check(1, 1, 0);
     check(1, 1, 1);
+
+    check(0, 0, -1);
+    check(0, -1, 0);
+    check(0, -1, -1);
+    check(-1, 0, 0);
+    check(-1, 0, -1);
+    check(-1, -1, 0);
+    check(-1, -1, -1);
+});
+
+
+/**
+ * See https://www.andre-gaschler.com/rotationconverter/
+ */
+test('toEulerAnglesXYZ', () => {
+
+    function check(quat, euler) {
+
+        const q = new Quaternion(...quat);
+
+        const r = new Vector3();
+        q.toEulerAnglesXYZ(r)
+
+        expect(r.x).toBeCloseTo(euler[0]);
+        expect(r.y).toBeCloseTo(euler[1]);
+        expect(r.z).toBeCloseTo(euler[2]);
+    }
+
+
+    check([0, 0, 0, 1], [0, 0, 0]);
+
+    check([0.4794255, 0, 0, 0.8775826], [1, 0, 0]);
+    check([0, 0.4794255, 0, 0.8775826], [0, 1, 0]);
+    check([0, 0, 0.4794255, 0.8775826], [0, 0, 1]);
+
+    check([0.4207355, 0.4207355, 0.2298488, 0.7701512], [1, 1, 0]);
+    check([0.2298488, 0.4207355, 0.4207355, 0.7701512], [0, 1, 1]);
+    check([0.4207355, -0.2298488, 0.4207355, 0.7701512], [1, 0, 1]);
+
+    check([0.5709415, 0.1675188, 0.5709415, 0.5656758], [1, 1, 1]);
+
+
+    check([-0.4794255, 0, 0, 0.8775826], [-1, 0, 0]);
+    check([0, -0.4794255, 0, 0.8775826], [0, -1, 0]);
+    check([0, 0, -0.4794255, 0.8775826], [0, 0, -1]);
+
+});
+
+test('computeTwistAngle', () => {
+    const q = new Quaternion();
+
+    q.fromAxisAngle(Vector3.up, 0);
+
+    expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(0);
+
+    const hp = Math.PI * 0.5;
+
+    q.fromAxisAngle(Vector3.up, hp);
+
+    expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(hp);
+
+    q.fromAxisAngle(Vector3.up, hp * 2);
+
+    expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(hp * 2);
+
+    q.fromAxisAngle(Vector3.up, hp * 3);
+
+    expect(q.computeTwistAngle(Vector3.up)).toBeCloseTo(hp * 3);
+
 });

package/core/geom/Vector2.js

@@ -475,7 +475,7 @@ class Vector2 {
     _distanceSqrTo(x, y) {
         const dx = this.x - x;
         const dy = this.y - y;
-        return magnitudeSqr(dx, dy);
+        return v2_length_sqr(dx, dy);
     }
 
     /**
@@ -685,7 +685,7 @@ export function v2_dot(x0, y0, x1, y1) {
  * @param {number} y
  * @returns {number}
  */
-function magnitudeSqr(x, y) {
+export function v2_length_sqr(x, y) {
     return x * x + y * y;
 }
 
@@ -696,7 +696,7 @@ function magnitudeSqr(x, y) {
  * @returns {number}
  */
 export function v2_magnitude(x, y) {
-    return Math.sqrt(magnitudeSqr(x, y));
+    return Math.sqrt(v2_length_sqr(x, y));
 }
 
 /**

package/core/geom/Vector3.d.ts

@@ -51,6 +51,8 @@ export default class Vector3 implements Vector3Like {
 
     _crossVectors(ax: number, ay: number, az: number, bx: number, by: number, bz: number): void
 
+    _projectVectors(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
+
     isZero(): boolean
 
     copy(other: Vector3Like): void

package/core/geom/Vector3.js

@@ -688,14 +688,38 @@ class Vector3 {
     }
 
     /**
-     *
+     * Compute orthogonal vectors given a normal
+     * Orthogonal vectors are normalized vectors pointing at right angles away from the input normal and to one another
+     * @see https://stackoverflow.com/questions/3684269/component-of-a-quaternion-rotation-around-an-axis
+     * @param normal
+     * @param orthonormal1
+     * @param orthonormal2
+     */
+    static findOrthonormals(normal, orthonormal1, orthonormal2) {
+        throw new Error('Not Implemented');
+
+        // Vector3 w = Vector3.Transform(normal, OrthoX);
+        // float dot = Vector3.Dot(normal, w);
+        // if (Math.Abs(dot) > 0.6)
+        // {
+        //     w = Vector3.Transform(normal, OrthoY);
+        // }
+        // w.Normalize();
+        //
+        // orthonormal1 = Vector3.Cross(normal, w);
+        // orthonormal1.Normalize();
+        // orthonormal2 = Vector3.Cross(normal, orthonormal1);
+        // orthonormal2.Normalize();
+    }
+
+    /**
+     * Project first vector onto second one
      * @param {number} x0
-     * @param y0
-     * @param z0
-     * @param x1
-     * @param y1
-     * @param z1
-     * @private
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
      */
     _projectVectors(x0, y0, z0, x1, y1, z1) {
 

package/core/geom/Vector3.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema",
+  "title": "Vector3",
+  "type": "object",
+  "properties": {
+    "x": {
+      "type": "number"
+    },
+    "y": {
+      "type": "number"
+    },
+    "z": {
+      "type": "number"
+    }
+  }
+}

package/core/geom/Vector4.js

@@ -114,6 +114,22 @@ class Vector4 {
         this.onChanged = new Signal();
     }
 
+    get 0() {
+        return this.x;
+    }
+
+    get 1() {
+        return this.y;
+    }
+
+    get 2() {
+        return this.z;
+    }
+
+    get 3() {
+        return this.w;
+    }
+
     /**
      *
      * @param {number[]} array

package/core/geom/packing/MaxRectangles.js

@@ -1,4 +1,4 @@
-import BinaryHeap from "../../../engine/navigation/grid/FastBinaryHeap.js";
+import BinaryHeap from "../../collection/heap/FastBinaryHeap.js";
 import { assert } from "../../assert.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";

package/core/graph/cluster_mesh_metis.js

@@ -102,6 +102,22 @@ export async function metis_cluster_bs(result, node_count, edge_addresses, adjec
 
     }
 
+    // remap P values. Metis assigns unique unsigned integer values to each cluster, but they don't necessarily start at 0, to fix this we remap values
+    const mapping = [];
+    let index_counter = 0;
+
+    for (let i = 0; i < p.length; i++) {
+        const source_index = p[i];
+
+        let target_index = mapping[source_index];
+        if (target_index === undefined) {
+            target_index = index_counter++;
+            mapping[source_index] = target_index;
+        }
+
+        p[i] = target_index;
+    }
+
     result.set(p);
     return partition_count;
 }

package/core/graph/coarsen_graph.js

@@ -1,4 +1,4 @@
-import FastBinaryHeap from "../../engine/navigation/grid/FastBinaryHeap.js";
+import FastBinaryHeap from "../collection/heap/FastBinaryHeap.js";
 import { mn_graph_collapse_weighted_edge } from "./mn_graph_collapse_weighted_edge.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 

package/core/graph/graph_k_means_cluster.js

@@ -3,7 +3,7 @@ import { seededRandom } from "../math/random/seededRandom.js";
 import { SquareMatrix } from "./SquareMatrix.js";
 import { DataType } from "../collection/table/DataType.js";
 import { BitSet } from "../binary/BitSet.js";
-import FastBinaryHeap from "../../engine/navigation/grid/FastBinaryHeap.js";
+import FastBinaryHeap from "../collection/heap/FastBinaryHeap.js";
 import { randomIntegerBetween } from "../math/random/randomIntegerBetween.js";
 
 /**

package/core/json/JsonUtils.js

@@ -2,24 +2,7 @@
  * Created by Alex on 03/11/2016.
  */
 
-/**
- *
- * @param o
- * @returns {boolean}
- */
-function isTypedArray(o) {
-    return (
-        o instanceof Int8Array ||
-        o instanceof Uint8Array ||
-        o instanceof Uint8ClampedArray ||
-        o instanceof Int16Array ||
-        o instanceof Uint16Array ||
-        o instanceof Int32Array ||
-        o instanceof Uint32Array ||
-        o instanceof Float32Array ||
-        o instanceof Float64Array
-    );
-}
+import { isTypedArray } from "../collection/array/typed/isTypedArray.js";
 
 /**
  *
@@ -114,6 +97,5 @@ function stringify(json) {
 
 export {
     stringify,
-    stringifyStream,
-    isTypedArray
+    stringifyStream
 };

package/core/math/bell_membership_function.js

@@ -0,0 +1,19 @@
+/**
+ * Generalized bell function, also known as "Cauchy membership function"
+ * @see "dbellmf" function from Matlab
+ * @see https://codecrucks.com/what-is-fuzzy-membership-function-complete-guide/
+ * @see https://researchhubs.com/post/maths/fundamentals/bell-shaped-function.html
+ * @param {number} v
+ * @param {number} a Controls window, larger value = larger window. Function will return exactly 0.5 at this distance away from center
+ * @param {number} b Slope, larger slope makes function's tails sharper, meaning that values fall off faster away from center
+ * @param {number} c Controls center of the bell curve
+ * @returns {number}
+ */
+export function bell_membership_function(v, a, b, c) {
+
+    const N = (v - c) / a;
+
+    const d = 1 + Math.pow(N, b * 2);
+
+    return 1 / d;
+}

package/core/math/exp2.js

@@ -0,0 +1,8 @@
+/**
+ * 2 raised to the power of the parameter
+ * @param {number} v
+ * @returns {number}
+ */
+export function exp2(v) {
+    return Math.pow(2, v);
+}

package/core/math/interval/NumericInterval.js

@@ -39,6 +39,7 @@ export class NumericInterval {
         this.onChanged = new Signal();
     }
 
+
     /**
      *
      * @param {number} min
@@ -108,6 +109,14 @@ export class NumericInterval {
         return this.min === 0 && this.max === 0;
     }
 
+    /**
+     * Whether min and max are the same
+     * @returns {boolean}
+     */
+    isExact() {
+        return this.min === this.max;
+    }
+
     /**
      *
      * @returns {number}
@@ -176,6 +185,14 @@ export class NumericInterval {
 
         return hash;
     }
+
+    /**
+     * Distance between min and max (= max - min)
+     * @returns {number}
+     */
+    get span() {
+        return this.max - this.min;
+    }
 }
 
 /**

package/core/math/physics/brdf/brdf_burley.js

@@ -0,0 +1,25 @@
+function F_Schlick(u, f0, f90) {
+
+    return f0 + (f90 - f0) * Math.pow(1.0 - u, 5.0);
+}
+
+/**
+ * @see https://google.github.io/filament/Filament.md.html#listing_diffusebrdf
+ * @see Brent Burley. 2012. Physically Based Shading at Disney. Physically Based Shading in Film and Game Production, ACM SIGGRAPH 2012 Courses.
+ * N = surface normal
+ * L = light direction
+ * V = view direction
+ * H = normalize( V + L )
+ *
+ * @param {number} NoV = abs(dot(n, v)) + 1e-5
+ * @param {number} NoL = lamp(dot(n, l), 0.0, 1.0)
+ * @param {number} LoH = clamp(dot(l, h), 0.0, 1.0)
+ * @param {number} roughness surface roughness coefficient
+ * @returns {number}
+ */
+export function brdf_burley(NoV, NoL, LoH, roughness) {
+    const f90 = 0.5 + 2.0 * roughness * LoH * LoH;
+    const lightScatter = F_Schlick(NoL, 1.0, f90);
+    const viewScatter = F_Schlick(NoV, 1.0, f90);
+    return lightScatter * viewScatter * (1.0 / Math.PI);
+}

package/core/math/physics/bsdf/bsdf_schlick.js

@@ -0,0 +1,22 @@
+import { exp2 } from "../../exp2.js";
+
+
+/**
+ *
+ * @param {number} f0
+ * @param {number} f90
+ * @param {number} dotVH
+ * @returns {number}
+ */
+export function bsdf_schlick(f0, f90, dotVH) {
+
+    // Original approximation by Christophe Schlick '94
+    // float fresnel = pow( 1.0 - dotVH, 5.0 );
+
+    // Optimized variant (presented by Epic at SIGGRAPH '13)
+    // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
+
+    const fresnel = exp2(((-5.55473) * dotVH - 6.98316) * dotVH);
+
+    return ((f0 * (1.0 - fresnel)) + (f90 * fresnel));
+}

package/core/math/physics/irradiance/interpolate_irradiance_linear.js

@@ -0,0 +1,18 @@
+import { inverseLerp } from "../../inverseLerp.js";
+
+/**
+ *
+ * @param {number} distance
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function interpolate_irradiance_linear(distance, min, max) {
+    if (distance <= min) {
+        return 1;
+    } else if (distance >= max) {
+        return 0;
+    } else {
+        return inverseLerp(max, min, distance);
+    }
+}

package/{engine/sound/ecs/emitter/attenuate/attenuateSoundLogarithmic.js → core/math/physics/irradiance/interpolate_irradiance_lograrithmic.js}

@@ -1,4 +1,4 @@
-import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
+import { inverseLerp } from "../../inverseLerp.js";
 
 /**
  *
@@ -7,7 +7,7 @@ import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
  * @param {number} max
  * @return {number}
  */
-export function attenuateSoundLogarithmic(distance, min, max) {
+export function interpolate_irradiance_lograrithmic(distance, min, max) {
     if (distance >= max) {
         return 0;
     }

package/{engine/sound/ecs/emitter/attenuate/attenuateSoundSmith.js → core/math/physics/irradiance/interpolate_irradiance_smith.js}

@@ -6,7 +6,7 @@
  * @param {number} max
  * @return {number}
  */
-export function attenuateSoundSmith(distance, min, max) {
+export function interpolate_irradiance_smith(distance, min, max) {
 
     if (distance < min) {
         return 1;

package/core/math/random/seededRandom.js

@@ -1,33 +1,4 @@
-import { assert } from "../../assert.js";
+import { seededRandom_Mulberry32 } from "./seededRandom_Mulberry32.js";
 
-/**
- *
- * @param {number} seed
- * @returns {Function}
- */
-export function seededRandom(seed) {
-    /**
-     *
-     * @returns {number}
-     */
-    function random() {
-        const x = Math.sin(seed++) * 10000;
-        return x - Math.floor(x);
-    }
 
-    /**
-     *
-     * @returns {number}
-     */
-    random.getCurrentSeed = function () {
-        return seed;
-    };
-
-    random.setCurrentSeed = function (v) {
-        assert.typeOf(v, "number", "v");
-
-        seed = v;
-    };
-
-    return random;
-}
+export const seededRandom = seededRandom_Mulberry32;

package/core/math/random/seededRandom_Mulberry32.js

@@ -0,0 +1,31 @@
+/**
+ *
+ * @param {number} [seed]
+ * @returns {function():number|{setCurrentSeed(v:number):void,getCurrentSeed():number}}
+ */
+export function seededRandom_Mulberry32(seed = 0) {
+    let _seed = seed;
+
+    function random() {
+        _seed += 0x6D2B79F5;
+
+        // Mulberry32 generator
+        let t = _seed;
+
+        t = Math.imul(t ^ t >>> 15, t | 1);
+
+        t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    }
+
+    random.setCurrentSeed = function (v) {
+        _seed = v;
+    };
+
+    random.getCurrentSeed = function () {
+        return _seed;
+    };
+
+    return random;
+}

package/core/math/random/seededRandom_sine.js

@@ -0,0 +1,33 @@
+import { assert } from "../../assert.js";
+
+/**
+ *
+ * @param {number} [seed]
+ * @returns {function():number|{setCurrentSeed(v:number):void,getCurrentSeed():number}}
+ */
+function seededRandom_sine(seed = 0) {
+    /**
+     *
+     * @returns {number}
+     */
+    function random() {
+        const x = Math.sin(seed++) * 10000;
+        return x - Math.floor(x);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    random.getCurrentSeed = function () {
+        return seed;
+    };
+
+    random.setCurrentSeed = function (v) {
+        assert.isNumber(v, "v");
+
+        seed = v;
+    };
+
+    return random;
+}

package/core/model/ObservedEnum.js

@@ -22,6 +22,14 @@ function ObservedEnum(value, validSet) {
     this.onChanged = new Signal();
 }
 
+/**
+ *
+ * @returns {Object<string, T>}
+ */
+ObservedEnum.prototype.getValidValueSet = function () {
+    return this.__validSet;
+}
+
 /**
  *
  * @param {T} value