@woosh/meep-engine 2.33.56 → 2.33.60

package/engine/asset/Asset.js

@@ -4,51 +4,6 @@
  * @param {string} type
  * @constructor
  */
-import { assert } from "../../core/assert.js";
-import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
-import { computeHashIntegerArray } from "../../core/collection/array/computeHashIntegerArray.js";
-
-export class AssetDescription {
-    /**
-     *
-     * @param {string} path
-     * @param {string} type
-     * @constructor
-     */
-    constructor(path, type) {
-        assert.typeOf(path, 'string', 'path');
-        assert.typeOf(type, 'string', 'type');
-
-        /**
-         * @type {string}
-         */
-        this.path = path;
-        /**
-         * @type {string}
-         */
-        this.type = type;
-    }
-
-    /**
-     *
-     * @param {AssetDescription} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.path === other.path && this.type === other.type;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    hash() {
-        return computeHashIntegerArray(
-            computeStringHash(this.path),
-            computeStringHash(this.type)
-        );
-    }
-}
 
 
 export class Asset {

package/engine/asset/AssetDescription.js

@@ -0,0 +1,51 @@
+import { assert } from "../../core/assert.js";
+import { computeHashIntegerArray } from "../../core/collection/array/computeHashIntegerArray.js";
+import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
+
+export class AssetDescription {
+    /**
+     *
+     * @param {string} path
+     * @param {string} type
+     * @constructor
+     */
+    constructor(path, type) {
+        assert.isString(path, 'path');
+        assert.isString(type, 'type');
+
+        /**
+         * @type {string}
+         */
+        this.path = path;
+        /**
+         * @type {string}
+         */
+        this.type = type;
+    }
+
+    /**
+     *
+     * @param {AssetDescription} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.path === other.path
+            && this.type === other.type
+            ;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        return computeHashIntegerArray(
+            computeStringHash(this.path),
+            computeStringHash(this.type)
+        );
+    }
+
+    toString() {
+        return `{ type: '${this.type}', path: '${this.path}' }`;
+    }
+}

package/engine/asset/AssetManager.d.ts

@@ -1,6 +1,7 @@
 import {AssetLoader} from "./loaders/AssetLoader";
 import {Asset} from "./Asset";
 import {CrossOriginConfig} from "./CORS/CrossOriginConfig";
+import {AssetTransformer} from "./AssetTransformer";
 
 export class AssetManager {
     public readonly crossOriginConfig: CrossOriginConfig
@@ -12,4 +13,10 @@ export class AssetManager {
     public clear(): void
 
     public registerLoader<T>(type: string, loader: AssetLoader<T>): Promise<void>
+
+    public unregisterLoader(type: string): Promise<void>
+
+    public registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void
+
+    public unregisterTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): boolean
 }

package/engine/asset/AssetManager.js

@@ -5,12 +5,13 @@
 
 import BoundedValue from "../../core/model/BoundedValue.js";
 import { ObservedMap } from "../../core/collection/ObservedMap.js";
-import { AssetDescription } from "./Asset.js";
 import { HashMap } from "../../core/collection/HashMap.js";
 import { extractAssetListFromManager } from "./preloader/extractAssetListFromManager.js";
 import { assert } from "../../core/assert.js";
 import { HashSet } from "../../core/collection/HashSet.js";
 import { CrossOriginConfig } from "./CORS/CrossOriginConfig.js";
+import { array_remove_element } from "../../core/collection/array/array_remove_element.js";
+import { AssetDescription } from "./AssetDescription.js";
 
 /**
  *
@@ -62,6 +63,13 @@ function AssetManager(engine) {
      */
     this.loaders = {};
 
+    /**
+     * After asset is loaded, a chain of transforms can be applied to it, these are registered here
+     * Transformers are executed in the order in which they are added
+     * @type {Object<AssetTransformer[]>}
+     */
+    this.transformers = {};
+
     /**
      * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
      * @type {Map<string, AssetDescription>}
@@ -209,7 +217,30 @@ AssetManager.prototype.submitRequest = function (path, type, request) {
     const assets = this.assets;
     const failures = this.failures;
 
-    function success(asset) {
+    /**
+     *
+     * @param {Asset} loaded_asset
+     */
+    const success = async (loaded_asset) => {
+        let asset = loaded_asset;
+
+        // apply transform chain
+        const transformers = this.transformers[type];
+        if (transformers !== undefined) {
+            const transformer_count = transformers.length;
+            for (let i = 0; i < transformer_count; i++) {
+                const transformer = transformers[i];
+
+                const transformed_asset = await transformer.transform(asset);
+
+                if (typeof transformed_asset !== "object") {
+                    console.error('Transformer produced invalid result. Ignoring result.', transformer, assetDescription);
+                } else {
+                    asset = transformed_asset;
+                }
+            }
+        }
+
         //link asset description
         asset.description = assetDescription;
 
@@ -298,6 +329,71 @@ AssetManager.prototype.getLoaderByType = function (type) {
     return this.loaders[type];
 };
 
+/**
+ *
+ * @param {string} type
+ * @return {AssetDescription[]}
+ * @private
+ */
+AssetManager.prototype.__getLoadedAssetDescriptorsByType = function (type) {
+    const loaded_assets = Array.from(this.assets.keys());
+    return loaded_assets.filter(t => t.type === type);
+}
+
+/**
+ * @template T
+ * @param {string} type
+ * @param {AssetTransformer<T>} transformer
+ */
+AssetManager.prototype.registerTransformer = function (type, transformer) {
+    let transformers = this.transformers[type];
+
+    if (transformers === undefined) {
+        transformers = [];
+
+        this.transformers[type] = transformers;
+    }
+
+    transformers.push(transformer);
+
+    // check for loaded assets
+    const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+
+    if (matching_assets.length > 0) {
+        console.warn(`Following assets of matching type '${type}' are already loaded and transform is not applied to them:\n\t${matching_assets.join('\n\t')}`);
+    }
+
+};
+
+/**
+ * @template T
+ * @param {string} type
+ * @param {AssetTransformer<T>} transformer
+ */
+AssetManager.prototype.unregisterTransformer = function (type, transformer) {
+
+    const transformers = this.transformers[type];
+
+    if (transformers === undefined) {
+        // not found
+        return false;
+    }
+
+    if (!array_remove_element(transformers, 0, transformers.length, transformer)) {
+        // not found
+        return false;
+    }
+
+    // check for loaded assets
+    const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+
+    if (matching_assets.length > 0) {
+        console.warn(`Following assets of matching type '${type}' are already loaded and transform was probably already applied to them:\n\t${matching_assets.join('\n\t')}`);
+    }
+
+    return true;
+}
+
 /**
  * @template T
  * @param {string} type

package/engine/asset/AssetTransformer.d.ts

@@ -0,0 +1,5 @@
+import {Asset} from "./Asset";
+
+export class AssetTransformer<A extends Asset<T>, T = any> {
+    transform(source: A): Promise<A>
+}

package/engine/asset/AssetTransformer.js

@@ -0,0 +1,15 @@
+/**
+ * Applies a transformation to an asset. Such as performing mesh simplification for example.
+ * Transformation is executed by the {@link AssetManager}
+ * @template {Asset<T>} A
+ * @template T
+ */
+export class AssetTransformer {
+    /**
+     * @param {A} source
+     * @returns {A}
+     */
+    async transform(source) {
+        throw new Error('Not Implemented');
+    }
+}

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -19,7 +19,6 @@ import { CrossOriginKind } from "../CORS/CrossOriginKind.js";
 import { computeObjectBoundingSphere } from "./gltf/computeObjectBoundingSphere.js";
 import { isMesh } from "./gltf/isMesh.js";
 import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { convert_three_object_to_micron } from "../../graphics/micron/convert_three_object_to_micron.js";
 import { HashSet } from "../../../core/collection/HashSet.js";
 import { computeGeometryHash } from "./geometry/geometry/computeGeometryHash.js";
 import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEquality.js";
@@ -173,11 +172,20 @@ export class GLTFAssetLoader extends AssetLoader {
         this.loader = loader;
 
         /**
-         *
+         * Asset optimization flag
+         * Whether or not geometry de-duping should be done
          * @type {boolean}
          * @private
          */
-        this.__enable_micron = true;
+        this.__enable_geometry_cache = false;
+
+        /**
+         * Asset optimization flag
+         * Whether or not texture de-duping should be done
+         * @type {boolean}
+         * @private
+         */
+        this.__enable_texture_cache = false;
 
         /**
          *
@@ -216,7 +224,7 @@ export class GLTFAssetLoader extends AssetLoader {
      * @param {boolean} v
      */
     set is_micron_enabled(v) {
-        this.__enable_micron = v;
+        console.warn('Deprecated. Handled by the MicronRenderPlugin. Remove usage, no further action required');
     }
 
     /**
@@ -224,7 +232,7 @@ export class GLTFAssetLoader extends AssetLoader {
      * @returns {boolean}
      */
     get is_micron_enabled() {
-        return this.__enable_micron;
+        throw new Error('Deprecated. Handled by the MicronRenderPlugin. Remove usage, no further action required. To check for presence of micron, check plugins instead.');
     }
 
     async link(assetManager, engine) {
@@ -275,14 +283,15 @@ export class GLTFAssetLoader extends AssetLoader {
                 alphaTest: object.material.alphaTest
             });
 
-            object.customDepthMaterial = materialCache.acquire(depthMaterial);
+            if (this.__enable_texture_cache) {
+                object.customDepthMaterial = materialCache.acquire(depthMaterial);
+            }
         }
     }
 
 
     load(path, success, failure, progress) {
         const loader = this.loader;
-        const geometry_cache = this.__geometry_cache;
         const texture_cache = this.__texture_cache;
 
 
@@ -290,19 +299,24 @@ export class GLTFAssetLoader extends AssetLoader {
          *
          * @param {THREE.Mesh|THREE.SkinnedMesh} mesh
          */
-        async function processMesh(mesh) {
+        const processMesh = async (mesh) => {
             let geometry = mesh.geometry;
 
             if (geometry === undefined) {
                 throw new Error(`No geometry found`);
             }
 
-            // replace geometry
-            geometry = geometry_cache.ensure(geometry);
-            mesh.geometry = geometry;
+            if (this.__enable_geometry_cache) {
+                // replace geometry
+                geometry = this.__geometry_cache.ensure(geometry);
+                mesh.geometry = geometry;
+            }
+
 
-            // replace textures from cache
-            replace_material_textures_from_cache(mesh.material, texture_cache);
+            if (this.__enable_texture_cache) {
+                // replace textures from cache
+                replace_material_textures_from_cache(mesh.material, texture_cache);
+            }
 
             const isSkinned = mesh.isSkinnedMesh === true;
 
@@ -431,18 +445,6 @@ export class GLTFAssetLoader extends AssetLoader {
                 asset.animations = animations;
             }
 
-            // build micron mesh
-            if (
-                this.__enable_micron
-                && (asset.animations === undefined || asset.animations.length === 0)
-            ) {
-                // TODO deal with animations
-                const micron_root = await convert_three_object_to_micron(root.clone());
-                micron_root.boundingSphere = root.boundingSphere;
-
-                asset.micron = micron_root;
-            }
-
             success(asset);
         }, function (xhr) {
             //dispatch progress callback

package/engine/asset/loaders/material/computeImageBitmapEquality.js

@@ -1,7 +1,7 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 import { assert } from "../../../../core/assert.js";
-import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 import { bitmap2sampler_gl } from "./bitmap2sampler_gl.js";
+import { fastArrayEquals } from "../../../../core/collection/array/fastArrayEquals.js";
 
 /**
  *
@@ -114,5 +114,5 @@ export function computeImageBitmapEquality(a, b) {
 
     const b_s = obtainSampler(b, ctx);
 
-    return isArrayEqualStrict(a_s.data, b_s.data);
+    return fastArrayEquals(a_s.data, b_s.data);
 }

package/engine/asset/loaders/material/computeTextureEquality.js

@@ -1,5 +1,5 @@
 import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
-import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
+import { fastArrayEquals } from "../../../../core/collection/array/fastArrayEquals.js";
 
 //
 
@@ -184,5 +184,5 @@ function textureMipmapEqual(a, b) {
         return true;
     }
 
-    return isArrayEqualStrict(aData, bData);
+    return fastArrayEquals(aData, bData);
 }

package/engine/ecs/gui/GUIElement.js

@@ -3,7 +3,6 @@
  */
 import Vector2 from '../../../core/geom/Vector2.js';
 import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
 import { assert } from "../../../core/assert.js";
 import { objectDeepEquals } from "../../../core/model/object/objectDeepEquals.js";
@@ -238,108 +237,3 @@ GUIElement.serializable = true;
 export default GUIElement;
 
 
-export class GUIElementSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = GUIElement;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GUIElement} value
-     */
-    serialize(buffer, value) {
-
-        if (!value.getFlag(GUIElementFlag.Managed)) {
-            throw new Error(`Expected 'Managed' flag to be set, instead it was cleared. Cannot serialize un-managed component`);
-        }
-
-        value.anchor.toBinaryBufferFloat32(buffer);
-        buffer.writeUTF8String(value.group);
-
-        buffer.writeUint8(value.visible.getValue() ? 1 : 0);
-
-        buffer.writeUTF8String(value.klass);
-        //write parameters
-
-        const paramKeys = Object.keys(value.parameters);
-
-        const numParamKeys = paramKeys.length;
-        buffer.writeUintVar(numParamKeys);
-
-        for (let i = 0; i < numParamKeys; i++) {
-            const paramKey = paramKeys[i];
-
-            buffer.writeUTF8String(paramKey);
-
-            const parameter = value.parameters[paramKey];
-
-            const paramType = typeof parameter;
-
-            if (paramType === "number") {
-                buffer.writeUint8(1);
-
-                buffer.writeFloat64(parameter);
-            } else if (paramType === "boolean") {
-                buffer.writeUint8(2);
-
-                buffer.writeUint8(parameter ? 1 : 0);
-            } else if (paramType === "string") {
-                buffer.writeUint8(3);
-
-                buffer.writeUTF8String(parameter);
-            } else {
-                throw new TypeError(`Unsupported parameter type ${paramType}`);
-            }
-
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GUIElement} value
-     */
-    deserialize(buffer, value) {
-        value.anchor.fromBinaryBufferFloat32(buffer);
-
-        value.group = buffer.readUTF8String();
-
-        value.visible.set(buffer.readUint8() !== 0);
-
-        value.klass = buffer.readUTF8String();
-
-        const numParamKeys = buffer.readUintVar();
-
-        const params = {};
-
-        for (let i = 0; i < numParamKeys; i++) {
-            //read key
-            const paramKey = buffer.readUTF8String();
-
-            //read type flag
-            const paramTypeHeader = buffer.readUint8();
-
-            let paramValue;
-            if (paramTypeHeader === 1) {
-                //number
-                paramValue = buffer.readFloat64();
-            } else if (paramTypeHeader === 2) {
-                //boolean
-                paramValue = buffer.readUint8() !== 0;
-            } else if (paramTypeHeader === 3) {
-                //string
-                paramValue = buffer.readUTF8String();
-            } else {
-                throw new TypeError(`Unknown type header value '${paramTypeHeader}' for parameter key '${paramKey}'`);
-            }
-
-            params[paramKey] = paramValue;
-        }
-
-        value.parameters = params;
-    }
-}

package/engine/ecs/gui/GUIElementSerializationAdapter.js

@@ -0,0 +1,108 @@
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+import GUIElement, { GUIElementFlag } from "./GUIElement.js";
+
+export class GUIElementSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = GUIElement;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GUIElement} value
+     */
+    serialize(buffer, value) {
+
+        if (!value.getFlag(GUIElementFlag.Managed)) {
+            throw new Error(`Expected 'Managed' flag to be set, instead it was cleared. Cannot serialize un-managed component`);
+        }
+
+        value.anchor.toBinaryBufferFloat32(buffer);
+        buffer.writeUTF8String(value.group);
+
+        buffer.writeUint8(value.visible.getValue() ? 1 : 0);
+
+        buffer.writeUTF8String(value.klass);
+        //write parameters
+
+        const paramKeys = Object.keys(value.parameters);
+
+        const numParamKeys = paramKeys.length;
+        buffer.writeUintVar(numParamKeys);
+
+        for (let i = 0; i < numParamKeys; i++) {
+            const paramKey = paramKeys[i];
+
+            buffer.writeUTF8String(paramKey);
+
+            const parameter = value.parameters[paramKey];
+
+            const paramType = typeof parameter;
+
+            if (paramType === "number") {
+                buffer.writeUint8(1);
+
+                buffer.writeFloat64(parameter);
+            } else if (paramType === "boolean") {
+                buffer.writeUint8(2);
+
+                buffer.writeUint8(parameter ? 1 : 0);
+            } else if (paramType === "string") {
+                buffer.writeUint8(3);
+
+                buffer.writeUTF8String(parameter);
+            } else {
+                throw new TypeError(`Unsupported parameter type ${paramType}`);
+            }
+
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GUIElement} value
+     */
+    deserialize(buffer, value) {
+        value.anchor.fromBinaryBufferFloat32(buffer);
+
+        value.group = buffer.readUTF8String();
+
+        value.visible.set(buffer.readUint8() !== 0);
+
+        value.klass = buffer.readUTF8String();
+
+        const numParamKeys = buffer.readUintVar();
+
+        const params = {};
+
+        for (let i = 0; i < numParamKeys; i++) {
+            //read key
+            const paramKey = buffer.readUTF8String();
+
+            //read type flag
+            const paramTypeHeader = buffer.readUint8();
+
+            let paramValue;
+            if (paramTypeHeader === 1) {
+                //number
+                paramValue = buffer.readFloat64();
+            } else if (paramTypeHeader === 2) {
+                //boolean
+                paramValue = buffer.readUint8() !== 0;
+            } else if (paramTypeHeader === 3) {
+                //string
+                paramValue = buffer.readUTF8String();
+            } else {
+                throw new TypeError(`Unknown type header value '${paramTypeHeader}' for parameter key '${paramKey}'`);
+            }
+
+            params[paramKey] = paramValue;
+        }
+
+        value.parameters = params;
+    }
+}