@woosh/meep-engine 2.48.18 → 2.48.20

package/package.json

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

package/src/core/binary/type/BinaryDataType.d.ts

@@ -0,0 +1,15 @@
+export enum BinaryDataType {
+    Uint8= "uint8",
+    Uint16= "uint16",
+    Uint32= "uint32",
+    Uint64= "uint64",
+
+    Int8= "int8",
+    Int16= "int16",
+    Int32= "int32",
+    Int64= "int64",
+
+    Float16= 'float16',
+    Float32= "float32",
+    Float64= "float64"
+}

package/src/{engine/graphics/render/forward_plus/data/computeDataType.js → core/binary/type/computeBinaryDataTypeByPrecision.js}

@@ -1,5 +1,5 @@
-import { NumericType } from "./NumericType.js";
-import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+import { NumericType } from "../../math/NumericType.js";
+import { BinaryDataType } from "./BinaryDataType.js";
 
 /**
  *
@@ -7,7 +7,7 @@ import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.j
  * @param {number} precision
  * @returns {BinaryDataType}
  */
-export function computeDataType(type, precision) {
+export function computeBinaryDataTypeByPrecision(type, precision) {
     if (type === NumericType.Uint) {
         if (precision <= 8) {
             return BinaryDataType.Uint8;

package/src/core/geom/2d/quad-tree/qt_query_data_nearest_to_point.js

@@ -0,0 +1,62 @@
+import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
+import { max2 } from "../../../math/max2.js";
+
+/**
+ *
+ * @type {QuadTreeNode[]}
+ */
+const node_stack = [];
+
+/**
+ * @template N
+ * @param {QuadTreeNode<N>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} [max_distance]
+ * @returns {QuadTreeDatum<N>}
+ */
+export function qt_query_data_nearest_to_point(tree, x, y, max_distance = Infinity) {
+
+    let stack_pointer = 0;
+
+    node_stack[stack_pointer] = tree;
+    stack_pointer++;
+
+    let best_leaf_data = undefined;
+    let best_distance_sqr = max_distance * max_distance;
+
+    while (stack_pointer > 0) {
+
+        --stack_pointer;
+        const node = node_stack[stack_pointer];
+
+        const distance_sqr = max2(0, aabb2_sqrDistanceToPoint(node.x0, node.y0, node.x1, node.y1, x, y));
+
+        if (distance_sqr >= best_distance_sqr) {
+            // too far
+            continue;
+        }
+
+        const data = node.data;
+
+        for (let i = 0; i < data.length; i++) {
+            const datum = data[i];
+
+            const distance_sqr = max2(0, aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y));
+
+            if (distance_sqr < best_distance_sqr) {
+                best_leaf_data = datum;
+                best_distance_sqr = distance_sqr;
+            }
+        }
+
+        if (node.isSplit()) {
+            node_stack[stack_pointer++] = node.topLeft;
+            node_stack[stack_pointer++] = node.topRight;
+            node_stack[stack_pointer++] = node.bottomLeft;
+            node_stack[stack_pointer++] = node.bottomRight;
+        }
+    }
+
+    return best_leaf_data;
+}

package/src/core/geom/Matrix4.js

@@ -4,6 +4,9 @@ const _z = new Vector3();
 const _x = new Vector3();
 const _y = new Vector3();
 
+/**
+ * @deprecated use arrays instead or mat4 from gl-matrix
+ */
 export class Matrix4 {
     /**
      *
@@ -197,7 +200,7 @@ export class Matrix4 {
         const sz = Math.hypot(this.c0, this.c1, this.c2);
 
         // if determine is negative, we need to invert one scale
-        const  det = this.determinant();
+        const det = this.determinant();
         if (det < 0) sx = -sx;
 
         position.set(

package/src/core/graph/Edge.js

@@ -26,8 +26,8 @@ export class Edge {
      * @constructor
      */
     constructor(a, b) {
-        assert.notEqual(a, undefined, 'a is undefined');
-        assert.notEqual(b, undefined, 'b is undefined');
+        assert.defined(a, 'a');
+        assert.defined(b, 'b');
 
         /**
          *
@@ -46,6 +46,11 @@ export class Edge {
         this.direction = EdgeDirectionType.Undirected;
     }
 
+    /**
+     *
+     * @param {N} node
+     * @return {boolean}
+     */
     contains(node) {
         return this.first === node || this.second === node;
     }
@@ -86,6 +91,8 @@ export class Edge {
      * @returns {number}
      */
     angle() {
+        console.error('method is deprecated, do not use');
+
         const delta = this.second.clone().sub(this.first);
         return Math.atan2(delta.y, delta.x);
     }
@@ -104,6 +111,8 @@ export class Edge {
      * @returns {number}
      */
     get length() {
+        console.error('method is deprecated, do not use');
+
         return this.first.distanceTo(this.second);
     }
 }

package/src/core/graph/layout/computeDisconnectedSubGraphs.js

@@ -1,4 +1,5 @@
 /**
+ * NOTE: use {@link graph_compute_disconnected_clusters} instead where possible
  * @param {{connections:Connection[]}[]} nodes
  * @return {Array}
  */

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

@@ -26,29 +26,31 @@ function construct_path(goal_node_container, cameFrom) {
 export class Graph {
 
     /**
-     * @template N
+     *
+     * @type {Map<N, NodeContainer<N>>}
+     * @private
+     */
+    __nodes = new Map();
+    /**
+     *
+     * @type {Set<Edge<N>>}
+     * @private
      */
-    constructor() {
+    __edges = new Set();
+
+    on = {
         /**
-         *
-         * @type {Map<N, NodeContainer<N>>}
-         * @private
+         * @type {Signal<N,this>}
          */
-        this.__nodes = new Map();
+        nodeAdded: new Signal(),
         /**
-         *
-         * @type {Set<Edge<N>>}
-         * @private
+         * @type {Signal<N,this>}
          */
-        this.__edges = new Set();
-
-        this.on = {
-            nodeAdded: new Signal(),
-            nodeRemoved: new Signal(),
-            edgeAdded: new Signal(),
-            edgeRemoved: new Signal()
-        };
-    }
+        nodeRemoved: new Signal(),
+        edgeAdded: new Signal(),
+        edgeRemoved: new Signal()
+    };
+
 
     /**
      *
@@ -115,6 +117,14 @@ export class Graph {
         return this.__nodes.size;
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    getNodeCount() {
+        return this.__nodes.size;
+    }
+
     /**
      *
      * @param {function(N):boolean} filter
@@ -169,14 +179,6 @@ export class Graph {
         return this.__nodes.keys();
     }
 
-    /**
-     *
-     * @returns {number}
-     */
-    getNodeCount() {
-        return this.__nodes.size;
-    }
-
     /**
      * Do not modify this set directly
      * @return {Set<Edge<N>>}
@@ -217,8 +219,10 @@ export class Graph {
         const context_0 = this.__nodes.get(edge.first);
         const context_1 = this.__nodes.get(edge.second);
 
-        if (context_0 === undefined || context_1 === undefined) {
-            throw new Error('One or more of the edge nodes are not part of the graph');
+        if (context_0 === undefined) {
+            throw new Error(`First node(=${edge.first}) of the edge is not part of the graph`);
+        } else if (context_1 === undefined) {
+            throw new Error(`Second node(=${edge.second}) of the edge is not part of the graph`);
         }
 
         context_0.addEdge(edge);
@@ -246,6 +250,7 @@ export class Graph {
         const context_1 = this.__nodes.get(edge.second);
 
         if (context_0 === undefined || context_1 === undefined) {
+            // this is a critical error, it should never happen as long as the API is used correctly
             throw new Error('One or both nodes of the edge are not present on the graph. This is a critical error');
         }
 
@@ -316,7 +321,7 @@ export class Graph {
         const context_a = this.__nodes.get(a);
 
         if (context_a === undefined) {
-            // a is not in the graph
+            // A is not in the graph
             return undefined;
         }
 
@@ -334,10 +339,10 @@ export class Graph {
      * @param {N} to
      * @returns {Edge<N>|undefined}
      */
-    getAnyDirectedEdge(from, to){
+    getAnyDirectedEdge(from, to) {
         const ctx_a = this.__nodes.get(from);
 
-        if(ctx_a === undefined){
+        if (ctx_a === undefined) {
             return undefined;
         }
 

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

@@ -1,10 +1,89 @@
-import { Edge } from "../Edge.js";
+import { Edge, EdgeDirectionType } from "../Edge.js";
 import { Graph } from "./Graph.js";
+import { jest } from "@jest/globals";
 
 test("constructor doesn't throw", () => {
     expect(() => new Graph()).not.toThrow();
 });
 
+test("adding same node twice", () => {
+
+    const graph = new Graph();
+
+    expect(graph.addNode(1)).toBe(true);
+    expect(graph.addNode(1)).toBe(false); // node already added
+
+});
+
+test("adding node triggers nodeAdded signal", () => {
+
+    const graph = new Graph();
+
+    const callback = jest.fn();
+
+    graph.on.nodeAdded.add(callback);
+
+    graph.addNode(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(7, graph);
+
+});
+
+test("removing node triggers nodeRemoved signal", () => {
+
+    const graph = new Graph();
+
+    const callback = jest.fn();
+
+    graph.on.nodeRemoved.add(callback);
+
+    graph.addNode(7);
+
+    expect(callback).not.toHaveBeenCalled();
+
+    graph.removeNode(1); // trying to remove non-existent node
+
+    expect(callback).not.toHaveBeenCalled();
+
+    graph.removeNode(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(7, graph);
+
+    graph.removeNode(7); //node was already removed, so we expect nothing to happen
+
+    expect(callback).toHaveBeenCalledTimes(1);
+});
+
+test("check node existence", () => {
+
+    const graph = new Graph();
+
+    expect(graph.hasNode(1)).toBe(false);
+
+    graph.addNode(1);
+
+    expect(graph.hasNode(1)).toBe(true);
+
+});
+
+test("removing node that does not exist", () => {
+    const graph = new Graph();
+
+    expect(graph.removeNode(1)).toBe(false);
+
+});
+
+test("removing same node twice", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+
+    expect(graph.removeNode(1)).toBe(true);
+    expect(graph.removeNode(1)).toBe(false);
+});
+
 test("nodeCount", () => {
     const g = new Graph();
 
@@ -19,6 +98,122 @@ test("nodeCount", () => {
     expect(g.nodeCount).toBe(0);
 });
 
+test("findNode on empty graph", () => {
+    const graph = new Graph();
+
+    expect(graph.findNode(n => n === 1)).toBe(undefined);
+});
+
+test("findNode that doesn't exist on graph with 1 node", () => {
+    const graph = new Graph();
+
+    graph.addNode(3);
+
+    expect(graph.findNode(n => n === 1)).toBe(undefined);
+});
+
+test("findNode amongst two", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(3);
+
+    expect(graph.findNode(n => n === 3)).toBe(3);
+});
+
+test("getNodeDegree", () => {
+
+    const graph = new Graph();
+
+    expect(graph.getNodeDegree(1)).toBe(0);
+
+    graph.addNode(1);
+
+    expect(graph.getNodeDegree(1)).toBe(0);
+
+    graph.addNode(3);
+
+    expect(graph.getNodeDegree(1)).toBe(0);
+    expect(graph.getNodeDegree(3)).toBe(0);
+
+    graph.createEdge(1, 3, EdgeDirectionType.Forward);
+
+    expect(graph.getNodeDegree(1)).toBe(1);
+    expect(graph.getNodeDegree(3)).toBe(1);
+});
+
+test("createEdge", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.edgeCount).toBe(1);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(true);
+});
+
+test("adding edge where one of the nodes is not part of the graph should throw and exception", () => {
+    const graph = new Graph();
+
+    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
+
+    graph.addNode(1);
+
+    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
+
+    graph.removeNode(1);
+    graph.addNode(2);
+
+    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
+});
+
+test("add one valid edge", () => {
+
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    const edge = new Edge(1, 2);
+    expect(graph.addEdge(edge)).toBe(true);
+
+    expect(graph.hasEdge(edge)).toBe(true);
+
+    expect(graph.edgeCount).toBe(1);
+});
+
+test("add same edge twice", () => {
+
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    const edge = new Edge(1, 2);
+
+    expect(graph.addEdge(edge)).toBe(true);
+    expect(graph.addEdge(edge)).toBe(false); //already exists
+
+    expect(graph.hasEdge(edge)).toBe(true);
+
+    expect(graph.edgeCount).toBe(1);
+});
+
+test("remove non-existing edge", () => {
+
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    const edge = new Edge(1, 2);
+
+    expect(graph.removeEdge(edge)).toBe(false);
+});
+
 test("edgeCount", () => {
     const g = new Graph();
 
@@ -54,3 +249,116 @@ test("after removing an edge, neighborhood is properly updated", () => {
     expect(g.getAttachedEdges(t, 1)).toBe(0);
     expect(g.getAttachedEdges(t, 2)).toBe(0);
 });
+
+test("edgeExistsBetween", () => {
+    const graph = new Graph();
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
+
+    graph.addNode(1);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
+
+    graph.addNode(2);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(true);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(true);
+
+});
+
+test("nodeHasEdges", () => {
+    const graph = new Graph();
+
+    expect(graph.nodeHasEdges(1)).toBe(false);
+
+    graph.addNode(1);
+
+    expect(graph.nodeHasEdges(1)).toBe(false);
+
+    graph.addNode(2);
+
+    expect(graph.nodeHasEdges(1)).toBe(false);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.nodeHasEdges(1)).toBe(true);
+    expect(graph.nodeHasEdges(2)).toBe(true);
+});
+
+test("getAnyEdgeBetween", () => {
+
+    const graph = new Graph();
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
+
+    graph.addNode(1);
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
+
+    graph.addNode(2);
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
+
+    const edge = graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(edge);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(edge);
+});
+
+test("find path from node to itself", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+
+    const path = graph.findPath(1, 1);
+
+    expect(path).toEqual([1]);
+});
+
+test("find path with 2 hops", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+    graph.addNode(3);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+    graph.createEdge(2, 3, EdgeDirectionType.Forward);
+
+    const path = graph.findPath(1, 3);
+
+    expect(path).toEqual([1, 2, 3]);
+});
+
+test("clear method removes all nodes", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+
+    graph.clear();
+
+    expect(graph.nodeCount).toBe(0);
+});
+
+test("clear method removes all edges", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    graph.clear();
+
+    expect(graph.edgeCount).toBe(0);
+});

package/src/core/process/task/TaskGroup.js

@@ -11,7 +11,7 @@ import TaskState from "./TaskState.js";
 
 /**
  *
- * @param {Task[]} subtasks
+ * @param {(Task|TaskGroup)[]} subtasks
  * @param {string} [name]
  * @constructor
  */

package/src/core/process/task/util/task_tree_compute_leaf_tasks.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {TaskGroup|Task} root
+ * @return {number}
+ */
+export function task_tree_compute_leaf_tasks(root) {
+    let result = 0;
+
+    if (root.isTaskGroup) {
+
+        const children = root.children;
+        const n = children.length;
+        for (let i = 0; i < n; i++) {
+            result += task_tree_compute_leaf_tasks(children[i]);
+        }
+    } else {
+        result += 1;
+    }
+
+    return result;
+}

package/src/engine/graphics/geometry/AttributeSpec.d.ts

@@ -1,8 +1,8 @@
-import {DataType} from "../../../core/parser/simple/DataType";
+import {BinaryDataType} from "../../../core/binary/type/BinaryDataType";
 
 export class AttributeSpec {
     readonly name: string
-    readonly type: DataType
+    readonly type: BinaryDataType
     readonly itemSize: number
     readonly normalized: boolean
 }

package/src/engine/graphics/material/optimization/MaterialOptimizationContext.js

@@ -21,9 +21,7 @@ import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2S
 import { BUFFER_GEOMETRY_UVS } from "./BUFFER_GEOMETRY_UVS.js";
 import { is_compliant_mesh } from "./is_compliant_mesh.js";
 import { MaterialDescriptor } from "./MaterialDescriptor.js";
-import {
-    computeThreeTextureTypeFromDataType
-} from "../../render/forward_plus/data/computeThreeTextureTypeFromDataType.js";
+import { computeThreeTextureTypeFromDataType } from "../../texture/computeThreeTextureTypeFromDataType.js";
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
 import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import {

package/src/engine/graphics/micron/render/instanced/PatchDataTextures.js

@@ -1,9 +1,10 @@
 import { assert } from "../../../../../core/assert.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { AttributeDataTexture } from "./AttributeDataTexture.js";
+import { AttributeDataTexture } from "../../../texture/AttributeDataTexture.js";
 import { max3 } from "../../../../../core/math/max3.js";
 import { gen_micron_vertex_attribute_texture_name } from "./shader/gen_micron_vertex_attribute_texture_name.js";
 import { min2 } from "../../../../../core/math/min2.js";
+import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
 
 /**
  *
@@ -23,6 +24,9 @@ const ALLOCATION_GROW_FACTOR = 1.2;
  */
 const MAX_TEXTURE_SIZE = 16384;
 
+const VERTICES_PER_TRIANGLE = 3;
+const ATTRIBUTE_TEXTURE_SLOT_WIDTH =MICRON_PATCH_SIZE_MAX * VERTICES_PER_TRIANGLE;
+
 export class PatchDataTextures {
     /**
      *
@@ -70,7 +74,7 @@ export class PatchDataTextures {
         const attribute_count = spec.attributes.length;
 
         for (let i = 0; i < attribute_count; i++) {
-            attributes[i] = new AttributeDataTexture(spec.attributes[i], this.__column_count);
+            attributes[i] = new AttributeDataTexture(spec.attributes[i], this.__column_count, ATTRIBUTE_TEXTURE_SLOT_WIDTH);
         }
 
     }

package/src/engine/graphics/render/forward_plus/LightManager.js

@@ -18,15 +18,17 @@ import { computeFrustumCorners } from "./computeFrustumCorners.js";
 import { read_plane_pair } from "./cluster/read_plane_pair.js";
 import { read_frustum_planes_to_array } from "../../../../core/geom/3d/frustum/read_frustum_planes_to_array.js";
 import { compute_cluster_planes_from_points } from "./cluster/compute_cluster_planes_from_points.js";
-import { TextureBackedMemoryRegion } from "./data/TextureBackedMemoryRegion.js";
+import { TextureBackedMemoryRegion } from "../../texture/TextureBackedMemoryRegion.js";
 import { assert } from "../../../../core/assert.js";
 import {
     DataType2TypedArrayConstructorMapping
 } from "../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
-import { NumericType } from "./data/NumericType.js";
-import { computeDataType } from "./data/computeDataType.js";
-import { computeThreeTextureTypeFromDataType } from "./data/computeThreeTextureTypeFromDataType.js";
-import { computeThreeTextureInternalFormatFromDataType } from "./data/computeThreeTextureInternalFormatFromDataType.js";
+import { NumericType } from "../../../../core/math/NumericType.js";
+import { computeBinaryDataTypeByPrecision } from "../../../../core/binary/type/computeBinaryDataTypeByPrecision.js";
+import { computeThreeTextureTypeFromDataType } from "../../texture/computeThreeTextureTypeFromDataType.js";
+import {
+    computeThreeTextureInternalFormatFromDataType
+} from "../../texture/computeThreeTextureInternalFormatFromDataType.js";
 import { BinaryUint32BVH } from "../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
 import { mat4 } from "gl-matrix";
 import { TextureAtlas } from "../../texture/atlas/TextureAtlas.js";
@@ -394,7 +396,7 @@ export class LightManager {
         const rounded_value = Math.ceil(bit_count);
 
         this.__cluster_texture_precision = rounded_value;
-        const dataType = computeDataType(NumericType.Uint, rounded_value);
+        const dataType = computeBinaryDataTypeByPrecision(NumericType.Uint, rounded_value);
 
         const threeTextureType = computeThreeTextureTypeFromDataType(dataType);
 
@@ -415,7 +417,7 @@ export class LightManager {
     }
 
     __build_cluster_texture() {
-        const dataType = computeDataType(NumericType.Uint, this.__cluster_texture_precision);
+        const dataType = computeBinaryDataTypeByPrecision(NumericType.Uint, this.__cluster_texture_precision);
 
         const threeTextureType = computeThreeTextureTypeFromDataType(dataType);
 

package/src/engine/graphics/{micron/render/instanced → texture}/AttributeDataTexture.js

@@ -1,29 +1,31 @@
-import { assert } from "../../../../../core/assert.js";
-import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
-import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
-import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
+import { assert } from "../../../core/assert.js";
+import { typed_array_copy } from "../../../core/collection/array/typed/typed_array_copy.js";
+import { channelCountToThreeTextureFormat } from "./channelCountToThreeTextureFormat.js";
 import { DataTexture, NearestFilter } from "three";
-import { compute_micron_buffer_array_constructor } from "../../build/compute_micron_buffer_array_constructor.js";
+import { computeThreeTextureTypeFromDataType } from "./computeThreeTextureTypeFromDataType.js";
+import { computeThreeTextureInternalFormatFromDataType } from "./computeThreeTextureInternalFormatFromDataType.js";
+import { DataTypeByteSizes } from "../../../core/binary/type/DataTypeByteSizes.js";
+import { normalized_internal_format } from "./normalized_internal_format.js";
 import {
-    computeThreeTextureTypeFromDataType
-} from "../../../render/forward_plus/data/computeThreeTextureTypeFromDataType.js";
-import {
-    computeThreeTextureInternalFormatFromDataType
-} from "../../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
-import { DataTypeByteSizes } from "../../../../../core/binary/type/DataTypeByteSizes.js";
-import { normalized_internal_format } from "../../../texture/normalized_internal_format.js";
+    compute_typed_array_constructor_from_data_type
+} from "../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
 
 export class AttributeDataTexture {
     /**
      *
      * @param {AttributeSpec} spec
      * @param {number} column_count
+     * @param {number} slot_width number of data points stored per slot
      */
-    constructor(spec, column_count) {
+    constructor(spec, column_count, slot_width) {
         assert.defined(spec, 'spec');
         assert.equal(spec.isAttributeSpec, true, 'spec.isAttributeSpec !== true');
 
         assert.isNonNegativeInteger(column_count, 'column_count');
+        assert.greaterThan(column_count, 0, 'column_count > 0');
+
+        assert.isNonNegativeInteger(slot_width, 'slot_width');
+        assert.greaterThan(slot_width, 0, 'slot_width > 0');
 
         /**
          *
@@ -48,6 +50,13 @@ export class AttributeDataTexture {
          */
         this.__texture = null;
 
+        /**
+         * Number of data points stored per slot
+         * @type {number}
+         * @private
+         */
+        this.__slot_width = slot_width;
+
         this.build();
     }
 
@@ -76,8 +85,7 @@ export class AttributeDataTexture {
     }
 
     computeSlotWidth() {
-        const VERTICES_PER_TRIANGLE = 3;
-        return MICRON_PATCH_SIZE_MAX * VERTICES_PER_TRIANGLE;
+        return this.__slot_width;
     }
 
     /**
@@ -109,7 +117,7 @@ export class AttributeDataTexture {
 
         const old_data = image.data;
 
-        const TypedArray = compute_micron_buffer_array_constructor(spec.type);
+        const TypedArray = compute_typed_array_constructor_from_data_type(spec.type);
         const new_data = new TypedArray(width * height * spec.itemSize);
 
         // retain data
@@ -127,7 +135,7 @@ export class AttributeDataTexture {
     build() {
         const spec = this.__spec;
 
-        const TypedArray = compute_micron_buffer_array_constructor(spec.type);
+        const TypedArray = compute_typed_array_constructor_from_data_type(spec.type);
 
         const width = this.computeSlotWidth() * this.__column_count;
         const height = Math.ceil(this.__capacity / this.__column_count);
@@ -287,8 +295,9 @@ export class AttributeDataTexture {
      * @return {AttributeDataTexture}
      * @param {AttributeSpec} spec
      * @param {number} column_count
+     * @param {number} slot_width
      */
-    static from(spec, column_count) {
-        return new AttributeDataTexture(spec, column_count);
+    static from(spec, column_count, slot_width) {
+        return new AttributeDataTexture(spec, column_count, slot_width);
     }
 }

package/src/engine/graphics/{render/forward_plus/data → texture}/TextureBackedMemoryRegion.js

@@ -1,16 +1,16 @@
 import { ClampToEdgeWrapping, DataTexture, NearestFilter, RedFormat, UnsignedByteType } from "three";
-import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
-import { assert } from "../../../../../core/assert.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { assert } from "../../../core/assert.js";
 import {
     DataType2TypedArrayConstructorMapping
-} from "../../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { NumericType } from "./NumericType.js";
-import { computeDataType } from "./computeDataType.js";
+} from "../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
+import { max2 } from "../../../core/math/max2.js";
+import { NumericType } from "../../../core/math/NumericType.js";
+import { computeBinaryDataTypeByPrecision } from "../../../core/binary/type/computeBinaryDataTypeByPrecision.js";
 import { computeThreeTextureTypeFromDataType } from "./computeThreeTextureTypeFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "./computeThreeTextureInternalFormatFromDataType.js";
 import { computeThreeTextureFormat } from "./computeThreeTextureFormat.js";
-import { DataTypeByteSizes } from "../../../../../core/binary/type/DataTypeByteSizes.js";
+import { DataTypeByteSizes } from "../../../core/binary/type/DataTypeByteSizes.js";
 
 /**
  * How wide a data texture is
@@ -168,7 +168,7 @@ export class TextureBackedMemoryRegion {
      * @private
      */
     __update_data_type() {
-        const new_data_type = computeDataType(this.__type, this.__precision);
+        const new_data_type = computeBinaryDataTypeByPrecision(this.__type, this.__precision);
 
         if (new_data_type !== this.__data_type) {
             this.__data_type = new_data_type;

package/src/engine/graphics/{render/forward_plus/data → texture}/computeThreeTextureFormat.js

@@ -1,6 +1,6 @@
-import { NumericType } from "./NumericType.js";
+import { NumericType } from "../../../core/math/NumericType.js";
 import { channelCountToThreIntegerTextureType } from "./channelCountToThreIntegerTextureType.js";
-import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
+import { channelCountToThreeTextureFormat } from "./channelCountToThreeTextureFormat.js";
 
 /**
  *

package/src/engine/graphics/{render/forward_plus/data → texture}/computeThreeTextureInternalFormatFromDataType.js

@@ -1,4 +1,4 @@
-import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 
 /**
  *

package/src/engine/graphics/{render/forward_plus/data → texture}/computeThreeTextureTypeFromDataType.js

@@ -1,4 +1,4 @@
-import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 import {
     ByteType,
     FloatType,

package/src/engine/graphics/texture/sampler/Sampler2D2Canvas.js

@@ -23,7 +23,7 @@ function convertSampler2D2Canvas(sampler, scale = 255, offset = 0, canvas, fillD
         canvas = document.createElement("canvas");
     }
 
-    const converted_sampler = Sampler2D.uint8(4, sampler.width, sampler.height);
+    const converted_sampler = Sampler2D.uint8clamped(4, sampler.width, sampler.height);
 
     const width = sampler.width;
     const height = sampler.height;

package/src/engine/graphics/texture/sampler/sampler2DToFloat32Texture.js

@@ -1,9 +1,7 @@
 import { ClampToEdgeWrapping, DataTexture, FloatType, LinearFilter, NearestFilter } from "three";
 import { assert } from "../../../../core/assert.js";
 import { channelCountToThreeTextureFormat } from "../channelCountToThreeTextureFormat.js";
-import {
-    computeThreeTextureInternalFormatFromDataType
-} from "../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
+import { computeThreeTextureInternalFormatFromDataType } from "../computeThreeTextureInternalFormatFromDataType.js";
 import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 
 /**

package/src/generation/GridTaskGroup.js

@@ -46,7 +46,7 @@ export class GridTaskGroup extends GridTaskGenerator {
 
         /**
          *
-         * @type {TaskGroup[]}
+         * @type {(TaskGroup|Task)[]}
          */
         const tasks = [];
 
@@ -85,13 +85,13 @@ export class GridTaskGroup extends GridTaskGenerator {
                 const dependencyTask = tasks[dependencyIndex];
 
                 task.addDependency(dependencyTask);
-            }
 
-            if (!ENV_PRODUCTION) {
-                catchGeneratorErrors(generator, task);
             }
+
+            catchGeneratorErrors(generator, task);
         }
 
+
         return new TaskGroup(tasks, 'Grid Generator');
     }
 }

package/src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.js

@@ -1,3 +1,5 @@
+import { assert } from "../../../../core/assert.js";
+
 /**
  * Utility function, mainly useful for visualizing filter values
  * @param {Sampler2D} result
@@ -5,14 +7,20 @@
  * @param {GridData} grid
  */
 export function populateSampler2DFromCellFilter({ result, filter, grid }) {
+    assert.defined(result,'result');
+    assert.defined(filter,'filter');
+    assert.defined(grid,'grid');
 
     if (!filter.initialized) {
         filter.initialize(grid, 0);
     }
 
-    for (let y = 0; y < result.height; y++) {
+    const result_height = result.height;
+    const v_scale_result = 1 / (result_height - 1);
+
+    for (let y = 0; y < result_height; y++) {
 
-        const v = y / (result.height - 1);
+        const v = y * v_scale_result;
 
         const grid_y = v * (grid.height - 1);
 

package/src/generation/filtering/numeric/util/sampler_from_filter.js

@@ -0,0 +1,26 @@
+import { assert } from "../../../../core/assert.js";
+import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { populateSampler2DFromCellFilter } from "./populateSampler2DFromCellFilter.js";
+
+/**
+ *
+ * @param {GridData} grid
+ * @param {CellFilter} filter
+ * @param {number} resolution_scale must be a positive integer
+ */
+export function sampler_from_filter(grid, filter, resolution_scale = 1) {
+    assert.isNonNegativeInteger(resolution_scale, 'scale');
+    assert.defined(grid, 'grid');
+    assert.defined(filter, 'filter');
+
+
+    const result = Sampler2D.uint8(1, grid.width * resolution_scale, grid.height * resolution_scale);
+
+    populateSampler2DFromCellFilter({
+        result: result,
+        filter: filter,
+        grid
+    })
+
+    return result;
+}

package/src/generation/filtering/numeric/util/visualise_filters_as_grid.js

@@ -0,0 +1,81 @@
+import { assert } from "../../../../core/assert.js";
+import EmptyView from "../../../../view/elements/EmptyView.js";
+import { CanvasView } from "../../../../view/elements/CanvasView.js";
+import { sampler_from_filter } from "./sampler_from_filter.js";
+import sampler2D2Canvas from "../../../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import LabelView from "../../../../view/common/LabelView.js";
+
+/**
+ *
+ * @param {GridData} grid
+ * @param {{name:string, filter:CellFilter}[]} projections
+ * @param {number} [resolution_scale]
+ * @param {number} [grid_width]
+ * @returns {View}
+ */
+export function visualise_filters_as_grid({
+                                              grid,
+                                              projections,
+                                              resolution_scale = 4,
+                                              grid_width = 4
+                                          }) {
+
+    assert.defined(grid, 'grid');
+    assert.defined(projections, 'projections');
+    assert.isArray(projections, 'projections');
+
+    const tile_size = [
+        grid.width * resolution_scale,
+        grid.height * resolution_scale
+    ];
+
+    const vContainer = new EmptyView();
+
+    for (let i = 0; i < projections.length; i++) {
+
+        const x = i % grid_width;
+        const y = Math.floor(i / grid_width);
+
+        const { filter, name = "unnamed" } = projections[i];
+
+        const tile = new EmptyView();
+
+        const vCanvas = new CanvasView();
+
+        const sampler = sampler_from_filter(grid, filter, resolution_scale);
+
+        vCanvas.size.set(sampler.width, sampler.height);
+        vCanvas.transformOrigin.set(0, 0);
+
+        sampler2D2Canvas(sampler, 255, 0, vCanvas.el)
+
+        tile.css({
+            position: "absolute",
+            left: "0",
+            top: "0"
+        });
+
+        tile.position.set((tile_size[0] + 1) * x, (tile_size[1] + 1) * y);
+
+        const label = new LabelView(name, {
+            css: {
+                top: "0",
+                left: "0",
+                position: "absolute",
+                padding: "4px",
+                color: "white",
+                textShadow: "0 0 2px black"
+            }
+        });
+
+        tile.addChild(vCanvas);
+        tile.addChild(label);
+
+        tile.size.set(vCanvas.size.x * resolution_scale, vCanvas.size.y * resolution_scale)
+
+        vContainer.addChild(tile);
+
+    }
+
+    return vContainer;
+}

package/src/generation/grid/generation/GridTaskSequence.js

@@ -43,7 +43,9 @@ export class GridTaskSequence extends GridTaskGenerator {
 
             if (i > 0) {
                 // add dependence on previous task
-                task.addDependency(tasks[i - 1]);
+                const dependency = tasks[i - 1];
+
+                task.addDependency(dependency);
             }
 
             tasks.push(task);