@woosh/meep-engine 2.48.11 → 2.48.13

package/package.json

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

package/src/core/collection/HashMap.js

@@ -589,7 +589,7 @@ export class HashMap {
                 } else {
                     return {
                         done: false,
-                        value: n.value[0]
+                        value: n.value[1]
                     };
                 }
 
@@ -616,7 +616,7 @@ export class HashMap {
                 } else {
                     return {
                         done: false,
-                        value: n.value[1]
+                        value: n.value[0]
                     };
                 }
 

package/src/core/collection/HashMap.spec.js

@@ -1,5 +1,5 @@
 import { HashMap } from "./HashMap.js";
-import { passThrough, strictEquals } from "../function/Functions.js";
+import { passThrough, returnOne, strictEquals } from "../function/Functions.js";
 
 /**
  *
@@ -74,3 +74,26 @@ test("retrieval works as intended after hash map grows", () => {
     expect(m.get(-7)).toEqual("c");
 
 });
+
+
+test("key iterator", () => {
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.set(7, "hello");
+
+    expect(map.keys().next().value).toBe(7);
+});
+
+test("value iterator", () => {
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.set(7, "hello");
+
+    expect(map.values().next().value).toBe("hello");
+});

package/src/core/collection/queue/Deque.d.ts

@@ -7,6 +7,8 @@ export class Deque<T> {
 
     size(): number
 
+    isEmpty(): boolean
+
     remove(e: T): boolean
 
     has(e: T): boolean
@@ -17,4 +19,11 @@ export class Deque<T> {
 
     add(e: T): void
 
+    addFirst(e: T): void
+
+    removeFirst(): T
+
+    addLast(e: T): void
+
+    removeLast(): T
 }

package/src/core/collection/queue/Deque.js

@@ -1,6 +1,7 @@
 import { ceilPowerOfTwo } from "../../binary/operations/ceilPowerOfTwo.js";
 import { max2 } from "../../math/max2.js";
 import { array_copy } from "../array/copyArray.js";
+import { assert } from "../../assert.js";
 
 const DEFAULT_SIZE = 16;
 
@@ -18,6 +19,8 @@ export class Deque {
      */
     constructor(minSize = DEFAULT_SIZE) {
 
+        assert.isNonNegativeInteger(minSize, 'minSize');
+
         const size = ceilPowerOfTwo(max2(DEFAULT_SIZE, minSize));
 
         /**

package/src/core/collection/queue/Deque.spec.js

@@ -87,3 +87,54 @@ test('size', () => {
 
     expect(deque.size()).toBe(0);
 });
+
+test("remove the only item", () => {
+    const deque = new Deque();
+
+    deque.add(7);
+
+    expect(deque.remove(7)).toBe(true);
+
+    expect(deque.size()).toBe(0);
+});
+
+test("remove first item", () => {
+
+    const deque = new Deque();
+
+    deque.add(7);
+    deque.add(13);
+
+    expect(deque.remove(7)).toBe(true);
+    expect(deque.size()).toBe(1);
+
+    expect(deque.pop()).toBe(13);
+});
+
+test("remove last item", () => {
+
+    const deque = new Deque();
+
+    deque.add(7);
+    deque.add(13);
+
+    expect(deque.remove(13)).toBe(true);
+    expect(deque.size()).toBe(1);
+
+    expect(deque.pop()).toBe(7);
+});
+
+test("remove middle item", () => {
+
+    const deque = new Deque();
+
+    deque.add(7);
+    deque.add(13);
+    deque.add(17);
+
+    expect(deque.remove(13)).toBe(true);
+    expect(deque.size()).toBe(2);
+
+    expect(deque.pop()).toBe(7);
+    expect(deque.pop()).toBe(17);
+});

package/src/core/debug/matchers/matchers.js

@@ -10,10 +10,20 @@ import { IsIn } from "./IsIn.js";
 import { IsAnything } from "./IsAnything.js";
 import { DescribeAs } from "./DescribeAs.js";
 
+/**
+ * @template T
+ * @param {Matcher<T>} matchers
+ * @return {Matcher<T>}
+ */
 export function anyOf(...matchers) {
     return new AnyOf(matchers);
 }
 
+/**
+ * @template T
+ * @param {Matcher<T>} matchers
+ * @return {Matcher<T>}
+ */
 export function allOf(...matchers) {
     return new AllOf(matchers);
 }

package/src/core/math/noise/create_noise_2d.js

@@ -0,0 +1,193 @@
+/*
+NOTE: this implementation is adapted from https://github.com/jwagner/simplex-noise.js
+ */
+
+// these #__PURE__ comments help uglifyjs with dead code removal
+//
+const F2 = /*#__PURE__*/ 0.5 * (Math.sqrt(3.0) - 1.0);
+const G2 = /*#__PURE__*/ (3.0 - Math.sqrt(3.0)) / 6.0;
+const F3 = 1.0 / 3.0;
+const G3 = 1.0 / 6.0;
+const F4 = /*#__PURE__*/ (Math.sqrt(5.0) - 1.0) / 4.0;
+const G4 = /*#__PURE__*/ (5.0 - Math.sqrt(5.0)) / 20.0;
+const grad2 = /*#__PURE__*/ new Int8Array([1, 1,
+    -1, 1,
+    1, -1,
+
+    -1, -1,
+    1, 0,
+    -1, 0,
+
+    1, 0,
+    -1, 0,
+    0, 1,
+
+    0, -1,
+    0, 1,
+    0, -1]);
+
+// double seems to be faster than single or int's
+// probably because most operations are in double precision
+const grad3 = /*#__PURE__*/ new Float64Array([1, 1, 0,
+    -1, 1, 0,
+    1, -1, 0,
+
+    -1, -1, 0,
+    1, 0, 1,
+    -1, 0, 1,
+
+    1, 0, -1,
+    -1, 0, -1,
+    0, 1, 1,
+
+    0, -1, 1,
+    0, 1, -1,
+    0, -1, -1]);
+
+// double is a bit quicker here as well
+const grad4 = /*#__PURE__*/ new Float64Array([0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1,
+    0, -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1,
+    1, 0, 1, 1, 1, 0, 1, -1, 1, 0, -1, 1, 1, 0, -1, -1,
+    -1, 0, 1, 1, -1, 0, 1, -1, -1, 0, -1, 1, -1, 0, -1, -1,
+    1, 1, 0, 1, 1, 1, 0, -1, 1, -1, 0, 1, 1, -1, 0, -1,
+    -1, 1, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, -1,
+    1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1, 0,
+    -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1, 0]);
+
+
+/**
+ * Creates a 2D noise function
+ * @param random the random function that will be used to build the permutation table
+ * @returns {function(x:number, y:number):number}
+ */
+export function createNoise2D(random = Math.random) {
+    // allocate continuous chunk of memory
+    const buffer = new ArrayBuffer(512 * 2);
+
+    const perm = new Uint8Array(buffer, 0, 512);
+    buildPermutationTable(random, perm);
+
+    const permMod12 = new Uint8Array(buffer, 512, 512);
+
+    for (let i = 0; i < 512; i++) {
+        permMod12[i] = (perm[i] % 12) * 2;
+    }
+
+    return function noise2D(x, y) {
+        // if(!isFinite(x) || !isFinite(y)) return 0;
+        let n0 = 0; // Noise contributions from the three corners
+        let n1 = 0;
+        let n2 = 0;
+        // Skew the input space to determine which simplex cell we're in
+        const s = (x + y) * F2; // Hairy factor for 2D
+
+        const i = (x + s) | 0;
+        const j = (y + s) | 0;
+
+        const t = (i + j) * G2;
+        const X0 = i - t; // Unskew the cell origin back to (x,y) space
+        const Y0 = j - t;
+        const x0 = x - X0; // The x,y distances from the cell origin
+        const y0 = y - Y0;
+        // For the 2D case, the simplex shape is an equilateral triangle.
+        // Determine which simplex we are in.
+        let i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
+        if (x0 > y0) {
+            i1 = 1;
+            j1 = 0;
+        } // lower triangle, XY order: (0,0)->(1,0)->(1,1)
+        else {
+            i1 = 0;
+            j1 = 1;
+        } // upper triangle, YX order: (0,0)->(0,1)->(1,1)
+        // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
+        // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
+        // c = (3-sqrt(3))/6
+        const x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+        const y1 = y0 - j1 + G2;
+        const x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
+        const y2 = y0 - 1.0 + 2.0 * G2;
+        // Work out the hashed gradient indices of the three simplex corners
+        const ii = i & 255;
+        const jj = j & 255;
+        // Calculate the contribution from the three corners
+        let t0 = 0.5 - x0 * x0 - y0 * y0;
+
+        if (t0 >= 0) {
+            const gi0 = ii + perm[jj];
+            const gi01 = permMod12[gi0];
+
+            const g0x = grad2[gi01];
+            const g0y = grad2[gi01 + 1];
+
+            t0 *= t0;
+            // n0 = t0 * t0 * (grad2[gi0] * x0 + grad2[gi0 + 1] * y0); // (x,y) of grad3 used for 2D gradient
+            n0 = t0 * t0 * (g0x * x0 + g0y * y0);
+        }
+
+        let t1 = 0.5 - x1 * x1 - y1 * y1;
+
+        if (t1 >= 0) {
+            const gi1 = ii + i1 + perm[jj + j1];
+            const gi11 = permMod12[gi1];
+
+            const g1x = grad2[gi11];
+            const g1y = grad2[gi11 + 1];
+
+            t1 *= t1;
+            // n1 = t1 * t1 * (grad2[gi1] * x1 + grad2[gi1 + 1] * y1);
+            n1 = t1 * t1 * (g1x * x1 + g1y * y1);
+        }
+
+        let t2 = 0.5 - x2 * x2 - y2 * y2;
+
+        if (t2 >= 0) {
+            const gi2 = ii + 1 + perm[jj + 1];
+
+            const gi21 = permMod12[gi2];
+
+            const g2x = grad2[gi21];
+            const g2y = grad2[gi21 + 1];
+
+            t2 *= t2;
+            // n2 = t2 * t2 * (grad2[gi2] * x2 + grad2[gi2 + 1] * y2);
+            n2 = t2 * t2 * (g2x * x2 + g2y * y2);
+        }
+
+        // Add contributions from each corner to get the final noise value.
+        // The result is scaled to return values in the interval [-1,1].
+        return 70.0 * (n0 + n1 + n2);
+    };
+}
+
+/**
+ * Builds a random permutation table.
+ * This is exported only for (internal) testing purposes.
+ * Do not rely on this export.
+ * @param {function} random
+ * @param {Uint8Array} p
+ * @private
+ */
+export function buildPermutationTable(random, p) {
+    const table_size = 512;
+
+    const half_table_size = table_size >>> 1;
+
+    for (let i = 0; i < half_table_size; i++) {
+        p[i] = i;
+    }
+
+    for (let i = 0; i < half_table_size - 1; i++) {
+        const r = i + ~~(random() * (256 - i));
+        const aux = p[i];
+
+        p[i] = p[r];
+        p[r] = aux;
+    }
+
+    for (let i = 256; i < table_size; i++) {
+        p[i] = p[i - 256];
+    }
+
+    return p;
+}

package/src/engine/Engine.js

@@ -100,6 +100,15 @@ class Engine {
          */
         this.ticker = new Ticker();
 
+        /**
+         *
+         * @type {AssetManager<Engine>}
+         */
+        this.assetManager = new AssetManager({
+            context:this,
+            executor: this.executor
+        });
+
         this.__performacne_monitor = new PeriodicConsolePrinter(15, () => {
             const metrics = this.performance;
             const stats = new MetricStatistics();
@@ -198,11 +207,6 @@ class Engine {
          */
         this.storage = this.platform.getStorage();
 
-        /**
-         *
-         * @type {AssetManager}
-         */
-        this.assetManager = new AssetManager(this);
 
         this.localization = new Localization();
         this.localization.setAssetManager(this.assetManager);

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

@@ -2,14 +2,19 @@ import {AssetLoader} from "./loaders/AssetLoader";
 import {Asset} from "./Asset";
 import {CrossOriginConfig} from "./CORS/CrossOriginConfig";
 import {AssetTransformer} from "./AssetTransformer";
-import Engine from "../Engine";
+import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor";
 
 interface PromiseOptions {
     skip_queue: boolean
 }
 
-export class AssetManager {
-    constructor(engine: Engine)
+interface AssetManagerOptions<CTX> {
+    context: CTX,
+    executor?: ConcurrentExecutor
+}
+
+export class AssetManager<CTX> {
+    constructor(options?: AssetManagerOptions<CTX>)
 
     public readonly crossOriginConfig: CrossOriginConfig
 
@@ -25,11 +30,11 @@ export class AssetManager {
 
     clear(): void
 
-    registerLoader<T>(type: string, loader: AssetLoader<T>): Promise<AssetLoader<T>>
+    registerLoader<T>(type: string, loader: AssetLoader<T, CTX>): Promise<AssetLoader<T,CTX>>
 
     unregisterLoader(type: string): Promise<void>
 
-    getLoaderByType<T>(type: string): AssetLoader<T> | undefined
+    getLoaderByType<T>(type: string): AssetLoader<T, CTX> | undefined
 
     registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void
 

package/src/engine/asset/AssetManager.js

@@ -19,6 +19,7 @@ import { AssetRequest, AssetRequestFlags } from "./AssetRequest.js";
 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";
 
 
 class Response {
@@ -45,6 +46,7 @@ function get_pending_asset_priority_score(pending_asset) {
 
 /**
  * Handles loading/generating assets
+ * @template CTX
  * @class
  */
 export class AssetManager {
@@ -164,19 +166,30 @@ export class AssetManager {
 
     /**
      *
-     * @type {Engine|null}
+     * @type {CTX|null}
      * @private
      */
-    #engine = null;
+    #context = null;
 
     /**
      *
-     * @param {Engine} engine
+     * @type {ConcurrentExecutor|null}
+     */
+    #executor = null;
+
+    /**
+     *
+     * @param {CTX} context
+     * @param {ConcurrentExecutor} executor
      * @constructor
      */
-    constructor(engine) {
+    constructor({
+                    context,
+                    executor = new ConcurrentExecutor()
+                } = {}) {
 
-        this.#engine = engine;
+        this.#context = context;
+        this.#executor = executor;
 
     }
 
@@ -185,7 +198,7 @@ export class AssetManager {
             return;
         }
 
-        this.#engine.executor.run(this.#response_processor);
+        this.#executor.run(this.#response_processor);
 
         this.#is_running = true;
     }
@@ -205,7 +218,7 @@ export class AssetManager {
             await Promise.allSettled([Task.promise(this.#response_processor)]);
         }
 
-        this.#engine.executor.removeTask(this.#response_processor);
+        this.#executor.removeTask(this.#response_processor);
 
         this.#is_running = false;
     }
@@ -260,7 +273,7 @@ export class AssetManager {
             throw new Error("Path must be string. Path = " + JSON.stringify(path));
         }
 
-        if(typeof type !== "string"){
+        if (typeof type !== "string") {
             throw new TypeError(`type must be a string, instead was '${typeof type}'`);
         }
 
@@ -696,7 +709,7 @@ export class AssetManager {
 
         } else {
 
-            await loader.link(this, this.#engine);
+            await loader.link(this, this.#context);
 
         }
 

package/src/engine/asset/PendingAsset.js

@@ -38,16 +38,16 @@ 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;
 

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

@@ -1,5 +1,10 @@
 import {Asset} from "../Asset";
 
-export class AssetLoader<T> {
-    public load(path: string, success: (asset: Asset<T>) => void, failure: (reason: any) => void, progress: (current: number, total: number) => void)
+export class AssetLoader<T,CTX> {
+    public load(
+        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 {Engine}
+     */
+    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;
     }
 
     /**

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;
 
         /**
          *

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

@@ -13,7 +13,7 @@ export class SoundAssetLoader extends AssetLoader {
          *
          * @type {AudioContext}
          */
-        this.context = context;
+        this.audioContext = context;
     }
 
     load(path, success, failure, progress) {
@@ -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/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);