@woosh/meep-engine 2.113.16 → 2.115.0

package/build/meep.cjs

@@ -47415,7 +47415,7 @@ class Vector2 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     fromArray(array, offset = 0) {
@@ -47427,7 +47427,7 @@ class Vector2 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     toArray(array, offset = 0) {
@@ -49003,6 +49003,34 @@ 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
@@ -49128,47 +49156,6 @@ function is_typed_array_equals(a, b) {
     return isArrayEqualStrict(a_proxy, b_proxy);
 }
 
-/**
- * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
- * @param {number} t ratio
- * @param {number} a position -2
- * @param {number} b position -1
- * @param {number} c position +1
- * @param {number} d position +2
- * @returns {number}
- */
-function interpolate_bicubic(t, a, b, c, d) {
-    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
-}
-
-/**
- * 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;
-}
-
 function typedArrayConstructorByInstance(a) {
     if (a instanceof Int8Array) {
         return Int8Array;
@@ -49195,6 +49182,19 @@ function typedArrayConstructorByInstance(a) {
     }
 }
 
+/**
+ * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
+ * @param {number} t ratio
+ * @param {number} a position -2
+ * @param {number} b position -1
+ * @param {number} c position +1
+ * @param {number} d position +2
+ * @returns {number}
+ */
+function interpolate_bicubic(t, a, b, c, d) {
+    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
+}
+
 /**
  * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
  * Inspired by OpenGL's glsl sampler2d API
@@ -54444,7 +54444,10 @@ function overlap1D(a0, a1, b0, b1) {
  * @param {number} by1
  * @returns {boolean} true if overlap exists, false if no overlap
  */
-function aabb2_overlap_exists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1) {
+function aabb2_overlap_exists(
+    ax0, ay0, ax1, ay1,
+    bx0, by0, bx1, by1
+) {
     return overlap1D(ax0, ax1, bx0, bx1)
         && overlap1D(ay0, ay1, by0, by1);
 }
@@ -59312,7 +59315,7 @@ function computeThreeTextureInternalFormatFromDataType(dt, channel_count) {
  * @param {Sampler2D} sampler
  * @returns {DataTexture}
  */
-function sampler2DtoFloat32Texture(sampler) {
+function sampler2d_to_float32_texture(sampler) {
 
     const width = sampler.width;
     const height = sampler.height;
@@ -59385,7 +59388,7 @@ function heightMap2NormalMap(renderer, sampler) {
     const width = sampler.width;
     const height = sampler.height;
 
-    const texture = sampler2DtoFloat32Texture(sampler);
+    const texture = sampler2d_to_float32_texture(sampler);
 
     //construct shader
     const shader = new NormalMapShader();
@@ -59688,9 +59691,9 @@ function normalMap2OcclusionMap(
     const width = resultSize.x;
     const height = resultSize.y;
     //
-    const normalTexture = sampler2DtoFloat32Texture(normalMap);
+    const normalTexture = sampler2d_to_float32_texture(normalMap);
 
-    const heightTexture = sampler2DtoFloat32Texture(heightMap);
+    const heightTexture = sampler2d_to_float32_texture(heightMap);
 
 
     //construct shader
@@ -87420,7 +87423,7 @@ class RingBuffer {
     }
 
     /**
-     *
+     * Removed first element that fulfills the criteria
      * @param {function(V):boolean} condition
      * @param {*} [thisArg]
      * @returns {V|undefined}
@@ -99189,6 +99192,30 @@ function intersects1D(a0, a1, b0, b1) {
     return a1 >= b0 && b1 >= a0;
 }
 
+/**
+ *
+ * @param {number} bounds_x0
+ * @param {number} bounds_y0
+ * @param {number} bounds_x1
+ * @param {number} bounds_y1
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {boolean}
+ */
+function aabb2_contains(
+    bounds_x0, bounds_y0, bounds_x1, bounds_y1,
+    x0, y0, x1, y1
+) {
+
+    return x0 >= bounds_x0
+        && x1 <= bounds_x1
+        && y0 >= bounds_y0
+        && y1 <= bounds_y1
+        ;
+}
+
 class Rectangle {
     /**
      *
@@ -99325,8 +99352,13 @@ class Rectangle {
 
         const _x0 = p.x;
         const _y0 = p.y;
+        const _x1 = s.x + _x0;
+        const _y1 = _y0 + s.y;
 
-        return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
+        return aabb2_overlap_exists(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -99339,6 +99371,7 @@ class Rectangle {
         const y0 = other.position.y;
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
+
         return this._overlaps(x0, y0, x1, y1);
     }
 
@@ -99398,13 +99431,18 @@ class Rectangle {
     _contains(x0, y0, x1, y1) {
         const size = this.size;
 
-        const _x0 = this.position.x;
-        const _y0 = this.position.y;
+        const position = this.position;
+
+        const _x0 = position.x;
+        const _y0 = position.y;
 
         const _y1 = size.y + _y0;
         const _x1 = size.x + _x0;
 
-        return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
+        return aabb2_contains(
+            _x0, _y0, _x1, _y1,
+            x0, y0, x1, y1
+        );
     }
 
     /**
@@ -99415,6 +99453,7 @@ class Rectangle {
     contains(other) {
         const x0 = other.position.x;
         const y0 = other.position.y;
+
         const y1 = other.size.y + y0;
         const x1 = other.size.x + x0;
 
@@ -106398,6 +106437,7 @@ function computeBinaryDataTypeByPrecision(type, precision) {
 const stack$1 = [];
 
 /**
+ * Quicksort implementation, instead of compare operator, uses scoring function
  * @template T
  * @param {T[]|ArrayLike<number>|Uint32Array} data
  * @param {function(T):number} score_function
@@ -106407,12 +106447,13 @@ const stack$1 = [];
  * @param {function(T[],number, number):*} [swap_operator]
  * @param {*} [swap_context]
  */
-function arrayQuickSort(
+function array_sort_quick(
     data,
     score_function, score_function_context,
     start = 0, end = data.length - 1,
     swap_operator = array_swap_one, swap_context = undefined
 ) {
+
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;
@@ -111353,7 +111394,7 @@ class LightManager {
         array_copy(visible_light_set.elements, 0, sorted_lights, 0, visible_light_count);
         array_copy(visible_decal_set.elements, 0, sorted_lights, visible_light_count, visible_decal_count);
 
-        arrayQuickSort(sorted_lights, this.__sort_visible_light_score, this, 0, expected_sorted_size - 1);
+        array_sort_quick(sorted_lights, this.__sort_visible_light_score, this, 0, expected_sorted_size - 1);
     }
 
     __update_visible_bvh() {