@woosh/meep-engine 2.75.7 → 2.75.8

package/build/meep.module.js

@@ -61261,46 +61261,47 @@ function heightMap2NormalMap(renderer, sampler) {
     return new Sampler2D(rgb, 3, width, height);
 }
 
-function WebGLRendererPool() {
-    this.used = new Set();
-}
+class WebGLRendererPool {
 
-WebGLRendererPool.prototype.get = function (options) {
-    const canvas = document.createElement('canvas');
-    const context = canvas.getContext('webgl2', { antialias: true });
+    used = new Set();
 
-    const renderer = new WebGLRenderer({
-        alpha: true,
-        context,
-        canvas
-    });
+    get(options) {
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('webgl2', { antialias: true });
 
-    assert.equal(renderer.domElement, canvas, 'renderer.domElement !== canvas');
+        const renderer = new WebGLRenderer({
+            alpha: true,
+            context,
+            canvas
+        });
 
-    this.used.add(renderer);
-    return renderer;
-};
+        assert.equal(renderer.domElement, canvas, 'renderer.domElement !== canvas');
 
-/**
- *
- * @param {THREE.WebGLRenderer} renderer
- * @returns {boolean}
- */
-WebGLRendererPool.prototype.release = function (renderer) {
-    if (!this.used.has(renderer)) {
-        //not from this pool
-        return false;
+        this.used.add(renderer);
+        return renderer;
     }
-    this.used.delete(renderer);
 
-    renderer.forceContextLoss();
-    renderer.dispose();
-    renderer.domElement = null;
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @returns {boolean}
+     */
+    release(renderer) {
+        if (!this.used.has(renderer)) {
+            //not from this pool
+            return false;
+        }
+        this.used.delete(renderer);
+
+        renderer.forceContextLoss();
+        renderer.dispose();
+        renderer.domElement = null;
 
-    return true;
-};
+        return true;
+    }
 
-WebGLRendererPool.global = new WebGLRendererPool();
+    static global = new WebGLRendererPool();
+}
 
 /**
  *
@@ -62970,185 +62971,6 @@ Cache.prototype.delete = Cache.prototype.remove;
  */
 Cache.prototype.has = Cache.prototype.contains;
 
-/**
- * Compute byte size of a UTF8 string
- * @param {string} value
- * @returns {number}
- */
-function string_compute_byte_size(value) {
-    const length = value.length;
-
-    let p = 0;
-
-    for (let i = 0; i < length; i++) {
-        let c = value.charCodeAt(i);
-        while (c > 0xff) {
-            p++;
-            c >>= 8;
-        }
-        p++;
-    }
-
-    return p;
-}
-
-/**
- *
- * @type {Cache<String,Sampler2D>}
- */
-const cache$1 = new Cache({
-    maxWeight: 304857600,
-    keyHashFunction: computeStringHash,
-    keyWeigher: string_compute_byte_size,
-    /**
-     *
-     * @param {Sampler2D} sampler
-     * @returns {number}
-     */
-    valueWeigher(sampler) {
-        return sampler.computeByteSize();
-    }
-});
-
-class TerrainLayer {
-    constructor() {
-        /**
-         *
-         * @type {String}
-         */
-        this.textureDiffuseURL = "";
-
-        /**
-         *
-         * @type {Sampler2D}
-         */
-        this.diffuse = Sampler2D.uint8(3, 1, 1);
-
-        /**
-         *
-         * @type {Vector2}
-         */
-        this.size = new Vector2(1, 1);
-
-        /**
-         * Additional free-form JSON metadata
-         * @type {Object}
-         */
-        this.extra = {};
-
-        /**
-         *
-         * @type {Signal}
-         */
-        this.onChanged = new Signal();
-    }
-
-    toJSON() {
-        return {
-            textureDiffuseURL: this.textureDiffuseURL,
-            size: this.size.toJSON(),
-            extra: this.extra
-        };
-    }
-
-    fromJSON({ textureDiffuseURL, size, extra = {} }) {
-        this.textureDiffuseURL = textureDiffuseURL;
-        this.size.fromJSON(size);
-        this.extra = extra;
-    }
-
-    /**
-     *
-     * @param {string} url
-     * @param {number} width
-     * @param {number} height
-     */
-    static from(url, width, height) {
-        const r = new TerrainLayer();
-
-        r.textureDiffuseURL = url;
-        r.size.set(width, height);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {TerrainLayerDescription} d
-     * @returns {TerrainLayer}
-     */
-    static fromDescription(d) {
-        return TerrainLayer.from(
-            d.diffuse,
-            d.size.x,
-            d.size.y
-        );
-    }
-
-    /**
-     *
-     * @param {AssetManager} assetManager
-     * @returns {Promise}
-     */
-    loadTextureData(assetManager) {
-
-        const path = this.textureDiffuseURL;
-
-        /**
-         *
-         * @type {Sampler2D|null}
-         */
-        const cached = cache$1.get(path);
-
-        if (cached !== null) {
-
-            console.log('Using cached terrain layer data for ', path);
-
-            this.diffuse.resize(cached.width, cached.height, false);
-
-            this.diffuse.data.set(cached.data);
-
-            this.onChanged.send0();
-
-            return Promise.resolve();
-
-        }
-
-        const assetPromise = assetManager.promise(path, GameAssetType.Image);
-
-        return assetPromise
-            .then(assert => {
-                const image = assert.create();
-
-                const source_item_size = image.itemSize;
-
-                const source_data = image.data;
-
-                // RGB
-                const destination_item_size = 3;
-
-                if (this.diffuse === null || this.diffuse.width !== image.width || this.diffuse.height !== image.height) {
-                    // loaded image does not match the side of the layer
-                    this.diffuse = Sampler2D.uint8(destination_item_size, image.width, image.height);
-                }
-
-                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
-
-                copy_Sampler2D_channel_data(source, this.diffuse);
-
-                this.onChanged.send0();
-
-                // write to cache
-                const cacheCopy = Sampler2D.uint8(destination_item_size, image.width, image.height);
-
-                cacheCopy.data.set(this.diffuse.data);
-
-                cache$1.put(path, cacheCopy);
-
-            });
-    }
-}
-
 /**
  * @template T
  * @param {T[]} array
@@ -64176,6 +63998,191 @@ function conditionEqualsStrict(v) {
     return this === v;
 }
 
+/**
+ * Compute byte size of a UTF8 string
+ * @param {string} value
+ * @returns {number}
+ */
+function string_compute_byte_size(value) {
+    const length = value.length;
+
+    let p = 0;
+
+    for (let i = 0; i < length; i++) {
+        let c = value.charCodeAt(i);
+        while (c > 0xff) {
+            p++;
+            c >>= 8;
+        }
+        p++;
+    }
+
+    return p;
+}
+
+/**
+ *
+ * @type {Cache<String,Sampler2D>}
+ */
+const cache$1 = new Cache({
+    maxWeight: 304857600,
+    keyHashFunction: computeStringHash,
+    keyWeigher: string_compute_byte_size,
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {number}
+     */
+    valueWeigher(sampler) {
+        return sampler.computeByteSize();
+    }
+});
+
+class TerrainLayer {
+
+    /**
+     *
+     * @type {String}
+     */
+    textureDiffuseURL = "";
+
+    /**
+     *
+     * @type {Sampler2D}
+     */
+    diffuse = Sampler2D.uint8(3, 1, 1);
+
+    /**
+     *
+     * @type {Vector2}
+     */
+    size = new Vector2(1, 1);
+
+    /**
+     * Additional free-form JSON metadata
+     * @type {Object}
+     */
+    extra = {};
+
+    /**
+     *
+     * @type {Signal}
+     */
+    onChanged = new Signal();
+
+
+    toJSON() {
+        return {
+            textureDiffuseURL: this.textureDiffuseURL,
+            size: this.size.toJSON(),
+            extra: this.extra
+        };
+    }
+
+    fromJSON({ textureDiffuseURL, size, extra = {} }) {
+        this.textureDiffuseURL = textureDiffuseURL;
+        this.size.fromJSON(size);
+        this.extra = extra;
+    }
+
+    /**
+     *
+     * @param {string} url
+     * @param {number} width
+     * @param {number} height
+     */
+    static from(url, width, height) {
+        const r = new TerrainLayer();
+
+        r.textureDiffuseURL = url;
+        r.size.set(width, height);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {TerrainLayerDescription} d
+     * @returns {TerrainLayer}
+     */
+    static fromDescription(d) {
+        return TerrainLayer.from(
+            d.diffuse,
+            d.size.x,
+            d.size.y
+        );
+    }
+
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @returns {Promise}
+     */
+    loadTextureData(assetManager) {
+
+        const path = this.textureDiffuseURL;
+
+        /**
+         *
+         * @type {Sampler2D|null}
+         */
+        const cached = cache$1.get(path);
+
+        if (cached !== null) {
+
+            console.log('Using cached terrain layer data for ', path);
+
+            this.diffuse.resize(cached.width, cached.height, false);
+
+            this.diffuse.data.set(cached.data);
+
+            this.onChanged.send0();
+
+            return Promise.resolve();
+
+        }
+
+        const assetPromise = assetManager.promise(path, GameAssetType.Image);
+
+        return assetPromise
+            .then(assert => {
+                const image = assert.create();
+
+                const source_item_size = image.itemSize;
+
+                const source_data = image.data;
+
+                // RGB
+                const destination_item_size = 3;
+
+                if (this.diffuse === null || this.diffuse.width !== image.width || this.diffuse.height !== image.height) {
+                    // loaded image does not match the side of the layer
+                    this.diffuse = Sampler2D.uint8(destination_item_size, image.width, image.height);
+                }
+
+                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
+
+                copy_Sampler2D_channel_data(source, this.diffuse);
+
+                this.onChanged.send0();
+
+                // write to cache
+                const cacheCopy = Sampler2D.uint8(destination_item_size, image.width, image.height);
+
+                cacheCopy.data.set(this.diffuse.data);
+
+                cache$1.put(path, cacheCopy);
+
+            });
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TerrainLayer.prototype.isTerrainLayer = true;
+
 class ScaledTextureKey {
     uri = '';
 
@@ -64430,6 +64437,7 @@ class TerrainLayers {
      */
     addLayer(layer) {
         assert.defined(layer);
+        assert.equal(layer.isTerrainLayer, true, 'layer.isTerrainLayer !== true');
 
         const index = this.layers.length;
 
@@ -88674,20 +88682,19 @@ class Graph {
  * Contains serializers for various data types as well as data upgraders which enable support for serialization format changes
  */
 class BinarySerializationRegistry {
-    constructor() {
-        /**
-         * @readonly
-         * @private
-         * @type {Map<string, Graph<BinaryClassUpgrader>>}
-         */
-        this.upgraders = new Map();
-        /**
-         * @readonly
-         * @private
-         * @type {Map<string, BinaryClassSerializationAdapter>}
-         */
-        this.serializers = new Map();
-    }
+
+    /**
+     * @readonly
+     * @private
+     * @type {Map<string, Graph<BinaryClassUpgrader>>}
+     */
+    upgraders = new Map();
+    /**
+     * @readonly
+     * @private
+     * @type {Map<string, BinaryClassSerializationAdapter>}
+     */
+    serializers = new Map();
 
     /**
      *
@@ -89506,6 +89513,30 @@ class MaterialManager {
 }
 
 class FrameBuffer {
+    /**
+     * is expected to be bound during initialization
+     * @type {WebGLRenderTarget}
+     */
+    renderTarget = null;
+
+    /**
+     * Number of users of the frame buffer
+     * @type {number}
+     */
+    referenceCount = 0;
+
+    /**
+     * Dependency frame buffers
+     * @type {string[]}
+     */
+    dependencies = [];
+
+    /**
+     * Size of the frame buffer in pixels
+     * @type {Vector2}
+     */
+    size = new Vector2(0, 0);
+
     /**
      *
      * @param {string} id
@@ -89518,29 +89549,6 @@ class FrameBuffer {
          */
         this.id = id;
 
-        /**
-         * is expected to be bound during initialization
-         * @type {WebGLRenderTarget}
-         */
-        this.renderTarget = null;
-
-        /**
-         * Number of users of the frame buffer
-         * @type {number}
-         */
-        this.referenceCount = 0;
-
-        /**
-         * Dependency frame buffers
-         * @type {string[]}
-         */
-        this.dependencies = [];
-
-        /**
-         * Size of the frame buffer in pixels
-         * @type {Vector2}
-         */
-        this.size = new Vector2(0, 0);
 
     }
 
@@ -100097,6 +100105,12 @@ ObjectPoolFactory.prototype.release = function (object) {
  * @template Key, Value
  */
 class ImmutableObjectPool {
+    /**
+     *
+     * @type {Signal<Key,Value>}
+     */
+    onRemoved = new Signal()
+
     constructor({ capacity = 100, perKeyCapacity = 10 } = {}) {
         /**
          *
@@ -100181,15 +100195,17 @@ class ImmutableObjectPool {
 
         const elements = this.data.get(key);
 
-        if (elements.length === 1) {
-            this.data.delete(key);
-        } else {
-            const i = elements.indexOf(el);
+        const i = elements.indexOf(el);
 
-            elements.splice(i, 1);
+        elements.splice(i, 1);
+
+        if (elements.length === 0) {
+            this.data.delete(key);
         }
 
         this.size--;
+
+        this.onRemoved.send2(key, el.value);
     }
 
     add(key, value) {

package/editor/ecs/component/createObjectEditor.js

@@ -1,9 +1,9 @@
+import LabelView from "../../../src/view/common/LabelView.js";
 import EmptyView from "../../../src/view/elements/EmptyView.js";
+import { createFieldEditor } from "./createFieldEditor.js";
 import { FieldDescriptor } from "./FieldDescriptor.js";
 import { FieldValueAdapter } from "./FieldValueAdapter.js";
-import { createFieldEditor } from "./createFieldEditor.js";
 import { findNearestRegisteredType } from "./findNearestRegisteredType.js";
-import LabelView from "../../../src/view/common/LabelView.js";
 
 /**
  * @template T

package/package.json

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

package/src/core/model/object/ImmutableObjectPool.js

@@ -1,10 +1,17 @@
 import { CacheElement } from "../../cache/CacheElement.js";
 import { HashMap } from "../../collection/map/HashMap.js";
+import Signal from "../../events/signal/Signal.js";
 
 /**
  * @template Key, Value
  */
 export class ImmutableObjectPool {
+    /**
+     *
+     * @type {Signal<Key,Value>}
+     */
+    onRemoved = new Signal()
+
     constructor({ capacity = 100, perKeyCapacity = 10 } = {}) {
         /**
          *
@@ -89,15 +96,17 @@ export class ImmutableObjectPool {
 
         const elements = this.data.get(key);
 
-        if (elements.length === 1) {
-            this.data.delete(key);
-        } else {
-            const i = elements.indexOf(el);
+        const i = elements.indexOf(el);
+
+        elements.splice(i, 1);
 
-            elements.splice(i, 1);
+        if (elements.length === 0) {
+            this.data.delete(key);
         }
 
         this.size--;
+
+        this.onRemoved.send2(key, el.value);
     }
 
     add(key, value) {

package/src/engine/ecs/storage/BinaryBufferDeSerializer.js

@@ -1,18 +1,16 @@
+import { assert } from "../../../core/assert.js";
 import Task from "../../../core/process/task/Task.js";
 import { TaskSignal } from "../../../core/process/task/TaskSignal.js";
-import { assert } from "../../../core/assert.js";
+import { emptyTask } from "../../../core/process/task/util/emptyTask.js";
 import { BinaryCollectionDeSerializer } from "./binary/collection/BinaryCollectionDeSerializer.js";
 import { BinaryObjectSerializationAdapter } from "./binary/object/BinaryObjectSerializationAdapter.js";
-import { emptyTask } from "../../../core/process/task/util/emptyTask.js";
 
 class BinaryBufferDeSerializer {
-    constructor() {
-        /**
-         *
-         * @type {BinarySerializationRegistry}
-         */
-        this.registry = null;
-    }
+    /**
+     *
+     * @type {BinarySerializationRegistry}
+     */
+    registry = null;
 
     /**
      *