@woosh/meep-engine 2.37.18 → 2.38.0

package/core/assert.js

@@ -1,5 +1,5 @@
-import { isTypedArray } from "./json/JsonUtils.js";
 import { isArrayEqualStrict } from "./collection/array/isArrayEqualStrict.js";
+import { isTypedArray } from "./collection/array/typed/isTypedArray.js";
 
 function equal(a, b, m) {
     assert(a === b, m) // eslint-disable-line eqeqeq

package/core/binary/float2uint8.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function float2uint8(v) {
+    return Math.round(v * 255);
+}

package/core/binary/uint82float.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function uint82float(v) {
+    return v / 255;
+}

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -619,20 +619,22 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         while (index !== NULL_NODE) {
             index = this.balance(index);
 
-            const child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
-            const child2 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
+            const node_address = index * ELEMENT_WORD_COUNT;
+
+            const child1 = uint32[node_address + COLUMN_CHILD_1];
+            const child2 = uint32[node_address + COLUMN_CHILD_2];
 
             assert.notEqual(child1, NULL_NODE, 'child1 is null');
             assert.notEqual(child2, NULL_NODE, 'child2 is null');
 
-            uint32[index * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+            uint32[node_address + COLUMN_HEIGHT] = 1 + max2(
                 uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
                 uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
             );
 
             this.node_set_combined_aabb(index, child1, child2);
 
-            index = uint32[index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+            index = uint32[node_address + COLUMN_PARENT];
         }
     }
 

package/core/collection/array/array_get_index_in_range.js

@@ -0,0 +1,16 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {T} needle
+ * @param {number} min_index
+ * @param {number} max_index
+ */
+export function array_get_index_in_range(array, needle, min_index, max_index) {
+    for (let i = min_index; i <= max_index; i++) {
+        if (array[i] === needle) {
+            return i;
+        }
+    }
+
+    return -1;
+}

package/core/collection/array/typed/isTypedArray.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param o
+ * @returns {boolean}
+ */
+function isTypedArray(o) {
+    return (
+        o instanceof Int8Array ||
+        o instanceof Uint8Array ||
+        o instanceof Uint8ClampedArray ||
+        o instanceof Int16Array ||
+        o instanceof Uint16Array ||
+        o instanceof Int32Array ||
+        o instanceof Uint32Array ||
+        o instanceof Float32Array ||
+        o instanceof Float64Array
+    );
+}
+
+export { isTypedArray };

package/core/collection/array/typedArrayToDataType.js

@@ -10,6 +10,7 @@ export function typedArrayToDataType(v) {
 
     switch (ctor) {
         case Uint8Array:
+        case Uint8ClampedArray:
             return DataType.Uint8;
         case Uint16Array:
             return DataType.Uint16;

package/{engine/navigation/grid → core/collection/heap}/BinaryHeap.js

@@ -1,3 +1,8 @@
+/**
+ * @deprecated use {@link FastBinaryHeap} instead
+ * @param scoreFunction
+ * @constructor
+ */
 function BinaryHeap(scoreFunction) {
     this.content = [];
     this.hash = [];
@@ -99,7 +104,7 @@ BinaryHeap.prototype = {
             element = content[n],
             elemScore = scoreFunction(element);
 
-        for (;;) {
+        for (; ;) {
             // Compute the indices of the child elements.
             const child2N = (n + 1) << 1,
                 child1N = child2N - 1;

package/{engine/navigation/grid → core/collection/heap}/FastBinaryHeap.js

@@ -1,4 +1,4 @@
-import { assert } from "../../../core/assert.js";
+import { assert } from "../../assert.js";
 
 /**
  * Min-Heap implementation with a score function. The data structure is a binary heap where elements are removed in order defined by scoring function
@@ -6,7 +6,8 @@ import { assert } from "../../../core/assert.js";
  */
 class BinaryHeap {
     /**
-     * @param {(T)=>number} scoreFunction
+     * @template T
+     * @param {function(el:T):number} scoreFunction
      * @constructor
      */
     constructor(scoreFunction) {

package/{engine/navigation/grid → core/collection/heap}/FastBinaryHeap.spec.js

@@ -1,7 +1,7 @@
-import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { seededRandom } from "../../math/random/seededRandom.js";
 import BinaryHeap from "./FastBinaryHeap.js";
-import { passThrough, returnZero } from "../../../core/function/Functions.js";
-import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
+import { passThrough, returnZero } from "../../function/Functions.js";
+import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new BinaryHeap(returnZero);

package/core/collection/heap/Uin32Heap.spec.js

@@ -0,0 +1,59 @@
+import { Uint32Heap } from "./Uint32Heap.js";
+
+test('initial capacity setting via constructor', () => {
+    const heap = new Uint32Heap(3);
+
+    expect(heap.capacity).toBe(3);
+});
+
+test('heap capacity grows as needed', () => {
+    const heap = new Uint32Heap(0);
+
+    heap.insert(1, 1);
+
+    expect(heap.capacity).toBeGreaterThanOrEqual(1);
+});
+
+test('initial heap size is 0', () => {
+    const heap = new Uint32Heap();
+
+    expect(heap.size).toBe(0);
+});
+
+test('insert operation increases size by 1', () => {
+    const heap = new Uint32Heap();
+
+    const s0 = heap.size;
+
+    heap.insert(0, 0);
+
+    expect(heap.size).toBe(s0 + 1);
+});
+
+test('pop operation reduces size by 1', () => {
+    const heap = new Uint32Heap();
+
+    heap.insert(0, 0);
+
+    const s0 = heap.size;
+
+    heap.pop_min();
+
+    expect(heap.size).toBe(s0 - 1);
+});
+
+test('insert 5 out of order, retrieve in order', () => {
+    const heap = new Uint32Heap();
+
+    heap.insert(3, 4);
+    heap.insert(5, 5);
+    heap.insert(7, 2);
+    heap.insert(11, 3);
+    heap.insert(13, 1);
+
+    expect(heap.pop_min()).toBe(13);
+    expect(heap.pop_min()).toBe(7);
+    expect(heap.pop_min()).toBe(11);
+    expect(heap.pop_min()).toBe(3);
+    expect(heap.pop_min()).toBe(5);
+});

package/core/collection/heap/Uint32Heap.js

@@ -0,0 +1,385 @@
+import { assert } from "../../assert.js";
+import { max2 } from "../../math/max2.js";
+
+const UINT32_MAX = 4294967295;
+
+const DEFAULT_CAPACITY = 64;
+const ELEMENT_BYTE_SIZE = 8;
+
+/**
+ * % to increase capacity by when growing
+ * NOTE: Must be greater than 1
+ * @type {number}
+ */
+const RESIZE_GROW_FACTOR = 1.2;
+/**
+ * Minimum number of elements to expand the size by when growing
+ * NOTE: Must be an integer
+ * NOTE: Must be greater than 0
+ * @type {number}
+ */
+const RESIZE_GROW_MIN_COUNT = 16;
+
+/**
+ *
+ * @param {number} i
+ * @returns {number}
+ */
+function HEAP_PARENT(i) {
+    return ((i) - 1) >> 1;
+}
+
+/**
+ *
+ * @param {number} i
+ * @returns {number}
+ */
+function HEAP_LEFT(i) {
+    return ((i) << 1) + 1;
+}
+
+/**
+ *
+ * @param {number} i
+ * @returns {number}
+ */
+function HEAP_RIGHT(i) {
+    return ((i) << 1) + 2;
+}
+
+/**
+ * Binary Heap implementation that stores uin32 ID along with a floating point score value
+ * 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 {
+    /**
+     *
+     * @param {number} [capacity] Can supply initial capacity, heap will still grow when necessary. This allows to prevent needless re-allocations when max heap size is known in advance
+     */
+    constructor(capacity = DEFAULT_CAPACITY) {
+        assert.isNonNegativeInteger(capacity, 'capacity');
+
+        this.__data_buffer = new ArrayBuffer(capacity * ELEMENT_BYTE_SIZE);
+
+        /**
+         * Used to access stored IDs
+         * @type {Uint32Array}
+         * @private
+         */
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+
+        /**
+         * Used to access stored Score values
+         * @type {Float32Array}
+         * @private
+         */
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+
+        this.__capacity = capacity;
+        this.__size = 0;
+    }
+
+    /**
+     *
+     * @private
+     */
+    __capacity_grow() {
+        const old_capacity = this.__capacity;
+
+        const new_capacity = max2(
+            old_capacity * RESIZE_GROW_FACTOR,
+            old_capacity + RESIZE_GROW_MIN_COUNT
+        );
+
+        assert.greaterThan(new_capacity, old_capacity, 'invalid growth');
+
+        const new_buffer = new ArrayBuffer(new_capacity * ELEMENT_BYTE_SIZE);
+        const new_uint32 = new Uint32Array(new_buffer);
+
+        // copy old data into new container
+        new_uint32.set(this.__data_uint32);
+
+        this.__data_buffer = new_buffer;
+        this.__data_uint32 = new_uint32;
+        this.__data_float32 = new Float32Array(new_buffer);
+
+        // update capacity
+        this.__capacity = new_capacity;
+    }
+
+    /**
+     * @private
+     * @param {number} a index of an element
+     * @param {number} b index of an element
+     * @returns {boolean}
+     */
+    compare(a, b) {
+        const float32 = this.__data_float32;
+
+        return float32[a * 2] < float32[b * 2];
+    }
+
+    /**
+     * Swap two elements
+     * @private
+     * @param {number} i element index
+     * @param {number} j element index
+     */
+    swap(i, j) {
+        const i2 = i * 2;
+        const j2 = j * 2;
+
+        const uint32 = this.__data_uint32;
+
+        const mem_0 = uint32[i2];
+        uint32[i2] = uint32[j2];
+        uint32[j2] = mem_0;
+
+        const mem_1 = uint32[i2 + 1];
+        uint32[i2 + 1] = uint32[j2 + 1];
+        uint32[j2 + 1] = mem_1;
+    }
+
+    /**
+     * @private
+     * @param {number} index
+     */
+    heap_down(index) {
+        let i = index;
+
+        // size does not change, cache it for performance
+        const size = this.__size;
+
+        while (true) {
+            const l = ((i) << 1) + 1;
+            const r = l + 1;
+
+            let smallest = i;
+
+            if (l < size && this.compare(l, smallest)) {
+                smallest = l;
+            }
+
+            if (r < size && this.compare(r, smallest)) {
+                smallest = r;
+            }
+
+            if (smallest === i) {
+                break;
+            }
+
+            this.swap(i, smallest);
+
+            i = smallest;
+        }
+
+    }
+
+    /**
+     * Bubble up given element into its correct position
+     * @private
+     * @param {number} index
+     */
+    heap_up(index) {
+        let i = index;
+
+        while (i > 0) {
+            // get parent
+            const p = ((i) - 1) >> 1;
+
+            if (this.compare(p, i)) {
+                break;
+            }
+
+            this.swap(p, i);
+
+            i = p;
+        }
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get size() {
+        return this.__size;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get capacity() {
+        return this.__capacity;
+    }
+
+    /**
+     * Node with the lowest score
+     * @returns {number}
+     */
+    get top_id() {
+        return this.__data_uint32[1];
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    is_empty() {
+        return this.__size === 0;
+    }
+
+    pop_min() {
+        assert.greaterThan(this.__size, 0, 'heap is empty');
+
+        const result = this.top_id;
+
+        this.__size--;
+
+        if (this.__size > 0) {
+            // move top element to the bottom
+            this.swap(0, this.__size);
+
+            // rebalance
+            this.heap_down(0);
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    find_index_by_id(id) {
+        const n = this.__size
+        const n2 = n * 2;
+
+        const uint32 = this.__data_uint32;
+
+        for (let address = 1; address < n2; address += 2) {
+            const _id = uint32[address];
+
+            if (_id === id) {
+                return (address >>> 1);
+            }
+        }
+
+        // not found
+        return -1;
+    }
+
+
+    /**
+     *
+     * @param {number} id
+     */
+    remove(id) {
+        const i = this.find_index_by_id(id);
+
+        if (i !== -1) {
+            this.__remove_by_index(i);
+        }
+    }
+
+    /**
+     *
+     * @param {number} index
+     */
+    __remove_by_index(index) {
+        assert.greaterThan(this.__size, 0, 'heap is empty');
+
+        let i = index;
+
+        while (i > 0) {
+            const p = HEAP_PARENT(i);
+            this.swap(p, i);
+
+            i = p;
+        }
+
+        this.pop_min();
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} score
+     */
+    update_score(id, score) {
+        const index = this.find_index_by_id(id);
+
+        if (index === -1) {
+            throw new Error('Not found');
+        }
+
+        this.__update_score_by_index(index, score);
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number} score
+     */
+    __update_score_by_index(index, score) {
+
+        const float32 = this.__data_float32;
+        const index2 = index * 2;
+        const existing_score = float32[index2];
+
+        if (score < existing_score) {
+            float32[index2] = score;
+            this.heap_up(index);
+        } else if (score > existing_score) {
+            float32[index2] = score;
+            this.heap_down(index);
+        }
+    }
+
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} score
+     */
+    insert_or_update(id, score) {
+        const i = this.find_index_by_id(id);
+
+        if (i === -1) {
+            this.insert(id, score);
+        } else {
+            this.__update_score_by_index(i, score);
+        }
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} score
+     */
+    insert(id, score) {
+        assert.isNonNegativeInteger(id, 'value');
+        assert.lessThanOrEqual(id, UINT32_MAX - 1, 'must be less than or equal to (2^32 - 2)');
+
+        if (this.__size >= this.__capacity) {
+            // need to re-allocate
+            this.__capacity_grow();
+        }
+
+        // insert at the end
+        const index = this.__size;
+        const address = index * 2;
+
+        // write data
+        this.__data_float32[address] = score;
+        this.__data_uint32[address + 1] = id;
+
+        // record increased size
+        this.__size++;
+
+        this.heap_up(index);
+    }
+
+
+}

package/core/collection/list/List.d.ts

@@ -5,7 +5,7 @@ export default class List<T> {
 
     on: {
         added: Signal<T>,
-        removed: Signal<T>
+        removed: Signal<T, number>
     }
 
     constructor(elements?: T[])

package/core/collection/table/RowFirstTable.js

@@ -6,6 +6,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
+import { array_copy } from "../array/copyArray.js";
 
 /**
  *
@@ -414,6 +415,39 @@ RowFirstTable.prototype.setRow = function (index, record) {
     this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
 }
 
+/**
+ * Reverse order of rows, row-0 will end up at and previously last row will become the first row etc.
+ */
+RowFirstTable.prototype.reverse_rows = function () {
+    const bpr = this.bytesPerRecord;
+    const copy_buffer = new Uint8Array(bpr);
+
+    const buffer = this.data;
+    const wrapper = new Uint8Array(buffer);
+
+    const length = this.length;
+
+    if (length <= 1) {
+        // need at least 2 rows for reversal to make any change
+        return;
+    }
+
+    const last_row_index = length - 1;
+
+
+    const traversal_limit = last_row_index >>> 1;
+    for (let i = 0; i <= traversal_limit; i++) {
+        const address = i * bpr;
+        array_copy(wrapper, address, copy_buffer, 0, bpr);
+
+        const swap_index = last_row_index - i;
+        const swap_address = swap_index * bpr;
+
+        wrapper.copyWithin(address, swap_address, swap_address + bpr)
+        wrapper.set(copy_buffer, swap_address);
+    }
+};
+
 /**
  * clear out all the data and free memory
  */