@woosh/meep-engine 2.33.5 → 2.33.10

package/core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js

@@ -0,0 +1,96 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array|Float64Array} aabb_corners
+ * @param {number[]|Float32Array} projection_matrix
+ */
+export function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matrix) {
+    assert.greaterThanOrEqual(result.length, 6, 'result.length must >= 6');
+    assert.greaterThanOrEqual(aabb_corners.length, 24, 'aabb_corners.length must >= 24');
+    assert.greaterThanOrEqual(projection_matrix.length, 16, 'projection_matrix.length must >= 16');
+
+    // read matrix into local variables for speed
+    const a0 = projection_matrix[0];
+    const a1 = projection_matrix[1];
+    const a2 = projection_matrix[2];
+    const a3 = projection_matrix[3];
+
+    const b0 = projection_matrix[4];
+    const b1 = projection_matrix[5];
+    const b2 = projection_matrix[6];
+    const b3 = projection_matrix[7];
+
+    const c0 = projection_matrix[8];
+    const c1 = projection_matrix[9];
+    const c2 = projection_matrix[10];
+    const c3 = projection_matrix[11];
+
+    const d0 = projection_matrix[12];
+    const d1 = projection_matrix[13];
+    const d2 = projection_matrix[14];
+    const d3 = projection_matrix[15];
+
+    // initialize bounds
+    let x0 = Number.POSITIVE_INFINITY;
+    let y0 = Number.POSITIVE_INFINITY;
+    let z0 = Number.POSITIVE_INFINITY;
+
+    let x1 = Number.NEGATIVE_INFINITY;
+    let y1 = Number.NEGATIVE_INFINITY;
+    let z1 = Number.NEGATIVE_INFINITY;
+
+
+    for (let i = 0; i < 24; i += 3) {
+
+        // read corner
+        const _x = aabb_corners[i];
+        const _y = aabb_corners[i + 1];
+        const _z = aabb_corners[i + 2];
+
+        // apply transform
+        const t_x = a0 * _x + b0 * _y + c0 * _z + d0;
+        const t_y = a1 * _x + b1 * _y + c1 * _z + d1;
+        const t_z = a2 * _x + b2 * _y + c2 * _z + d2;
+        const t_w = a3 * _x + b3 * _y + c3 * _z + d3;
+
+        // perspective divide and normalization (-1,1 space projected to -0.5,0.5)
+        const d = 1 / t_w;
+
+        // finally compute screen-space coordinates of the corner
+        const x = t_x * d;
+        const y = t_y * d;
+        const z = t_z * d;
+
+        if (x0 > x) {
+            x0 = x;
+        }
+        if (x1 < x) {
+            x1 = x;
+        }
+
+        if (y0 > y) {
+            y0 = y;
+        }
+        if (y1 < y) {
+            y1 = y;
+        }
+
+        if (z0 > z) {
+            z0 = z;
+        }
+        if (z1 < z) {
+            z1 = z;
+        }
+
+    }
+
+    result[0] = x0;
+    result[1] = y0;
+    result[2] = z0;
+
+    result[3] = x1;
+    result[4] = y1;
+    result[5] = z1;
+}

package/{engine/graphics/micron/build/bounds → core/geom/3d}/compute_bounding_cone_of_2_cones.js

@@ -1,9 +1,9 @@
 //
 
 
-import Vector3 from "../../../../../core/geom/Vector3.js";
-import Quaternion, { quat3_createFromAxisAngle } from "../../../../../core/geom/Quaternion.js";
-import { max2 } from "../../../../../core/math/max2.js";
+import Vector3 from "../Vector3.js";
+import Quaternion, { quat3_createFromAxisAngle } from "../Quaternion.js";
+import { max2 } from "../../math/max2.js";
 
 const tangent = new Vector3();
 

package/{engine/graphics/micron/build/bounds → core/geom/3d}/compute_bounding_cone_of_2_cones.spec.js

@@ -1,5 +1,5 @@
 import { compute_bounding_cone_of_2_cones } from "./compute_bounding_cone_of_2_cones.js";
-import { ConicRay } from "../../../../../core/geom/ConicRay.js";
+import { ConicRay } from "../ConicRay.js";
 
 /**
  *

package/{engine/graphics/micron/build/bounds → core/geom/3d}/compute_bounding_sphere_of_2_spheres.js

@@ -2,9 +2,9 @@
 
 
 import { vec3 } from "gl-matrix";
-import { Miniball } from "../../../../../core/geom/packing/miniball/Miniball.js";
-import { PointSet } from "../../../../../core/geom/packing/miniball/PointSet.js";
-import { max2 } from "../../../../../core/math/max2.js";
+import { Miniball } from "../packing/miniball/Miniball.js";
+import { PointSet } from "../packing/miniball/PointSet.js";
+import { max2 } from "../../math/max2.js";
 
 /**
  *

package/core/geom/3d/frustum/array_normalize_plane.js

@@ -0,0 +1,25 @@
+import { v3_length } from "../../Vector3.d.ts";
+
+/**
+ * Normalize a plane in-place
+ * @param {number[]} source
+ * @param {number} source_offset
+ */
+function array_normalize_plane(source, source_offset) {
+    const _x = source[source_offset];
+    const _y = source[source_offset + 1];
+    const _z = source[source_offset + 2];
+
+    const length = v3_length(_x, _y, _z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    /*
+    By re-using values already in the registers instead of using *= we save a few extra READ ops
+     */
+    source[source_offset] = _x * inverseNormalLength;
+    source[source_offset + 1] = _y * inverseNormalLength;
+    source[source_offset + 2] = _z * inverseNormalLength;
+
+    source[source_offset + 3] *= inverseNormalLength;
+}

package/core/geom/3d/frustum/array_setFromProjectionMatrix.js

@@ -0,0 +1,60 @@
+import { v3_length } from "../../Vector3.js";
+
+/**
+ *
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ */
+function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+    const length = v3_length(x, y, z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    destination[destination_offset] = x * inverseNormalLength;
+    destination[destination_offset + 1] = y * inverseNormalLength;
+    destination[destination_offset + 2] = z * inverseNormalLength;
+    destination[destination_offset + 3] = w * inverseNormalLength;
+}
+
+/**
+ * Set frustum from projection matrix
+ * @param {number[]|Float32Array} frustum_planes
+ * @param {number[]} me
+ */
+export function array_setFromProjectionMatrix(frustum_planes, me) {
+
+    const me0 = me[0];
+    const me3 = me[3];
+
+    const me4 = me[4];
+    const me7 = me[7];
+
+    const me8 = me[8];
+    const me11 = me[11];
+
+    const me12 = me[12];
+    const me15 = me[15];
+
+    array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
+    array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
+
+    const me1 = me[1];
+    const me5 = me[5];
+    const me9 = me[9];
+    const me13 = me[13];
+
+    array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
+    array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
+
+    const me2 = me[2];
+    const me6 = me[6];
+    const me10 = me[10];
+    const me14 = me[14];
+
+    array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
+    array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);
+}

package/{engine/graphics/micron/util → core/geom/3d}/unit_hemioct.spec.js

@@ -1,5 +1,5 @@
 import { decode_hemioct_to_unit, encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
-import { v3_length } from "../../../../core/geom/Vector3.js";
+import { v3_length } from "../Vector3.d.ts";
 
 test('encode-decode', () => {
     const v0 = [];

package/{engine/graphics/micron/build → core}/graph/SquareMatrix.js

@@ -1,5 +1,5 @@
-import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
-import { assert } from "../../../../../core/assert.js";
+import { DataType2TypedArrayConstructorMapping } from "../collection/table/DataType2TypedArrayConstructorMapping.js";
+import { assert } from "../assert.js";
 
 export class SquareMatrix {
     /**

package/{engine/graphics/micron/build → core}/graph/SquareMatrix.spec.js

@@ -1,5 +1,5 @@
 import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
+import { DataType } from "../collection/table/DataType.js";
 
 test('set/get cell', () => {
     const m = new SquareMatrix(2, DataType.Uint8);

package/{engine/graphics/micron/build → core}/graph/WeightedEdge.js

@@ -1,4 +1,4 @@
-import { Edge } from "../../../../../core/graph/Edge.js";
+import { Edge } from "./Edge.js";
 
 export class WeightedEdge extends Edge {
     constructor(a, b) {

package/{engine/graphics/micron/build → core}/graph/build_face_graph_from_mesh.js

@@ -1,6 +1,6 @@
-import { Graph } from "../../../../../core/graph/v2/Graph.js";
+import { Graph } from "./v2/Graph.js";
 import { MultiNode } from "./MultiNode.js";
-import { compute_face_connection_weight } from "../clustering/compute_face_connection_weight.js";
+import { compute_face_connection_weight } from "../../engine/graphics/micron/build/clustering/compute_face_connection_weight.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 import { graph_compute_disconnected_clusters } from "./graph_compute_disconnected_clusters.js";
 

package/{engine/graphics/micron/build/clustering → core/graph}/cluster_mesh_metis.js

@@ -1,5 +1,5 @@
-import { Metis } from "../graph/metis/metis.js";
-import { metis_options } from "../graph/metis/metis_options.js";
+import { Metis } from "./metis/metis.js";
+import { metis_options } from "./metis/metis_options.js";
 
 /**
  * How many times to retry partitioning before giving up
@@ -7,10 +7,6 @@ import { metis_options } from "../graph/metis/metis_options.js";
  */
 const MAX_STEPS = 50;
 
-function cluster_mesh_metis_detailed(mesh, patch_size) {
-
-}
-
 /**
  *
  * @param {Uint32Array} result

package/{engine/graphics/micron/build → core}/graph/coarsen_graph.js

@@ -1,4 +1,4 @@
-import FastBinaryHeap from "../../../../navigation/grid/FastBinaryHeap.js";
+import FastBinaryHeap from "../../engine/navigation/grid/FastBinaryHeap.js";
 import { mn_graph_collapse_weighted_edge } from "./mn_graph_collapse_weighted_edge.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 

package/{engine/graphics/micron/build → core}/graph/coarsen_graph.spec.js

@@ -1,4 +1,4 @@
-import { Graph } from "../../../../../core/graph/v2/Graph.js";
+import { Graph } from "./v2/Graph.js";
 import { MultiNode } from "./MultiNode.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 import { coarsen_graph } from "./coarsen_graph.js";

package/{engine/graphics/micron/build → core}/graph/eigen/eigen.spec.js

@@ -1,5 +1,5 @@
 import { SquareMatrix } from "../SquareMatrix.js";
-import { DataType } from "../../../../../../core/collection/table/DataType.js";
+import { DataType } from "../../collection/table/DataType.js";
 import { matrix_eigenvalues_in_place } from "./eigen.js";
 
 function roughly_equal_array_vectors(actual, expected) {

package/{engine/graphics/micron/build → core}/graph/graph_k_means_cluster.js

@@ -1,10 +1,10 @@
 //
-import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
-import { randomIntegerBetween } from "../../../../../core/math/MathUtils.js";
+import { seededRandom } from "../math/random/seededRandom.js";
+import { randomIntegerBetween } from "../math/MathUtils.js";
 import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
-import { BitSet } from "../../../../../core/binary/BitSet.js";
-import FastBinaryHeap from "../../../../navigation/grid/FastBinaryHeap.js";
+import { DataType } from "../collection/table/DataType.js";
+import { BitSet } from "../binary/BitSet.js";
+import FastBinaryHeap from "../../engine/navigation/grid/FastBinaryHeap.js";
 
 /**
  * @template N

package/{engine/graphics/micron/build → core}/graph/graph_laplacian_matrix.js

@@ -1,6 +1,6 @@
 import { graph_degree_matrix } from "./graph_degree_matrix.js";
 import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
+import { DataType } from "../collection/table/DataType.js";
 import { graph_adjacency_matrix } from "./graph_adjacency_matrix.js";
 
 /**

package/{engine/graphics/micron/build → core}/graph/metis/metis.js

@@ -1,5 +1,5 @@
-import WorkerBuilder from "../../../../../../core/process/worker/WorkerBuilder.js";
-import { OnDemandWorkerManager } from "../../../../../../core/process/worker/OnDemandWorkerManager.js";
+import WorkerBuilder from "../../process/worker/WorkerBuilder.js";
+import { OnDemandWorkerManager } from "../../process/worker/OnDemandWorkerManager.js";
 
 
 export class Metis {

package/core/process/undo/ActionProcessor.d.ts

@@ -17,6 +17,8 @@ export class ActionProcessor<CTX, MD> {
 
     redo(): void
 
+    navigateTo(mark: MD): boolean
+
     doMany(actions: Action<CTX>[]): void
 
     do(action: Action<CTX>): this

package/core/process/undo/ActionProcessor.js

@@ -202,6 +202,64 @@ export class ActionProcessor {
 
     }
 
+    /**
+     * Navigate to a specific mark back or forward
+     * @param {M} mark_descriptor specific mark description
+     * @returns {boolean} true on success, false otherwise (e.g. mark not found)
+     * @throws {Error} when mark is non-unique
+     */
+    navigateTo(mark_descriptor) {
+        // find all matching marks
+        const matching_marks = this.marks.filter(m => m.description === mark_descriptor);
+
+        if (matching_marks.length === 0) {
+            // not found
+            return false;
+        }
+
+        if (matching_marks.length > 1) {
+            throw new Error(`Attempting to navigate to a non-unique mark descriptor '${mark_descriptor}'. Mark descriptor must be unique, instead ${matching_marks.length} matches were found`);
+        }
+
+        const match = matching_marks[0];
+
+        const target = match.index;
+
+        let temp_cursor = this.cursor;
+
+        if (target > this.cursor) {
+
+            while (target > this.cursor) {
+                // navigate forward
+                this.redo();
+
+                if (temp_cursor === this.cursor) {
+                    // no cursor change
+                    return false;
+                }
+
+                temp_cursor = this.cursor;
+            }
+
+        } else if (target < this.cursor) {
+
+            while (target < this.cursor) {
+                // navigate backwards
+                this.undo();
+
+                if (temp_cursor === this.cursor) {
+                    // no cursor change
+                    return false;
+                }
+
+                temp_cursor = this.cursor;
+            }
+
+        }
+
+        return true;
+    }
+
     undo() {
         let markAddress = 0;
         /**
@@ -226,7 +284,7 @@ export class ActionProcessor {
             markAddress = 0;
         }
 
-        //keep rewinding until we hit mark
+        //keep rewinding until we hit a mark
         while (this.cursor > markAddress && this.cursor > 0) {
             this.cursor--;
             const action = this.history.get(this.cursor);

package/core/process/undo/ActionProcessor.spec.js

@@ -0,0 +1,59 @@
+import { ActionProcessor } from "./ActionProcessor.js";
+import { Action } from "./Action.js";
+
+class DummyContext {
+    constructor() {
+        this.value = 0;
+    }
+}
+
+class DummyAction extends Action {
+    apply(context) {
+        // do nothing
+        context.value++;
+    }
+
+    revert(context) {
+        context.value--;
+    }
+}
+
+test('navigateTo backwards', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    ap.mark('a');
+    ap.do(new DummyAction());
+    ap.mark('b');
+    ap.do(new DummyAction());
+
+    expect(ap.navigateTo('a')).toBe(true);
+
+    expect(ctx.value).toBe(0);
+});
+
+test('navigateTo forward', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    ap.mark('a');
+    ap.do(new DummyAction());
+    ap.mark('b');
+    ap.do(new DummyAction());
+    ap.mark('c');
+
+    ap.undo();
+    ap.undo();
+    ap.undo();
+
+    expect(ap.navigateTo('c')).toBe(true);
+
+    expect(ctx.value).toBe(2);
+});
+
+test('navigateTo non-existent on empty', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    expect(ap.navigateTo('a')).toBe(false);
+});

package/core/process/undo/Mark.js

@@ -8,13 +8,14 @@ export class Mark {
      * @constructor
      */
     constructor(index, description) {
-        assert.typeOf(index, 'number', 'index');
+        assert.isNumber(index, 'index');
 
         /**
          *
          * @type {number}
          */
         this.index = index;
+
         /**
          *
          * @type {D}

package/engine/Engine.d.ts

@@ -8,6 +8,7 @@ import {AssetManager} from "./asset/AssetManager";
 import {EntityManager} from "./ecs/EntityManager";
 import View from "../view/View";
 import Ticker from "./simulation/Ticker";
+import {EnginePluginManager} from "./plugin/EnginePluginManager";
 
 export interface IEngineInitializationOptions {
     entityManager?: EntityManager
@@ -25,6 +26,7 @@ export default class Engine {
     public readonly devices: { keyboard: KeyboardDevice, pointer: PointerDevice }
     public readonly assetManager: AssetManager
     public readonly ticker: Ticker
+    public readonly plugins: EnginePluginManager
 
     public start(): Promise<any>
 

package/engine/EngineHarness.js

@@ -203,10 +203,10 @@ export class EngineHarness {
      *
      * @param {Engine} engine
      * @param {Vector3} [focus]
-     * @param heightMap
-     * @param heightRange
-     * @param pitch
-     * @param yaw
+     * @param [heightMap]
+     * @param [heightRange]
+     * @param [pitch]
+     * @param [yaw]
      * @param {number} [distance]
      * @param {Vector2} [terrainSize]
      * @param {number} [terrainResolution]

package/engine/asset/loaders/material/bitmap2sampler_gl.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {WebGL2RenderingContext} gl
+ * @param {Sampler2D} sampler
+ * @param {ImageBitmap} bitmap
+ */
+export function bitmap2sampler_gl(gl, sampler, bitmap) {
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
+    gl.drawBuffers([gl.COLOR_ATTACHMENT0]);
+
+    const w = sampler.width;
+    const h = sampler.height;
+
+    if (sampler.itemSize !== 4) {
+        throw new Error(`Expected sampler.itemSize to be 4, instead was '${sampler.itemSize}'`);
+    }
+
+    gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, sampler.data);
+}

package/engine/asset/loaders/material/computeImageBitmapEquality.js

@@ -1,6 +1,7 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 import { assert } from "../../../../core/assert.js";
 import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
+import { bitmap2sampler_gl } from "./bitmap2sampler_gl.js";
 
 /**
  *
@@ -8,23 +9,6 @@ import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqu
  */
 const sampler_cache = new WeakMap();
 
-/**
- *
- * @param {WebGL2RenderingContext} gl
- * @param {Sampler2D} sampler
- * @param {ImageBitmap} bitmap
- */
-function bitmap2sampler_gl(gl, sampler, bitmap) {
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
-    gl.drawBuffers([gl.COLOR_ATTACHMENT0]);
-
-    const data = new Uint8Array(sampler.width * sampler.height * 4);
-
-    gl.readPixels(0, 0, sampler.width, sampler.height, gl.RGBA, gl.UNSIGNED_BYTE, data);
-
-    sampler.data = data;
-}
-
 /**
  *
  * @param {ImageBitmap} bitmap
@@ -45,7 +29,7 @@ function obtainSampler(bitmap, ctx) {
     const width = bitmap.width;
     const height = bitmap.height;
 
-    const sampler = new Sampler2D(null, 4, width, height);
+    const sampler = Sampler2D.uint8(4, width, height);
 
     bitmap2sampler_gl(ctx, sampler, bitmap);
 
@@ -75,15 +59,19 @@ function obtainCanvasCtx(width, height) {
 
     if (ctx_ref === null || (gl = ctx_ref.deref()) === undefined) {
         const canvas = document.createElement('canvas');
+
         gl = canvas.getContext("webgl2");
         gl.activeTexture(gl.TEXTURE0);
+
         const texture = gl.createTexture();
+
         gl.bindTexture(gl.TEXTURE_2D, texture);
+
         const framebuffer = gl.createFramebuffer();
+
         gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
         gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
 
-
         ctx_ref = new WeakRef(gl);
     }
 

package/engine/ecs/foliage/InstancedFoliage.js

@@ -1,9 +1,5 @@
 import { BinaryNode } from "../../../core/bvh2/BinaryNode.js";
-import {
-    deserializeRowFirstTable,
-    RowFirstTable,
-    serializeRowFirstTable
-} from "../../../core/collection/table/RowFirstTable.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
 import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { LeafNode } from "../../../core/bvh2/LeafNode.js";
@@ -19,6 +15,8 @@ import { traverseBinaryNodeUsingVisitor } from "../../../core/bvh2/traversal/tra
 import { serializeBinaryNodeToBinaryBuffer } from "../../../core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js";
 import { deserializeBinaryNodeFromBinaryBuffer } from "../../../core/bvh2/serialization/deserializeBinaryNodeFromBinaryBuffer.js";
 import { computeGeometryBoundingSphereMiniball } from "../../graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js";
+import { serializeRowFirstTable } from "../../../core/collection/table/serializeRowFirstTable.js";
+import { deserializeRowFirstTable } from "../../../core/collection/table/deserializeRowFirstTable.js";
 
 /**
  * @readonly