@woosh/meep-engine 2.48.22 → 2.49.0

package/src/core/collection/HashMap.spec.js

@@ -1,4 +1,4 @@
-import { HashMap } from "./HashMap.js";
+import { generate_next_linear_congruential_index, HashMap } from "./HashMap.js";
 import { passThrough, returnOne, strictEquals } from "../function/Functions.js";
 
 /**
@@ -16,6 +16,7 @@ function makeSample() {
     });
 }
 
+
 test('put and get same value', () => {
     const m = makeSample();
 
@@ -107,6 +108,44 @@ test("retrieval works as intended after hash map grows", () => {
 
 });
 
+test("after deletion element is not found", () => {
+    const map = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals,
+    });
+
+    map.set(1, "a");
+
+    map.delete(1);
+
+    expect(map.size).toBe(0);
+    expect(map.get(1)).toBeUndefined();
+});
+
+test("deleting an element then inserting another one all with hash collisions", () => {
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals,
+    });
+
+    map.set(1, "a");
+    map.set(7, "b");
+
+    map.delete(1);
+
+    expect(map.get(7)).toBe("b");
+    expect(map.get(1)).toBeUndefined();
+
+    map.set(13, "c");
+
+    expect(map.get(13)).toBe("c");
+
+    map.delete(13);
+
+    expect(map.get(7)).toBe("b");
+    expect(map.get(13)).toBeUndefined();
+});
+
 
 test("key iterator", () => {
     const map = new HashMap({
@@ -129,3 +168,73 @@ test("value iterator", () => {
 
     expect(map.values().next().value).toBe("hello");
 });
+
+
+test("clear works as expected", () => {
+    const map = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.set(7, "hello");
+
+    map.clear();
+
+    expect(map.get(7)).toBe(undefined);
+    expect(map.size).toBe(0);
+});
+
+test("lcg 32", () => {
+    const generated = new Uint32Array(32);
+
+    let next = 0;
+    for (let i = 0; i < 32; i++) {
+
+        generated[i] = next;
+
+        next = generate_next_linear_congruential_index(next, 31);
+
+    }
+
+    generated.sort();
+
+    for (let i = 0; i < 32; i++) {
+        expect(generated[i]).toBe(i);
+    }
+});
+
+
+test.skip("performance - random fill 100,000", () => {
+    const map = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals
+    });
+
+    const map_warmup = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals
+    });
+
+    // warm up
+    for (let i = 0; i < 10000; i++) {
+        map_warmup.set(i, i);
+        map_warmup.get(i);
+    }
+
+    const t0 = performance.now();
+
+    for (let i = 0; i < 100000; i++) {
+        map.set(i, i);
+    }
+
+    const t1 = performance.now();
+
+    for (let i = 0; i < 100000; i++) {
+        map.get(i);
+    }
+
+    const t2 = performance.now();
+
+    console.log(`Fill: ${t1 - t0}ms`)
+    console.log(`Drain: ${t2 - t1}ms`)
+});

package/src/core/collection/array/{typedArrayToDataType.js → typed/typedArrayToDataType.js}

@@ -1,4 +1,4 @@
-import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
+import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
 
 /**
  *

package/src/core/collection/array/weightedRandomFromArray.spec.js

@@ -0,0 +1,20 @@
+import { weightedRandomFromArray } from "./weightedRandomFromArray.js";
+import { passThrough, returnOne, returnZero } from "../../function/Functions.js";
+
+test("empty array", () => {
+    expect(weightedRandomFromArray([], returnZero, passThrough, null, 0))
+        .toBeUndefined();
+});
+
+test("single element array", () => {
+    expect(weightedRandomFromArray([1], returnZero, passThrough, null, 1))
+        .toBe(1);
+});
+
+test("two elements", () => {
+    expect(weightedRandomFromArray([1,3], returnZero, passThrough, null, 2))
+        .toBe(1);
+
+    expect(weightedRandomFromArray([1,3], returnOne, passThrough, null, 2))
+        .toBe(3);
+});

package/src/core/collection/heap/Uint32Heap.js

@@ -49,6 +49,7 @@ function HEAP_RIGHT(i) {
 
 /**
  * Binary Heap implementation that stores uin32 ID along with a floating point score value
+ * Very fast and compact
  * Inspired by Blender's heap implementation found here: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/BLI_heap.c
  */
 export class Uint32Heap {

package/src/core/debug/matchers/AnyOf.js

@@ -20,8 +20,7 @@ export class AnyOf extends BaseMatcher {
 
     matches(item, mismatch_description) {
         for (const matcher of this.#matchers) {
-            if (!matcher.matches(item, NullDescription.INSTANCE)) {
-
+            if (matcher.matches(item, NullDescription.INSTANCE)) {
                 return true;
             }
         }

package/src/core/events/signal/Signal.js

@@ -41,6 +41,7 @@ export class Signal {
      * @returns {boolean}
      */
     get dispatching() {
+        console.warn('deprecated, use .isDispatching instead');
         return this.getFlag(SignalFlags.Dispatching);
     }
 
@@ -49,6 +50,7 @@ export class Signal {
      * @param {boolean} v
      */
     set dispatching(v) {
+        console.warn('deprecated, flag should not be written to from outside of the signal');
         this.writeFlag(SignalFlags.Dispatching, v);
     }
 
@@ -147,7 +149,7 @@ export class Signal {
      * @param {*} [context]
      */
     addOne(h, context) {
-        assert.isFunction( h,  "handler");
+        assert.isFunction(h, "handler");
 
         const handler = new SignalHandler(h, context);
 
@@ -209,12 +211,12 @@ export class Signal {
         }
 
         //mark dispatch process
-        this.dispatching = true;
+        this.setFlag(SignalFlags.Dispatching);
 
         dispatchViaProxy(this.handlers, args);
 
         //mark end of dispatch process
-        this.dispatching = false;
+        this.clearFlag(SignalFlags.Dispatching);
     }
 
     /**
@@ -588,11 +590,11 @@ export class Signal {
     }
 
     /**
-     *
+     * @deprecated do not use
      * @returns {boolean}
      */
     isDispatching() {
-        return this.dispatching;
+        return this.getFlag(SignalFlags.Dispatching);
     }
 
     /**

package/src/core/events/signal/SignalBinding.js

@@ -4,73 +4,75 @@
  */
 
 
-/**
- *
- * @param {Signal} signal
- * @param {function} handler
- * @param {*} [context]
- * @constructor
- */
-function SignalBinding(signal, handler, context) {
-    if (typeof handler !== "function") {
-        throw new TypeError(`handler must be a function, instead was ${handler}`);
-    }
+export class SignalBinding {
+    /**
+     *
+     * @param {Signal} signal
+     * @param {function} handler
+     * @param {*} [context]
+     * @constructor
+     */
+    constructor(signal, handler, context) {
+        if (typeof handler !== "function") {
+            throw new TypeError(`handler must be a function, instead was ${handler}`);
+        }
 
-    if (typeof signal !== "object") {
-        throw new TypeError(`signal must be of an object, instead was ${signal}`)
-    }
+        if (typeof signal !== "object") {
+            throw new TypeError(`signal must be of an object, instead was ${signal}`)
+        }
 
-    if (typeof signal.add !== "function") {
-        throw new TypeError(`signal.add must be a function, instead was ${signal.add}`);
-    }
+        if (typeof signal.add !== "function") {
+            throw new TypeError(`signal.add must be a function, instead was ${signal.add}`);
+        }
 
-    /**
-     * Binding signal
-     * @type {Signal}
-     */
-    this.signal = signal;
+        /**
+         * Binding signal
+         * @type {Signal}
+         */
+        this.signal = signal;
 
-    /**
-     * Signal handler to be attached to the signal
-     * @type {Function}
-     */
-    this.handler = handler;
+        /**
+         * Signal handler to be attached to the signal
+         * @type {Function}
+         */
+        this.handler = handler;
 
-    /**
-     *
-     * @type {*}
-     */
-    this.context = context;
+        /**
+         *
+         * @type {*}
+         */
+        this.context = context;
+
+        /**
+         * State flag
+         * @type {boolean}
+         */
+        this.linked = false;
+    }
 
     /**
-     * State flag
-     * @type {boolean}
+     * Attaches handler to the signal
+     * Idempotent
      */
-    this.linked = false;
-}
+    link() {
+        if (this.linked) {
+            return;
+        }
 
-/**
- * Attaches handler to the signal
- * Idempotent
- */
-SignalBinding.prototype.link = function () {
-    if (!this.linked) {
         this.linked = true;
         this.signal.add(this.handler, this.context);
     }
-};
 
-/**
- * Detaches handler from the signal
- * Idempotent
- */
-SignalBinding.prototype.unlink = function () {
-    if (this.linked) {
+    /**
+     * Detaches handler from the signal
+     * Idempotent
+     */
+    unlink() {
+        if (!this.linked) {
+            return;
+        }
+
         this.linked = false;
         this.signal.remove(this.handler, this.context);
     }
-};
-
-export {
-    SignalBinding
-};
+}

package/src/core/events/signal/SignalFlags.js

@@ -1,4 +1,11 @@
 export const SignalFlags = {
+    /**
+     * If set - signal will not invoke handlers when dispatched
+     */
     Silent: 1,
+    /**
+     * Is set at the start of the dispatch and cleared at the end
+     * @deprecated
+     */
     Dispatching: 2
 }

package/src/core/function/Functions.js

@@ -6,7 +6,7 @@
 
 /**
  * No-operation function. Does nothing. Useful when a callback is required to avoid checks for a missing function.
- * @param {*..} arguments
+ * @param {*} arguments
  */
 export function noop() {
 }

package/src/core/geom/{Rectangle.js → 2d/Rectangle.js}

@@ -1,11 +1,11 @@
 /**
  * Created by Alex on 14/03/2016.
  */
-import { max2 } from "../math/max2.js";
-import { min2 } from "../math/min2.js";
-import Vector2 from "./Vector2.js";
-import { intersects1D } from "../math/interval/intersects1D.js";
-import { overlap1D } from "../math/interval/overlap1D.js";
+import { max2 } from "../../math/max2.js";
+import { min2 } from "../../math/min2.js";
+import Vector2 from "../Vector2.js";
+import { intersects1D } from "../../math/interval/intersects1D.js";
+import { overlap1D } from "../../math/interval/overlap1D.js";
 
 
 class Rectangle {

package/src/core/geom/{AABB2.js → 2d/aabb/AABB2.js}

@@ -4,13 +4,14 @@
  */
 
 
-import { assert } from "../assert.js";
-import { clamp } from "../math/clamp.js";
-import { max2 } from "../math/max2.js";
-import { min2 } from "../math/min2.js";
-import LineSegment2 from "./LineSegment2.js";
-import Vector2 from "./Vector2.js";
-import { overlap1D } from "../math/interval/overlap1D.js";
+import { assert } from "../../../assert.js";
+import { clamp } from "../../../math/clamp.js";
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+import LineSegment2 from "../LineSegment2.js";
+import Vector2 from "../../Vector2.js";
+import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
+import { aabb2_overlap_exists } from "./aabb2_overlap_exists.js";
 
 /**
  *
@@ -137,7 +138,7 @@ class AABB2 {
         const bx1 = other.x1;
         const by1 = other.y1;
 
-        return computeOverlap(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1, result);
+        return aabb2_compute_overlap(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1, result);
     }
 
     /**
@@ -156,7 +157,7 @@ class AABB2 {
         const bx1 = other.x1;
         const by1 = other.y1;
 
-        return aabb2_overlapExists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1);
+        return aabb2_overlap_exists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1);
     }
 
     /**
@@ -583,74 +584,5 @@ AABB2.zero = Object.freeze(new AABB2(0, 0, 0, 0));
  */
 AABB2.unit = Object.freeze(new AABB2(0, 0, 1, 1));
 
-/**
- *
- * @param {number} ax0
- * @param {number} ay0
- * @param {number} ax1
- * @param {number} ay1
- * @param {number} bx0
- * @param {number} by0
- * @param {number} bx1
- * @param {number} by1
- * @returns {boolean} true if overlap exists, false if no overlap
- */
-export function aabb2_overlapExists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1) {
-    return overlap1D(ax0, ax1, bx0, bx1)
-        && overlap1D(ay0, ay1, by0, by1);
-}
-
-/**
- *
- * @param {number} bounds_x0
- * @param {number} bounds_y0
- * @param {number} bounds_x1
- * @param {number} bounds_y1
- * @param {number} x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @return {boolean}
- */
-export function aabb2_contains(bounds_x0, bounds_y0, bounds_x1, bounds_y1, x0, y0, x1, y1) {
-
-    return x0 >= bounds_x0 && x1 <= bounds_x1 && y0 >= bounds_y0 && y1 <= bounds_y1;
-}
-
-/**
- *
- * @param {number} ax0
- * @param {number} ay0
- * @param {number} ax1
- * @param {number} ay1
- * @param {number} bx0
- * @param {number} by0
- * @param {number} bx1
- * @param {number} by1
- * @param {AABB2} result
- * @returns {boolean} true if overlap exists, false if no overlap
- */
-function computeOverlap(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1, result) {
-    const x0 = max2(ax0, bx0);
-    const x1 = min2(ax1, bx1);
-
-    if (x0 >= x1) {
-        //no overlap
-        return false;
-    }
-
-    const y0 = max2(ay0, by0);
-    const y1 = min2(ay1, by1);
-
-    if (y0 >= y1) {
-        //no overlap
-        return false;
-    }
-
-    result.set(x0, y0, x1, y1);
-
-    return true;
-}
-
 
 export default AABB2;

package/src/core/geom/2d/aabb/aabb2_compute_center_from_multiple.js

@@ -0,0 +1,19 @@
+import Vector2 from "../../Vector2.js";
+
+/**
+ *
+ * @param {Array.<AABB2>} boxes
+ * @returns {Vector2}
+ */
+export function aabb2_compute_center_from_multiple(boxes) {
+    const numBoxes = boxes.length;
+
+    const center = new Vector2();
+    for (let i = 0; i < numBoxes; i++) {
+        const box = boxes[i];
+        center._add(box.midX(), box.midY());
+    }
+    center.multiplyScalar(1 / numBoxes);
+
+    return center;
+}

package/src/core/geom/2d/aabb/aabb2_compute_overlap.js

@@ -0,0 +1,42 @@
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+
+/**
+ *
+ * @param {number} ax0
+ * @param {number} ay0
+ * @param {number} ax1
+ * @param {number} ay1
+ * @param {number} bx0
+ * @param {number} by0
+ * @param {number} bx1
+ * @param {number} by1
+ * @param {AABB2} result
+ * @returns {boolean} true if overlap exists, false if no overlap
+ */
+export function aabb2_compute_overlap(
+    ax0, ay0, ax1, ay1,
+    bx0, by0, bx1, by1,
+    result
+) {
+
+    const x0 = max2(ax0, bx0);
+    const x1 = min2(ax1, bx1);
+
+    if (x0 >= x1) {
+        //no overlap
+        return false;
+    }
+
+    const y0 = max2(ay0, by0);
+    const y1 = min2(ay1, by1);
+
+    if (y0 >= y1) {
+        //no overlap
+        return false;
+    }
+
+    result.set(x0, y0, x1, y1);
+
+    return true;
+}

package/src/core/geom/2d/aabb/aabb2_contains.js

@@ -0,0 +1,23 @@
+/**
+ *
+ * @param {number} bounds_x0
+ * @param {number} bounds_y0
+ * @param {number} bounds_x1
+ * @param {number} bounds_y1
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @return {boolean}
+ */
+export function aabb2_contains(
+    bounds_x0, bounds_y0, bounds_x1, bounds_y1,
+    x0, y0, x1, y1
+) {
+
+    return x0 >= bounds_x0
+        && x1 <= bounds_x1
+        && y0 >= bounds_y0
+        && y1 <= bounds_y1
+        ;
+}

package/src/core/geom/2d/aabb/aabb2_distance_sqr_to_point.js

@@ -0,0 +1,25 @@
+import { max3 } from "../../../math/max3.js";
+
+/**
+ * NOTE: The result is not a signed distance, any degree of penetration will produce 0 distance as a result
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ * @returns {number}
+ */
+export function aabb2_distance_sqr_to_point(x0, y0, x1, y1, px, py) {
+
+    const dx0 = x0 - px;
+    const dx1 = px - x1;
+
+    const dy0 = y0 - py;
+    const dy1 = py - y1;
+
+    const dx = max3(0, dx0, dx1);
+    const dy = max3(0, dy0, dy1);
+
+    return dx * dx + dy * dy;
+}

package/src/core/geom/2d/aabb/aabb2_distance_to_point.js

@@ -0,0 +1,17 @@
+import { aabb2_distance_sqr_to_point } from "./aabb2_distance_sqr_to_point.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} px
+ * @param {number} py
+ * @returns {number}
+ */
+export function aabb2_distance_to_point(x0, y0, x1, y1, px, py) {
+    const sqrD = aabb2_distance_sqr_to_point(x0, y0, x1, y1, px, py);
+    return Math.sqrt(sqrD);
+}
+

package/src/core/geom/2d/aabb/aabb2_distance_to_point.spec.js

@@ -0,0 +1,17 @@
+import { aabb2_distance_to_point } from "./aabb2_distance_to_point.js";
+
+test('aabb2_distance_to_point', () => {
+    expect(aabb2_distance_to_point(0, 0, 0, 0, 0, 0)).toBeCloseTo(0);
+
+    expect(aabb2_distance_to_point(0, 0, 0, 0, 1, 0)).toBeCloseTo(1);
+    expect(aabb2_distance_to_point(0, 0, 0, 0, 0, 1)).toBeCloseTo(1);
+
+    expect(aabb2_distance_to_point(0, 0, 0, 0, 1, 1)).toBeCloseTo(1.41421356237);
+
+
+    expect(aabb2_distance_to_point(0, 0, 1, 1, 2, 0.5)).toBeCloseTo(1);
+    expect(aabb2_distance_to_point(0, 0, 1, 1, 0.5, 2)).toBeCloseTo(1);
+
+    expect(aabb2_distance_to_point(0, 0, 1, 1, -1, 0.5)).toBeCloseTo(1);
+    expect(aabb2_distance_to_point(0, 0, 1, 1, 0.5, -1)).toBeCloseTo(1);
+});

package/src/core/geom/2d/aabb/aabb2_overlap_exists.js

@@ -0,0 +1,18 @@
+import { overlap1D } from "../../../math/interval/overlap1D.js";
+
+/**
+ *
+ * @param {number} ax0
+ * @param {number} ay0
+ * @param {number} ax1
+ * @param {number} ay1
+ * @param {number} bx0
+ * @param {number} by0
+ * @param {number} bx1
+ * @param {number} by1
+ * @returns {boolean} true if overlap exists, false if no overlap
+ */
+export function aabb2_overlap_exists(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1) {
+    return overlap1D(ax0, ax1, bx0, bx1)
+        && overlap1D(ay0, ay1, by0, by1);
+}