@woosh/meep-engine 2.117.18 → 2.117.19

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

@@ -6,7 +6,6 @@ import { min2 } from "../../math/min2.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../model/object/invokeObjectHash.js";
 import { array_copy } from "../array/array_copy.js";
-import { array_swap_one } from "../array/array_swap_one.js";
 import { UintArrayForCount } from "../array/typed/uint_array_for_count.js";
 
 /*
@@ -140,62 +139,62 @@ export class HashMap {
      * number of bins is always power or two
      * @type {Uint32Array}
      */
-    #bins = EMPTY_BINS;
+    __bins = EMPTY_BINS;
 
     /**
      * Note that dead entries are marked as such with a special reserved hash values, so records can be reused for new entries
      * @type {Array<HashMapEntry<K,V>>}
      */
-    #entries = new Array(0);
+    __entries = new Array(0);
 
     /**
      * Pointer to the end of allocated entries segment
      * @type {number}
      */
-    #entries_bound = 0;
+    __entries_bound = 0;
 
     /**
      *
      * @type {number}
      */
-    #entries_start = 0;
+    __entries_start = 0;
 
     /**
      * number of records in the map
      * @type {number}
      */
-    #size = 0;
+    __size = 0;
 
-    #bin_count = 0;
+    __bin_count = 0;
 
     /**
      * Always exactly half of the number of bins
      * @type {number}
      */
-    #entries_allocated_count = 0;
+    __entries_allocated_count = 0;
 
-    #bin_count_power_of_two = 0;
+    __bin_count_power_of_two = 0;
 
-    #entries_count_power_of_two = 0;
+    __entries_count_power_of_two = 0;
 
     /**
      * Mask used to map from hash to a bin index
      * @type {number}
      */
-    #bin_count_mask = 0;
+    __bin_count_mask = 0;
 
     /**
      * How full the table can get before number of buckets is increased
      * @type {number}
      * @private
      */
-    #load_factor = DEFAULT_LOAD_FACTOR;
+    __load_factor = DEFAULT_LOAD_FACTOR;
 
     /**
      * Used to track modifications to prevent concurrent changes during iteration
      * @type {number}
      */
-    #version = 0;
+    __version = 0;
 
     /**
      * @template K, V
@@ -234,13 +233,13 @@ export class HashMap {
          */
         this.keyEqualityFunction = keyEqualityFunction;
 
-        this.#load_factor = loadFactor;
+        this.__load_factor = loadFactor;
 
         this.#setBinCount(ceilPowerOfTwo(capacity));
     }
 
     get size() {
-        return this.#size;
+        return this.__size;
     }
 
     /**
@@ -248,7 +247,7 @@ export class HashMap {
      * @returns {number}
      */
     getCurrentLoad() {
-        return this.#size / this.#bin_count;
+        return this.__size / this.__bin_count;
     }
 
     /**
@@ -260,33 +259,33 @@ export class HashMap {
         assert.isNonNegativeInteger(count, 'count');
         assert.equal(isPowerOfTwo(count), true, `count must be a power of two, instead was ${count}`);
 
-        if (count < this.#size) {
-            throw new Error(`count must be at least equal to must of records in the map (=${this.#size}), instead was ${count}`);
+        if (count < this.__size) {
+            throw new Error(`count must be at least equal to must of records in the map (=${this.__size}), instead was ${count}`);
         }
 
 
-        this.#entries_count_power_of_two = ctz32(count);
-        this.#bin_count_power_of_two = this.#entries_count_power_of_two + 1;
+        this.__entries_count_power_of_two = ctz32(count);
+        this.__bin_count_power_of_two = this.__entries_count_power_of_two + 1;
 
-        this.#bin_count = 2 ** this.#bin_count_power_of_two;
-        this.#bin_count_mask = this.#bin_count - 1;
+        this.__bin_count = 2 ** this.__bin_count_power_of_two;
+        this.__bin_count_mask = this.__bin_count - 1;
 
-        const old_entry_allocation_count = this.#entries_allocated_count;
+        const old_entry_allocation_count = this.__entries_allocated_count;
 
-        this.#entries_allocated_count = 2 ** this.#entries_count_power_of_two;
+        this.__entries_allocated_count = 2 ** this.__entries_count_power_of_two;
 
-        const BinsArray = UintArrayForCount(this.#entries_allocated_count + ENTRY_BASE);
+        const BinsArray = UintArrayForCount(this.__entries_allocated_count + ENTRY_BASE);
 
-        this.#bins = new BinsArray(this.#bin_count);
+        this.__bins = new BinsArray(this.__bin_count);
 
-        const new_entries = new Array(this.#entries_allocated_count);
-        const old_entries = this.#entries;
+        const new_entries = new Array(this.__entries_allocated_count);
+        const old_entries = this.__entries;
 
-        this.#entries = new_entries;
+        this.__entries = new_entries;
 
-        array_copy(old_entries, 0, new_entries, 0, min2(old_entry_allocation_count, this.#entries_allocated_count));
+        array_copy(old_entries, 0, new_entries, 0, min2(old_entry_allocation_count, this.__entries_allocated_count));
 
-        if (this.#size > 0) {
+        if (this.__size > 0) {
             // re-hash
             this.rebuild();
         }
@@ -298,7 +297,7 @@ export class HashMap {
      * @returns {number}
      * @private
      */
-    #compute_bin_index(hash) {
+    compute_bin_index(hash) {
         assert.isInteger(hash, 'hash');
 
         // mix the input hash to minimize potential impact of poor hash function spread
@@ -307,7 +306,7 @@ export class HashMap {
         // force index to unsigned integer
         const index = mixed_hash >>> 0;
 
-        return index & this.#bin_count_mask;
+        return index & this.__bin_count_mask;
     }
 
     /**
@@ -355,15 +354,15 @@ export class HashMap {
      */
     #allocate_entry(k, v, hash) {
 
-        const i = this.#entries_bound;
+        const i = this.__entries_bound;
 
-        this.#entries_bound++;
+        this.__entries_bound++;
 
-        if (this.#entries[i] !== undefined) {
+        if (this.__entries[i] !== undefined) {
 
             // entry exists, let's reuse it
 
-            const entry = this.#entries[i];
+            const entry = this.__entries[i];
 
             assert.equal(entry.hash, RESERVED_HASH, 'Entry is occupied');
 
@@ -375,7 +374,7 @@ export class HashMap {
 
             // entry slot is empty
 
-            this.#entries[i] = new HashMapEntry(k, v, hash);
+            this.__entries[i] = new HashMapEntry(k, v, hash);
 
         }
 
@@ -396,11 +395,11 @@ export class HashMap {
     }
 
     #rebuild_if_necessary() {
-        if (this.#entries_bound !== this.#entries_allocated_count) {
+        if (this.__entries_bound !== this.__entries_allocated_count) {
             return;
         }
 
-        if (this.#size === this.#entries_allocated_count) {
+        if (this.__size === this.__entries_allocated_count) {
             // used up all allocated entries
             // bin count must always be larger than end of the entries table
             this.#grow();
@@ -419,20 +418,20 @@ export class HashMap {
         this.#rebuild_if_necessary();
 
         const raw_hash = this.#build_key_hash(key);
-        let bin_index = this.#compute_bin_index(raw_hash);
+        let bin_index = this.compute_bin_index(raw_hash);
 
         assert.isFiniteNumber(bin_index, 'hash');
 
         let first_deleted_bin_index = UNDEFINED_BIN_INDEX;
 
         for (; ;) {
-            const bin = this.#bins[bin_index];
+            const bin = this.__bins[bin_index];
 
             if (bin > BIN_RESERVED_VALUE_DELETED) {
                 // bin is occupied
 
                 // check if it's the entry that we're looking for
-                const entry = this.#entries[bin - ENTRY_BASE];
+                const entry = this.__entries[bin - ENTRY_BASE];
 
                 if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
@@ -450,17 +449,17 @@ export class HashMap {
 
                 const entry_index = this.#allocate_entry(key, value, raw_hash);
 
-                assert.defined(this.#entries[entry_index], 'entry');
+                assert.defined(this.__entries[entry_index], 'entry');
 
-                assert.equal(this.#entries[entry_index].hash, raw_hash, 'entry.hash');
-                assert.equal(this.#entries[entry_index].value, value, 'entry.value');
-                assert.equal(this.#entries[entry_index].key, key, 'entry.key');
+                assert.equal(this.__entries[entry_index].hash, raw_hash, 'entry.hash');
+                assert.equal(this.__entries[entry_index].value, value, 'entry.value');
+                assert.equal(this.__entries[entry_index].key, key, 'entry.key');
 
                 const bin_value = entry_index + ENTRY_BASE;
 
-                this.#bins[bin_index] = bin_value;
+                this.__bins[bin_index] = bin_value;
 
-                assert.equal(bin_value, this.#bins[bin_index], 'Bin value write error');
+                assert.equal(bin_value, this.__bins[bin_index], 'Bin value write error');
 
                 break;
 
@@ -471,19 +470,19 @@ export class HashMap {
             }
 
             // perform secondary hashing
-            bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+            bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
         }
 
-        const old_size = this.#size;
+        const old_size = this.__size;
         const new_size = old_size + 1;
-        this.#size = new_size;
+        this.__size = new_size;
 
         // compute actual current load
-        const bucket_count = this.#bin_count;
+        const bucket_count = this.__bin_count;
         const load = new_size / bucket_count;
 
-        if (load > this.#load_factor) {
+        if (load > this.__load_factor) {
             // current load is too high, increase table size
             this.#grow();
         }
@@ -497,16 +496,16 @@ export class HashMap {
     get(key) {
         const raw_hash = this.#build_key_hash(key);
 
-        let bin_index = this.#compute_bin_index(raw_hash);
+        let bin_index = this.compute_bin_index(raw_hash);
 
         for (; ;) {
-            const bin = this.#bins[bin_index];
+            const bin = this.__bins[bin_index];
 
             if (bin > BIN_RESERVED_VALUE_DELETED) {
                 // bin is occupied
 
                 // check if the entry is what we're looking for
-                const entry = this.#entries[bin - ENTRY_BASE];
+                const entry = this.__entries[bin - ENTRY_BASE];
 
                 if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
@@ -519,7 +518,7 @@ export class HashMap {
             }
 
             // perform secondary hashing
-            bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+            bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
         }
 
@@ -569,24 +568,25 @@ export class HashMap {
     }
 
     /**
-     *
-     * @param {number} bin
+     * Update the entries start of table TAB after removing an entry with index N in the array entries.
+     * @param {number} bin index of deleted entry
      */
     #update_range_for_deleted(bin) {
-        if (this.#entries_start === bin) {
-            let start = bin + 1;
-            let bound = this.#entries_bound;
+        if (this.__entries_start !== bin) {
+            return;
+        }
 
-            const entries = this.#entries;
+        let start = bin + 1;
+        let bound = this.__entries_bound;
+        const entries = this.__entries;
 
-            while (start < bound && entries[start].hash === RESERVED_HASH) {
-                start++;
-            }
+        while (start < bound && entries[start].hash === RESERVED_HASH) {
+            start++;
+        }
 
-            assert.greaterThanOrEqual(bound - start, this.#size, `live entity bounds must span at least number of entries equal to map size(=${this.#size}), instead got start(=${start}), and end(=${bound})`)
+        assert.greaterThanOrEqual(bound - start, this.__size, `live entity bounds must span at least number of entries equal to map size(=${this.__size}), instead got start(=${start}), and end(=${bound})`)
 
-            this.#entries_start = start;
-        }
+        this.__entries_start = start;
     }
 
     /**
@@ -597,12 +597,12 @@ export class HashMap {
     delete(key) {
 
         const raw_hash = this.#build_key_hash(key);
-        let bin_index = this.#compute_bin_index(raw_hash);
+        let bin_index = this.compute_bin_index(raw_hash);
 
         assert.isFiniteNumber(bin_index, 'hash');
 
-        const bins = this.#bins;
-        const entries = this.#entries;
+        const bins = this.__bins;
+        const entries = this.__entries;
 
         for (; ;) {
             const bin = bins[bin_index];
@@ -623,7 +623,7 @@ export class HashMap {
                     // mark slot as removed
                     bins[bin_index] = BIN_RESERVED_VALUE_DELETED;
 
-                    this.#size--;
+                    this.__size--;
 
                     this.#update_range_for_deleted(entry_index);
 
@@ -636,7 +636,7 @@ export class HashMap {
             }
 
             // perform secondary hashing
-            bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+            bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
         }
     }
@@ -650,9 +650,9 @@ export class HashMap {
     verifyHashes(callback, thisArg) {
         let all_hashes_valid = true;
 
-        const count = this.#bin_count;
+        const count = this.__bin_count;
         for (let j = 0; j < count; j++) {
-            const bin = this.#bins[j];
+            const bin = this.__bins[j];
 
             if (bin <= BIN_RESERVED_VALUE_DELETED) {
                 // unoccupied
@@ -662,7 +662,7 @@ export class HashMap {
             /**
              * @type {HashMapEntry<K,V>}
              */
-            const entry = this.#entries[bin - ENTRY_BASE];
+            const entry = this.__entries[bin - ENTRY_BASE];
 
             //check hash
             const raw_hash = this.#build_key_hash(entry.key);
@@ -679,7 +679,7 @@ export class HashMap {
     }
 
     #grow() {
-        this.#setBinCount(this.#entries_allocated_count * 2);
+        this.#setBinCount(this.__entries_allocated_count * 2);
     }
 
 
@@ -687,17 +687,17 @@ export class HashMap {
      * Rebuild table, useful for when table is resized
      */
     rebuild() {
-        const entries_bound = this.#entries_bound;
-        const entries = this.#entries;
+        const entries_bound = this.__entries_bound;
+        const entries = this.__entries;
 
         // reset all bins
-        const bins = this.#bins;
+        const bins = this.__bins;
         bins.fill(BIN_RESERVED_VALUE_EMPTY);
 
         let written_entries = 0;
 
         for (
-            let existing_entry_index = this.#entries_start;
+            let existing_entry_index = this.__entries_start;
             existing_entry_index < entries_bound;
             existing_entry_index++
         ) {
@@ -715,11 +715,13 @@ export class HashMap {
 
             if (new_index !== existing_entry_index) {
                 // move entries to the new position, compacting holes
-                array_swap_one(entries, new_index, existing_entry_index);
+
+                entries[new_index] = entries[existing_entry_index];
             }
 
-            let bin_index = this.#compute_bin_index(hash);
+            let bin_index = this.compute_bin_index(hash);
 
+            // search for place for the entry
             for (; ;) {
                 const bin = bins[bin_index];
 
@@ -730,22 +732,22 @@ export class HashMap {
                 }
 
                 // perform secondary hashing
-                bin_index = generate_next_linear_congruential_index(bin_index, this.#bin_count_mask);
+                bin_index = generate_next_linear_congruential_index(bin_index, this.__bin_count_mask);
 
             }
         }
 
-        assert.equal(written_entries, this.#size, `live entries(=${written_entries}) should match size(=${this.#size})`);
+        assert.equal(written_entries, this.__size, `live entries(=${written_entries}) should match size(=${this.__size})`);
 
-        this.#entries_start = 0;
-        this.#entries_bound = this.#size;
-        this.#version++;
+        this.__entries_start = 0;
+        this.__entries_bound = this.__size;
+        this.__version++;
     }
 
     #count_live_entities() {
         let count = 0;
-        for (let i = this.#entries_start; i < this.#entries_bound; i++) {
-            const entry = this.#entries[i];
+        for (let i = this.__entries_start; i < this.__entries_bound; i++) {
+            const entry = this.__entries[i];
 
             if (entry.hash !== RESERVED_HASH) {
                 count++;
@@ -762,13 +764,13 @@ export class HashMap {
     forEach(callback, thisArg) {
         assert.isFunction(callback, 'callback');
 
-        const count = this.#bin_count;
-        const entries = this.#entries;
-        const bins = this.#bins;
-        const start_version = this.#version;
+        const count = this.__bin_count;
+        const entries = this.__entries;
+        const bins = this.__bins;
+        const start_version = this.__version;
 
         for (let j = 0; j < count; j++) {
-            assert.equal(start_version, this.#version, 'HashMap modified during traversal');
+            assert.equal(start_version, this.__version, 'HashMap modified during traversal');
 
             const bin = bins[j];
 
@@ -802,8 +804,8 @@ export class HashMap {
     clear() {
 
         // clear out all
-        const bins = this.#bins;
-        const count = this.#bin_count;
+        const bins = this.__bins;
+        const count = this.__bin_count;
 
         for (let i = 0; i < count; i++) {
             const bin = bins[i];
@@ -814,7 +816,7 @@ export class HashMap {
                     // occupied, move to deleted
                     const entry_index = bin - ENTRY_BASE;
 
-                    this.#deallocate(this.#entries[entry_index]);
+                    this.#deallocate(this.__entries[entry_index]);
                 }
 
                 // mark as empty
@@ -824,23 +826,23 @@ export class HashMap {
 
         }
 
-        this.#size = 0;
+        this.__size = 0;
 
-        this.#entries_start = 0;
-        this.#entries_bound = 0;
+        this.__entries_start = 0;
+        this.__entries_bound = 0;
     }
 
     * [Symbol.iterator]() {
 
-        const count = this.#bin_count;
+        const count = this.__bin_count;
 
-        const bins = this.#bins;
-        const entries = this.#entries;
+        const bins = this.__bins;
+        const entries = this.__entries;
 
-        const start_version = this.#version;
+        const start_version = this.__version;
 
         for (let j = 0; j < count; j++) {
-            assert.equal(start_version, this.#version, 'HashMap modified during traversal');
+            assert.equal(start_version, this.__version, 'HashMap modified during traversal');
 
             const bin = bins[j];
 

package/src/engine/graphics/material/manager/ManagedTexture.d.ts

@@ -1,3 +0,0 @@
-export class ManagedTexture {
-}
-//# sourceMappingURL=ManagedTexture.d.ts.map

package/src/engine/graphics/material/manager/ManagedTexture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ManagedTexture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/material/manager/ManagedTexture.js"],"names":[],"mappings":"AAAA;CAEC"}

package/src/engine/graphics/material/manager/ManagedTexture.js

@@ -1,3 +0,0 @@
-export class ManagedTexture {
-    
-}

package/src/engine/graphics/material/manager/TextureManager.d.ts

@@ -1,3 +0,0 @@
-export class TextureManager {
-}
-//# sourceMappingURL=TextureManager.d.ts.map

package/src/engine/graphics/material/manager/TextureManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/material/manager/TextureManager.js"],"names":[],"mappings":"AAAA;CAEC"}

package/src/engine/graphics/material/manager/TextureManager.js

@@ -1,3 +0,0 @@
-export class TextureManager {
-
-}