@woosh/meep-engine 2.39.42 → 2.40.0

package/engine/ecs/terrain/ecs/Terrain.js

@@ -37,6 +37,8 @@ import { buildLightTexture } from "./BuildLightTexture.js";
 import { promiseSamplerHeight } from "./PromiseSamplerHeight.js";
 import { loadLegacyTerrainSplats } from "./splat/loadLegacyTerrainSplats.js";
 import { WHITE_PIXEL_DATA_URL } from "../../../graphics/WHITE_PIXEL_DATA_URL.js";
+import { mat4 } from "gl-matrix";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 
 let idCounter = 0;
 
@@ -157,6 +159,13 @@ class Terrain {
          */
         this.frustumCulled = true;
 
+        /**
+         * 4x4 transform matrix
+         * @private
+         * @type {Float32Array}
+         */
+        this.__transform_matrix = mat4.create();
+
 
         /**
          *
@@ -176,6 +185,11 @@ class Terrain {
          */
         this.__buildWorker = makeTerrainWorkerProxy();
 
+        /**
+         *
+         * @type {TerrainTileManager}
+         * @private
+         */
         this.__tiles = new TerrainTileManager({
             material: this.material,
             buildWorker: this.__buildWorker
@@ -393,26 +407,17 @@ class Terrain {
      * @param {function} errorCallback
      */
     sampleHeight(x, y, callback, missCallback, errorCallback) {
-        assert.typeOf(callback, 'function', 'callback');
-        assert.typeOf(missCallback, 'function', 'missCallback');
-        assert.typeOf(errorCallback, 'function', 'errorCallback');
+        assert.isFunction(callback, 'callback');
+        assert.isFunction(missCallback, 'missCallback');
+        assert.isFunction(errorCallback, 'errorCallback');
 
-        let processed = false;
+        const hit = new SurfacePoint3();
 
-        /**
-         *
-         * @param {Vector3} hit
-         * @param face
-         * @param geometry
-         */
-        function processHit(hit, face, geometry) {
-            if (!processed) {
-                processed = true;
-                callback(hit.y);
-            }
+        if (this.raycastVerticalFirstSync(hit, x, y)) {
+            callback(hit.position.y);
+        } else {
+            missCallback();
         }
-
-        this.raycastVertical(x, y, processHit, missCallback, errorCallback);
     }
 
     /**
@@ -426,27 +431,27 @@ class Terrain {
      * @param {number} directionZ
      * @returns {boolean}
      */
-    raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ) {
-        if (this.__tiles === undefined) {
-            return false;
-        }
-
+    raycastFirstSync(
+        result,
+        originX, originY, originZ,
+        directionX, directionY, directionZ
+    ) {
         return this.__tiles.raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ);
     }
 
     /**
-     *
+     * @deprecated
      * @param {Vector3} origin
      * @param {Vector3} direction
      * @param {function(hit:Vector3, normal:Vector3, geometry:BufferGeometry)} callback
      * @param {function} missCallback
      */
     raycast(origin, direction, callback, missCallback) {
-        this.__tiles.raycast(origin, direction, callback, missCallback);
+        throw new Error('Deprecated, use raycastFirstSync instead');
     }
 
     /**
-     *
+     * @deprecated
      * @param {number} x
      * @param {number} y
      * @param {function} callback
@@ -454,11 +459,7 @@ class Terrain {
      * @param {function} errorCallback
      */
     raycastVertical(x, y, callback, missCallback, errorCallback) {
-        assert.typeOf(callback, 'function', 'callback');
-        assert.typeOf(missCallback, 'function', 'missCallback');
-        assert.typeOf(errorCallback, 'function', 'errorCallback');
-
-        this.__tiles.raycastVertical(x, y, callback, missCallback);
+        throw new Error('Deprecated, use raycastVerticalFirstSync instead');
     }
 
     /**
@@ -469,12 +470,7 @@ class Terrain {
      * @return {boolean}
      */
     raycastVerticalFirstSync(contact, x, y) {
-        if (this.__tiles === undefined) {
-            //tiles don't exist
-            return false;
-        }
-
-        return this.__tiles.raycastVerticalFirstSync(contact, x, y);
+           return this.__tiles.raycastVerticalFirstSync(contact, x, y);
     }
 
     /**
@@ -649,6 +645,24 @@ class Terrain {
         m.uniformsNeedUpdate = true;
     }
 
+    /**
+     *
+     * @param {mat4|Float32Array|number[]} m4
+     */
+    set transform(m4) {
+        mat4.copy(this.__transform_matrix, m4);
+
+        this.__tiles.transform = m4;
+    }
+
+    /**
+     *
+     * @return {Float32Array}
+     */
+    get transform() {
+        return this.__transform_matrix;
+    }
+
     /**
      *
      * @param {TerrainLayer} layer
@@ -846,6 +860,14 @@ class Terrain {
         this.setFlag(TerrainFlags.Built);
     }
 
+    /**
+     * Note: For advanced users only. You can seriously mess up how things look and function with respect to terrain here
+     * @return {TerrainTileManager}
+     */
+    get tiles() {
+        return this.__tiles;
+    }
+
     /**
      *
      * @returns {Texture|null}

package/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -5,6 +5,8 @@ import { assert } from "../../../../core/assert.js";
 import { noop } from "../../../../core/function/Functions.js";
 import { TerrainFlags } from "./TerrainFlags.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
+import { Transform } from "../../transform/Transform.js";
+import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
 
 /**
  *
@@ -157,9 +159,12 @@ class TerrainSystem extends System {
         this.__time_delta = timeDelta;
 
 
-        if (dataset !== null) {
-            dataset.traverseComponents(Terrain, this.__visitTerrainComponent, this);
+        if (dataset === null) {
+            return;
         }
+
+
+        dataset.traverseComponents(Terrain, this.__visitTerrainComponent, this);
     }
 
     /**
@@ -171,13 +176,26 @@ class TerrainSystem extends System {
     __visitTerrainComponent(terrain, entity) {
         const em = this.entityManager;
 
-        const dataset = em.dataset;
+        const ecd = em.dataset;
+
+        /**
+         *
+         * @type {Transform|undefined}
+         */
+        const transform = ecd.getComponent(entity, Transform);
+
+        if (transform !== undefined) {
+            // terrain has a transform
+            terrain.transform = transform.matrix;
+        }else{
+            terrain.transform = MATRIX_4_IDENTITY;
+        }
 
         terrain.update(this.__time_delta);
 
         //do frustum culling
         if (terrain.frustumCulled) {
-            TerrainSystem.traverseVisibleTiles(dataset, terrain, ensureTileBuilt);
+            TerrainSystem.traverseVisibleTiles(ecd, terrain, ensureTileBuilt);
         }
     }
 

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,76 @@ 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
+        );
     }
 
     /**
@@ -523,23 +503,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 +523,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 +547,6 @@ class TerrainTile {
         }
 
 
-        //set bounding box
-        // console.time('bb');
-        this.computeBoundingBox();
-        // console.timeEnd('bb');
-
         const mesh = this.mesh;
 
         mesh.geometry = g;
@@ -583,6 +554,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();