@woosh/meep-engine 2.65.0 → 2.67.0

package/src/engine/graphics/ecs/water/WaterSystem.js

@@ -1,21 +1,42 @@
 /**
  * Created by Alex on 17/02/2017.
  */
-import { BackSide, Plane, PlaneBufferGeometry, Vector3 as ThreeVector3 } from 'three';
+import { BackSide, PlaneBufferGeometry } from 'three';
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { System } from '../../../ecs/System.js';
-import Water from './Water.js';
-import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
-import { buildPlanarRenderLayerClipPlaneComputationMethod } from "../../render/layers/RenderLayerUtils.js";
+import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
+import { make_bvh_visibility_builder } from "../../render/make_bvh_visibility_builder.js";
+import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
 import ThreeFactory from "../../three/ThreeFactory.js";
-import { RenderPassType } from "../../render/RenderPassType.js";
 import { makeAlexWaterMaterial } from "../water2/shader/AlexWaterShader.js";
-import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
-import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
-import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
-
-const WATER_SIZE = 800;
+import Water from './Water.js';
+import { WATER_SIZE } from "./WATER_SIZE.js";
 
 class WaterSystem extends System {
+    dependencies = [Water];
+
+    /**
+     * @readonly
+     * @type {BVH}
+     */
+    bvh = new BVH();
+
+
+    cleaup = [];
+
+    /**
+     *
+     * @type {Water[]}
+     */
+    updateQueue = [];
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __time_delta = 0;
+
     /**
      *
      * @param {GraphicsEngine} graphics
@@ -24,7 +45,6 @@ class WaterSystem extends System {
     constructor(graphics) {
         super();
 
-        this.dependencies = [Water];
 
         this.graphicsEngine = graphics;
 
@@ -34,29 +54,6 @@ class WaterSystem extends System {
          */
         this.renderLayer = null;
 
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        this.bvh = null;
-
-        //TODO override "computeFrustumClippingPlanes", this is a hack to get camera system to work as indeded when computing clipping planes
-        //TODO come up with a less convoluted design
-
-        this.cleaup = [];
-
-        /**
-         *
-         * @type {Water[]}
-         */
-        this.updateQueue = [];
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__time_delta = 0;
     }
 
 
@@ -81,43 +78,21 @@ class WaterSystem extends System {
 
         const viewport_size = graphicsEngine.viewport.size;
 
-        this.renderLayer.extractRenderable = function (component) {
-            return component.__threeObject;
-        };
+        this.renderLayer.buildVisibleSet = make_bvh_visibility_builder(
+            this.entityManager, this.bvh,
+            (destination, offset, entity, ecd) => {
+                const component = ecd.getComponent(entity, Water);
 
-        this.renderLayer.renderPass = RenderPassType.Transparent;
+                const mesh = component.__threeObject;
 
-        /**
-         *
-         * @param {Frustum} frustum
-         * @param {function(near:number, far:number)} visitor
-         */
-        this.renderLayer.computeNearFarClippingPlanes = buildPlanarRenderLayerClipPlaneComputationMethod(function (visitor) {
+                if (mesh === null) {
+                    return 0
+                }
 
-            /**
-             *
-             * @type {EntityComponentDataset}
-             */
-            const dataset = entityManager.dataset;
-
-            /**
-             *
-             * @param {Water} water
-             * @param entity
-             */
-            function componentVisitor(water, entity) {
-
-                //determinate the plane
-                const plane = new Plane(new ThreeVector3(0, 1, 0), water.level.getValue());
-
-                visitor(plane);
+                destination[offset] = mesh;
+                return 1;
             }
-
-            dataset.traverseComponents(Water, componentVisitor);
-        });
-
-
-        this.bvh = this.renderLayer.bvh;
+        )
 
 
         const self = this;
@@ -191,64 +166,37 @@ class WaterSystem extends System {
 
         water.side = BackSide;
 
-        /**
-         * @type {Object3D}
-         */
-        let mesh;
         if (component.__threeObject === null) {
             const geometry = new PlaneBufferGeometry(width, height, 1, 1);
 
-            mesh = ThreeFactory.createMesh(
+            const mesh = ThreeFactory.createMesh(
                 geometry,
                 water
             );
 
-
             component.__threeObject = mesh;
-        } else {
-            mesh = component.__threeObject;
         }
 
-        mesh.rotation.x = Math.PI * 0.5;
-        mesh.position.x = width / 4;
-        mesh.position.z = height / 4;
-        mesh.position.y = component.level.getValue();
-
-        threeUpdateTransform(mesh);
+        component.updateTransform();
 
-        const leafNode = new LeafNode(
-            component,
+        component.level.onChanged.add(component.updateTransform, component);
 
-            -width / 4,
-            component.level.getValue(),
-            -height / 4,
-            width * (3 / 4),
-            component.level.getValue(),
-            height * (3 / 4)
-        );
-
-        component.bvh = leafNode;
-
-        function processLevelValue(v, oldV) {
-            mesh.position.y = v;
-            threeUpdateTransform(mesh);
-
-            leafNode.move(0, 0, v - oldV);
-        }
-
-        component.level.onChanged.add(processLevelValue);
-
-        this.bvh.insertNode(leafNode);
+        component.bvh.link(this.bvh, entity);
 
         this.cleaup[entity] = function () {
-            component.level.onChanged.remove(processLevelValue);
+            component.level.onChanged.remove(component.updateTransform, component);
         };
 
         this.updateQueue.push(component);
     }
 
+    /**
+     *
+     * @param {Water} component
+     * @param {number} entity
+     */
     unlink(component, entity) {
-        component.bvh.disconnect();
+        component.bvh.unlink();
 
         const cleaup = this.cleaup[entity];
         cleaup();

package/src/engine/graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js

@@ -1,15 +1,15 @@
-import Vector3 from "../../../../../core/geom/Vector3.js";
+import { mat4 } from "gl-matrix";
 
 import { Vector3 as ThreeVector3 } from 'three';
-import { rayTriangleIntersection } from "../../../../../core/geom/3d/triangle/rayTriangleIntersection.js";
-import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { assert } from "../../../../../core/assert.js";
-import { v3_length } from "../../../../../core/geom/vec3/v3_length.js";
-import { ray3_array_apply_matrix4 } from "../../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
-import { mat4 } from "gl-matrix";
-import { ray3_array_compose } from "../../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { array_copy } from "../../../../../core/collection/array/array_copy.js";
 import { MATRIX_4_IDENTITY } from "../../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
+import { ray3_array_apply_matrix4 } from "../../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { ray3_array_compose } from "../../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
+import { rayTriangleIntersection } from "../../../../../core/geom/3d/triangle/rayTriangleIntersection.js";
+import { v3_length } from "../../../../../core/geom/vec3/v3_length.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
 
 const hit = new ThreeVector3();
 
@@ -42,6 +42,12 @@ function bindGeometryFace(indices, vertices, index) {
 
 const vNormal = new Vector3();
 
+/**
+ *
+ * @param {number[]} indices
+ * @param {number[]} normals
+ * @param {number} index
+ */
 function bindGeometryFaceNormal(indices, normals, index) {
 
     const index3 = index * 3;

package/src/engine/graphics/geometry/bvh/buffered/bvh32_from_indexed_geometry.js

@@ -0,0 +1,58 @@
+import { max3 } from "../../../../../core/math/max3.js";
+import { min3 } from "../../../../../core/math/min3.js";
+
+/**
+ *
+ * @param {BinaryUint32BVH} bvh
+ * @param {Float32Array} vertices
+ * @param {Uint32Array} indices
+ */
+export function bvh32_from_indexed_geometry(bvh, vertices, indices) {
+
+    const triangle_count = indices.length / 3;
+
+    bvh.setLeafCount(triangle_count);
+    bvh.initialize_structure();
+
+    for (let i = 0; i < triangle_count; i++) {
+
+        const index3 = i * 3;
+
+        // read triangle vertex indices
+        const iA = indices[index3];
+        const iB = indices[index3 + 1];
+        const iC = indices[index3 + 2];
+
+        const a = iA * 3;
+        const b = iB * 3;
+        const c = iC * 3;
+
+        // read actual positions of each vertex
+        const aX = vertices[a];
+        const aY = vertices[a + 1];
+        const aZ = vertices[a + 2];
+
+        const bX = vertices[b];
+        const bY = vertices[b + 1];
+        const bZ = vertices[b + 2];
+
+        const cX = vertices[c];
+        const cY = vertices[c + 1];
+        const cZ = vertices[c + 2];
+
+        // compute bounds of the triangle
+        const x0 = min3(aX, bX, cX);
+        const y0 = min3(aY, bY, cY);
+        const z0 = min3(aZ, bZ, cZ);
+
+        const x1 = max3(aX, bX, cX);
+        const y1 = max3(aY, bY, cY);
+        const z1 = max3(aZ, bZ, cZ);
+
+        bvh.setLeafData(i, i, x0, y0, z0, x1, y1, z1)
+    }
+
+    // finalize build
+    // bvh.sort_morton(MATRIX_4_IDENTITY);
+    bvh.build();
+}

package/src/engine/graphics/particles/ecs/ParticleEmitterSystem.js

@@ -1,30 +1,30 @@
-import {assert} from "../../../../core/assert.js";
-import {
-    bvh_query_user_data_overlaps_frustum
-} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
-import {ResourceAccessKind} from "../../../../core/model/ResourceAccessKind.js";
-import {ResourceAccessSpecification} from "../../../../core/model/ResourceAccessSpecification.js";
-import {ImageRGBADataLoader} from "../../../asset/loaders/image/ImageRGBADataLoader.js";
-import {System} from "../../../ecs/System.js";
-import {Transform} from "../../../ecs/transform/Transform.js";
-import {RenderPassType} from "../../render/RenderPassType.js";
-import {StandardFrameBuffers} from "../../StandardFrameBuffers.js";
-import {ParticleEmitter} from "../particular/engine/emitter/ParticleEmitter.js";
-import {ParticleEmitterFlag} from "../particular/engine/emitter/ParticleEmitterFlag.js";
-import {ParticularEngine} from "../particular/engine/ParticularEngine.js";
-
-/**
- *
- * @param {ParticleEmitter} emitter
- * @returns {Group|Object3D}
- */
-function extractRenderable(emitter) {
-    return emitter.mesh;
-}
-
-const scratch_array = [];
+import { assert } from "../../../../core/assert.js";
+import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
+import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
+import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
+import { System } from "../../../ecs/System.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { make_bvh_visibility_builder } from "../../render/make_bvh_visibility_builder.js";
+import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
+import { ParticleEmitter } from "../particular/engine/emitter/ParticleEmitter.js";
+import { ParticleEmitterFlag } from "../particular/engine/emitter/ParticleEmitterFlag.js";
+import { ParticularEngine } from "../particular/engine/ParticularEngine.js";
 
 export class ParticleEmitterSystem extends System {
+    dependencies = [ParticleEmitter, Transform];
+
+    components_used = [
+        ResourceAccessSpecification.from(ParticleEmitter, ResourceAccessKind.Read | ResourceAccessKind.Write)
+    ];
+
+    /**
+     *
+     * @type {RenderLayer|null}
+     */
+    renderLayer = null;
+
+    __handlers = [];
+
     /**
      *
      * @extends {System.<ParticleEmitter>}
@@ -37,12 +37,6 @@ export class ParticleEmitterSystem extends System {
         assert.defined(engine, 'engine');
         assert.equal(engine.isEngine, true, 'engine.isEngine !== true');
 
-        this.dependencies = [ParticleEmitter, Transform];
-
-        this.components_used = [
-            ResourceAccessSpecification.from(ParticleEmitter, ResourceAccessKind.Read | ResourceAccessKind.Write)
-        ];
-
         /**
          *
          * @type {GraphicsEngine}
@@ -61,13 +55,6 @@ export class ParticleEmitterSystem extends System {
          */
         this.particleEngine = new ParticularEngine(engine.assetManager, engine.graphics.getMaterialManager());
 
-        /**
-         *
-         * @type {RenderLayer|null}
-         */
-        this.renderLayer = null;
-
-        this.__handlers = [];
     }
 
     async startup(entityManager, readyCallback, errorCallback) {
@@ -87,33 +74,16 @@ export class ParticleEmitterSystem extends System {
 
         this.renderLayer = renderLayer;
 
-        renderLayer.renderPass = RenderPassType.Transparent;
-
-        renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
+        renderLayer.buildVisibleSet = make_bvh_visibility_builder(
+            this.entityManager, this.particleEngine.bvh,
+            (destination, offset, entity, ecd) => {
+                const component = ecd.getComponent(entity, ParticleEmitter);
 
-            const ecd = entityManager.dataset;
 
-            if (ecd === null) {
-                return 0;
+                destination[offset] = component.mesh;
+                return 1;
             }
-
-            const view_frustum = view.frustum;
-
-            const hit_count = bvh_query_user_data_overlaps_frustum(scratch_array, 0, this.particleEngine.bvh, view_frustum);
-
-            for (let i = 0; i < hit_count; i++) {
-                const id = scratch_array[i];
-
-                /**
-                 * @type {ParticleEmitter}
-                 */
-                const emitter = ecd.getComponent(id, ParticleEmitter);
-
-                destination[destination_offset + i] = emitter.mesh;
-            }
-
-            return hit_count;
-        };
+        );
 
         renderLayer.visibleSet.onAdded.add((points) => {
             /**

package/src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js

@@ -516,7 +516,7 @@ export class ParticleEmitter {
         const ebb = this.emissionBounds;
         const pbb = this.particleBounds;
 
-        aabb3_array_combine(this.bvh_leaf.bounds, ebb, pbb);
+        aabb3_array_combine(this.bvh_leaf.bounds,0, ebb,0, pbb,0);
 
         this.bvh_leaf.write_bounds();
 

package/src/engine/graphics/particles/particular/engine/renderers/billboard/prototypeBillboardRenderer.js

@@ -1,18 +1,16 @@
-import { EngineHarness } from "../../../../../../EngineHarness.js";
-import { ParticlePool } from "../../emitter/ParticlePool.js";
-import { make_particle_billboard_shader } from "./ParticleBillboardMaterial.js";
 import { DataTexture, LinearFilter, LinearMipMapLinearFilter, Matrix4, Points } from "three";
-import { ManagedAtlas } from "../../../../../texture/atlas/ManagedTextureAtlas.js";
-import { writeSample2DDataToDataTexture } from "../../../../../texture/sampler/writeSampler2DDataToDataTexture.js";
+import Vector3 from "../../../../../../../core/geom/Vector3.js";
 import { ImageRGBADataLoader } from "../../../../../../asset/loaders/image/ImageRGBADataLoader.js";
-import { EngineConfiguration } from "../../../../../../EngineConfiguration.js";
-import { MeshSystem } from "../../../../../ecs/mesh/MeshSystem.js";
 import Entity from "../../../../../../ecs/Entity.js";
 import { Transform } from "../../../../../../ecs/transform/Transform.js";
+import { EngineConfiguration } from "../../../../../../EngineConfiguration.js";
+import { EngineHarness } from "../../../../../../EngineHarness.js";
 import Mesh from "../../../../../ecs/mesh/Mesh.js";
-import Vector3 from "../../../../../../../core/geom/Vector3.js";
-import { RenderPassType } from "../../../../../render/RenderPassType.js";
+import { MeshSystem } from "../../../../../ecs/mesh/MeshSystem.js";
 import { StandardFrameBuffers } from "../../../../../StandardFrameBuffers.js";
+import { ManagedAtlas } from "../../../../../texture/atlas/ManagedTextureAtlas.js";
+import { writeSample2DDataToDataTexture } from "../../../../../texture/sampler/writeSampler2DDataToDataTexture.js";
+import { ParticlePool } from "../../emitter/ParticlePool.js";
 import {
     BILLBOARD_PARTICLE_ATTRIBUTE_BLEND,
     BILLBOARD_PARTICLE_ATTRIBUTE_COLOR,
@@ -21,6 +19,7 @@ import {
     BILLBOARD_PARTICLE_ATTRIBUTE_UV,
     BILLBOARD_PARTICLE_SPECIFICATION
 } from "./BILLBOARD_PARTICLE_SPECIFICATION.js";
+import { make_particle_billboard_shader } from "./ParticleBillboardMaterial.js";
 
 
 const engineHarness = new EngineHarness();
@@ -113,8 +112,6 @@ async function main(engine) {
     layer.visibleSet.push(points);
     layer.visibleSet.finalizeUpdate();
 
-    layer.renderPass = RenderPassType.Transparent;
-
     engine.graphics.on.visibilityConstructionStarted.add((renderer, camera, scene) => {
         renderer.getSize(shaderMaterial.uniforms.resolution.value);
 

package/src/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -1,27 +1,27 @@
+import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import {
     aabb3_compute_distance_above_plane_max
 } from "../../../../../core/geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
 import { point_light_inside_volume } from "./point_light_inside_volume.js";
-import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
- * @param {DataView} data_view
+ * @param {Float32Array} data
  * @param {number} address
  * @param {ArrayLike<number>|number[]} planes
  * @return {boolean}
  */
-function frustum_check(data_view, address, planes) {
-    const n_x0 = data_view.getFloat32(address);
-    const n_y0 = data_view.getFloat32(address + 4);
-    const n_z0 = data_view.getFloat32(address + 8);
+function frustum_check(data, address, planes) {
+    const n_x0 = data[address];
+    const n_y0 = data[address + 1];
+    const n_z0 = data[address + 2];
 
-    const n_x1 = data_view.getFloat32(address + 12);
-    const n_y1 = data_view.getFloat32(address + 16);
-    const n_z1 = data_view.getFloat32(address + 20);
+    const n_x1 = data[address + 3];
+    const n_y1 = data[address + 4];
+    const n_z1 = data[address + 5];
 
     for (let plane_address = 0; plane_address < 24; plane_address += 4) {
 
@@ -54,7 +54,7 @@ function frustum_check(data_view, address, planes) {
  * Most of the data is in flat continuous array for cache coherence
  * @param {number[]} destination
  * @param {number} destination_offset
- * @param {BinaryUint32BVH} root
+ * @param {BinaryUint32BVH} bvh
  * @param {number[]|Uint8ClampedArray} source_data
  * @param {number[]|Float32Array|Float64Array} planes
  * @param {number[]|Float32Array|Float64Array} points
@@ -63,13 +63,13 @@ function frustum_check(data_view, address, planes) {
 export function query_bvh_frustum_from_texture(
     destination,
     destination_offset,
-    root,
+    bvh,
     source_data,
     planes, points
 ) {
     let result = 0;
 
-    const binary_node_count = root.getBinaryNodeCount();
+    const binary_node_count = bvh.getBinaryNodeCount();
 
     if (binary_node_count <= 0) {
         // this should not happen
@@ -88,8 +88,10 @@ export function query_bvh_frustum_from_texture(
      */
     stack[stack_top] = 0;
 
-    const last_valid_index = binary_node_count + root.getLeafNodeCount();
-    const data_view = root.getDataView();
+    const last_valid_index = binary_node_count + bvh.getLeafNodeCount();
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
 
     do {
         stack.pointer--;
@@ -101,7 +103,7 @@ export function query_bvh_frustum_from_texture(
             // is intermediate node
             const node_address = node_index * BVH_BINARY_NODE_SIZE;
 
-            if (!frustum_check(data_view, node_address, planes)) {
+            if (!frustum_check(float32, node_address, planes)) {
                 continue;
             }
 
@@ -124,7 +126,7 @@ export function query_bvh_frustum_from_texture(
 
             const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
 
-            const light_descriptor = data_view.getUint32(node_address + 24);
+            const light_descriptor = uint32[node_address + 6];
 
             const light_type = light_descriptor & 3;
 
@@ -148,7 +150,7 @@ export function query_bvh_frustum_from_texture(
             } else if (light_type === 3) {
                 // decal
 
-                if (!frustum_check(data_view, node_address, planes)) {
+                if (!frustum_check(float32, node_address, planes)) {
                     continue;
                 }
 
@@ -162,7 +164,7 @@ export function query_bvh_frustum_from_texture(
             result++;
         }
 
-    }while (stack.pointer > stack_top)
+    } while (stack.pointer > stack_top)
 
     return result;
 }

package/src/engine/graphics/render/layers/RenderLayer.d.ts

@@ -1,15 +1,16 @@
-import {BinaryNode} from "../../../../core/bvh2/BinaryNode";
-import {RenderLayerState} from "./RenderLayerState";
 import {Object3D} from "three";
 import {IncrementalDeltaSet} from "../visibility/IncrementalDeltaSet";
+import {RenderLayerState} from "./RenderLayerState";
 
 export class RenderLayer {
-    bvh: BinaryNode
     name: string
     state: RenderLayerState
 
     managed: boolean
 
+    /**
+     * @deprecated
+     */
     extractRenderable(leafData: any): Object3D
 
     /**