@woosh/meep-engine 2.33.57 → 2.33.61

package/core/geom/packing/MaxRectangles.js

@@ -12,9 +12,10 @@ import Vector2 from "../Vector2.js";
  * @param {AABB2[]} boxes
  */
 function removeRedundantBoxesArray(boxes) {
+    let i, j;
     let numBoxes = boxes.length;
 
-    loop_a: for (let i = 0; i < numBoxes; i++) {
+    loop_a: for (i = 0; i < numBoxes; i++) {
         const a = boxes[i];
 
         const ax0 = a.x0;
@@ -22,7 +23,7 @@ function removeRedundantBoxesArray(boxes) {
         const ax1 = a.x1;
         const ay1 = a.y1;
 
-        for (let j = i + 1; j < numBoxes; j++) {
+        for (j = i + 1; j < numBoxes; j++) {
             const b = boxes[j];
 
             const bx0 = b.x0;
@@ -157,7 +158,7 @@ function findBestContainer(width, height, boxes, costFunction) {
     let best = null;
     let bestScore = Number.POSITIVE_INFINITY;
 
-    boxes.traversePreOrder(node => {
+    const visitor = (node) => {
 
         if (node.getWidth() < width) {
             //too small, don't traverse deeper
@@ -195,7 +196,11 @@ function findBestContainer(width, height, boxes, costFunction) {
                 best = box;
             }
         }
-    });
+
+        return true;
+    };
+
+    boxes.traversePreOrder(visitor);
 
     return best;
 }
@@ -337,6 +342,10 @@ export class MaxRectanglesPacker {
         this.free = new QuadTreeNode(0, 0, width, height);
         this.free.add(null, 0, 0, width, height);
 
+        /**
+         *
+         * @type {AABB2[]}
+         */
         this.boxes = [];
     }
 

package/core/math/hash/murmur3_32.js

@@ -9,9 +9,9 @@ export function murmur3_32(key, seed) {
     let k1;
     let i = 0;
 
-    const bytes = key.length;
+    const key_length = key.length;
 
-    while (i < bytes) {
+    while (i < key_length) {
         k1 = key[i];
         ++i;
 
@@ -26,7 +26,7 @@ export function murmur3_32(key, seed) {
     }
 
     // mix in array length
-    h1 ^= bytes;
+    h1 ^= key_length;
 
     h1 ^= h1 >>> 16;
     h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16));

package/engine/animation/removeEntityGenericEffect.js

@@ -3,22 +3,7 @@ import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter
 
 const lib = {
     'cloud-puff': {
-        "position": {
-            "x": 56.41791044776119,
-            "y": -8.887834661270745,
-            "z": 223.65671641791042
-        },
-        "scale": {
-            "x": 1,
-            "y": 1,
-            "z": 1
-        },
-        "rotation": {
-            "x": 0,
-            "y": 0,
-            "z": 0,
-            "w": 1
-        },
+        "receiveLight": true,
         "parameters": [
             {
                 "name": "scale",
@@ -80,24 +65,24 @@ const lib = {
                         "track": {
                             "itemSize": 4,
                             "data": [
-                                0.9803921568627451,
-                                0.9803921568627451,
-                                0.9803921568627451,
-                                0.3,
+                                0.6,
+                                0.6,
+                                0.6,
+                                0,
 
-                                0.9882352941176471,
-                                0.9882352941176471,
-                                0.9882352941176471,
-                                0.9880952380952381,
+                                0.6,
+                                0.6,
+                                0.6,
+                                1,
 
-                                0.9882352941176471,
-                                0.9882352941176471,
-                                0.9882352941176471,
+                                0.6,
+                                0.6,
+                                0.6,
                                 0.5,
 
-                                0.9882352941176471,
-                                0.9882352941176471,
-                                0.9882352941176471,
+                                0.6,
+                                0.6,
+                                0.6,
                                 0
                             ],
                             "positions": [
@@ -155,7 +140,13 @@ export function removeEntityGenericEffect(
     }
 ) {
 
-    const emitter = ParticleEmitter.fromJSON(lib[particles]);
+    const particle_json = lib[particles];
+
+    if (particle_json === undefined) {
+        throw new Error(`Unsupported particle ID '${particles}'`);
+    }
+
+    const emitter = ParticleEmitter.fromJSON(particle_json);
 
     const result = removeEntityWithEffect({
         entity,

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/asset/loaders/material/computeTextureHash.js

@@ -1,7 +1,7 @@
-import { max2 } from "../../../../core/math/max2.js";
 import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { murmur3_32 } from "../../../../core/math/hash/murmur3_32.js";
 
 /**
  *
@@ -59,6 +59,7 @@ export function computeImageDataHash(image) {
  */
 function computeSpecificHash(texture) {
     let dataHash = 0;
+    let i;
 
     if (texture.image !== null && texture.image !== undefined) {
 
@@ -73,25 +74,18 @@ function computeSpecificHash(texture) {
     if (Array.isArray(mipmaps)) {
         const nMipmaps = mipmaps.length;
 
-        for (let i = 0; i < nMipmaps; i++) {
+        for (i = 0; i < nMipmaps; i++) {
             const mipmap = mipmaps[i];
 
-            if (mipmap.width > 16) {
-                continue;
-            }
-
             const data = mipmap.data;
-
             const dataSize = data.length;
 
-            const dataStride = max2(1, Math.floor(dataSize / 31));
-
-            for (let i = 0; i < dataSize; i += dataStride) {
-                const datum = data[i];
-
-                dataHash = ((dataHash << 5) - dataHash) + datum;
+            if (dataSize > 1024) {
+                continue;
             }
 
+            dataHash = ((dataHash << 5) - dataHash) + murmur3_32(data, 1337);
+
             break;
         }
 

package/engine/ecs/attachment/AttachmentSystem.js

@@ -6,7 +6,6 @@ import { assert } from "../../../core/assert.js";
 import Mesh from "../../graphics/ecs/mesh/Mesh.js";
 import { BoneAttachmentBinding } from "./BoneAttachmentBinding.js";
 import { TransformAttachmentBinding } from "./TransformAttachmentBinding.js";
-import { MeshSystem } from "../../graphics/ecs/mesh/MeshSystem.js";
 
 /**
  * @readonly
@@ -318,10 +317,10 @@ export class AttachmentSystem extends System {
 
     /**
      *
-     * @param {Mesh} mesh
      * @param {number} entity
+     * @private
      */
-    visitVisibleMesh(mesh, entity) {
+    __update_entity(entity) {
         const bindings = this.parentBindingIndex.get(entity);
 
         if (bindings !== undefined) {
@@ -335,25 +334,27 @@ export class AttachmentSystem extends System {
         }
     }
 
+    /**
+     *
+     * @param {Mesh} mesh
+     * @param {number} entity
+     */
+    visitComponent(mesh, entity) {
+        this.__update_entity(entity);
+    }
+
     update(timeDelta) {
         //process wait queue
         this.processWaiting();
 
-        /**
-         *
-         * @type {MeshSystem}
-         */
-        const meshSystem = this.entityManager.getSystem(MeshSystem);
+        const em = this.entityManager;
 
-        meshSystem.traverseVisible(this.visitVisibleMesh, this);
+        const ecd = em.dataset;
 
-    }
-}
+        if (ecd === null) {
+            return;
+        }
 
-/**
- *
- * @param {AttachmentBinding} binding
- */
-function updateBinding(binding) {
-    binding.update();
+        ecd.traverseComponents(Attachment, this.visitComponent, this);
+    }
 }