@woosh/meep-engine 2.48.13 → 2.48.15

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.48.13",
+  "version": "2.48.15",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/font/FontAssetLoader.js

@@ -4,7 +4,7 @@ import { FontAsset } from "./FontAsset.js";
 
 
 export class FontAssetLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope,path, success, failure, progress) {
         load(path, function (err, font) {
             if (err) {
                 failure(err);
@@ -15,6 +15,6 @@ export class FontAssetLoader extends AssetLoader {
                 success(asset);
 
             }
-        });
+        },{});
     }
 }

package/src/core/math/bessel_3.js

@@ -1,5 +1,6 @@
 /**
  * Kaiser Bessel Function of third kind
+ * NOTE: this is an approximation, if input value is sufficiently large - results will be way off
  * @see https://www.shadertoy.com/view/wlf3RH
  * @returns {number}
  * @param {number} x
@@ -7,5 +8,6 @@
 export function bessel_3(x) {
     const y = 0.5 * x;
     const y2 = (y * y);
-    return (y2 * y * (1.0 / 6.0 + y2 * (1.0 / 24.0 + y2 * (1.0 / 240.0 + y2 * (1.0 / 4320.0 + y2 / 120960.0)))));
+    // return (y2 * y * (1.0 / 6.0 + y2 * (1.0 / 24.0 + y2 * (1.0 / 240.0 + y2 * (1.0 / 4320.0 + y2 / 120960.0)))));
+    return (y2 * y * (0.16666666666666666 + y2 * (0.041666666666666664 + y2 * (0.004166666666666667 + y2 * (2.314814814814815E-4 + y2 * 8.267195767195768E-6)))));
 }

package/src/core/path/computeFileExtension.js

@@ -6,8 +6,9 @@ import { computePathBase } from "./computePathBase.js";
  * @returns {String|null}
  */
 export function computeFileExtension(path) {
-    if (typeof path !== "string") {
-        throw new Error('path is not a string');
+    const type_of_path = typeof path;
+    if (type_of_path !== "string") {
+        throw new Error(`path must be a string, instead was '${type_of_path}'`);
     }
 
     //get base

package/src/engine/Engine.js

@@ -378,9 +378,11 @@ class Engine {
     loadAssetList(listURL) {
         const preloader = new Preloader();
         const assetManager = this.assetManager;
-        assetManager.get(listURL, "json", function (asset) {
-            preloader.addAll(asset.create());
-            preloader.load(assetManager);
+        assetManager.get({
+            path: listURL, type: "json", callback: function (asset) {
+                preloader.addAll(asset.create());
+                preloader.load(assetManager);
+            }
         });
         return preloader;
     }

package/src/engine/achievements/AchievementManager.js

@@ -244,31 +244,31 @@ export class AchievementManager extends EnginePlugin {
     loadDefinitions(assetManager) {
         return new Promise((resolve, reject) => {
             assetManager.get(
-                "data/database/achievements/data.json",
-                GameAssetType.JSON,
-                (asset) => {
-                    try {
+                {
+                    path: "data/database/achievements/data.json", type: GameAssetType.JSON, callback: (asset) => {
+                        try {
 
-                        const json = asset.create();
+                            const json = asset.create();
 
-                        json.forEach(def => {
-                            const achievement = new Achievement();
+                            json.forEach(def => {
+                                const achievement = new Achievement();
 
-                            achievement.fromJSON(def);
+                                achievement.fromJSON(def);
 
-                            this.entries.push(achievement);
-                        });
+                                this.entries.push(achievement);
+                            });
 
-                    } catch (e) {
+                        } catch (e) {
 
-                        reject(e);
+                            reject(e);
 
-                        return;
-                    }
+                            return;
+                        }
 
-                    resolve();
+                        resolve();
 
-                }, reject);
+                    }, failure: reject
+                });
         });
     }
 

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

@@ -13,7 +13,7 @@ interface AssetManagerOptions<CTX> {
     executor?: ConcurrentExecutor
 }
 
-export class AssetManager<CTX> {
+export declare class AssetManager<CTX> {
     constructor(options?: AssetManagerOptions<CTX>)
 
     public readonly crossOriginConfig: CrossOriginConfig

package/src/engine/asset/AssetManager.js

@@ -20,6 +20,9 @@ import FastBinaryHeap from "../../core/collection/heap/FastBinaryHeap.js";
 import { AssetLoadState } from "./AssetLoadState.js";
 import { PendingAsset } from "./PendingAsset.js";
 import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor.js";
+import { AssetLoader } from "./loaders/AssetLoader.js";
+import { array_push_if_unique } from "../../core/collection/array/array_push_if_unique.js";
+import { AssetRequestScope } from "./AssetRequestScope.js";
 
 
 class Response {
@@ -250,12 +253,19 @@ export class AssetManager {
     /**
      * @param {String} path
      * @param {String} type
+     * @param {AssetRequestScope} [scope]
      * @param {boolean} [skip_queue] if true will skip the queue and dispatch request immediately
      * @returns {Promise<Asset>}
      */
-    promise(path, type, { skip_queue = false } = {}) {
+    promise(path, type, { scope, skip_queue = false } = {}) {
         return new Promise((resolve, reject) => {
-            this.get(path, type, resolve, reject);
+            this.get({
+                path,
+                type,
+                callback: resolve,
+                failure: reject,
+                scope
+            });
         });
     }
 
@@ -267,10 +277,20 @@ export class AssetManager {
      * @param {function(*)} [failure]
      * @param {function(loaded:number, total:number)} [progress]
      * @param {boolean} [skip_queue]
-     */
-    get(path, type, callback, failure = console.error, progress = noop, skip_queue = false) {
+     * @param {AssetRequestScope} [scope]
+     */
+    get({
+            path,
+            type,
+            callback,
+            failure = console.error,
+            progress = noop,
+            skip_queue = false,
+            scope = null
+        }) {
+
         if (typeof path !== "string") {
-            throw new Error("Path must be string. Path = " + JSON.stringify(path));
+            throw new TypeError(`Path must be string. instead was '${typeof path}'`);
         }
 
         if (typeof type !== "string") {
@@ -287,6 +307,7 @@ export class AssetManager {
             //create request object
             const assetRequest = new AssetRequest(callback, failure, progress);
 
+            assetRequest.scope = scope;
             assetRequest.writeFlag(AssetRequestFlags.SkipQueue, skip_queue);
 
             //submit request
@@ -539,18 +560,34 @@ export class AssetManager {
             pendingAsset.progress.setUpperLimit(total);
         }
 
-        try {
-            const fullPath = this.rootPath + path;
+        // collect scopes
+        const scopes = [];
 
-            if (typeof loader === "function") {
+        for (let i = 0; i < requests.length; i++) {
+            const request = requests[i];
+            const request_scope = request.scope;
 
-                loader(fullPath, success, failure, progress);
+            if (request_scope !== null) {
+                array_push_if_unique(scopes, request_scope)
+            }
+        }
 
-            } else {
+        let scope;
+        if (scopes.length > 0) {
+            scope = AssetRequestScope.from(scopes);
+        } else {
+            scope = AssetRequestScope.GLOBAL;
+        }
 
-                loader.load(fullPath, success, failure, progress);
 
-            }
+        const full_path = this.rootPath + path;
+
+        // console.log(`Request type: ${type}, path: ${path}, scope: ${scope}`);
+
+        try {
+
+
+            loader.load(scope, full_path, success, failure, progress);
 
         } catch (e) {
             console.error(`Loader failed on invocation. path=${path}, type=${type}`, 'Loader exception: ', e);
@@ -702,20 +739,25 @@ export class AssetManager {
             }
         }
 
-        if (typeof loader === "function") {
 
+        let _loader = loader;
+
+        if (typeof _loader === "function") {
+
+            _loader = new AssetLoader();
+            _loader.load = loader;
 
             console.warn(`function-based loaders are deprecated (${type})`);
 
         } else {
 
-            await loader.link(this, this.#context);
+            await _loader.link(this, this.#context);
 
         }
 
-        this.#loaders[type] = loader;
+        this.#loaders[type] = _loader;
 
-        return loader;
+        return _loader;
     }
 
     /**

package/src/engine/asset/AssetManager.spec.js

@@ -16,7 +16,7 @@ function dummyEngine() {
 }
 
 class DummyLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope,path, success, failure, progress) {
         success(new Asset(() => 1));
     }
 }

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

@@ -49,7 +49,7 @@ export class PendingAsset {
 
         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,7 +1,9 @@
 import {Asset} from "../Asset";
+import {AssetRequestScope} from "../AssetRequestScope";
 
-export class AssetLoader<T,CTX> {
+export declare class AssetLoader<T, CTX> {
     public load(
+        scope: AssetRequestScope,
         path: string,
         success: (asset: Asset<T>) => void,
         failure: (reason: any) => void,

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

@@ -11,7 +11,7 @@ export class AssetLoader {
 
     /**
      *
-     * @type {Engine}
+     * @type {CTX}
      */
     context = null;
 
@@ -34,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

@@ -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

@@ -16,7 +16,7 @@ export class SoundAssetLoader extends AssetLoader {
         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();
 

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 });
         });
     }