@woosh/meep-engine 2.34.33 → 2.34.37

package/engine/ecs/foliage/InstancedFoliage.js

@@ -1,23 +1,19 @@
 import { BinaryNode } from "../../../core/bvh2/BinaryNode.js";
 import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
-import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
-import Vector3 from "../../../core/geom/Vector3.js";
 import { LeafNode } from "../../../core/bvh2/LeafNode.js";
 import Vector4 from "../../../core/geom/Vector4.js";
 
 import { BufferGeometry } from 'three';
 import { DataType } from "../../../core/collection/table/DataType.js";
 import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
-import { ThreeFrustumsIntersectionBVHVisitor } from "../../../core/bvh2/traversal/ThreeFrustumsIntersectionBVHVisitor.js";
-import { FoliageVisibilitySetBuilder } from "./FoliageVisibilitySetBuilder.js";
-import { traverseBinaryNodeUsingVisitor } from "../../../core/bvh2/traversal/traverseBinaryNodeUsingVisitor.js";
 import { serializeBinaryNodeToBinaryBuffer } from "../../../core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js";
 import { deserializeBinaryNodeFromBinaryBuffer } from "../../../core/bvh2/serialization/deserializeBinaryNodeFromBinaryBuffer.js";
 import { computeGeometryBoundingSphereMiniball } from "../../graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js";
 import { serializeRowFirstTable } from "../../../core/collection/table/serializeRowFirstTable.js";
 import { deserializeRowFirstTable } from "../../../core/collection/table/deserializeRowFirstTable.js";
-import { assert } from "../../../core/assert.js";
+import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
+import { aabb3_from_v3_array_transformed } from "../../../core/bvh2/aabb3/aabb3_from_v3_array_transformed.js";
+import { ViewState } from "./ViewState.js";
 
 /**
  * @readonly
@@ -57,15 +53,16 @@ export class InstancedFoliage {
 
         /**
          *
-         * @type {InstancedMeshGroup}
+         * @type {THREE.BufferGeometry|null}
          */
-        this.instances = new InstancedMeshGroup();
+        this.geometry = null;
 
         /**
          *
-         * @type {THREE.BufferGeometry|null}
+         * @type {THREE.Material|null}
+         * @private
          */
-        this.geometry = null;
+        this.__material = null;
 
         /**
          *
@@ -73,32 +70,39 @@ export class InstancedFoliage {
          */
         this.instanceBoundingSphere = new Vector4(0, 0, 0, 0);
 
-
         /**
          *
-         * @type {ThreeFrustumsIntersectionBVHVisitor}
+         * @type {Map<CameraView, ViewState>}
+         * @private
          */
-        this.bvhVisibilityVisitor = new ThreeFrustumsIntersectionBVHVisitor();
+        this.__views = new Map();
 
-        /**
-         *
-         * @type {FoliageVisibilitySetBuilder}
-         */
-        this.visibilitySetBuilder = new FoliageVisibilitySetBuilder();
-        this.bvhVisibilityVisitor.collector = this.visibilitySetBuilder;
+        this.__cast_shadow = true;
+        this.__receive_shadow = true;
+    }
 
-        /**
-         *
-         * @type {*[]}
-         * @private
-         */
-        this.__garbage = [];
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__garbagePointer = 0;
+    set castShadow(v) {
+        this.__cast_shadow = v;
+
+        for (const [view, state] of this.__views) {
+            state.instances.mesh.castShadow = v;
+        }
+    }
+
+    get castShadow() {
+        return this.__cast_shadow;
+    }
+
+    set receiveShadow(v) {
+        this.__receive_shadow = v;
+
+        for (const [view, state] of this.__views) {
+            state.instances.mesh.receiveShadow = v;
+        }
+    }
+
+    get receiveShadow() {
+        return this.__receive_shadow;
     }
 
     /**
@@ -136,7 +140,11 @@ export class InstancedFoliage {
     }
 
     dispose() {
-        this.instances.dispose();
+        for (const [view, state] of this.__views) {
+            state.dispose();
+        }
+
+        this.__views.clear();
     }
 
     initialize() {
@@ -168,7 +176,7 @@ export class InstancedFoliage {
         );
 
         //compute bounding box for this instance
-        this.expandBoundingBoxForInstance(position, rotation, scale, leaf);
+        this.bomputeInstanceBoundsTight(position, rotation, scale, leaf);
 
         //insert bounding box into the spatial index
         this.bvh.insertNode(leaf);
@@ -210,42 +218,15 @@ export class InstancedFoliage {
      * @param {Quaternion} rotation
      * @param {Vector3} scale
      */
-    expandBoundingBoxForInstance(position, rotation, scale, result) {
+    bomputeInstanceBoundsTight(position, rotation, scale, result) {
 
         const vertexData = this.geometry.attributes.position.array;
 
-        const rXYZ = new Vector3(rotation.x, rotation.y, rotation.z);
-
-        const v = new Vector3(0, 0, 0);
-
-        const c0 = new Vector3(0, 0, 0);
-        const c1 = new Vector3(0, 0, 0);
-        const c2 = new Vector3(0, 0, 0);
-
-        for (let i = 0, l = vertexData.length; i < l; i += 3) {
-            const x = vertexData[i];
-            const y = vertexData[i + 1];
-            const z = vertexData[i + 2];
-
-            v.set(x, y, z);
-
-            //transform point
-
-            //apply scale
-            v.multiply(scale);
+        const transform = new Float32Array(16);
 
-            //apply rotation
-            c1.copy(v).multiplyScalar(rotation.w);
-            c0.copy(rXYZ).cross(v).add(c1);
-            c2.copy(rXYZ).cross(c0).multiplyScalar(2);
+        compose_matrix4_array(transform, position, rotation, scale);
 
-            v.add(c2);
-
-            //apply translation
-            v.add(position);
-
-            result._expandToFitPoint(v.x, v.y, v.z);
-        }
+        aabb3_from_v3_array_transformed(result, vertexData, vertexData.length, transform);
     }
 
     computeInstanceBoundingSphere() {
@@ -277,9 +258,12 @@ export class InstancedFoliage {
 
 
         this.geometry = bufferGeometry;
+        this.__material = material;
 
-        this.instances.setMaterial(material);
-        this.instances.setGeometry(bufferGeometry);
+        for (const [view, state] of this.__views) {
+            state.instances.setMaterial(material);
+            state.instances.setGeometry(bufferGeometry);
+        }
 
         this.computeInstanceBoundingSphere();
 
@@ -318,108 +302,60 @@ export class InstancedFoliage {
 
     /**
      *
-     * @param index
-     * @param {int} ref
+     * @param {CameraView} view
      */
-    __updateVisibility(index, ref) {
-        assert.isNonNegativeInteger(ref, 'ref');
-
-        /**
-         *
-         * @type {FoliageVisibilitySetBuilder}
-         */
-        const builder = this.visibilitySetBuilder;
+    add_view(view) {
 
-        /**
-         *
-         * @type {BitSet}
-         */
-        const visibleElementSet = builder.visibleSet;
-
-        if (!visibleElementSet.get(ref)) {
-            //no longer visible
-            this.__garbage[this.__garbagePointer++] = ref;
-        } else {
-            //visible, and is already in the group, update the set
-            visibleElementSet.set(ref, false);
+        if (this.__views.has(view)) {
+            throw new Error('View already registered');
         }
-    }
-
-    __removeGarbage() {
 
-        const garbagePointer = this.__garbagePointer;
-        const instances = this.instances;
+        const state = new ViewState();
 
+        state.__view = view;
 
-        const garbage = this.__garbage;
-
-        for (let i = 0; i < garbagePointer; i++) {
-            const ref = garbage[i];
-            instances.remove(ref);
+        if (this.geometry !== null) {
+            state.instances.setGeometry(this.geometry);
+        }
+        if (this.__material !== null) {
+            state.instances.setMaterial(this.__material);
         }
 
+        state.instances.mesh.castShadow = this.castShadow;
+        state.instances.mesh.receiveShadow = this.receiveShadow;
+
+        this.__views.set(view, state);
     }
 
     /**
      *
-     * @param {Frustum[]} frustums
-     * @param {function[]} [visibilityFilters]
+     * @param {CameraView} view
      */
-    update(frustums, visibilityFilters = []) {
-        const instances = this.instances;
-
-        this.bvhVisibilityVisitor.setFrustums(frustums);
+    remove_view(view) {
+        const state = this.__views.get(view);
 
-        const visibilitySetBuilder = this.visibilitySetBuilder;
-        visibilitySetBuilder.setFilters(visibilityFilters);
-        visibilitySetBuilder.initialize();
-
-        const visibleElementSet = visibilitySetBuilder.visibleSet;
-
-        //build visible set
-        traverseBinaryNodeUsingVisitor(this.bvh, this.bvhVisibilityVisitor);
-
-        visibilitySetBuilder.finalize();
-
-        // console.log(`Visible: `, elementsToAdd.size);
-
-        //reset garbage pointer
-        this.__garbagePointer = 0;
-
-        //remove those that are no longer visible
-        instances.traverseReferences(this.__updateVisibility, this);
-
-        //cull instances that are no longer visible
-        this.__removeGarbage();
-
-
-        const data = this.data;
-
-        //process entities that have become newly visible
-        for (let index = visibleElementSet.nextSetBit(0); index !== -1; index = visibleElementSet.nextSetBit(index + 1)) {
-            //read transform data for instance
-            data.getRow(index, rowData);
-
-            const positionX = rowData[0];
-            const positionY = rowData[1];
-            const positionZ = rowData[2];
+        if (state === undefined) {
+            return false;
+        }
 
-            const encodedRotation = rowData[3];
+        state.dispose();
 
+        this.__views.delete(view);
 
-            const scaleX = rowData[4];
-            const scaleY = rowData[5];
-            const scaleZ = rowData[6];
+        return true;
+    }
 
-            const i = instances.add(index);
+    /**
+     *
+     * @param {CameraView} view
+     * @return {ViewState}
+     */
+    update(view) {
+        const state = this.__views.get(view);
 
-            tempQuaternion.decodeFromUint32(encodedRotation);
+        state.update(this.bvh, this.data);
 
-            //apply instance transforms
-            instances.setPositionAt(i, positionX, positionY, positionZ);
-            instances.setRotationAt(i, tempQuaternion.x, tempQuaternion.y, tempQuaternion.z, tempQuaternion.w);
-            instances.setScaleAt(i, scaleX, scaleY, scaleZ);
-        }
+        return state;
     }
 }
 
@@ -442,6 +378,3 @@ function serializeLeafValueUintVar(buffer, value) {
 }
 
 
-const tempQuaternion = new Quaternion();
-const rowData = [];
-

package/engine/ecs/foliage/ViewState.js

@@ -0,0 +1,190 @@
+import { BitSet } from "../../../core/binary/BitSet.js";
+import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
+import { assert } from "../../../core/assert.js";
+import { queryBinaryNode_FrustumIntersections_Data } from "../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_array = [];
+
+export class ViewState {
+    constructor() {
+        /**
+         *
+         * @type {CameraView|null}
+         * @private
+         */
+        this.__view = null;
+
+        this.__visible_set = new BitSet();
+
+        //prevent re-allocation
+        this.__visible_set.preventShrink();
+
+        /**
+         *
+         * @type {InstancedMeshGroup}
+         */
+        this.instances = new InstancedMeshGroup();
+
+        /**
+         *
+         * @type {number[]}
+         * @private
+         */
+        this.__garbage = [];
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__garbagePointer = 0;
+    }
+
+    dispose() {
+        this.instances.dispose();
+    }
+
+
+    /**
+     *
+     * @param {number} index
+     * @param {int} ref
+     */
+    __updateVisibility(index, ref) {
+        assert.isNonNegativeInteger(ref, 'ref');
+
+        /**
+         *
+         * @type {BitSet}
+         */
+        const visibleElementSet = this.__visible_set;
+
+        if (!visibleElementSet.get(ref)) {
+            //no longer visible
+            this.__garbage[this.__garbagePointer++] = ref;
+        } else {
+            //visible, and is already in the group, update the set
+            visibleElementSet.set(ref, false);
+        }
+    }
+
+    __compute_visibility_update() {
+        const instances = this.instances;
+
+        const indices = instances.indices;
+
+        const index_count = indices.length;
+
+        /**
+         *
+         * @type {BitSet}
+         */
+        const visible_set = this.__visible_set;
+
+        const garbage = this.__garbage;
+
+        for (let ref = 0; ref < index_count; ref++) {
+            const index = indices[ref];
+
+            if (index === undefined) {
+                // unoccupied
+                continue;
+            }
+
+            if (!visible_set.get(ref)) {
+                //no longer visible
+                garbage[this.__garbagePointer++] = ref;
+            } else {
+                //visible, and is already in the group, update the set
+                visible_set.set(ref, false);
+            }
+        }
+    }
+
+    __removeGarbage() {
+
+        const garbagePointer = this.__garbagePointer;
+        const instances = this.instances;
+
+
+        const garbage = this.__garbage;
+
+        for (let i = 0; i < garbagePointer; i++) {
+            const ref = garbage[i];
+            instances.remove(ref);
+        }
+
+    }
+
+    /**
+     *
+     * @param {BinaryNode<number>} bvh
+     * @param {RowFirstTable} data
+     */
+    update(bvh, data) {
+
+        // reset visible set
+        this.__visible_set.reset();
+
+        //reset garbage pointer
+        this.__garbagePointer = 0;
+
+        const instances = this.instances;
+
+        const visible_instance_set = this.__visible_set;
+
+
+        // collect visible instances
+        const collected_nodes = queryBinaryNode_FrustumIntersections_Data(scratch_array, 0, bvh, this.__view.frustum);
+
+        for (let i = 0; i < collected_nodes; i++) {
+            const instance_id = scratch_array[i];
+
+            // mark them as visible
+            visible_instance_set.set(instance_id, true);
+        }
+
+        //remove those that are no longer visible
+        this.__compute_visibility_update();
+
+        //cull instances that are no longer visible
+        this.__removeGarbage();
+
+        //process entities that have become newly visible
+        for (
+            let index = visible_instance_set.nextSetBit(0);
+            index !== -1;
+            index = visible_instance_set.nextSetBit(index + 1)
+        ) {
+            //read transform data for instance
+            data.getRow(index, rowData);
+
+            const positionX = rowData[0];
+            const positionY = rowData[1];
+            const positionZ = rowData[2];
+
+            const encodedRotation = rowData[3];
+
+
+            const scaleX = rowData[4];
+            const scaleY = rowData[5];
+            const scaleZ = rowData[6];
+
+            const i = instances.add(index);
+
+            tempQuaternion.decodeFromUint32(encodedRotation);
+
+            //apply instance transforms
+            instances.setPositionAt(i, positionX, positionY, positionZ);
+            instances.setRotationAt(i, tempQuaternion.x, tempQuaternion.y, tempQuaternion.z, tempQuaternion.w);
+            instances.setScaleAt(i, scaleX, scaleY, scaleZ);
+        }
+    }
+}
+
+const tempQuaternion = new Quaternion();
+const rowData = [];

package/engine/ecs/foliage/ecs/Foliage2System.js

@@ -26,13 +26,8 @@ function cleanupLayer(layerData, renderLayer) {
 export function loadFoliageLayer(layer, assetManager) {
     const instancedFoliage = layer.data;
 
-    /**
-     * @type {THREE.Mesh}
-     */
-    const threeMesh = instancedFoliage.instances.mesh;
-
-    threeMesh.castShadow = layer.castShadow.getValue();
-    threeMesh.receiveShadow = layer.receiveShadow.getValue();
+    instancedFoliage.castShadow = layer.castShadow.getValue();
+    instancedFoliage.receiveShadow = layer.receiveShadow.getValue();
 
     const modelURL = layer.modelURL.getValue();
 
@@ -112,15 +107,24 @@ export class Foliage2System extends System {
     startup(entityManager, readyCallback, errorCallback) {
         this.entityManager = entityManager;
 
-        this.renderLayer = this.graphics.layers.create('instanced-mesh-system');
-        this.renderLayer.buildVisibleSet = (frustums, filters, visitObject, thisArg) => {
+        const graphics = this.graphics;
+
+        this.renderLayer = graphics.layers.create('instanced-mesh-system');
+
+        graphics.views.elements.forEach(this.__handle_view_added, this);
+
+        graphics.views.elements.on.added.add(this.__handle_view_added, this);
+        graphics.views.elements.on.removed.add(this.__handle_view_removed, this);
+
+        this.renderLayer.buildVisibleSet = (view, visitObject, thisArg) => {
             const data = this.data;
 
             for (let entity in data) {
 
                 const layers = data[entity];
+                const layer_count = layers.length;
 
-                for (let i = 0, numLayers = layers.length; i < numLayers; i++) {
+                for (let i = 0; i < layer_count; i++) {
                     /**
                      * @type {{instances:InstancedFoliage}}
                      */
@@ -133,9 +137,9 @@ export class Foliage2System extends System {
                          */
                         const instances = layerData.instances;
 
-                        instances.update(frustums, filters);
+                        const view_state = instances.update(view);
 
-                        const group = instances.instances;
+                        const group = view_state.instances;
 
                         if (group.getCount() <= 0) {
                             //no visible instances, skip
@@ -153,9 +157,61 @@ export class Foliage2System extends System {
         readyCallback();
     }
 
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_added(view) {
+        const em = this.entityManager;
+
+        if (em === null) {
+            return;
+        }
+
+        const ecd = em.dataset;
+
+        if (ecd === null) {
+            return;
+        }
+
+        ecd.traverseComponents(InstancedMeshComponent, im => {
+            im.add_view(view);
+        });
+    }
+
+
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_removed(view) {
+
+        const em = this.entityManager;
+
+        if (em === null) {
+            return;
+        }
+
+        const ecd = em.dataset;
+
+        if (ecd === null) {
+            return;
+        }
+
+        ecd.traverseComponents(InstancedMeshComponent, im => {
+            im.remove_view(view);
+        });
+    }
+
     shutdown(entityManager, readyCallback, errorCallback) {
         this.graphics.layers.remove(this.renderLayer);
 
+        this.graphics.views.elements.forEach(this.__handle_view_removed, this);
+        this.graphics.views.elements.on.added.remove(this.__handle_view_added, this);
+        this.graphics.views.elements.on.removed.remove(this.__handle_view_removed, this);
+
         readyCallback();
     }
 
@@ -166,16 +222,16 @@ export class Foliage2System extends System {
 
     /**
      *
-     * @param {InstancedMeshComponent} foliage
+     * @param {InstancedMeshComponent} instances
      * @param entity
      */
-    link(foliage, entity) {
+    link(instances, entity) {
         const layers = [];
         const data = this.data;
 
         data[entity] = layers;
 
-        const layerList = foliage.layers;
+        const layerList = instances.layers;
         const layer_count = layerList.length;
 
         for (let i = 0; i < layer_count; i++) {
@@ -215,11 +271,16 @@ export class Foliage2System extends System {
             }
         }
 
-        //TODO need to expose InstancedMesh BVH to let camera frustum calculation work correctly
-
+        //
+        this.graphics.views.elements.forEach(instances.add_view, instances);
     }
 
-    unlink(foliage, entity) {
+    /**
+     *
+     * @param {InstancedMeshComponent} instances
+     * @param {number} entity
+     */
+    unlink(instances, entity) {
         const renderLayer = this.renderLayer;
         const layers = this.data[entity];
 
@@ -230,7 +291,9 @@ export class Foliage2System extends System {
             cleanupLayer(layerData, renderLayer);
         }
 
-        foliage.dispose();
+        this.graphics.views.elements.forEach(instances.remove_view, instances);
+
+        instances.dispose();
 
         delete this.data[entity];
     }