@woosh/meep-engine 2.49.3 → 2.49.4

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.4",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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

@@ -0,0 +1,18 @@
+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>
+    })
+
+    invalidate(key:K):void
+
+    clear():void
+
+    get(key:K):Promise<V>
+}

package/src/core/cache/LoadingCache.js

@@ -0,0 +1,115 @@
+//
+
+import { Cache } from "./Cache.js";
+
+/**
+ * @template {V}
+ */
+class Record {
+    /**
+     *
+     * @param {V} value
+     * @param {number} time
+     */
+    constructor(value, time) {
+        this.value = value;
+        this.time = time;
+    }
+}
+
+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
+
+    /**
+     * @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
+     */
+    constructor({
+                    maxWeight,
+                    keyWeigher,
+                    valueWeigher,
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    capacity,
+                    timeToLive = DEFAULT_TIME_TO_LIVE,
+                    load
+                }) {
+
+        this.#internal = new Cache({
+            maxWeight,
+            keyWeigher,
+            valueWeigher,
+            keyHashFunction,
+            keyEqualityFunction,
+            capacity,
+        });
+
+        this.#timeToLive = timeToLive;
+        this.#load = load;
+    }
+
+    /**
+     *
+     * @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;
+
+        let record = this.#internal.get(key);
+
+        if (record === null || (record.time + this.#timeToLive) < currentTime) {
+
+            // missing or stale record
+            const promise = this.#load(key);
+
+            record = new Record(promise, currentTime);
+
+            this.#internal.put(key, record);
+
+        }
+
+
+        return record.value;
+    }
+}

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;