@woosh/meep-engine 2.56.1 → 2.58.0

package/src/engine/graphics/sh3/visualise_probe.js

@@ -1,5 +1,5 @@
 import { SH3VisualisationMaterial } from "./SH3VisualisationMaterial.js";
-import EntityBuilder from "../../ecs/EntityBuilder.js";
+import Entity from "../../ecs/Entity.js";
 import { Transform } from "../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "../ecs/mesh-v2/ShadedGeometry.js";
 import { OctahedronBufferGeometry } from "three";
@@ -12,7 +12,7 @@ import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
  * @param position_offset
  * @param sh
  * @param sh_offset
- * @return {EntityBuilder}
+ * @return {Entity}
  */
 export function visualise_probe({ size = 1,shadow=false, position, position_offset = 0, sh, sh_offset = 0 }) {
 
@@ -27,7 +27,7 @@ export function visualise_probe({ size = 1,shadow=false, position, position_offs
     shadedGeometry.writeFlag(ShadedGeometryFlags.ReceiveShadow,shadow);
     shadedGeometry.writeFlag(ShadedGeometryFlags.CastShadow,shadow);
 
-    return new EntityBuilder()
+    return new Entity()
         .add(Transform.fromJSON({
             position: {
                 x: position[position_offset],

package/src/engine/graphics/shadows/testShadowMapRendering.js

@@ -33,7 +33,7 @@ import {
 import WaterSystem from "../ecs/water/WaterSystem.js";
 import Army from "../../../../../model/game/ecs/component/army/Army.js";
 import Mesh from "../ecs/mesh/Mesh.js";
-import EntityBuilder from "../../ecs/EntityBuilder.js";
+import Entity from "../../ecs/Entity.js";
 import { buildCanvasViewFromTexture } from "../render/visibility/hiz/buildCanvasViewFromTexture.js";
 import ViewportPosition from "../../ecs/gui/position/ViewportPosition.js";
 import Vector2 from "../../../core/geom/Vector2.js";
@@ -143,7 +143,7 @@ function init_shadowmap_preview(engine) {
     });
 
 
-    new EntityBuilder()
+    new Entity()
         .add(ViewportPosition.fromJSON({
             offset: new Vector2(10, 10)
         }))
@@ -165,7 +165,7 @@ async function main(engine) {
 
     const character = ecd.getAnyComponent(Army);
 
-    const entity = EntityBuilder.readFromDataset(character.entity, ecd);
+    const entity = Entity.readFromDataset(character.entity, ecd);
 
     entity.getComponent(Mesh).url = "data/models/Conqueror Mech/Conqueror Mech.gltf";
 

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/downloadSamplerAsPNG.js

@@ -1,4 +1,4 @@
-import { downloadUrlAsFile } from "../../../../core/binary/ByteArrayTools.js";
+import { downloadUrlAsFile } from "../../../../core/binary/downloadUrlAsFile.js";
 import { convertSampler2D2DataURL } from "./convertSampler2D2DataURL.js";
 
 /**

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/texture/sprite/prototypeSpriteCutoutGeometry.js

@@ -2,7 +2,7 @@ import { EngineHarness } from "../../../EngineHarness.js";
 import GUIElementSystem from "../../../ecs/gui/GUIElementSystem.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import EmptyView from "../../../../view/elements/EmptyView.js";
-import EntityBuilder from "../../../ecs/EntityBuilder.js";
+import Entity from "../../../ecs/Entity.js";
 import GUIElement from "../../../ecs/gui/GUIElement.js";
 import ViewportPositionSystem from "../../../ecs/gui/position/ViewportPositionSystem.js";
 import { CanvasView } from "../../../../view/elements/CanvasView.js";
@@ -193,7 +193,7 @@ async function main(engine) {
 
     vContainer.addChild(vOptimalPoly);
 
-    new EntityBuilder()
+    new Entity()
         .add(GUIElement.fromView(vContainer))
         .add(new ViewportPosition({
             offset: new Vector2(100, 100)

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/input/ecs/controllers/KeyboardCameraController.js

@@ -5,7 +5,7 @@
 
 import Vector2 from '../../../../core/geom/Vector2.js';
 import Script from '../../../ecs/components/Script.js';
-import EntityBuilder from '../../../ecs/EntityBuilder.js';
+import Entity from '../../../ecs/Entity.js';
 import InputController from '../components/InputController.js';
 import { assert } from "../../../../core/assert.js";
 import { Tag } from "../../../ecs/components/Tag.js";
@@ -105,7 +105,7 @@ class KeyboardCameraController {
             controller.target.add(v3);
         });
 
-        const builder = new EntityBuilder();
+        const builder = new Entity();
 
         this.builder = builder
             .add(inputController)

package/src/engine/input/ecs/util/TopDownCameraControllerHelper.js

@@ -4,7 +4,7 @@
 import { Transform } from '../../../ecs/transform/Transform.js';
 import Renderable from '../../../ecs/renderable/Renderable.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
-import EntityBuilder from '../../../ecs/EntityBuilder.js';
+import Entity from '../../../ecs/Entity.js';
 import { Group as ThreeGroup, Matrix4 as ThreeMatrix4, Mesh as ThreeMesh, MeshLambertMaterial } from 'three';
 
 
@@ -62,7 +62,7 @@ const TopDownCameraControllerHelper = function (targetController, targetTransfor
     group.add(tMarkerTo);
 
 
-    const builder = new EntityBuilder();
+    const builder = new Entity();
     const transform = new Transform();
     builder.add(new Renderable(group))
         .add(transform);