@woosh/meep-engine 2.37.19 → 2.37.20

package/core/geom/Quaternion.js

@@ -11,6 +11,8 @@ import { lerp } from "../math/lerp.js";
 import { EPSILON, epsilonEquals, PI2 } from "../math/MathUtils.js";
 import Vector3 from "./Vector3.js";
 import { v3_dot } from "./v3_dot.js";
+import { min2 } from "../math/min2.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 const matrix = new ThreeMatrix4();
 
@@ -45,39 +47,46 @@ class Quaternion {
      * @param {Number} [w=1]
      * @constructor
      */
-    constructor(x, y, z, w) {
-        this.x = (typeof x === "number") ? x : 0;
-        this.y = (typeof x === "number") ? y : 0;
-        this.z = (typeof z === "number") ? z : 0;
-        this.w = (typeof w === "number") ? w : 1;
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+
+        /**
+         *
+         * @type {Number}
+         */
+        this.x = x;
+        /**
+         *
+         * @type {Number}
+         */
+        this.y = y;
+        /**
+         *
+         * @type {Number}
+         */
+        this.z = z;
+        /**
+         *
+         * @type {Number}
+         */
+        this.w = w;
 
         this.onChanged = new Signal();
     }
 
-    /**
-     *
-     * @param {Vector3} forwardVector
-     * @return {Quaternion}
-     */
-    lookRotation_2(forwardVector) {
-
-
-        const dot = Vector3.forward.dot(forwardVector);
-        if (Math.abs(dot - (-1.0)) < 0.000001) {
-            return this.set(Vector3.up.x, Vector3.up.y, Vector3.up.z, 3.1415926535897932);
-        }
-        if (Math.abs(dot - (1.0)) < 0.000001) {
-            return this.set(0, 0, 0, 1);
-        }
+    get 0() {
+        return this.x;
+    }
 
-        const rotAngle = Math.acos(dot);
-        rotAxis.copy(Vector3.forward);
-        rotAxis.cross(forwardVector);
-        rotAxis.normalize();
+    get 1() {
+        return this.y;
+    }
 
-        quat3_createFromAxisAngle(rotAxis, rotAngle, this);
+    get 2() {
+        return this.z;
+    }
 
-        return this;
+    get 3() {
+        return this.w;
     }
 
     /**
@@ -171,30 +180,6 @@ class Quaternion {
         return euler.setFromRotationMatrix(matrix);
     }
 
-    /**
-     *
-     * @param {Vector3} direction
-     * @param {Vector3} reference Reference direction, for example if you want to align Up direction or Forward, supply those here
-     * @param {number} limit
-     */
-    lookRotation_3(direction, reference, limit) {
-        const q = new Quaternion();
-
-        const f = new Vector3();
-
-        f.copy(reference);
-
-        f.applyQuaternion(this);
-
-        f.normalize();
-
-        //
-        q.fromUnitVectors2(f, direction);
-
-        console.log(f.toJSON(), q.toJSON(), direction.toJSON(), reference.toJSON());
-
-        this.multiply(q);
-    }
 
     /**
      *
@@ -317,11 +302,10 @@ class Quaternion {
     }
 
     /**
-     *
+     * @see https://stackoverflow.com/questions/3684269/component-of-a-quaternion-rotation-around-an-axis
      * @param {Vector3} axis
      * @param {Quaternion} swing
      * @param {Quaternion} twist
-     * @returns {number}
      */
     computeSwingAndTwist(axis, swing, twist) {
         const x = this.x;
@@ -329,17 +313,48 @@ class Quaternion {
         const z = this.z;
         const w = this.w;
 
-        const p = new Vector3();
+        // perform projection of rotation onto axis
+        const d = v3_dot(x, y, z, axis.x, axis.y, axis.z);
+
+        const mag2 = (axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
 
-        p._projectVectors(x, y, z, axis.x, axis.y, axis.z);
+        const m = d / mag2;
+
+        const px = axis.x * m;
+        const py = axis.y * m;
+        const pz = axis.z * m;
+
+        if (d < 0) {
+            // axis points in the opposite direction from calculated twist, invert all components
+            twist.set(-px, -py, -pz, -w);
+        } else {
+            twist.set(px, py, pz, w);
+
+        }
 
-        twist.set(p.x, p.y, p.z, w);
         twist.normalize();
 
         // rotation * twist.conjugated()
         swing._multiplyQuaternions(x, y, z, w, -twist.x, -twist.y, -twist.z, twist.w);
     }
 
+    /**
+     * Compute rotation (twist) around input axis
+     * @param {Vector3} axis
+     * @returns {number} in radians
+     */
+    computeTwistAngle(axis) {
+        assert.defined(axis, "axis");
+
+        const swing = new Quaternion();
+        const twist = new Quaternion();
+
+        this.computeSwingAndTwist(axis, swing, twist);
+
+        // extract twist angle from quaternion, see {@link #toAxisAngle}
+        return Math.acos(twist.w) * 2;
+    }
+
     /**
      *
      * @param {Vector3} axis
@@ -366,7 +381,8 @@ class Quaternion {
     normalize() {
         let l = this.length();
 
-        if (l === 0) {
+        if (l < EPSILON) {
+            // use identity
             this.set(0, 0, 0, 1);
         } else {
             const m = 1 / l;
@@ -472,10 +488,9 @@ class Quaternion {
     lookAt(source, target) {
         const forward = new Vector3();
 
-        forward
-            .copy(target)
-            .sub(source)
-            .normalize();
+        forward.subVectors(target, source);
+
+        forward.normalize();
 
         this.alignToDirection(forward);
     }
@@ -532,11 +547,11 @@ class Quaternion {
     }
 
     /**
-     *
+     * @see https://localcoder.org/euler-angle-to-quaternion-then-quaternion-to-euler-angle
+     * @see https://discourse.mcneel.com/t/what-is-the-right-method-to-convert-quaternion-to-plane-using-rhinocommon/92411/21?page=2
      * @param {Vector3} result
      */
     toEulerAnglesXYZ(result) {
-
         const x = this.x;
         const y = this.y;
         const z = this.z;
@@ -547,9 +562,19 @@ class Quaternion {
         const y2 = y * y;
         const z2 = z * z;
 
-        const psi = Math.atan2(2 * (x * w - y * z), (w2 - x2 - y2 + z2));
-        const theta = Math.asin(2 * (x * z + y * w));
-        const phi = Math.atan2(2 * (z * w - x * y), (w2 + x2 - y2 - z2));
+        const r31 = 2 * (x * w - y * z);
+        const r32 = w2 - x2 - y2 + z2;
+
+        const psi = Math.atan2(r31, r32);
+
+        const r21 = 2 * (x * z + y * w);
+
+        const theta = Math.asin(r21);
+
+        const r11 = 2 * (z * w - x * y);
+        const r12 = w2 + x2 - y2 - z2;
+
+        const phi = Math.atan2(r11, r12);
 
         result.set(psi, theta, phi);
     }
@@ -1156,6 +1181,7 @@ class Quaternion {
         this.set(x, y, z, w);
     }
 
+
     /**
      * @see https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
      * @param {Quaternion} other
@@ -1511,6 +1537,18 @@ class Quaternion {
             ;
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        // fast and dumb hash, just spread bits a bit and XOR them
+        return computeHashFloat(this.x)
+            ^ (computeHashFloat(this.y) >> 2)
+            ^ (computeHashFloat(this.z) >> 1)
+            ^ (computeHashFloat(this.w) << 2);
+    }
+
     /**
      *
      * @param {Quaternion} other
@@ -1582,6 +1620,28 @@ class Quaternion {
 
         return result;
     }
+
+
+    /**
+     * Behaves similarly to Unity's Quaternion `RotateToward` method
+     * @param {Quaternion} result
+     * @param {Quaternion} from
+     * @param {Quaternion} to
+     * @param {number} max_delta
+     */
+    static rotateTowards(result, from, to, max_delta) {
+        const angle = from.angleTo(to);
+
+        if (angle === 0) {
+            result.copy(to);
+        } else {
+            // clamp to 1, to make sure we don't overshoot
+            const t = min2(1, max_delta / angle);
+
+            from.slerp(to, t);
+        }
+
+    }
 }
 
 /**
@@ -1600,6 +1660,10 @@ const axis = new Vector3();
 
 const tempvec3 = new Vector3();
 
+/**
+ * Used in UINT32 packing
+ * @type {number}
+ */
 const K_CONST = 0.70710678118; // 1/sqrt(2)
 
 export default Quaternion;

package/core/geom/Quaternion.spec.js

@@ -206,6 +206,8 @@ test('toEulerAnglesXYZ', () => {
     }
 
 
+    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]);
@@ -221,5 +223,27 @@ test('toEulerAnglesXYZ', () => {
     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/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/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;