@woosh/meep-engine 2.76.3 → 2.77.0

package/editor/view/ecs/components/TerrainController.js

@@ -1,20 +1,19 @@
-import DatGuiController from "./DatGuiController.js";
+import Signal from "../../../../src/core/events/signal/Signal.js";
 import Vector2 from "../../../../src/core/geom/Vector2.js";
-import View from "../../../../src/view/View.js";
-import { NativeListController } from "../../../../src/view/controller/controls/NativeListController.js";
+import ObservedValue from "../../../../src/core/model/ObservedValue.js";
 import { TerrainLayer } from "../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js";
 import CheckersTextureURI from "../../../../src/engine/graphics/texture/CheckersTextureURI.js";
-import EmptyView from "../../../../src/view/elements/EmptyView.js";
-import convertSampler2D2Canvas from "../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
-import { CanvasView } from "../../../../src/view/elements/CanvasView.js";
 import { sampler2d_scale } from "../../../../src/engine/graphics/texture/sampler/resize/sampler2d_scale.js";
 import { Sampler2D } from "../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
-import Signal from "../../../../src/core/events/signal/Signal.js";
+import convertSampler2D2Canvas from "../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import LabelView from "../../../../src/view/common/LabelView.js";
+import { NativeListController } from "../../../../src/view/controller/controls/NativeListController.js";
 import Vector2Control from "../../../../src/view/controller/controls/Vector2Control.js";
+import { CanvasView } from "../../../../src/view/elements/CanvasView.js";
+import EmptyView from "../../../../src/view/elements/EmptyView.js";
 import GroupView from "../../../../src/view/elements/Group.js";
-import LabelView from "../../../../src/view/common/LabelView.js";
-import ObservedValue from "../../../../src/core/model/ObservedValue.js";
-import { SplatMapOptimizer } from "../../../../src/engine/ecs/terrain/ecs/splat/SplatMapOptimizer.js";
+import View from "../../../../src/view/View.js";
+import DatGuiController from "./DatGuiController.js";
 
 class LayersController extends View {
     /**
@@ -173,12 +172,6 @@ export class TerrainController extends View {
                     model.__tiles.rebuild();
                 }, 'Rebuild');
 
-                controller.addAction(() => {
-
-                    SplatMapOptimizer.optimizeSynchronous(model.splat)
-
-                }, 'Optimize Textures');
-
                 controller.add(model, 'size', { step: 1 });
                 controller.add(model, 'resolution').step(1);
                 controller.add(model, 'gridScale').step(1).name('Gird Size');

package/package.json

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

package/src/core/collection/heap/Uint32Heap.js

@@ -159,7 +159,7 @@ export class Uint32Heap {
         const size = this.__size;
 
         while (true) {
-            const l = ((i) << 1) + 1;
+            const l = (i << 1) + 1;
             const r = l + 1;
 
             let smallest = i;
@@ -282,6 +282,15 @@ export class Uint32Heap {
         return -1;
     }
 
+    /**
+     *
+     * @param {number} id
+     * @returns {boolean}
+     */
+    contains(id){
+        return this.find_index_by_id(id) !== -1;
+    }
+
     /**
      * Clear out all the data, heap will be made empty
      */

package/src/core/graph/Edge.js

@@ -86,6 +86,26 @@ export class Edge {
         return (this.direction & EdgeDirectionType.Backward) !== 0;
     }
 
+    /**
+     * Checks direction of the edge, if the edge is directed towards supplied node - returns true, false otherwise
+     * @param {N} node
+     * @returns {boolean}
+     */
+    isDirectedTowards(node) {
+        return (this.first === node && this.direction === EdgeDirectionType.Backward)
+            || (this.second === node && this.direction === EdgeDirectionType.Forward);
+    }
+
+    /**
+     * Checks direction of the edge, if the edge is directed away from the supplied node - returns true, false otherwise
+     * @param {N} node
+     * @returns {boolean}
+     */
+    isDirectedAwayFrom(node) {
+        return (this.first === node && this.direction === EdgeDirectionType.Forward)
+            || (this.second === node && this.direction === EdgeDirectionType.Backward)
+    }
+
     /**
      * @deprecated
      * @returns {number}

package/src/core/graph/Graph.js

@@ -15,6 +15,7 @@ import { Edge, EdgeDirectionType } from "./Edge.js";
 
 /**
  * @template N
+ * @deprecated use v2 `Graph` class instead, it's faster and has a wider range of algorithms built on top of it
  */
 export class Graph {
     /**

package/src/core/graph/SquareMatrix.js

@@ -1,5 +1,5 @@
-import { DataType2TypedArrayConstructorMapping } from "../binary/type/DataType2TypedArrayConstructorMapping.js";
 import { assert } from "../assert.js";
+import { DataType2TypedArrayConstructorMapping } from "../binary/type/DataType2TypedArrayConstructorMapping.js";
 import { array_copy } from "../collection/array/array_copy.js";
 
 export class SquareMatrix {
@@ -9,6 +9,8 @@ export class SquareMatrix {
      * @param {BinaryDataType|string} type
      */
     constructor(size, type) {
+        assert.isNonNegativeInteger(size, 'size');
+
         const TypedArray = DataType2TypedArrayConstructorMapping[type];
 
         if (TypedArray === undefined) {
@@ -162,7 +164,7 @@ export class SquareMatrix {
      * @param {number[]} [destination]
      * @param {number} [offset]
      */
-    toArray(destination = new Array(this.length), offset=0) {
+    toArray(destination = new Array(this.length), offset = 0) {
         array_copy(this.data, 0, destination, offset, this.length);
 
         return destination;

package/src/core/graph/WeightedEdge.js

@@ -1,15 +1,11 @@
 import { Edge } from "./Edge.js";
 
 export class WeightedEdge extends Edge {
-    constructor(a, b) {
-        super(a, b);
-
-        /**
-         *
-         * @type {number}
-         */
-        this.weight = 0;
-    }
+    /**
+     *
+     * @type {number}
+     */
+    weight = 0;
 
     /**
      *

package/src/core/graph/coloring/validateGraphColoring.js

@@ -1,5 +1,5 @@
 /**
- *
+ * Debug method used for validating coloring. Will pass if no two nodes share a color
  * @param {number[]} colors
  * @param {Graph} graph
  * @returns {boolean}

package/src/core/graph/eigen/matrix_eigenvalues_in_place.js

@@ -0,0 +1,21 @@
+import { matrix_householder_in_place } from "./matrix_householder_in_place.js";
+import { matrix_qr_in_place } from "./matrix_qr_in_place.js";
+
+
+/**
+ * list of eigen values square matrix (allow non symmetric)
+ * NOTE: Modifies input matrix
+ * @param {SquareMatrix} mat
+ * @return {number[]}
+ */
+export function matrix_eigenvalues_in_place(mat) {
+    const n = mat.size;
+    matrix_householder_in_place(mat.data, n);
+    matrix_qr_in_place(mat.data, n);
+
+    const result = new Float32Array(n);
+
+    mat.readDiagonal(result);
+
+    return result;
+}

package/src/core/graph/eigen/{eigen.spec.js → matrix_eigenvalues_in_place.spec.js}

@@ -1,6 +1,6 @@
-import { SquareMatrix } from "../SquareMatrix.js";
 import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
-import { matrix_eigenvalues_in_place } from "./eigen.js";
+import { SquareMatrix } from "../SquareMatrix.js";
+import { matrix_eigenvalues_in_place } from "./matrix_eigenvalues_in_place.js";
 
 function roughly_equal_array_vectors(actual, expected) {
     expect(actual.length).toBe(expected.length);

package/src/core/graph/eigen/matrix_householder_in_place.js

@@ -0,0 +1,92 @@
+const EPSILON = 1e-10;
+
+/**
+ * NxN matrix Householder reduction
+ * Return subfunction to upper Hessenberg matrix by Householder transformation
+ * @see http://www-in.aut.ac.jp/~minemura/pub/Csimu/C/QRmethod.html
+ * @param {number[]} a
+ * @param {number} n
+ */
+export function matrix_householder_in_place(a, n) {
+    const u = new Float64Array(n);
+    const d = new Float64Array(n);
+    const ds = new Float64Array(n);
+
+    let i, j, k;
+    let sum;
+
+    for (k = 0; k <= n - 3; k++) {
+
+        for (i = 0; i <= k; i++) {
+            u[i] = 0;
+        }
+
+        for (i = k + 1; i < n; i++) {
+            u[i] = a[n * i + k];
+        }
+
+        // Build transformation matrix H
+        sum = 0.0;
+
+        for (i = k + 1; i < n; i++) {
+            sum = sum + u[i] * u[i];
+        }
+
+        const u_k_1 = u[k + 1];
+
+        const u_k_1_abs = Math.abs(u_k_1);
+        if (u_k_1_abs < EPSILON) {
+            continue;
+        }
+
+        const sigma = Math.sqrt(sum) * u_k_1 / u_k_1_abs;
+
+        u[k + 1] += sigma;
+
+        const v_norm = Math.sqrt(2.0 * sigma * u[k + 1]);
+
+        for (i = k + 1; i < n; i++) {
+            u[i] /= v_norm;
+        }
+
+        // Similarity transformation
+        for (i = 0; i < n; i++) {
+            d[i] = 0.0;
+            ds[i] = 0.0;
+            for (j = k + 1; j <= n - 1; j++) {
+                const u_j = u[j];
+
+                d[i] += a[n * i + j] * u_j;
+                ds[i] += a[n * j + i] * u_j;
+            }
+        }
+
+        let ud = 0.0;
+        let uds = 0.0;
+
+        for (i = k + 1; i < n; i++) {
+            const u_i = u[i];
+
+            ud += u_i * d[i];
+            uds += u_i * ds[i];
+        }
+
+        for (i = 0; i < n; i++) {
+            const u_i = u[i];
+
+            d[i] = 2.0 * (d[i] - ud * u_i);
+            ds[i] = 2.0 * (ds[i] - uds * u_i);
+        }
+
+        for (i = 0; i < n; i++) {
+            const u_i = u[i];
+            const d_i = d[i];
+
+            const n_i = n * i;
+
+            for (j = 0; j < n; j++) {
+                a[n_i + j] -= u_i * ds[j] + d_i * u[j];
+            }
+        }
+    }
+}

package/src/core/graph/eigen/{eigen.js → matrix_qr_in_place.js}

@@ -1,97 +1,5 @@
 const EPSILON = 1e-10;
 
-/**
- * NxN matrix Householder reduction
- * Return subfunction to upper Hessenberg matrix by Householder transformation
- * @see http://www-in.aut.ac.jp/~minemura/pub/Csimu/C/QRmethod.html
- * @param {number[]} a
- * @param {number} n
- */
-function householder_in_place(a, n) {
-    const u = new Float64Array(n);
-    const d = new Float64Array(n);
-    const ds = new Float64Array(n);
-
-    let i, j, k;
-    let sum;
-
-    for (k = 0; k <= n - 3; k++) {
-
-        for (i = 0; i <= k; i++) {
-            u[i] = 0;
-        }
-
-        for (i = k + 1; i < n; i++) {
-            u[i] = a[n * i + k];
-        }
-
-        // Build transformation matrix H
-        sum = 0.0;
-
-        for (i = k + 1; i < n; i++) {
-            sum = sum + u[i] * u[i];
-        }
-
-        const u_k_1 = u[k + 1];
-
-        const u_k_1_abs = Math.abs(u_k_1);
-        if (u_k_1_abs < EPSILON) {
-            continue;
-        }
-
-        const sigma = Math.sqrt(sum) * u_k_1 / u_k_1_abs;
-
-        u[k + 1] += sigma;
-
-        const v_norm = Math.sqrt(2.0 * sigma * u[k + 1]);
-
-        for (i = k + 1; i < n; i++) {
-            u[i] /= v_norm;
-        }
-
-        // Similarity transformation
-        for (i = 0; i < n; i++) {
-            d[i] = 0.0;
-            ds[i] = 0.0;
-            for (j = k + 1; j <= n - 1; j++) {
-                const u_j = u[j];
-
-                d[i] += a[n * i + j] * u_j;
-                ds[i] += a[n * j + i] * u_j;
-            }
-        }
-
-        let ud = 0.0;
-        let uds = 0.0;
-
-        for (i = k + 1; i < n; i++) {
-            const u_i = u[i];
-
-            ud += u_i * d[i];
-            uds += u_i * ds[i];
-        }
-
-        for (i = 0; i < n; i++) {
-            const u_i = u[i];
-
-            d[i] = 2.0 * (d[i] - ud * u_i);
-            ds[i] = 2.0 * (ds[i] - uds * u_i);
-        }
-
-        for (i = 0; i < n; i++) {
-            const u_i = u[i];
-            const d_i = d[i];
-
-            const n_i = n * i;
-
-            for (j = 0; j < n; j++) {
-                a[n_i + j] -= u_i * ds[j] + d_i * u[j];
-            }
-        }
-    }
-}
-
-
 /**
  * Perform QR factorization in-place
  * Subfunction that analyzes eigenvalues by QR decomposition
@@ -99,7 +7,7 @@ function householder_in_place(a, n) {
  * @param {number[]} a Square matrix
  * @param {number} n size of the matrix in single dimension
  */
-function qr_in_place(a, n) {
+export function matrix_qr_in_place(a, n) {
     const q = new Float64Array(n * n);
     const w = new Float64Array(n);
 
@@ -207,23 +115,4 @@ function qr_in_place(a, n) {
             a[n * i + i] += mu;
         }
     }
-}
-
-
-/**
- * list of eigen values square matrix (allow non symmetric)
- * NOTE: Modifies input matrix
- * @param {SquareMatrix} mat
- * @return {number[]}
- */
-export function matrix_eigenvalues_in_place(mat) {
-    const n = mat.size;
-    householder_in_place(mat.data, n);
-    qr_in_place(mat.data, n);
-
-    const result = new Float32Array(n);
-
-    mat.readDiagonal(result);
-
-    return result;
-}
+}

package/src/core/graph/v2/Graph.js

@@ -1,20 +1,23 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
-import { NodeContainer } from "./NodeContainer.js";
 import { Edge, EdgeDirectionType } from "../Edge.js";
+import { NodeContainer } from "./NodeContainer.js";
 
 /**
+ * Reconstruct path from search metadata
  * @template T
  * @param {NodeContainer<T>} goal_node_container
- * @param {Map<NodeContainer<T>,NodeContainer<T>>} cameFrom
- * @returns {T[]}
+ * @param {Map<NodeContainer<T>,NodeContainer<T>>} came_from
+ * @returns {T[]} Nodes comprising the path from start to goal
  */
-function construct_path(goal_node_container, cameFrom) {
+function construct_path(goal_node_container, came_from) {
     const result = [];
+
     let c = goal_node_container;
+
     do {
         result.unshift(c.node);
-        c = cameFrom.get(c);
+        c = came_from.get(c);
     } while (c !== undefined);
 
     return result;
@@ -28,16 +31,21 @@ export class Graph {
     /**
      *
      * @type {Map<N, NodeContainer<N>>}
+     * @readonly
      * @private
      */
     __nodes = new Map();
     /**
      *
      * @type {Set<Edge<N>>}
+     * @readonly
      * @private
      */
     __edges = new Set();
 
+    /**
+     * @readonly
+     */
     on = {
         /**
          * @type {Signal<N,this>}
@@ -191,10 +199,10 @@ export class Graph {
      *
      * @param {N} source
      * @param {N} target
-     * @param {EdgeDirectionType} type
+     * @param {EdgeDirectionType} [type] Undirected by default
      * @returns {Edge<N>}
      */
-    createEdge(source, target, type) {
+    createEdge(source, target, type = EdgeDirectionType.Undirected) {
         const edge = new Edge(source, target);
 
         edge.direction = type;
@@ -376,8 +384,7 @@ export class Graph {
         const edge_count = edges.length;
 
         for (let i = 0; i < edge_count; i++) {
-            const edge = edges[i];
-            result[i] = edge;
+            result[i] = edges[i];
         }
 
         return edge_count;

package/src/core/graph/v2/NodeContainer.js

@@ -1,45 +1,141 @@
 import { EdgeDirectionType } from "../Edge.js";
 
+/**
+ * Supplementary structure to `Graph`, holds edges and neighbour nodes for fast access
+ * Used internally by `Graph`
+ * @template N
+ */
 export class NodeContainer {
     /**
-     * @template N
+     * Node being described
+     * @type {N}
      */
-    constructor() {
-        /**
-         *
-         * @type {N}
-         */
-        this.node = null;
+    node = null;
+
+    /**
+     * Attached edges
+     * @type {Edge<N>[]}
+     * @private
+     */
+    __edges = [];
+
+    /**
+     *
+     * @type {Map<N,number>}
+     * @private
+     */
+    __neighbors = new Map();
+
+    /**
+     *
+     * @return {number}
+     */
+    getEdgeCount() {
+        return this.__edges.length;
+    }
+
+    /**
+     * Do not modify the returned value
+     * @return {Edge<N>[]}
+     */
+    getEdges() {
+        return this.__edges;
+    }
 
+    /**
+     *
+     * @returns {N[]}
+     */
+    get inNodes() {
+        return this.inEdges.map(e => e.other(this.node));
+    }
+
+    /**
+     *
+     * @returns {N[]}
+     */
+    get outNodes() {
+        return this.outEdges.map(e => e.other(this.node));
+    }
+
+
+    get outEdges() {
         /**
          *
          * @type {Edge<N>[]}
-         * @private
          */
-        this.__edges = [];
+        const result = [];
 
+        this.getOutgoingEdges(result);
+
+        return result;
+    }
+
+    get inEdges() {
         /**
          *
-         * @type {Map<N,number>}
-         * @private
+         * @type {Edge<N>[]}
          */
-        this.__neighbors = new Map();
+        const result = [];
+
+        this.getIncomingEdges(result);
+
+        return result;
     }
 
+
     /**
      *
-     * @return {number}
+     * @param {Edge<N>[]} result
+     * @returns {number}
      */
-    getEdgeCount() {
-        return this.__edges.length;
+    getIncomingEdges(result) {
+        const edges = this.__edges;
+
+        const edge_count = edges.length;
+
+        let result_count = 0;
+
+        for (let i = 0; i < edge_count; i++) {
+            const edge = edges[i];
+
+            if (edge.isDirectedTowards(this.node)) {
+
+                result.push(edge);
+                result_count++;
+
+            }
+
+        }
+
+        return result_count;
     }
 
     /**
-     * Do not modify the returned value
-     * @return {Edge<N>[]}
+     *
+     * @param {Edge<N>[]} result
+     * @returns {number}
      */
-    getEdges() {
-        return this.__edges;
+    getOutgoingEdges(result) {
+        const edges = this.__edges;
+
+        const edge_count = edges.length;
+
+        let result_count = 0;
+
+        for (let i = 0; i < edge_count; i++) {
+            const edge = edges[i];
+
+            if (edge.isDirectedAwayFrom(this.node)) {
+
+                result.push(edge);
+                result_count++;
+
+            }
+
+        }
+
+        return result_count;
     }
 
     /**
@@ -52,12 +148,14 @@ export class NodeContainer {
         const edges = this.__edges;
         const edge_count = edges.length;
 
+        const current_node = this.node;
+
         for (let i = 0; i < edge_count; i++) {
             const edge = edges[i];
 
             if (
-                (edge.first === this.node && edge.direction === EdgeDirectionType.Forward)
-                || (edge.second === this.node && edge.direction === EdgeDirectionType.Backward)
+                (edge.first === current_node && edge.direction === EdgeDirectionType.Forward)
+                || (edge.second === current_node && edge.direction === EdgeDirectionType.Backward)
 
             ) {
                 r++;
@@ -81,7 +179,7 @@ export class NodeContainer {
 
     /**
      *
-     * @param {function(Edge)} visitor
+     * @param {function(Edge<N>)} visitor
      * @param {*} [thisArg]
      * @returns {number}
      */