@woosh/meep-engine 2.75.6 → 2.75.8

package/build/meep.cjs

@@ -61263,46 +61263,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();
+}
 
 /**
  *
@@ -62972,185 +62973,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
@@ -64178,6 +64000,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 = '';
 
@@ -64432,6 +64439,7 @@ class TerrainLayers {
      */
     addLayer(layer) {
         assert.defined(layer);
+        assert.equal(layer.isTerrainLayer, true, 'layer.isTerrainLayer !== true');
 
         const index = this.layers.length;
 
@@ -88676,20 +88684,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();
 
     /**
      *
@@ -89508,6 +89515,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
@@ -89520,29 +89551,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);
 
     }
 
@@ -100099,6 +100107,12 @@ ObjectPoolFactory.prototype.release = function (object) {
  * @template Key, Value
  */
 class ImmutableObjectPool {
+    /**
+     *
+     * @type {Signal<Key,Value>}
+     */
+    onRemoved = new Signal()
+
     constructor({ capacity = 100, perKeyCapacity = 10 } = {}) {
         /**
          *
@@ -100183,15 +100197,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) {