@woosh/meep-engine 2.60.0 → 2.61.0

package/src/core/process/worker/WorkerBuilder.js

@@ -3,53 +3,163 @@
  */
 
 
-import { convertPathToURL } from "../../../engine/network/convertPathToURL.js";
-import WorkerProxy from "./WorkerProxy.js";
+import {convertPathToURL} from "../../../engine/network/convertPathToURL.js";
 import LineBuilder from "../../codegen/LineBuilder.js";
+import WorkerProxy from "./WorkerProxy.js";
 
 const RxMatchFunctionName = /(function\s*)([a-zA-Z0-9_]+)?(\s*\([^\]]*\)\s*\{.*)/g;
 
-const WorkerBuilder = function () {
-    this.imports = [];
-    this.methods = {};
-    this.functions = [];
-    this.preable = new LineBuilder();
-};
+class WorkerBuilder {
 
-WorkerBuilder.prototype.addCode = function (code) {
-    this.preable.add(code);
-};
+    imports = [];
+    methods = {};
+    functions = [];
+    preamble = new LineBuilder();
 
-/**
- *
- * @param {string} name
- * @param {function|string} method
- */
-WorkerBuilder.prototype.addMethod = function (name, method) {
-    this.methods[name] = method;
-};
+    addCode(code) {
+        this.preamble.add(code);
+    }
 
-/**
- * NOTE: take care when using minifiers as they may mangle function names
- * @deprecated
- * @param name
- * @param {function} f
- */
-WorkerBuilder.prototype.importFunction = function (name, f) {
-    this.functions.push({
-        f,
-        name
-    });
-};
+    /**
+     *
+     * @param {string} name
+     * @param {function|string} method
+     */
+    addMethod(name, method) {
+        this.methods[name] = method;
+    }
 
-/**
- *
- * @param {string} path
- */
-WorkerBuilder.prototype.importScript = function (path) {
-    path = convertPathToURL(path);
+    /**
+     * NOTE: take care when using minifiers as they may mangle function names
+     * @deprecated
+     * @param name
+     * @param {function} f
+     */
+    importFunction(name, f) {
+        this.functions.push({
+            f,
+            name
+        });
+    }
+
+    /**
+     *
+     * @param {string} path
+     */
+    importScript(path) {
+        path = convertPathToURL(path);
+
+        this.imports.push(path);
+    }
+
+    /**
+     *
+     * @returns {WorkerProxy}
+     */
+    build() {
+        const codeLines = [];
+
+        codeLines.push('var globalScope = this;');
+
+        //handle imports
+        this.imports.forEach(function (url) {
+            codeLines.push("globalScope.importScripts('" + url + "');");
+        });
+
+        codeLines.push(this.preamble.build());
+
+        //handle functions
+        this.functions.forEach(function (spec) {
+            const f = spec.f;
+
+            const function_string = f.toString();
+
+            // We rewrite the function to explicitly set function name. This is needed to work around various code compressors such as Uglify or Terser that mange original function names or remove them altogether
+            const renamed_function_string = function_string.replace(RxMatchFunctionName, `$1${spec.name}$3`);
+
+            codeLines.push(renamed_function_string);
+        });
+
+
+        //api hash
+        codeLines.push('var api = {};');
+        for (let apiName in this.methods) {
+            if (this.methods.hasOwnProperty(apiName)) {
+                const method = this.methods[apiName];
+
+
+                const type_of_method = typeof method;
+
+                let method_code;
+
+                if (type_of_method === 'function') {
+                    method_code = method.toString();
+                } else if (type_of_method === 'string') {
+                    method_code = method;
+                } else {
+                    throw new Error(`Unsupported method type '${type_of_method}'`);
+                }
 
-    this.imports.push(path);
+
+                codeLines.push("api['" + apiName + "'] = " + method_code + ";");
+            }
+        }
+
+        //api handler
+        Array.prototype.push.apply(codeLines, [
+            `function extractTransferables(obj, result) {
+                if (typeof obj !== "object") {
+                    return; //not an object, skip
+                } else if (obj instanceof ArrayBuffer) {
+                    result.push(obj);
+                } else if (obj.buffer instanceof ArrayBuffer) {
+                    result.push(obj.buffer);
+                } else if (obj instanceof ImageBitmap) {
+                    result.push(obj);
+                } else {
+                    for (var i in obj) {
+                        if (obj.hasOwnProperty(i)) {
+                            extractTransferables(obj[i], result);
+                        }
+                    }
+                }
+            }`,
+            'globalScope.onmessage = function(event){',
+            '   var eventData = event.data;',
+            '   var requestId = eventData.id',
+            '   var methodName = eventData.methodName;',
+            '   var parameters = eventData.parameters;',
+            '   var method = api[methodName];',
+
+            '   function sendResult(result){',
+            '       var transferables = [];',
+            '       extractTransferables(result, transferables);',
+            '       globalScope.postMessage({methodName: methodName, id: requestId, result: result}, transferables);',
+            '   }',
+
+            '   function sendError(error){',
+            '       let stack = "";',
+            '       try{stack = error.stack.split("\\n")}catch(e){}',
+            '       globalScope.postMessage({methodName: methodName, id: requestId, error: {message: error.message, stack: stack }});',
+            '   }',
+
+            '   if(method === undefined){',
+            '       sendError(new Error("API named \'"+methodName+"\' was not found."));',
+            '   }else{',
+            '       try{',
+            '           method.apply(null,parameters).then(sendResult, sendError);',
+            '       }catch(e){',
+            '           sendError(e);',
+            '       }',
+            '   }',
+            '};'
+        ]);
+
+        const code = codeLines.join("\n");
+        const workerURL = codeToURL(code);
+
+        return new WorkerProxy(workerURL, this.methods);
+    }
 };
 
 /**
@@ -64,7 +174,7 @@ function codeToURL(code) {
 
     if (typeof window === 'object') {
         if (typeof window.Blob !== "undefined") {
-            blob = new Blob([code], { type: js_mime });
+            blob = new Blob([code], {type: js_mime});
         } else {
             // Backwards-compatibility
             const BlobBuilder = window.BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder;
@@ -84,114 +194,4 @@ function codeToURL(code) {
     }
 }
 
-/**
- *
- * @returns {WorkerProxy}
- */
-WorkerBuilder.prototype.build = function () {
-    const codeLines = [];
-
-    codeLines.push('var globalScope = this;');
-
-    //handle imports
-    this.imports.forEach(function (url) {
-        codeLines.push("globalScope.importScripts('" + url + "');");
-    });
-
-    codeLines.push(this.preable.build());
-
-    //handle functions
-    this.functions.forEach(function (spec) {
-        const f = spec.f;
-
-        const function_string = f.toString();
-
-        // We rewrite the function to explicitly set function name. This is needed to work around various code compressors such as Uglify or Terser that mange original function names or remove them altogether
-        const renamed_function_string = function_string.replace(RxMatchFunctionName, `$1${spec.name}$3`);
-
-        codeLines.push(renamed_function_string);
-    });
-
-
-    //api hash
-    codeLines.push('var api = {};');
-    for (let apiName in this.methods) {
-        if (this.methods.hasOwnProperty(apiName)) {
-            const method = this.methods[apiName];
-
-
-            const type_of_method = typeof method;
-
-            let method_code;
-
-            if (type_of_method === 'function') {
-                method_code = method.toString();
-            } else if (type_of_method === 'string') {
-                method_code = method;
-            } else {
-                throw new Error(`Unsupported method type '${type_of_method}'`);
-            }
-
-
-            codeLines.push("api['" + apiName + "'] = " + method_code + ";");
-        }
-    }
-
-    //api handler
-    Array.prototype.push.apply(codeLines, [
-        `function extractTransferables(obj, result) {
-            if (typeof obj !== "object") {
-                return; //not an object, skip
-            } else if (obj instanceof ArrayBuffer) {
-                result.push(obj);
-            } else if (obj.buffer instanceof ArrayBuffer) {
-                result.push(obj.buffer);
-            } else if (obj instanceof ImageBitmap) {
-                result.push(obj);
-            } else {
-                for (var i in obj) {
-                    if (obj.hasOwnProperty(i)) {
-                        extractTransferables(obj[i], result);
-                    }
-                }
-            }
-        }`,
-        'globalScope.onmessage = function(event){',
-        '   var eventData = event.data;',
-        '   var requestId = eventData.id',
-        '   var methodName = eventData.methodName;',
-        '   var parameters = eventData.parameters;',
-        '   var method = api[methodName];',
-
-        '   function sendResult(result){',
-        '       var transferables = [];',
-        '       extractTransferables(result, transferables);',
-        '       globalScope.postMessage({methodName: methodName, id: requestId, result: result}, transferables);',
-        '   }',
-
-        '   function sendError(error){',
-        '       let stack = "";',
-        '       try{stack = error.stack.split("\\n")}catch(e){}',
-        '       globalScope.postMessage({methodName: methodName, id: requestId, error: {message: error.message, stack: stack }});',
-        '   }',
-
-        '   if(method === undefined){',
-        '       sendError(new Error("API named \'"+methodName+"\' was not found."));',
-        '   }else{',
-        '       try{',
-        '           method.apply(null,parameters).then(sendResult, sendError);',
-        '       }catch(e){',
-        '           sendError(e);',
-        '       }',
-        '   }',
-        '};'
-    ]);
-
-    const code = codeLines.join("\n");
-    const workerURL = codeToURL(code);
-
-    const proxy = new WorkerProxy(workerURL, this.methods);
-    return proxy;
-};
-
 export default WorkerBuilder;

package/src/core/process/worker/WorkerProxy.js

@@ -39,29 +39,29 @@ function needsSerialization(value) {
 
 
 class WorkerProxy {
+
+    __pending = {};
+    __isRunning = false;
+
+    /**
+     *
+     * @type {Worker|null}
+     * @private
+     */
+    __worker = null;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __id_counter = 0;
+
+
     constructor(url, methods) {
         this.url = url;
         this.methods = methods;
 
-        this.__pending = {};
-        this.__isRunning = false;
-        /**
-         *
-         * @type {Worker|null}
-         * @private
-         */
-        this.__worker = null;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__id_counter = 0;
-        //
-
-        this.__handleMessageBound = this.__handleMessage.bind(this);
-
         this.__generateAPI(this, methods);
     }
 
@@ -119,6 +119,10 @@ class WorkerProxy {
     }
 
     __makeMethod(name) {
+        if (this.__pending.hasOwnProperty(name)) {
+            throw new Error(`Method '${name}' already defined`);
+        }
+
         this.__pending[name] = [];
 
         const proxy = this;
@@ -144,7 +148,7 @@ class WorkerProxy {
      * @param {Event} event
      * @private
      */
-    __handleMessage(event) {
+    __handleMessage = (event) => {
         const pending = this.__pending;
 
         const data = event.data;
@@ -262,7 +266,7 @@ class WorkerProxy {
         }
 
         this.__worker = new Worker(this.url);
-        this.__worker.onmessage = this.__handleMessageBound;
+        this.__worker.onmessage = this.__handleMessage;
 
         // TODO attach proper error handler
         this.__worker.onerror = (errorEvent) => {

package/src/core/process/worker/extractTransferables.js

@@ -6,7 +6,7 @@
  */
 export function extractTransferables(obj, result) {
     if (typeof obj !== "object") {
-        return; //not an object, skip
+        // not an object, skip
     } else if (obj instanceof ArrayBuffer) {
         result.push(obj);
     } else if (obj.buffer instanceof ArrayBuffer) {
@@ -14,7 +14,7 @@ export function extractTransferables(obj, result) {
     } else if (obj instanceof ImageBitmap) {
         result.push(obj);
     } else {
-        for (var i in obj) {
+        for (let i in obj) {
             if (obj.hasOwnProperty(i)) {
                 extractTransferables(obj[i], result);
             }

package/src/engine/Engine.js

@@ -2,35 +2,35 @@
  *
  */
 
+import {PerspectiveCamera as ThreePerspectiveCamera} from 'three';
+import {assert} from "../core/assert.js";
+import Vector1 from "../core/geom/Vector1.js";
+import {Localization} from "../core/localization/Localization.js";
+import {ModuleRegistry} from "../core/model/ModuleRegistry.js";
+import ObservedBoolean from "../core/model/ObservedBoolean.js";
 import ConcurrentExecutor from '../core/process/executor/ConcurrentExecutor.js';
+import EmptyView from "../view/elements/EmptyView.js";
+import {ViewStack} from "../view/elements/navigation/ViewStack.js";
 
-import { AssetManager } from './asset/AssetManager.js';
-import { GraphicsEngine } from './graphics/GraphicsEngine.js';
-import SoundEngine from './sound/SoundEngine.js';
-import { PerspectiveCamera as ThreePerspectiveCamera } from 'three';
-import { PointerDevice } from "./input/devices/PointerDevice.js";
-import KeyboardDevice from "./input/devices/KeyboardDevice.js";
+import {AssetManager} from './asset/AssetManager.js';
 import Preloader from "./asset/preloader/Preloader.js";
+import {MetricCollection} from "./development/performance/MetricCollection.js";
+import {MetricStatistics} from "./development/performance/MetricStatistics.js";
+import {PeriodicConsolePrinter} from "./development/performance/monitor/PeriodicConsolePrinter.js";
+import {EntityManager} from "./ecs/EntityManager.js";
+import {BinarySerializationRegistry} from "./ecs/storage/binary/BinarySerializationRegistry.js";
+import {GraphicsEngine} from './graphics/GraphicsEngine.js';
+import KeyboardDevice from "./input/devices/KeyboardDevice.js";
+import {PointerDevice} from "./input/devices/PointerDevice.js";
+import {StaticKnowledgeDatabase} from "./knowledge/database/StaticKnowledgeDatabase.js";
+import {logger} from "./logging/GlobalLogger.js";
+import {OptionGroup} from "./options/OptionGroup.js";
+import {EnginePluginManager} from "./plugin/EnginePluginManager.js";
 import SceneManager from "./scene/SceneManager.js";
+import Ticker from "./simulation/Ticker.js";
+import SoundEngine from './sound/SoundEngine.js';
 
 import GUIEngine from './ui/GUIEngine.js';
-import { EntityManager } from "./ecs/EntityManager.js";
-import ObservedBoolean from "../core/model/ObservedBoolean.js";
-import Vector1 from "../core/geom/Vector1.js";
-import { ViewStack } from "../view/elements/navigation/ViewStack.js";
-import EmptyView from "../view/elements/EmptyView.js";
-import { assert } from "../core/assert.js";
-import { StaticKnowledgeDatabase } from "./knowledge/database/StaticKnowledgeDatabase.js";
-import Ticker from "./simulation/Ticker.js";
-import { Localization } from "../core/localization/Localization.js";
-import { ModuleRegistry } from "../core/model/ModuleRegistry.js";
-import { BinarySerializationRegistry } from "./ecs/storage/binary/BinarySerializationRegistry.js";
-import { EnginePluginManager } from "./plugin/EnginePluginManager.js";
-import { OptionGroup } from "./options/OptionGroup.js";
-import { MetricCollection } from "./development/performance/MetricCollection.js";
-import { PeriodicConsolePrinter } from "./development/performance/monitor/PeriodicConsolePrinter.js";
-import { MetricStatistics } from "./development/performance/MetricStatistics.js";
-import { logger } from "./logging/GlobalLogger.js";
 
 
 function EngineSettings() {
@@ -44,6 +44,10 @@ const METRIC_ID_RENDER = 'render_time';
 const METRIC_ID_SIMULATION = 'simulation_time';
 
 class Engine {
+    #last_frame_timestamp = 0;
+
+    viewStack = new ViewStack();
+
     /**
      *
      * @param {EnginePlatform} platform
@@ -220,7 +224,7 @@ class Engine {
 
         if (enableGraphics !== false) {
 
-            const graphicsEngine = new GraphicsEngine(this.camera, this.entityManager);
+            const graphicsEngine = new GraphicsEngine(this.camera);
 
             /**
              *
@@ -317,8 +321,6 @@ class Engine {
         });
         this.gameView = gameView;
 
-
-        this.viewStack = new ViewStack();
         this.viewStack.push(gameView, 'game-view');
 
         if (this.graphics !== undefined) {
@@ -409,6 +411,8 @@ class Engine {
     }
 
     render() {
+        assert.isInstanceOf(this, Engine, 'this', 'Engine');
+
         const graphics = this.graphics;
 
         if (graphics.autoDraw) {
@@ -437,56 +441,38 @@ class Engine {
      * @returns {Promise}
      */
     start() {
-        const self = this;
-
-
         this.assetManager.startup();
 
-        function promiseEntityManager() {
-            return new Promise(function (resolve, reject) {
+        const promiseEntityManager = () => {
+            return new Promise((resolve, reject) => {
                 //initialize entity manager
-                self.entityManager.startup(resolve, reject);
+                this.entityManager.startup(resolve, reject);
             });
         }
 
         this.__performacne_monitor.start();
 
-        const metrics = this.performance;
-
         return Promise.all([
             this.sound.start()
                 .then(promiseEntityManager),
             this.staticKnowledge.load(this.assetManager, this.executor),
             this.gui.startup(this),
             this.plugins.startup()
-        ]).then(function () {
-
-            let t0 = performance.now();
-
-            function animate() {
-                const t1 = performance.now();
-                requestAnimationFrame(animate);
-                self.render();
+        ]).then(async () => {
 
-                const frame_delay = (t1 - t0) / 1000;
-
-                // swap variables
-                t0 = t1;
-
-                // record metric
-                metrics.get(METRIC_ID_FRAME).record(frame_delay);
-            }
+            this.#last_frame_timestamp = performance.now();
 
             /**
              * Starting the engine
              */
-            requestAnimationFrame(animate);
+            requestAnimationFrame(this.#animation_frame);
+
             //start simulation
-            self.ticker.start({ maxTimeout: 200 });
+            this.ticker.start({maxTimeout: 200});
             //self.uiController.init(self);
 
             //load options
-            self.options.attachToStorage('lazykitty.komrade.options', self.storage);
+            await this.options.attachToStorage('lazykitty.komrade.options', this.storage);
 
             logger.info('engine started');
         }, function (e) {
@@ -496,6 +482,25 @@ class Engine {
 
     }
 
+    /**
+     * Fired every animation frame via {@link requestAnimationFrame}
+     */
+    #animation_frame = () => {
+
+        const t0 = this.#last_frame_timestamp;
+        const t1 = performance.now();
+        requestAnimationFrame(this.#animation_frame);
+        this.render();
+
+        const frame_delay = (t1 - t0) / 1000;
+
+        // swap variables
+        this.#last_frame_timestamp = t1;
+
+        // record metric
+        this.performance.get(METRIC_ID_FRAME).record(frame_delay);
+    }
+
     /**
      * Shutdown the engine, disposing all relevant resources
      */

package/src/engine/EngineConfiguration.d.ts

@@ -1,7 +1,7 @@
-import {EnginePlugin} from "./plugin/EnginePlugin";
+import {AssetLoader} from "./asset/loaders/AssetLoader";
 import {System} from "./ecs/System";
 import {StaticKnowledgeDataTableDescriptor} from "./knowledge/database/StaticKnowledgeDataTableDescriptor";
-import {AssetLoader} from "./asset/loaders/AssetLoader";
+import {EnginePlugin} from "./plugin/EnginePlugin";
 
 export class EngineConfiguration {
     addPlugin(plugin: EnginePlugin): boolean
@@ -10,9 +10,9 @@ export class EngineConfiguration {
 
     addManySystems(...systems: System<any>[]): void
 
-    addDataTable(table: StaticKnowledgeDataTableDescriptor): boolean
+    addDataTable<T>(table: StaticKnowledgeDataTableDescriptor<T>): boolean
 
-    addLoader<T>(type: string, loader: AssetLoader<T>): boolean
+    addLoader<T, CTX>(type: string, loader: AssetLoader<T, CTX>): boolean
 
     hasLoader(type: string): boolean