@woosh/meep-engine 2.74.0 → 2.75.1

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

@@ -1,3 +1,6 @@
+import { aabb3_unsigned_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+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 +71,139 @@ 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`);
+});
+
+test.skip('naive search, 1m random boxes, 10k queries', () => {
+
+    const random = seededRandom(1);
+
+    const OBJECT_COUNT = 1000000;
+
+    const boxes = new Float32Array(OBJECT_COUNT * 6);
+
+    const min_bound = -1000;
+    const max_bound = 1000;
+
+    const extents = 25;
+
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const address = i * 6;
+
+        const x = randomFloatBetween(random, min_bound, max_bound);
+        const y = randomFloatBetween(random, min_bound, max_bound);
+        const z = randomFloatBetween(random, min_bound, max_bound);
+
+        boxes[address] = x - extents;
+        boxes[address + 1] = y - extents;
+        boxes[address + 2] = z - extents;
+
+        boxes[address + 3] = x + extents;
+        boxes[address + 4] = y + extents;
+        boxes[address + 5] = z + extents;
+
+    }
+
+    function naive_query(boxes, count, x, y, z) {
+        let best_distance_sqr = Infinity;
+        let best_index = 0;
+
+        const limit = count * 6;
+
+        for (let i = 0; i < limit; i += 6) {
+            const distance_sqr = aabb3_unsigned_distance_sqr_to_point(
+                boxes[i], boxes[i + 1], boxes[i + 2],
+                boxes[i + 3], boxes[i + 4], boxes[i + 5],
+
+                x, y, z
+            )
+
+            if (distance_sqr < best_distance_sqr) {
+                best_index = i;
+                best_distance_sqr = distance_sqr;
+            }
+        }
+
+        return best_index;
+    }
+
+    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);
+
+        naive_query(boxes, OBJECT_COUNT, 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/events/signal/SignalBinding.js

@@ -1,28 +1,35 @@
 /**
- * @author Alex Goldring
- * @copyright Alex Goldring 2018
+ * Utility class for managing connection between listeners to signals
  */
+export class SignalBinding {
+    /**
+     * State flag
+     * @type {boolean}
+     */
+    #linked = false;
 
+    get linked() {
+        return this.#linked;
+    }
 
-export class SignalBinding {
     /**
      *
      * @param {Signal} signal
      * @param {function} handler
-     * @param {*} [context]
+     * @param {*} [context] will be passed as thisArg to the handler
      * @constructor
      */
     constructor(signal, handler, context) {
         if (typeof handler !== "function") {
-            throw new TypeError(`handler must be a function, instead was ${handler}`);
+            throw new TypeError(`handler must be a function, instead was '${typeof handler}'`);
         }
 
         if (typeof signal !== "object") {
-            throw new TypeError(`signal must be of an object, instead was ${signal}`)
+            throw new TypeError(`signal must be of an object, instead was '${typeof signal}'`)
         }
 
         if (typeof signal.add !== "function") {
-            throw new TypeError(`signal.add must be a function, instead was ${signal.add}`);
+            throw new TypeError(`signal.add must be a function, instead was '${typeof signal.add}'`);
         }
 
         /**
@@ -43,11 +50,6 @@ export class SignalBinding {
          */
         this.context = context;
 
-        /**
-         * State flag
-         * @type {boolean}
-         */
-        this.linked = false;
     }
 
     /**
@@ -55,11 +57,11 @@ export class SignalBinding {
      * Idempotent
      */
     link() {
-        if (this.linked) {
+        if (this.#linked) {
             return;
         }
 
-        this.linked = true;
+        this.#linked = true;
         this.signal.add(this.handler, this.context);
     }
 
@@ -68,11 +70,11 @@ export class SignalBinding {
      * Idempotent
      */
     unlink() {
-        if (!this.linked) {
+        if (!this.#linked) {
             return;
         }
 
-        this.linked = false;
+        this.#linked = false;
         this.signal.remove(this.handler, this.context);
     }
 }

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/model/ObservedBoolean.js

@@ -91,7 +91,7 @@ class ObservedBoolean extends Boolean {
 
     /**
      *
-     * @param {function} f
+     * @param {function(boolean)} f
      */
     process(f) {
         f(this.__value);

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) {