@woosh/meep-engine 2.60.1 → 2.62.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.1",
+  "version": "2.62.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/bvh2/BinaryNode.js

@@ -3,19 +3,19 @@
  */
 
 
-import { assert } from "../assert.js";
-import { arrayQuickSort } from "../collection/array/arrayQuickSort.js";
-import { max2 } from "../math/max2.js";
-import { min2 } from "../math/min2.js";
-import { computeSampleStandardDeviation } from "../math/statistics/computeSampleStandardDeviation.js";
-import { isLeaf, LeafNode } from "./LeafNode.js";
-import { Node } from "./Node.js";
-import { surfaceAreaHeuristic } from "./sah/surfaceAreaHeuristic.js";
-import { BVHVisitor } from "./traversal/BVHVisitor.js";
-import { traverseBinaryNodeUsingVisitor } from "./traversal/traverseBinaryNodeUsingVisitor.js";
-import { aabb3_intersects_aabb3 } from "../geom/3d/aabb/aabb3_intersects_aabb3.js";
-import { aabb3_box_surface_area_2 } from "../geom/3d/aabb/aabb3_box_surface_area_2.js";
-import { aabb3_combined_surface_area } from "../geom/3d/aabb/aabb3_combined_surface_area.js";
+import {assert} from "../assert.js";
+import {arrayQuickSort} from "../collection/array/arrayQuickSort.js";
+import {aabb3_box_surface_area_2} from "../geom/3d/aabb/aabb3_box_surface_area_2.js";
+import {aabb3_combined_surface_area} from "../geom/3d/aabb/aabb3_combined_surface_area.js";
+import {aabb3_intersects_aabb3} from "../geom/3d/aabb/aabb3_intersects_aabb3.js";
+import {max2} from "../math/max2.js";
+import {min2} from "../math/min2.js";
+import {computeSampleStandardDeviation} from "../math/statistics/computeSampleStandardDeviation.js";
+import {isLeaf, LeafNode} from "./LeafNode.js";
+import {Node} from "./Node.js";
+import {surfaceAreaHeuristic} from "./sah/surfaceAreaHeuristic.js";
+import {BVHVisitor} from "./traversal/BVHVisitor.js";
+import {traverseBinaryNodeUsingVisitor} from "./traversal/traverseBinaryNodeUsingVisitor.js";
 
 
 /**
@@ -36,6 +36,9 @@ let stackPointer = 0;
  */
 const stack = [];
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} instead
+ */
 export class BinaryNode extends Node {
     constructor() {
         super();

package/src/core/bvh2/LeafNode.js

@@ -1,9 +1,9 @@
 /**
  * Created by Alex on 17/11/2014.
  */
-import { Node } from "./Node.js";
-import { serializeAABB3 } from "../geom/3d/aabb/serializeAABB3.js";
-import { deserializeAABB3 } from "../geom/3d/aabb/deserializeAABB3.js";
+import {deserializeAABB3} from "../geom/3d/aabb/deserializeAABB3.js";
+import {serializeAABB3} from "../geom/3d/aabb/serializeAABB3.js";
+import {Node} from "./Node.js";
 
 
 /**
@@ -15,6 +15,9 @@ function isLeaf(node) {
     return node.isLeafNode;
 }
 
+/**
+ * @deprecated use {@link ExplicitBinaryBoundingVolumeHierarchy} and {@link EBBVHLeafProxy} respectively
+ */
 export class LeafNode extends Node {
     /**
      *

package/src/core/bvh2/bvh3/query/bvh_query_user_data_overlaps_sphere.js

@@ -0,0 +1,81 @@
+import {SCRATCH_UINT32_TRAVERSAL_STACK} from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import {aabb3_array_intersects_sphere_array} from "../../../geom/3d/aabb/aabb3_array_intersects_sphere_array.js";
+import {NULL_NODE} from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import {bvh_collect_user_data} from "./bvh_collect_user_data.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+const scratch_aabb = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|Float32Array} sphere
+ */
+export function bvh_query_user_data_overlaps_sphere(
+    result,
+    result_offset,
+    bvh,
+    sphere
+) {
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let result_cursor = result_offset;
+
+    while (stack.pointer > stack_top) {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        // test node against the ray
+        bvh.node_get_aabb(node, scratch_aabb);
+        const intersection = aabb3_array_intersects_sphere_array(scratch_aabb, sphere);
+
+        if (intersection === 0) {
+            // fully outside
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (node_is_leaf) {
+            // leaf node
+            result[result_cursor++] = bvh.node_get_user_data(node);
+
+        } else if (intersection === 2) {
+            // fully inside, fast collection path
+            result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
+        } else {
+            // partially inside
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            stack[stack.pointer++] = child1;
+            stack[stack.pointer++] = child2;
+        }
+    }
+
+    // drop stack frame
+
+    return result_cursor - result_offset;
+}

package/src/core/geom/3d/aabb/AABB3.js

@@ -3,22 +3,24 @@
  */
 
 
-import { aabb3_compute_distance_above_plane_max } from "./aabb3_compute_distance_above_plane_max.js";
-import { aabb3_compute_plane_side } from "./aabb3_compute_plane_side.js";
+import {assert} from "../../../assert.js";
 import computeMortonCode from "../morton/Morton.js";
-import { aabb3_build_corners } from "./aabb3_build_corners.js";
-import { assert } from "../../../assert.js";
-import { aabb3_intersects_frustum_degree } from "./aabb3_intersects_frustum_degree.js";
-import { aabb3_intersects_line_segment } from "./aabb3_intersects_line_segment.js";
-import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
-import { aabb3_compute_surface_area } from "./aabb3_compute_surface_area.js";
-import { aabb3_intersects_frustum_array } from "./aabb3_intersects_frustum_array.js";
-import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
-import { aabb3_signed_distance_sqr_to_point } from "./aabb3_signed_distance_sqr_to_point.js";
-import { aabb3_array_intersects_point } from "./aabb3_array_intersects_point.js";
+import {aabb3_array_intersects_point} from "./aabb3_array_intersects_point.js";
+import {aabb3_build_corners} from "./aabb3_build_corners.js";
+import {aabb3_compute_distance_above_plane_max} from "./aabb3_compute_distance_above_plane_max.js";
+import {aabb3_compute_plane_side} from "./aabb3_compute_plane_side.js";
+import {aabb3_compute_surface_area} from "./aabb3_compute_surface_area.js";
+import {aabb3_intersects_frustum_array} from "./aabb3_intersects_frustum_array.js";
+import {aabb3_intersects_frustum_degree} from "./aabb3_intersects_frustum_degree.js";
+import {aabb3_intersects_line_segment} from "./aabb3_intersects_line_segment.js";
+import {aabb3_intersects_ray} from "./aabb3_intersects_ray.js";
+import {aabb3_matrix4_project} from "./aabb3_matrix4_project.js";
+import {aabb3_signed_distance_sqr_to_point} from "./aabb3_signed_distance_sqr_to_point.js";
+import {aabb3_signed_distance_to_aabb3} from "./aabb3_signed_distance_to_aabb3.js";
 
 /**
  * Axis-Aligned bounding box in 3D
+ * NOTE: In cases where all you want is raw performance - prefer to use typed arrays instead along with `aabb3_` functions
  */
 export class AABB3 {
     /**
@@ -238,7 +240,12 @@ export class AABB3 {
      * @returns {boolean}
      */
     _equals(x0, y0, z0, x1, y1, z1) {
-        return this.x0 === x0 && this.y0 === y0 && this.z0 === z0 && this.x1 === x1 && this.y1 === y1 && this.z1 === z1;
+        return this.x0 === x0
+            && this.y0 === y0
+            && this.z0 === z0
+            && this.x1 === x1
+            && this.y1 === y1
+            && this.z1 === z1;
     }
 
     /**
@@ -332,28 +339,10 @@ export class AABB3 {
         const _y1 = this.y1;
         const _z1 = this.z1;
 
-        //do projection
-        const xp0 = _x0 - x1;
-        const xp1 = x0 - _x1;
-        const yp0 = _y0 - y1;
-        const yp1 = y0 - _y1;
-        const zp0 = _z0 - z1;
-        const zp1 = z0 - _z1;
-
-        //calculate separation in each axis
-        const dx = Math.max(xp0, xp1);
-        const dy = Math.max(yp0, yp1);
-        const dz = Math.max(zp0, zp1);
-
-        //straight-line distance
-        let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
-        if (dx < 0 && dy < 0 && dz < 0) {
-            //penetration
-            return -distance;
-        } else {
-            return distance;
-        }
+        return aabb3_signed_distance_to_aabb3(
+            _x0, _y0, _z0, _x1, _y1, _z1,
+            x0, y0, z0, x1, y1, z1
+        );
     }
 
     /**
@@ -778,7 +767,6 @@ export class AABB3 {
     }
 
     /**
-     *
      * @param {Plane[]} clippingPlanes
      * @returns {boolean}
      */

package/src/core/geom/3d/aabb/aabb3_array_compute_from_sphere.js

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} radius
+ */
+export function aabb3_array_compute_from_sphere(
+    output, output_offset,
+    x, y, z, radius
+) {
+
+    output[output_offset] = x - radius;
+    output[output_offset + 1] = y - radius;
+    output[output_offset + 2] = z - radius;
+    output[output_offset + 3] = x + radius;
+    output[output_offset + 4] = y + radius;
+    output[output_offset + 5] = z + radius;
+
+}

package/src/core/geom/3d/aabb/aabb3_array_intersects_sphere.js

@@ -0,0 +1,22 @@
+import {aabb3_signed_distance_sqr_to_point} from "./aabb3_signed_distance_sqr_to_point.js";
+
+/**
+ *
+ * @param {number[]} aabb
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} radius
+ * @returns {boolean}
+ */
+export function aabb3_array_intersects_sphere(aabb, x, y, z, radius) {
+    const distance_sqr = aabb3_signed_distance_sqr_to_point(
+        aabb[0], aabb[1], aabb[2],
+        aabb[3], aabb[4], aabb[5],
+        x, y, z
+    );
+
+    const radius2 = radius * radius;
+
+    return distance_sqr <= radius2;
+}

package/src/core/geom/3d/aabb/aabb3_array_intersects_sphere_array.js

@@ -0,0 +1,11 @@
+import {aabb3_array_intersects_sphere} from "./aabb3_array_intersects_sphere.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} aabb
+ * @param {number[]|Float32Array} sphere [x,y,z, radius]
+ * @returns {boolean}
+ */
+export function aabb3_array_intersects_sphere_array(aabb, sphere) {
+    return aabb3_array_intersects_sphere(aabb, sphere[0], sphere[1], sphere[2], sphere[3]);
+}

package/src/core/geom/3d/aabb/aabb3_signed_distance_to_aabb3.js

@@ -0,0 +1,28 @@
+export function aabb3_signed_distance_to_aabb3(
+    ax0,ay0,az0,ax1,ay1,az1,
+    bx0,by0,bz0, bx1,by1,bz1
+){
+
+    //do projection
+    const xp0 = bx0 - ax1;
+    const xp1 = ax0 - bx1;
+    const yp0 = by0 - ay1;
+    const yp1 = ay0 - by1;
+    const zp0 = bz0 - az1;
+    const zp1 = az0 - bz1;
+
+    //calculate separation in each axis
+    const dx = Math.max(xp0, xp1);
+    const dy = Math.max(yp0, yp1);
+    const dz = Math.max(zp0, zp1);
+
+    //straight-line distance
+    let distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+    if (dx < 0 && dy < 0 && dz < 0) {
+        //penetration
+        return -distance;
+    } else {
+        return distance;
+    }
+}

package/src/core/geom/3d/aabb/serializeAABB3Quantized16Uint.js

@@ -9,20 +9,29 @@
  * @param {number} y1
  * @param {number} z1
  */
-export function serializeAABB3Quantized16Uint(buffer, box, x0, y0, z0, x1, y1, z1) {
+export function serializeAABB3Quantized16Uint(
+    buffer, box,
+    x0, y0, z0, x1, y1, z1
+) {
+
     //compute value ranges
-    const xD = x1 - x0;
-    const yD = y1 - y0;
-    const zD = z1 - z0;
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+    const dz = z1 - z0;
+
+    // scale delta to Uin16 range, and avoid division by 0
+    const mx = dx > 0 ? 65535 / dx : 0;
+    const my = dy > 0 ? 65535 / dy : 0;
+    const mz = dz > 0 ? 65535 / dz : 0;
 
     //quantize all values
-    const _x0 = (((box.x0 - x0) / xD) * 65535) | 0;
-    const _y0 = (((box.y0 - y0) / yD) * 65535) | 0;
-    const _z0 = (((box.z0 - z0) / zD) * 65535) | 0;
+    const _x0 = Math.floor((box.x0 - x0) * mx);
+    const _y0 = Math.floor((box.y0 - y0) * my);
+    const _z0 = Math.floor((box.z0 - z0) * mz);
 
-    const _x1 = (((box.x1 - x0) / xD) * 65535) | 0;
-    const _y1 = (((box.y1 - y0) / yD) * 65535) | 0;
-    const _z1 = (((box.z1 - z0) / zD) * 65535) | 0;
+    const _x1 = Math.ceil((box.x1 - x0) * mx);
+    const _y1 = Math.ceil((box.y1 - y0) * my);
+    const _z1 = Math.ceil((box.z1 - z0) * mz);
 
     buffer.writeUint16(_x0);
     buffer.writeUint16(_y0);

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_SQRTPI = 1.12837916709551257389615890312154517;
-const F_SQRT2 = 1.41421356237309504880168872420969808;
-const F_SQRT1_2 = 0.707106781186547524400844362104849039;
-const M_SQRT_3 = 1.7320508076;
-
-/**
- * SH scaling factors
- */
-function Kml(m, l) {
-    //  returns sqrt((2*l + 1) / 4*pi) * sqrt( (l-|m|)! / (l+|m|)! )
-
-    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