@woosh/meep-engine 2.42.8 → 2.43.0

package/core/process/task/util/delayTask.js

@@ -0,0 +1,45 @@
+import Task from "../Task.js";
+import { TaskSignal } from "../TaskSignal.js";
+import { clamp01 } from "../../../math/clamp01.js";
+
+/**
+ *
+ * @param {number} delay in milliseconds
+ * @param {string} [name]
+ * @returns {Task}
+ */
+export function delayTask(delay, name = "unnamed") {
+    let startTime = -1;
+
+    const estimatedDuration = delay / 1000;
+    return new Task({
+        name: `delay (${delay}ms): ${name}`,
+        initializer() {
+            startTime = Date.now();
+        },
+        cycleFunction() {
+            if (Date.now() >= startTime + delay) {
+                return TaskSignal.EndSuccess;
+            } else {
+                return TaskSignal.Yield;
+            }
+        },
+        computeProgress() {
+            if (startTime === -1) {
+                return 0;
+            }
+
+            const currentTime = Date.now();
+            const remainingTime = currentTime - startTime;
+
+            let fraction = remainingTime / delay;
+
+            if (Number.isNaN(fraction)) {
+                fraction = 0;
+            }
+
+            return clamp01(fraction);
+        },
+        estimatedDuration
+    });
+}

package/core/process/task/util/emptyTask.js

@@ -0,0 +1,19 @@
+import Task from "../Task.js";
+import { TaskSignal } from "../TaskSignal.js";
+
+/**
+ * Does nothing, useful when a task is required but no work is needed
+ * @param {string} [name="no-operation"]
+ * @returns {Task}
+ */
+export function emptyTask(name = "no-operation") {
+    return new Task({
+        name,
+        cycleFunction: function () {
+            return TaskSignal.EndSuccess;
+        },
+        computeProgress: function () {
+            return 1;
+        }
+    });
+}

package/core/process/task/util/failingTask.js

@@ -0,0 +1,17 @@
+import Task from "../Task.js";
+
+/**
+ * Always fails by throwing an object that was given (typically an Error instance)
+ * @param {*} e value to be thrown
+ */
+export function failingTask(e) {
+    return new Task({
+        name: "Failing Task",
+        cycleFunction: function () {
+            throw e;
+        },
+        computeProgress: function () {
+            return 0;
+        }
+    });
+}

package/core/process/task/util/futureTask.js

@@ -0,0 +1,48 @@
+import { TaskSignal } from "../TaskSignal.js";
+import Task from "../Task.js";
+
+/**
+ *
+ * @param {Future} future
+ * @param {String} name
+ * @returns {Task}
+ */
+export function futureTask(future, name) {
+    if (typeof future.resolve !== 'function') {
+        // Not a future
+        throw new Error("No resolve function on the supplied object");
+    }
+
+    let resolved = false;
+    let rejected = false;
+    let error = null;
+
+    future.then(function () {
+        resolved = true;
+    }, function (e) {
+        rejected = true;
+        error = e;
+    });
+
+    function cycle() {
+        future.resolve();
+        if (resolved) {
+            return TaskSignal.EndSuccess;
+        } else if (rejected) {
+            throw error;
+        } else {
+            //give up CPU share
+            return TaskSignal.Yield;
+        }
+    }
+
+    function progress() {
+        return resolved ? 1 : 0;
+    }
+
+    return new Task({
+        name: name,
+        cycleFunction: cycle,
+        computeProgress: progress
+    });
+}

package/core/process/task/util/promiseTask.js

@@ -0,0 +1,42 @@
+import { TaskSignal } from "../TaskSignal.js";
+import Task from "../Task.js";
+
+/**
+ *
+ * @param {Promise} promise
+ * @param {string} name
+ * @returns {Task}
+ */
+export function promiseTask(promise, name) {
+    let resolved = false;
+    let rejected = false;
+    let error = null;
+
+    promise.then(function () {
+        resolved = true;
+    }, function (e) {
+        rejected = true;
+        error = e;
+    });
+
+    function cycle() {
+        if (resolved) {
+            return TaskSignal.EndSuccess;
+        } else if (rejected) {
+            throw error;
+        } else {
+            //give up CPU share
+            return TaskSignal.Yield;
+        }
+    }
+
+    function progress() {
+        return resolved ? 1 : 0;
+    }
+
+    return new Task({
+        name: name,
+        cycleFunction: cycle,
+        computeProgress: progress
+    });
+}

package/core/process/task/util/randomCountTask.js

@@ -0,0 +1,64 @@
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { TaskSignal } from "../TaskSignal.js";
+import Task from "../Task.js";
+import { randomizeArrayElementOrder } from "../../../collection/ArrayUtils.js";
+
+/**
+ *
+ * @param {number} seed RNG seed
+ * @param {number|function(*):number} initial
+ * @param {number|function(*):number} limit
+ * @param {function(index:int)} callback
+ * @returns {Task}
+ */
+export function randomCountTask(seed, initial, limit, callback) {
+
+    const random = seededRandom(seed);
+
+    const span = limit - initial;
+
+    const sequence = new Uint16Array(span);
+
+    let i = 0;
+
+    function cycle() {
+        if (i >= span) {
+            return TaskSignal.EndSuccess;
+        }
+
+        const order = sequence[i];
+
+        const index = order + initial;
+
+        callback(index);
+
+        i++;
+
+        return TaskSignal.Continue;
+    }
+
+    return new Task({
+        name: `Count ${initial} -> ${limit}`,
+        initializer() {
+
+            i = 0;
+
+            //generate sequence
+            for (let i = 0; i < span; i++) {
+                sequence[i] = i;
+            }
+
+            //shuffle
+            randomizeArrayElementOrder(random, sequence);
+        },
+        cycleFunction: cycle,
+        computeProgress: function () {
+
+            if (span === 0) {
+                return 0;
+            }
+
+            return i / span;
+        }
+    });
+}

package/core/process/task/util/wrapTaskIgnoreFailure.js

@@ -0,0 +1,47 @@
+import Task from "../Task.js";
+import { TaskSignal } from "../TaskSignal.js";
+
+/**
+ *
+ * @param {Task} task
+ * @returns {Task}
+ */
+export function wrapTaskIgnoreFailure(task) {
+    let initializationFailed = false;
+
+    const wrapper = new Task({
+        name: `Ignore Failure of [${task.name}]`,
+        initializer() {
+            try {
+                task.initialize();
+            } catch (e) {
+                initializationFailed = true;
+                console.warn(e);
+            }
+        },
+        estimatedDuration: task.estimatedDuration,
+        cycleFunction() {
+
+            task.__executedCpuTime = wrapper.__executedCpuTime;
+            task.__executedCycleCount = wrapper.__executedCycleCount;
+
+            if (initializationFailed) {
+                //initializer failed, don't execute the source task
+                return TaskSignal.EndSuccess;
+            }
+
+            const c = task.cycle();
+
+            if (c === TaskSignal.EndFailure) {
+                return TaskSignal.EndSuccess;
+            }
+
+            return c;
+        },
+        computeProgress() {
+            return task.computeProgress();
+        }
+    });
+
+    return wrapper;
+}

package/engine/Engine.js

@@ -11,10 +11,8 @@ 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 Grid from './grid/Grid.js';
 import Preloader from "./asset/preloader/Preloader.js";
 import SceneManager from "./scene/SceneManager.js";
-import CompressionService from "./compression/CompressionService.js";
 
 import GUIEngine from './ui/GUIEngine.js';
 import { EntityManager } from "./ecs/EntityManager.js";
@@ -189,9 +187,10 @@ class Engine {
         this.settings = new EngineSettings();
 
 
-        this.services = {
-            compression: new CompressionService()
-        };
+        /**
+         * @deprecated use plugins instead
+         */
+        this.services = {};
 
         /**
          *
@@ -251,9 +250,6 @@ class Engine {
          */
         this.sceneManager = new SceneManager(this.entityManager, this.ticker.clock);
 
-        //
-        this.grid = new Grid(this);
-
         this.initializeViews();
 
         this.devices = {
@@ -281,6 +277,10 @@ class Engine {
         this.plugins.initialize(this);
     }
 
+    get grid() {
+        throw new Error('Deprecated, use systems/components to achieve the same functionality as before');
+    }
+
     initializeViews() {
 
         const viewport = this.graphics.viewport;

package/engine/EngineBootstrapper.js

@@ -41,7 +41,7 @@ export class EngineBootstrapper {
 
         const frameRunner = new FrameRunner(() => {
             vExecutionEngineState.updateText(`Executor: ${engine.executor.queueReady.length} ready, ${engine.executor.queueUnresolved.length} unresolved`);
-            vAssetManagerState.updateText(`Assets: ${engine.assetManager.assets.size} loaded, ${engine.assetManager.requestMap.size} pending`);
+            vAssetManagerState.updateText(`Assets: ${engine.assetManager.assets.size} loaded, ${engine.assetManager.request_map.size} pending`);
         });
 
         frameRunner.startup();