@woosh/meep-engine 2.93.3 → 2.94.0

package/build/meep.cjs

@@ -49005,13 +49005,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
@@ -49301,6 +49294,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
@@ -49489,6 +49483,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;
         }
 
@@ -49510,10 +49505,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);
     }
 
     /**
@@ -52551,8 +52546,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;
 
@@ -52580,7 +52577,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;
@@ -53323,6 +53319,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
@@ -53497,73 +53582,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
@@ -53582,28 +53600,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;
 }
@@ -53652,7 +53648,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) {
         /**
@@ -53752,6 +53748,14 @@ class Color {
         this.a = v;
     }
 
+    /**
+     * Pretending to be an array
+     * @return {number}
+     */
+    get length() {
+        return 4;
+    }
+
     /**
      *
      * @param {number} r
@@ -54021,6 +54025,7 @@ class Color {
      * @param {number} value
      */
     fromUint(value) {
+
         const r = value >> 16;
         const g = (value >> 8) & 0xFF;
         const b = (value) & 0xFF;
@@ -56345,7 +56350,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
@@ -56958,7 +56963,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;
 
 /**
  *
@@ -111133,6 +111145,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() {
         /**
@@ -111149,6 +111256,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;
     }
@@ -111172,6 +111287,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;
 
@@ -111197,6 +111313,7 @@ class LightBinding {
 
         this.__apply_position();
         this.__apply_rotation();
+        this.__apply_scale();
 
         this.applySettings(ctx.system.settings);
     }
@@ -111208,6 +111325,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);
@@ -111225,6 +111343,10 @@ class LightBinding {
 
     }
 
+    __apply_scale(){
+
+    }
+
     __apply_intensity() {
 
     }
@@ -111250,106 +111372,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 = [];
     }
 
     /**
@@ -111361,6 +111399,10 @@ class FPLightBinding extends LightBinding {
         return ctx.system.__plugin.getValue();
     }
 
+    #updateDistance() {
+        this.__light.radius.set(this.scaled_distance);
+    }
+
     link(ctx) {
         /**
          *
@@ -111373,11 +111415,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;
 
         /**
          *
@@ -111386,9 +111434,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) {
@@ -111401,7 +111455,47 @@ 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);
 }
 
 /**
@@ -111453,41 +111547,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;
@@ -111627,7 +111686,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() {
@@ -111794,6 +111853,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();