@woosh/meep-engine 2.118.8 → 2.118.11

package/build/meep.module.js

@@ -1,7 +1,7 @@
 /**
  *
- * @param {Array|Uint8Array} a
- * @param {Array|Uint8Array} b
+ * @param {Array|Uint8Array|Float32Array} a
+ * @param {Array|Uint8Array|Float32Array} b
  * @returns {boolean}
  */
 function isArrayEqualStrict(a, b) {
@@ -2531,10 +2531,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);
     }
 
     /**
@@ -2584,10 +2584,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
@@ -2847,31 +2843,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
@@ -3004,24 +2975,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);
@@ -3109,6 +3062,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;
@@ -4015,18 +3970,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
             );
 
@@ -4558,10 +4513,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
@@ -49010,34 +48962,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
@@ -49184,6 +49108,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;
@@ -49258,19 +49238,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;
 
@@ -49287,18 +49267,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
@@ -49321,8 +49289,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);
     }
@@ -49377,8 +49345,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;
@@ -49440,8 +49408,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
@@ -49670,7 +49638,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
+        );
     }
 
     /**
@@ -49725,24 +49697,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
@@ -49872,11 +49826,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) {
 
@@ -50054,10 +50008,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;
@@ -50069,6 +50026,11 @@ class Sampler2D {
      * @return {boolean}
      */
     equals(other) {
+        if(this === other){
+            // special case
+            return true;
+        }
+
         if (
             this.width !== other.width
             || this.height !== other.height
@@ -50089,9 +50051,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;
     }
@@ -50627,6 +50587,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
@@ -55302,29 +55290,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}
@@ -55610,73 +55575,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
@@ -55690,15 +55588,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];
@@ -55707,14 +55607,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++;
                 }
@@ -55748,7 +55649,7 @@ class BinaryUint32BVH {
     }
 
     /**
-     *
+     * Does not update intermediate node bounds
      * @param {number} i
      * @param {number} j
      * @private
@@ -56422,13 +56323,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}
@@ -57739,7 +57633,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);
 
@@ -58209,6 +58103,7 @@ class TerrainTile {
 
                 geometry.boundingSphere = new Sphere(center, radius);
             }
+
             //pull bounding box from geometry
 
             bb = geometry.boundingBox;
@@ -58216,6 +58111,7 @@ class TerrainTile {
                 geometry.computeBoundingBox();
                 bb = geometry.boundingBox;
             }
+
         }
 
         const x0 = bb.min.x;
@@ -59113,11 +59009,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');
@@ -59635,7 +59531,10 @@ const AmbientOcclusionShader = function () {
  * @returns {number}
  */
 function gaussian$1(sigma, v) {
-    return Math.exp(-(v * v) / (2 * sigma * sigma));
+    const v2 = v * v;
+    const sigma2 = sigma * sigma;
+
+    return Math.exp(- v2 / (2 * sigma2));
 }
 
 /**
@@ -62617,7 +62516,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');
     }
@@ -62824,7 +62723,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();
 
@@ -63643,11 +63542,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();
     }
 
     /**
@@ -63726,6 +63630,10 @@ class WorkerProxy {
 
     }
 
+    /**
+     *
+     * @private
+     */
     __generateAPI() {
 
 
@@ -66106,6 +66014,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
@@ -85584,7 +85515,7 @@ class Deque {
 
     /**
      *
-     * @param {E} e
+     * @param {T} e
      * @returns {boolean}
      */
     has(e) {
@@ -90948,6 +90879,10 @@ function configureThreeRenderer(webGLRenderer) {
 class GraphicsEngine {
     #debug = false;
 
+    get isGraphicsEngine(){
+        return true;
+    }
+
     /**
      *
      * @param {Camera} camera
@@ -92426,13 +92361,7 @@ class TaskGroup {
      * @returns {boolean}
      */
     addChild(child) {
-        if (this.children.indexOf(child) !== -1) {
-            return false;
-        }
-
-        this.children.push(child);
-
-        return true;
+        return array_push_if_unique(this.children, child);
     }
 
     /**
@@ -92582,7 +92511,7 @@ class TaskGroup {
      * @returns {Promise<unknown>}
      */
     promise() {
-        return Task.promise(this);
+        return new Promise((resolve, reject) => this.join(resolve, reject));
     }
 }
 
@@ -92959,14 +92888,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.
@@ -97801,139 +97728,6 @@ class SimpleLifecycle {
     }
 }
 
-class LinearValue {
-
-    /**
-     * @readonly
-     * @type {Signal}
-     */
-    onChanged = new Signal();
-
-    /**
-     *
-     * @param {number} [x = 0]
-     * @param {number} [a = 0]
-     * @param {number} [b = 1]
-     * @constructor
-     */
-    constructor(x = 0, a = 0, b = 1) {
-
-        /**
-         *
-         * @type {number}
-         */
-        this.x = x;
-        /**
-         *
-         * @type {number}
-         */
-        this.a = a;
-        /**
-         *
-         * @type {number}
-         */
-        this.b = b;
-
-    }
-
-    /**
-     *
-     * @param {LinearValue} other
-     * @returns {LinearValue}
-     */
-    copy(other) {
-        return this.set(other.x, other.a, other.b);
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} a
-     * @param {number} b
-     * @returns {LinearValue}
-     */
-    set(x, a, b) {
-        this.x = x;
-        this.a = a;
-        this.b = b;
-
-        this.onChanged.dispatch(x, a, b);
-        return this;
-    }
-
-    /**
-     *
-     * @param v
-     * @returns {LinearValue}
-     */
-    addMultiplier(v) {
-        this.b += v;
-
-        this.onChanged.dispatch(this.x, this.a, this.b);
-        return this;
-    }
-
-    /**
-     *
-     * @param v
-     * @returns {LinearValue}
-     */
-    subMultiplier(v) {
-        return this.addMultiplier(-v);
-    }
-
-    /**
-     *
-     * @param v
-     * @returns {LinearValue}
-     */
-    addConstant(v) {
-        this.a += v;
-
-        this.onChanged.dispatch(this.x, this.a, this.b);
-        return this;
-    }
-
-    /**
-     *
-     * @param v
-     * @returns {LinearValue}
-     */
-    subConstant(v) {
-        return this.addConstant(-v);
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    getValue() {
-        // y = b*x + a
-        return this.x * this.b + this.a;
-    }
-
-    /**
-     *
-     * @param {LinearValue} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.x === other.x && this.a === other.a && this.b === other.b;
-    }
-
-    toJSON() {
-        return {
-            x: this.x,
-            a: this.a,
-            b: this.b
-        };
-    }
-
-    fromJSON(json) {
-        this.set(json.x, json.a, json.b);
-    }
-}
-
 /**
  *
  * @param {string} string
@@ -98113,7 +97907,6 @@ function findProcessor(model) {
 }
 
 
-
 class ValueProcessor {
     /**
      * @template Container, Value
@@ -98160,7 +97953,6 @@ const processors = [
     p(isInstanceOf(ObservedBoolean), extractorGetValue, format),
     p(isInstanceOf(ObservedValue), extractorGetValue, format),
     p(isInstanceOf(ObservedString), extractorGetValue, format),
-    p(isInstanceOf(LinearValue), extractorGetValue, formatNumber),
     p(isInstanceOf(BoundedValue), extractBoundedValue, formatArray),
     p(isInstanceOf(Stat), extractorGetValue, formatNumber),
     p(isInstanceOf(Vector1), extractorGetValue, formatNumber),
@@ -115645,14 +115437,14 @@ class InputControllerSystem extends System {
 }
 
 class LoggerBackend {
-    constructor() {
 
-        /**
-         * @private
-         * @type {LogLevel|number}
-         */
-        this.level = LogLevel.Info;
-    }
+
+    /**
+     * @private
+     * @type {LogLevel|number}
+     */
+    level = LogLevel.Info;
+
 
     /**
      *