@woosh/meep-engine 2.75.7 → 2.75.9

package/build/meep.module.js

@@ -49635,137 +49635,6 @@ const TerrainShader = {
     fragmentShader: fragment$2()
 };
 
-/**
- *
- * Produces a proportional mix of 2 values, a*(1-portion) + b*portion
- * Same as lerp
- */
-const mix = lerp$1;
-
-/**
- * Color blending modes
- * @enum {number}
- */
-const BlendingType = {
-    NoBlending: 5,
-    Normal: 0,
-    Add: 1,
-    Subtract: 2,
-    Multiply: 3,
-    MultiplyAdd: 4
-};
-
-function typedArrayConstructorByInstance(a) {
-    if (a instanceof Int8Array) {
-        return Int8Array;
-    } else if (a instanceof Int16Array) {
-        return Int16Array;
-    } else if (a instanceof Int32Array) {
-        return Int32Array;
-    } else if (a instanceof Uint8Array) {
-        return Uint8Array;
-    } else if (a instanceof Uint8ClampedArray) {
-        return Uint8ClampedArray;
-    } else if (a instanceof Uint16Array) {
-        return Uint16Array;
-    } else if (a instanceof Uint32Array) {
-        return Uint32Array;
-    } else if (a instanceof Float32Array) {
-        return Float32Array;
-    } else if (a instanceof Float64Array) {
-        return Float64Array;
-    } else if (Array.isArray(a)) {
-        return Array;
-    } else {
-        throw new TypeError(`Unsupported array type`);
-    }
-}
-
-/**
- * @readonly
- * @enum {string}
- */
-const BinaryDataType = {
-    Uint8: "uint8",
-    Uint16: "uint16",
-    Uint32: "uint32",
-    Uint64: "uint64",
-
-    Int8: "int8",
-    Int16: "int16",
-    Int32: "int32",
-    Int64: "int64",
-
-    Float16: 'float16',
-    Float32: "float32",
-    Float64: "float64"
-};
-
-/**
- *
- * @param {*} v
- * @returns {BinaryDataType}
- */
-function typedArrayToDataType(v) {
-    const ctor = Object.getPrototypeOf(v).constructor;
-
-    switch (ctor) {
-        case Uint8Array:
-        case Uint8ClampedArray:
-            return BinaryDataType.Uint8;
-        case Uint16Array:
-            return BinaryDataType.Uint16;
-        case Uint32Array:
-            return BinaryDataType.Uint32;
-
-        case Int8Array:
-            return BinaryDataType.Int8;
-        case Int16Array:
-            return BinaryDataType.Int16;
-        case Int32Array:
-            return BinaryDataType.Int32;
-
-        case Float32Array:
-            return BinaryDataType.Float32;
-        case Float64Array:
-            return BinaryDataType.Float64;
-        default:
-            throw new Error('unsupported constructor type');
-    }
-}
-
-/**
- * Mapping from {@DataType} to TypedArray constructors
- * @enum {function}
- */
-const DataType2TypedArrayConstructorMapping = {
-    [BinaryDataType.Uint8]: Uint8Array,
-    [BinaryDataType.Uint16]: Uint16Array,
-    [BinaryDataType.Uint32]: Uint32Array,
-    [BinaryDataType.Int8]: Int8Array,
-    [BinaryDataType.Int16]: Int16Array,
-    [BinaryDataType.Int32]: Int32Array,
-    // No float16 array type, using uint16 as a backing instead
-    [BinaryDataType.Float16]: Uint16Array,
-    [BinaryDataType.Float32]: Float32Array,
-    [BinaryDataType.Float64]: Float64Array,
-};
-
-/**
- *
- * @param {BinaryDataType} dt
- * @returns {constructor|function}
- */
-function compute_typed_array_constructor_from_data_type(dt) {
-    const r = DataType2TypedArrayConstructorMapping[dt];
-
-    if (r === undefined) {
-        throw new Error(`Unsupported data type '${dt}'`);
-    }
-
-    return r;
-}
-
 /**
  * Adapted from https://github.com/beatgammit/base64-js
  * @author Jameson Little
@@ -49978,25 +49847,55 @@ class Base64 {
 }
 
 /**
- * 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}
+ * @readonly
+ * @enum {string}
  */
-function computeStridedIntegerArrayHash(
-    array, offset, length, stride
-) {
-    let result = length;
+const BinaryDataType = {
+    Uint8: "uint8",
+    Uint16: "uint16",
+    Uint32: "uint32",
+    Uint64: "uint64",
 
-    for (let i = offset; i < length; i += stride) {
-        const value = array[i];
+    Int8: "int8",
+    Int16: "int16",
+    Int32: "int32",
+    Int64: "int64",
 
-        result = ((result * 31) + value) | 0;
+    Float16: 'float16',
+    Float32: "float32",
+    Float64: "float64"
+};
+
+/**
+ * Mapping from {@DataType} to TypedArray constructors
+ * @enum {function}
+ */
+const DataType2TypedArrayConstructorMapping = {
+    [BinaryDataType.Uint8]: Uint8Array,
+    [BinaryDataType.Uint16]: Uint16Array,
+    [BinaryDataType.Uint32]: Uint32Array,
+    [BinaryDataType.Int8]: Int8Array,
+    [BinaryDataType.Int16]: Int16Array,
+    [BinaryDataType.Int32]: Int32Array,
+    // No float16 array type, using uint16 as a backing instead
+    [BinaryDataType.Float16]: Uint16Array,
+    [BinaryDataType.Float32]: Float32Array,
+    [BinaryDataType.Float64]: Float64Array,
+};
+
+/**
+ *
+ * @param {BinaryDataType} dt
+ * @returns {constructor|function}
+ */
+function compute_typed_array_constructor_from_data_type(dt) {
+    const r = DataType2TypedArrayConstructorMapping[dt];
+
+    if (r === undefined) {
+        throw new Error(`Unsupported data type '${dt}'`);
     }
 
-    return result;
+    return r;
 }
 
 //
@@ -50066,6 +49965,107 @@ function is_typed_array_equals(a, b) {
     return isArrayEqualStrict(a_proxy, b_proxy);
 }
 
+/**
+ *
+ * @param {*} v
+ * @returns {BinaryDataType}
+ */
+function typedArrayToDataType(v) {
+    const ctor = Object.getPrototypeOf(v).constructor;
+
+    switch (ctor) {
+        case Uint8Array:
+        case Uint8ClampedArray:
+            return BinaryDataType.Uint8;
+        case Uint16Array:
+            return BinaryDataType.Uint16;
+        case Uint32Array:
+            return BinaryDataType.Uint32;
+
+        case Int8Array:
+            return BinaryDataType.Int8;
+        case Int16Array:
+            return BinaryDataType.Int16;
+        case Int32Array:
+            return BinaryDataType.Int32;
+
+        case Float32Array:
+            return BinaryDataType.Float32;
+        case Float64Array:
+            return BinaryDataType.Float64;
+        default:
+            throw new Error('unsupported constructor type');
+    }
+}
+
+/**
+ *
+ * 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
+ * @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 result = length;
+
+    for (let i = offset; i < length; i += stride) {
+        const value = array[i];
+
+        result = ((result * 31) + value) | 0;
+    }
+
+    return result;
+}
+
+function typedArrayConstructorByInstance(a) {
+    if (a instanceof Int8Array) {
+        return Int8Array;
+    } else if (a instanceof Int16Array) {
+        return Int16Array;
+    } else if (a instanceof Int32Array) {
+        return Int32Array;
+    } else if (a instanceof Uint8Array) {
+        return Uint8Array;
+    } else if (a instanceof Uint8ClampedArray) {
+        return Uint8ClampedArray;
+    } else if (a instanceof Uint16Array) {
+        return Uint16Array;
+    } else if (a instanceof Uint32Array) {
+        return Uint32Array;
+    } else if (a instanceof Float32Array) {
+        return Float32Array;
+    } else if (a instanceof Float64Array) {
+        return Float64Array;
+    } else if (Array.isArray(a)) {
+        return Array;
+    } else {
+        throw new TypeError(`Unsupported array type`);
+    }
+}
+
 /**
  * Created by Alex on 11/11/2014.
  */
@@ -50134,35 +50134,6 @@ class Sampler2D {
         this.version = 0;
     }
 
-    /**
-     * @deprecated
-     * @param {number} [channel=0]
-     * @returns {{x: number, index: number, y: number, value: number}}
-     */
-    computeMax(channel = 0) {
-        throw new Error("deprecated, use sampler2d_channel_compute_max");
-    }
-
-    /**
-     * @deprecated
-     * @param {number[]} result
-     * @param {number} result_offset
-     * @param {number} [channel=0]
-     * @returns {number} number of matches written to result array
-     */
-    computeMinIndices(result, result_offset = 0, channel = 0) {
-        throw new Error("deprecated, use sampler2d_channel_compute_min_indices")
-    }
-
-    /**
-     * @deprecated
-     * @param {number} [channel=0]
-     * @returns {{x: number, index: number, y: number, value: number}}
-     */
-    computeMin(channel = 0) {
-        throw new Error("deprecated, use sampler2d_channel_compute_min");
-    }
-
     /**
      *
      * @deprecated
@@ -50172,18 +50143,7 @@ class Sampler2D {
      * @returns {number}
      */
     get(x, y, result) {
-        console.warn("Deprecated method, use sampleBilinear instead");
-
-        const t = [];
-
-        this.sampleBilinear(x, y, t, 0);
-
-        if (result !== undefined) {
-            result.readFromArray(t, 0);
-            return result;
-        } else {
-            return t[0];
-        }
+        throw new Error("Deprecated method, use sampleBilinear instead");
     }
 
     /**
@@ -50386,23 +50346,14 @@ class Sampler2D {
         const vl2 = data[row3_address + col2_offset];
         const vl3 = data[row3_address + col3_offset];
 
-
-        // return bicubic(xd, yd,
-        //     vi0, vi1, vi2, vi3,
-        //     vj0, vj1, vj2, vj3,
-        //     vk0, vk1, vk2, vk3,
-        //     vl0, vl1, vl2, vl3,
-        // );
-
-
         // perform filtering in X (rows)
-        const s0 = bicubic_terp(xd, vi0, vi1, vi2, vi3);
-        const s1 = bicubic_terp(xd, vj0, vj1, vj2, vj3);
-        const s2 = bicubic_terp(xd, vk0, vk1, vk2, vk3);
-        const s3 = bicubic_terp(xd, vl0, vl1, vl2, vl3);
+        const s0 = interpolate_bicubic(xd, vi0, vi1, vi2, vi3);
+        const s1 = interpolate_bicubic(xd, vj0, vj1, vj2, vj3);
+        const s2 = interpolate_bicubic(xd, vk0, vk1, vk2, vk3);
+        const s3 = interpolate_bicubic(xd, vl0, vl1, vl2, vl3);
 
         // filter in Y (columns)
-        return bicubic_terp(yd, s0, s1, s2, s3);
+        return interpolate_bicubic(yd, s0, s1, s2, s3);
     }
 
     /**
@@ -50641,162 +50592,6 @@ class Sampler2D {
         result.set(x, y);
     }
 
-    /**
-     * Copy a patch from another sampler with a margin.
-     * This is useful for texture rendering where filtering can cause bleeding along the edges of the patch.
-     * @param {Sampler2D} source where to copy from
-     * @param {Number} sourceX where to start reading from, X coordinate
-     * @param {Number} sourceY where to start reading from, X coordinate
-     * @param {Number} destinationX where to start writing to, X coordinate
-     * @param {Number} destinationY where to start writing to, X coordinate
-     * @param {Number} width size of the patch that is to be copied
-     * @param {Number} height size of the patch that is to be copied
-     * @param {Number} marginLeft
-     * @param {Number} marginRight
-     * @param {Number} marginTop
-     * @param {Number} marginBottom
-     */
-    copyWithMargin(source, sourceX, sourceY, destinationX, destinationY, width, height, marginLeft, marginRight, marginTop, marginBottom) {
-        const dItemSize = this.itemSize;
-        const sItemSize = source.itemSize;
-        const _itemSize = Math.min(dItemSize, sItemSize);
-
-
-        const dRowSize = dItemSize * this.width;
-        const sRowSize = sItemSize * source.width;
-
-        const sData = source.data;
-        const dData = this.data;
-
-        let x, y, i;
-
-        let xMax, yMax;
-
-        let dA, sA, dOffset, sOffset;
-        //Write top-left corner
-        sOffset = sourceY * sRowSize + sourceX * dItemSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write top margin
-        sA = sourceY * sRowSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = 0; x < width; x++) {
-
-                dOffset = dA + (x + destinationX) * dItemSize;
-                sOffset = sA + (x + sourceX) * dItemSize;
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write top-right corner
-        sOffset = sourceY * sRowSize + (sourceX + width - 1) * dItemSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write left margin
-        for (y = 0; y < height; y++) {
-            dA = (y + destinationY) * dRowSize;
-            sA = (y + sourceY) * sRowSize;
-
-            sOffset = sA + (sourceX) * dItemSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //write actual patch
-        this.copy(source, sourceX, sourceY, destinationX, destinationY, width, height);
-
-        //Write right margin
-        for (y = 0; y < height; y++) {
-            dA = (y + destinationY) * dRowSize;
-            sA = (y + sourceY) * sRowSize;
-
-            sOffset = sA + (sourceX + width - 1) * dItemSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-
-        //Write Bottom-left margin
-        sOffset = (sourceY + height - 1) * sRowSize + sourceX * dItemSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write Bottom margin
-        sA = (sourceY + height - 1) * sRowSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = 0; x < width; x++) {
-
-                dOffset = dA + (x + destinationX) * dItemSize;
-                sOffset = sA + (x + sourceX) * dItemSize;
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write Bottom-right margin
-        sOffset = (sourceY + height - 1) * sRowSize + (sourceX + width - 1) * dItemSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-
-        this.version++;
-    }
-
     /**
      * Copy a patch from another sampler
      * @param {Sampler2D} source where to copy from
@@ -50853,106 +50648,6 @@ class Sampler2D {
         this.version++;
     }
 
-    /**
-     * Copy a patch from another sampler with the same itemSize
-     * @param {Sampler2D} source where to copy from
-     * @param {Number} sourceX where to start reading from, X coordinate
-     * @param {Number} sourceY where to start reading from, X coordinate
-     * @param {Number} destinationX where to start writing to, X coordinate
-     * @param {Number} destinationY where to start writing to, X coordinate
-     * @param {Number} width size of the patch that is to be copied
-     * @param {Number} height size of the patch that is to be copied
-     */
-    copy_sameItemSize(source, sourceX, sourceY, destinationX, destinationY, width, height) {
-        const itemSize = this.itemSize;
-        const sItemSize = source.itemSize;
-
-        assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != this.itemSize(=${itemSize})`);
-
-        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
-
-
-        const dRowSize = itemSize * this.width;
-        const sRowSize = itemSize * source.width;
-
-        const sData = source.data;
-        const dData = this.data;
-
-        const patchRowSize = _w * itemSize;
-
-        let y, i;
-
-        for (y = 0; y < _h; y++) {
-            const dA = (y + destinationY) * dRowSize;
-            const sA = (y + sourceY) * sRowSize;
-
-            const dOffset = dA + destinationX * itemSize;
-            const sOffset = sA + sourceX * itemSize;
-
-            for (i = 0; i < patchRowSize; i++) {
-
-                dData[dOffset + i] = sData[sOffset + i];
-
-            }
-        }
-
-        this.version++;
-    }
-
-    /**
-     * Assumes both samplers are uint8 with values 0-255
-     * @param {Sampler2D} source
-     * @param sourceX
-     * @param sourceY
-     * @param destinationX
-     * @param destinationY
-     * @param width
-     * @param height
-     * @param {BlendingType} [blendMode]
-     */
-    paint(source, sourceX, sourceY, destinationX, destinationY, width, height, blendMode = BlendingType.Normal) {
-        let blendFunction;
-        if (blendMode === BlendingType.Normal) {
-            blendFunction = blendFunctionNormal;
-        } else {
-            throw new Error(`Unsupported blendType(=${blendMode})`);
-        }
-
-        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
-
-        const _x0 = Math.max(0, -destinationX);
-        const _y0 = Math.max(0, -destinationY);
-
-        const c0 = [0, 0, 0, 255];
-        const c1 = [0, 0, 0, 255];
-
-        const c3 = [];
-
-        let x, y;
-
-        for (y = _y0; y < _h; y++) {
-            for (x = _x0; x < _w; x++) {
-                const d_x = Math.round(x + destinationX);
-                const d_y = Math.round(y + destinationY);
-
-                this.read(d_x, d_y, c0);
-
-                const s_x = Math.round(x + sourceY);
-                const s_y = Math.round(y + sourceY);
-
-                source.read(s_x, s_y, c1);
-
-                blendFunction(c1, c0, c3);
-
-                this.set(d_x, d_y, c3);
-
-            }
-        }
-
-
-    }
 
     /**
      * Fill data values with zeros for a given area
@@ -51213,22 +50908,6 @@ class Sampler2D {
         return dataSize + 280;
     }
 
-    /**
-     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
-    }
-
-    /**
-     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
-    }
-
     /**
      *
      * @param {Sampler2D} other
@@ -51439,38 +51118,7 @@ Sampler2D.prototype.isSampler2D = true;
  * @readonly
  * @type {string}
  */
-Sampler2D.typeName = "Sampler2D";
-
-/**
- * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
- * @param {number} t
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} d
- * @returns {number}
- */
-function bicubic_terp(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;
-}
-
-
-/**
- *
- * @param {number[]} source
- * @param {number[]} destination
- * @param {Array} result
- */
-function blendFunctionNormal(source, destination, result) {
-
-    const a1 = source[3] / 255;
-    const a0 = destination[3] / 255;
-
-    result[0] = source[0] * a1 + destination[0] * (1 - a1);
-    result[1] = source[1] * a1 + destination[1] * (1 - a1);
-    result[2] = source[2] * a1 + destination[2] * (1 - a1);
-    result[3] = (a1 + a0 * (1 - a1)) * 255;
-}
+Sampler2D.typeName = "Sampler2D";
 
 /**
  *
@@ -51779,6 +51427,354 @@ function SplatMaterial(
 
 const WHITE_PIXEL_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAA1JREFUGFdj+P///38ACfsD/QVDRcoAAAAASUVORK5CYII=";
 
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+function float2uint8(v) {
+    return Math.round(v * 255);
+}
+
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+function uint82float(v) {
+    return v / 255;
+}
+
+/**
+ * Copy data from one array to another
+ * Follows Java System.arraycopy interface
+ * @template T
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Uint32Array|Int32Array|Float32Array|Float64Array} source The source array
+ * @param {number} source_position Starting position where to copy from inside the source array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Uint32Array|Int32Array|Float32Array|Float64Array} destination The destination array
+ * @param {number} destination_position Starting position where to copy to inside the destination array
+ * @param {number} length How many elements should be copied
+ */
+function array_copy(
+    source,
+    source_position,
+    destination,
+    destination_position,
+    length
+) {
+    assert.isNonNegativeInteger(source_position, 'source_position');
+    assert.isNonNegativeInteger(destination_position, 'destination_position');
+    assert.isNonNegativeInteger(length, 'length');
+
+    let i, j, k;
+
+    for (k = 0; k < length; k++) {
+        i = source_position + k;
+        j = destination_position + k;
+
+        destination[j] = source[i];
+    }
+}
+
+/**
+ * @author Alex Goldring
+ * @copyright Alex Goldring 2018
+ */
+
+
+class Vector1 extends Number {
+    /**
+     *
+     * @param {number} [x=0]
+     * @constructor
+     * @class
+     * @property {number} x
+     */
+    constructor(x = 0) {
+        super();
+
+        assert.isNumber( x, 'x');
+        assert.notNaN(x, 'x');
+
+        this.x = x;
+
+        this.onChanged = new Signal();
+    }
+
+    /**
+     * Inherited from Number class
+     * @returns {number}
+     */
+    valueOf() {
+        return this.x;
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    toString() {
+        return String(this.x);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getValue() {
+        return this.x;
+    }
+
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {number}
+     */
+    compareTo(other) {
+        return this.x - other.x;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @returns {Vector1}
+     */
+    set(x) {
+        assert.isNumber( x,'x');
+        assert.notNaN(x, 'x');
+
+        const oldValue = this.x;
+        if (oldValue !== x) {
+            this.x = x;
+
+            if (this.onChanged.hasHandlers()) {
+                this.onChanged.send2(x, oldValue);
+            }
+        }
+
+        return this;
+    }
+
+    /**
+     * Set value without triggering {@link #onChanged} signal
+     * @param {number} x
+     */
+    setSilent(x) {
+        this.x = x;
+    }
+
+    /**
+     *
+     * @return {boolean}
+     */
+    isZero() {
+        return this.x === 0;
+    }
+
+    increment() {
+        this._add(1);
+    }
+
+    decrement() {
+        this._add(-1);
+    }
+
+    /**
+     *
+     * @param {Number} v
+     * @return {Vector1}
+     */
+    _add(v) {
+        return this.set(this.x + v);
+    }
+
+    /**
+     *
+     * @param {Vector1|Vector2|Vector3|Vector4} other
+     */
+    add(other) {
+        return this._add(other.x);
+    }
+
+    /**
+     *
+     * @param {Number} v
+     * @return {Vector1}
+     */
+    _sub(v) {
+        return this._add(-v);
+    }
+
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {Vector1}
+     */
+    sub(other) {
+        return this._sub(other.x);
+    }
+
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {Vector1}
+     */
+    multiply(other) {
+        return this.set(this.x * other.x);
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    multiplyScalar(v) {
+        this.set(this.x * v);
+    }
+
+    /**
+     *
+     * @param {number} low
+     * @param {number} high
+     * @returns {Vector1}
+     */
+    clamp(low, high) {
+        return this.set(clamp$1(this.x, low, high));
+    }
+
+    /**
+     *
+     * @param {Vector1|Vector2|Vector3|Vector4} other
+     */
+    copy(other) {
+        this.set(other.x);
+    }
+
+    /**
+     *
+     * @returns {Vector1}
+     */
+    clone() {
+        return new Vector1(this.x);
+    }
+
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.x === other.x;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        return computeHashFloat(this.x);
+    }
+
+    /**
+     *
+     * @param {function(newValue:number, oldValue:number)} handler
+     */
+    process(handler) {
+        handler(this.x, this.x);
+        this.onChanged.add(handler);
+    }
+
+    toJSON() {
+        return this.x;
+    }
+
+    fromJSON(val) {
+        this.set(val);
+    }
+
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    readFromArray(array, offset=0) {
+        this.set(array[offset]);
+    }
+
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    writeToArray(array, offset=0) {
+        array[offset] = this.x;
+    }
+
+    asArray(){
+        return [this.x];
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.x);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const x = buffer.readFloat64();
+
+        this.set(x);
+    }
+
+    /**
+     *
+     * @param {Vector1} a
+     * @param {Vector1} b
+     * @return {number}
+     */
+    static compare(a, b) {
+        return a.x - b.x;
+    }
+
+    get 0() {
+        return this.x;
+    }
+
+    set 0(v) {
+        this.x = v;
+    }
+
+    * [Symbol.iterator]() {
+
+        yield this.x;
+
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Vector1.prototype.isVector1 = true;
+
+Vector1.typeName = "Vector1";
+
+/**
+ * @readonly
+ * @type {Vector1}
+ */
+Vector1.zero = Object.freeze(new Vector1(0));
+
+/**
+ * @readonly
+ * @type {Vector1}
+ */
+Vector1.one = Object.freeze(new Vector1(1));
+
 /**
  *
  * @param {Uint8Array|number[]|ArrayLike<number>|IArguments} data
@@ -52276,342 +52272,6 @@ class Vector4 {
     }
 }
 
-/**
- * Created by Alex on 11/11/2014.
- */
-
-
-function canvas2Sampler2D(canvas) {
-    const width = canvas.width;
-    const height = canvas.height;
-
-    const context = canvas.getContext("2d");
-
-    const result = new Sampler2D(null, 4, width, height);
-
-    canvasDataToSampler(result, context);
-
-    return result;
-
-}
-
-/**
- *
- * @param {Sampler2D} target
- * @param {CanvasRenderingContext2D} ctx
- */
-function canvasDataToSampler(target, ctx) {
-    const width = target.width;
-    const height = target.height;
-
-    const imageData = ctx.getImageData(0, 0, width, height);
-
-    const data = imageData.data;
-
-    assert.equal(data.length, target.height * target.width * target.itemSize);
-
-    target.data = data;
-}
-
-/**
- * @author Alex Goldring
- * @copyright Alex Goldring 2018
- */
-
-
-class Vector1 extends Number {
-    /**
-     *
-     * @param {number} [x=0]
-     * @constructor
-     * @class
-     * @property {number} x
-     */
-    constructor(x = 0) {
-        super();
-
-        assert.isNumber( x, 'x');
-        assert.notNaN(x, 'x');
-
-        this.x = x;
-
-        this.onChanged = new Signal();
-    }
-
-    /**
-     * Inherited from Number class
-     * @returns {number}
-     */
-    valueOf() {
-        return this.x;
-    }
-
-    /**
-     *
-     * @returns {string}
-     */
-    toString() {
-        return String(this.x);
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    getValue() {
-        return this.x;
-    }
-
-    /**
-     *
-     * @param {Vector1} other
-     * @returns {number}
-     */
-    compareTo(other) {
-        return this.x - other.x;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @returns {Vector1}
-     */
-    set(x) {
-        assert.isNumber( x,'x');
-        assert.notNaN(x, 'x');
-
-        const oldValue = this.x;
-        if (oldValue !== x) {
-            this.x = x;
-
-            if (this.onChanged.hasHandlers()) {
-                this.onChanged.send2(x, oldValue);
-            }
-        }
-
-        return this;
-    }
-
-    /**
-     * Set value without triggering {@link #onChanged} signal
-     * @param {number} x
-     */
-    setSilent(x) {
-        this.x = x;
-    }
-
-    /**
-     *
-     * @return {boolean}
-     */
-    isZero() {
-        return this.x === 0;
-    }
-
-    increment() {
-        this._add(1);
-    }
-
-    decrement() {
-        this._add(-1);
-    }
-
-    /**
-     *
-     * @param {Number} v
-     * @return {Vector1}
-     */
-    _add(v) {
-        return this.set(this.x + v);
-    }
-
-    /**
-     *
-     * @param {Vector1|Vector2|Vector3|Vector4} other
-     */
-    add(other) {
-        return this._add(other.x);
-    }
-
-    /**
-     *
-     * @param {Number} v
-     * @return {Vector1}
-     */
-    _sub(v) {
-        return this._add(-v);
-    }
-
-    /**
-     *
-     * @param {Vector1} other
-     * @returns {Vector1}
-     */
-    sub(other) {
-        return this._sub(other.x);
-    }
-
-    /**
-     *
-     * @param {Vector1} other
-     * @returns {Vector1}
-     */
-    multiply(other) {
-        return this.set(this.x * other.x);
-    }
-
-    /**
-     *
-     * @param {number} v
-     */
-    multiplyScalar(v) {
-        this.set(this.x * v);
-    }
-
-    /**
-     *
-     * @param {number} low
-     * @param {number} high
-     * @returns {Vector1}
-     */
-    clamp(low, high) {
-        return this.set(clamp$1(this.x, low, high));
-    }
-
-    /**
-     *
-     * @param {Vector1|Vector2|Vector3|Vector4} other
-     */
-    copy(other) {
-        this.set(other.x);
-    }
-
-    /**
-     *
-     * @returns {Vector1}
-     */
-    clone() {
-        return new Vector1(this.x);
-    }
-
-    /**
-     *
-     * @param {Vector1} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.x === other.x;
-    }
-
-    /**
-     * @returns {number}
-     */
-    hash() {
-        return computeHashFloat(this.x);
-    }
-
-    /**
-     *
-     * @param {function(newValue:number, oldValue:number)} handler
-     */
-    process(handler) {
-        handler(this.x, this.x);
-        this.onChanged.add(handler);
-    }
-
-    toJSON() {
-        return this.x;
-    }
-
-    fromJSON(val) {
-        this.set(val);
-    }
-
-    /**
-     *
-     * @param {number[]} array
-     * @param {number} offset
-     */
-    readFromArray(array, offset=0) {
-        this.set(array[offset]);
-    }
-
-    /**
-     *
-     * @param {number[]} array
-     * @param {number} offset
-     */
-    writeToArray(array, offset=0) {
-        array[offset] = this.x;
-    }
-
-    asArray(){
-        return [this.x];
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        buffer.writeFloat64(this.x);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        const x = buffer.readFloat64();
-
-        this.set(x);
-    }
-
-    /**
-     *
-     * @param {Vector1} a
-     * @param {Vector1} b
-     * @return {number}
-     */
-    static compare(a, b) {
-        return a.x - b.x;
-    }
-
-    get 0() {
-        return this.x;
-    }
-
-    set 0(v) {
-        this.x = v;
-    }
-
-    * [Symbol.iterator]() {
-
-        yield this.x;
-
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-Vector1.prototype.isVector1 = true;
-
-Vector1.typeName = "Vector1";
-
-/**
- * @readonly
- * @type {Vector1}
- */
-Vector1.zero = Object.freeze(new Vector1(0));
-
-/**
- * @readonly
- * @type {Vector1}
- */
-Vector1.one = Object.freeze(new Vector1(1));
-
 /**
  *
  * @param {string|null|undefined} string
@@ -52773,6 +52433,43 @@ class ObservedString extends String {
  */
 ObservedString.prototype.isObservedString = true;
 
+/**
+ * Created by Alex on 11/11/2014.
+ */
+
+
+function canvas2Sampler2D(canvas) {
+    const width = canvas.width;
+    const height = canvas.height;
+
+    const context = canvas.getContext("2d");
+
+    const result = new Sampler2D(null, 4, width, height);
+
+    canvasDataToSampler(result, context);
+
+    return result;
+
+}
+
+/**
+ *
+ * @param {Sampler2D} target
+ * @param {CanvasRenderingContext2D} ctx
+ */
+function canvasDataToSampler(target, ctx) {
+    const width = target.width;
+    const height = target.height;
+
+    const imageData = ctx.getImageData(0, 0, width, height);
+
+    const data = imageData.data;
+
+    assert.equal(data.length, target.height * target.width * target.itemSize);
+
+    target.data = data;
+}
+
 /**
  *
  * @param {Sampler2D} input
@@ -53007,52 +52704,96 @@ function sampler2d_scale(input, output) {
 }
 
 /**
- *
- * @param {number} v
- * @returns {number}
+ * Color blending modes
+ * @enum {number}
  */
-function uint82float(v) {
-    return v / 255;
-}
+const BlendingType = {
+    NoBlending: 5,
+    Normal: 0,
+    Add: 1,
+    Subtract: 2,
+    Multiply: 3,
+    MultiplyAdd: 4
+};
 
 /**
  *
- * @param {number} v
- * @returns {number}
+ * @param {number[]} source
+ * @param {number[]} destination
+ * @param {Array} result
  */
-function float2uint8(v) {
-    return Math.round(v * 255);
-}
-
+function blendFunctionNormal(source, destination, result) {
+
+    const a1 = source[3] / 255;
+    const a0 = destination[3] / 255;
+
+    result[0] = source[0] * a1 + destination[0] * (1 - a1);
+    result[1] = source[1] * a1 + destination[1] * (1 - a1);
+    result[2] = source[2] * a1 + destination[2] * (1 - a1);
+    result[3] = (a1 + a0 * (1 - a1)) * 255;
+}
+
 /**
- * Copy data from one array to another
- * Follows Java System.arraycopy interface
- * @template T
- * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Uint32Array|Int32Array|Float32Array|Float64Array} source The source array
- * @param {number} source_position Starting position where to copy from inside the source array
- * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Uint32Array|Int32Array|Float32Array|Float64Array} destination The destination array
- * @param {number} destination_position Starting position where to copy to inside the destination array
- * @param {number} length How many elements should be copied
+ * Assumes both samplers are RGBA uint8 with values 0-255
+ * @param {Sampler2D} destination
+ * @param {Sampler2D} source
+ * @param {number} sourceX
+ * @param {number} sourceY
+ * @param {number} destinationX
+ * @param {number} destinationY
+ * @param {number} width
+ * @param {number} height
+ * @param {BlendingType} [blendMode]
  */
-function array_copy(
-    source,
-    source_position,
+function sampler2d_paint(
     destination,
-    destination_position,
-    length
+    source,
+    sourceX, sourceY,
+    destinationX, destinationY,
+    width, height,
+    blendMode = BlendingType.Normal
 ) {
-    assert.isNonNegativeInteger(source_position, 'source_position');
-    assert.isNonNegativeInteger(destination_position, 'destination_position');
-    assert.isNonNegativeInteger(length, 'length');
 
-    let i, j, k;
+    let blendFunction;
+    if (blendMode === BlendingType.Normal) {
+        blendFunction = blendFunctionNormal;
+    } else {
+        throw new Error(`Unsupported blendType(=${blendMode})`);
+    }
 
-    for (k = 0; k < length; k++) {
-        i = source_position + k;
-        j = destination_position + k;
+    const _w = Math.min(width, source.width - sourceX, destination.width - destinationX);
+    const _h = Math.min(height, source.height - sourceY, destination.height - destinationY);
 
-        destination[j] = source[i];
+    const _x0 = Math.max(0, -destinationX);
+    const _y0 = Math.max(0, -destinationY);
+
+    const c0 = [0, 0, 0, 255];
+    const c1 = [0, 0, 0, 255];
+
+    const c3 = [];
+
+    let x, y;
+
+    for (y = _y0; y < _h; y++) {
+        for (x = _x0; x < _w; x++) {
+            const d_x = Math.round(x + destinationX);
+            const d_y = Math.round(y + destinationY);
+
+            destination.read(d_x, d_y, c0);
+
+            const s_x = Math.round(x + sourceY);
+            const s_y = Math.round(y + sourceY);
+
+            source.read(s_x, s_y, c1);
+
+            blendFunction(c1, c0, c3);
+
+            destination.set(d_x, d_y, c3);
+
+        }
     }
+
+
 }
 
 /**
@@ -53110,7 +52851,7 @@ class TerrainOverlay {
          */
         this.size = new Vector2(size.x, size.y);
 
-       /**
+        /**
          *
          * @type {ObservedString}
          */
@@ -53161,7 +52902,7 @@ class TerrainOverlay {
      *
      * @returns {string}
      */
-    get baseTileImage(){
+    get baseTileImage() {
         return this.stack.length === 0 ? this.tileImage.getValue() : this.stack[0].tileImage
     }
 
@@ -53169,7 +52910,7 @@ class TerrainOverlay {
      *
      * @param {string} v
      */
-    set baseTileImage(v){
+    set baseTileImage(v) {
         if (this.stack.length === 0) {
             this.tileImage.set(v);
         } else {
@@ -53357,7 +53098,7 @@ class TerrainOverlay {
         const scaled_source = Sampler2D.uint8(4, dWidth, dHeight);
         sampler2d_scale(source, scaled_source);
 
-        this.sampler.paint(scaled_source, 0, 0, dx, dy, dWidth, dHeight);
+        sampler2d_paint(this, scaled_source, 0, 0, dx, dy, dWidth, dHeight);
 
         this.texture.needsUpdate = true;
     }
@@ -53394,31 +53135,30 @@ function loadCloudTexture(url) {
 
 
 class Clouds {
-    constructor() {
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__enabled = false;
-        /**
-         *
-         * @type {Array}
-         * @private
-         */
-        this.materials = [];
-        this.time = 0;
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    __enabled = false;
+    /**
+     *
+     * @type {Array}
+     * @private
+     */
+    materials = [];
+    time = 0;
 
 
-        this.__speed0 = new Vector2();
-        this.__speed1 = new Vector2();
-        this.__speed2 = new Vector2();
+    __speed0 = new Vector2();
+    __speed1 = new Vector2();
+    __speed2 = new Vector2();
 
-        //how fast clouds reform
-        this.variability = 0.37;
+    //how fast clouds reform
+    variability = 0.37;
 
+    constructor() {
         this.setSpeed(0.5, -0.5);
-
     }
 
     /**
@@ -55268,7 +55008,7 @@ function rgb2uint24(r, g, b) {
 /**
  * Convert a decimal value to hex
  * @param {number} c generally expects b byte value, 0-255
- * @returns {string}
+ * @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);
@@ -61261,46 +61001,47 @@ function heightMap2NormalMap(renderer, sampler) {
     return new Sampler2D(rgb, 3, width, height);
 }
 
-function WebGLRendererPool() {
-    this.used = new Set();
-}
+class WebGLRendererPool {
 
-WebGLRendererPool.prototype.get = function (options) {
-    const canvas = document.createElement('canvas');
-    const context = canvas.getContext('webgl2', { antialias: true });
+    used = new Set();
 
-    const renderer = new WebGLRenderer({
-        alpha: true,
-        context,
-        canvas
-    });
+    get(options) {
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('webgl2', { antialias: true });
 
-    assert.equal(renderer.domElement, canvas, 'renderer.domElement !== canvas');
+        const renderer = new WebGLRenderer({
+            alpha: true,
+            context,
+            canvas
+        });
 
-    this.used.add(renderer);
-    return renderer;
-};
+        assert.equal(renderer.domElement, canvas, 'renderer.domElement !== canvas');
 
-/**
- *
- * @param {THREE.WebGLRenderer} renderer
- * @returns {boolean}
- */
-WebGLRendererPool.prototype.release = function (renderer) {
-    if (!this.used.has(renderer)) {
-        //not from this pool
-        return false;
+        this.used.add(renderer);
+        return renderer;
     }
-    this.used.delete(renderer);
 
-    renderer.forceContextLoss();
-    renderer.dispose();
-    renderer.domElement = null;
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @returns {boolean}
+     */
+    release(renderer) {
+        if (!this.used.has(renderer)) {
+            //not from this pool
+            return false;
+        }
+        this.used.delete(renderer);
 
-    return true;
-};
+        renderer.forceContextLoss();
+        renderer.dispose();
+        renderer.domElement = null;
 
-WebGLRendererPool.global = new WebGLRendererPool();
+        return true;
+    }
+
+    static global = new WebGLRendererPool();
+}
 
 /**
  *
@@ -62970,185 +62711,6 @@ Cache.prototype.delete = Cache.prototype.remove;
  */
 Cache.prototype.has = Cache.prototype.contains;
 
-/**
- * Compute byte size of a UTF8 string
- * @param {string} value
- * @returns {number}
- */
-function string_compute_byte_size(value) {
-    const length = value.length;
-
-    let p = 0;
-
-    for (let i = 0; i < length; i++) {
-        let c = value.charCodeAt(i);
-        while (c > 0xff) {
-            p++;
-            c >>= 8;
-        }
-        p++;
-    }
-
-    return p;
-}
-
-/**
- *
- * @type {Cache<String,Sampler2D>}
- */
-const cache$1 = new Cache({
-    maxWeight: 304857600,
-    keyHashFunction: computeStringHash,
-    keyWeigher: string_compute_byte_size,
-    /**
-     *
-     * @param {Sampler2D} sampler
-     * @returns {number}
-     */
-    valueWeigher(sampler) {
-        return sampler.computeByteSize();
-    }
-});
-
-class TerrainLayer {
-    constructor() {
-        /**
-         *
-         * @type {String}
-         */
-        this.textureDiffuseURL = "";
-
-        /**
-         *
-         * @type {Sampler2D}
-         */
-        this.diffuse = Sampler2D.uint8(3, 1, 1);
-
-        /**
-         *
-         * @type {Vector2}
-         */
-        this.size = new Vector2(1, 1);
-
-        /**
-         * Additional free-form JSON metadata
-         * @type {Object}
-         */
-        this.extra = {};
-
-        /**
-         *
-         * @type {Signal}
-         */
-        this.onChanged = new Signal();
-    }
-
-    toJSON() {
-        return {
-            textureDiffuseURL: this.textureDiffuseURL,
-            size: this.size.toJSON(),
-            extra: this.extra
-        };
-    }
-
-    fromJSON({ textureDiffuseURL, size, extra = {} }) {
-        this.textureDiffuseURL = textureDiffuseURL;
-        this.size.fromJSON(size);
-        this.extra = extra;
-    }
-
-    /**
-     *
-     * @param {string} url
-     * @param {number} width
-     * @param {number} height
-     */
-    static from(url, width, height) {
-        const r = new TerrainLayer();
-
-        r.textureDiffuseURL = url;
-        r.size.set(width, height);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {TerrainLayerDescription} d
-     * @returns {TerrainLayer}
-     */
-    static fromDescription(d) {
-        return TerrainLayer.from(
-            d.diffuse,
-            d.size.x,
-            d.size.y
-        );
-    }
-
-    /**
-     *
-     * @param {AssetManager} assetManager
-     * @returns {Promise}
-     */
-    loadTextureData(assetManager) {
-
-        const path = this.textureDiffuseURL;
-
-        /**
-         *
-         * @type {Sampler2D|null}
-         */
-        const cached = cache$1.get(path);
-
-        if (cached !== null) {
-
-            console.log('Using cached terrain layer data for ', path);
-
-            this.diffuse.resize(cached.width, cached.height, false);
-
-            this.diffuse.data.set(cached.data);
-
-            this.onChanged.send0();
-
-            return Promise.resolve();
-
-        }
-
-        const assetPromise = assetManager.promise(path, GameAssetType.Image);
-
-        return assetPromise
-            .then(assert => {
-                const image = assert.create();
-
-                const source_item_size = image.itemSize;
-
-                const source_data = image.data;
-
-                // RGB
-                const destination_item_size = 3;
-
-                if (this.diffuse === null || this.diffuse.width !== image.width || this.diffuse.height !== image.height) {
-                    // loaded image does not match the side of the layer
-                    this.diffuse = Sampler2D.uint8(destination_item_size, image.width, image.height);
-                }
-
-                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
-
-                copy_Sampler2D_channel_data(source, this.diffuse);
-
-                this.onChanged.send0();
-
-                // write to cache
-                const cacheCopy = Sampler2D.uint8(destination_item_size, image.width, image.height);
-
-                cacheCopy.data.set(this.diffuse.data);
-
-                cache$1.put(path, cacheCopy);
-
-            });
-    }
-}
-
 /**
  * @template T
  * @param {T[]} array
@@ -64176,6 +63738,191 @@ function conditionEqualsStrict(v) {
     return this === v;
 }
 
+/**
+ * Compute byte size of a UTF8 string
+ * @param {string} value
+ * @returns {number}
+ */
+function string_compute_byte_size(value) {
+    const length = value.length;
+
+    let p = 0;
+
+    for (let i = 0; i < length; i++) {
+        let c = value.charCodeAt(i);
+        while (c > 0xff) {
+            p++;
+            c >>= 8;
+        }
+        p++;
+    }
+
+    return p;
+}
+
+/**
+ *
+ * @type {Cache<String,Sampler2D>}
+ */
+const cache$1 = new Cache({
+    maxWeight: 304857600,
+    keyHashFunction: computeStringHash,
+    keyWeigher: string_compute_byte_size,
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {number}
+     */
+    valueWeigher(sampler) {
+        return sampler.computeByteSize();
+    }
+});
+
+class TerrainLayer {
+
+    /**
+     *
+     * @type {String}
+     */
+    textureDiffuseURL = "";
+
+    /**
+     *
+     * @type {Sampler2D}
+     */
+    diffuse = Sampler2D.uint8(3, 1, 1);
+
+    /**
+     *
+     * @type {Vector2}
+     */
+    size = new Vector2(1, 1);
+
+    /**
+     * Additional free-form JSON metadata
+     * @type {Object}
+     */
+    extra = {};
+
+    /**
+     *
+     * @type {Signal}
+     */
+    onChanged = new Signal();
+
+
+    toJSON() {
+        return {
+            textureDiffuseURL: this.textureDiffuseURL,
+            size: this.size.toJSON(),
+            extra: this.extra
+        };
+    }
+
+    fromJSON({ textureDiffuseURL, size, extra = {} }) {
+        this.textureDiffuseURL = textureDiffuseURL;
+        this.size.fromJSON(size);
+        this.extra = extra;
+    }
+
+    /**
+     *
+     * @param {string} url
+     * @param {number} width
+     * @param {number} height
+     */
+    static from(url, width, height) {
+        const r = new TerrainLayer();
+
+        r.textureDiffuseURL = url;
+        r.size.set(width, height);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {TerrainLayerDescription} d
+     * @returns {TerrainLayer}
+     */
+    static fromDescription(d) {
+        return TerrainLayer.from(
+            d.diffuse,
+            d.size.x,
+            d.size.y
+        );
+    }
+
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @returns {Promise}
+     */
+    loadTextureData(assetManager) {
+
+        const path = this.textureDiffuseURL;
+
+        /**
+         *
+         * @type {Sampler2D|null}
+         */
+        const cached = cache$1.get(path);
+
+        if (cached !== null) {
+
+            console.log('Using cached terrain layer data for ', path);
+
+            this.diffuse.resize(cached.width, cached.height, false);
+
+            this.diffuse.data.set(cached.data);
+
+            this.onChanged.send0();
+
+            return Promise.resolve();
+
+        }
+
+        const assetPromise = assetManager.promise(path, GameAssetType.Image);
+
+        return assetPromise
+            .then(assert => {
+                const image = assert.create();
+
+                const source_item_size = image.itemSize;
+
+                const source_data = image.data;
+
+                // RGB
+                const destination_item_size = 3;
+
+                if (this.diffuse === null || this.diffuse.width !== image.width || this.diffuse.height !== image.height) {
+                    // loaded image does not match the side of the layer
+                    this.diffuse = Sampler2D.uint8(destination_item_size, image.width, image.height);
+                }
+
+                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
+
+                copy_Sampler2D_channel_data(source, this.diffuse);
+
+                this.onChanged.send0();
+
+                // write to cache
+                const cacheCopy = Sampler2D.uint8(destination_item_size, image.width, image.height);
+
+                cacheCopy.data.set(this.diffuse.data);
+
+                cache$1.put(path, cacheCopy);
+
+            });
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TerrainLayer.prototype.isTerrainLayer = true;
+
 class ScaledTextureKey {
     uri = '';
 
@@ -64430,6 +64177,7 @@ class TerrainLayers {
      */
     addLayer(layer) {
         assert.defined(layer);
+        assert.equal(layer.isTerrainLayer, true, 'layer.isTerrainLayer !== true');
 
         const index = this.layers.length;
 
@@ -72139,6 +71887,25 @@ BitSet.fixedSize = function (x) {
  */
 
 class EntityObserver {
+    /**
+     *
+     * @type {BitSet}
+     */
+    componentMask = new BitSet();
+
+    /**
+     * Mapping from component index to position in array of observed component types,
+     * this is used to build arguments for callbacks
+     * @type {number[]}
+     */
+    componentIndexMapping = [];
+
+    /**
+     *
+     * @type {EntityComponentDataset|null}
+     */
+    dataset = null;
+
     /**
      *
      * @param {Array} componentTypes
@@ -72147,7 +71914,12 @@ class EntityObserver {
      * @param {*} [thisArg=undefined] will assume {@link this} value inside callbacks
      * @constructor
      */
-    constructor(componentTypes, completedCallback, brokenCallback, thisArg) {
+    constructor(
+        componentTypes,
+        completedCallback,
+        brokenCallback,
+        thisArg
+    ) {
         assert.isArray(componentTypes, 'componentTypes must be an array, instead was something else');
         assert.isFunction(completedCallback, 'completedCallback');
         assert.isFunction(brokenCallback, 'brokenCallback');
@@ -72186,26 +71958,6 @@ class EntityObserver {
          * @type {*}
          */
         this.thisArg = thisArg;
-
-
-        /**
-         *
-         * @type {BitSet}
-         */
-        this.componentMask = new BitSet();
-
-        /**
-         * Mapping from component index to position in array of observed component types,
-         * this is used to build arguments for callbacks
-         * @type {number[]}
-         */
-        this.componentIndexMapping = [];
-
-        /**
-         *
-         * @type {EntityComponentDataset|null}
-         */
-        this.dataset = null;
     }
 
     /**
@@ -73290,6 +73042,9 @@ class EntityManager {
     on = {
         systemStarted: new Signal(),
         systemStopped: new Signal(),
+        /**
+         * @type {Signal<System>}
+         */
         systemAdded: new Signal(),
         systemRemoved: new Signal(),
     };
@@ -74716,17 +74471,43 @@ ParentEntity.serializable = false;
 const DEFAULT_FLAGS$1 = EntityNodeFlags.LiveManagement;
 
 class EntityNode {
+    /**
+     *
+     * @type {EntityNode|null}
+     * @private
+     */
+    __parent = null;
+
+    /**
+     *
+     * @type {EntityNode[]}
+     * @private
+     */
+    __children = [];
+
+    /**
+     * Local transform
+     * @type {Transform}
+     * @private
+     */
+    __transform = new Transform();
+
+    on = {
+        built: new Signal(),
+        destroyed: new Signal()
+    };
+
+    /**
+     *
+     * @type {number}
+     */
+    flags = DEFAULT_FLAGS$1;
+
     /**
      *
      * @param {Entity} [entity] optional entity to be wrapped
      */
     constructor(entity = new Entity()) {
-        /**
-         *
-         * @type {EntityNode|null}
-         * @private
-         */
-        this.__parent = null;
 
         /**
          *
@@ -74735,30 +74516,6 @@ class EntityNode {
          */
         this.__entity = entity;
 
-        /**
-         *
-         * @type {EntityNode[]}
-         * @private
-         */
-        this.__children = [];
-
-        /**
-         * Local transform
-         * @type {Transform}
-         * @private
-         */
-        this.__transform = new Transform();
-
-        this.on = {
-            built: new Signal(),
-            destroyed: new Signal()
-        };
-
-        /**
-         *
-         * @type {number}
-         */
-        this.flags = DEFAULT_FLAGS$1;
     }
 
     /**
@@ -79429,7 +79186,6 @@ class EnginePlugin extends BaseProcess {
      */
     engine = null;
 
-
     attach() {
         /**
          * Must be unique for each plugin
@@ -82577,10 +82333,12 @@ const SerializationFlags = {
 };
 
 class SerializationMetadata {
-    constructor() {
-        this.flags = 0;
-    }
 
+    /**
+     *
+     * @type {number}
+     */
+    flags = 0;
 
     /**
      *
@@ -88674,20 +88432,19 @@ class Graph {
  * Contains serializers for various data types as well as data upgraders which enable support for serialization format changes
  */
 class BinarySerializationRegistry {
-    constructor() {
-        /**
-         * @readonly
-         * @private
-         * @type {Map<string, Graph<BinaryClassUpgrader>>}
-         */
-        this.upgraders = new Map();
-        /**
-         * @readonly
-         * @private
-         * @type {Map<string, BinaryClassSerializationAdapter>}
-         */
-        this.serializers = new Map();
-    }
+
+    /**
+     * @readonly
+     * @private
+     * @type {Map<string, Graph<BinaryClassUpgrader>>}
+     */
+    upgraders = new Map();
+    /**
+     * @readonly
+     * @private
+     * @type {Map<string, BinaryClassSerializationAdapter>}
+     */
+    serializers = new Map();
 
     /**
      *
@@ -89506,6 +89263,30 @@ class MaterialManager {
 }
 
 class FrameBuffer {
+    /**
+     * is expected to be bound during initialization
+     * @type {WebGLRenderTarget}
+     */
+    renderTarget = null;
+
+    /**
+     * Number of users of the frame buffer
+     * @type {number}
+     */
+    referenceCount = 0;
+
+    /**
+     * Dependency frame buffers
+     * @type {string[]}
+     */
+    dependencies = [];
+
+    /**
+     * Size of the frame buffer in pixels
+     * @type {Vector2}
+     */
+    size = new Vector2(0, 0);
+
     /**
      *
      * @param {string} id
@@ -89518,29 +89299,6 @@ class FrameBuffer {
          */
         this.id = id;
 
-        /**
-         * is expected to be bound during initialization
-         * @type {WebGLRenderTarget}
-         */
-        this.renderTarget = null;
-
-        /**
-         * Number of users of the frame buffer
-         * @type {number}
-         */
-        this.referenceCount = 0;
-
-        /**
-         * Dependency frame buffers
-         * @type {string[]}
-         */
-        this.dependencies = [];
-
-        /**
-         * Size of the frame buffer in pixels
-         * @type {Vector2}
-         */
-        this.size = new Vector2(0, 0);
 
     }
 
@@ -100097,6 +99855,12 @@ ObjectPoolFactory.prototype.release = function (object) {
  * @template Key, Value
  */
 class ImmutableObjectPool {
+    /**
+     *
+     * @type {Signal<Key,Value>}
+     */
+    onRemoved = new Signal()
+
     constructor({ capacity = 100, perKeyCapacity = 10 } = {}) {
         /**
          *
@@ -100181,15 +99945,17 @@ class ImmutableObjectPool {
 
         const elements = this.data.get(key);
 
-        if (elements.length === 1) {
-            this.data.delete(key);
-        } else {
-            const i = elements.indexOf(el);
+        const i = elements.indexOf(el);
 
-            elements.splice(i, 1);
+        elements.splice(i, 1);
+
+        if (elements.length === 0) {
+            this.data.delete(key);
         }
 
         this.size--;
+
+        this.onRemoved.send2(key, el.value);
     }
 
     add(key, value) {
@@ -109357,6 +109123,64 @@ class IdPool {
     }
 }
 
+/**
+ * @template T
+ * @param {T} object
+ * @return {T}
+ */
+function invokeObjectClone(object) {
+    return object.clone();
+}
+
+/**
+ * Copy a patch from another sampler with the same itemSize
+ * @param {Sampler2D} destination
+ * @param {Sampler2D} source where to copy from
+ * @param {Number} sourceX where to start reading from, X coordinate
+ * @param {Number} sourceY where to start reading from, X coordinate
+ * @param {Number} destinationX where to start writing to, X coordinate
+ * @param {Number} destinationY where to start writing to, X coordinate
+ * @param {Number} width size of the patch that is to be copied
+ * @param {Number} height size of the patch that is to be copied
+ */
+function sampler2d_sub_copy_same_item_size(destination, source, sourceX, sourceY, destinationX, destinationY, width, height) {
+    const itemSize = destination.itemSize;
+    const sItemSize = source.itemSize;
+
+    assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != destination.itemSize(=${itemSize})`);
+
+    const _w = Math.min(width, source.width - sourceX, destination.width - destinationX);
+    const _h = Math.min(height, source.height - sourceY, destination.height - destinationY);
+
+
+    const dRowSize = itemSize * destination.width;
+    const sRowSize = itemSize * source.width;
+
+    const sData = source.data;
+    const dData = destination.data;
+
+    const patchRowSize = _w * itemSize;
+
+    let y, i;
+
+    for (y = 0; y < _h; y++) {
+        const dA = (y + destinationY) * dRowSize;
+        const sA = (y + sourceY) * sRowSize;
+
+        const dOffset = dA + destinationX * itemSize;
+        const sOffset = sA + sourceX * itemSize;
+
+        for (i = 0; i < patchRowSize; i++) {
+
+            dData[dOffset + i] = sData[sOffset + i];
+
+        }
+    }
+
+    // update destination version
+    destination.version++;
+}
+
 class AtlasPatch {
     constructor() {
         /**
@@ -109525,15 +109349,6 @@ const AtlasPatchFlag = {
     Attached: 4
 };
 
-/**
- * @template T
- * @param {T} object
- * @return {T}
- */
-function invokeObjectClone(object) {
-    return object.clone();
-}
-
 class TextureAtlas extends AbstractTextureAtlas {
     /**
      *
@@ -109732,7 +109547,8 @@ class TextureAtlas extends AbstractTextureAtlas {
         const patch_position = patch.position;
         const patch_size = patch.size;
 
-        target.copy_sameItemSize(
+        sampler2d_sub_copy_same_item_size(
+            target,
             source,
             0, 0,
             patch_position.x, patch_position.y, patch_size.x, patch_size.y
@@ -113528,29 +113344,31 @@ var FrustumProjector = {
 };
 
 class SystemEntityContext {
-    constructor() {
 
-        this.entity = -1;
+    /**
+     *
+     * @type {number}
+     */
+    entity = -1;
 
-        /**
-         * Pointer back to the system
-         * @type {System}
-         */
-        this.system = null;
+    /**
+     * Pointer back to the system
+     * @type {System}
+     */
+    system = null;
 
-        /**
-         *
-         * @type {*[]}
-         */
-        this.components = [];
+    /**
+     *
+     * @type {*[]}
+     */
+    components = [];
 
-        /**
-         *
-         * @type {boolean}
-         * @protected
-         */
-        this.__is_linked = false;
-    }
+    /**
+     *
+     * @type {boolean}
+     * @protected
+     */
+    __is_linked = false;
 
     /**
      *