@woosh/meep-engine 2.65.0 → 2.67.0

package/editor/ecs/component/editors/ecs/terrain/TerrainEditor.js

@@ -1,10 +1,9 @@
-import { ObjectEditor } from "../../primitive/ObjectEditor.js";
-import { BitFlagsEditor } from "../../common/BitFlagsEditor.js";
+import { Texture } from "three";
+import { GridTransformKind } from "../../../../../../src/engine/ecs/terrain/ecs/GridTransformKind.js";
 import { TerrainFlags } from "../../../../../../src/engine/ecs/terrain/ecs/TerrainFlags.js";
-import { ImagePathEditor } from "../../ImagePathEditor.js";
+import { BitFlagsEditor } from "../../common/BitFlagsEditor.js";
 import { EnumEditor } from "../../common/EnumEditor.js";
-import { GridTransformKind } from "../../../../../../src/engine/ecs/terrain/ecs/GridTransformKind.js";
-import { Texture } from "three";
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
 
 export class TerrainEditor extends ObjectEditor {
     build(parent, field, registry) {
@@ -69,11 +68,6 @@ export class TerrainEditor extends ObjectEditor {
                 material: {
                     transient: true
                 },
-                heightMapURL: {
-                    editor: new ImagePathEditor(),
-                    deprecated: true,
-                    type: String
-                },
                 heightRange: {
                     deprecated: true
                 },

package/editor/process/symbolic/makeGridPositionSymbolDisplay.js

@@ -1,19 +1,19 @@
+import { BufferGeometry, Float32BufferAttribute, Line, LineBasicMaterial } from "three";
+import { SurfacePoint3 } from "../../../src/core/geom/3d/SurfacePoint3.js";
+import Vector3 from "../../../src/core/geom/Vector3.js";
 import { max2 } from "../../../src/core/math/max2.js";
 import { min2 } from "../../../src/core/math/min2.js";
+import { ProcessState } from "../../../src/core/process/ProcessState.js";
 import Task from "../../../src/core/process/task/Task.js";
 import { TaskSignal } from "../../../src/core/process/task/TaskSignal.js";
 import Entity from "../../../src/engine/ecs/Entity.js";
-import { BufferGeometry, Float32BufferAttribute, Line, LineBasicMaterial } from "three";
+import { EventType } from "../../../src/engine/ecs/EntityManager.js";
 import Renderable from "../../../src/engine/ecs/renderable/Renderable.js";
-import { SurfacePoint3 } from "../../../src/core/geom/3d/SurfacePoint3.js";
-import Vector3 from "../../../src/core/geom/Vector3.js";
+import { obtainTerrain } from "../../../src/engine/ecs/terrain/util/obtainTerrain.js";
 import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import GridPosition from "../../../src/engine/grid/position/GridPosition.js";
 import EditorEntity from "../../ecs/EditorEntity.js";
-import { EventType } from "../../../src/engine/ecs/EntityManager.js";
 import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
-import GridPosition from "../../../src/engine/grid/position/GridPosition.js";
-import { ProcessState } from "../../../src/core/process/ProcessState.js";
-import { obtainTerrain } from "../../../src/engine/ecs/terrain/util/obtainTerrain.js";
 
 /**
  *

package/editor/tools/SelectionTool.js

@@ -3,23 +3,19 @@
  */
 
 
-import Tool from './engine/Tool.js';
-import Vector2 from '../../src/core/geom/Vector2.js';
+import { Frustum as ThreeFrustum } from 'three';
 import AABB2 from '../../src/core/geom/2d/aabb/AABB2.js';
+import Vector2 from '../../src/core/geom/Vector2.js';
+import { makeScreenScissorFrustum } from "../../src/engine/graphics/camera/makeScreenScissorFrustum.js";
 import { Camera } from '../../src/engine/graphics/ecs/camera/Camera.js';
+import { ShadedGeometrySystem } from "../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import { make_ray_from_viewport_position } from "../../src/engine/graphics/make_ray_from_viewport_position.js";
 import View from '../../src/view/View.js';
 
 import SelectionAddAction from '../actions/concrete/SelectionAddAction.js';
 import SelectionClearAction from '../actions/concrete/SelectionClearAction.js';
-
-import { Frustum as ThreeFrustum, Raycaster } from 'three';
-import Vector3 from "../../src/core/geom/Vector3.js";
 import EditorEntity from "../ecs/EditorEntity.js";
-import Terrain from "../../src/engine/ecs/terrain/ecs/Terrain.js";
-import { SurfacePoint3 } from "../../src/core/geom/3d/SurfacePoint3.js";
-import { makeScreenScissorFrustum } from "../../src/engine/graphics/camera/makeScreenScissorFrustum.js";
-import { ShadedGeometrySystem } from "../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
-import { make_ray_from_viewport_position } from "../../src/engine/graphics/make_ray_from_viewport_position.js";
+import Tool from './engine/Tool.js';
 
 class SelectionView extends View {
     constructor() {
@@ -283,72 +279,6 @@ export function pickingEntitySelection(point, engine, camera) {
         }
     }
 
-    //query render layers
-    engine.graphics.layers.traverse(function (layer) {
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        const bvh = layer.bvh;
-
-        bvh.traverseRayLeafIntersections(ray_origin.x, ray_origin.y, ray_origin.z, ray_direction.x, ray_direction.y, ray_direction.z, function (leaf) {
-            const entity = findEntityOfNode(leaf);
-
-            if (typeof entity !== "number") {
-                //no entity
-                return;
-            }
-
-            const object = leaf.object;
-            if (
-                leaf.hasOwnProperty("object")
-                && typeof object === "object"
-                && object !== null
-                && object.isObject3D
-                && typeof object.raycast === "function"
-            ) {
-                //found a "raycast" function on the value object held by the leaf, assuming this is THREE.js raycast function
-                const raycaster = new Raycaster(ray_origin, ray_direction, 0, Infinity);
-
-                // WORKAROUND FOR https://github.com/mrdoob/three.js/issues/17078
-                raycaster.camera = camera;
-
-
-                object.traverse(node => {
-                    const intersection = [];
-                    node.raycast(raycaster, intersection);
-
-                    intersection.forEach(function (contact) {
-                        tryAddEntity(entity, contact.point);
-                    });
-                });
-
-            } else {
-                /**
-                 *
-                 * @type {Terrain}
-                 */
-                const terrain = dataset.getComponent(entity, Terrain);
-
-                if (terrain !== undefined) {
-                    const sp = new SurfacePoint3();
-
-                    terrain.raycastFirstSync(sp, ray_origin.x, ray_origin.y, ray_origin.z, ray_direction.x, ray_direction.y, ray_direction.z);
-
-                    tryAddEntity(entity, sp.position);
-                    return;
-                }
-
-                const center = new Vector3(0, 0, 0);
-
-                leaf.getCenter(center);
-
-                tryAddEntity(entity, center);
-            }
-        });
-
-    });
-
     return bestCandidate !== null ? [bestCandidate] : [];
 }
 
@@ -381,25 +311,6 @@ function marqueeSelection(box, editor, camera) {
     makeScreenScissorFrustum(frustum, normalizedBox, camera);
 
     const selection = [];
-    //query render layers
-    engine.graphics.layers.traverse(function (layer) {
-        layer.bvh.threeTraverseFrustumsIntersections([frustum], function (leaf, fullyInside) {
-
-            if (leaf.hasOwnProperty("entity") && selection.indexOf(leaf.entity) === -1) {
-                let entity = findEntityOfNode(leaf);
-
-                entity = dereferenceEntity(entity, dataset);
-
-                if (entity === -1) {
-                    return;
-                }
-
-                if (selection.indexOf(entity) === -1) {
-                    selection.push(entity);
-                }
-            }
-        });
-    });
 
     return selection;
 }

package/package.json

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

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -1,114 +1,70 @@
-import { array_copy } from "../../../collection/array/array_copy.js";
-import { min2 } from "../../../math/min2.js";
-import { max2 } from "../../../math/max2.js";
+import { assert } from "../../../assert.js";
 import { ceilPowerOfTwo } from "../../../binary/operations/ceilPowerOfTwo.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { array_swap } from "../../../collection/array/array_swap.js";
+import { aabb3_array_combine } from "../../../geom/3d/aabb/aabb3_array_combine.js";
+import { aabb3_array_set } from "../../../geom/3d/aabb/aabb3_array_set.js";
+import { aabb3_compute_half_surface_area } from "../../../geom/3d/aabb/aabb3_compute_half_surface_area.js";
 import { mortonEncode_magicbits } from "../../../geom/3d/morton/mortonEncode_magicbits.js";
-import { min3 } from "../../../math/min3.js";
+import { max2 } from "../../../math/max2.js";
 import { max3 } from "../../../math/max3.js";
-import { aabb3_compute_half_surface_area } from "../../../geom/3d/aabb/aabb3_compute_half_surface_area.js";
+import { min2 } from "../../../math/min2.js";
+import { min3 } from "../../../math/min3.js";
 
 /**
  * @readonly
  * @type {number}
  */
-export const BVH_BOX_BYTE_SIZE = 24;
+export const BVH_BOX_BYTE_SIZE = 6;
 
 /**
- * In bytes
+ * In words (4 byte)
  * @readonly
  * @type {number}
  */
-export const BVH_BINARY_NODE_SIZE = 24;
+export const BVH_BINARY_NODE_SIZE = 6;
 /**
  * @readonly
  * @type {number}
  */
-export const BVH_LEAF_NODE_SIZE = 28;
-
-/**
- *
- * @param {DataView} data
- * @param {number} destination
- * @param {number} source_a
- * @param {number} source_b
- */
-function refit_binary(data, destination, source_a, source_b) {
-    const ax0 = data.getFloat32(source_a);
-    const ay0 = data.getFloat32(source_a + 4);
-    const az0 = data.getFloat32(source_a + 8);
-    const ax1 = data.getFloat32(source_a + 12);
-    const ay1 = data.getFloat32(source_a + 16);
-    const az1 = data.getFloat32(source_a + 20);
-
-    const bx0 = data.getFloat32(source_b);
-    const by0 = data.getFloat32(source_b + 4);
-    const bz0 = data.getFloat32(source_b + 8);
-    const bx1 = data.getFloat32(source_b + 12);
-    const by1 = data.getFloat32(source_b + 16);
-    const bz1 = data.getFloat32(source_b + 20);
-
-    const x0 = min2(ax0, bx0);
-    const y0 = min2(ay0, by0);
-    const z0 = min2(az0, bz0);
-
-    const x1 = max2(ax1, bx1);
-    const y1 = max2(ay1, by1);
-    const z1 = max2(az1, bz1);
-
-    data.setFloat32(destination, x0);
-    data.setFloat32(destination + 4, y0);
-    data.setFloat32(destination + 8, z0);
-    data.setFloat32(destination + 12, x1);
-    data.setFloat32(destination + 16, y1);
-    data.setFloat32(destination + 20, z1);
-}
-
-/**
- *
- * @param {Uint8Array} data
- * @param {number} destination
- * @param {number} source
- */
-function copy_box(data, destination, source) {
-    array_copy(data, source, data, destination, 24);
-}
+export const BVH_LEAF_NODE_SIZE = 7;
 
 /**
  *
- * @param {DataView} data
+ * @param {Float32Array} data
  * @param {number} destination
  * @param {number} source
  */
 function copy_box_zero_size(data, destination, source) {
-    const x = data.getFloat32(source);
-    const y = data.getFloat32(source + 4);
-    const z = data.getFloat32(source + 8);
+    assert.isNonNegativeInteger(destination, 'destination');
+    assert.isNonNegativeInteger(source, 'source');
 
-    data.setFloat32(destination, x);
-    data.setFloat32(destination + 4, y);
-    data.setFloat32(destination + 8, z);
+    const x = data[source];
+    const y = data[source + 1];
+    const z = data[source + 2];
 
-    data.setFloat32(destination + 12, x);
-    data.setFloat32(destination + 16, y);
-    data.setFloat32(destination + 20, z);
+    assert.notNaN(x, 'x');
+    assert.notNaN(y, 'y');
+    assert.notNaN(z, 'z');
+
+    aabb3_array_set(data, destination, x, y, z, x, y, z);
 }
 
 /**
  * Assumes data will be normalized to 0...1 value range
- * @param {DataView} data
+ * @param {Float32Array} data
  * @param {number} address
  * @param {number[]} matrix
  * @returns {number}
  */
 function build_morton(data, address, matrix) {
 
-    const x0 = data.getFloat32(address);
-    const y0 = data.getFloat32(address + 4);
-    const z0 = data.getFloat32(address + 8);
-    const x1 = data.getFloat32(address + 12);
-    const y1 = data.getFloat32(address + 16);
-    const z1 = data.getFloat32(address + 20);
+    const x0 = data[address];
+    const y0 = data[address + 1];
+    const z0 = data[address + 2];
+    const x1 = data[address + 3];
+    const y1 = data[address + 4];
+    const z1 = data[address + 5];
 
     const cx = (x0 + x1) / 2;
     const cy = (y0 + y1) / 2;
@@ -123,16 +79,28 @@ const scratch_box_0 = new Float32Array(18);
 const stack = [];
 
 export class BinaryUint32BVH {
-    constructor() {
-        this.__data_buffer = new ArrayBuffer(320);
-        this.__data_uint8 = new Uint8Array(this.__data_buffer);
+    /**
+     *
+     * @private
+     * @type {ArrayBuffer}
+     */
+    __data_buffer;
 
-        /**
-         * @readonly
-         * @type {DataView}
-         * @private
-         */
-        this.__data_view = new DataView(this.__data_buffer);
+    /**
+     * @readonly
+     * @type {Float32Array}
+     * @private
+     */
+    __data_float32;
+
+    /**
+     * @readonly
+     * @private
+     * @type {Uint32Array}
+     */
+    __data_uint32;
+
+    constructor() {
 
         /**
          *
@@ -147,6 +115,8 @@ export class BinaryUint32BVH {
          * @private
          */
         this.__node_count_leaf = 0;
+
+        this.data = new ArrayBuffer(320);
     }
 
     getTotalBoxCount() {
@@ -169,23 +139,37 @@ export class BinaryUint32BVH {
         return this.__node_count_binary * BVH_BINARY_NODE_SIZE;
     }
 
+    get float32() {
+        return this.__data_float32;
+    }
+
+    get uint32() {
+        return this.__data_uint32;
+    }
+
     /**
      *
-     * @returns {DataView}
+     * @param {ArrayBuffer} v
      */
-    getDataView() {
-        return this.__data_view;
+    set data(v) {
+        this.__data_buffer = v;
+
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+    }
+
+    get data() {
+        return this.__data_buffer;
     }
 
     initialize_structure() {
         // compute memory requirements
-        const storage_size = this.__node_count_binary * BVH_BINARY_NODE_SIZE + this.__node_count_leaf * BVH_LEAF_NODE_SIZE;
+        const word_count = this.__node_count_binary * BVH_BINARY_NODE_SIZE + this.__node_count_leaf * BVH_LEAF_NODE_SIZE;
+        const storage_size = word_count * 4;
 
         // possibly resize the storage
         if (this.__data_buffer.byteLength < storage_size) {
-            this.__data_buffer = new ArrayBuffer(storage_size);
-            this.__data_uint8 = new Uint8Array(this.__data_buffer);
-            this.__data_view = new DataView(this.__data_buffer);
+            this.data = new ArrayBuffer(storage_size);
         }
     }
 
@@ -218,19 +202,28 @@ export class BinaryUint32BVH {
      * @param {number} y1
      * @param {number} z1
      */
-    setLeafData(index, payload, x0, y0, z0, x1, y1, z1) {
-        const address = index * BVH_LEAF_NODE_SIZE + this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+    setLeafData(
+        index, payload,
+        x0, y0, z0,
+        x1, y1, z1
+    ) {
+        assert.notNaN(x0, 'x0');
+        assert.notNaN(y0, 'y0');
+        assert.notNaN(z0, 'z0');
+        assert.notNaN(x1, 'x1');
+        assert.notNaN(y1, 'y1');
+        assert.notNaN(z1, 'z1');
 
-        const view = this.__data_view;
+        const address = index * BVH_LEAF_NODE_SIZE + this.__node_count_binary * BVH_BINARY_NODE_SIZE;
 
-        view.setFloat32(address, x0);
-        view.setFloat32(address + 4, y0);
-        view.setFloat32(address + 8, z0);
-        view.setFloat32(address + 12, x1);
-        view.setFloat32(address + 16, y1);
-        view.setFloat32(address + 20, z1);
+        aabb3_array_set(
+            this.__data_float32,
+            address,
+            x0, y0, z0,
+            x1, y1, z1
+        );
 
-        view.setUint32(address + 24, payload);
+        this.__data_uint32[address + 6] = payload;
     }
 
     /**
@@ -240,10 +233,7 @@ export class BinaryUint32BVH {
      * @param {number} destination_offset offset within the destination array where to start writing results
      */
     readBounds(address, destination, destination_offset) {
-        const v = this.__data_view;
-        for (let i = 0; i < 6; i++) {
-            destination[destination_offset + i] = v.getFloat32(address + i * 4);
-        }
+        array_copy(this.__data_float32, address, destination, destination_offset, 6);
     }
 
     /**
@@ -256,7 +246,7 @@ export class BinaryUint32BVH {
 
         const address = block_address + leaf_index * BVH_LEAF_NODE_SIZE + BVH_BOX_BYTE_SIZE;
 
-        return this.__data_view.getUint32(address);
+        return this.__data_uint32[address];
     }
 
     compute_total_surface_area() {
@@ -369,7 +359,7 @@ export class BinaryUint32BVH {
         stack[0] = 0; // first node
         stack[1] = this.__node_count_leaf - 1; // last node
 
-        const data = this.__data_view;
+        const data = this.__data_float32;
 
         while (stackPointer > 0) {
             stackPointer -= 2;
@@ -382,7 +372,9 @@ export class BinaryUint32BVH {
 
             const pivotIndex = (left + right) >> 1;
 
-            const pivot = build_morton(data, pivotIndex * BVH_LEAF_NODE_SIZE + leaf_block_address, projection);
+            const pivot_address = pivotIndex * BVH_LEAF_NODE_SIZE + leaf_block_address;
+
+            const pivot = build_morton(data, pivot_address, projection);
 
             /* partition */
             while (i <= j) {
@@ -426,9 +418,12 @@ export class BinaryUint32BVH {
      */
     __swap_leaves(i, j) {
         const leaf_block_address = this.getLeafBlockAddress();
+        const a = i * BVH_LEAF_NODE_SIZE + leaf_block_address;
+        const b = j * BVH_LEAF_NODE_SIZE + leaf_block_address;
+
         array_swap(
-            this.__data_uint8, i * BVH_LEAF_NODE_SIZE + leaf_block_address,
-            this.__data_uint8, j * BVH_LEAF_NODE_SIZE + leaf_block_address,
+            this.__data_float32, a,
+            this.__data_float32, b,
             BVH_LEAF_NODE_SIZE
         );
     }
@@ -453,6 +448,8 @@ export class BinaryUint32BVH {
 
         const node_count_leaf = this.__node_count_leaf;
 
+        const float32 = this.__data_float32;
+
         // build bottom-most level, just above the leaves
         for (i = 0; i < level_node_count; i++) {
             const leafIndex0 = i * 2;
@@ -463,13 +460,17 @@ export class BinaryUint32BVH {
 
             if (leafIndex1 < node_count_leaf) {
                 // both children nodes are valid
-                refit_binary(this.__data_view, offset, leafOffset0, leafOffset1);
+                aabb3_array_combine(
+                    float32, offset,
+                    float32, leafOffset0,
+                    float32, leafOffset1
+                );
             } else if (leafIndex0 < node_count_leaf) {
                 // only left child node is valid
-                copy_box(this.__data_uint8, offset, leafOffset0);
+                array_copy(float32, leafOffset0, float32, offset, 6);
             } else {
                 //initialize to 0-size box same position as previous node
-                copy_box_zero_size(this.__data_view, offset, offset - BVH_BINARY_NODE_SIZE);
+                copy_box_zero_size(this.__data_float32, offset, (offset - BVH_BINARY_NODE_SIZE));
             }
 
             offset += BVH_BINARY_NODE_SIZE;
@@ -492,7 +493,11 @@ export class BinaryUint32BVH {
                 const address_child_0 = childIndex0 * BVH_BINARY_NODE_SIZE;
                 const address_child_1 = childIndex1 * BVH_BINARY_NODE_SIZE;
 
-                refit_binary(this.__data_view, address_parent, address_child_0, address_child_1);
+                aabb3_array_combine(
+                    float32, address_parent,
+                    float32, address_child_0,
+                    float32, address_child_1
+                );
 
                 parentIndex++;
             }

package/src/core/bvh2/binary/2/BinaryUint32BVH.spec.js

@@ -63,6 +63,60 @@ test('read/write 1 leaf', () => {
     expect(bounds[5]).toBeCloseTo(23);
 });
 
+test("2 leaf node build", () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(2);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
+    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
+
+    bvh.build();
+
+    const bounds = [];
+
+    bvh.readBounds(0, bounds, 0);
+
+    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 1.4, 1.5, 1.6])));
+});
+
+test("1 leaf node build", () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(1);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
+
+    bvh.build();
+
+    const bounds = [];
+
+    bvh.readBounds(0, bounds, 0);
+
+    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])));
+});
+
+test("3 leaf node build", () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(3);
+    bvh.initialize_structure();
+
+    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
+    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
+    bvh.setLeafData(2, 11, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6);
+
+    bvh.build();
+
+    const bounds = [];
+
+    bvh.readBounds(0, bounds, 0);
+
+    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 2.4, 2.5, 2.6])));
+});
+
 test('4 node sorted build', () => {
     const bvh = new BinaryUint32BVH();