@woosh/meep-engine 2.60.0 → 2.61.0

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.60.0",
+  "version": "2.61.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/BitSet.js

@@ -457,7 +457,7 @@ BitSet.prototype.get = function (bitIndex) {
     assert.isNonNegativeInteger(bitIndex, "bitIndex");
 
     if (bitIndex >= this.__length) {
-        //bit is outside of the recorded region
+        //bit is outside the recorded region
         return false;
     }
 

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -1,18 +1,26 @@
-import { max2 } from "../../../../math/max2.js";
-import { mat3, vec3 } from "gl-matrix";
-import { array_copy } from "../../../../collection/array/array_copy.js";
-import { min2 } from "../../../../math/min2.js";
-import { assert } from "../../../../assert.js";
+import {mat3, vec3} from "gl-matrix";
+import {assert} from "../../../../assert.js";
+import {array_copy} from "../../../../collection/array/array_copy.js";
+import {min2} from "../../../../math/min2.js";
 
 /*
 @see https://github.com/Bestmaker602/olacziy/blob/212b64ea5f1856b390cdf7629801243f76a4466d/libs/ibl/src/CubemapSH.cpp
  */
 
+
+const F_PI = 3.14159265358979323846264338327950288;
+const F_SQRT1_2 = 0.707106781186547524400844362104849039;
+const M_SQRT_3 = 1.7320508076;
+
+const M_SQRT_PI = 1.7724538509;
+const M_SQRT_5 = 2.2360679775;
+const M_SQRT_15 = 3.8729833462;
+
 /**
  *
  * @param {number[]} M 5x5 matrix
  * @param {number[]} x vec5
- * @return {number[]}
+ * @return {number[]} vec5
  */
 function multiply_5d(M, x) {
     return [
@@ -24,51 +32,6 @@ function multiply_5d(M, x) {
     ];
 }
 
-
-/**
- * returns n! / d!
- * @param {number} n
- * @param {number} d
- * @return {number}
- */
-function factorial(n, d = 1) {
-    let _d = max2(1, d);
-    let _n = max2(1, n);
-
-    let r = 1.0;
-
-    if (_n === _d) {
-        // intentionally left blank
-    } else if (_n > _d) {
-        for (; _n > _d; _n--) {
-            r *= _n;
-        }
-    } else {
-        for (; _d > _n; _d--) {
-            r *= _d;
-        }
-        r = 1.0 / r;
-    }
-    return r;
-}
-
-const F_PI = 3.14159265358979323846264338327950288;
-const F_2_PI = 0.636619772367581343075535053490057448;
-const F_2_SQRTPI = 1.12837916709551257389615890312154517;
-const F_SQRT2 = 1.41421356237309504880168872420969808;
-const F_SQRT1_2 = 0.707106781186547524400844362104849039;
-const M_SQRT_3 = 1.7320508076;
-
-/**
- * SH scaling factors:
- *  returns sqrt((2*l + 1) / 4*pi) * sqrt( (l-|m|)! / (l+|m|)! )
- */
-function Kml(m, l) {
-    m = m < 0 ? -m : m;  // abs() is not constexpr
-    const K = (2 * l + 1) * factorial((l - m), (l + m));
-    return Math.sqrt(K) * (F_2_SQRTPI * 0.25);
-}
-
 /**
  * compute Index of spherical harmonics coefficient
  * @param {number} m signed offset from zonal harmonic
@@ -79,127 +42,6 @@ function SHindex(m, l) {
     return l * (l + 1) + m;
 }
 
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {number} numBands
- */
-function Ki(result, result_offset, numBands) {
-    for (let l = 0; l < numBands; l++) {
-        result[SHindex(0, l) + result_offset] = Kml(0, l);
-        for (let m = 1; m <= l; m++) {
-            result[SHindex(m, l) + result_offset] =
-                result[SHindex(-m, l) + result_offset] = F_SQRT2 * Kml(m, l);
-        }
-    }
-}
-
-/**
- * < cos(theta) > SH coefficients pre-multiplied by 1 / K(0,l)
- * @param {number} l
- * @returns {number}
- */
-function computeTruncatedCosSh(l) {
-    if (l === 0) {
-        return F_PI;
-    } else if (l === 1) {
-        return 2 * F_PI / 3;
-    } else if ((l & 1) !== 0) {
-        return 0;
-    }
-
-    const l_2 = l / 2;
-    const A0 = ((l_2 & 1) ? 1.0 : -1.0) / ((l + 2) * (l - 1));
-    const A1 = factorial(l, l_2) / (factorial(l_2) * (1 << l));
-    return 2 * F_PI * A0 * A1;
-}
-
-/*
- * Calculates non-normalized SH bases, i.e.:
- *  m > 0, cos(m*phi)   * P(m,l)
- *  m < 0, sin(|m|*phi) * P(|m|,l)
- *  m = 0, P(0,l)
- */
-function computeShBasis(SHb, result_offset, numBands, sx, sy, sz) {
-
-    /*
-     * TODO: all the Legendre computation below is identical for all faces, so it
-     * might make sense to pre-compute it once. Also note that there is
-     * a fair amount of symmetry within a face (which we could take advantage of
-     * to reduce the pre-compute table).
-     */
-
-    /*
-     * Below, we compute the associated Legendre polynomials using recursion.
-     * see: http://mathworld.wolfram.com/AssociatedLegendrePolynomial.html
-     *
-     * Note [0]: sz == cos(theta) ==> we only need to compute P(sz)
-     *
-     * Note [1]: We in fact compute P(sz) / sin(theta)^|m|, by removing
-     * the "sqrt(1 - sz*sz)" [i.e.: sin(theta)] factor from the recursion.
-     * This is later corrected in the ( cos(m*phi), sin(m*phi) ) recursion.
-     */
-
-    // s = (x, y, z) = (sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta))
-
-    // handle m=0 separately, since it produces only one coefficient
-    let Pml_2 = 0;
-    let Pml_1 = 1;
-    SHb[result_offset + 0] = Pml_1;
-    for (let l = 1; l < numBands; l++) {
-        const Pml = ((2 * l - 1.0) * Pml_1 * sz - (l - 1.0) * Pml_2) / l;
-        Pml_2 = Pml_1;
-        Pml_1 = Pml;
-        SHb[result_offset + SHindex(0, l)] = Pml;
-    }
-    let Pmm = 1;
-    for (let m = 1; m < numBands; m++) {
-        Pmm = (1.0 - 2 * m) * Pmm;      // See [1], divide by sqrt(1 - sz*sz);
-        Pml_2 = Pmm;
-        Pml_1 = (2 * m + 1.0) * Pmm * sz;
-        // l == m
-        SHb[result_offset + SHindex(-m, m)] = Pml_2;
-        SHb[result_offset + SHindex(m, m)] = Pml_2;
-        if (m + 1 < numBands) {
-            // l == m+1
-            SHb[result_offset + SHindex(-m, m + 1)] = Pml_1;
-            SHb[result_offset + SHindex(m, m + 1)] = Pml_1;
-            for (let l = m + 2; l < numBands; l++) {
-                const Pml = ((2 * l - 1.0) * Pml_1 * sz - (l + m - 1.0) * Pml_2) / (l - m);
-                Pml_2 = Pml_1;
-                Pml_1 = Pml;
-                SHb[result_offset + SHindex(-m, l)] = Pml;
-                SHb[result_offset + SHindex(m, l)] = Pml;
-            }
-        }
-    }
-
-    // At this point, SHb contains the associated Legendre polynomials divided
-    // by sin(theta)^|m|. Below we compute the SH basis.
-    //
-    // ( cos(m*phi), sin(m*phi) ) recursion:
-    // cos(m*phi + phi) == cos(m*phi)*cos(phi) - sin(m*phi)*sin(phi)
-    // sin(m*phi + phi) == sin(m*phi)*cos(phi) + cos(m*phi)*sin(phi)
-    // cos[m+1] == cos[m]*sx - sin[m]*sy
-    // sin[m+1] == sin[m]*sx + cos[m]*sy
-    //
-    // Note that (d.x, d.y) == (cos(phi), sin(phi)) * sin(theta), so the
-    // code below actually evaluates:
-    //      (cos((m*phi), sin(m*phi)) * sin(theta)^|m|
-    let Cm = sx;
-    let Sm = sy;
-    for (let m = 1; m <= numBands; m++) {
-        for (let l = m; l < numBands; l++) {
-            SHb[result_offset + SHindex(-m, l)] *= Sm;
-            SHb[result_offset + SHindex(m, l)] *= Cm;
-        }
-        const Cm1 = Cm * sx - Sm * sy;
-        const Sm1 = Sm * sx + Cm * sy;
-        Cm = Cm1;
-        Sm = Sm1;
-    }
-}
 
 /*
  * utilities to rotate very low order spherical harmonics (up to 3rd band)
@@ -247,10 +89,10 @@ function rotateShericalHarmonicBand1(band1, M) {
 /**
  *  This projects a vec3 to SH2/k space (i.e. we premultiply by 1/k)
  *  below can't be constexpr
- * @return {number[]} vec5
  * @param {number} x
  * @param {number} y
  * @param {number} z
+ * @return {number[]} vec5
  */
 function project_v3_to_sh(x, y, z) {
     return [
@@ -266,7 +108,7 @@ function project_v3_to_sh(x, y, z) {
  *
  * @param {number[]} band2 vec5
  * @param {number[]} M mat3
- * @return {*}
+ * @return {number[]} vec5
  */
 function rotateShericalHarmonicBand2(band2, M) {
     const n = F_SQRT1_2;
@@ -310,7 +152,7 @@ function rotateShericalHarmonicBand2(band2, M) {
     return result;
 }
 
-/*
+/**
  * SH from environment with high dynamic range (or high frequencies -- high dynamic range creates
  * high frequencies) exhibit "ringing" and negative values when reconstructed.
  * To mitigate this, we need to low-pass the input image -- or equivalently window the SH by
@@ -321,7 +163,9 @@ function rotateShericalHarmonicBand2(band2, M) {
  *    Deringing Spherical Harmonics
  * by Peter-Pike Sloan
  * https://www.ppsloan.org/publications/shdering.pdf
- *
+ * @param {number} w
+ * @param {number} l
+ * @returns {number}
  */
 function sincWindow(l, w) {
     if (l === 0) {
@@ -379,10 +223,6 @@ function shmin(input_sh3) {
     // See "Deringing Spherical Harmonics" by Peter-Pike Sloan
     // https://www.ppsloan.org/publications/shdering.pdf
 
-    const M_SQRT_PI = 1.7724538509;
-    const M_SQRT_3 = 1.7320508076;
-    const M_SQRT_5 = 2.2360679775;
-    const M_SQRT_15 = 3.8729833462;
     const A = [
         1.0 / (2.0 * M_SQRT_PI),    // 0: 0  0
         -M_SQRT_3 / (2.0 * M_SQRT_PI),    // 1: 1 -1
@@ -545,9 +385,13 @@ function windowing(f, cutoff, numBands) {
  * @param {number} input_offset
  * @param {number} numBands
  * @param {number} channel_count
- * @param {number} cutoff
+ * @param {number} [cutoff]
  */
-function windowSH(output, output_offset, input, input_offset, numBands, channel_count, cutoff) {
+function windowSH(
+    output, output_offset,
+    input, input_offset,
+    numBands, channel_count, cutoff = 0
+) {
     assert.isNonNegativeInteger(channel_count, 'channel_count');
     assert.greaterThan(channel_count, 0, 'channel_count must be greater than 0');
 
@@ -575,13 +419,17 @@ function windowSH(output, output_offset, input, input_offset, numBands, channel_
             // find a cut-off band that works
             let l = numBands;
             let r = cutoff;
+
             for (let i = 0; i < 16 && l + 0.1 < r; i++) {
+
                 const m = 0.5 * (l + r);
+
                 if (shmin(windowing(SH, m, numBands)) < 0) {
                     r = m;
                 } else {
                     l = m;
                 }
+
             }
 
             // record minimum cutoff

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.spec.js

@@ -1,6 +1,6 @@
 import { sh3_dering_optimize_positive } from "./sh3_dering_optimize_positive.js";
 
-test("de-ringing produces plausible numeric values", () => {
+test("de-ringing produces plausible numeric values from 1", () => {
 
     const result = [];
 
@@ -25,3 +25,29 @@ test("de-ringing produces plausible numeric values", () => {
     }
 
 });
+
+test("de-ringing produces plausible numeric values from -1", () => {
+
+    const result = [];
+
+    const harmonics = new Float32Array(9);
+
+    harmonics.fill(-1);
+
+    sh3_dering_optimize_positive(
+        result, 0,
+        harmonics,
+        0,
+        1
+    );
+
+    for (let i = 0; i < 9; i++) {
+
+        const element = result[i];
+
+        expect(element).not.toBeNaN();
+        expect(Number.isFinite(element)).toBe(true);
+
+    }
+
+});

package/src/core/geom/ConicRay.js

@@ -1,9 +1,9 @@
-import { assert } from "../assert.js";
+import {assert} from "../assert.js";
+import {computeHashIntegerArray} from "../collection/array/computeHashIntegerArray.js";
+import {EPSILON} from "../math/EPSILON.js";
+import {epsilonEquals} from "../math/epsilonEquals.js";
+import {computeHashFloat} from "../primitives/numbers/computeHashFloat.js";
 import Vector3 from "./Vector3.js";
-import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
-import { epsilonEquals } from "../math/epsilonEquals.js";
-import { EPSILON } from "../math/EPSILON.js";
 
 
 /**
@@ -11,24 +11,19 @@ import { EPSILON } from "../math/EPSILON.js";
  * Mainly used inside particle systems for pick a motion direction at spawn
  */
 export class ConicRay {
+
     /**
-     *
-     * @constructor
+     * Must be normalized
+     * @type {Vector3}
      */
-    constructor() {
-        /**
-         * Must be normalized
-         * @type {Vector3}
-         */
-        this.direction = new Vector3(0, 1, 0);
-
-        /**
-         * Semi-angle of the cone, that is the angle between the center axis and the edge of the cone
-         * In radians
-         * @type {number}
-         */
-        this.angle = 0;
-    }
+    direction = new Vector3(0, 1, 0);
+
+    /**
+     * Half-angle of the cone, that is the angle between the center axis and the edge of the cone
+     * In radians
+     * @type {number}
+     */
+    angle = 0;
 
     toJSON() {
         return {

package/src/core/geom/ConicRay.spec.js

@@ -0,0 +1,24 @@
+import {ConicRay} from "./ConicRay.js";
+import Vector3 from "./Vector3.js";
+
+test("constructor", () => {
+    const ray = new ConicRay();
+
+    expect(ray.angle).not.toBeNaN();
+    expect(typeof ray.angle).toBe("number");
+    expect(ray.direction).toBeDefined();
+});
+
+test("sampleRandomDirection", () => {
+
+    const ray = new ConicRay();
+
+    ray.angle = Math.PI * 0.25;
+
+    const r = new Vector3();
+
+    ray.sampleRandomDirection(() => 0, r);
+
+    expect(r.length()).toBeCloseTo(1);
+    expect(r.angleTo(ray.direction)).toBeLessThanOrEqual(ray.angle);
+});