@woosh/meep-engine 2.93.3 → 2.94.1

package/build/meep.module.js

@@ -49003,13 +49003,6 @@ function typedArrayToDataType(v) {
     }
 }
 
-/**
- *
- * Produces a proportional mix of 2 values, a*(1-portion) + b*portion
- * Same as lerp
- */
-const mix = lerp$1;
-
 /**
  * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
  * @param {number} t ratio
@@ -49299,6 +49292,7 @@ class Sampler2D {
     }
 
     /**
+     * TODO there is an oversaturation bug in here somewhere, prefer to use linear sampling for now instead
      * Bicubic-filtered sampling
      * @param {number} x
      * @param {number} y
@@ -49487,6 +49481,7 @@ class Sampler2D {
         const q0 = data[i0];
 
         if (x0 === x1 && y0 === y1) {
+            // exactly sampled in the center of the pixel, no interpolation required
             return q0;
         }
 
@@ -49508,10 +49503,10 @@ class Sampler2D {
         const p1 = data[j1];
 
         // perform Bi-Linear interpolation
-        const s0 = mix(q0, q1, xd);
-        const s1 = mix(p0, p1, xd);
+        const s0 = lerp$1(q0, q1, xd);
+        const s1 = lerp$1(p0, p1, xd);
 
-        return mix(s0, s1, yd);
+        return lerp$1(s0, s1, yd);
     }
 
     /**
@@ -52549,8 +52544,10 @@ class BVH {
      * @param {number} index_b
      */
     node_set_combined_aabb(destination, index_a, index_b) {
+
         const address_a = ELEMENT_WORD_COUNT * index_a;
         const address_b = ELEMENT_WORD_COUNT * index_b;
+        const address_destination = ELEMENT_WORD_COUNT * destination;
 
         const float32 = this.__data_float32;
 
@@ -52578,7 +52575,6 @@ class BVH {
         const b_z1 = float32[address_b + 5];
         const z1 = max2(a_z1, b_z1);
 
-        const address_destination = destination * ELEMENT_WORD_COUNT;
 
         float32[address_destination] = x0;
         float32[address_destination + 1] = y0;
@@ -53321,6 +53317,95 @@ function clamp01(value) {
     }
 }
 
+/**
+ * Returns lowest value out of 3 supplied
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number}
+ */
+function min3(a, b, c) {
+
+    let v = a;
+    if (v > b) {
+        v = b;
+    }
+    if (v > c) {
+        v = c;
+    }
+    return v;
+}
+
+/**
+ * Convert a decimal value to hex
+ * @param {number} c generally expects b byte value, 0-255
+ * @returns {string} zero-padded value, for example instead of "0", will return "00" and instead of "F" will return "0F"
+ */
+function dec2hex(c) {
+    const hex = Math.round(c).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+}
+
+/**
+ * Takes values in 0..255 range
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @returns {string}
+ */
+function rgb2hex(r, g, b) {
+
+    return dec2hex(r) + dec2hex(g) + dec2hex(b);
+}
+
+/**
+ *
+ * @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}}
+ */
+function rgb2hsv(r, g, b) {
+
+    const _r = uint82float(r);
+    const _g = uint82float(g);
+    const _b = uint82float(b);
+
+
+    const max = Math.max(_r, _g, _b);
+    const min = Math.min(_r, _g, _b);
+
+    let h, s, v = max;
+
+    const 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 {number} h from 0 to 1
@@ -53495,73 +53580,6 @@ function parse_color(c) {
     return result;
 }
 
-/**
- * Returns lowest value out of 3 supplied
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @returns {number}
- */
-function min3(a, b, c) {
-
-    let v = a;
-    if (v > b) {
-        v = b;
-    }
-    if (v > c) {
-        v = c;
-    }
-    return v;
-}
-
-/**
- *
- * @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}}
- */
-function rgb2hsv(r, g, b) {
-
-    const _r = uint82float(r);
-    const _g = uint82float(g);
-    const _b = uint82float(b);
-
-
-    const max = Math.max(_r, _g, _b);
-    const min = Math.min(_r, _g, _b);
-
-    let h, s, v = max;
-
-    const 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 {number} r in 0..1 range
@@ -53580,28 +53598,6 @@ function rgb2uint24(r, g, b) {
         ;
 }
 
-/**
- * Convert a decimal value to hex
- * @param {number} c generally expects b byte value, 0-255
- * @returns {string} zero-padded value, for example instead of "0", will return "00" and instead of "F" will return "0F"
- */
-function dec2hex(c) {
-    const hex = Math.round(c).toString(16);
-    return hex.length === 1 ? "0" + hex : hex;
-}
-
-/**
- * Takes values in 0..255 range
- * @param {number} r
- * @param {number} g
- * @param {number} b
- * @returns {string}
- */
-function rgb2hex(r, g, b) {
-
-    return dec2hex(r) + dec2hex(g) + dec2hex(b);
-}
-
 function convert(c) {
     return (c < 0.0031308) ? c * 12.92 : 1.055 * (Math.pow(c, 0.41666)) - 0.055;
 }
@@ -53650,7 +53646,7 @@ class Color {
      * @param {number} r value from 0 to 1
      * @param {number} g value from 0 to 1
      * @param {number} b value from 0 to 1
-     * @param {number} [a] value from 0 to 1
+     * @param {number} [a] value from 0 to 1 Alpha channel (transparency)
      */
     constructor(r = 0, g = 0, b = 0, a = 1) {
         /**
@@ -53750,6 +53746,14 @@ class Color {
         this.a = v;
     }
 
+    /**
+     * Pretending to be an array
+     * @return {number}
+     */
+    get length() {
+        return 4;
+    }
+
     /**
      *
      * @param {number} r
@@ -54019,6 +54023,7 @@ class Color {
      * @param {number} value
      */
     fromUint(value) {
+
         const r = value >> 16;
         const g = (value >> 8) & 0xFF;
         const b = (value) & 0xFF;
@@ -56343,7 +56348,7 @@ class AABB3 {
      * @param {number} y
      * @param {number} z
      */
-    _translate(x,y,z){
+    _translate(x, y, z) {
         this.setBounds(
             this.x0 + x, this.y0 + y, this.z0 + z,
             this.x1 + x, this.y1 + y, this.z1 + z
@@ -56956,7 +56961,14 @@ class AABB3 {
  * @readonly
  * @type {boolean}
  */
-AABB3.prototype.isAABB3 = true;
+AABB3.prototype.isAABB3 = true;
+
+/**
+ * Pretending to be an array
+ * @readonly
+ * @type {number}
+ */
+AABB3.prototype.length = 6;
 
 /**
  *
@@ -102830,7 +102842,7 @@ class GUIEngine {
 
     constructor() {
 
-        this.ticker.subscribe(d => {
+        this.ticker.onTick.add(d => {
 
 
             let ctx = null;
@@ -111131,6 +111143,101 @@ class SystemEntityContext {
     }
 }
 
+class PointLight extends AbstractLight {
+    constructor() {
+        super();
+
+        /**
+         * @readonly
+         * @type {Vector3}
+         */
+        this.position = new Vector3$1();
+
+        /**
+         *
+         * @type {Vector1}
+         */
+        this.radius = new Vector1(1);
+
+        /**
+         * @readonly
+         * @type {Color}
+         */
+        this.color = new Color(1, 1, 1);
+
+        /**
+         *
+         * @type {Vector1}
+         */
+        this.intensity = new Vector1(1);
+    }
+
+    getCenter(result) {
+        this.position.writeToArray(result, 0);
+    }
+
+    getAABB(result) {
+        const r = this.radius.getValue();
+        const p = this.position;
+
+        const center_x = p.x;
+        const center_y = p.y;
+        const center_z = p.z;
+
+        result[0] = center_x - r;
+            result[1] =     center_y - r;
+            result[2] =  center_z - r;
+
+            result[3] =  center_x + r;
+            result[4] =  center_y + r;
+            result[5] =  center_z + r;
+    }
+
+    onDimensionChanged(listener, context) {
+        this.position.onChanged.add(listener, context);
+        this.radius.onChanged.add(listener, context);
+    }
+
+    offDimensionChanged(listener, context) {
+        this.position.onChanged.remove(listener, context);
+        this.radius.onChanged.remove(listener, context);
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|Float64Array} destination
+     * @param {number} address
+     * @returns {number} number of used slots
+     */
+    toArray(destination, address) {
+        const position = this.position;
+
+        destination[address] = position.x;
+        destination[address + 1] = position.y;
+        destination[address + 2] = position.z;
+
+        destination[address + 3] = this.radius.getValue();
+
+        const color = this.color;
+
+        destination[address + 4] = color.r;
+        destination[address + 5] = color.g;
+        destination[address + 6] = color.b;
+
+        destination[address + 7] = this.intensity.getValue();
+
+        return 8;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+PointLight.prototype.isPointLight = true;
+
+PointLight.prototype.ENCODED_SLOT_COUNT = 8;
+
 class LightBinding {
     constructor() {
         /**
@@ -111147,6 +111254,14 @@ class LightBinding {
         this.__c_light = null;
     }
 
+    get scaled_distance() {
+        const scale = this.__c_transform.scale;
+        const scale_magnitude = max3(scale.x, scale.y, scale.z);
+        const light_radius = this.__c_light.distance.getValue();
+
+        return light_radius * scale_magnitude;
+    }
+
     set component_transform(v) {
         this.__c_transform = v;
     }
@@ -111170,6 +111285,7 @@ class LightBinding {
     link(ctx) {
         this.__c_transform.position.onChanged.add(this.__apply_position, this);
         this.__c_transform.rotation.onChanged.add(this.__apply_rotation, this);
+        this.__c_transform.rotation.onChanged.add(this.__apply_scale, this);
 
         const l = this.__c_light;
 
@@ -111195,6 +111311,7 @@ class LightBinding {
 
         this.__apply_position();
         this.__apply_rotation();
+        this.__apply_scale();
 
         this.applySettings(ctx.system.settings);
     }
@@ -111206,6 +111323,7 @@ class LightBinding {
     unlink(ctx) {
         this.__c_transform.position.onChanged.remove(this.__apply_position, this);
         this.__c_transform.rotation.onChanged.remove(this.__apply_rotation, this);
+        this.__c_transform.rotation.onChanged.remove(this.__apply_scale, this);
 
         this.__c_light.intensity.onChanged.remove(this.__apply_intensity, this);
         this.__c_light.color.onChanged.remove(this.__apply_color, this);
@@ -111223,6 +111341,10 @@ class LightBinding {
 
     }
 
+    __apply_scale(){
+
+    }
+
     __apply_intensity() {
 
     }
@@ -111248,106 +111370,22 @@ class LightBinding {
     }
 }
 
-class PointLight extends AbstractLight {
+class FPLightBinding extends LightBinding {
     constructor() {
         super();
 
-        /**
-         * @readonly
-         * @type {Vector3}
-         */
-        this.position = new Vector3$1();
-
         /**
          *
-         * @type {Vector1}
-         */
-        this.radius = new Vector1(1);
-
-        /**
-         * @readonly
-         * @type {Color}
+         * @type {PointLight|null}
+         * @private
          */
-        this.color = new Color(1, 1, 1);
+        this.__light = null;
 
         /**
          *
-         * @type {Vector1}
+         * @type {SignalBinding[]}
          */
-        this.intensity = new Vector1(1);
-    }
-
-    getCenter(result) {
-        this.position.writeToArray(result, 0);
-    }
-
-    getAABB(result) {
-        const r = this.radius.getValue();
-        const p = this.position;
-
-        const center_x = p.x;
-        const center_y = p.y;
-        const center_z = p.z;
-
-        result[0] = center_x - r;
-            result[1] =     center_y - r;
-            result[2] =  center_z - r;
-
-            result[3] =  center_x + r;
-            result[4] =  center_y + r;
-            result[5] =  center_z + r;
-    }
-
-    onDimensionChanged(listener, context) {
-        this.position.onChanged.add(listener, context);
-        this.radius.onChanged.add(listener, context);
-    }
-
-    offDimensionChanged(listener, context) {
-        this.position.onChanged.remove(listener, context);
-        this.radius.onChanged.remove(listener, context);
-    }
-
-    /**
-     *
-     * @param {number[]|Float32Array|Float64Array} destination
-     * @param {number} address
-     * @returns {number} number of used slots
-     */
-    toArray(destination, address) {
-        const position = this.position;
-
-        destination[address] = position.x;
-        destination[address + 1] = position.y;
-        destination[address + 2] = position.z;
-
-        destination[address + 3] = this.radius.getValue();
-
-        const color = this.color;
-
-        destination[address + 4] = color.r;
-        destination[address + 5] = color.g;
-        destination[address + 6] = color.b;
-
-        destination[address + 7] = this.intensity.getValue();
-
-        return 8;
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-PointLight.prototype.isPointLight = true;
-
-PointLight.prototype.ENCODED_SLOT_COUNT = 8;
-
-class FPLightBinding extends LightBinding {
-    constructor() {
-        super();
-
-        this.__light = null;
+        this.bindings = [];
     }
 
     /**
@@ -111359,6 +111397,10 @@ class FPLightBinding extends LightBinding {
         return ctx.system.__plugin.getValue();
     }
 
+    #updateDistance() {
+        this.__light.radius.set(this.scaled_distance);
+    }
+
     link(ctx) {
         /**
          *
@@ -111371,11 +111413,17 @@ class FPLightBinding extends LightBinding {
         const pl = new PointLight();
 
         const cLight = this.__c_light;
+        const cTransform = this.__c_transform;
+
+        this.bindings.push(
+            new SignalBinding(cLight.distance.onChanged, this.#updateDistance, this),
+            new SignalBinding(cTransform.scale.onChanged, this.#updateDistance, this)
+        );
 
         pl.intensity = cLight.intensity;
         pl.color = cLight.color;
-        pl.radius = cLight.distance;
-        pl.position = this.__c_transform.position;
+
+        pl.position = cTransform.position;
 
         /**
          *
@@ -111384,9 +111432,15 @@ class FPLightBinding extends LightBinding {
          */
         cLight.__fp_light = pl;
 
+        this.__light = pl;
+
+        this.#updateDistance();
+
         lightManager.addLight(pl);
 
-        this.__light = pl;
+        for (let i = 0; i < this.bindings.length; i++) {
+            this.bindings[i].link();
+        }
     }
 
     unlink(ctx) {
@@ -111399,9 +111453,49 @@ class FPLightBinding extends LightBinding {
         const lightManager = fp.getLightManager();
 
         lightManager.removeLight(this.__light);
+
+        for (let i = 0; i < this.bindings.length; i++) {
+            this.bindings[i].unlink();
+        }
+        this.bindings.splice(0, this.bindings.length);
+    }
+}
+
+class ShadowMap {
+    constructor() {
+        /**
+         *
+         * @type {CameraView[]}
+         */
+        this.views = [];
+
+
     }
 }
 
+/**
+ *
+ * @param {Light} component
+ * @param {Quaternion} r
+ */
+function applyRotation(component, r) {
+    const l = component.__threeObject;
+
+    r.toEulerAnglesXYZ(l.rotation);
+
+    if (l.target !== undefined) {
+
+        const targetPosition = l.target.position;
+
+        targetPosition.set(0, 0, 1).applyQuaternion(r);
+        targetPosition.set(l.position.x + targetPosition.x, l.position.y + targetPosition.y, l.position.z + targetPosition.z);
+
+        l.target.updateMatrixWorld(true);
+    }
+
+    threeUpdateTransform(component.__threeObject);
+}
+
 /**
  *
  * @param {Light} component
@@ -111451,41 +111545,6 @@ function threeEnsureLightObject(component, cache) {
     }
 }
 
-/**
- *
- * @param {Light} component
- * @param {Quaternion} r
- */
-function applyRotation(component, r) {
-    const l = component.__threeObject;
-
-    r.toEulerAnglesXYZ(l.rotation);
-
-    if (l.target !== undefined) {
-
-        const targetPosition = l.target.position;
-
-        targetPosition.set(0, 0, 1).applyQuaternion(r);
-        targetPosition.set(l.position.x + targetPosition.x, l.position.y + targetPosition.y, l.position.z + targetPosition.z);
-
-        l.target.updateMatrixWorld(true);
-    }
-
-    threeUpdateTransform(component.__threeObject);
-}
-
-class ShadowMap {
-    constructor() {
-        /**
-         *
-         * @type {CameraView[]}
-         */
-        this.views = [];
-
-
-    }
-}
-
 const shadow_scene = new Scene$1();
 shadow_scene.autoUpdate = false;
 shadow_scene.matrixAutoUpdate = false;
@@ -111625,7 +111684,7 @@ class ThreeLightBinding extends LightBinding {
     }
 
     __apply_distance(v) {
-        this.__three_getLight().distance = this.__c_light.distance.getValue();
+        this.__three_getLight().distance = this.scaled_distance;
     }
 
     __apply_angle() {
@@ -111792,6 +111851,10 @@ class ThreeLightBinding extends LightBinding {
         applyRotation(this.__c_light, this.__c_transform.rotation);
     }
 
+    __apply_scale() {
+        this.__three_getLight().distance = this.scaled_distance;
+    }
+
     applySettings(settings) {
         const light = this.__three_getLight();
 
@@ -116188,17 +116251,17 @@ class Uint32Heap {
         const size = this.__size;
 
         while (true) {
-            const l = (i << 1) + 1;
-            const r = l + 1;
+            const left = (i << 1) + 1;
+            const right = left + 1;
 
             let smallest = i;
 
-            if (l < size && this.compare(l, smallest)) {
-                smallest = l;
+            if (left < size && this.compare(left, smallest)) {
+                smallest = left;
             }
 
-            if (r < size && this.compare(r, smallest)) {
-                smallest = r;
+            if (right < size && this.compare(right, smallest)) {
+                smallest = right;
             }
 
             if (smallest === i) {
@@ -116272,19 +116335,23 @@ class Uint32Heap {
 
     pop_min() {
 
-        const result = this.top_id;
+        const new_size = this.__size - 1;
+        this.__size = new_size;
 
-        this.__size--;
+        const uint32 = this.__data_uint32;
+        const top_id = uint32[1];
 
-        if (this.__size > 0) {
-            // move top element to the bottom
-            this.swap(0, this.__size);
+        // move bottom element to the top.
+        // the top doesn't need to be moved down as we have discarded it already
+        const i2 = new_size << 1; // same as *2
 
-            // rebalance
-            this.heap_down(0);
-        }
+        uint32[0] = uint32[i2];
+        uint32[1] = uint32[i2 + 1];
 
-        return result;
+        // re-balance
+        this.heap_down(0);
+
+        return top_id;
     }
 
     /**
@@ -116302,6 +116369,7 @@ class Uint32Heap {
             const _id = uint32[address];
 
             if (_id === id) {
+                // reverse address to index
                 return (address >>> 1);
             }
         }
@@ -116315,7 +116383,7 @@ class Uint32Heap {
      * @param {number} id
      * @returns {boolean}
      */
-    contains(id){
+    contains(id) {
         return this.find_index_by_id(id) !== -1;
     }
 
@@ -116446,7 +116514,7 @@ class Uint32Heap {
 
         // insert at the end
         const index = current_size;
-        const address = index << 1;
+        const address = index << 1; // same as *2
 
         // write data
         this.__data_float32[address] = score;
@@ -116644,6 +116712,12 @@ const open = new Uint32Heap();
 const closed = new BitSet();
 closed.preventShrink();
 
+/**
+ * Contains refined heuristic value
+ * @type {Float32Array}
+ */
+let g_score = new Float32Array(1024);
+
 /**
  *
  * @param {number[]|Uint8Array|Uint16Array|Float32Array} field
@@ -116667,14 +116741,15 @@ function find_path_on_grid_astar(
     open.clear();
     closed.reset();
 
-    /**
-     * Contains refined heuristic value
-     * @type {number[]}
-     */
-    const g_score = [];
+    const cell_count = width * height;
 
-    g_score[start] = 0;
+    if (g_score.length < cell_count) {
+        g_score = new Float32Array(cell_count);
+    }
 
+    g_score.fill(Infinity, 0, cell_count);
+
+    g_score[start] = 0;
 
     open.insert(start, heuristic(start, goal, width));
 
@@ -116718,27 +116793,19 @@ function find_path_on_grid_astar(
             // updated path cost
             const cost_so_far = g_score[currentNode] + transition_cost;
 
-            const index_in_open_set = open.find_index_by_id(neighbor);
-
-            const not_in_open_set = index_in_open_set === -1;
-
-            if (not_in_open_set || cost_so_far < g_score[neighbor]) {
+            if (cost_so_far < g_score[neighbor]) {
 
-                // update refined score
+                // update actual cost
                 g_score[neighbor] = cost_so_far;
 
                 const remaining_heuristic = heuristic(neighbor, goal, width);
 
                 const refined_heuristic = cost_so_far + remaining_heuristic;
 
-                if (not_in_open_set) {
-                    // Pushing to heap will put it in proper place based on the 'f' value.
-                    open.insert(neighbor, refined_heuristic);
-                } else {
-                    // Already seen the node, but since it has been re-scored we need to reorder it in the heap
-                    open.__update_score_by_index(index_in_open_set, refined_heuristic);
-                }
+                // Pushing to heap will put it in proper place based on the 'f' value.
+                open.insert_or_update(neighbor, refined_heuristic);
             }
+
         }
     }