@woosh/meep-engine 2.33.36 → 2.33.40

package/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -434,11 +434,11 @@ export class BinaryUint32BVH {
      * Assemble leaf nodes into hierarchy, set binary node bounds iteratively bottom up
      */
     build() {
-        const nodeCount = this.__node_count_binary;
+        const binary_node_count = this.__node_count_binary;
 
-        const leaf_node_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+        const leaf_node_block_address = binary_node_count * BVH_BINARY_NODE_SIZE;
 
-        let level = Math.floor(Math.log(nodeCount) / Math.log(2));
+        let level = Math.floor(Math.log(binary_node_count) / Math.log(2));
 
         let i, offset, level_node_count;
         //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node

package/core/collection/HashMap.js

@@ -57,8 +57,9 @@ export class HashMap {
                     capacity = DEFAULT_INITIAL_CAPACITY,
                     loadFactor = DEFAULT_LOAD_FACTOR
                 } = {}) {
-        assert.typeOf(keyHashFunction, 'function', 'keyHashFunction');
-        assert.typeOf(keyEqualityFunction, 'function', 'keyEqualityFunction');
+
+        assert.isFunction(keyHashFunction, 'keyHashFunction');
+        assert.isFunction(keyEqualityFunction, 'keyEqualityFunction');
 
         /**
          *
@@ -77,6 +78,10 @@ export class HashMap {
          */
         this.records = [];
 
+        /**
+         *
+         * @type {number}
+         */
         this.size = 0;
 
 
@@ -245,21 +250,23 @@ export class HashMap {
         const bucket_index = this.__compute_bucket_index(raw_hash);
         const bucket = this.records[bucket_index];
 
-        if (bucket === undefined) {
-            return undefined;
-        }
+        if (bucket !== undefined) {
 
-        const bucketSize = bucket.length;
+            const bucketSize = bucket.length;
 
-        //check if key already exists
-        for (let i = 0; i < bucketSize; i++) {
-            const entry = bucket[i];
+            //check if key already exists
+            for (let i = 0; i < bucketSize; i++) {
+                const entry = bucket[i];
 
-            const entryKey = entry.key;
-            if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
+                const entryKey = entry.key;
 
-                return entry.value;
+                if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
+
+                    return entry.value;
+
+                }
             }
+
         }
 
         //not found

package/core/collection/array/typed/typed_array_copy.js

@@ -3,8 +3,8 @@ import { array_copy } from "../copyArray.js";
 
 /**
  * Assumes arrays have the same type
- * @param {TypedArray|Float32Array} source
- * @param {TypedArray|Float32Array} destination
+ * @param {TypedArray|Float32Array|Uint8Array} source
+ * @param {TypedArray|Float32Array|Uint8Array} destination
  */
 export function typed_array_copy(source, destination) {
     const destination_size = destination.length;

package/core/collection/table/RowFirstTable.js

@@ -6,8 +6,6 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
-import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
-
 
 /**
  *
@@ -15,9 +13,9 @@ import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
  * @constructor
  */
 function RowFirstTable(spec) {
-    assert.notEqual(spec, undefined, 'spec is undefined');
-    assert.notEqual(spec, null, 'spec is null');
-    assert.ok(spec instanceof RowFirstTableSpec, 'spec is not an instance of RowFirstTableSpec');
+    assert.defined(spec, 'spec');
+    assert.notNull(spec, 'spec');
+    assert.equal(spec.isRowFirstTableSpec, true, 'spec.isRowFirstTableSpec !== true');
 
     /**
      *
@@ -81,6 +79,10 @@ RowFirstTable.prototype.initialize = function () {
     this.writeRowMethod = spec.writeRowMethod;
 };
 
+/**
+ *
+ * @returns {number}
+ */
 RowFirstTable.prototype.hash = function () {
     // to keep hash calculation fast, do a fixed number evenly spaced taps inside the data table
 
@@ -97,7 +99,7 @@ RowFirstTable.prototype.hash = function () {
 
     const dataView = this.dataView;
 
-    let result = 0;
+    let result = byteLength;
 
     for (let i = 0; i < step_count; i++) {
         const address = i * step_size * 4;
@@ -285,7 +287,7 @@ RowFirstTable.prototype.addRow = function (values) {
 
     this.writeRowMethod(this.dataView, this.bytesPerRecord * rowIndex, values);
 
-    this.on.added.dispatch(rowIndex, values);
+    this.on.added.send2(rowIndex, values);
 };
 
 /**
@@ -311,7 +313,7 @@ RowFirstTable.prototype.addRows = function (count, valueSupplier) {
 
     function addOneSignaling(index) {
         addOneSilent(index);
-        onAdded.dispatch(index, row);
+        onAdded.send2(index, row);
     }
 
     function addOneSilent(i) {
@@ -432,6 +434,9 @@ RowFirstTable.prototype.toRowArray = function () {
 
 };
 
+/**
+ * Print the table to console
+ */
 RowFirstTable.prototype.printToConsole = function () {
     const rows = this.toRowArray();
 

package/core/collection/table/RowFirstTableSpec.js

@@ -237,6 +237,12 @@ RowFirstTableSpec.prototype.equals = function (other) {
     return isArrayEqualStrict(this.types, other.types);
 };
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+RowFirstTableSpec.prototype.isRowFirstTableSpec = true;
+
 
 const cache = new Cache({
     keyHashFunction: computeStringHash

package/core/color/Color.js

@@ -1,12 +1,14 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
-import { parseColor, rgb2hsv } from "./ColorUtils.js";
+import { parseColor } from "./ColorUtils.js";
 import { clamp } from "../math/clamp.js";
 import { min2 } from "../math/min2.js";
 import { max2 } from "../math/max2.js";
 import { min3 } from "../math/min3.js";
 import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { rgb2hsv } from "./rgb2hsv.js";
+import { rgb2uint24 } from "./rgb2uint24.js";
 
 class Color {
     /**
@@ -273,14 +275,8 @@ class Color {
      * @returns {number}
      */
     toUint() {
-        const r = Math.round(this.r * 255);
-        const g = Math.round(this.g * 255);
-        const b = Math.round(this.b * 255);
-
-        return (b & 0xFF)
-            | (g & 0xFF) << 8
-            | (r & 0xFF) << 16
-            ;
+
+        return rgb2uint24(this.r, this.g, this.b);
     }
 
     /**

package/core/color/ColorUtils.js

@@ -2,149 +2,9 @@
  * Created by Alex on 02/05/2016.
  */
 
-import { clamp } from "../math/clamp.js";
+import { hsv2rgb } from "./hsv2rgb.js";
+import { parseHex } from "./parseHex.js";
 
-/**
- *
- * @param {number} h from 0 to 1
- * @param {number} s from 0 to 1
- * @param {number} v from 0 to 1
- * @returns {{r: number, g: number, b: number}}
- */
-function hsv2rgb(h, s, v) {
-
-    let _h = h % 1;
-
-    if (_h < 0) {
-        _h = h + 1;
-    }
-
-    const _s = clamp(s, 0, 1);
-    const _v = clamp(v, 0, 1);
-
-    let r, g, b, i, f, p, q, t;
-
-    i = Math.floor(h * 6);
-    f = _h * 6 - i;
-    p = _v * (1 - _s);
-    q = _v * (1 - f * _s);
-    t = _v * (1 - (1 - f) * _s);
-    switch (i % 6) {
-        case 0:
-            r = _v, g = t, b = p;
-            break;
-        case 1:
-            r = q, g = _v, b = p;
-            break;
-        case 2:
-            r = p, g = _v, b = t;
-            break;
-        case 3:
-            r = p, g = q, b = _v;
-            break;
-        case 4:
-            r = t, g = p, b = _v;
-            break;
-        case 5:
-            r = _v, g = p, b = q;
-            break;
-    }
-    return {
-        r: Math.round(r * 255),
-        g: Math.round(g * 255),
-        b: Math.round(b * 255)
-    };
-}
-
-/**
- *
- * @param {number} r 0 to 255
- * @param {number} g 0 to 255
- * @param {number} b 0 to 255
- * @returns {{h: number, s: number, v: number}}
- */
-export function rgb2hsv(r, g, b) {
-
-    r /= 255;
-    g /= 255;
-    b /= 255;
-
-
-    const max = Math.max(r, g, b);
-    const min = Math.min(r, g, b);
-
-    var h, s, v = max;
-
-    var d = max - min;
-
-    s = max === 0 ? 0 : d / max;
-
-    if (max === min) {
-        h = 0; // achromatic
-    } else {
-        switch (max) {
-            case r:
-                h = (g - b) / d + (g < b ? 6 : 0);
-                break;
-            case g:
-                h = (b - r) / d + 2;
-                break;
-            case b:
-                h = (r - g) / d + 4;
-                break;
-        }
-
-        h /= 6;
-    }
-
-    return {
-        h,
-        s,
-        v
-    };
-}
-
-/**
- *
- * @param {string} hex
- * @returns {{r: Number, g: Number, b: Number}} rgb
- */
-function parseHex(hex) {
-    function hex2dec(v) {
-        return parseInt(v, 16)
-    }
-
-    return {
-        r: hex2dec(hex.slice(1, 3)),
-        g: hex2dec(hex.slice(3, 5)),
-        b: hex2dec(hex.slice(5))
-    };
-}
-
-
-/**
- *
- * @param r
- * @param g
- * @param b
- * @returns {string}
- */
-function rgb2hex(r, g, b) {
-    function dec2hex(c) {
-        const hex = c.toString(16);
-        return hex.length === 1 ? "0" + hex : hex;
-    }
-
-    return dec2hex(r) + dec2hex(g) + dec2hex(b);
-}
-
-function int2rgb(value) {
-    return {
-        r: (value >> 16) & 255,
-        g: (value >> 8) & 255,
-        b: (value) & 255
-    }
-}
 
 const rgbRegEx = /rgb\(([0-9]+),\s*([0-9]+),\s*([0-9]+)\)/;
 const hsvRegEx = /hsv\(([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?)\)/;
@@ -152,7 +12,7 @@ const hsvRegEx = /hsv\(([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+
 /**
  *
  * @param {string|number} c
- * @returns {number[]} Numeric array, values are in Uint range
+ * @returns {number[]} Numeric array, values are in Uint8 range (0...255)
  */
 export function parseColor(c) {
 
@@ -194,7 +54,7 @@ export function parseColor(c) {
         } else {
             throw new Error(`Failed to decode color string '${c}' `);
         }
-    } else if(type_of_code === 'number'){
+    } else if (type_of_code === 'number') {
 
         result[0] = c >> 16;
         result[1] = (c >> 8) & 0xFF;
@@ -207,9 +67,3 @@ export function parseColor(c) {
     return result;
 }
 
-export {
-    hsv2rgb,
-    parseHex,
-    rgb2hex,
-    int2rgb
-};

package/core/color/YCbCr_to_rgb_uint24.js

@@ -0,0 +1,20 @@
+/**
+ * @see https://en.wikipedia.org/wiki/YUV
+ * @param {number} Y
+ * @param {number} Cb
+ * @param {number} Cr
+ * @returns {number}
+ */
+export function YCbCr_to_rgb_uint24(Y, Cb, Cr) {
+    const _Cr = Cr - 128;
+    const _Cb = Cb - 128;
+
+    const r = Y + _Cr + (_Cr >> 2) + (_Cr >> 3) + (_Cr >> 5);
+    const g = Y - ((_Cb >> 2) + (_Cb >> 4) + (_Cb >> 5)) - ((_Cr >> 1) + (_Cr >> 3) + (_Cr >> 4) + (_Cr >> 5));
+    const b = Y + _Cb + (_Cb >> 1) + (_Cb >> 2) + (_Cb >> 6);
+
+    return (b & 0xFF)
+        | (g & 0xFF) << 8
+        | (r & 0xFF) << 16
+        ;
+}

package/core/color/hsv2rgb.js

@@ -0,0 +1,54 @@
+import { clamp } from "../math/clamp.js";
+
+/**
+ *
+ * @param {number} h from 0 to 1
+ * @param {number} s from 0 to 1
+ * @param {number} v from 0 to 1
+ * @returns {{r: number, g: number, b: number}}
+ */
+export function hsv2rgb(h, s, v) {
+
+    let _h = h % 1;
+
+    if (_h < 0) {
+        _h = h + 1;
+    }
+
+    const _s = clamp(s, 0, 1);
+    const _v = clamp(v, 0, 1);
+
+    let r, g, b, i, f, p, q, t;
+
+    i = Math.floor(h * 6);
+    f = _h * 6 - i;
+    p = _v * (1 - _s);
+    q = _v * (1 - f * _s);
+    t = _v * (1 - (1 - f) * _s);
+    switch (i % 6) {
+        case 0:
+            r = _v, g = t, b = p;
+            break;
+        case 1:
+            r = q, g = _v, b = p;
+            break;
+        case 2:
+            r = p, g = _v, b = t;
+            break;
+        case 3:
+            r = p, g = q, b = _v;
+            break;
+        case 4:
+            r = t, g = p, b = _v;
+            break;
+        case 5:
+            r = _v, g = p, b = q;
+            break;
+    }
+    return {
+        r: Math.round(r * 255),
+        g: Math.round(g * 255),
+        b: Math.round(b * 255)
+    };
+}
+

package/core/color/int2rgb.js

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number} value
+ * @returns {{r: number, b: number, g: number}}
+ */
+export function int2rgb(value) {
+    return {
+        r: (value >> 16) & 255,
+        g: (value >> 8) & 255,
+        b: (value) & 255
+    }
+}

package/core/color/parseHex.js

@@ -0,0 +1,18 @@
+function hex2dec(v) {
+    return parseInt(v, 16)
+}
+
+/**
+ *
+ * @param {string} hex
+ * @returns {{r: Number, g: Number, b: Number}} rgb
+ */
+export function parseHex(hex) {
+
+
+    return {
+        r: hex2dec(hex.slice(1, 3)),
+        g: hex2dec(hex.slice(3, 5)),
+        b: hex2dec(hex.slice(5))
+    };
+}

package/core/color/rgb2hex.js

@@ -0,0 +1,16 @@
+function dec2hex(c) {
+    const hex = c.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+}
+
+/**
+ *
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {string}
+ */
+export function rgb2hex(r, g, b) {
+
+    return dec2hex(r) + dec2hex(g) + dec2hex(b);
+}

package/core/color/rgb2hsv.js

@@ -0,0 +1,47 @@
+/**
+ *
+ * @param {number} r 0 to 255
+ * @param {number} g 0 to 255
+ * @param {number} b 0 to 255
+ * @returns {{h: number, s: number, v: number}}
+ */
+export function rgb2hsv(r, g, b) {
+
+    r /= 255;
+    g /= 255;
+    b /= 255;
+
+
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+
+    var h, s, v = max;
+
+    var d = max - min;
+
+    s = max === 0 ? 0 : d / max;
+
+    if (max === min) {
+        h = 0; // achromatic
+    } else {
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+
+        h /= 6;
+    }
+
+    return {
+        h,
+        s,
+        v
+    };
+}

package/core/color/rgb2uint24.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {number}
+ */
+export function rgb2uint24(r,g,b){
+    const _r = Math.round(r * 255);
+    const _g = Math.round(g * 255);
+    const _b = Math.round(b * 255);
+
+    return (_b & 0xFF)
+        | (_g & 0xFF) << 8
+        | (_r & 0xFF) << 16
+        ;
+}

package/core/color/rgb_to_YCbCr_uint24.js

@@ -0,0 +1,18 @@
+/**
+ *
+ * @see https://en.wikipedia.org/wiki/YUV
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {number}
+ */
+export function rgb_to_YCbCr_uint24(r, g, b) {
+    const Y = 0.299 * r + 0.587 * g + 0.114 * b;
+    const Cb = -0.169 * r - 0.331 * g + 0.499 * b + 128;
+    const Cr = 0.499 * g - 0.418 * g - 0.0813 * b + 128;
+
+    return (Cr & 0xFF)
+        | (Cb & 0xFF) << 8
+        | (Y & 0xFF) << 16
+        ;
+}

package/core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js

@@ -4,7 +4,7 @@ import { assert } from "../../../assert.js";
  *
  * @param {number[]|Float32Array} result
  * @param {number[]|Float32Array|Float64Array} aabb_corners
- * @param {number[]|Float32Array} projection_matrix
+ * @param {number[]|Float32Array|mat4} projection_matrix
  */
 export function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matrix) {
     assert.greaterThanOrEqual(result.length, 6, 'result.length must >= 6');

package/core/geom/3d/aabb/compute_aabb_from_points.js

@@ -0,0 +1,28 @@
+import { min2 } from "../../../math/min2.js";
+import { max2 } from "../../../math/max2.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number[]} input
+ * @param {number} input_count
+ * @param {number} d number of dimensions
+ */
+export function compute_aabb_from_points(result, input, input_count, d) {
+    let i = 0;
+    let j = 0;
+
+    for (; i < d; i++) {
+        result[i] = Infinity;
+        result[i + d] = -Infinity;
+    }
+
+    for (i = 0; i < input_count; i++) {
+        for (j = 0; j < d; j++) {
+            const v = input[j];
+
+            result[j] = min2(result[j], v);
+            result[j + d] = max2(result[j + d], v);
+        }
+    }
+}

package/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -1,10 +1,12 @@
 /**
  * method to separate bits from a given integer 3 positions apart
  * we only look at the first 10 bits
+ *
+ * @example when input is ABC, output bits are A00B00C
  * @param {number} a
  * @returns {number}
  */
-function splitBy3(a) {
+function split_by_3(a) {
     let x = a;
     x = (x | x << 16) & 0x30000ff;
     x = (x | x << 8) & 0x0300f00f;
@@ -25,10 +27,9 @@ function splitBy3(a) {
  */
 export function mortonEncode_magicbits(x, y, z) {
 
-    const x_bits = splitBy3(x);
-    const y_bits = splitBy3(y) << 1;
-    const z_bit = splitBy3(z) << 2;
-
-    return x_bits | y_bits | z_bit;
+    const x_bits = split_by_3(x);
+    const y_bits = split_by_3(y) << 1;
+    const z_bits = split_by_3(z) << 2;
 
+    return x_bits | y_bits | z_bits;
 }