@woosh/meep-engine 2.33.59 → 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/hud/HeadsUpDisplaySystem.js

@@ -6,23 +6,15 @@
 import { System } from '../../System.js';
 import HeadsUpDisplay from './HeadsUpDisplay.js';
 import { Transform } from '../../transform/Transform.js';
-
-import { Matrix4 } from 'three';
 import { GraphicsEngine } from "../../../graphics/GraphicsEngine.js";
 import { FogOfWarVisibilityPredicate } from "../../fow/FogOfWarVisibilityPredicate.js";
-import Vector4 from "../../../../core/geom/Vector4.js";
 import ViewportPosition from "../position/ViewportPosition.js";
 import GUIElement from "../GUIElement.js";
 import { HeadsUpDisplayFlag } from "./HeadsUpDisplayFlag.js";
+import { mat4 } from "gl-matrix";
 
-/**
- *
- * @type {Vector4}
- */
-const v4 = new Vector4();
-const projectionMatrix = new Matrix4();
+const projection = new Float32Array(16);
 
-const up = new Vector4();
 
 /**
  *
@@ -77,7 +69,7 @@ class HeadsUpDisplaySystem extends System {
     }
 
     /**
-     *
+     * NOTE: for the sake of speed all of the matrix and vector multiplications have been inlined, readability of this method is pretty bad
      * @param {HeadsUpDisplay} hud
      * @param {Transform} transform
      * @param {ViewportPosition} vp
@@ -87,48 +79,69 @@ class HeadsUpDisplaySystem extends System {
     __apply_entity_transformation(hud, transform, vp, element) {
         const worldOffset = hud.worldOffset;
 
-        let worldOffsetX = worldOffset.x;
-        let worldOffsetY = worldOffset.y;
-        let worldOffsetZ = worldOffset.z;
-
-        v4.set(
-            worldOffsetX,
-            worldOffsetY,
-            worldOffsetZ,
-            1
-        );
+        let x = worldOffset.x;
+        let y = worldOffset.y;
+        let z = worldOffset.z;
 
         if (hud.getFlag(HeadsUpDisplayFlag.TransformWorldOffset)) {
             //apply scale and rotation
+            const transform_scale = transform.scale;
+
+            x *= transform_scale.x;
+            y *= transform_scale.y;
+            z *= transform_scale.y;
 
-            v4.multiplyVector3(transform.scale);
+            const q = transform.rotation;
+
+            const qx = q.x;
+            const qy = q.y;
+            const qz = q.z;
+            const qw = q.w;
+
+            // calculate quat * vec
+            const ix = qw * x + qy * z - qz * y;
+            const iy = qw * y + qz * x - qx * z;
+            const iz = qw * z + qx * y - qy * x;
+            const iw = -qx * x - qy * y - qz * z;
+
+            // calculate result * inverse quat
+            x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+            y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+            z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
 
-            v4.applyQuaternion(transform.rotation);
         }
 
+        // add transform position to get final world position
         const position = transform.position;
 
-        v4.add3(position);
-
-        const worldPositionX = v4.x;
-        const worldPositionY = v4.y;
-        const worldPositionZ = v4.z;
+        x += position.x;
+        y += position.y;
+        z += position.z;
 
+        const worldPositionX = x;
+        const worldPositionY = y;
+        const worldPositionZ = z;
 
         // Convert the [-1, 1] screen coordinate into a world coordinate on the near plane
-        v4.threeApplyMatrix4(projectionMatrix);
 
-        const d = 1 / Math.abs(v4.w);
-        v4.x *= d;
-        v4.y *= d;
-        v4.z *= d;
+        // apply projection matrix
+        const _x = projection[0] * x + projection[4] * y + projection[8] * z + projection[12];
+        const _y = projection[1] * x + projection[5] * y + projection[9] * z + projection[13];
+        const _z = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];
+        const _w = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];
+
+        // apply perspective transform
+        const d = 1 / Math.abs(_w);
+        x = _x * d;
+        y = _y * d;
+        z = _z * d;
 
-        const ndcX = (v4.x + 1) / 2;
-        const ndcY = (1 - v4.y) / 2;
+        const ndcX = (x + 1) / 2;
+        const ndcY = (1 - y) / 2;
 
         vp.position.set(ndcX, ndcY);
 
-        const trackedPositionOutOfBounds = v4.z > 1 || v4.z < -1;
+        const trackedPositionOutOfBounds = z > 1 || z < -1;
 
         const visible = (!trackedPositionOutOfBounds || vp.stickToScreenEdge) && this.__visibility_predicate.test(worldPositionX, worldPositionY, worldPositionZ);
 
@@ -141,18 +154,20 @@ class HeadsUpDisplaySystem extends System {
             if (hud.getFlag(HeadsUpDisplayFlag.PerspectiveRotation)) {
                 //compute rotation in screen-space
 
-                up.set(worldPositionX, worldPositionY + 1, worldPositionZ, 1);
-                up.threeApplyMatrix4(projectionMatrix);
+                const w_y_1 = worldPositionY + 1;
+
+                const _up_x = projection[0] * worldPositionX + projection[4] * w_y_1 + projection[8] * worldPositionZ + projection[12];
+                const _up_y = projection[1] * worldPositionX + projection[5] * w_y_1 + projection[9] * worldPositionZ + projection[13];
+                const _up_w = projection[3] * worldPositionX + projection[7] * w_y_1 + projection[11] * worldPositionZ + projection[15];
 
                 // compute perspective divide
-                const d = 1 / Math.abs(up.w);
+                const d = 1 / Math.abs(_up_w);
 
-                up.x *= d;
-                up.y *= d;
-                up.z *= d;
+                const up_x = _up_x * d;
+                const up_y = _up_y * d;
 
-                const up_ndcX = (up.x + 1) / 2;
-                const up_ndcY = (1 - up.y) / 2;
+                const up_ndcX = (up_x + 1) / 2;
+                const up_ndcY = (1 - up_y) / 2;
 
                 const angle = Math.atan2(up_ndcY - ndcY, up_ndcX - ndcX);
 
@@ -176,7 +191,7 @@ class HeadsUpDisplaySystem extends System {
          */
         const camera = this.graphics.camera;
 
-        projectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+        mat4.multiply(projection, camera.projectionMatrix.elements, camera.matrixWorldInverse.elements);
 
         const visibilityPredicate = this.__visibility_predicate;
 

package/engine/ecs/storage/binary/BinaryClassUpgrader.js

@@ -82,6 +82,7 @@ export class BinaryClassUpgrader {
      *
      * @param {BinaryBuffer} source
      * @param {BinaryBuffer} target
+     * @returns {void}
      */
     upgrade(source, target) {
         throw new Error('Not Implemented');

package/engine/ecs/util/removeComponentsExcept.js

@@ -10,7 +10,7 @@ export function removeComponentsExcept(ecd, entity, whitelist) {
     const components = ecd.getAllComponents(entity);
     const component_count = components.length;
 
-    for (let i = 0; i < component_count; i++) {
+    l0:for (let i = 0; i < component_count; i++) {
         const component = components[i];
 
         if (component === undefined) {
@@ -21,7 +21,7 @@ export function removeComponentsExcept(ecd, entity, whitelist) {
         for (let i = 0; i < exception_count; i++) {
             if (component instanceof whitelist[i]) {
                 //keep
-                continue;
+                continue l0;
             }
         }
 
@@ -29,4 +29,4 @@ export function removeComponentsExcept(ecd, entity, whitelist) {
         ecd.removeComponentFromEntityByIndex(entity, i);
     }
 
-}
+}

package/engine/graphics/GraphicsEngine.js

@@ -35,7 +35,6 @@ import { MetricsCategory } from "../metrics/MetricsCategory.js";
 import Vector1 from "../../core/geom/Vector1.js";
 import { NormalFrameBuffer } from "./render/buffer/buffers/NormalFrameBuffer.js";
 import { MaterialManager } from "./material/manager/MaterialManager.js";
-import { CoalesceTextures } from "./material/manager/compilers/CoalesceTextures.js";
 import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
@@ -91,14 +90,15 @@ function GraphicsEngine(camera, entityManger) {
      */
     this.__material_manager = new MaterialManager();
 
-    this.__material_manager.addCompileStep(new CoalesceTextures());
+    // The line below would de-dupe textures, it is a rather slow process however
+    // this.__material_manager.addCompileStep(new CoalesceTextures());
 
     this.on = {
         preRender: new Signal(),
         postRender: new Signal(),
 
         preOpaquePass: new Signal(),
-        postOpaquePass : new Signal(),
+        postOpaquePass: new Signal(),
 
         /**
          * @deprecated

package/engine/graphics/ecs/mesh/Mesh.js

@@ -52,10 +52,10 @@ class Mesh {
         this.mesh = null;
 
         /**
-         * Mesh with micron data, if available
+         * Override Mesh data, if available. Typically set via plugins
          * @type {Object3D|null}
          */
-        this.micron_mesh = null;
+        this.override_mesh = null;
 
         /**
          * @transient
@@ -128,9 +128,9 @@ class Mesh {
         //set bvh
         updateNodeByTransformAndBBB(this.bvh, this.boundingBox, _t);
 
-        // micron
-        if (this.micron_mesh !== null) {
-            applyTransformToThreeObject(this.micron_mesh, _t);
+        // override
+        if (this.override_mesh !== null) {
+            applyTransformToThreeObject(this.override_mesh, _t);
         }
     }