@woosh/meep-engine 2.48.19 → 2.48.21

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.48.19",
+  "version": "2.48.21",
   "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/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/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/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);

package/src/engine/graphics/micron/MICRON_GEOMETRY_FIELD.js

@@ -1 +0,0 @@
-export const MICRON_GEOMETRY_FIELD = '@micron_geometry';

package/src/engine/graphics/micron/MICRON_URI_FIELD.js

@@ -1 +0,0 @@
-export const MICRON_URI_FIELD = '@micron_path';

package/src/engine/graphics/micron/build/MICRON_PATCH_SIZE_MAX.js

@@ -1,5 +0,0 @@
-/**
- * Maximum number of triangles per patch
- * @type {number}
- */
-export const MICRON_PATCH_SIZE_MAX = 128;