@woosh/meep-engine 2.65.0 → 2.66.0

package/src/engine/graphics/ecs/trail2d/makeGradientTrail.js

@@ -1,11 +1,11 @@
-import Trail2D, { Trail2DFlags } from "./Trail2D.js";
+import { assert } from "../../../../core/assert.js";
 import {
     RIBBON_ATTRIBUTE_ADDRESS_AGE,
     RIBBON_ATTRIBUTE_ADDRESS_COLOR,
     RIBBON_ATTRIBUTE_ADDRESS_THICKNESS,
     RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET
 } from "../../trail/x/ribbon_attributes_spec.js";
-import { assert } from "../../../../core/assert.js";
+import Trail2D, { Trail2DFlags } from "./Trail2D.js";
 
 /**
  *
@@ -62,7 +62,7 @@ export function makeGradientTrail({
     trail2D.clearFlag(Trail2DFlags.Spawning);
     trail2D.setFlag(Trail2DFlags.Built);
 
-    ribbon.computeBoundingBox(trail2D.bvhLeaf);
+    ribbon.computeBoundingBox(trail2D.bvh.bounds);
 
     return trail2D;
 }

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

@@ -0,0 +1 @@
+export const WATER_SIZE = 800;

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

@@ -3,62 +3,69 @@
  */
 
 
-import Vector1 from "../../../../core/geom/Vector1.js";
 import { ClampToEdgeWrapping, DataTexture, FloatType, LinearFilter, RedFormat } from "three";
-import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
+import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
 import { Color } from "../../../../core/color/Color.js";
+import Vector1 from "../../../../core/geom/Vector1.js";
+import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
+import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
+import { WATER_SIZE } from "./WATER_SIZE.js";
 
 class Water {
-    constructor(options) {
-        this.level = new Vector1(0);
+    level = new Vector1(0);
+    /**
+     *
+     * @type {Color}
+     */
+    color = new Color(0, 0.3, 0.5);
 
-        if (options !== undefined) {
-            this.fromJSON(options);
-        }
 
-        /**
-         *
-         * @type {Color}
-         */
-        this.color = new Color(0, 0.3, 0.5);
+    /**
+     * Defines what is considered as shore as well as how long is the transition between shore and deep water
+     * @type {NumericInterval}
+     */
+    shoreDepthTransition = new NumericInterval(0.7, 2);
 
 
-        /**
-         * Defines what is considered as shore as well as how long is the transition between shore and deep water
-         * @type {NumericInterval}
-         */
-        this.shoreDepthTransition = new NumericInterval(0.7, 2);
+    /**
+     * Color of the water at the shore
+     * @type {Color}
+     */
+    shoreColor = new Color(0.584, 0.792, 0.850);
 
+    /**
+     *
+     * @type {Vector1}
+     */
+    waveSpeed = new Vector1(1.8);
 
-        /**
-         * Color of the water at the shore
-         * @type {Color}
-         */
-        this.shoreColor = new Color(0.584, 0.792, 0.850);
+    /**
+     *
+     * @type {Vector1}
+     */
+    waveAmplitude = new Vector1(0.3);
 
-        /**
-         *
-         * @type {Vector1}
-         */
-        this.waveSpeed = new Vector1(1.8);
+    /**
+     *
+     * @type {Vector1}
+     */
+    waveFrequency = new Vector1(1);
 
-        /**
-         *
-         * @type {Vector1}
-         */
-        this.waveAmplitude = new Vector1(0.3);
+    /**
+     * Scattering of light, the higher this value is - the more opaque water will become
+     * @type {Vector1}
+     */
+    scattering = new Vector1(1.2);
 
-        /**
-         *
-         * @type {Vector1}
-         */
-        this.waveFrequency = new Vector1(1);
+    bvh = new BvhClient();
+
+    constructor(options) {
+
+        if (options !== undefined) {
+            console.error('Constructor options are deprecated');
+            this.fromJSON(options);
+        }
 
-        /**
-         * Scattering of light, the higher this value is - the more opaque water will become
-         * @type {Vector1}
-         */
-        this.scattering = new Vector1(1.2);
 
         /**
          *
@@ -83,6 +90,41 @@ class Water {
         this.scattering.onChanged.add(this.writeShaderUniforms, this);
     }
 
+    updateTransform() {
+        const width = WATER_SIZE;
+        const height = WATER_SIZE;
+
+        const mesh = this.__threeObject;
+
+        if (mesh !== null) {
+
+            mesh.rotation.x = Math.PI * 0.5;
+            mesh.position.x = width / 4;
+            mesh.position.z = height / 4;
+            mesh.position.y = this.level.getValue();
+
+            threeUpdateTransform(mesh);
+        }
+
+        this.updateBounds();
+    }
+
+    updateBounds() {
+        const width = WATER_SIZE;
+        const height = WATER_SIZE;
+
+        const level = this.level.getValue();
+
+        this.bvh.resize(
+            -width / 4,
+            level,
+            -height / 4,
+            width * (3 / 4),
+            level,
+            height * (3 / 4)
+        );
+    }
+
     /**
      *
      * @param {Terrain} terrain

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);