@woosh/meep-engine 2.43.20 → 2.43.22

package/core/collection/HashMap.d.ts

@@ -5,8 +5,8 @@ export class HashMap<K, V> implements Iterable<[V, K]> {
                     capacity,
                     loadFactor
                 }: {
-        keyHashFunction: (k: K) => number,
-        keyEqualityFunction: (a: K, b: K) => boolean,
+        keyHashFunction?: (k: K) => number,
+        keyEqualityFunction?: (a: K, b: K) => boolean,
         capacity?: number,
         loadFactor?: number
     })

package/core/collection/HashMap.js

@@ -60,6 +60,8 @@ export class HashMap {
 
         assert.isFunction(keyHashFunction, 'keyHashFunction');
         assert.isFunction(keyEqualityFunction, 'keyEqualityFunction');
+        assert.isNonNegativeInteger(capacity, 'capacity');
+        assert.isNumber(loadFactor, 'loadFactor');
 
         /**
          *
@@ -275,8 +277,8 @@ export class HashMap {
 
     /**
      *
-     * @param {Key} key
-     * @param {function(Key):V} compute
+     * @param {K} key
+     * @param {function(K):V} compute
      * @param {*} [compute_context]
      * @return {V}
      */
@@ -294,6 +296,24 @@ export class HashMap {
         return value;
     }
 
+    /**
+     * Returns existing value if key exists, if it doesn't - sets it and returns what was passed in
+     * @param {K} key
+     * @param {V} value this value will be written at the key location if the key wasn't found in the Map
+     * @return {V}
+     */
+    getOrSet(key, value) {
+        const existing = this.get(key);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        this.set(key, value);
+
+        return value;
+    }
+
 
     /**
      *

package/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -15,6 +15,24 @@ function split_by_3(a) {
     return x;
 }
 
+/**
+ * method to separate bits from a given integer 2 positions apart
+ *
+ * @example when input is ABC, output bits are A00B00C
+ * @see https://github.com/Forceflow/libmorton/blob/234a443ca8e2c64f6385f1a9d6ee10a70d08a3fa/include/libmorton/morton2D.h#L99
+ * @param {number} a
+ * @returns {number}
+ */
+export function split_by_2(a) {
+    let x = a;
+    x = (x | x << 16) & 0x0000FFFF;
+    x = (x | x << 8) & 0x00FF00FF;
+    x = (x | x << 4) & 0x0F0F0F0F;
+    x = (x | x << 2) & 0x33333333;
+    x = (x | x << 1) & 0x55555555;
+    return x;
+}
+
 /**
  * Based on article and C++ source code:
  *      https://www.forceflow.be/2013/10/07/morton-encodingdecoding-through-bit-interleaving-implementations/

package/core/geom/3d/topology/struct/BinaryElementPool.js

@@ -0,0 +1,292 @@
+import { max3 } from "../../../../math/max3.js";
+import { assert } from "../../../../assert.js";
+import { typed_array_copy } from "../../../../collection/array/typed/typed_array_copy.js";
+
+/**
+ * How many items to reserve by default
+ * @readonly
+ * @type {number}
+ */
+const INITIAL_CAPACITY = 128;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const CAPACITY_GROW_MULTIPLIER = 1.2;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const CAPACITY_GROW_MIN_STEP = 32;
+
+/**
+ * Align on 4 byte boundary
+ * @param {number} n
+ * @return {number}
+ */
+function align_4(n) {
+    const result = ((n + 0x3) >> 2) << 2;
+
+    assert.greaterThanOrEqual(result, n, 'aligned result must be >= input');
+
+    return result;
+}
+
+/**
+ * @see https://github.com/blender/blender/blob/master/source/blender/blenlib/intern/BLI_mempool.c
+ */
+export class BinaryElementPool {
+
+    /**
+     *
+     * @param {number} item_size in bytes
+     * @param {number} initial_capacity how many items to reverse in the newly created pool
+     */
+    constructor(item_size, initial_capacity = INITIAL_CAPACITY) {
+        assert.isNonNegativeInteger(item_size, 'item_size');
+        assert.greaterThan(item_size, 0, 'item_size must be greater than 0');
+
+        /**
+         * Size of a single pool item in bytes
+         * @type {number}
+         * @private
+         */
+        this.__item_size = item_size;
+
+        /**
+         * Unused slots
+         * @type {number[]}
+         * @private
+         */
+        this.__free = [];
+
+        /**
+         * Tracks last unallocated item in the list,
+         * this separate cursor is necessary to prevent re-allocation of the 'free' array
+         * @type {number}
+         * @private
+         */
+        this.__free_pointer = 0;
+
+        this.__data_buffer = new ArrayBuffer(align_4(initial_capacity * item_size));
+        this.__data_uint8 = new Uint8Array(this.__data_buffer);
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+        this.__data_view = new DataView(this.__data_buffer);
+
+        this.__capacity = initial_capacity;
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__size = 0;
+    }
+
+    /**
+     * Returns size of used region, this includes both elements that are allocated and those that aren't
+     * Please note that this value does not represent number of currently active elements, if you need that - you'll need to use something else
+     * @return {number}
+     */
+    get size() {
+        return this.__size;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get byteSize() {
+        return this.__capacity * this.__item_size;
+    }
+
+    /**
+     *
+     * @return {Uint32Array}
+     */
+    get data_uint32() {
+        return this.__data_uint32;
+    }
+
+    /**
+     *
+     * @return {Float32Array}
+     */
+    get data_float32() {
+        return this.__data_float32;
+    }
+
+    get data_view() {
+        return this.__data_view;
+    }
+
+    /**
+     * Get rid of excess capacity
+     */
+    trim() {
+        this.__set_capacity(this.__size);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @return {number}
+     */
+    element_address(id) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        return this.__item_size * id;
+    }
+
+    /**
+     * Used alongside iterators to check if element is actually allocated or not
+     * @param {number} id
+     * @return {boolean}
+     */
+    is_allocated(id) {
+        if (id >= this.__size) {
+            // ID is past allocated region
+            return false;
+        }
+
+        const pointer = this.__free_pointer;
+
+        for (let i = 0; i < pointer; i++) {
+            const _id = this.__free[i];
+
+            if (id === _id) {
+                // found in unallocated set
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     *
+     * @param {number} new_capacity
+     * @private
+     */
+    __set_capacity(new_capacity) {
+        if (this.__capacity === new_capacity) {
+            // no point
+            return;
+        }
+
+        const old_data_uint8 = this.__data_uint8;
+
+        const aligned_byte_size = align_4(new_capacity * this.__item_size);
+
+        const new_data_buffer = new ArrayBuffer(aligned_byte_size);
+
+        this.__data_buffer = new_data_buffer;
+        this.__data_uint8 = new Uint8Array(new_data_buffer);
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+        this.__data_view = new DataView(new_data_buffer);
+
+        // copy old data
+        typed_array_copy(old_data_uint8, this.__data_uint8);
+
+        this.__capacity = new_capacity;
+    }
+
+    /**
+     *
+     * @param {number} min_capacity
+     * @private
+     */
+    __grow_capacity(min_capacity) {
+        const new_capacity = Math.ceil(max3(
+            min_capacity,
+            this.__capacity * CAPACITY_GROW_MULTIPLIER,
+            this.__capacity + CAPACITY_GROW_MIN_STEP
+        ));
+
+        this.__set_capacity(new_capacity);
+    }
+
+    /**
+     *
+     * @param {number} capacity
+     */
+    ensure_capacity(capacity) {
+        if (this.__capacity < capacity) {
+            this.__grow_capacity(capacity);
+        }
+    }
+
+
+    /**
+     *
+     * @return {number} ID of the allocated element
+     */
+    allocate() {
+        if (this.__free_pointer > 0) {
+            // get unused slot
+            this.__free_pointer--;
+            return this.__free[this.__free_pointer];
+        }
+
+        // allocate new
+        let result = this.__size;
+        this.__size++;
+
+        if (this.__size >= this.__capacity) {
+            // grow if necessary
+            this.__grow_capacity(this.__size);
+        }
+
+        assert.greaterThan(this.__data_buffer.byteLength, result * this.__item_size, 'memory underflow');
+
+        return result;
+    }
+
+    /**
+     * Allocate a continuous range of IDs in bulk
+     * @param {number} count
+     * @return {number} offset where the range starts, this is your first ID basically
+     */
+    allocate_continuous(count) {
+        const offset = this.__size;
+
+        this.__size += count;
+
+        if (this.__size >= this.__capacity) {
+            this.__grow_capacity(this.__size);
+        }
+
+        assert.greaterThanOrEqual(this.__data_buffer.byteLength, (offset + count) * this.__item_size, 'memory underflow');
+
+        return offset;
+    }
+
+    /**
+     * Please note that this method does not perform any checks at all.
+     * You have to make sure that the item is actually unneeded and no duplicate calls are made
+     * @param {number} id
+     */
+    release(id) {
+        if (id === this.__size - 1) {
+            // releasing item at the end of the reserved region, don't have to push it into free set
+            this.__size--;
+        } else if (id >= this.__size) {
+            // do nothing, just throw it away
+            // this should never happen
+        } else {
+            this.__free[this.__free_pointer++] = id;
+        }
+    }
+
+    /**
+     * Removed all data from the pool
+     */
+    clear() {
+        this.__size = 0;
+        this.__free_pointer = 0;
+    }
+}

package/core/geom/3d/topology/struct/BinaryElementPool.spec.js

@@ -0,0 +1,36 @@
+import { BinaryElementPool } from "./BinaryElementPool.js";
+
+test('Constructor does not throw', () => {
+    new BinaryElementPool(1);
+});
+
+test('Allocation returns a valid non-negative ID', () => {
+    const pool = new BinaryElementPool(1);
+
+    const id = pool.allocate();
+
+    expect(id).toBeGreaterThanOrEqual(0);
+    expect(Number.isInteger(id)).toBe(true);
+    expect(Number.isFinite(id)).toBe(true);
+});
+
+test('Consecutive allocations return different IDs', () => {
+    const pool = new BinaryElementPool(1);
+
+    const a = pool.allocate();
+    const b = pool.allocate();
+
+    expect(a).not.toEqual(b);
+});
+
+test('Allocate, release, allocate produces the same ID',()=>{
+    const pool = new BinaryElementPool(1);
+
+    const a = pool.allocate();
+
+    pool.release(a);
+
+    const b = pool.allocate();
+
+    expect(a).toEqual(b);
+});