@woosh/meep-engine 2.33.36 → 2.33.37

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/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/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/plane/orient3d_fast.js

@@ -0,0 +1,45 @@
+/**
+ * Return a positive value if the point pd lies below the
+ * plane passing through pa, pb, and pc; "below" is defined so
+ * that pa, pb, and pc appear in counterclockwise order when
+ * viewed from above the plane.  Returns a negative value if
+ * pd lies above the plane.  Returns zero if the points are
+ * coplanar.  The result is also a rough approximation of six
+ * times the signed volume of the tetrahedron defined by the
+ * four points.
+ *
+ * NOTE: ported from http://www.cs.cmu.edu/afs/cs/project/quake/public/code/predicates.c
+ *
+ * @param {number[]} points
+ * @param {number} a index of point a
+ * @param {number} b index of point b
+ * @param {number} c index of point c
+ * @param {number} d index of point d
+ * @returns {number}
+ */
+export function orient3d_fast(points, a, b, c, d) {
+    const a3 = a * 3;
+    const d3 = d * 3;
+
+    const adx = points[a3] - points[d3];
+
+    const b3 = b * 3;
+
+    const bdx = points[b3] - points[d3];
+
+    const c3 = c * 3;
+
+    const cdx = points[c3] - points[d3];
+
+    const ady = points[a3 + 1] - points[d3 + 1];
+    const bdy = points[b3 + 1] - points[d3 + 1];
+    const cdy = points[c3 + 1] - points[d3 + 1];
+
+    const adz = points[a3 + 2] - points[d3 + 2];
+    const bdz = points[b3 + 2] - points[d3 + 2];
+    const cdz = points[c3 + 2] - points[d3 + 2];
+
+    return adx * (bdy * cdz - bdz * cdy)
+        + bdx * (cdy * adz - cdz * ady)
+        + cdx * (ady * bdz - adz * bdy);
+}

package/core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js

@@ -24,7 +24,12 @@ export function plane_three_computeConvex3PlaneIntersection(result, result_offse
 }
 
 /**
+ * Given 3 planes, compute point of their intersection.
+ * This only works when the planes are "convex", that is - no two planes are parallel.
+ * Simply put - intersection must exist to be found.
+ *
  * NOTE: Based on Intersection of 3 planes, Graphics Gems 1 pg 305
+ *
  * @param {Float32Array|number[]|vec3} result
  * @param {number} result_offset
  * @param {number} a_normal_x