@woosh/meep-engine 2.118.9 → 2.118.11

package/build/meep.cjs

@@ -2,8 +2,8 @@
 
 /**
  *
- * @param {Array|Uint8Array} a
- * @param {Array|Uint8Array} b
+ * @param {Array|Uint8Array|Float32Array} a
+ * @param {Array|Uint8Array|Float32Array} b
  * @returns {boolean}
  */
 function isArrayEqualStrict(a, b) {
@@ -2533,10 +2533,10 @@ let Vector3$1 = class Vector3 {
      * @param {number} [squaredError]
      * @return {boolean}
      */
-    isNormalized(squaredError = 0.01) {
+    isNormalized(squaredError = 1e-5) {
         const lengthSq = this.lengthSqr();
 
-        return (lengthSq + squaredError) >= 1 && (lengthSq - squaredError) <= 1;
+        return epsilonEquals(lengthSq, 1, squaredError);
     }
 
     /**
@@ -2586,10 +2586,6 @@ let Vector3$1 = class Vector3 {
         return v3_length_sqr(this.x - x, this.y - y, this.z - z);
     }
 
-    distanceToSquared(other) {
-        return v3_length_sqr(this.x - other.x, this.y - other.y, this.z - other.z);
-    }
-
     /**
      * Angle between two vectors (co-planar) in radians
      * @param {Vector3} other
@@ -2849,31 +2845,6 @@ let Vector3$1 = class Vector3 {
         this._projectVectors(x0, y0, z0, x1, y1, z1);
     }
 
-    /**
-     * 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
@@ -3006,24 +2977,6 @@ let Vector3$1 = class Vector3 {
         this.set(x, y, z);
     }
 
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @deprecated use dedicated method directly instead
-     */
-    toBinaryBufferFloat32_EqualityEncoded(buffer) {
-        throw new Error('deprecated, use v3_binary_equality_encode')
-    }
-
-    /**
-     * Uses an extra byte for a header. Only writes unique components. Useful for things like scale where all components usually have the same value
-     * @param {BinaryBuffer} buffer
-     * @deprecated use dedicated method directly instead
-     */
-    fromBinaryBufferFloat32_EqualityEncoded(buffer) {
-        throw new Error('deprecated, use v3_binary_equality_decode')
-    }
-
     hash() {
         const x = computeHashFloat(this.x);
         const y = computeHashFloat(this.y);
@@ -3111,6 +3064,8 @@ let Vector3$1 = class Vector3 {
 
 // Aliases
 
+Vector3$1.prototype.distanceToSquared = Vector3$1.prototype.distanceSqrTo;
+
 Vector3$1.prototype.lengthSq = Vector3$1.prototype.lengthSqr;
 Vector3$1.prototype.fromArray = Vector3$1.prototype.readFromArray;
 Vector3$1.prototype.toArray = Vector3$1.prototype.writeToArray;
@@ -4017,18 +3972,18 @@ let Quaternion$1 = class Quaternion {
         if (uv_dot < -0.9999999) {
             //to vector is opposite, produce a reversal quaternion
 
-            tempvec3.crossVectors(Vector3$1.left, from);
+            scratch_v3_a.crossVectors(Vector3$1.left, from);
 
-            if (tempvec3.lengthSqr() < 0.00001) {
-                tempvec3.crossVectors(Vector3$1.up, from);
+            if (scratch_v3_a.lengthSqr() < 0.00001) {
+                scratch_v3_a.crossVectors(Vector3$1.up, from);
             }
 
-            tempvec3.normalize();
+            scratch_v3_a.normalize();
 
             this.set(
-                tempvec3.x,
-                tempvec3.y,
-                tempvec3.z,
+                scratch_v3_a.x,
+                scratch_v3_a.y,
+                scratch_v3_a.z,
                 0
             );
 
@@ -4560,10 +4515,7 @@ Quaternion$1.prototype.toArray = Quaternion$1.prototype.writeToArray;
  * @readonly
  * @type {Quaternion}
  */
-Quaternion$1.identity = Object.freeze(new Quaternion$1(0, 0, 0, 1));
-
-
-const tempvec3 = new Vector3$1();
+Quaternion$1.identity = Object.freeze(new Quaternion$1(0, 0, 0, 1));
 
 /**
  * @readonly
@@ -49012,34 +48964,6 @@ function compute_typed_array_constructor_from_data_type(dt) {
     return r;
 }
 
-/**
- * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
- * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
- * @param {number} offset
- * @param {number} length
- * @param {number} stride
- * @return {number}
- */
-function computeStridedIntegerArrayHash(
-    array, offset, length, stride
-) {
-    let hash = length;
-
-    for (let i = offset; i < length; i += stride) {
-        const value = array[i] >>> 0; //force uint32
-
-        /**
-         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
-         * (h<<5) - h ===  h*31
-         * @type {number}
-         */
-        hash = ((hash << 5) - hash) + value;
-    }
-
-    // force uint32
-    return hash >>> 0;
-}
-
 /**
  *
  * @param {*} array
@@ -49186,6 +49110,62 @@ function is_typed_array_equals(a, b) {
     return isArrayEqualStrict(a_proxy, b_proxy);
 }
 
+/**
+ * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
+ * @template T
+ * @param {T[]|Uint32Array|Uint16Array|Uint8Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} stride
+ * @param {function(T):number} elementHash
+ * @param {*} [elementHashContext]
+ * @return {number}
+ */
+function computeStridedArrayHash(
+    array, offset, length, stride,
+    elementHash, elementHashContext
+) {
+
+    let hash = length;
+
+    for (let i = offset; i < length; i += stride) {
+        const value = elementHash.call(elementHashContext, array[i]);
+
+        /**
+         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
+         * (h<<5) - h ===  h*31
+         * @type {number}
+         */
+        hash = ((hash << 5) - hash) + value;
+    }
+
+    // force uint32
+    return hash >>> 0;
+}
+
+/**
+ *
+ * @param {Uint32Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} [sample_limit]
+ * @returns {number}
+ */
+function sparse_typed_array_hash(array, offset, length, sample_limit = 31) {
+    // limit hash evaluation to first 1k of the data to random memory access and keep CPU cache usage more coherent
+    const hash_evaluation_length = min2(length, 1024);
+
+    // compute stride so that we don't have to iterate over the entire buffer, instead picking at most X(509) values to consider
+    const stride = Math.max(1, Math.ceil(hash_evaluation_length / sample_limit));
+
+    // TODO implement fast dedicated float and int paths
+
+    return computeStridedArrayHash(
+        array, 0, hash_evaluation_length, stride,
+        computeHashFloat
+    );
+}
+
 function typedArrayConstructorByInstance(a) {
     if (a instanceof Int8Array) {
         return Int8Array;
@@ -49260,19 +49240,19 @@ class Sampler2D {
 
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.width = width;
 
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.height = height;
 
         /**
          * Number of channels
-         * @type {Number}
+         * @type {number}
          */
         this.itemSize = itemSize;
 
@@ -49289,18 +49269,6 @@ class Sampler2D {
         this.version = 0;
     }
 
-    /**
-     *
-     * @deprecated
-     * @param {number} x
-     * @param {number}y
-     * @param {Vector1|Vector2|Vector3|Vector4} result
-     * @returns {number}
-     */
-    get(x, y, result) {
-        throw new Error("Deprecated method, use sampleBilinear instead");
-    }
-
     /**
      *
      * @param {number} u
@@ -49323,8 +49291,8 @@ class Sampler2D {
      * @returns {number}
      */
     sampleChannelCatmullRomUV(u, v, channel) {
-        const x = u * (this.width) - 0.5;
-        const y = v * (this.height) - 0.5;
+        const x = u * this.width - 0.5;
+        const y = v * this.height - 0.5;
 
         return this.sampleChannelCatmullRom(x, y, channel);
     }
@@ -49379,8 +49347,8 @@ class Sampler2D {
         const texPos12_x = texPos1_x + offset12_x;
         const texPos12_y = texPos1_y + offset12_y;
 
-
         let result = 0.0;
+
         result += this.sampleChannelBilinear(texPos0_x, texPos0_y, channel) * w0_x * w0_y;
         result += this.sampleChannelBilinear(texPos12_x, texPos0_y, channel) * w12_x * w0_y;
         result += this.sampleChannelBilinear(texPos3_x, texPos0_y, channel) * w3_x * w0_y;
@@ -49442,8 +49410,8 @@ class Sampler2D {
     }
 
     /**
-     * TODO there is an oversaturation bug in here somewhere, prefer to use linear sampling for now instead
-     * Bicubic-filtered sampling
+     *
+     * Bicubic-filtered sampling, note values can be negative due to the nature of the cubic curve
      * @param {number} x
      * @param {number} y
      * @param {number} channel
@@ -49672,7 +49640,11 @@ class Sampler2D {
         const x = Math.round(u * w - 0.5);
         const y = Math.round(v * h - 0.5);
 
-        this.read(clamp$1(x, 0, w - 1), clamp$1(y, 0, h - 1), result);
+        this.read(
+            clamp$1(x, 0, w - 1),
+            clamp$1(y, 0, h - 1),
+            result
+        );
     }
 
     /**
@@ -49727,24 +49699,6 @@ class Sampler2D {
         }
     }
 
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {Vector4|Vector3|Vector2} [result]
-     * @deprecated
-     */
-    sample(u, v, result) {
-
-        const temp = [];
-
-        this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
-
-        result.readFromArray(temp);
-
-        return temp[0];
-    }
-
     /**
      *
      * @param {number} x
@@ -49874,11 +49828,11 @@ class Sampler2D {
 
     /**
      *
-     * @param {Number} x
-     * @param {Number} y
-     * @param {Number} width
-     * @param {Number} height
-     * @param {Array.<Number>} value
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {Array.<number>} value
      */
     fill(x, y, width, height, value) {
 
@@ -50056,10 +50010,13 @@ class Sampler2D {
     computeByteSize() {
         let dataSize;
 
-        if (Array.isArray(this.data)) {
-            dataSize = 8 * this.data.length;
+        const data = this.data;
+
+        if (Array.isArray(data)) {
+            // Assume IEEE float 64
+            dataSize = 8 * data.length;
         } else {
-            dataSize = this.data.buffer.byteLength;
+            dataSize = data.buffer.byteLength;
         }
 
         return dataSize + 280;
@@ -50071,6 +50028,11 @@ class Sampler2D {
      * @return {boolean}
      */
     equals(other) {
+        if(this === other){
+            // special case
+            return true;
+        }
+
         if (
             this.width !== other.width
             || this.height !== other.height
@@ -50091,9 +50053,7 @@ class Sampler2D {
 
         const length = this.data.length;
 
-        const stride = Math.max(1, Math.ceil(length / 509));
-
-        hash ^= computeStridedIntegerArrayHash(this.data, 0, length, stride);
+        hash ^= sparse_typed_array_hash(this.data, 0, length, 509);
 
         return hash;
     }
@@ -50629,6 +50589,34 @@ Vector1.zero = Object.freeze(new Vector1(0));
  */
 Vector1.one = Object.freeze(new Vector1(1));
 
+/**
+ * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
+ * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} stride
+ * @return {number}
+ */
+function computeStridedIntegerArrayHash(
+    array, offset, length, stride
+) {
+    let hash = length;
+
+    for (let i = offset; i < length; i += stride) {
+        const value = array[i] >>> 0; //force uint32
+
+        /**
+         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
+         * (h<<5) - h ===  h*31
+         * @type {number}
+         */
+        hash = ((hash << 5) - hash) + value;
+    }
+
+    // force uint32
+    return hash >>> 0;
+}
+
 /**
  *
  * @param {Uint8Array|number[]|ArrayLike<number>|IArguments} data
@@ -55304,29 +55292,6 @@ function v3_morton_encode_bounded(x, y, z, bounds) {
     );
 }
 
-/**
- * Returns highest value out of 3 supplied
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @returns {number}
- */
-function max3(a, b, c) {
-
-    let v = a;
-
-    if (v < b) {
-        v = b;
-    }
-
-    if (v < c) {
-        v = c;
-    }
-
-    return v;
-
-}
-
 /**
  * @readonly
  * @type {number}
@@ -55612,73 +55577,6 @@ class BinaryUint32BVH {
         return result;
     }
 
-    /**
-     *
-     * @param {number} a address
-     * @param {number} b address
-     * @param {number} c address
-     * @returns {number}
-     * @private
-     */
-    __compute_bounds_area_of_3_boxes(a, b, c) {
-        const float32 = this.__data_float32;
-
-        const x0 = min3(float32[a + 0], float32[b + 0], float32[c + 0]);
-        const y0 = min3(float32[a + 1], float32[b + 1], float32[c + 1]);
-        const z0 = min3(float32[a + 2], float32[b + 2], float32[c + 2]);
-
-        const x1 = max3(float32[a + 3], float32[b + 3], float32[c + 3]);
-        const y1 = max3(float32[a + 4], float32[b + 4], float32[c + 4]);
-        const z1 = max3(float32[a + 5], float32[b + 5], float32[c + 5]);
-
-        return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
-    }
-
-    /**
-     *
-     * @param {number} a
-     * @param {number} b
-     * @returns {number}
-     * @private
-     */
-    __fitness_function_should_swap_leaves_sah(a, b) {
-        const a_0 = max2(a - 1, 0);
-        const a_1 = min2(a + 1, this.__node_count_leaf - 1);
-
-        const leaf_block_offset = this.getLeafBlockAddress();
-
-        const a_c_address = a * BVH_LEAF_NODE_SIZE + leaf_block_offset;
-        const a_0_address = a_0 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
-        const a_1_address = a_1 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
-
-
-        const b_0 = max2(b - 1, 0);
-        const b_1 = min2(b + 1, this.__node_count_leaf - 1);
-
-        const b_c_address = b * BVH_LEAF_NODE_SIZE + leaf_block_offset;
-        const b_0_address = b_0 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
-        const b_1_address = b_1 * BVH_LEAF_NODE_SIZE + leaf_block_offset;
-
-
-        const current_area = this.__compute_bounds_area_of_3_boxes(a_0_address, a_c_address, a_1_address) + this.__compute_bounds_area_of_3_boxes(b_0_address, b_c_address, b_1_address);
-        const swap_area = this.__compute_bounds_area_of_3_boxes(a_0_address, b_c_address, a_1_address) + this.__compute_bounds_area_of_3_boxes(b_0_address, a_c_address, b_1_address);
-
-        return current_area - swap_area;
-    }
-
-    sort_bubble_sah() {
-        const n = this.__node_count_leaf;
-
-        for (let i = 0; i < n; i++) {
-            for (let j = i + 1; j < n; j++) {
-                if (this.__fitness_function_should_swap_leaves_sah(i, j) > 0) {
-                    this.__swap_leaves(i, j);
-                }
-            }
-        }
-    }
-
-
     /**
      * Sort leaf nodes according to their morton codes
      * @param {number[]} bounds
@@ -55692,15 +55590,17 @@ class BinaryUint32BVH {
             return;
         }
 
-        let stackPointer = 2;
+        const stack_top = stack$9.pointer;
+
+        let stackPointer = stack_top;
         let i, j;
 
-        stack$9[0] = 0; // first node
-        stack$9[1] = this.__node_count_leaf - 1; // last node
+        stack$9[stackPointer++] = 0; // first node
+        stack$9[stackPointer++] = this.__node_count_leaf - 1; // last node
 
         const data = this.__data_float32;
 
-        while (stackPointer > 0) {
+        while (stackPointer > stack_top) {
             stackPointer -= 2;
 
             const right = stack$9[stackPointer + 1];
@@ -55709,14 +55609,15 @@ class BinaryUint32BVH {
             i = left;
             j = right;
 
-            const pivotIndex = (left + right) >> 1;
+            const pivot_index = (left + right) >> 1;
 
-            const pivot_address = pivotIndex * BVH_LEAF_NODE_SIZE + leaf_block_address;
+            const pivot_address = pivot_index * BVH_LEAF_NODE_SIZE + leaf_block_address;
 
             const pivot = build_morton(data, pivot_address, bounds);
 
             /* partition */
             while (i <= j) {
+
                 while (build_morton(data, i * BVH_LEAF_NODE_SIZE + leaf_block_address, bounds) < pivot) {
                     i++;
                 }
@@ -55750,7 +55651,7 @@ class BinaryUint32BVH {
     }
 
     /**
-     *
+     * Does not update intermediate node bounds
      * @param {number} i
      * @param {number} j
      * @private
@@ -56424,13 +56325,6 @@ class AABB3 {
             || (z + tolerance) < this.z0 || (z - tolerance) > this.z1);
     }
 
-    computeMortonCode() {
-        const cx = (this.x0 + this.x1) >> 1;
-        const cy = (this.y0 + this.y1) >> 1;
-        const cz = (this.z0 + this.z1) >> 1;
-        return mortonEncode_magicbits(cx, cy, cz);
-    }
-
     /**
      *
      * @returns {number}
@@ -57741,7 +57635,7 @@ const m4_tmp = [];
 class TerrainTile {
     gridPosition = new Vector2();
     scale = new Vector2(1, 1);
-    size = new Vector2();
+    size = new Vector2(1, 1);
     position = new Vector2();
     resolution = new ObservedInteger(1);
 
@@ -58211,6 +58105,7 @@ class TerrainTile {
 
                 geometry.boundingSphere = new Sphere(center, radius);
             }
+
             //pull bounding box from geometry
 
             bb = geometry.boundingBox;
@@ -58218,6 +58113,7 @@ class TerrainTile {
                 geometry.computeBoundingBox();
                 bb = geometry.boundingBox;
             }
+
         }
 
         const x0 = bb.min.x;
@@ -59115,11 +59011,11 @@ function writeSample2DDataToDataTexture(sampler, texture) {
         }
     } else if (sampler.itemSize === 3) {
         if (texture.format !== RGBFormat$1) {
-            throw new Error('itemSize is 2 and texture.format is not RGBFormat');
+            throw new Error('itemSize is 3 and texture.format is not RGBFormat');
         }
     } else if (sampler.itemSize === 4) {
         if (texture.format !== RGBAFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGBAFormat');
+            throw new Error('itemSize is 4 and texture.format is not RGBAFormat');
         }
     } else {
         throw new Error('Unsupported itemSize');
@@ -62622,7 +62518,7 @@ function saturated_value_by_constructor(ctor) {
  * @param {Sampler2D} source
  * @param {Sampler2D} destination
  */
-function copy_Sampler2D_channel_data(source, destination) {
+function sampler2d_transfer_data(source, destination) {
     if (source.width !== destination.width || source.height !== destination.height) {
         throw new Error('Source and destination dimensions do not match');
     }
@@ -62829,7 +62725,7 @@ class TerrainLayer {
 
                 const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
 
-                copy_Sampler2D_channel_data(source, this.diffuse);
+                sampler2d_transfer_data(source, this.diffuse);
 
                 this.onChanged.send0();
 
@@ -63648,11 +63544,16 @@ class WorkerProxy {
     __id_counter = 0;
 
 
+    /**
+     *
+     * @param {string} url
+     * @param {Object} methods
+     */
     constructor(url, methods) {
         this.url = url;
         this.methods = methods;
 
-        this.__generateAPI(this, methods);
+        this.__generateAPI();
     }
 
     /**
@@ -63731,6 +63632,10 @@ class WorkerProxy {
 
     }
 
+    /**
+     *
+     * @private
+     */
     __generateAPI() {
 
 
@@ -66111,6 +66016,29 @@ function read_three_planes_to_array(planes, array) {
     }
 }
 
+/**
+ * Returns highest value out of 3 supplied
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number}
+ */
+function max3(a, b, c) {
+
+    let v = a;
+
+    if (v < b) {
+        v = b;
+    }
+
+    if (v < c) {
+        v = c;
+    }
+
+    return v;
+
+}
+
 /**
  *
  * @param {number[]|Float32Array} output
@@ -85589,7 +85517,7 @@ class Deque {
 
     /**
      *
-     * @param {E} e
+     * @param {T} e
      * @returns {boolean}
      */
     has(e) {
@@ -92962,14 +92890,12 @@ const LogLevel = {
 };
 
 class Logger {
-    constructor() {
-        /**
-         *
-         * @private
-         * @type {LoggerBackend[]}
-         */
-        this.backends = [];
-    }
+    /**
+     *
+     * @private
+     * @type {LoggerBackend[]}
+     */
+    backends = [];
 
     /**
      * Add a logging backend, this is a structure that handles incoming log messages.
@@ -115513,14 +115439,14 @@ class InputControllerSystem extends System {
 }
 
 class LoggerBackend {
-    constructor() {
 
-        /**
-         * @private
-         * @type {LogLevel|number}
-         */
-        this.level = LogLevel.Info;
-    }
+
+    /**
+     * @private
+     * @type {LogLevel|number}
+     */
+    level = LogLevel.Info;
+
 
     /**
      *