@woosh/meep-engine 2.108.2 → 2.108.3

package/build/meep.module.js

@@ -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;
@@ -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;
 }
@@ -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;
             }
         }
     }
@@ -57180,7 +57190,7 @@ function aabb3_array_intersects_ray(
     );
 }
 
-const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$8 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -57214,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;
 
@@ -57228,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);
 
@@ -57253,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;
             }
 
 
@@ -57270,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;
 }
@@ -65881,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;
@@ -65907,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);
 }
 
 /**
@@ -66043,7 +66072,7 @@ function aabb3_array_intersects_clipping_volume_array(
     );
 }
 
-const stack$6 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -66073,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;
 
@@ -66087,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);
 
@@ -66111,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;
             }
 
 
@@ -66128,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;
 }
@@ -67239,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;
 
 /**
  *
@@ -67262,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);
 
@@ -67286,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
@@ -67303,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);
 
@@ -67330,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);
@@ -67370,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;
         }
     }
 
@@ -67432,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;
@@ -67503,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;
 
@@ -67523,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) {
@@ -67557,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);
 }
 
 /**
@@ -74777,7 +75060,7 @@ class SGMeshSystem extends System {
     }
 }
 
-const stack$3 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$4 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -74801,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);
@@ -74832,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
@@ -75141,85 +75424,11 @@ class RuntimeDrawMethodOptimizer {
     }
 }
 
-const stack$2 = [];
+const stack$3 = [];
 
 /**
  * @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;
-        }
-    }
-}
-
-/**
- * @template T
- * @param {T[]} data
+ * @param {T[]|Uint32Array} data
  * @param {function(T,T):number} compare_function
  * @param {*} compare_function_context
  * @param {number} start
@@ -75238,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;
@@ -75281,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;
         }
     }
 }
@@ -76207,6 +76416,12 @@ function textureImagesEqual(a, b) {
 
     }
 
+    if (isTypedArray(a.data) && isTypedArray(b.data)) {
+        if (!textureMipmapEqual(a, b)) {
+            return false;
+        }
+    }
+
     // assume equivalent
     return true;
 }
@@ -88152,7 +88367,7 @@ class ColorAndDepthFrameBuffer extends FrameBuffer {
     }
 }
 
-const stack$1 = [];
+const stack$2 = [];
 
 class ThreeBypassRenderer {
     constructor() {
@@ -88229,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)
@@ -88274,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;
             }
         }
 
@@ -105798,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