@woosh/meep-engine 2.108.0 → 2.108.3

package/build/meep.module.js

@@ -2868,10 +2868,10 @@ let Vector3$1 = class Vector3 {
     }
 
     /**
-     *
+     * Convert spherical coordinates to cartesian
      * @param {number} radius
-     * @param {number} phi
-     * @param {number} theta
+     * @param {number} phi Also known as Azimuth
+     * @param {number} theta Also known as Elevation
      */
     setFromSphericalCoords(radius, phi, theta) {
 
@@ -49538,7 +49538,7 @@ class Sampler2D {
      *
      * @param {number} u
      * @param {number} v
-     * @param {number[]} result
+     * @param {number[]|Float32Array} result
      * @param {number} result_offset
      */
     sampleBilinearUV(u, v, result, result_offset = 0) {
@@ -49606,8 +49606,8 @@ class Sampler2D {
         const clamped_x = clamp$1(x, 0, x_max);
         const clamped_y = clamp$1(y, 0, y_max);
 
-        const x0 = clamped_x | 0;
-        const y0 = clamped_y | 0;
+        const x0 = clamped_x >>> 0;
+        const y0 = clamped_y >>> 0;
 
         //
         const row0 = y0 * rowSize;
@@ -49668,7 +49668,7 @@ class Sampler2D {
      *
      * @param {number} u
      * @param {number} v
-     * @param {ArrayLike<number>} result
+     * @param {number[]|ArrayLike<number>} result
      */
     sampleNearestUV(u, v, result) {
         const w = this.width;
@@ -50288,7 +50288,7 @@ const WHITE_PIXEL_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEA
  * @param {number} v
  * @returns {number}
  */
-function float2uint8(v) {
+function float_to_uint8(v) {
     return Math.round(v * 255);
 }
 
@@ -50297,7 +50297,7 @@ function float2uint8(v) {
  * @param {number} v
  * @returns {number}
  */
-function uint82float(v) {
+function uint8_to_float(v) {
     return v / 255;
 }
 
@@ -51696,7 +51696,7 @@ class TerrainOverlay {
         for (let i = 0; i < 4; i++) {
             const v = this.sampler.readChannel(x, y, i);
 
-            result[i] = uint82float(v);
+            result[i] = uint8_to_float(v);
         }
     }
 
@@ -51743,7 +51743,7 @@ class TerrainOverlay {
     paintPoint(x, y, vec4) {
         for (let i = 0; i < 4; i++) {
 
-            this.sampler.writeChannel(x, y, i, float2uint8(vec4[i]));
+            this.sampler.writeChannel(x, y, i, float_to_uint8(vec4[i]));
 
         }
 
@@ -53220,7 +53220,7 @@ function aabb3_intersects_ray(
     const diff_x = origin_x - center_x;
 
 
-    if (diff_x * direction_x >= 0.0 && abs(diff_x) > extents_x) {
+    if (diff_x * direction_x >= 0 && abs(diff_x) > extents_x) {
         return false;
     }
 
@@ -53232,7 +53232,7 @@ function aabb3_intersects_ray(
     const diff_y = origin_y - center_y;
 
 
-    if (diff_y * direction_y >= 0.0 && abs(diff_y) > extents_y) {
+    if (diff_y * direction_y >= 0 && abs(diff_y) > extents_y) {
         return false;
     }
 
@@ -53244,7 +53244,7 @@ function aabb3_intersects_ray(
     const diff_z = origin_z - center_z;
 
 
-    if (diff_z * direction_z >= 0.0 && abs(diff_z) > extents_z) {
+    if (diff_z * direction_z >= 0 && abs(diff_z) > extents_z) {
         return false;
     }
 
@@ -53270,7 +53270,7 @@ function aabb3_intersects_ray(
     return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
 }
 
-const stack$9 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$a = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 
 /**
@@ -53303,9 +53303,9 @@ function bvh_query_leaves_ray(
      *
      * @type {number}
      */
-    const stack_top = stack$9.pointer++;
+    const stack_top = stack$a.pointer++;
 
-    stack$9[stack_top] = root;
+    stack$a[stack_top] = root;
 
     let result_cursor = result_offset;
 
@@ -53316,13 +53316,13 @@ function bvh_query_leaves_ray(
     const uint32 = bvh.__data_uint32;
 
     do {
-        stack$9.pointer--;
+        stack$a.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$9[stack$9.pointer];
+        const node = stack$a[stack$a.pointer];
 
         const address = node * ELEMENT_WORD_COUNT;
 
@@ -53344,15 +53344,15 @@ function bvh_query_leaves_ray(
         if (child_1 !== NULL_NODE) {
 
             // this is not a leaf node, push children onto traversal stack
-            stack$9[stack$9.pointer++] = uint32[address + COLUMN_CHILD_2];
-            stack$9[stack$9.pointer++] = child_1;
+            stack$a[stack$a.pointer++] = uint32[address + COLUMN_CHILD_2];
+            stack$a[stack$a.pointer++] = child_1;
 
         } else {
             // leaf node
 
             result[result_cursor++] = node;
         }
-    } while (stack$9.pointer > stack_top);
+    } while (stack$a.pointer > stack_top);
 
     return result_cursor - result_offset;
 }
@@ -53524,9 +53524,9 @@ function hsv2rgb(h, s, v) {
             break;
     }
     return {
-        r: float2uint8(r),
-        g: float2uint8(g),
-        b: float2uint8(b)
+        r: float_to_uint8(r),
+        g: float_to_uint8(g),
+        b: float_to_uint8(b)
     };
 }
 
@@ -53617,9 +53617,9 @@ function parse_color(c) {
  * @returns {number}
  */
 function rgb2uint24(r, g, b) {
-    const _r = float2uint8(r);
-    const _g = float2uint8(g);
-    const _b = float2uint8(b);
+    const _r = float_to_uint8(r);
+    const _g = float_to_uint8(g);
+    const _b = float_to_uint8(b);
 
     return (_b & 0xFF)
         | (_g & 0xFF) << 8
@@ -53638,7 +53638,7 @@ function rgb_to_luminance(r, g, b) {
     return 0.299 * r + 0.587 * g + 0.114 * b;
 }
 
-function convert(c) {
+function convert_channel_linear_to_sRGB(c) {
     if (c < 0.0031308) {
         return c * 12.92;
     } else {
@@ -53661,9 +53661,9 @@ function linear_to_sRGB(
     const g = input[input_offset + 1];
     const b = input[input_offset + 2];
 
-    output[output_offset] = convert(r);
-    output[output_offset + 1] = convert(g);
-    output[output_offset + 2] = convert(b);
+    output[output_offset] = convert_channel_linear_to_sRGB(r);
+    output[output_offset + 1] = convert_channel_linear_to_sRGB(g);
+    output[output_offset + 2] = convert_channel_linear_to_sRGB(b);
 }
 
 /**
@@ -53837,9 +53837,9 @@ class Color {
      */
     setRGBUint8(r, g, b) {
         this.setRGB(
-            uint82float(r),
-            uint82float(g),
-            uint82float(b),
+            uint8_to_float(r),
+            uint8_to_float(g),
+            uint8_to_float(b),
         );
     }
 
@@ -54132,9 +54132,9 @@ class Color {
      */
     toHex() {
         return '#' + rgb2hex(
-            float2uint8(this.r),
-            float2uint8(this.g),
-            float2uint8(this.b)
+            float_to_uint8(this.r),
+            float_to_uint8(this.g),
+            float_to_uint8(this.b)
         );
     }
 
@@ -54143,7 +54143,7 @@ class Color {
      * @returns {string}
      */
     toCssRGBAString() {
-        return `rgba(${float2uint8(this.r)},${float2uint8(this.g)},${float2uint8(this.b)},${this.a})`;
+        return `rgba(${float_to_uint8(this.r)},${float_to_uint8(this.g)},${float_to_uint8(this.b)},${this.a})`;
     }
 
     /**
@@ -55232,7 +55232,7 @@ function build_morton(data, address, bounds) {
 
 }
 
-const stack$8 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$9 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 class BinaryUint32BVH {
     /**
@@ -55374,6 +55374,18 @@ class BinaryUint32BVH {
 
     }
 
+    /**
+     *
+     * @param {number} index
+     * @return {number}
+     */
+    getLeafAddress(index) {
+
+        const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+
+        return index * BVH_LEAF_NODE_SIZE + leaf_block_address;
+    }
+
     /**
      *
      * @param {number} index
@@ -55391,9 +55403,7 @@ class BinaryUint32BVH {
         x1, y1, z1
     ) {
 
-        const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
-
-        const address = index * BVH_LEAF_NODE_SIZE + leaf_block_address;
+        const address = this.getLeafAddress(index);
 
         aabb3_array_set(
             this.__data_float32,
@@ -55533,16 +55543,16 @@ class BinaryUint32BVH {
         let stackPointer = 2;
         let i, j;
 
-        stack$8[0] = 0; // first node
-        stack$8[1] = this.__node_count_leaf - 1; // last node
+        stack$9[0] = 0; // first node
+        stack$9[1] = this.__node_count_leaf - 1; // last node
 
         const data = this.__data_float32;
 
         while (stackPointer > 0) {
             stackPointer -= 2;
 
-            const right = stack$8[stackPointer + 1];
-            const left = stack$8[stackPointer];
+            const right = stack$9[stackPointer + 1];
+            const left = stack$9[stackPointer];
 
             i = left;
             j = right;
@@ -55577,12 +55587,12 @@ class BinaryUint32BVH {
 
             /* recursion */
             if (left < j) {
-                stack$8[stackPointer++] = left;
-                stack$8[stackPointer++] = j;
+                stack$9[stackPointer++] = left;
+                stack$9[stackPointer++] = j;
             }
             if (i < right) {
-                stack$8[stackPointer++] = i;
-                stack$8[stackPointer++] = right;
+                stack$9[stackPointer++] = i;
+                stack$9[stackPointer++] = right;
             }
         }
     }
@@ -56759,11 +56769,13 @@ class AABB3 {
      * Get center position of the box
      * @param {Vector3} target where to write result
      */
-    getCenter(target) {
+    getCenter(target = new Vector3$1()) {
         const x = this.getCenterX();
         const y = this.getCenterY();
         const z = this.getCenterZ();
         target.set(x, y, z);
+
+        return target;
     }
 
 
@@ -57178,7 +57190,7 @@ function aabb3_array_intersects_ray(
     );
 }
 
-const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$8 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -57212,13 +57224,13 @@ function bvh32_query_user_data_ray(
      *
      * @type {number}
      */
-    const stack_top = stack$7.pointer++;
+    const stack_top = stack$8.pointer++;
 
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
-    stack$7[stack_top] = 0;
+    stack$8[stack_top] = 0;
 
     const last_valid_index = binary_node_count + bvh.leaf_node_count;
 
@@ -57226,10 +57238,10 @@ function bvh32_query_user_data_ray(
     const uint32 = bvh.uint32;
 
     do {
-        stack$7.pointer--;
+        stack$8.pointer--;
 
         // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack$7[stack$7.pointer];
+        const node_index = stack$8[stack$8.pointer];
 
         const node_address = bvh.getNodeAddress(node_index);
 
@@ -57251,11 +57263,11 @@ function bvh32_query_user_data_ray(
 
             // left node ends up on top of the stack, which aligns with the desired access sequence
             if (right_index < last_valid_index) {
-                stack$7[stack$7.pointer++] = right_index;
+                stack$8[stack$8.pointer++] = right_index;
                 // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
-                stack$7[stack$7.pointer++] = left_index;
+                stack$8[stack$8.pointer++] = left_index;
             } else if (left_index < last_valid_index) {
-                stack$7[stack$7.pointer++] = left_index;
+                stack$8[stack$8.pointer++] = left_index;
             }
 
 
@@ -57268,7 +57280,7 @@ function bvh32_query_user_data_ray(
             hit_count++;
         }
 
-    } while (stack$7.pointer > stack_top)
+    } while (stack$8.pointer > stack_top)
 
     return hit_count;
 }
@@ -63068,72 +63080,137 @@ const ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
  * @param {string} path
  * @return {string}
  */
-function convertPathToURL(path) {
-
-    if (!isGlobalPath(path)) {
+function localPathToGlobal(path) {
+    /**
+     * @type {Window|DedicatedWorkerGlobalScope}
+     */
+    let scope;
 
-        /**
-         * @type {Window|DedicatedWorkerGlobalScope}
-         */
-        let scope;
+    if (ENVIRONMENT_IS_WEB) {
+        scope = window;
+    } else if (ENVIRONMENT_IS_WORKER) {
+        scope = self;
+    } else if (ENVIRONMENT_IS_NODE) {
 
-        if (ENVIRONMENT_IS_WEB) {
-            scope = window;
-        } else if (ENVIRONMENT_IS_WORKER) {
-            scope = self;
-        } else if (ENVIRONMENT_IS_NODE) {
+        let normalized_path = `${process.cwd()}/`.replace(/\\/g, '/');
 
-            let normalized_path = `${process.cwd()}/`.replace(/\\/g, '/');
+        // remove multiple sequential slashes
+        normalized_path = normalized_path.replace(/\/+/g, '/');
 
-            // remove multiple sequential slashes
-            normalized_path = normalized_path.replace(/\/+/g, '/');
+        if (normalized_path[0] !== '/') {
+            // Windows drive letter must be prefixed with a slash.
+            normalized_path = `/${normalized_path}`;
+        }
 
-            if (normalized_path[0] !== '/') {
-                // Windows drive letter must be prefixed with a slash.
-                normalized_path = `/${normalized_path}`;
+        scope = {
+            location: {
+                pathname: normalized_path,
+                host: '',
+                protocol: 'file:'
             }
+        };
+    } else {
+        throw new Error('Unknown environment');
+    }
 
-            scope = {
-                location: {
-                    pathname: normalized_path,
-                    host: '',
-                    protocol: 'file:'
-                }
-            };
+    const location = scope.location;
+    const pathname = location.pathname;
+
+    let directoryPath;
+
+    /*
+    path name contains file name also, there are two options here, "a/b" or "a/b/" second is a directory
+    we need to extract directory to load relative path
+    */
+
+    if (pathname.endsWith('/')) {
+        //path is to a directory, strip last slash
+        directoryPath = pathname.substring(0, pathname.length - 1);
+    } else {
+        //path is to a file
+        const i = pathname.lastIndexOf('/');
+
+        if (i === -1) {
+            //root level file
+            directoryPath = "";
         } else {
-            throw new Error('Unknown environment');
+            directoryPath = pathname.substring(0, i);
         }
+    }
 
-        const location = scope.location;
-        const pathname = location.pathname;
+    const urlBase = location.protocol + "//" + location.host + directoryPath + "/";
+    return urlBase + path;
+}
 
-        let directoryPath;
+/**
+ * Given a path, which may be a local path, produce a fully qualified URL
+ * @example '/path' -> 'http://example.com/path'
+ * @example 'some/local/path' -> 'http://example.com/current_path/some/local/path'
+ * @param {string} path
+ * @return {string}
+ */
+function convertPathToURL(path) {
 
-        /*
-        path name contains file name also, there are two options here, "a/b" or "a/b/" second is a directory
-        we need to extract directory to load relative path
-        */
+    const is_global = isGlobalPath(path);
 
-        if (pathname.endsWith('/')) {
-            //path is to a directory, strip last slash
-            directoryPath = pathname.substring(0, pathname.length - 1);
-        } else {
-            //path is to a file
-            const i = pathname.lastIndexOf('/');
+    let result = path;
 
-            if (i === -1) {
-                //root level file
-                directoryPath = "";
-            } else {
-                directoryPath = pathname.substring(0, i);
-            }
+    if (!is_global) {
+        result = localPathToGlobal(path);
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {string} code
+ * @param {string} [mime_type]
+ * @return {Blob}
+ */
+function codeToBlob(code, mime_type = 'application/javascript') {
+
+    let blob;
+
+    if (typeof globalThis.Blob !== "undefined") {
+        blob = new Blob([code], { type: mime_type });
+    } else {
+        // Backwards-compatibility
+        const BlobBuilder = globalThis.BlobBuilder
+            || globalThis.BlobBuilder
+            || globalThis.WebKitBlobBuilder
+            || globalThis.MozBlobBuilder;
+
+        if (BlobBuilder !== undefined) {
+            blob = new BlobBuilder();
+            blob.append(code);
+            blob = blob.getBlob();
+        } else {
+            throw new Error(`No BlobBuilder interface supported in current context`);
         }
 
-        const urlBase = location.protocol + "//" + location.host + directoryPath + "/";
-        path = urlBase + path;
     }
 
-    return path;
+
+    return blob;
+}
+
+/**
+ *
+ * @param {string} code
+ * @param {string} [mime_type]
+ * @return {string}
+ */
+function codeToURL(code, mime_type = 'application/javascript') {
+
+    const blob = codeToBlob(code, mime_type);
+
+    if (blob !== undefined && URL.createObjectURL !== undefined) {
+        return URL.createObjectURL(blob);
+    } else {
+        // build data URL in a slowest way possible
+        return `data:${mime_type},${encodeURIComponent(code)}`;
+    }
 }
 
 class Line {
@@ -63589,6 +63666,7 @@ class WorkerProxy {
 
 const RxMatchFunctionName = /(function\s*)([a-zA-Z0-9_]+)?(\s*\([^\]]*\)\s*\{.*)/g;
 
+
 class WorkerBuilder {
 
     imports = [];
@@ -63631,9 +63709,9 @@ class WorkerBuilder {
      * @param {string} path
      */
     importScript(path) {
-        path = convertPathToURL(path);
+        const qualified_path = convertPathToURL(path);
 
-        this.imports.push(path);
+        this.imports.push(qualified_path);
     }
 
     /**
@@ -63643,7 +63721,7 @@ class WorkerBuilder {
     build() {
         const codeLines = [];
 
-        codeLines.push('var globalScope = this;');
+        codeLines.push('var globalScope = globalThis;');
 
         //handle imports
         this.imports.forEach(function (url) {
@@ -63744,37 +63822,6 @@ class WorkerBuilder {
 
         return new WorkerProxy(workerURL, this.methods);
     }
-}
-/**
- *
- * @param {string} code
- * @return {string}
- */
-function codeToURL(code) {
-    const js_mime = 'application/javascript';
-
-    let blob;
-
-    if (typeof window === 'object') {
-        if (typeof window.Blob !== "undefined") {
-            blob = new Blob([code], {type: js_mime});
-        } else {
-            // Backwards-compatibility
-            const BlobBuilder = window.BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder;
-            if (BlobBuilder !== undefined) {
-                blob = new BlobBuilder();
-                blob.append(code);
-                blob = blob.getBlob();
-            }
-        }
-    }
-
-    if (blob !== undefined && URL.createObjectURL !== undefined) {
-        return URL.createObjectURL(blob);
-    } else {
-        // build data URL in a slowest way possible
-        return `data:${js_mime},${encodeURIComponent(code)}`;
-    }
 }
 
 /**
@@ -65844,14 +65891,17 @@ function read_three_planes_to_array(planes, array) {
 
 /**
  *
- * @param {BinaryUint32BVH} bvh
- * @param {number} triangle_index
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
  * @param {number[]|Float32Array} vertices
  * @param {number} a_index
  * @param {number} b_index
  * @param {number} c_index
  */
-function bvh32_set_leaf_from_triangle(bvh, triangle_index, vertices, a_index, b_index, c_index) {
+function aabb3_compute_from_triangle(
+    output, output_offset,
+    vertices, a_index, b_index, c_index
+) {
     const a = a_index * 3;
     const b = b_index * 3;
     const c = c_index * 3;
@@ -65870,15 +65920,31 @@ function bvh32_set_leaf_from_triangle(bvh, triangle_index, vertices, a_index, b_
     const cZ = vertices[c + 2];
 
     // compute bounds of the triangle
-    const x0 = min3(aX, bX, cX);
-    const y0 = min3(aY, bY, cY);
-    const z0 = min3(aZ, bZ, cZ);
+    output[output_offset] = min3(aX, bX, cX);
+    output[output_offset + 1] = min3(aY, bY, cY);
+    output[output_offset + 2] = min3(aZ, bZ, cZ);
 
-    const x1 = max3(aX, bX, cX);
-    const y1 = max3(aY, bY, cY);
-    const z1 = max3(aZ, bZ, cZ);
+    output[output_offset + 3] = max3(aX, bX, cX);
+    output[output_offset + 4] = max3(aY, bY, cY);
+    output[output_offset + 5] = max3(aZ, bZ, cZ);
+
+}
+
+/**
+ *
+ * @param {BinaryUint32BVH} bvh
+ * @param {number} triangle_index
+ * @param {number[]|Float32Array} vertices
+ * @param {number} a_index
+ * @param {number} b_index
+ * @param {number} c_index
+ */
+function bvh32_set_leaf_from_triangle(bvh, triangle_index, vertices, a_index, b_index, c_index) {
+
+    const address = bvh.getLeafAddress(triangle_index);
+    aabb3_compute_from_triangle(bvh.__data_float32, address, vertices, a_index, b_index, c_index);
+    bvh.__data_uint32[address + 6] = triangle_index;
 
-    bvh.setLeafData(triangle_index, triangle_index, x0, y0, z0, x1, y1, z1);
 }
 
 /**
@@ -66006,7 +66072,7 @@ function aabb3_array_intersects_clipping_volume_array(
     );
 }
 
-const stack$6 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -66036,13 +66102,13 @@ function bvh32_query_user_data_overlaps_clipping_volume(
      *
      * @type {number}
      */
-    const stack_top = stack$6.pointer++;
+    const stack_top = stack$7.pointer++;
 
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
-    stack$6[stack_top] = 0;
+    stack$7[stack_top] = 0;
 
     const last_valid_index = binary_node_count + bvh.leaf_node_count;
 
@@ -66050,10 +66116,10 @@ function bvh32_query_user_data_overlaps_clipping_volume(
     const uint32 = bvh.uint32;
 
     do {
-        stack$6.pointer--;
+        stack$7.pointer--;
 
         // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack$6[stack$6.pointer];
+        const node_index = stack$7[stack$7.pointer];
 
         const node_address = bvh.getNodeAddress(node_index);
 
@@ -66074,11 +66140,11 @@ function bvh32_query_user_data_overlaps_clipping_volume(
 
             // left node ends up on top of the stack, which aligns with the desired access sequence
             if (right_index < last_valid_index) {
-                stack$6[stack$6.pointer++] = right_index;
+                stack$7[stack$7.pointer++] = right_index;
                 // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
-                stack$6[stack$6.pointer++] = left_index;
+                stack$7[stack$7.pointer++] = left_index;
             } else if (left_index < last_valid_index) {
-                stack$6[stack$6.pointer++] = left_index;
+                stack$7[stack$7.pointer++] = left_index;
             }
 
 
@@ -66091,7 +66157,7 @@ function bvh32_query_user_data_overlaps_clipping_volume(
             hit_count++;
         }
 
-    } while (stack$6.pointer > stack_top)
+    } while (stack$7.pointer > stack_top)
 
     return hit_count;
 }
@@ -67202,7 +67268,7 @@ function aabb3_array_intersects_frustum_degree(aabb, frustum) {
 //
 
 
-const stack$5 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$6 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -67225,20 +67291,20 @@ function bvh_collect_user_data(
      *
      * @type {number}
      */
-    const stack_top = stack$5.pointer++;
+    const stack_top = stack$6.pointer++;
 
-    stack$5[stack_top] = root;
+    stack$6[stack_top] = root;
 
     let result_cursor = destination_offset;
 
-    while (stack$5.pointer > stack_top) {
-        stack$5.pointer--;
+    while (stack$6.pointer > stack_top) {
+        stack$6.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$5[stack$5.pointer];
+        const node = stack$6[stack$6.pointer];
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
@@ -67249,8 +67315,8 @@ function bvh_collect_user_data(
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            stack$5[stack$5.pointer++] = child1;
-            stack$5[stack$5.pointer++] = child2;
+            stack$6[stack$6.pointer++] = child1;
+            stack$6[stack$6.pointer++] = child2;
 
         } else {
             // leaf root
@@ -67266,7 +67332,7 @@ function bvh_collect_user_data(
 
 //
 
-const stack$4 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$5 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 const scratch_aabb$1 = new Float32Array(6);
 
@@ -67293,20 +67359,20 @@ function bvh_query_user_data_overlaps_frustum(
      *
      * @type {number}
      */
-    const stack_top = stack$4.pointer++;
+    const stack_top = stack$5.pointer++;
 
-    stack$4[stack_top] = root;
+    stack$5[stack_top] = root;
 
     let result_cursor = result_offset;
 
-    while (stack$4.pointer > stack_top) {
-        stack$4.pointer--;
+    while (stack$5.pointer > stack_top) {
+        stack$5.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$4[stack$4.pointer];
+        const node = stack$5[stack$5.pointer];
 
         // test node against the ray
         bvh.node_get_aabb(node, scratch_aabb$1);
@@ -67333,8 +67399,8 @@ function bvh_query_user_data_overlaps_frustum(
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            stack$4[stack$4.pointer++] = child1;
-            stack$4[stack$4.pointer++] = child2;
+            stack$5[stack$5.pointer++] = child1;
+            stack$5[stack$5.pointer++] = child2;
         }
     }
 
@@ -67395,7 +67461,7 @@ function computeFileExtension(path) {
  * @param {number} height
  * @param {number} channel_count
  */
-function flipArrayInPlace(input, width, height, channel_count = 4) {
+function sampler2d_flipY_in_place(input, width, height, channel_count = 4) {
     const row_size = width * channel_count;
     let t, x0, x1;
     let i = 0;
@@ -67466,6 +67532,235 @@ const CopyShader = {
 
 };
 
+/**
+ *
+ * @param {number} format
+ * @returns {number}
+ */
+function formatToChannelCount(format) {
+    switch (format) {
+        case RedFormat:
+        case RedIntegerFormat:
+            return 1;
+        case RGFormat:
+            return 2;
+        case RGBFormat:
+            return 3;
+        case RGBAFormat:
+            return 4;
+        default:
+            throw new Error(`Unsupported format '${format}'`);
+    }
+}
+
+/**
+ *
+ * @param {Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array} array
+ * @return {boolean}
+ */
+function typed_array_is_integer(array) {
+    const ctor = array.constructor;
+
+    return ctor === Uint8ClampedArray
+        || ctor === Uint8Array
+        || ctor === Uint16Array
+        || ctor === Uint32Array
+        || ctor === Int8Array
+        || ctor === Int16Array
+        || ctor === Int32Array
+        ;
+}
+
+/**
+ * Applies a linear polynomial transform to each value of a given channel
+ * @param {Sampler2D} output
+ * @param {Sampler2D} input
+ * @param {number} output_channel_index
+ * @param {number} input_channel_index
+ * @param {number} gradient
+ * @param {number} intercept
+ */
+function sampler2d_channel_linear_transform(
+    output, input,
+    output_channel_index, input_channel_index,
+    gradient, intercept
+) {
+
+    const input_width = input.width;
+    const input_height = input.height;
+
+    const output_width = output.width;
+    const output_height = output.height;
+
+    if (
+        input_width !== output_width
+        || input_height !== output_height
+    ) {
+        throw new Error('Dimensions of input and output are incompatible');
+    }
+
+    const input_item_size = input.itemSize;
+    const output_item_size = output.itemSize;
+
+    const input_data = input.data;
+    const output_data = output.data;
+
+    const pixel_count = input_width * input_height;
+
+
+    if (typed_array_is_integer(output_data)) {
+
+        for (let i = 0; i < pixel_count; i++) {
+
+            const input_address = i * input_item_size + input_channel_index;
+            const output_address = i * output_item_size + output_channel_index;
+
+            const input_value = input_data[input_address];
+
+            output_data[output_address] = Math.round(input_value * gradient + intercept);
+
+        }
+
+    } else {
+
+        for (let i = 0; i < pixel_count; i++) {
+
+            const input_address = i * input_item_size + input_channel_index;
+            const output_address = i * output_item_size + output_channel_index;
+
+            const input_value = input_data[input_address];
+
+            output_data[output_address] = input_value * gradient + intercept;
+
+        }
+
+    }
+
+}
+
+function compute_gradient_and_intercept_uint8(ctor) {
+    let gradient = 1;
+    let intercept = 0;
+
+    switch (ctor) {
+        case Uint16Array:
+            gradient = 0.0038910505836575876;
+            break;
+        case Uint32Array:
+            gradient = 5.937181414556033e-8;
+            break;
+        case Int8Array:
+            gradient = 1;
+            intercept = 127;
+            break
+        case Int16Array:
+            gradient = 0.0038910505836575876;
+            intercept = 127;
+            break;
+        case Int32Array:
+            gradient = 5.937181414556033e-8;
+            intercept = 127;
+            break
+        case Float32Array:
+        case Float64Array:
+            gradient = 255;
+            break;
+        // do nothing;
+    }
+
+    return {
+        gradient, intercept
+    }
+}
+
+/**
+ * Many applications work with 8bit RGBA images, this utility function converts a given input to that format
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
+ */
+function sampler2d_to_uint8_RGBA(output, input) {
+    if (
+        input.width !== output.width
+        || input.height !== output.height
+    ) {
+        throw new Error('Dimensions of source and destination are incompatible');
+    }
+
+    if (output.itemSize !== 4) {
+        throw new Error(`Destination must have 4 channels exactly, instead got '${output.itemSize}'`);
+    }
+
+    const { gradient, intercept } = compute_gradient_and_intercept_uint8(input.data.constructor);
+
+    const source_item_size = input.itemSize;
+
+    if (intercept === 0 && gradient === 1 && source_item_size === 4) {
+        // already in the right format, use shortcut
+        output.data.set(input.data);
+        return;
+    }
+
+    if (source_item_size === 1) {
+
+        // grayscale
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 0, gradient, intercept);
+
+        output.channelFill(3, 255);
+
+    } else if (source_item_size === 2) {
+
+        // grayscale with alpha
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 3, 1, gradient, intercept);
+
+    } else if (source_item_size === 3) {
+
+        // RGB
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 1, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 2, gradient, intercept);
+
+        output.channelFill(3, 255);
+
+    } else if (source_item_size === 4) {
+
+        // RGBA
+
+        sampler2d_channel_linear_transform(output, input, 0, 0, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 1, 1, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 2, 2, gradient, intercept);
+        sampler2d_channel_linear_transform(output, input, 3, 3, gradient, intercept);
+
+    }
+}
+
+/**
+ *
+ * @param {Sampler2D} input
+ * @returns {Sampler2D}
+ */
+function sampler2d_ensure_uint8_RGBA(input) {
+    if (
+        input.itemSize === 4
+        && (input.data.constructor === Uint8Array || input.data.constructor === Uint8ClampedArray)
+    ) {
+        return input;
+    }
+
+    const resampled = Sampler2D.uint8(4, input.width, input.height);
+
+    sampler2d_to_uint8_RGBA(resampled, input);
+
+    return resampled;
+}
+
 const DEFAULT_TEXTURE_WIDTH = 512;
 const DEFAULT_TEXTURE_HEIGHT = 512;
 
@@ -67486,6 +67781,8 @@ function convertTexture2Sampler2D(
     let _height = height;
     let _width = width;
 
+    const channel_count = formatToChannelCount(texture.format);
+
     // TODO take channel count into account
 
     if (_width === undefined || _height === undefined) {
@@ -67520,34 +67817,57 @@ function convertTexture2Sampler2D(
 
     }
 
-    // TODO add special case for DataTexture
 
-    const built = WebGLRendererPool.global.use(renderer => {
+    let data;
 
-        const ctx = renderer.getContext();
+    if (texture.isDataTexture === true) {
 
-        //support for compressed textures
-        ctx.getExtension("WEBGL_compressed_texture_s3tc");
+        // special case
+
+        const source = new Sampler2D(texture.image.data, channel_count, texture.image.width, texture.image.height);
+
+        let converted = sampler2d_ensure_uint8_RGBA(source);
+
+        if (converted.width !== _width || converted.height !== _height) {
+            const target = Sampler2D.uint8(4, _width, _height);
+
+            sampler2d_scale(converted, target);
+
+            converted = target;
+        }
+
+        data = converted.data;
+
+    } else {
+        const built = WebGLRendererPool.global.use(renderer => {
+
+            const ctx = renderer.getContext();
+
+            //support for compressed textures
+            ctx.getExtension("WEBGL_compressed_texture_s3tc");
+
+            return processTexture(renderer, _width, _height, {
+                vertexShader: CopyShader.vertexShader,
+                fragmentShader: CopyShader.fragmentShader,
+                uniforms: {
+                    tDiffuse: {
+                        value: texture,
+                        type: 't'
+                    },
+                    opacity: { value: 1.0 }
+                }
+            });
 
-        return processTexture(renderer, _width, _height, {
-            vertexShader: CopyShader.vertexShader,
-            fragmentShader: CopyShader.fragmentShader,
-            uniforms: {
-                tDiffuse: {
-                    value: texture,
-                    type: 't'
-                },
-                opacity: { value: 1.0 }
-            }
         });
 
-    });
+        data = built.array;
+    }
 
     if (flipY) {
-        flipArrayInPlace(built.array, _width, _height);
+        sampler2d_flipY_in_place(data, _width, _height);
     }
 
-    return new Sampler2D(built.array, 4, _width, _height);
+    return new Sampler2D(data, 4, _width, _height);
 }
 
 /**
@@ -67689,20 +68009,19 @@ class AssetLoader {
 function observeResponseProgress(input, progress) {
     let response = input;
 
-
-    if (typeof ReadableStream === 'undefined' || response.body.getReader === undefined) {
+    // Workaround: Checking if response.body === undefined for Alipay browser
+    if (typeof ReadableStream === 'undefined' || response.body === undefined || response.body.getReader === undefined) {
 
         return response;
 
     }
 
-    /**
-     * @type {ReadableStreamDefaultReader<Uint8Array>}
-     */
-    const reader = response.body.getReader();
+    // Nginx needs X-File-Size check
+    // https://serverfault.com/questions/482875/why-does-nginx-remove-content-length-header-for-chunked-content
+    const contentLength = response.headers.get('Content-Length') || response.headers.get('X-File-Size');
 
-    const contentLength = response.headers.get('Content-Length');
     const total = contentLength ? parseInt(contentLength) : 0;
+
     let loaded = 0;
 
     // periodically read data into the new stream tracking while download progress
@@ -67710,6 +68029,11 @@ function observeResponseProgress(input, progress) {
         type: "bytes",
         start(controller) {
 
+            /**
+             * @type {ReadableStreamDefaultReader<Uint8Array>}
+             */
+            const reader = response.body.getReader();
+
             pump();
 
             function pump() {
@@ -67727,6 +68051,7 @@ function observeResponseProgress(input, progress) {
                     progress(loaded, total);
 
                     controller.enqueue(value);
+
                     pump();
 
                 });
@@ -67798,16 +68123,13 @@ class ArrayBufferLoader extends AssetLoader {
 
         let response = await fetch(request);
 
-        if (!(response.status === 200 || response.status === 0)) {
+        const response_status = response.status;
 
-            throw Error(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`);
+        if (response_status !== 200 && response_status !== 0) {
 
-        }
-
-        // Some browsers return HTTP Status 0 when using non-http protocol
-        // e.g. 'file://' or 'data://'. Handle as success.
+            throw Error(`fetch for "${response.url}" responded with ${response_status}: ${response.statusText}`);
 
-        if (response.status === 0) ;
+        }
 
         try {
             response = observeResponseProgress(response, progress);
@@ -74738,7 +75060,7 @@ class SGMeshSystem extends System {
     }
 }
 
-const stack$3 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$4 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -74762,20 +75084,20 @@ function bvh_query_leaves_generic(
      *
      * @type {number}
      */
-    const stack_top = stack$3.pointer++;
+    const stack_top = stack$4.pointer++;
 
-    stack$3[stack_top] = root;
+    stack$4[stack_top] = root;
 
     let result_cursor = result_offset;
 
-    while (stack$3.pointer > stack_top) {
-        stack$3.pointer--;
+    while (stack$4.pointer > stack_top) {
+        stack$4.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$3[stack$3.pointer];
+        const node = stack$4[stack$4.pointer];
 
         // test node against the ray
         const pass = query.evaluate(node, bvh);
@@ -74793,8 +75115,8 @@ function bvh_query_leaves_generic(
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            stack$3[stack$3.pointer++] = child2;
-            stack$3[stack$3.pointer++] = child1;
+            stack$4[stack$4.pointer++] = child2;
+            stack$4[stack$4.pointer++] = child1;
 
         } else {
             // leaf node
@@ -75102,85 +75424,11 @@ class RuntimeDrawMethodOptimizer {
     }
 }
 
-const stack$2 = [];
-
-/**
- * @template T
- * @param {T[]|ArrayLike<number>|Uint32Array} data
- * @param {function(T):number} score_function
- * @param {*} score_function_context
- * @param {number} start
- * @param {number} end
- * @param {function(T[],number, number):*} [swap_operator]
- * @param {*} [swap_context]
- */
-function arrayQuickSort(
-    data,
-    score_function, score_function_context,
-    start, end,
-    swap_operator = array_swap_one, swap_context = undefined
-) {
-    if (start >= end) {
-        // section of 0 size, nothing to sort
-        return;
-    }
-
-    let stackPointer = 2;
-    let i, j;
-
-    stack$2[0] = start;
-    stack$2[1] = end;
-
-    while (stackPointer > 0) {
-        stackPointer -= 2;
-
-        const right = stack$2[stackPointer + 1];
-        const left = stack$2[stackPointer];
-
-        i = left;
-        j = right;
-
-        const pivotIndex = (left + right) >> 1;
-
-        const pivot = score_function.call(score_function_context, data[pivotIndex]);
-
-        /* partition */
-        while (i <= j) {
-            while (score_function.call(score_function_context, data[i]) < pivot) {
-                i++;
-            }
-
-            while (score_function.call(score_function_context, data[j]) > pivot) {
-                j--;
-            }
-
-            if (i <= j) {
-
-                if (i !== j) {
-                    //do swap
-                    swap_operator.call(swap_context, data, i, j);
-                }
-
-                i++;
-                j--;
-            }
-        }
-
-        /* recursion */
-        if (left < j) {
-            stack$2[stackPointer++] = left;
-            stack$2[stackPointer++] = j;
-        }
-        if (i < right) {
-            stack$2[stackPointer++] = i;
-            stack$2[stackPointer++] = right;
-        }
-    }
-}
+const stack$3 = [];
 
 /**
  * @template T
- * @param {T[]} data
+ * @param {T[]|Uint32Array} data
  * @param {function(T,T):number} compare_function
  * @param {*} compare_function_context
  * @param {number} start
@@ -75199,14 +75447,14 @@ function array_quick_sort_by_comparator(
     let stackPointer = 2;
     let i, j;
 
-    stack$2[0] = start;
-    stack$2[1] = end;
+    stack$3[0] = start;
+    stack$3[1] = end;
 
     while (stackPointer > 0) {
         stackPointer -= 2;
 
-        const right = stack$2[stackPointer + 1];
-        const left = stack$2[stackPointer];
+        const right = stack$3[stackPointer + 1];
+        const left = stack$3[stackPointer];
 
         i = left;
         j = right;
@@ -75242,12 +75490,12 @@ function array_quick_sort_by_comparator(
 
         /* recursion */
         if (left < j) {
-            stack$2[stackPointer++] = left;
-            stack$2[stackPointer++] = j;
+            stack$3[stackPointer++] = left;
+            stack$3[stackPointer++] = j;
         }
         if (i < right) {
-            stack$2[stackPointer++] = i;
-            stack$2[stackPointer++] = right;
+            stack$3[stackPointer++] = i;
+            stack$3[stackPointer++] = right;
         }
     }
 }
@@ -75590,6 +75838,9 @@ const TextureAttachmentsByMaterialType = {
         taDisplacement,
         taAlphaMap
     ],
+    MeshBasicMaterial: [
+        taDiffuse
+    ],
     MeshStandardMaterial: [
         taDiffuse,
         taAlphaMap,
@@ -76165,6 +76416,12 @@ function textureImagesEqual(a, b) {
 
     }
 
+    if (isTypedArray(a.data) && isTypedArray(b.data)) {
+        if (!textureMipmapEqual(a, b)) {
+            return false;
+        }
+    }
+
     // assume equivalent
     return true;
 }
@@ -88110,7 +88367,7 @@ class ColorAndDepthFrameBuffer extends FrameBuffer {
     }
 }
 
-const stack$1 = [];
+const stack$2 = [];
 
 class ThreeBypassRenderer {
     constructor() {
@@ -88187,13 +88444,13 @@ class ThreeBypassRenderer {
             const object3D = input[i];
 
             if (input_filter(object3D)) {
-                stack$1[stack_top++] = object3D;
+                stack$2[stack_top++] = object3D;
             }
 
         }
 
         while (stack_top > 0) {
-            const object3D = stack$1[--stack_top];
+            const object3D = stack$2[--stack_top];
 
             if (
                 object_filter(object3D)
@@ -88232,7 +88489,7 @@ class ThreeBypassRenderer {
             for (i = 0; i < child_count; i++) {
                 const child = children[i];
 
-                stack$1[stack_top++] = child;
+                stack$2[stack_top++] = child;
             }
         }
 
@@ -105066,6 +105323,9 @@ class TopDownCameraController {
 
         this.distance = eye.distanceTo(target);
 
+        // ensure we can maintain this distance
+        this.distanceMax = max2(this.distance, this.distanceMax);
+
         this.target.copy(target);
     }
 
@@ -105753,6 +106013,82 @@ function computeBinaryDataTypeByPrecision(type, precision) {
     throw new Error(`Unsupported numeric type(=${type}) and precision(=${precision}) combination`);
 }
 
+const stack$1 = [];
+
+/**
+ * @template T
+ * @param {T[]|ArrayLike<number>|Uint32Array} data
+ * @param {function(T):number} score_function
+ * @param {*} score_function_context
+ * @param {number} start
+ * @param {number} end
+ * @param {function(T[],number, number):*} [swap_operator]
+ * @param {*} [swap_context]
+ */
+function arrayQuickSort(
+    data,
+    score_function, score_function_context,
+    start, end,
+    swap_operator = array_swap_one, swap_context = undefined
+) {
+    if (start >= end) {
+        // section of 0 size, nothing to sort
+        return;
+    }
+
+    let stackPointer = 2;
+    let i, j;
+
+    stack$1[0] = start;
+    stack$1[1] = end;
+
+    while (stackPointer > 0) {
+        stackPointer -= 2;
+
+        const right = stack$1[stackPointer + 1];
+        const left = stack$1[stackPointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        const pivot = score_function.call(score_function_context, data[pivotIndex]);
+
+        /* partition */
+        while (i <= j) {
+            while (score_function.call(score_function_context, data[i]) < pivot) {
+                i++;
+            }
+
+            while (score_function.call(score_function_context, data[j]) > pivot) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    swap_operator.call(swap_context, data, i, j);
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack$1[stackPointer++] = left;
+            stack$1[stackPointer++] = j;
+        }
+        if (i < right) {
+            stack$1[stackPointer++] = i;
+            stack$1[stackPointer++] = right;
+        }
+    }
+}
+
 /**
  *
  * @param {number[]|Float32Array|Float64Array} source
@@ -115602,6 +115938,12 @@ function setLocale(engine) {
     return engine.localization.loadLocale(locale);
 }
 
+/**
+ * Equal to ~ 5500 K light color
+ * @type {Readonly<Color>}
+ */
+const DEFAULT_SUNLIGHT_COLOR = Object.freeze(new Color(1, 0.93, 0.87));
+
 class EngineHarness {
     constructor() {
         /**
@@ -115879,7 +116221,7 @@ class EngineHarness {
                                  ecd = engine.entityManager.dataset,
                                  shadowmapResolution = 1024,
                                  castShadow = true,
-                                 sun = Color.white,
+                                 sun = DEFAULT_SUNLIGHT_COLOR,
                                  sunIntensity = 0.9,
                                  sunDirection = new Vector3$1(0.1, -1, 0.1),
                                  ambient = Color.white,