@woosh/meep-engine 2.64.0 → 2.66.0

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

@@ -3,6 +3,7 @@
  */
 
 
+import { mat4 } from "gl-matrix";
 import {
     ClampToEdgeWrapping,
     DataTexture,
@@ -12,82 +13,105 @@ import {
     RedFormat,
     UnsignedByteType
 } from 'three';
+import { assert } from "../../../../core/assert.js";
+import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
+import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import Vector2 from '../../../../core/geom/Vector2.js';
 import { clamp } from "../../../../core/math/clamp.js";
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import { SplatMaterial } from "../../../graphics/material/SplatMaterial.js";
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
-import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
-import Vector2 from '../../../../core/geom/Vector2.js';
+import { WHITE_PIXEL_DATA_URL } from "../../../graphics/WHITE_PIXEL_DATA_URL.js";
 import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
 
 import Clouds from '../TerrainClouds.js';
+import { TerrainPreview } from "../TerrainPreview.js";
 
 import TerrainTileManager from '../tiles/TerrainTileManager.js';
-import { TerrainPreview } from "../TerrainPreview.js";
-import { assert } from "../../../../core/assert.js";
-import { GameAssetType } from "../../../asset/GameAssetType.js";
-import { TerrainLayers } from "./layers/TerrainLayers.js";
-import { SplatMaterial } from "../../../graphics/material/SplatMaterial.js";
-import { SplatMapping } from "./splat/SplatMapping.js";
-import { OffsetScaleTransform2D } from "./OffsetScaleTransform2D.js";
+import { buildLightTexture } from "./BuildLightTexture.js";
 import { GridTransformKind } from "./GridTransformKind.js";
+import { TerrainLayers } from "./layers/TerrainLayers.js";
 import { makeTerrainWorkerProxy } from "./makeTerrainWorkerProxy.js";
+import { OffsetScaleTransform2D } from "./OffsetScaleTransform2D.js";
+import { SplatMapping } from "./splat/SplatMapping.js";
 import { TerrainFlags } from "./TerrainFlags.js";
-import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
-import { buildLightTexture } from "./BuildLightTexture.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;
 
 class Terrain {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.id = idCounter++;
+    /**
+     *
+     * @type {number}
+     */
+    id = idCounter++;
 
-        /**
-         * @private
-         * @type {number|TerrainFlags}
-         */
-        this.flags = 0;
+    /**
+     * @private
+     * @type {number|TerrainFlags}
+     */
+    flags = 0;
 
-        /**
-         *
-         * @type {number}
-         */
-        this.gridScale = 1;
+    /**
+     *
+     * @type {number}
+     */
+    gridScale = 1;
 
-        /**
-         * Transform from grid coordinate system to world coordinate system
-         * @type {OffsetScaleTransform2D}
-         */
-        this.gridTransform = new OffsetScaleTransform2D();
+    /**
+     * Transform from grid coordinate system to world coordinate system
+     * @type {OffsetScaleTransform2D}
+     */
+    gridTransform = new OffsetScaleTransform2D();
 
-        /**
-         *
-         * @type {number}
-         */
-        this.gridTransformKind = GridTransformKind.Direct;
+    /**
+     *
+     * @type {number}
+     */
+    gridTransformKind = GridTransformKind.Direct;
 
-        /**
-         * Number of geometric subdivisions per single terrain tile
-         * @example if value is set to 4, each tile will be split into 4x4 quads
-         * @type {number}
-         */
-        this.resolution = 4;
+    /**
+     * Number of geometric subdivisions per single terrain tile
+     * @example if value is set to 4, each tile will be split into 4x4 quads
+     * @type {number}
+     */
+    resolution = 4;
 
-        /**
-         *
-         * @type {Vector2}
-         */
-        this.size = new Vector2(0, 0);
-        /**
-         *
-         * @type {TerrainPreview}
-         */
-        this.preview = new TerrainPreview();
+    /**
+     * @readonly
+     * @type {Vector2}
+     */
+    size = new Vector2(0, 0);
+    /**
+     *
+     * @type {TerrainPreview}
+     */
+    preview = new TerrainPreview();
+    /**
+     * @readonly
+     * @type {SplatMapping}
+     */
+    splat = new SplatMapping();
+
+    /**
+     * @readonly
+     * @type {TerrainLayers}
+     */
+    layers = new TerrainLayers();
+
+    /**
+     * @readonly
+     * @type {WorkerProxy}
+     */
+    __buildWorker = makeTerrainWorkerProxy();
+
+    /**
+     * @readonly
+     * @type {BvhClient}
+     */
+    bvh = new BvhClient();
+
+    constructor() {
 
         /**
          *
@@ -96,23 +120,12 @@ class Terrain {
         this.clouds = new Clouds();
         this.clouds.enabled = true;
 
-        /**
-         * @deprecated
-         * @type {String}
-         */
-        this.heightMapURL = null;
-
         /**
          * @deprecated
          * @type {number}
          */
         this.heightRange = 0;
 
-        /**
-         *
-         * @type {SplatMapping}
-         */
-        this.splat = new SplatMapping();
 
         /**
          *
@@ -139,12 +152,6 @@ class Terrain {
         this.heightTexture.internalFormat = 'R32F';
 
 
-        /**
-         *
-         * @type {TerrainLayers}
-         */
-        this.layers = new TerrainLayers();
-
         /**
          * @type {ShaderMaterial}
          */
@@ -170,18 +177,6 @@ class Terrain {
          */
         this.overlay = new TerrainOverlay(this.size);
 
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        this.bvh = new BinaryNode();
-
-        /**
-         *
-         * @type {WorkerProxy}
-         */
-        this.__buildWorker = makeTerrainWorkerProxy();
-
         /**
          *
          * @type {TerrainTileManager}
@@ -332,6 +327,8 @@ class Terrain {
 
         this.heightTexture.dispose();
 
+        this.bvh.unlink();
+
         this.clearFlag(TerrainFlags.Linked);
     }
 
@@ -769,8 +766,7 @@ class Terrain {
 
         this.buildGridTransform();
 
-        this.bvh.reset();
-        this.bvh.setNegativelyInfiniteBounds();
+        this.bvh.resize(0, 0, 0, 0, 0, 0);
 
         //
         this.overlay.size.copy(this.size);

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

@@ -1,13 +1,17 @@
-import { System } from '../../System.js';
-import Terrain from './Terrain.js';
-import { CameraSystem } from '../../../graphics/ecs/camera/CameraSystem.js';
 import { assert } from "../../../../core/assert.js";
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import {
+    bvh_query_user_data_overlaps_frustum
+} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 import { noop } from "../../../../core/function/Functions.js";
-import { TerrainFlags } from "./TerrainFlags.js";
+import { read_frustum_planes_to_array } from "../../../../core/geom/3d/frustum/read_frustum_planes_to_array.js";
+import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
+import { CameraSystem } from '../../../graphics/ecs/camera/CameraSystem.js';
+import { System } from '../../System.js';
 import { Transform } from "../../transform/Transform.js";
-import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
-import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
+import Terrain from './Terrain.js';
+import { TerrainFlags } from "./TerrainFlags.js";
 
 /**
  *
@@ -24,6 +28,30 @@ function ensureTileBuilt(tile, tileManager) {
 }
 
 class TerrainSystem extends System {
+    dependencies = [Terrain];
+
+    gridScaleX = 1;
+    gridScaleY = 1;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __time_delta = 0;
+
+    /**
+     *
+     * @type {RenderLayer|null}
+     */
+    renderLayer = null;
+
+    /**
+     *
+     * @type {BVH}
+     */
+    bvh = new BVH();
+
     /**
      *
      * @param {GraphicsEngine} graphics
@@ -44,30 +72,7 @@ class TerrainSystem extends System {
 
         this.graphics = graphics;
 
-        this.dependencies = [Terrain];
         this.assetManager = assetManager;
-
-        this.gridScaleX = 1;
-        this.gridScaleY = 1;
-
-        /**
-         *
-         * @type {RenderLayer|null}
-         */
-        this.renderLayer = null;
-
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        this.bvh = null;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__time_delta = 0;
     }
 
     mapPointGrid2World(x, y, v3) {
@@ -83,18 +88,51 @@ class TerrainSystem extends System {
 
         this.renderLayer = this.graphics.layers.create('terrain-system');
 
-        /**
-         *
-         * @param {TerrainTile} tile
-         * @returns {THREE.Object3D}
-         */
-        function extractRenderable(tile) {
-            return tile.mesh;
-        }
 
-        this.renderLayer.extractRenderable = extractRenderable;
+        this.renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
+            const em = this.entityManager;
+
+            if (em === null) {
+                return 0;
+            }
+
+            const ecd = em.dataset;
+
+            if (ecd === null) {
+                return 0;
+            }
+
+            const tiles = [];
+
+            let match_count = 0;
 
-        this.bvh = this.renderLayer.bvh;
+            ecd.traverseComponents(Terrain, (component, entity) => {
+                const tile_manager = component.tiles;
+
+                const hit_count = bvh_query_user_data_overlaps_frustum(
+                    tiles, 0,
+                    tile_manager.bvh, view.frustum
+                );
+
+                for (let i = 0; i < hit_count; i++) {
+
+                    const tile_index = tiles[i];
+
+                    const tile = tile_manager.tiles[tile_index];
+
+                    if (!tile.isBuilt) {
+                        continue;
+                    }
+
+                    destination[destination_offset + match_count] = tile.mesh;
+
+                    match_count++;
+                }
+
+            });
+
+            return match_count;
+        };
 
         const am = this.assetManager;
 
@@ -133,14 +171,7 @@ class TerrainSystem extends System {
 
         component.link(this.graphics);
 
-        const bvh = component.__tiles.bvh;
-
-
-        //record entity for editor
-        bvh.entity = entity;
-
-        //set render layer BVH to one maintained by TilesEngine
-        this.renderLayer.bvh = bvh;
+        component.bvh.link(this.bvh, entity);
     }
 
     /**
@@ -149,12 +180,6 @@ class TerrainSystem extends System {
      * @param entity
      */
     unlink(component, entity) {
-
-        if (this.renderLayer.bvh === component.__tiles.bvh) {
-            // remove from render index
-            this.renderLayer.bvh = new BinaryNode();
-        }
-
         component.unlink();
     }
 
@@ -217,12 +242,36 @@ class TerrainSystem extends System {
         assert.notEqual(terrain, undefined, 'terrain is undefined');
 
         const tileManager = terrain.__tiles;
+
+        const tiles = [];
+        const set = new Set();
+        let tile_count = 0;
+
+        const frustum = new Float32Array(24);
+
         if (tileManager !== undefined) {
             CameraSystem.getActiveFrustums(ecd, function (frustums) {
-                tileManager.bvh.threeTraverseFrustumsIntersections(frustums, function (leafNode) {
-                    const tile = leafNode.object;
-                    callback(tile, tileManager);
-                });
+                let found_tiles = 0;
+
+                for (let i = 0; i < frustums.length; i++) {
+
+                    read_frustum_planes_to_array(frustums[i].planes, frustum);
+
+                    found_tiles += bvh_query_user_data_overlaps_frustum(tiles, tile_count, tileManager.bvh, frustum);
+                }
+
+                for (let i = 0; i < found_tiles; i++) {
+                    const tile_index = tiles[i];
+
+                    if (!set.has(tile_index)) {
+                        const tile = tileManager.tiles[tile_index];
+
+                        callback(tile, tileManager);
+                    }
+
+                    set.add(tile_index);
+                }
+
             });
         }
     }

package/src/engine/ecs/terrain/ecs/makeTerrainWorkerProxy.js

@@ -64,12 +64,15 @@ export function makeTerrainWorkerProxy() {
 
                     // var timerName = 'building bvh '+(geometry.indices.length/3);
                     // console.time(timerName);
-                    const bvh = Lib.BinaryBVHFromBufferGeometry.buildUnsorted(geometry.vertices, geometry.indices);
+                    const bvh = Lib.build_bvh(geometry.vertices, geometry.indices);
                     // console.timeEnd(timerName);
 
                     resolve({
                         geometry: geometry,
-                        bvh: bvh
+                        bvh: {
+                            leaf_count: bvh.getLeafNodeCount(),
+                            data: bvh.data
+                        }
                     });
                 } catch (e) {
                     reject(e);