@woosh/meep-engine 2.42.7 → 2.43.0

package/view/minimap/gl/MinimapTerrainGL.js

@@ -1,10 +1,9 @@
 import { MinimapWorldLayer } from "./MinimapWorldLayer.js";
-import { Mesh, MeshBasicMaterial, PlaneBufferGeometry } from "three";
+import { Mesh, MeshBasicMaterial, NearestFilter, PlaneBufferGeometry } from "three";
 import ObservedValue from "../../../core/model/ObservedValue.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { Cache } from "../../../core/cache/Cache.js";
 import { GameAssetType } from "../../../engine/asset/GameAssetType.js";
-import { NearestFilter } from "three/src/constants.js";
 
 export class MinimapTerrainGL extends MinimapWorldLayer {
     /**

package/view/renderModel.js

@@ -4,10 +4,10 @@
 import Future from '../core/process/Future.js';
 
 import ConcurrentExecutor from '../core/process/executor/ConcurrentExecutor.js';
-import { futureTask } from "../core/process/task/TaskUtils.js";
 import { promiseMaterialLoaded } from "../engine/graphics/util/promiseMaterialLoaded.js";
 import { guessAssetType } from "../engine/asset/guessAssetType.js";
 import { makeModelView as _makeModelView } from "../engine/graphics/makeModelView.js";
+import { futureTask } from "../core/process/task/util/futureTask.js";
 
 
 //use an executor to prevent stalling main thread when building previews

package/view/tooltip/TooltipView.js

@@ -1,11 +1,12 @@
 import View from "../View.js";
-import dom from "../DOM.js";
 import Vector2 from "../../core/geom/Vector2.js";
-import { forceIntoBox, pullBoxTowardsPoint, resolveAABB2Overlap } from "../../core/graph/layout/BoxLayouter.js";
 import AABB2 from "../../core/geom/AABB2.js";
 import { CompassArrowView } from "../elements/CompassArrowView.js";
 import EmptyView from "../elements/EmptyView.js";
 import { EPSILON } from "../../core/math/MathUtils.js";
+import { forceIntoBox } from "../../core/graph/layout/box/forceIntoBox.js";
+import { pullBoxTowardsPoint } from "../../core/graph/layout/box/pullBoxTowardsPoint.js";
+import { resolveAABB2Overlap } from "../../core/graph/layout/box/resolveAABB2Overlap.js";
 
 
 class TooltipView extends View {
@@ -25,10 +26,9 @@ class TooltipView extends View {
          */
         this.model = tip;
 
-        //build dom tree
-        const dRoot = dom('div').addClass("tooltip-view");
         //set dom element
-        this.el = dRoot.el;
+        this.el = document.createElement('div');
+        this.addClass("tooltip-view");
 
         const vContents = new EmptyView({ classList: ['contents'] });
 

package/core/process/task/TaskUtils.js

@@ -1,352 +0,0 @@
-/**
- * Created by Alex on 22/05/2016.
- */
-import { randomizeArrayElementOrder } from "../../collection/ArrayUtils.js";
-import { seededRandom } from "../../math/random/seededRandom.js";
-import Task from "./Task.js";
-import { TaskSignal } from "./TaskSignal.js";
-import { clamp01 } from "../../math/clamp01.js";
-
-/**
- *
- * @param {function} action
- * @param {string} name
- * @return {Task}
- */
-export function actionTask(action, name = "unnamed") {
-    return new Task({
-        name,
-        cycleFunction() {
-            action();
-
-            return TaskSignal.EndSuccess;
-        }
-    });
-}
-
-/**
- *
- * @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;
-        }
-    });
-}
-
-/**
- *
- * @param {number|function(*):number} initial
- * @param {number|function(*):number} limit
- * @param {function(index:int)} callback
- * @returns {Task}
- */
-export function countTask(initial, limit, callback) {
-    let initialValue = 0;
-    let limitValue = 0;
-
-    let i = initialValue;
-
-    function cycle() {
-        if (i >= limitValue) {
-            return TaskSignal.EndSuccess;
-        }
-        callback(i);
-        i++;
-
-        return TaskSignal.Continue;
-    }
-
-    const initialType = typeof initial;
-    const limitType = typeof limit;
-
-    const name = "count (from " + ((initialType === 'number') ? initial : 'variable') + " to " + ((limitType === 'number') ? limit : 'variable') + ")";
-
-    return new Task({
-        name: name,
-        initializer() {
-
-            if (initialType === "number") {
-                initialValue = initial;
-            } else if (initialType === "function") {
-                initialValue = initial();
-            }
-
-            if (limitType === "number") {
-                limitValue = limit;
-            } else if (limitType === "function") {
-                limitValue = limit();
-            }
-
-            i = initialValue;
-
-        },
-        cycleFunction: cycle,
-        computeProgress: function () {
-            const span = limitValue - initialValue;
-
-            if (span === 0) {
-                return 0;
-            }
-
-            return (i - initialValue) / span;
-        }
-    });
-}
-
-/**
- *
- * @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
-    });
-}
-
-/**
- *
- * @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;
-        }
-    });
-}
-
-/**
- *
- * @param e value to be thrown
- */
-export function failingTask(e) {
-    return new Task({
-        name: "Failing Task",
-        cycleFunction: function () {
-            throw e;
-        },
-        computeProgress: function () {
-            return 0;
-        }
-    });
-}
-
-/**
- *
- * @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
-    });
-}
-
-/**
- *
- * @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
-    });
-}
-
-
-/**
- *
- * @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;
-}