@woosh/meep-engine 2.74.0 → 2.75.0

package/src/core/bvh2/bvh3/BVH.spec.js

@@ -1,3 +1,5 @@
+import { randomFloatBetween } from "../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../math/random/seededRandom.js";
 import { BVH, NULL_NODE } from "./BVH.js";
 
 test("constructor doesn't throw", () => {
@@ -302,3 +304,46 @@ test("move leaf node", () => {
 
     expect(actual_bounds).toEqual(a_new_bounds);
 });
+
+test.skip("performance, insert 10k random nodes", () => {
+
+    const random = seededRandom(1);
+
+    const bvh = new BVH();
+
+    const min_bound = -1000;
+    const max_bound = 1000;
+
+    const OBJECT_COUNT = 1000000;
+
+
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const node = bvh.allocate_node();
+
+        bvh.node_set_user_data(node, i);
+
+        const x = randomFloatBetween(random, min_bound, max_bound);
+        const y = randomFloatBetween(random, min_bound, max_bound);
+        const z = randomFloatBetween(random, min_bound, max_bound);
+
+        const extents = randomFloatBetween(random, 1, 10);
+
+        const x0 = x - extents;
+        const y0 = y - extents;
+        const z0 = z - extents;
+
+        const x1 = x + extents;
+        const y1 = y + extents;
+        const z1 = z + extents;
+
+        // console.log([x0, y0, z0, x1, y1, z1].join(', '))
+
+        bvh.node_set_aabb_primitive(
+            node,
+            x0, y0, z0,
+            x1, y1, z1
+        );
+
+        bvh.insert_leaf(node);
+    }
+});

package/src/core/bvh2/bvh3/build_triangle_morton_codes.js

@@ -0,0 +1,73 @@
+import morton from "../../geom/3d/morton/Morton.js";
+
+/**
+ * Compute morton codes for each triangle
+ * @param {number[]|Uint32Array} morton_codes
+ * @param {number} tri_count
+ * @param {number[]|Uint8Array|Uint16Array|Uint32Array} index_array
+ * @param {number[]|Float32Array} position_array
+ * @param {number} aabb_x0
+ * @param {number} aabb_y0
+ * @param {number} aabb_z0
+ * @param {number} aabb_x1
+ * @param {number} aabb_y1
+ * @param {number} aabb_z1
+ */
+export function build_triangle_morton_codes(
+    morton_codes,
+    tri_count,
+    index_array,
+    position_array,
+    aabb_x0, aabb_y0, aabb_z0,
+    aabb_x1, aabb_y1, aabb_z1
+) {
+
+    const aabb_size_x = aabb_x1 - aabb_x0;
+    const aabb_size_y = aabb_y1 - aabb_y0;
+    const aabb_size_z = aabb_z1 - aabb_z0;
+
+    const morton_scale_x = aabb_size_x === 0 ? 0 : 1023 / aabb_size_x;
+    const morton_scale_y = aabb_size_y === 0 ? 0 : 1023 / aabb_size_y;
+    const morton_scale_z = aabb_size_z === 0 ? 0 : 1023 / aabb_size_z;
+
+    // compute morton codes
+    for (let i = 0; i < tri_count; i++) {
+
+
+        const i3 = i * 3;
+
+        const a = index_array[i3];
+        const b = index_array[i3 + 1];
+        const c = index_array[i3 + 2];
+
+        const a_address = a * 3;
+        const ax = position_array[a_address];
+        const ay = position_array[a_address + 1];
+        const az = position_array[a_address + 2];
+
+        const b_address = b * 3;
+        const bx = position_array[b_address];
+        const by = position_array[b_address + 1];
+        const bz = position_array[b_address + 2];
+
+        const c_address = c * 3;
+        const cx = position_array[c_address];
+        const cy = position_array[c_address + 1];
+        const cz = position_array[c_address + 2];
+
+        const center_x = (ax + bx + cx) * 0.333333333;
+        const center_y = (ay + by + cy) * 0.333333333;
+        const center_z = (az + bz + cz) * 0.333333333;
+
+        // normalize to bounds
+        const ncx = (center_x - aabb_x0) * morton_scale_x;
+        const ncy = (center_y - aabb_y0) * morton_scale_y;
+        const ncz = (center_z - aabb_z0) * morton_scale_z;
+
+        morton_codes[i] = morton(
+            Math.round(ncx),
+            Math.round(ncy),
+            Math.round(ncz)
+        );
+    }
+}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -2,9 +2,10 @@ import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_
 import { arrayQuickSort } from "../../collection/array/arrayQuickSort.js";
 import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
-import morton from "../../geom/3d/morton/Morton.js";
 import { max2 } from "../../math/max2.js";
+import { build_triangle_morton_codes } from "./build_triangle_morton_codes.js";
 import { NULL_NODE } from "./BVH.js";
+import { ebvh_build_hierarchy } from "./ebvh_build_hierarchy.js";
 
 /**
  * Build the BVH bottom-up using spatial hash sorting
@@ -22,18 +23,6 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
     // get bounds for the entire geometry
     aabb3_from_v3_array(aabb3, position_array, position_array.length);
 
-    const aabb_x0 = aabb3.x0;
-    const aabb_y0 = aabb3.y0;
-    const aabb_z0 = aabb3.z0;
-
-    const aabb_size_x = aabb3.getExtentsX();
-    const aabb_size_y = aabb3.getExtentsY();
-    const aabb_size_z = aabb3.getExtentsZ();
-
-    const morton_scale_x = aabb_size_x === 0 ? 0 : 1023 / aabb_size_x;
-    const morton_scale_y = aabb_size_y === 0 ? 0 : 1023 / aabb_size_y;
-    const morton_scale_z = aabb_size_z === 0 ? 0 : 1023 / aabb_size_z;
-
     // allocate nodes
     const tri_count = index_array.length / 3;
     const node_leaf_count = tri_count;
@@ -52,59 +41,15 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         nodes[i] = (node_total_count - 1) - i;
     }
 
-    // for (let i = node_total_count - 1; i >= 0; i--) {
-    //     // store nodes in reverse order so that top-level nodes end up on top
-    //     nodes[i] = bvh.allocate_node();
-    // }
-
     const morton_codes = new Uint32Array(tri_count);
     const sorted_triangle_order = new Uint32Array(tri_count);
 
-    // compute morton codes
     for (let i = 0; i < tri_count; i++) {
-
         sorted_triangle_order[i] = i;
-
-        const i3 = i * 3;
-
-        const a = index_array[i3];
-        const b = index_array[i3 + 1];
-        const c = index_array[i3 + 2];
-
-        const a_address = a * 3;
-        const ax = position_array[a_address];
-        const ay = position_array[a_address + 1];
-        const az = position_array[a_address + 2];
-
-        const b_address = b * 3;
-        const bx = position_array[b_address];
-        const by = position_array[b_address + 1];
-        const bz = position_array[b_address + 2];
-
-        const c_address = c * 3;
-        const cx = position_array[c_address];
-        const cy = position_array[c_address + 1];
-        const cz = position_array[c_address + 2];
-
-        const center_x = (ax + bx + cx) * 0.333333333;
-        const center_y = (ay + by + cy) * 0.333333333;
-        const center_z = (az + bz + cz) * 0.333333333;
-
-
-        // normalize to bounds
-        const ncx = (center_x - aabb_x0) * morton_scale_x;
-        const ncy = (center_y - aabb_y0) * morton_scale_y;
-        const ncz = (center_z - aabb_z0) * morton_scale_z;
-
-        const morton_code = morton(
-            Math.round(ncx),
-            Math.round(ncy),
-            Math.round(ncz)
-        );
-
-        morton_codes[i] = morton_code;
     }
 
+    build_triangle_morton_codes(morton_codes, tri_count, index_array, position_array, aabb3.x0, aabb3.y0, aabb3.z0, aabb3.x1, aabb3.y1, aabb3.z1);
+
     // sort leaves by morton codes
     arrayQuickSort(sorted_triangle_order, (triangle_index) => morton_codes[triangle_index], null, 0, tri_count - 1);
 
@@ -129,47 +74,6 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         unprocessed_nodes[i] = node;
     }
 
-    // Assemble hierarchy
-    let unprocessed_node_count = tri_count;
-
-
-    while (used_index < node_total_count && unprocessed_node_count > 1) {
-
-        let added_nodes = 0;
-        let cursor = 0;
-
-        while (cursor + 1 < unprocessed_node_count) {
-            const child_1 = unprocessed_nodes[cursor++];
-            const child_2 = unprocessed_nodes[cursor++];
-
-            const parent = nodes[used_index++];
-
-            bvh.node_set_combined_aabb(parent, child_1, child_2);
-
-            bvh.node_set_parent(child_1, parent);
-            bvh.node_set_parent(child_2, parent);
-
-            bvh.node_set_child1(parent, child_1);
-            bvh.node_set_child2(parent, child_2);
-
-            bvh.node_set_height(parent,
-                1 + max2(
-                    bvh.node_get_height(child_1),
-                    bvh.node_get_height(child_2)
-                )
-            );
-
-            unprocessed_nodes[added_nodes++] = parent;
-        }
-
-        while (cursor < unprocessed_node_count) {
-            // dangling nodes, push them onto the next level
-            unprocessed_nodes[added_nodes++] = unprocessed_nodes[cursor++];
-        }
-
-        unprocessed_node_count = added_nodes;
-    }
-
     // assign root
-    bvh.__root = nodes[nodes.length - 1];
+    bvh.__root = ebvh_build_hierarchy(bvh,unprocessed_nodes,tri_count,nodes,used_index);
 }

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.js

@@ -0,0 +1,59 @@
+import { max2 } from "../../math/max2.js";
+
+/**
+ * Assumes nodes are spatially sorted
+ * NOTE: {@link unprocessed_nodes} will be modified during execution to save memory
+ * @param {BVH} bvh
+ * @param {number[]|Uint32Array} unprocessed_nodes contains nodes that need to be built into a hierarchy, these must not be present in the BVH hierarchy
+ * @param {number} input_node_count
+ * @param {number[]|Uint32Array} node_pool Contains node indices that can be used to build ancestry hierarchy, need to be pre-allocated before calling this method
+ * @param {number} node_pool_offset
+ * @returns {number} new root
+ */
+export function ebvh_build_hierarchy(bvh, unprocessed_nodes, input_node_count, node_pool, node_pool_offset) {
+
+    let used_index = node_pool_offset;
+
+    // Assemble hierarchy
+    let unprocessed_node_count = input_node_count;
+
+
+    while (unprocessed_node_count > 1) {
+
+        let added_nodes = 0;
+        let cursor = 0;
+
+        while (cursor + 1 < unprocessed_node_count) {
+            const child_1 = unprocessed_nodes[cursor++];
+            const child_2 = unprocessed_nodes[cursor++];
+
+            const parent = node_pool[used_index++];
+
+            bvh.node_set_combined_aabb(parent, child_1, child_2);
+
+            bvh.node_set_parent(child_1, parent);
+            bvh.node_set_parent(child_2, parent);
+
+            bvh.node_set_child1(parent, child_1);
+            bvh.node_set_child2(parent, child_2);
+
+            bvh.node_set_height(parent,
+                1 + max2(
+                    bvh.node_get_height(child_1),
+                    bvh.node_get_height(child_2)
+                )
+            );
+
+            unprocessed_nodes[added_nodes++] = parent;
+        }
+
+        while (cursor < unprocessed_node_count) {
+            // dangling nodes, push them onto the next level
+            unprocessed_nodes[added_nodes++] = unprocessed_nodes[cursor++];
+        }
+
+        unprocessed_node_count = added_nodes;
+    }
+
+    return unprocessed_nodes[0];
+}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point.js

@@ -1,13 +1,6 @@
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_signed_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
-import { max2 } from "../../../math/max2.js";
-import { NULL_NODE } from "../BVH.js";
-
-/**
- *
- * @type {number[]}
- */
-const scratch_aabb = [];
+import { aabb3_unsigned_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
@@ -21,7 +14,7 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @returns {number} user data of the leaf, or -1 if not found
  */
 export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance = Infinity) {
-      const root = bvh.root;
+    const root = bvh.root;
 
     if (root === NULL_NODE) {
         return -1;
@@ -35,10 +28,17 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
 
     stack[stack_top] = root;
 
-    let best_leaf_data = -1;
+    let best_leaf = -1;
     let best_distance_sqr = max_distance * max_distance;
 
-    while (stack.pointer > stack_top) {
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
         stack.pointer--;
 
         /**
@@ -47,42 +47,41 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
          */
         const node = stack[stack.pointer];
 
-        bvh.node_get_aabb(node, scratch_aabb);
+        const address = node * ELEMENT_WORD_COUNT;
 
         // compute distance to box
-        const distance_sqr = max2(0, aabb3_signed_distance_sqr_to_point(
-            scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
-            scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
+        const distance_sqr = aabb3_unsigned_distance_sqr_to_point(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
             x, y, z
-        ));
+        );
 
-        if (distance_sqr > best_distance_sqr) {
+        if (distance_sqr >= best_distance_sqr) {
             // node is too far
             continue;
         }
 
-        const node_is_leaf = bvh.node_is_leaf(node);
-
-        if (!node_is_leaf) {
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
 
-            // read in-order
-            const child1 = bvh.node_get_child1(node);
-            const child2 = bvh.node_get_child2(node);
+        if (child_1 !== NULL_NODE) {
 
-            // write to stack in reverse order, so that fist child ends up being visited first
-            stack[stack.pointer++] = child1;
-            stack[stack.pointer++] = child2;
+            // this is not a leaf node, push children onto traversal stack
+            stack[stack.pointer++] = child_1;
+            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
 
         } else {
 
             // leaf node
-            if (distance_sqr < best_distance_sqr) {
-                best_distance_sqr = distance_sqr;
-                best_leaf_data = bvh.node_get_user_data(node);
-            }
+            best_distance_sqr = distance_sqr;
+            best_leaf = node;
 
         }
+    } while (stack.pointer > stack_top)
+
+    if (best_leaf === -1) {
+        return -1;
     }
 
-    return best_leaf_data;
+    return bvh.node_get_user_data(best_leaf);
 }

package/src/core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point.spec.js

@@ -1,3 +1,5 @@
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
 import { BVH } from "../BVH.js";
 import { bvh_query_user_data_nearest_to_point } from "./bvh_query_user_data_nearest_to_point.js";
 
@@ -68,3 +70,65 @@ test('two point, distance sufficient to both', () => {
 
     expect(result).toBe(0);
 });
+
+
+test.skip("performance, 1M random boxes, 10k queries", () => {
+
+    const random = seededRandom(1);
+
+    const bvh = new BVH();
+
+    const min_bound = -1000;
+    const max_bound = 1000;
+
+    const OBJECT_COUNT = 1000000;
+
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const node = bvh.allocate_node();
+
+        bvh.node_set_user_data(node, i);
+
+        const x = randomFloatBetween(random, min_bound, max_bound);
+        const y = randomFloatBetween(random, min_bound, max_bound);
+        const z = randomFloatBetween(random, min_bound, max_bound);
+
+        const extents = randomFloatBetween(random, 1, 50);
+
+        const x0 = x - extents;
+        const y0 = y - extents;
+        const z0 = z - extents;
+
+        const x1 = x + extents;
+        const y1 = y + extents;
+        const z1 = z + extents;
+
+        bvh.node_set_aabb_primitive(
+            node,
+            x0, y0, z0,
+            x1, y1, z1
+        );
+
+        bvh.insert_leaf(node);
+    }
+
+    const SAMPLE_POINT_COUNT = 10000;
+
+    const t0 = performance.now();
+
+    for (let i = 0; i < SAMPLE_POINT_COUNT; i++) {
+
+        const x = randomFloatBetween(random, min_bound, max_bound);
+        const y = randomFloatBetween(random, min_bound, max_bound);
+        const z = randomFloatBetween(random, min_bound, max_bound);
+
+        bvh_query_user_data_nearest_to_point(
+            bvh, x, y, z
+        );
+    }
+
+    const t1 = performance.now();
+
+    const duration = (t1 - t0);
+
+    console.log(`${duration / SAMPLE_POINT_COUNT}ms/query`);
+});

package/src/core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js

@@ -8,6 +8,7 @@ export const SCRATCH_UINT32_TRAVERSAL_STACK = new Uint32Array(781250);
 
 /**
  * Pointer used to track current top of the stack, make sure to unwind once your traversal is done
+ * Must be a positive integer
  * @type {number}
  */
 SCRATCH_UINT32_TRAVERSAL_STACK.pointer = 0;

package/src/core/geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js

@@ -45,3 +45,4 @@ export function aabb3_signed_distance_sqr_to_point(
         return -(dx * dx + dy * dy + dz * dz);
     }
 }
+

package/src/core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js

@@ -0,0 +1,36 @@
+import { max3 } from "../../../math/max3.js";
+
+/**
+ * Compute squared distance to point, value is negative if the point is inside the box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} point_x
+ * @param {number} point_y
+ * @param {number} point_z
+ * @returns {number}
+ */
+export function aabb3_unsigned_distance_sqr_to_point(
+    x0, y0, z0,
+    x1, y1, z1,
+    point_x, point_y, point_z
+) {
+    //do projection
+    const xp0 = x0 - point_x;
+    const xp1 = point_x - x1;
+    const yp0 = y0 - point_y;
+    const yp1 = point_y - y1;
+    const zp0 = z0 - point_z;
+    const zp1 = point_z - z1;
+
+    //calculate separation in each axis
+    const dx = max3(0, xp0, xp1);
+    const dy = max3(0, yp0, yp1);
+    const dz = max3(0, zp0, zp1);
+
+    //straight-line distance
+    return dx * dx + dy * dy + dz * dz;
+}

package/src/core/process/worker/OnDemandWorkerManager.js

@@ -1,4 +1,4 @@
-import {assert} from "../../assert.js";
+import { assert } from "../../assert.js";
 
 export class OnDemandWorkerManager {
 
@@ -35,6 +35,10 @@ export class OnDemandWorkerManager {
         this.worker = worker;
     }
 
+    /**
+     * In milliseconds
+     * @param {number} v
+     */
     setTimeout(v) {
         assert.isNonNegativeInteger(v, 'v');
 

package/src/engine/asset/loaders/ArrayBufferLoader.js

@@ -1,8 +1,8 @@
+import { noop } from "../../../core/function/Functions.js";
 import { Asset } from "../Asset.js";
-import { AssetLoader } from "./AssetLoader.js";
-import { CrossOriginKind } from "../CORS/CrossOriginKind.js";
 import { CrossOriginConfig } from "../CORS/CrossOriginConfig.js";
-import { noop } from "../../../core/function/Functions.js";
+import { CrossOriginKind } from "../CORS/CrossOriginKind.js";
+import { AssetLoader } from "./AssetLoader.js";
 
 export class ArrayBufferLoader extends AssetLoader {
     /**
@@ -90,33 +90,31 @@ export class ArrayBufferLoader extends AssetLoader {
             const reader = response.body.getReader();
             const contentLength = response.headers.get('Content-Length');
             const total = contentLength ? parseInt(contentLength) : 0;
-            const lengthComputable = total !== 0;
             let loaded = 0;
 
             // periodically read data into the new stream tracking while download progress
             const stream = new ReadableStream({
+                type: "bytes",
                 start(controller) {
 
-                    readData();
+                    pump();
 
-                    function readData() {
+                    function pump() {
 
                         reader.read().then(({ done, value }) => {
 
                             if (done) {
-
+                                // no more data, we're done
                                 controller.close();
+                                return;
+                            }
 
-                            } else {
-
-                                loaded += value.byteLength;
-
-                                progress(loaded, length);
+                            loaded += value.byteLength;
 
-                                controller.enqueue(value);
-                                readData();
+                            progress(loaded, total);
 
-                            }
+                            controller.enqueue(value);
+                            pump();
 
                         });
 

package/src/engine/asset/loaders/image/ImageDecoderWorker.js

@@ -23,7 +23,7 @@ async function decode_png(png_bytes) {
             width,
             height,
             itemSize: uint_channels.itemSize,
-            bitDepth: png.bitDepth
+            bitDepth: 8
         });
     });
 }

package/src/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -1,12 +1,11 @@
-import { AssetLoader } from "../AssetLoader.js";
-import { GameAssetType } from "../../GameAssetType.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 import { convertTexture2Sampler2D } from "../../../graphics/texture/sampler/convertTexture2Sampler2D.js";
-import { ImageRGBADataAsset } from "./ImageRGBADataAsset.js";
+import { GameAssetType } from "../../GameAssetType.js";
 import { ArrayBufferLoader } from "../ArrayBufferLoader.js";
+import { AssetLoader } from "../AssetLoader.js";
 import { CodecWithFallback } from "./codec/CodecWithFallback.js";
 import { ThreadedImageDecoder } from "./codec/ThreadedImageDecoder.js";
-import { NativeImageDecoder } from "./codec/NativeImageDecoder.js";
-import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
+import { ImageRGBADataAsset } from "./ImageRGBADataAsset.js";
 
 const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
@@ -16,7 +15,7 @@ export class ImageRGBADataLoader extends AssetLoader {
 
         this.decoder = new CodecWithFallback(
             new ThreadedImageDecoder(),
-            new NativeImageDecoder()
+            // new NativeImageDecoder()
         );
     }
 
@@ -58,7 +57,6 @@ export class ImageRGBADataLoader extends AssetLoader {
 
         const bitmap = await this.__decode_via_worker(path, scope);
 
-
         let data;
 
         const bitDepth = bitmap.bitDepth;

package/src/engine/asset/loaders/image/codec/ThreadedImageDecoder.js

@@ -21,7 +21,7 @@ export class ThreadedImageDecoder extends Codec {
          */
         this.worker = new OnDemandWorkerManager(workerBuilder.build());
 
-        this.worker.setTimeout(200);
+        this.worker.setTimeout(1200);
     }
 
     async test(data) {