@woosh/meep-engine 2.39.43 → 2.40.1

package/engine/ecs/terrain/tiles/TerrainTile.js

@@ -18,13 +18,14 @@ import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
 
 import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
 
-import BVHFromBufferGeometry from '../../../graphics/geometry/bvh/buffered/BVHFromBufferGeometry.js';
-
 import IndexedBinaryBVH from '../../../../core/bvh2/binary/IndexedBinaryBVH.js';
 import { BVHGeometryRaycaster } from "../../../graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js";
 import ObservedInteger from "../../../../core/model/ObservedInteger.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import Signal from "../../../../core/events/signal/Signal.js";
+import { mat4 } from "gl-matrix";
+import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
+import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
 
 function extractFaceIndexFromLeaf(leaf) {
     return leaf;
@@ -92,11 +93,17 @@ class TerrainTile {
         this.isBuildInProgress = false;
         this.referenceCount = 0;
 
+        /**
+         *
+         * @type {Signal<TerrainTile>}
+         */
         this.onBuilt = new Signal();
         this.onDestroyed = new Signal();
 
-        this.buildCallbacks = [];
-
+        /**
+         * @private
+         * @type {{bottomLeft: boolean, top: boolean, left: boolean, bottom: boolean, bottomRight: boolean, topLeft: boolean, topRight: boolean, right: boolean}}
+         */
         this.stitching = {
             top: false,
             bottom: false,
@@ -110,27 +117,34 @@ class TerrainTile {
             bottomRight: false
         };
 
+        /**
+         * Initial estimate of height bounds for this tile
+         * Untransformed by transform matrix
+         * @type {NumericInterval}
+         * @private
+         */
+        this.__initial_height_range = new NumericInterval(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
+
         this.raycaster = new BVHGeometryRaycaster();
         //Binary BVH form doesn't have distinct leaf objects and stores face indices directly, this requires a special face index extractor that treats leaves as indices directly.
         this.raycaster.extractFaceIndexFromLeaf = extractFaceIndexFromLeaf;
     }
 
     /**
-     * @returns {Promise}
+     *
+     * @return {number[]}
      */
-    promiseBuilt() {
-
+    get transform() {
+        return this.mesh.matrixWorld.elements;
     }
 
     /**
      *
-     * @param {number} x
-     * @param {number} y
-     * @param {function} callback
-     * @param {function} missCallback
+     * @param {number[]|Float32Array|mat4} m4
      */
-    raycastVertical(x, y, callback, missCallback) {
-        return this.raycaster.raycastVertical(x, y, callback, missCallback)
+    set transform(m4) {
+        mat4.copy(this.mesh.matrixWorld.elements, m4);
+        this.computeBoundingBox();
     }
 
     /**
@@ -188,7 +202,7 @@ class TerrainTile {
     }
 
     /**
-     *
+     * Stitch vertex normals along the edges of the tile set
      * @param {TerrainTile|undefined} top
      * @param {TerrainTile|undefined} bottom
      * @param {TerrainTile|undefined} left
@@ -254,7 +268,9 @@ class TerrainTile {
                         bottom.getVertexNormal(i, v0);
                         top.getVertexNormal(otherOffset + i, v1);
 
-                        v0.add(v1).normalize();
+                        v0.add(v1);
+                        v0.normalize();
+
                         bottom.setVertexNormal(i, v0);
                         top.setVertexNormal(otherOffset + i, v0);
                     }
@@ -316,7 +332,9 @@ class TerrainTile {
                         right.getVertexNormal(index0, v0);
                         left.getVertexNormal(index1, v1);
 
-                        v0.add(v1).normalize();
+                        v0.add(v1);
+                        v0.normalize();
+
                         right.setVertexNormal(index0, v0);
                         left.setVertexNormal(index1, v0);
                     }
@@ -361,7 +379,11 @@ class TerrainTile {
                 topRight.getVertexNormal(tCornerIndex, v2);
                 bottomLeft.getVertexNormal(lCornerIndex, v3);
 
-                v0.add(v1).add(v2).add(v3).normalize();
+                v0.add(v1);
+                v0.add(v2);
+                v0.add(v3);
+                v0.normalize();
+
                 topLeft.setVertexNormal(tlCornerIndex, v0);
                 bottomRight.setVertexNormal(cornerIndex, v0);
                 topRight.setVertexNormal(tCornerIndex, v0);
@@ -404,118 +426,78 @@ class TerrainTile {
         stitchSides();
     }
 
-    stitchNormals(top, left, topLeft) {
-        const v0 = new Vector3(),
-            v1 = new Vector3();
-        if (top !== null && left !== null && topLeft !== null) {
-
-            const v2 = new Vector3();
-            const v3 = new Vector3();
-            //fix corner
-            const tlCornerIndex = (topLeft.size.x * topLeft.resolution.getValue()) * (topLeft.size.y * topLeft.resolution.getValue()) - 1;
-            const cornerIndex = 0;
-            const tCornerIndex = top.size.x * top.resolution.getValue() * (top.size.y * top.resolution.getValue() - 1);
-            const lCornerIndex = left.size.x * left.resolution.getValue() - 1;
-
-            topLeft.getVertexNormal(tlCornerIndex, v0);
-            this.getVertexNormal(cornerIndex, v1);
-            top.getVertexNormal(tCornerIndex, v2);
-            left.getVertexNormal(lCornerIndex, v3);
-
-            v0.add(v1).add(v2).add(v3).normalize();
-            topLeft.setVertexNormal(tlCornerIndex, v0);
-            this.setVertexNormal(cornerIndex, v0);
-            top.setVertexNormal(tCornerIndex, v0);
-            left.setVertexNormal(lCornerIndex, v0);
-        }
-        let i, l;
-        let otherOffset;
-        let otherResolution;
-        const thisResolution = this.resolution.getValue();
-        if (top !== null) {
-            otherResolution = top.resolution.getValue();
-            otherOffset = top.size.x * otherResolution * (top.size.y * otherResolution - 1);
-            for (i = 0, l = this.size.x * thisResolution; i < l; i++) {
-                this.getVertexNormal(i, v0);
-                top.getVertexNormal(otherOffset + i, v1);
-
-                v0.add(v1).normalize();
-                this.setVertexNormal(i, v0);
-                top.setVertexNormal(otherOffset + i, v0);
-            }
-        }
-        if (left !== null) {
-            otherResolution = left.resolution.getValue();
-            otherOffset = left.size.x * otherResolution - 1;
-            const otherMultiplier = left.size.x * otherResolution;
-            const thisMultiplier = this.size.x * thisResolution;
-            for (i = 0, l = this.size.y * thisResolution; i < l; i++) {
-
-                const index0 = i * thisMultiplier;
-                const index1 = otherOffset + i * otherMultiplier;
-
-                this.getVertexNormal(index0, v0);
-                left.getVertexNormal(index1, v1);
-
-                v0.add(v1).normalize();
-                this.setVertexNormal(index0, v0);
-                left.setVertexNormal(index1, v0);
-            }
-        }
-    }
-
     computeBoundingBox() {
+        /**
+         * @type {ThreeBox3}
+         */
+        let bb;
+
         const geometry = this.geometry;
-        //check for bvh
-        const bvh = this.bvh;
-        if (bvh !== null) {
-            geometry.boundingBox = new ThreeBox3(new ThreeVector3(bvh.x0, bvh.y0, bvh.z0), new ThreeVector3(bvh.x1, bvh.y1, bvh.z1));
 
-            const dX = bvh.x1 - bvh.x0;
-            const dY = bvh.y1 - bvh.y0;
-            const dZ = bvh.z1 - bvh.z0;
+        if (geometry === null) {
+            // no geometry present yet
 
-            const radius = Math.sqrt(dX * dX + dY * dY + dZ * dZ) / 2;
+            const position = this.position;
+            const scale = this.scale;
+            const size = this.size;
 
-            const center = new ThreeVector3(bvh.x0 + dX / 2, bvh.y0 + dY / 2, bvh.z0 + dZ / 2);
+            const initial_height_range = this.__initial_height_range;
 
-            geometry.boundingSphere = new ThreeSphere(center, radius);
-        }
-        //pull bounding box from geometry
-        let bb = geometry.boundingBox;
-        if (bb === null) {
-            geometry.computeBoundingBox();
-            bb = geometry.boundingBox;
-        }
-        this.boundingBox.setBounds(bb.min.x, bb.min.y, bb.min.z, bb.max.x, bb.max.y, bb.max.z);
-    }
+            const min = new ThreeVector3(position.x * scale.x, initial_height_range.min, position.y * scale.y);
+            const max = new ThreeVector3(min.x + size.x * scale.x, initial_height_range.max, min.z + size.y * scale.y);
 
-    generateBufferedGeometryBVH() {
-        const geometry = this.geometry;
-        // console.profile('build bvh');
-        this.bvh = BVHFromBufferGeometry.buildUnsortedBinaryBVH(geometry);
-        // console.profileEnd('build bvh');
-    }
+            bb = new ThreeBox3(
+                min,
+                max
+            );
 
-    unload() {
-        this.isBuilt = false;
+        } else {
 
-        this.geometry = null;
-        this.bvh = null;
+            //check for bvh
+            const bvh = this.bvh;
+            if (bvh !== null) {
+                geometry.boundingBox = new ThreeBox3(new ThreeVector3(bvh.x0, bvh.y0, bvh.z0), new ThreeVector3(bvh.x1, bvh.y1, bvh.z1));
+
+                const dX = bvh.x1 - bvh.x0;
+                const dY = bvh.y1 - bvh.y0;
+                const dZ = bvh.z1 - bvh.z0;
+
+                const radius = Math.sqrt(dX * dX + dY * dY + dZ * dZ) / 2;
+
+                const center = new ThreeVector3(bvh.x0 + dX / 2, bvh.y0 + dY / 2, bvh.z0 + dZ / 2);
+
+                geometry.boundingSphere = new ThreeSphere(center, radius);
+            }
+            //pull bounding box from geometry
 
-        const stitching = this.stitching;
+            bb = geometry.boundingBox;
+            if (bb === null) {
+                geometry.computeBoundingBox();
+                bb = geometry.boundingBox;
+            }
+        }
 
-        stitching.top = false;
-        stitching.bottom = false;
+        const x0 = bb.min.x;
+        const y0 = bb.min.y;
+        const z0 = bb.min.z;
 
-        stitching.left = false;
-        stitching.right = false;
+        const x1 = bb.max.x;
+        const y1 = bb.max.y;
+        const z1 = bb.max.z;
+
+        const geometry_bb = new AABB3(
+            x0, y0, z0,
+            x1, y1, z1
+        );
 
-        stitching.topLeft = false;
-        stitching.topRight = false;
+        geometry_bb.applyMatrix4(this.transform);
 
-        stitching.bottomLeft = false;
-        stitching.bottomRight = false;
+        this.boundingBox.setBounds(
+            geometry_bb.x0, geometry_bb.y0, geometry_bb.z0,
+            geometry_bb.x1, geometry_bb.y1, geometry_bb.z1
+        );
+        // update changes up the tree
+        this.boundingBox.bubbleRefit();
     }
 
     /**
@@ -523,23 +505,17 @@ class TerrainTile {
      * @param {number} min_height
      * @param {number} max_height
      */
-    createInitialBounds(min_height, max_height) {
-        const offset = this.position.clone().multiply(this.scale);
-
-        const size = this.size.clone().multiply(this.scale);
-
-        const max = offset.clone().add(size);
-
-        this.boundingBox.setBounds(
-            offset.x, min_height, offset.y,
-            max.x, max_height, max.y
-        );
+    setInitialHeightBounds(min_height, max_height) {
+        this.__initial_height_range.set(min_height, max_height);
     }
 
     dispose() {
         if (this.geometry !== null) {
             this.geometry.dispose();
+            this.geometry = null;
         }
+
+        this.isBuilt = false;
     }
 
     build(tileData) {
@@ -549,7 +525,9 @@ class TerrainTile {
         const tileDataGeometry = tileData.geometry;
 
         const g = new ThreeBufferGeometry();
+
         g.setIndex(new ThreeBufferAttribute(tileDataGeometry.indices, 1));
+
         g.setAttribute('position', new ThreeBufferAttribute(tileDataGeometry.vertices, 3));
         g.setAttribute('normal', new ThreeBufferAttribute(tileDataGeometry.normals, 3));
         g.setAttribute('uv', new ThreeBufferAttribute(tileDataGeometry.uvs, 2));
@@ -571,11 +549,6 @@ class TerrainTile {
         }
 
 
-        //set bounding box
-        // console.time('bb');
-        this.computeBoundingBox();
-        // console.timeEnd('bb');
-
         const mesh = this.mesh;
 
         mesh.geometry = g;
@@ -583,6 +556,11 @@ class TerrainTile {
         mesh.receiveShadow = true;
         mesh.castShadow = true;
 
+        //set bounding box
+        // console.time('bb');
+        this.computeBoundingBox();
+        // console.timeEnd('bb');
+
         // console.timeEnd('total');
         // console.groupEnd();
 

package/engine/ecs/terrain/tiles/TerrainTileManager.js

@@ -15,7 +15,6 @@ import { MeshPhongMaterial } from 'three';
 import { assert } from "../../../../core/assert.js";
 import { Color } from "../../../../core/color/Color.js";
 import { noop } from "../../../../core/function/Functions.js";
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { RaycastBVHVisitor } from "../../../../core/bvh2/traversal/RaycastBVHVisitor.js";
 import { FirstRayIntersectionTerrainBVHVisitor } from "./FirstRayIntersectionTerrainBVHVisitor.js";
@@ -24,6 +23,8 @@ import { aabb2_overlapExists } from "../../../../core/geom/AABB2.js";
 import ObservedInteger from "../../../../core/model/ObservedInteger.js";
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
 import { randomFloatBetween } from "../../../../core/math/random/randomFloatBetween.js";
+import { mat4, vec3 } from "gl-matrix";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 
 class TerrainTileManager {
     /**
@@ -105,7 +106,30 @@ class TerrainTileManager {
             this.traverse(this.assignTileMaterial, this);
         });
 
+        /**
+         *
+         * @type {Float32Array}
+         * @private
+         */
+        this.__transform = new Float32Array(16);
+
+    }
+
+    set transform(m4) {
+        if (isArrayEqualStrict(m4, this.__transform)) {
+            // no change
+            return;
+        }
+
+        mat4.copy(this.__transform, m4);
+
+        this.traverse(t => {
+            t.transform = m4;
+        });
+    }
 
+    get transform() {
+        return this.__transform;
     }
 
     /**
@@ -156,74 +180,6 @@ class TerrainTileManager {
         this.initializeTiles();
     }
 
-    /**
-     *
-     * @param {Vector3} origin
-     * @param {Vector3} direction
-     * @param {function} callback
-     * @param {function} missCallback
-     */
-    raycast(origin, direction, callback, missCallback) {
-        assert.typeOf(callback, 'function', 'callback');
-        assert.typeOf(missCallback, 'function', 'missCallback');
-
-        let bestHit = null;
-        let bestNormal = null;
-        let bestGeometry = null;
-        let bestDistanceSqr = Number.POSITIVE_INFINITY;
-
-        let firstStageOver = false;
-
-        let tileCount = 0;
-
-        function tryReturn() {
-            if (tileCount === 0 && firstStageOver) {
-                callback(bestHit, bestNormal, bestGeometry);
-            }
-        }
-
-        function registerHit(hit, normal, geo) {
-            const d = hit.distanceSqrTo(origin);
-            if (d < bestDistanceSqr) {
-                bestDistanceSqr = d;
-                bestHit = hit;
-                bestNormal = normal;
-                bestGeometry = geo;
-            }
-        }
-
-
-        /**
-         *
-         * @param {TerrainTile} tile
-         */
-        function doCast(tile) {
-
-            tile.raycast(origin, direction, registerHit, missCallback);
-            tileCount--;
-            tryReturn();
-        }
-
-        this.bvh.traverseRayLeafIntersections(origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, function (leaf) {
-            /**
-             *
-             * @type {TerrainTile}
-             */
-            const tile = leaf.object;
-
-            tileCount++;
-
-            if (tile.isBuilt) {
-                doCast(tile);
-            } else {
-                tile.onBuilt.addOne(doCast);
-            }
-        });
-
-        firstStageOver = true;
-        tryReturn();
-    }
-
     /**
      *
      * @param {TerrainTile} tile
@@ -378,7 +334,8 @@ class TerrainTileManager {
                 tile.scale.copy(this.scale);
                 tile.resolution.copy(this.resolution);
 
-                tile.createInitialBounds(this.heightRange.min, this.heightRange.max);
+                tile.setInitialHeightBounds(this.heightRange.min, this.heightRange.max);
+                tile.computeBoundingBox();
 
                 //hook for building
                 tile.ensureBuilt = ensureBuilt(x, y);
@@ -397,11 +354,8 @@ class TerrainTileManager {
      * @returns {number}
      */
     computeTileIndex(x, y) {
-        assert.ok(Number.isInteger(x), `x must be an integer, instead was ${x}`);
-        assert.ok(Number.isInteger(y), `x must be an integer, instead was ${y}`);
-
-        assert.ok(x >= 0, `x(=${x}) must be greater or equal to 0`);
-        assert.ok(y >= 0, `y(=${y}) must be greater or equal to 0`);
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
 
         const w = Math.ceil(this.totalSize.x / this.tileSize.x);
 
@@ -415,9 +369,16 @@ class TerrainTileManager {
      *
      * @param {number} x
      * @param {number} y
-     * @returns {TerrainTile}
+     * @returns {TerrainTile|undefined}
      */
     getRaw(x, y) {
+        if (
+            x < 0
+            || x >= Math.ceil(this.totalSize.x / this.tileSize.x)
+            || y < 0
+        ) {
+            return undefined;
+        }
 
         const tileIndex = this.computeTileIndex(x, y);
 
@@ -442,6 +403,43 @@ class TerrainTileManager {
         return this.getRaw(tileX, tileY);
     }
 
+    /**
+     * Given world coordinates in top-down plane, where X runs along X axis and Y runs along Z axis, returns terrain tile that overlaps that 2d region
+     * @param {number} x
+     * @param {number} y
+     * @return {TerrainTile|undefined}
+     */
+    getTileByWorldPosition2D(x, y) {
+        const v3 = vec3.fromValues(x, 0, y);
+
+        const world_inverse = mat4.create();
+
+        mat4.invert(world_inverse, this.transform);
+
+
+        vec3.transformMat4(v3, v3, world_inverse);
+
+        return this.getRawTileByPosition(v3.x, v3.z);
+    }
+
+    /**
+     * Builds and returns the tile from world coordinates
+     * @param {number} x
+     * @param {number} y
+     * @returns {Promise<TerrainTile>}
+     */
+    obtainTileAtWorldPosition2D(x, y) {
+        const tile = this.getTileByWorldPosition2D(x, y);
+
+        return this.obtain(tile.gridPosition.x, tile.gridPosition.y);
+    }
+
+    /**
+     * @deprecated use {@link #obtain instead}
+     * @param {number} x
+     * @param {number} y
+     * @param {function(TerrainTile):*} callback
+     */
     processTile(x, y, callback) {
         const tile = this.getRaw(x, y);
 
@@ -454,9 +452,10 @@ class TerrainTileManager {
 
     /**
      *
-     * @param {int} x
-     * @param {int} y
-     * @returns {Promise}
+     * @param {number} x coordinate
+     * @param {number} y coordinate
+     * @returns {Promise<TerrainTile>}
+     * @throws if no tile exists at given coordinates
      */
     obtain(x, y) {
         const tile = this.getRaw(x, y);
@@ -490,6 +489,10 @@ class TerrainTileManager {
      * @param {TerrainTile} tile
      */
     release(tile) {
+        if (tile.referenceCount <= 0) {
+            console.warn('Tile already has no references');
+        }
+
         tile.referenceCount--;
 
         if (tile.referenceCount <= 0) {
@@ -497,7 +500,7 @@ class TerrainTileManager {
             tile.dispose();
         }
 
-
+        // TODO check tile.isBuilt flag
         tile.onDestroyed.send1(tile);
     }
 
@@ -512,9 +515,17 @@ class TerrainTileManager {
         }
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {TerrainTile} tile
+     */
     stitchTile(x, y, tile) {
 
-        const gridSize = this.totalSize.clone().divide(this.tileSize).floor();
+        const gridSize = this.totalSize.clone();
+        gridSize.divide(this.tileSize);
+        gridSize.floor();
 
         const self = this;
         //normal stitching
@@ -569,6 +580,7 @@ class TerrainTileManager {
         directionZ
     ) {
 
+        // console.log('+ raycastFirstSync');
         raycastBVHVisitor.collector = firstRayIntersectionTerrainBVHVisitor;
         raycastBVHVisitor.setOrigin(originX, originY, originZ);
         raycastBVHVisitor.setDirection(directionX, directionY, directionZ);
@@ -579,6 +591,8 @@ class TerrainTileManager {
 
         traverseBinaryNodeUsingVisitor(this.bvh, raycastBVHVisitor);
 
+        // console.log('- raycastFirstSync');
+
         if (firstRayIntersectionTerrainBVHVisitor.closestDistance !== Number.POSITIVE_INFINITY) {
             result.copy(firstRayIntersectionTerrainBVHVisitor.closest);
 
@@ -588,41 +602,6 @@ class TerrainTileManager {
         return false;
     }
 
-    raycastVertical(x, y, successCallback, missCallback) {
-        assert.typeOf(missCallback, 'function', 'missCallback');
-
-        /**
-         *
-         * @param {TerrainTile} tile
-         */
-        function doCast(tile) {
-            tile.raycastVertical(x, y, successCallback, missCallback);
-        }
-
-
-        let miss = true;
-
-        this.bvh.traverseRayLeafIntersections(x, -10000, y, 0, 1, 0, function (leaf) {
-            /**
-             *
-             * @type {TerrainTile}
-             */
-            const tile = leaf.object;
-
-            miss = false;
-
-            if (tile.isBuilt) {
-                doCast(tile);
-            } else {
-                tile.onBuilt.addOne(doCast);
-            }
-        });
-
-        if (miss) {
-            missCallback();
-        }
-    }
-
     /**
      * TODO untested
      * @param {SurfacePoint3} contact
@@ -631,7 +610,10 @@ class TerrainTileManager {
      * @return {boolean}
      */
     raycastVerticalFirstSync(contact, x, y) {
-        return this.raycastFirstSync(contact, x, -10000, y, 0, 1, 0);
+        // console.log('+ raycastVerticalFirstSync');
+        const r = this.raycastFirstSync(contact, x, -10000, y, 0, 1, 0);
+        // console.log('- raycastVerticalFirstSync');
+        return r;
     }
 
     /**
@@ -697,14 +679,11 @@ class TerrainTileManager {
 
             // console.timeEnd(processName);
 
-            self.on.tileBuilt.dispatch(tile);
+            self.on.tileBuilt.send1(tile);
         }, reject);
     }
 }
 
-const v3_origin = new Vector3();
-const v3_direction = new Vector3();
-
 const raycastBVHVisitor = new RaycastBVHVisitor();
 const firstRayIntersectionTerrainBVHVisitor = new FirstRayIntersectionTerrainBVHVisitor();