@woosh/meep-engine 2.56.0 → 2.57.0

package/src/engine/graphics/texture/atlas/AbstractTextureAtlas.js

@@ -2,7 +2,7 @@ export class AbstractTextureAtlas {
     /**
      *
      * @param {Sampler2D} sampler
-     * @param {number} padding
+     * @param {number} [padding]
      * @returns {AtlasPatch}
      */
     add(sampler, padding) {

package/src/engine/graphics/texture/atlas/AtlasPatch.js

@@ -47,7 +47,6 @@ export class AtlasPatch {
          * Used for packing inside TextureAtlas.
          * Do not modify manually
          * @readonly
-         * @protected
          * @type {AABB2}
          */
         this.packing = new AABB2();

package/src/engine/graphics/texture/atlas/AtlasPatchFlag.js

@@ -3,5 +3,12 @@
  */
 export const AtlasPatchFlag = {
     Packed: 1,
-    Painted: 2
+    /**
+     * Set when patch is drawn into the atlas, cleared when it's not
+     */
+    Painted: 2,
+    /**
+     * Set when patch is added to an atlas and clear when it is removed
+     */
+    Attached: 4
 };

package/src/engine/graphics/texture/atlas/CachingTextureAtlas.js

@@ -249,6 +249,24 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
         return -1;
     }
 
+    /**
+     *
+     * @param {AtlasPatch} patch
+     * @returns {number}
+     * @private
+     */
+    __find_cache_record_index_by_patch(patch) {
+        const records = this.__cached_patches;
+        const n = records.length;
+        for (let i = 0; i < n; i++) {
+            if (records[i].patch === patch) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
     add(sampler, padding = 4) {
         const existing_patch_index = this.__find_cache_record_index(sampler);
 
@@ -289,6 +307,13 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
             return false;
         }
 
+        const index = this.__find_cache_record_index_by_patch(patch);
+
+        if (index !== -1) {
+            // already in the cache
+            return false;
+        }
+
         // push to cache, let eviction logic handle the rest
         const record = new PatchRecord();
 

package/src/engine/graphics/texture/atlas/CachingTextureAtlas.spec.js

@@ -22,3 +22,57 @@ test("add one", () => {
     expect(atlas.contains(patch)).toBe(true);
 
 });
+
+test("remove one", () => {
+
+    const atlas = new TextureAtlas();
+    const cached = new CachingTextureAtlas({ atlas });
+
+    const s = Sampler2D.uint8(4, 1, 1);
+
+    const patch = cached.add(s, 0);
+
+    expect(cached.remove(patch)).toBe(true);
+
+    // should stay cached
+    expect(atlas.contains(patch)).toBe(true);
+
+    // cache should tell us that patch is already removed
+    expect(cached.remove(patch)).toBe(false);
+
+});
+
+test("add patch that was already in the cache", () => {
+
+    const atlas = new TextureAtlas();
+    const cached = new CachingTextureAtlas({ atlas });
+
+    const s = Sampler2D.uint8(4, 1, 1);
+
+    const patch_a = cached.add(s, 0);
+
+    cached.remove(patch_a);
+
+    const patch_b = cached.add(s, 0);
+
+    expect(patch_a).toBe(patch_b);
+});
+
+test("eviction", () => {
+
+    const atlas = new TextureAtlas(1);
+    const cached = new CachingTextureAtlas({ atlas });
+
+    const sampler_a = Sampler2D.uint8(4, 1, 1);
+
+    const patch_a = cached.add(sampler_a, 0);
+
+    cached.remove(patch_a);
+    cached.update();
+
+    const sampler_b = Sampler2D.uint8(4, 1, 1);
+
+    const patch_b = cached.add(sampler_b, 0);
+
+    expect(atlas.contains(patch_a)).toBe(false);
+});

package/src/engine/graphics/texture/atlas/ManagedTextureAtlas.js

@@ -1,20 +1,56 @@
 import { TextureAtlas } from "./TextureAtlas.js";
-import { ReferenceManager } from "../../../reference/v1/ReferenceManager.js";
-import { Sampler2D } from "../sampler/Sampler2D.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
-import { HashMap } from "../../../../core/collection/map/HashMap.js";
 import { strictEquals } from "../../../../core/function/Functions.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
-import { copy_Sampler2D_channel_data } from "../sampler/copy_Sampler2D_channel_data.js";
 import { CachingTextureAtlas } from "./CachingTextureAtlas.js";
+import { Reference } from "../../../reference/v2/Reference.js";
+import { LoadingCache } from "../../../../core/cache/LoadingCache.js";
+import { Sampler2D } from "../sampler/Sampler2D.js";
+import { sampler2d_ensure_uint8_RGBA } from "../sampler/sampler2d_ensure_uint8_RGBA.js";
 
 export class ManagedAtlas {
+
+    /**
+     *
+     * @type {AssetManager|null}
+     */
+    #assets = null;
+
+    /**
+     *
+     * @type {Map<string, Reference>}
+     */
+    #references = new Map();
+
+    /**
+     * Pixel padding
+     * @type {number}
+     */
+    #padding = 4;
+
+    /**
+     * @type {LoadingCache<string, AtlasPatch>}
+     */
+    #patch_loader;
+
+    /**
+     *
+     * @type {Map<string, AtlasPatch>}
+     */
+    #url_patch_lookup = new Map();
+    /**
+     *
+     * @type {Map<AtlasPatch,string[]>}
+     */
+    #patch_url_lookup = new Map();
+
     /**
      *
      * @param {AssetManager} assetManager
      * @constructor
      */
     constructor(assetManager) {
+        this.#assets = assetManager;
 
         /**
          * pre-allocate space on the atlas to avoid some initial re-sizing
@@ -22,16 +58,8 @@ export class ManagedAtlas {
          */
         const atlas = new TextureAtlas(64);
 
-        /**
-         *
-         * @type {WeakMap<string, Sampler2D>}
-         * @private
-         */
-        this.__cached_samplers = new Map();
-        const cached_samplers = this.__cached_samplers;
 
-        const cached_atlas = new CachingTextureAtlas({ atlas });
-        this.__caching_atlas = cached_atlas;
+        this.__caching_atlas = new CachingTextureAtlas({ atlas });
 
         /**
          *
@@ -39,177 +67,90 @@ export class ManagedAtlas {
          */
         this.atlas = atlas;
 
-        /**
-         *
-         * @type {HashMap<String, AtlasPatch>}
-         */
-        const activePatches = new HashMap({
-            keyHashFunction: computeStringHash,
-            keyEqualityFunction: strictEquals
-        });
-
-        /**
-         * @private
-         * @type {HashMap<String, AtlasPatch>}
-         */
-        this.patchesActive = activePatches;
-
-        /**
-         * Automatically update TextureAtlas
-         * @type {boolean}
-         */
-        this.autoUpdate = true;
-
-        this.rebuildDelay = 200; //in milliseconds
+        atlas.on.removed.add(this.#remove_from_lookup, this);
 
-        let counterLoadingAssets = 0;
-        let lastRebuildTime = 0;
-
-        const self = this;
+        this.#patch_loader = new LoadingCache({
+            keyHashFunction: computeStringHash,
+            keyEqualityFunction: strictEquals,
+            load: async (url) => {
+                const sampler = await this.#resolve_texture(url);
 
-        function tryRebuild() {
-            const timeNow = Date.now();
-            const timeElapsed = timeNow - lastRebuildTime;
+                const patch = this.__caching_atlas.add(sampler, this.#padding);
 
-            if (counterLoadingAssets === 0 || timeElapsed > self.rebuildDelay) {
-                atlas.update();
+                this.#add_to_lookup(url, patch);
 
-                lastRebuildTime = timeNow;
+                return patch;
             }
-        }
-
-        /**
-         *
-         * @param {string} url
-         * @returns {Promise<AtlasPatch>}
-         */
-        function creator(url) {
-            return new Promise(function (resolve, reject) {
-
-                let patch = activePatches.get(url);
-
-                if (patch !== undefined) {
-                    resolve(patch);
-                    return;
-                }
-
-                const cached_sampler = cached_samplers.get(url);
-
-                if (cached_sampler !== undefined) {
-                    patch = cached_atlas.add(cached_sampler);
-                    resolve(patch);
-                    return;
-                }
-
-                /**
-                 *
-                 * @param {Asset} asset
-                 */
-                function onLoad(asset) {
-
-                    //since load happens asynchronously, we need to make sure that the patch is still required
-                    const refCount = referenceManager.getCount(url);
-
-                    if (refCount === 0) {
-                        //no longer part of active reference set, ignore
-                        //this happens when a patch is requested and removed before it is loaded
-                        reject(`'${url}' is no longer part of active reference set`);
-                        return;
-                    }
-
-                    const image = asset.create();
-
-                    const source = new Sampler2D(image.data, image.itemSize, image.width, image.height);
-                    //assert.equal(atlas.patches.filter(p => p.sampler.data === image.data).length, 0, "Atlas already contains this asset data");
-
-                    //build sampler
-                    let sampler;
-
-                    if (source.itemSize !== 4) {
-                        // source image is not in RGBA layout, resample
-                        sampler = Sampler2D.uint8(4, image.width, image.height);
-                        copy_Sampler2D_channel_data(source, sampler)
-                    } else {
-                        sampler = source;
-                    }
-
-                    cached_samplers.set(url, sampler);
-
-
-                    const patch = cached_atlas.add(sampler);
-
-                    //record active patch
-                    activePatches.set(url, patch);
-
-                    counterLoadingAssets--;
-
-                    if (self.autoUpdate) {
-                        tryRebuild();
-                    }
-
-                    // console.warn(`ManagedAtlas: Loaded patch. size: ${image.data.length}, width: ${image.width}, height: ${image.height}, url: ${url}`, atlas);
-
-                    resolve(patch);
-                }
-
-                function onFailure(error) {
-                    counterLoadingAssets--;
-
-                    reject(error);
-                }
-
+        });
+    }
 
-                counterLoadingAssets++;
+    /**
+     *
+     * @param {AtlasPatch} patch
+     */
+    #remove_from_lookup(patch) {
+        const urls = this.#patch_url_lookup.get(patch);
 
-                assetManager.get({ path: url, type: GameAssetType.Image, callback: onLoad, failure: onFailure });
+        for (let i = 0; i < urls.length; i++) {
+            const url = urls[i];
 
-            });
+            this.#url_patch_lookup.delete(url);
         }
+    }
 
-        /**
-         *
-         * @param {String} url
-         * @param {Promise<AtlasPatch>} promise
-         */
-        function destroyer(url, promise) {
-            promise.then(function (patch) {
-                //it is possible that promise is resolved after patch has already been removed from the Atlas, so we first check
+    /**
+     *
+     * @param {string} url
+     * @param {AtlasPatch} patch
+     */
+    #add_to_lookup(url, patch) {
 
-                if (activePatches.has(url)) {
-                    //remove from active
-                    activePatches.delete(url);
+        this.#url_patch_lookup.set(url, patch);
 
-                    self.__caching_atlas.remove(patch);
-                }
-            });
+        let urls = this.#patch_url_lookup.get(patch);
+        if (urls === undefined) {
+            urls = [];
+            this.#patch_url_lookup.set(patch, urls);
         }
+        urls.push(url);
+    }
 
-        /**
-         *
-         * @type {ReferenceManager.<String,Promise.<AtlasPatch>>}
-         */
-        const referenceManager = new ReferenceManager(creator, destroyer);
+    /**
+     *
+     * @param {string} url
+     * @returns {Promise<Sampler2D>}
+     */
+    async #resolve_texture(url) {
+        const asset = await this.#assets.promise(url, GameAssetType.Image);
+        const source = asset.create();
 
-        /**
-         *
-         * @type {ReferenceManager<String, Promise<AtlasPatch>>}
-         */
-        this.references = referenceManager;
+        return sampler2d_ensure_uint8_RGBA(source);
     }
 
     reset() {
-        this.references.reset();
+        this.#references.clear();
         this.__caching_atlas.reset();
-        this.patchesActive.clear();
+        this.#url_patch_lookup.clear();
     }
 
     /**
      *
      * @param {string} key
-     * @returns {Promise<AtlasPatch>}
+     * @returns {Promise<Reference<AtlasPatch>>}
      */
-    acquire(key) {
-        return this.references.acquire(key);
+    async acquire(url) {
+        const reference = new Reference();
+
+        let patch = this.#url_patch_lookup.get(url);
+
+        if (patch === undefined) {
+            // patch is not active, need to load it
+            patch = await this.#patch_loader.get(url);
+        }
+
+        reference.bind(patch);
+
+        return reference;
     }
 
     /**
@@ -217,6 +158,6 @@ export class ManagedAtlas {
      * @param {string} key
      */
     release(key) {
-        this.references.release(key);
+        throw  new Error('Method is deprecated, use "Reference.release" instead');
     }
 }

package/src/engine/graphics/texture/atlas/TextureAtlas.js

@@ -66,7 +66,11 @@ export class TextureAtlas extends AbstractTextureAtlas {
         this.packer = new MaxRectanglesPacker(size, size);
 
         this.on = {
-            painted: new Signal()
+            painted: new Signal(),
+            /**
+             * @type {Signal<AtlasPatch, Sampler2D>}
+             */
+            removed: new Signal()
         };
 
         /**
@@ -264,6 +268,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
 
         assert.notNull(sampler, 'sampler');
         assert.defined(sampler, 'sampler');
+        assert.equal(sampler.isSampler2D, true, 'sampler.isSampler2D !== true');
 
         assert.isNonNegativeInteger(padding, 'padding');
 
@@ -276,6 +281,9 @@ export class TextureAtlas extends AbstractTextureAtlas {
         patch.size.set(sampler.width, sampler.height);
         patch.padding = padding;
 
+        // mark patch as belonging to an atlas
+        patch.setFlag(AtlasPatchFlag.Attached);
+
         const padding2 = padding * 2;
 
         patch.packing.set(0, 0, sampler.width + padding2, sampler.height + padding2);
@@ -324,6 +332,15 @@ export class TextureAtlas extends AbstractTextureAtlas {
             this.packer.remove(patch.packing);
         }
 
+        // clear flags
+        patch.clearFlag(
+            AtlasPatchFlag.Attached
+            | AtlasPatchFlag.Packed
+            | AtlasPatchFlag.Painted
+        );
+
+        this.on.removed.send2(patch, patch.sampler);
+
         return true;
     }
 

package/src/engine/graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js

@@ -0,0 +1,22 @@
+import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_to_uint8_RGBA } from "./sampler2d_to_uint8_RGBA.js";
+
+/**
+ *
+ * @param {Sampler2D} input
+ * @returns {Sampler2D}
+ */
+export function sampler2d_ensure_uint8_RGBA(input) {
+    if (
+        input.itemSize === 4
+        && (input.data.constructor === Uint8Array || input.data.constructor === Uint8ClampedArray)
+    ) {
+        return input;
+    }
+
+    const resampled = Sampler2D.uint8(4, input.width, input.height);
+
+    sampler2d_to_uint8_RGBA(resampled, input);
+
+    return resampled;
+}

package/src/engine/graphics/util/projectSphere.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { v4_applyMatrix4 } from "../../../core/geom/Vector4.js";
-import { v3_dot } from "../../../core/geom/v3_dot.js";
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
 
 const v4 = [];
 

package/src/engine/navigation/ecs/components/Path.js

@@ -14,7 +14,7 @@ import { RowFirstTable } from "../../../../core/collection/table/RowFirstTable.j
 import { min2 } from "../../../../core/math/min2.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 import { InterpolationType } from "./InterpolationType.js";
-import { v3_distance } from "../../../../core/geom/v3_distance.js";
+import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
 import {
     line3_computeSegmentPointDistance_sqr
 } from "../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";

package/src/engine/options/OptionGroup.js

@@ -155,6 +155,16 @@ export class OptionGroup extends OptionAbstract {
 
         return p
             .then((loaded) => {
+                if (loaded === undefined) {
+                    // no loaded data, assume options are loaded for hte first time
+                    return;
+                }
+
+                if (typeof loaded !== "string") {
+                    console.error(`expected loaded options to be a string, instead was '${typeof loaded}'`);
+                    return;
+                }
+
                 group.fromJSON(JSON.parse(loaded));
             })
             .finally(() => {