@woosh/meep-engine 2.82.0 → 2.84.0

package/build/meep.module.js

@@ -85688,6 +85688,12 @@ class RingBuffer {
      * @param {number} new_size
      */
     resize(new_size) {
+
+        if (new_size === this.size) {
+            // already the right size
+            return;
+        }
+
         const array = new Array(new_size);
 
         this.data = array;

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.82.0",
+  "version": "2.84.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/RingBuffer.js

@@ -48,6 +48,12 @@ export class RingBuffer {
      * @param {number} new_size
      */
     resize(new_size) {
+
+        if (new_size === this.size) {
+            // already the right size
+            return;
+        }
+
         const array = new Array(new_size);
 
         this.data = array;

package/src/engine/graphics/ecs/decal/v2/FPDecalSystem.js

@@ -6,9 +6,10 @@ import { bvh_query_leaves_ray } from "../../../../../core/bvh2/bvh3/query/bvh_qu
 import {
     bvh_query_user_data_overlaps_frustum
 } from "../../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
-import { AsyncLoadingCache } from "../../../../../core/collection/map/AsyncLoadingCache.js";
+import { LoadingCache } from "../../../../../core/cache/LoadingCache.js";
 
 import { returnTrue } from "../../../../../core/function/returnTrue.js";
+import { strictEquals } from "../../../../../core/function/strictEquals.js";
 import { aabb3_matrix4_project } from "../../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import { aabb3_raycast } from "../../../../../core/geom/3d/aabb/aabb3_raycast.js";
 import {
@@ -17,6 +18,7 @@ import {
 import { ray3_array_apply_matrix4 } from "../../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
 import { ray3_array_compose } from "../../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
+import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
 import { AssetManager } from "../../../../asset/AssetManager.js";
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { AbstractContextSystem } from "../../../../ecs/system/AbstractContextSystem.js";
@@ -241,15 +243,19 @@ export class FPDecalSystem extends AbstractContextSystem {
 
         /**
          *
-         * @type {Map<string, Sampler2D>}
+         * @type {LoadingCache<string, Sampler2D>}
          * @private
          */
-        this.__texture_cache = new AsyncLoadingCache(new Map(), (key) => {
-            return this.__assets.promise(key, GameAssetType.Image).then(asset => {
-                const asset_sampler = asset.create();
+        this.__texture_cache = new LoadingCache({
+            load: (key) => {
+                return this.__assets.promise(key, GameAssetType.Image).then(asset => {
+                    const asset_sampler = asset.create();
 
-                return sampler2d_ensure_uint8_RGBA(asset_sampler);
-            });
+                    return sampler2d_ensure_uint8_RGBA(asset_sampler);
+                });
+            },
+            keyHashFunction: computeStringHash,
+            keyEqualityFunction: strictEquals
         });
 
         /**

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

@@ -1,50 +0,0 @@
-import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
-
-/**
- * Cache wrapper that loads data when it's not found in the cache
- * @deprecated prefer to use {@link LoadingCache} instead
- */
-export class AsyncLoadingCache extends AbstractAsyncMap {
-    /**
-     *
-     * @param {Map} cache
-     * @param {function(K):Promise<T>} loader
-     */
-    constructor(cache, loader) {
-        super();
-
-        this.__cache = cache;
-        this.__loader = loader;
-        this.__pending = new Map();
-    }
-
-    async get(key) {
-
-        const cached = this.__cache.get(key);
-
-        if (cached !== undefined) {
-            return cached;
-        }
-
-        let promise = this.__pending.get(key);
-        let original_loader = false;
-
-        if (promise === undefined) {
-            promise = this.__loader(key);
-
-            this.__pending.set(key, promise);
-
-            original_loader = true;
-        }
-
-        const value = await promise;
-
-        if (original_loader) {
-            this.__cache.set(key, value);
-            // remove from pending
-            this.__pending.delete(key);
-        }
-
-        return value;
-    }
-}

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

@@ -1,358 +0,0 @@
-import { assert } from "../../assert.js";
-import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
-import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
-
-/**
- * @template Key,Value
- */
-export class AsyncRemoteHashMap extends AbstractAsyncMap {
-
-    /**
-     *
-     * @param keyHashFunction
-     * @param keyEqualityFunction
-     * @param {BinaryClassSerializationAdapter} keySerializationAdapter
-     * @param {BinaryClassSerializationAdapter} valueSerializationAdapter
-     * @param storageKeyPrefix
-     * @param {Storage} storage
-     */
-    constructor({
-                    keyHashFunction,
-                    keyEqualityFunction,
-                    keySerializationAdapter,
-                    valueSerializationAdapter,
-                    storageKeyPrefix,
-                    storage
-                }) {
-        super();
-
-        assert.isString(storageKeyPrefix, 'storageKeyPrefix');
-
-        this._keyHashFunction = keyHashFunction;
-        this._keyEqualityFunction = keyEqualityFunction;
-        this._keySerializationAdapter = keySerializationAdapter;
-        this._valueSerializationAdapter = valueSerializationAdapter;
-        this._storageKeyPrefix = storageKeyPrefix;
-        this._storage = storage;
-
-        /**
-         *
-         * @type {Map<number,Promise>}
-         * @private
-         */
-        this._bucket_locks = new Map();
-    }
-
-    /**
-     *
-     * @param {Storage} storage
-     */
-    attach_storage(storage) {
-        this._storage = storage;
-    }
-
-    detach_storage() {
-        this._storage = null;
-    }
-
-    async __get_bucket_lock(hash) {
-        let source_lock = this._bucket_locks.get(hash);
-        if (source_lock === undefined) {
-            source_lock = Promise.resolve();
-        }
-
-        let is_resolved = false;
-        const lock_object = {
-            release() {
-                is_resolved = true;
-            }
-        };
-
-        const release_promise = new Promise((resolve, reject) => {
-            lock_object.release = resolve;
-
-            if (is_resolved) {
-                resolve();
-            }
-        });
-
-        const new_lock = source_lock.then(() => release_promise);
-
-        this._bucket_locks.set(hash, new_lock);
-
-        await source_lock;
-
-        return lock_object;
-    }
-
-    /**
-     * @param {number} hash
-     * @return {Promise<ArrayBuffer|undefined>}
-     * @private
-     */
-    __get_bucket_binary(hash) {
-        return this._storage.promiseLoadBinary(this.__compute_bucket_storage_key(hash)).catch(() => {
-            return undefined;
-        });
-    }
-
-    __compute_bucket_storage_key(hash) {
-        return `${this._storageKeyPrefix}/${hash}`;
-    }
-
-    /**
-     *
-     * @param {number} hash
-     * @param {ArrayBuffer} bucket
-     * @return {Promise}
-     * @private
-     */
-    __set_bucket_binary(hash, bucket) {
-        return this._storage.promiseStoreBinary(this.__compute_bucket_storage_key(hash), bucket);
-    }
-
-    /**
-     *
-     * @param {Key} key
-     * @param {Value|undefined} value
-     * @param {ArrayBuffer} buffer
-     * @return {ArrayBuffer}
-     * @private
-     */
-    __set_value_by_key_in_bucket(key, value, buffer) {
-        const source = new BinaryBuffer();
-        source.fromArrayBuffer(buffer);
-
-        const record_count = buffer.byteLength >= 2 ? source.readUint16() : 0;
-
-        let new_record_count = record_count;
-
-        // first attempt to find the key
-        const existing_value_address = this.__get_value_offset_from_bucket_by_key(key, buffer);
-
-        if (existing_value_address === -1) {
-            new_record_count++;
-        }
-
-        const destination = new BinaryBuffer();
-        destination.writeUint16(new_record_count);
-
-        let destination_data_offset = 2 + 16 * new_record_count;
-        let write_cursor = 0;
-        // copy old record over
-        for (let i = 0; i < record_count; i++) {
-            source.position = 2 + i * 16;
-
-            const key_position = source.readUint32();
-            const key_length = source.readUint32();
-            const value_position = source.readUint32();
-            const value_length = source.readUint32();
-
-            if (existing_value_address !== -1 && value_position === existing_value_address) {
-                // skip
-                continue;
-            }
-
-            // write key + value
-            destination.position = 2 + write_cursor * 16;
-
-            // write header section
-            destination.writeUint32(destination_data_offset);
-            destination.writeUint32(key_length);
-            destination.writeUint32(destination_data_offset + key_length);
-            destination.writeUint32(value_length);
-
-            destination.position = destination_data_offset;
-            source.position = key_position;
-            BinaryBuffer.copyBytes(source, destination, key_length);
-
-            destination_data_offset += key_length;
-
-            destination.position = destination_data_offset;
-            source.position = value_position;
-            BinaryBuffer.copyBytes(source, destination, value_length);
-
-            destination_data_offset += value_length;
-
-            write_cursor++;
-        }
-
-        const inserted_key_address = destination_data_offset;
-        const inserted_key_length = this.__encode_object(destination, inserted_key_address, key, this._keySerializationAdapter);
-
-        destination_data_offset += inserted_key_length;
-        const inserted_value_address = destination_data_offset;
-        const inserted_value_length = this.__encode_object(destination, inserted_value_address, value, this._valueSerializationAdapter);
-
-
-        // write section for the new value
-        destination.position = 2 + 16 * write_cursor;
-        destination.writeUint32(inserted_key_address);
-        destination.writeUint32(inserted_key_length);
-        destination.writeUint32(inserted_value_address);
-        destination.writeUint32(inserted_value_length);
-
-        // restore position
-        destination.position = inserted_value_address + inserted_value_length;
-
-        destination.trim();
-
-        return destination.data;
-    }
-
-    /**
-     *
-     * @param {Key} key
-     * @param {ArrayBuffer} buffer
-     * @return {number} -1 if not found, otherwise address within the buffer where the value can be read
-     * @private
-     */
-    __get_value_offset_from_bucket_by_key(key, buffer) {
-        const binary = new BinaryBuffer();
-        binary.fromArrayBuffer(buffer);
-
-        if (binary.length < 2) {
-            return -1;
-        }
-
-        const record_count = binary.readUint16();
-
-        if (record_count === 0) {
-            return -1;
-        }
-
-        const key_offsets = new Uint32Array(record_count);
-        const value_offsets = new Uint32Array(record_count);
-
-        // read record offsets
-        for (let i = 0; i < record_count; i++) {
-            const key_offset = binary.readUint32();
-            const key_length = binary.readUint32();
-
-            const value_offset = binary.readUint32();
-            const value_length = binary.readUint32();
-
-            key_offsets[i] = key_offset;
-            value_offsets[i] = value_offset;
-        }
-
-        // read key
-        for (let i = 0; i < record_count; i++) {
-            const key_address = key_offsets[i];
-
-            const stored_key = this.__decode_object(binary, key_address, this._keySerializationAdapter);
-
-            if (this._keyEqualityFunction(stored_key, key)) {
-                return value_offsets[i]
-            }
-        }
-
-        return -1;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {number} address
-     * @param {BinaryClassSerializationAdapter} adapter
-     * @return {Value}
-     * @private
-     */
-    __decode_object(buffer, address, adapter) {
-
-        buffer.position = address;
-
-        const ValueKlass = adapter.getClass();
-
-        const value = new ValueKlass();
-
-        adapter.deserialize(buffer, value);
-
-        return value;
-    }
-
-    /**
-     * @template T
-     * @param {BinaryBuffer} buffer
-     * @param {number} address
-     * @param {T} value
-     * @param {BinaryClassSerializationAdapter} adapter
-     * @returns {number} bytes written
-     * @private
-     */
-    __encode_object(buffer, address, value, adapter) {
-        buffer.position = address;
-
-        adapter.serialize(buffer, value);
-
-        const bytes_written = buffer.position - address;
-
-        return bytes_written;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {number} address
-     * @return {Value}
-     * @private
-     */
-    __decode_value(buffer, address) {
-        return this.__decode_object(buffer, address, this._valueSerializationAdapter);
-    }
-
-    /**
-     *
-     * @param {Key} key
-     * @return {Promise<Value|undefined>}
-     */
-    async get(key) {
-        // hash the key to identify bucket to load
-        const key_hash = this._keyHashFunction(key);
-
-        const lock = await this.__get_bucket_lock(key_hash);
-
-        const bucket_buffer = await this.__get_bucket_binary(key_hash);
-
-        lock.release();
-
-        if (bucket_buffer === undefined) {
-            return;
-        }
-
-        const value_address = this.__get_value_offset_from_bucket_by_key(key, bucket_buffer);
-
-        if (value_address === -1) {
-            return;
-        }
-
-        const binary = new BinaryBuffer();
-        binary.fromArrayBuffer(bucket_buffer);
-
-        return this.__decode_value(binary, value_address);
-    }
-
-    /**
-     *
-     * @param {Key} key
-     * @param {Value} value
-     * @return {Promise<void>}
-     */
-    async set(key, value) {
-        const key_hash = this._keyHashFunction(key);
-
-        const lock = await this.__get_bucket_lock(key_hash);
-
-        let bucket_buffer = await this.__get_bucket_binary(key_hash);
-
-        if (bucket_buffer === undefined) {
-            bucket_buffer = new ArrayBuffer(0);
-        }
-
-        const updated_buffer = this.__set_value_by_key_in_bucket(key, value, bucket_buffer);
-
-        await this.__set_bucket_binary(key_hash, updated_buffer);
-
-        lock.release();
-    }
-}

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

@@ -1,43 +0,0 @@
-import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
-
-/**
- * Two-tier key-value storage. Intended to accelerate slow asynchronous
- * storage with a fast but limited (in space and reliability) cache in front.
- *
- * First tier (volatile) is considered to be fast an unreliable,
- * whereas second tier (persisted) is considered to be reliable, but slow.
- */
-export class CachedAsyncMap extends AbstractAsyncMap {
-    /**
-     *
-     * @param {AbstractAsyncMap} volatile data here may be lost at any point, this is our "cache"
-     * @param {AbstractAsyncMap} persisted data here is stored reliably
-     */
-    constructor(volatile, persisted) {
-        super();
-
-        this.__volatile = volatile;
-        this.__persisted = persisted;
-    }
-
-    async get(key) {
-        const volatile_value = await this.__volatile.get(key);
-
-        if (volatile_value !== undefined && volatile_value !== null) {
-            return volatile_value;
-        }
-
-        // TODO re-insert into volatile if persisted has a hit
-
-        return await this.__persisted.get(key);
-    }
-
-    async set(key, value) {
-        const lock = this.__volatile.set(key, value);
-
-        // don't wait for completion on persisted
-        this.__persisted.set(key, value);
-
-        await lock;
-    }
-}

package/src/core/collection/map/CachedAsyncMap.spec.js

@@ -1,47 +0,0 @@
-import { CachedAsyncMap } from "./CachedAsyncMap.js";
-import { AsyncMapWrapper } from "./AsyncMapWrapper.js";
-
-test("'get' retrieves data if it is available in volatile level", async () => {
-
-    const first = new Map();
-
-    const sut = new CachedAsyncMap(new AsyncMapWrapper(first), new AsyncMapWrapper());
-
-    first.set(1, 3);
-
-    expect(await sut.get(1)).toBe(3);
-});
-
-test("'get' retrieves data if it is available in persisted level", async () => {
-
-    const second = new Map();
-
-    const sut = new CachedAsyncMap(new AsyncMapWrapper(), new AsyncMapWrapper(second));
-
-    second.set(1, 3);
-
-    expect(await sut.get(1)).toBe(3);
-});
-
-test("'set' propagates data into volatile level", async () => {
-
-    const first = new Map();
-
-    const sut = new CachedAsyncMap(new AsyncMapWrapper(first), new AsyncMapWrapper());
-
-    await sut.set(1, 3);
-
-    expect(first.get(1)).toBe(3);
-});
-
-
-test("'set' propagates data into persisted level", async () => {
-
-    const second = new Map();
-
-    const sut = new CachedAsyncMap(new AsyncMapWrapper(), new AsyncMapWrapper(second));
-
-    await sut.set(1, 3);
-
-    expect(second.get(1)).toBe(3);
-});