@woosh/meep-engine 2.49.3 → 2.49.6

package/package.json

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

package/src/core/cache/LoadingCache.d.ts

@@ -0,0 +1,19 @@
+export declare class LoadingCache<K, V> {
+    constructor(options: {
+        maxWeight?: number,
+        keyWeigher?: (key: K) => number,
+        valueWeigher?: (value: V) => number,
+        keyHashFunction?: (key: K) => number,
+        keyEqualityFunction?: (a: K, b: K) => boolean,
+        capacity?: number,
+        timeToLive?: number,
+        load: (key: K) => Promise<V>,
+        retryFailed?: boolean
+    })
+
+    invalidate(key: K): void
+
+    clear(): void
+
+    get(key: K): Promise<V>
+}

package/src/core/cache/LoadingCache.js

@@ -0,0 +1,144 @@
+//
+
+import { Cache } from "./Cache.js";
+
+/**
+ * @template R
+ */
+class Record {
+    /**
+     * @template R
+     * @param {R} value
+     * @param {number} time
+     */
+    constructor(value, time) {
+        this.value = value;
+        this.time = time;
+        this.failed = false;
+    }
+}
+
+const DEFAULT_TIME_TO_LIVE = 10;
+
+/**
+ * @template K,V
+ */
+export class LoadingCache {
+    /**
+     * @type {Cache<K,Record<Promise<V>>>}
+     */
+    #internal
+    /**
+     * In seconds
+     * @type {number}
+     */
+    #timeToLive = DEFAULT_TIME_TO_LIVE;
+
+    /**
+     * @type {function(key:K):Promise<V>}
+     */
+    #load
+
+    /**
+     *
+     * @type {boolean}
+     */
+    #policyRetryFailed = true;
+
+    /**
+     * @see {@link Cache} for more details on what each parameter means
+     * @param maxWeight
+     * @param keyWeigher
+     * @param valueWeigher
+     * @param keyHashFunction
+     * @param keyEqualityFunction
+     * @param capacity
+     * @param {number} [timeToLive] in seconds
+     * @param load
+     * @param {boolean} [retryFailed]
+     */
+    constructor({
+                    maxWeight,
+                    keyWeigher,
+                    valueWeigher,
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    capacity,
+                    timeToLive = DEFAULT_TIME_TO_LIVE,
+                    load,
+                    retryFailed = true
+                }) {
+
+        this.#internal = new Cache({
+            maxWeight,
+            keyWeigher,
+            valueWeigher,
+            keyHashFunction,
+            keyEqualityFunction,
+            capacity,
+        });
+
+        this.#timeToLive = timeToLive;
+        this.#load = load;
+        this.#policyRetryFailed = retryFailed;
+    }
+
+    /**
+     *
+     * @param {K} key
+     */
+    invalidate(key) {
+        this.#internal.remove(key);
+    }
+
+    /**
+     *
+     */
+    clear() {
+        this.#internal.clear();
+    }
+
+    /**
+     *
+     * @param {K} key
+     * @return {Promise<V>}
+     */
+    async get(key) {
+        const currentTime = performance.now() * 1e-3;
+
+        /**
+         *
+         * @type {Record<Promise<V>>}
+         */
+        let record = this.#internal.get(key);
+
+        if (record === null
+            || (record.time + this.#timeToLive) < currentTime  // timeout
+            || (record.failed && this.#policyRetryFailed) // load failed and we're configured to retry
+        ) {
+
+            // record needs to be loaded
+
+            let promise;
+
+            try {
+                promise = this.#load(key);
+            }catch (e){
+                promise = Promise.reject(e);
+            }
+
+            record = new Record(promise, currentTime);
+
+            this.#internal.put(key, record);
+
+            promise.catch(() => {
+                // mark as failure
+                record.failed = true;
+            });
+
+        }
+
+
+        return record.value;
+    }
+}

package/src/core/cache/LoadingCache.spec.js

@@ -0,0 +1,47 @@
+import { LoadingCache } from "./LoadingCache.js";
+import { delay } from "../process/delay.js";
+
+test("successful load", async () => {
+    const cache = new LoadingCache({
+        async load(key) {
+            return 17;
+        }
+    });
+
+    expect(await cache.get(1)).toEqual(17);
+});
+
+test("record reuse", async () => {
+    const load = jest.fn(async () => 17);
+
+    const cache = new LoadingCache({
+        load
+    });
+
+    expect(await cache.get(1)).toEqual(17);
+    expect(await cache.get(1)).toEqual(17);
+
+    expect(load).toHaveBeenCalledTimes(1);
+});
+
+test("timeout reload reuse", async () => {
+
+    const values = [3, 5, 11];
+
+    const load = jest.fn(async () => values.pop());
+
+    const cache = new LoadingCache({
+        load,
+        timeToLive: 0.00001
+    });
+
+    expect(await cache.get(1)).toEqual(11);
+
+    await delay(1);
+
+    expect(await cache.get(1)).toEqual(5);
+
+    await delay(1);
+
+    expect(await cache.get(1)).toEqual(3);
+});

package/src/core/geom/3d/compute_triangle_normal.js

@@ -1,55 +1,5 @@
-import { v3_length_sqr } from "../v3_length_sqr.js";
 import { vec3 } from "gl-matrix";
-
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {number} vAx
- * @param {number} vAy
- * @param {number} vAz
- * @param {number} vBx
- * @param {number} vBy
- * @param {number} vBz
- * @param {number} vCx
- * @param {number} vCy
- * @param {number} vCz
- */
-export function v3_compute_triangle_normal(result, result_offset, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz) {
-    //compute CB and AB vectors
-    const vCBx = vCx - vBx;
-    const vCBy = vCy - vBy;
-    const vCBz = vCz - vBz;
-
-    const vABx = vAx - vBx;
-    const vABy = vAy - vBy;
-    const vABz = vAz - vBz;
-
-    //compute triangle normal
-    const crossX = vCBy * vABz - vCBz * vABy;
-    const crossY = vCBz * vABx - vCBx * vABz;
-    const crossZ = vCBx * vABy - vCBy * vABx;
-
-    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
-
-    if (l_sqr === 0) {
-        // degenerate triangle, provide arbitrary invalid result
-        result[result_offset] = 0;
-        result[result_offset + 1] = 1;
-        result[result_offset + 2] = 0;
-        return;
-    }
-
-    const l_inv = 1 / Math.sqrt(l_sqr);
-
-    const x = crossX * l_inv;
-    const y = crossY * l_inv;
-    const z = crossZ * l_inv;
-
-    result[result_offset] = x;
-    result[result_offset + 1] = y;
-    result[result_offset + 2] = z;
-}
+import { v3_compute_triangle_normal } from "./v3_compute_triangle_normal.js";
 
 /**
  *

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -613,9 +613,9 @@ function windowSH(output, output_offset, input, input_offset, numBands, channel_
 
 /**
  *
- * @param {number[]} result
+ * @param {number[]|Float32Array} result
  * @param {number} result_offset
- * @param {number[]} harmonics
+ * @param {number[]|Float32Array} harmonics
  * @param {number} harmonics_offset
  * @param {number} dimension_count
  */

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.spec.js

@@ -0,0 +1,27 @@
+import { sh3_dering_optimize_positive } from "./sh3_dering_optimize_positive.js";
+
+test("de-ringing produces plausible numeric values", () => {
+
+    const result = [];
+
+    const harmonics = new Float32Array(9);
+
+    harmonics.fill(1);
+
+    sh3_dering_optimize_positive(
+        result, 0,
+        harmonics,
+        0,
+        1
+    );
+
+    for (let i = 0; i < 9; i++) {
+
+        const element = result[i];
+
+        expect(element).not.toBeNaN();
+        expect(Number.isFinite(element)).toBe(true);
+
+    }
+
+});

package/src/core/geom/3d/triangle/computeTriangleRayIntersection.spec.js

@@ -0,0 +1,25 @@
+import { computeTriangleRayIntersection } from "./computeTriangleRayIntersection.js";
+import { SurfacePoint3 } from "../SurfacePoint3.js";
+
+test("simple axis aligned intersection", () => {
+    const sp = new SurfacePoint3();
+
+    expect(computeTriangleRayIntersection(
+        sp,
+        0, 0, -1,
+        0, 0, 1,
+        -1, -1, 0,
+        1, -1, 0,
+        0, 1, 0
+    )).toBe(true);
+
+    expect(computeTriangleRayIntersection(
+        sp,
+        0, 0, -1,
+        0, 0, -1,
+        -1, -1, 0,
+        1, -1, 0,
+        0, 1, 0
+    )).toBe(false);
+
+});

package/src/core/geom/3d/v3_compute_triangle_normal.js

@@ -0,0 +1,51 @@
+import { v3_length_sqr } from "../v3_length_sqr.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} vAx
+ * @param {number} vAy
+ * @param {number} vAz
+ * @param {number} vBx
+ * @param {number} vBy
+ * @param {number} vBz
+ * @param {number} vCx
+ * @param {number} vCy
+ * @param {number} vCz
+ */
+export function v3_compute_triangle_normal(result, result_offset, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz) {
+    //compute CB and AB vectors
+    const vCBx = vCx - vBx;
+    const vCBy = vCy - vBy;
+    const vCBz = vCz - vBz;
+
+    const vABx = vAx - vBx;
+    const vABy = vAy - vBy;
+    const vABz = vAz - vBz;
+
+    //compute triangle normal
+    const crossX = vCBy * vABz - vCBz * vABy;
+    const crossY = vCBz * vABx - vCBx * vABz;
+    const crossZ = vCBx * vABy - vCBy * vABx;
+
+    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
+
+    if (l_sqr === 0) {
+        // degenerate triangle, provide arbitrary invalid result
+        result[result_offset] = 0;
+        result[result_offset + 1] = 1;
+        result[result_offset + 2] = 0;
+        return;
+    }
+
+    const l_inv = 1 / Math.sqrt(l_sqr);
+
+    const x = crossX * l_inv;
+    const y = crossY * l_inv;
+    const z = crossZ * l_inv;
+
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
+}

package/src/core/geom/3d/v3_compute_triangle_normal.spec.js

@@ -0,0 +1,27 @@
+import { v3_compute_triangle_normal } from "./v3_compute_triangle_normal.js";
+
+test("axis aligned triangles on +X plane", () => {
+    const result = [];
+
+    v3_compute_triangle_normal(
+        result, 0,
+        0, -1, -1,
+        0, 1, -1,
+        0, 0, 1,
+    );
+
+    expect(result).toEqual([+1, 0, 0]);
+});
+
+test("axis aligned triangles on -X plane", () => {
+    const result = [];
+
+    v3_compute_triangle_normal(
+        result, 0,
+        0, 0, 1,
+        0, 1, -1,
+        0, -1, -1,
+    );
+
+    expect(result).toEqual([-1, 0, 0]);
+});

package/src/core/geom/packing/miniball/Miniball.spec.js

@@ -0,0 +1,11 @@
+import { Miniball } from "./Miniball.js";
+import { PointSet } from "./PointSet.js";
+
+test("single point in 1d", () => {
+
+    const miniball = new Miniball(new PointSet(1, 1, [7]));
+
+    expect(miniball.center()).toEqual([7]);
+    expect(miniball.radius()).toEqual(0);
+
+});

package/src/core/graph/graph_k_means_cluster.spec.js

@@ -0,0 +1,23 @@
+import { graph_k_means_cluster } from "./graph_k_means_cluster.js";
+import { Graph } from "./v2/Graph.js";
+
+test("empty graph", () => {
+    const graph = new Graph();
+
+    const clusters = graph_k_means_cluster(graph, 0, 0);
+
+    expect(Array.isArray(clusters)).toBe(true);
+    expect(clusters.length).toBe(0);
+});
+
+test("2-node graph with k=1", () => {
+    const graph = new Graph();
+    graph.addNode(3);
+    graph.addNode(7);
+
+    const clusters = graph_k_means_cluster(graph, 1, 0);
+
+    expect(Array.isArray(clusters)).toBe(true);
+    expect(clusters.length).toBe(1);
+    expect(clusters.map(cluster => cluster.sort())).toEqual([[0, 1]]);
+});

package/src/core/graph/GraphElement.js

@@ -1,6 +0,0 @@
-class GraphElement {
-    properties = [];
-    labels = [];
-}
-
-export default GraphElement;

package/src/core/graph/Node.js

@@ -1,12 +0,0 @@
-/**
- * Created by Alex on 29/01/14.
- */
-
-
-import GraphElement from "./GraphElement.js";
-
-class GraphNode extends GraphElement {
-    edges = [];
-}
-
-export default GrapNode;