@woosh/meep-engine 2.33.38 → 2.33.42

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

@@ -0,0 +1,99 @@
+import { Cache } from "../../../../core/cache/Cache.js";
+import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
+
+/**
+ * 4Mb
+ * @type {number}
+ */
+const DEFAULT_CACHE_SIZE = 4194304;
+
+export class CachingTextureAtlas extends AbstractTextureAtlas {
+    /**
+     *
+     * @param {AbstractTextureAtlas} atlas
+     * @param {number} cache_size
+     */
+    constructor({
+                    atlas,
+                    cache_size = DEFAULT_CACHE_SIZE
+                }) {
+        super();
+
+        /**
+         *
+         * @type {Cache<Sampler2D, AtlasPatch>}
+         * @private
+         */
+        this.__cached_patches = new Cache({
+            maxWeight: cache_size,
+            keyWeigher(sampler) {
+                return sampler.computeByteSize();
+            }
+        });
+
+        /**
+         *
+         * @type {TextureAtlas}
+         * @private
+         */
+        this.__atals = atlas;
+
+        this.__cached_patches.onEvicted.add(this.__handle_cache_eviction, this);
+    }
+
+    /**
+     *
+     * @returns {AbstractTextureAtlas}
+     */
+    get atlas() {
+        return this.__atals;
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {AtlasPatch} patch
+     * @private
+     */
+    __handle_cache_eviction(sampler, patch) {
+        this.__atals.remove(patch);
+    }
+
+    reset() {
+        this.__cached_patches.drop();
+        this.__atals.reset();
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {AtlasPatch}
+     */
+    add(sampler) {
+        const existing_patch = this.__cached_patches.get(sampler);
+
+        if (existing_patch !== null) {
+            // cache hit
+            return existing_patch;
+        }
+
+        return this.__atals.add(sampler);
+    }
+
+    /**
+     *
+     * @param {AtlasPatch} patch
+     */
+    remove(patch) {
+
+        // validate presence of patch in the atlas
+        if (!this.__atals.contains(patch)) {
+            return false;
+        }
+
+        // push to cache, let eviction logic handle the rest
+        this.__cached_patches.put(patch.sampler, patch);
+
+        return true;
+    }
+}

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

@@ -1,14 +1,12 @@
 import { TextureAtlas } from "./TextureAtlas.js";
 import { ReferenceManager } from "../../../reference/v1/ReferenceManager.js";
 import { Sampler2D } from "../sampler/Sampler2D.js";
-import { Cache } from "../../../../core/cache/Cache.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { HashMap } from "../../../../core/collection/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";
-
-const CACHE_SIZE = 4194304;
+import { CachingTextureAtlas } from "./CachingTextureAtlas.js";
 
 export class ManagedAtlas {
     /**
@@ -26,28 +24,20 @@ export class ManagedAtlas {
 
         /**
          *
-         * @type {TextureAtlas}
+         * @type {WeakMap<string, Sampler2D>}
+         * @private
          */
-        this.atlas = atlas;
+        this.__cached_samplers = new Map();
+        const cached_samplers = this.__cached_samplers;
 
+        const cached_atlas = new CachingTextureAtlas({ atlas });
+        this.__caching_atlas = cached_atlas;
 
         /**
          *
-         * @type {Cache<String, AtlasPatch>}
+         * @type {TextureAtlas}
          */
-        const patchesInactive = new Cache({
-            maxWeight: CACHE_SIZE,
-            keyHashFunction: computeStringHash,
-            keyEqualityFunction: strictEquals,
-            valueWeigher(patch) {
-                return patch.sampler.data.length;
-            }
-        });
-
-        // watch for patches being removed
-        patchesInactive.onRemoved.add((key, value) => {
-            atlas.remove(value);
-        });
+        this.atlas = atlas;
 
         /**
          *
@@ -64,19 +54,12 @@ export class ManagedAtlas {
          */
         this.patchesActive = activePatches;
 
-        /**
-         * @private
-         * @type {Cache<String, AtlasPatch>}
-         */
-        this.patchesInactive = patchesInactive;
-
         /**
          * Automatically update TextureAtlas
          * @type {boolean}
          */
         this.autoUpdate = true;
 
-
         this.rebuildDelay = 200; //in milliseconds
 
         let counterLoadingAssets = 0;
@@ -97,7 +80,7 @@ export class ManagedAtlas {
 
         /**
          *
-         * @param {String} url
+         * @param {string} url
          * @returns {Promise<AtlasPatch>}
          */
         function creator(url) {
@@ -110,14 +93,10 @@ export class ManagedAtlas {
                     return;
                 }
 
-                patch = patchesInactive.get(url);
-
-                if (patch !== null) {
-                    //move to active
-                    patchesInactive.silentRemove(url);
-
-                    activePatches.set(url, patch);
+                const cached_sampler = cached_samplers.get(url);
 
+                if (cached_sampler !== undefined) {
+                    patch = cached_atlas.add(cached_sampler);
                     resolve(patch);
                     return;
                 }
@@ -154,7 +133,10 @@ export class ManagedAtlas {
                         sampler = source;
                     }
 
-                    const patch = atlas.add(sampler);
+                    cached_samplers.set(url, sampler);
+
+
+                    const patch = cached_atlas.add(sampler);
 
                     //record active patch
                     activePatches.set(url, patch);
@@ -197,8 +179,7 @@ export class ManagedAtlas {
                     //remove from active
                     activePatches.delete(url);
 
-                    //put into inactive set
-                    patchesInactive.put(url, patch);
+                    self.__caching_atlas.remove(patch);
                 }
             });
         }
@@ -218,8 +199,7 @@ export class ManagedAtlas {
 
     reset() {
         this.references.reset();
-        this.atlas.reset();
-        this.patchesInactive.drop();
+        this.__caching_atlas.reset();
         this.patchesActive.clear();
     }
 

package/engine/graphics/texture/atlas/ReferencedTextureAtlas.js

@@ -0,0 +1,75 @@
+import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
+import { Reference } from "../../../reference/v2/Reference.js";
+
+export class ReferencedTextureAtlas extends AbstractTextureAtlas {
+    /**
+     *
+     * @param {AbstractTextureAtlas} atlas
+     */
+    constructor(atlas) {
+        super();
+
+        this.__atlas = atlas;
+
+        /**
+         *
+         * @type {Map<Sampler2D, AtlasPatch>}
+         * @private
+         */
+        this.__patches = new Map();
+        /**
+         *
+         * @type {Map<AtlasPatch, number>}
+         * @private
+         */
+        this.__ref_counts = new Map();
+
+    }
+
+    /**
+     *
+     * @param {Reference} ref
+     * @param {AtlasPatch} patch
+     * @private
+     */
+    __handle_ref_release(ref, patch) {
+        const ref_counts = this.__ref_counts;
+
+        const ref_count = ref_counts.get(patch);
+        ref_counts.set(patch, ref_count - 1);
+
+        if (ref_count === 1) {
+            // clear patch
+            this.__atlas.remove(patch);
+        }
+    }
+
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {Reference<AtlasPatch>}
+     */
+    acquire(sampler) {
+
+        let patch = this.__patches.get(sampler);
+
+        const ref_counts = this.__ref_counts;
+
+        const atlas = this.__atlas;
+
+        if (patch === undefined) {
+            patch = atlas.add(sampler);
+            ref_counts.set(patch, 1)
+        } else {
+            ref_counts.set(patch, ref_counts.get(patch) + 1);
+        }
+
+        const ref = new Reference();
+        ref.bind(patch);
+
+        ref.onReleased.add(this.__handle_ref_release, this);
+
+        return ref;
+    }
+}

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

@@ -11,8 +11,9 @@ import { assert } from "../../../../core/assert.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 import { invokeObjectClone } from "../../../../core/model/ObjectUtils.js";
+import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
 
-export class TextureAtlas {
+export class TextureAtlas extends AbstractTextureAtlas {
     /**
      *
      * @param {number} [size]
@@ -20,6 +21,8 @@ export class TextureAtlas {
      * @constructor
      */
     constructor(size = 16, data_type = DataType.Uint8) {
+        super();
+
         /**
          *
          * @type {IdPool}
@@ -68,6 +71,23 @@ export class TextureAtlas {
         this.__needsUpdate = false;
     }
 
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {AtlasPatch|undefined}
+     */
+    getPatch(sampler) {
+        const patches = this.patches;
+        const patch_count = patches.length;
+        for (let i = 0; i < patch_count; i++) {
+            const patch = patches[i];
+
+            if (patch.sampler === sampler) {
+                return patch;
+            }
+        }
+    }
+
     /**
      * Whether or not current state of atlas requires calling {#update}
      * @returns {boolean}
@@ -222,7 +242,7 @@ export class TextureAtlas {
     /**
      *
      * @param {Sampler2D} sampler
-     * @param {number} padding
+     * @param {number} [padding]
      * @return {AtlasPatch}
      */
     add(sampler, padding = 4) {

package/engine/reference/v2/Reference.d.ts

@@ -1,4 +1,8 @@
+import Signal from "../../../core/events/signal/Signal";
+
 export class Reference<T> {
+    readonly onReleased: Signal<Reference<T>, T>
+
     getValue(): T | null
 
     release(): void

package/engine/reference/v2/Reference.js

@@ -73,12 +73,14 @@ export class Reference {
             return;
         }
 
+        const v = this.__value;
+
         // prevent further usage of the reference
         this.__value = null;
 
         this.__is_bound = false;
 
-        this.__onReleased.send1(this);
+        this.__onReleased.send2(this,v);
     }
 }
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.38",
+  "version": "2.33.42",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",