@woosh/meep-engine 2.48.12 → 2.48.14

package/src/engine/asset/AssetRequest.js

@@ -38,7 +38,13 @@ export class AssetRequest {
          * Higher priority requests should be handled first
          * @type {number}
          */
-        this.priority = 0;
+        this.priority = 1;
+
+        /**
+         *
+         * @type {AssetRequestScope}
+         */
+        this.scope = null;
 
         /**
          *
@@ -47,6 +53,18 @@ export class AssetRequest {
         this.flags = 0;
     }
 
+    get scoped_priority() {
+        const _p = this.priority;
+
+        const scope = this.scope;
+
+        if (scope === null) {
+            return _p;
+        }
+
+        return _p * scope.final_priority;
+    }
+
     /**
      *
      * @param {number|AssetRequestFlags} flag

package/src/engine/asset/AssetRequestScope.d.ts

@@ -0,0 +1,3 @@
+export declare class AssetRequestScope{
+
+}

package/src/engine/asset/AssetRequestScope.js

@@ -0,0 +1,64 @@
+let id_counter = 0;
+
+export class AssetRequestScope {
+    id = id_counter++;
+
+    priority = 1
+
+    /**
+     *
+     * @type {AssetRequestScope[]}
+     */
+    sources = []
+
+
+    get final_priority() {
+        const sources = this.sources;
+        const n = sources.length;
+
+        if (n === 0) {
+            return this.priority;
+        }
+
+
+        let max = sources[0].final_priority;
+
+        for (let i = 0; i < n; i++) {
+            const source = sources[i];
+
+            const source_priority = source.final_priority;
+
+            if (source_priority > max) {
+                max = source_priority;
+            }
+        }
+
+        return this.priority * max;
+    }
+
+    /**
+     *
+     * @param {AssetRequestScope[]} sources
+     * @return {AssetRequestScope}
+     */
+    static from(sources) {
+        const r = new AssetRequestScope();
+
+        r.sources = sources;
+
+        return r;
+    }
+
+    toString() {
+        const sources = this.sources.length > 0 ? `[ ${this.sources.join(', ')} ]` : 'none';
+        return `Scope{ id:${this.id}, sources:${sources} }`;
+    }
+
+}
+
+
+/**
+ * @readonly
+ * @type {Readonly<AssetRequestScope>}
+ */
+AssetRequestScope.GLOBAL = Object.freeze(new AssetRequestScope());

package/src/engine/asset/PendingAsset.js

@@ -38,18 +38,18 @@ export class PendingAsset {
      * @return {number}
      */
     get priority() {
-        let max_priority = 0;
-
         const requests = this.requests;
-        const n = requests.length;
+        const request_count = requests.length;
 
-        if (n > 0) {
-            max_priority = requests[0].priority;
+        if (request_count === 0) {
+            return 0;
         }
 
-        for (let i = 1; i < n; i++) {
+        let max_priority = requests[0].priority;
+
+        for (let i = 1; i < request_count; i++) {
             const request = requests[i];
-            const priority = request.priority;
+            const priority = request.scoped_priority;
 
             if (priority > max_priority) {
                 max_priority = request;

package/src/engine/asset/loaders/ArrayBufferLoader.js

@@ -22,7 +22,7 @@ export class ArrayBufferLoader extends AssetLoader {
         this.__fetch_priority = fetch_priority;
     }
 
-    load(path, success, failure = console.error, progress = noop) {
+    load(scope, path, success, failure = console.error, progress = noop) {
         const coc = this.assetManager !== null ? this.assetManager.crossOriginConfig : CrossOriginConfig.default;
 
         const headers = new Headers();

package/src/engine/asset/loaders/AssetLoader.d.ts

@@ -1,5 +1,12 @@
 import {Asset} from "../Asset";
+import {AssetRequestScope} from "../AssetRequestScope";
 
-export class AssetLoader<T> {
-    public load(path: string, success: (asset: Asset<T>) => void, failure: (reason: any) => void, progress: (current: number, total: number) => void)
+export declare class AssetLoader<T, CTX> {
+    public load(
+        scope: AssetRequestScope,
+        path: string,
+        success: (asset: Asset<T>) => void,
+        failure: (reason: any) => void,
+        progress: (current: number, total: number) => void
+    )
 }

package/src/engine/asset/loaders/AssetLoader.js

@@ -1,26 +1,28 @@
+/**
+ * @template CTX
+ * @template Asset
+ */
 export class AssetLoader {
-    constructor() {
-        /**
-         *
-         * @type {AssetManager}
-         */
-        this.assetManager = null;
+    /**
+     *
+     * @type {AssetManager}
+     */
+    assetManager = null;
 
-        /**
-         *
-         * @type {Engine}
-         */
-        this.engine = null;
-    }
+    /**
+     *
+     * @type {CTX}
+     */
+    context = null;
 
     /**
      *
      * @param {AssetManager} assetManager
-     * @param {Engine} engine
+     * @param {CTX} context
      */
-    async link(assetManager, engine) {
+    async link(assetManager, context) {
         this.assetManager = assetManager;
-        this.engine = engine;
+        this.context = context;
     }
 
     /**
@@ -32,12 +34,13 @@ export class AssetLoader {
 
     /**
      *
+     * @param {AssetRequestScope} scope
      * @param {string} path
      * @param {function(Asset)} success
      * @param {function} failure
      * @param {function(current:number, total:number)} progress
      */
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
         failure('Not Implemented');
     }
 }

package/src/engine/asset/loaders/GLTFAssetLoader.d.ts

@@ -1,6 +1,6 @@
 import {AssetLoader} from "./AssetLoader";
 import {Object3D} from "three";
 
-export class GLTFAssetLoader extends AssetLoader<Object3D> {
+export class GLTFAssetLoader extends AssetLoader<Object3D, any> {
     setDracoDecoderPath(path: string): void
 }

package/src/engine/asset/loaders/GLTFAssetLoader.js

@@ -241,7 +241,7 @@ export class GLTFAssetLoader extends AssetLoader {
          *
          * @type {GraphicsEngine}
          */
-        const graphics = this.engine.graphics;
+        const graphics = this.context.graphics;
 
         /**
          *
@@ -273,7 +273,7 @@ export class GLTFAssetLoader extends AssetLoader {
     }
 
 
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
         const loader = this.loader;
         const texture_cache = this.__texture_cache;
 

package/src/engine/asset/loaders/JavascriptAssetLoader.js

@@ -21,22 +21,27 @@ class JavascriptAsset extends Asset {
 
 export class JavascriptAssetLoader extends AssetLoader {
 
-    load(path, success, failure, progress) {
-        this.assetManager.get(path, GameAssetType.Text, (textAsset) => {
+    load(scope, path, success, failure, progress) {
+        this.assetManager.get({
+            path: path,
+            scope,
+            type: GameAssetType.Text,
+            callback: (textAsset) => {
 
-            const text = textAsset.create();
+                const text = textAsset.create();
 
-            let asset;
+                let asset;
 
-            try {
-                asset = new JavascriptAsset(text);
-            } catch (e) {
-                failure(e);
-                return;
-            }
+                try {
+                    asset = new JavascriptAsset(text);
+                } catch (e) {
+                    failure(e);
+                    return;
+                }
 
-            success(asset);
+                success(asset);
 
-        }, failure, progress);
+            }, failure: failure, progress: progress
+        });
     }
 }

package/src/engine/asset/loaders/JsonAssetLoader.js

@@ -2,7 +2,7 @@ import xhr from "../../network/xhr.js";
 import { AssetLoader } from "./AssetLoader.js";
 
 export class JsonAssetLoader extends AssetLoader {
-    load(path, callback, failure, progress) {
+    load(scope, path, callback, failure, progress) {
         xhr(path, function (data) {
             let object;
             try {

package/src/engine/asset/loaders/LegacyThreeJSONAssetLoader.js

@@ -20,8 +20,11 @@ const placeholderTexture = checkerTexture.create();
 
 const placeholderMaterial = new ThreeMeshLambertMaterial({ map: placeholderTexture });
 
+/**
+ * @deprecated
+ */
 export class LegacyThreeJSONAssetLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
 
         console.warn(`JSON loader is deprecated. Attempting to load model '${path}'`);
 

package/src/engine/asset/loaders/SVGAssetLoader.js

@@ -2,7 +2,7 @@ import { AssetLoader } from "./AssetLoader.js";
 
 export class SVGAssetLoader extends AssetLoader {
 
-    load(url, callback, failure, progress) {
+    load(scope,url, callback, failure, progress) {
         const xhr = new XMLHttpRequest();
         xhr.open('GET', url, true);
 

package/src/engine/asset/loaders/SoundAssetLoader.js

@@ -13,10 +13,10 @@ export class SoundAssetLoader extends AssetLoader {
          *
          * @type {AudioContext}
          */
-        this.context = context;
+        this.audioContext = context;
     }
 
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
         // Load a sound file using an ArrayBuffer XMLHttpRequest.
         const request = new XMLHttpRequest();
 
@@ -24,16 +24,14 @@ export class SoundAssetLoader extends AssetLoader {
 
         request.responseType = "arraybuffer";
 
-        const context = this.context;
+        const context = this.audioContext;
 
         request.onload = function (e) {
             //decode works asynchronously, this is important to prevent lag in main thread
             context.decodeAudioData(request.response, function (buffer) {
                 const byteSize = e.total;
 
-                const asset = new Asset(function () {
-                    return buffer;
-                }, byteSize);
+                const asset = new Asset(() => buffer, byteSize);
 
                 success(asset);
             }, failure);

package/src/engine/asset/loaders/TextAssetLoader.js

@@ -2,7 +2,7 @@ import xhr from "../../network/xhr.js";
 import { AssetLoader } from "./AssetLoader.js";
 
 export class TextAssetLoader extends AssetLoader {
-    load(path, callback, failure, progress) {
+    load(scope,path, callback, failure, progress) {
         xhr(path, function (data) {
             const asset = {
                 create: function () {

package/src/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -32,11 +32,12 @@ export class ImageRGBADataLoader extends AssetLoader {
     /**
      *
      * @param {string} path
+     * @param {AssetRequestScope} scope
      * @returns {Promise<{data:ArrayBuffer, width: number, height:number, itemSize: number, bitDepth:number}>}
      * @private
      */
-    async __decode_via_worker(path) {
-        const asset = await this.assetManager.promise(path, ASSET_TYPE_ARRAY_BUFFER);
+    async __decode_via_worker(path, scope) {
+        const asset = await this.assetManager.promise(path, ASSET_TYPE_ARRAY_BUFFER, { scope });
 
         /**
          * @type {ArrayBuffer}
@@ -49,12 +50,13 @@ export class ImageRGBADataLoader extends AssetLoader {
     /**
      *
      * @param {String} path
+     * @param {AssetRequestScope} scope
      * @return {Promise<ImageRGBADataAsset>}
      * @private
      */
-    async __standard(path) {
+    async __standard(path, scope) {
 
-        const bitmap = await this.__decode_via_worker(path);
+        const bitmap = await this.__decode_via_worker(path, scope);
 
 
         let data;
@@ -75,32 +77,37 @@ export class ImageRGBADataLoader extends AssetLoader {
         return new ImageRGBADataAsset(data, bitmap.width, bitmap.height, bitmap.itemSize);
     }
 
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
         const extension = computeFileExtension(path);
 
         if (extension === 'dds') {
             //compressed texture
-            this.assetManager.get(path, GameAssetType.Texture, asset => {
+            this.assetManager.get({
+                path: path,
+                scope,
+                type: GameAssetType.Texture,
+                callback: asset => {
 
-                /**
-                 *
-                 * @type {Texture}
-                 */
-                const texture = asset.create();
+                    /**
+                     *
+                     * @type {Texture}
+                     */
+                    const texture = asset.create();
 
-                const sampler2D = convertTexture2Sampler2D(texture);
+                    const sampler2D = convertTexture2Sampler2D(texture);
 
-                texture.dispose();
+                    texture.dispose();
 
-                const f = new ImageRGBADataAsset(sampler2D.data, sampler2D.width, sampler2D.height, sampler2D.itemSize);
+                    const f = new ImageRGBADataAsset(sampler2D.data, sampler2D.width, sampler2D.height, sampler2D.itemSize);
 
-                success(f);
+                    success(f);
 
-            }, failure, progress);
+                }, failure: failure, progress: progress
+            });
 
         } else {
 
-            this.__standard(path).then(success, failure);
+            this.__standard(path, scope).then(success, failure);
 
         }
     }

package/src/engine/asset/loaders/texture/TextureAssetLoader.d.ts

@@ -1,6 +1,6 @@
 import {AssetLoader} from "../AssetLoader";
 import {Texture} from "three";
 
-export class TextureAssetLoader extends AssetLoader<Texture> {
+export class TextureAssetLoader extends AssetLoader<Texture, any> {
 
 }

package/src/engine/asset/loaders/texture/TextureAssetLoader.js

@@ -4,7 +4,7 @@ import { loadStandardImageTexture } from "./loadStandardImageTexture.js";
 import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 export class TextureAssetLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
         //figure out what kind of a texture it is
         let fileExtension = computeFileExtension(path);
 

package/src/engine/asset/preloader/Preloader.js

@@ -158,7 +158,7 @@ Preloader.prototype.load = function (assetManager) {
         });
 
         batch.forEach(function (def) {
-            assetManager.get(def.uri, def.type, assetLoadSuccess, assetLoadFailed);
+            assetManager.get({ path: def.uri, type: def.type, callback: assetLoadSuccess, failure: assetLoadFailed });
         });
     }
 

package/src/engine/development/performance/MetricStatistics.js

@@ -1,8 +1,10 @@
 export class MetricStatistics {
-    constructor() {
-        this.mean = 0;
-        this.meadian = 0;
-        this.max = 0;
-        this.min = 0;
+    mean = 0;
+    median = 0;
+    max = 0;
+    min = 0;
+
+    toString() {
+        return `{min:${this.min}, max:${this.max}, mean:${this.mean}, median:${this.median}`;
     }
 }

package/src/engine/development/performance/RingBufferMetric.js

@@ -49,7 +49,7 @@ export class RingBufferMetric extends AbstractMetric {
 
             // no data
             result.mean = 0;
-            result.meadian = 0;
+            result.median = 0;
             result.min = 0;
             result.max = 0;
 
@@ -58,7 +58,7 @@ export class RingBufferMetric extends AbstractMetric {
         } else {
 
             result.mean = computeStatisticalMean(array, 0, data_count);
-            result.meadian = computeStatisticalPartialMedian(array, 0, data_count);
+            result.median = computeStatisticalPartialMedian(array, 0, data_count);
             result.max = computeArrayMax(array, 0, data_count);
             result.min = computeArrayMin(array, 0, data_count);
 

package/src/engine/ecs/foliage/ecs/Foliage2System.js

@@ -38,12 +38,14 @@ export function loadFoliageLayer(layer, assetManager) {
             reject(`Undetermined asset type for url='${modelURL}'`);
         }
 
-        assetManager.get(modelURL, assetType, function (asset) {
-            const mesh = asset.create();
-            instancedFoliage.setInstance(mesh.geometry, mesh.material);
+        assetManager.get({
+            path: modelURL, type: assetType, callback: function (asset) {
+                const mesh = asset.create();
+                instancedFoliage.setInstance(mesh.geometry, mesh.material);
 
-            resolve();
-        }, reject);
+                resolve();
+            }, failure: reject
+        });
     });
 
     const result = mesh.then(function () {

package/src/engine/ecs/foliage/ecs/InstancedMeshUtils.js

@@ -78,6 +78,7 @@ export function convertInstancedMeshComponents2Entities(dataset, assetManager) {
 export function optimizeIndividualMeshesEntitiesToInstances(dataset, threshold = 30) {
     //get all entities that have a translation and mesh only
     const candidates = {};
+    const not_loaded = {};
 
     /**
      *
@@ -99,7 +100,14 @@ export function optimizeIndividualMeshesEntitiesToInstances(dataset, threshold =
         }
 
         if (!mesh.getFlag(MeshFlags.Loaded)) {
-            console.warn(`Mesh[${entity}] not loaded - '${model_url}'`);
+            let misses = not_loaded[model_url];
+
+            if (misses === undefined) {
+                misses = not_loaded[model_url] = [];
+            }
+
+            misses.push(entity);
+
             return;
         }
 
@@ -125,6 +133,11 @@ export function optimizeIndividualMeshesEntitiesToInstances(dataset, threshold =
     // traverse entities that have only Mesh and a Transform
     dataset.traverseEntitiesExact([Mesh, Transform], visitMeshTransformEntity);
 
+    for (const mesh_url in not_loaded) {
+
+        console.warn(`Mesh[${mesh_url}] not loaded, ${not_loaded[mesh_url].length} entities affected`);
+    }
+
     const tasks = [];
 
     const foliage2 = new InstancedMeshComponent();

package/src/engine/ecs/gui/GUIElementSystem.d.ts

@@ -1,7 +1,7 @@
 import {System} from "../System";
 import Engine from "../../Engine";
 import View from "../../../view/View";
-import {GUIElement} from "./GUIElement";
+import GUIElement from "./GUIElement";
 
 export default class GUIElementSystem extends System<GUIElement> {
     constructor(container: View, engine: Engine)

package/src/engine/ecs/sockets/serialization/AttachmentSocketsAssetLoader.js

@@ -4,9 +4,9 @@ import { AttachmentSockets } from "../AttachmentSockets.js";
 import { Asset } from "../../../asset/Asset.js";
 
 export class AttachmentSocketsAssetLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
 
-        this.assetManager.promise(path, GameAssetType.JSON)
+        this.assetManager.promise(path, GameAssetType.JSON, { scope })
             .then(asset => {
 
                 const json = asset.create();

package/src/engine/ecs/terrain/ecs/PromiseSamplerHeight.js

@@ -41,19 +41,26 @@ export function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
             fulfill(defaultSampler);
         } else if (heightMapURL.endsWith('.bin')) {
             //load texture from a binary file
-            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
+            assetManager.get({
+                path: heightMapURL,
+                type: GameAssetType.ArrayBuffer,
+                callback: assetObtained,
+                failure: reject
+            });
         } else {
-            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
-                const image = asset.create();
+            assetManager.get({
+                path: heightMapURL, type: GameAssetType.Image, callback: function (asset) {
+                    const image = asset.create();
 
-                // plane
-                const imgWidth = image.width;
-                const imgHeight = image.height;
+                    // plane
+                    const imgWidth = image.width;
+                    const imgHeight = image.height;
 
-                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
+                    const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
 
-                fulfill(samplerHeight);
-            }, reject);
+                    fulfill(samplerHeight);
+                }, failure: reject
+            });
         }
     });
 }