@woosh/meep-engine 2.34.35 → 2.34.39

package/core/bvh2/traversal/ThreeFrustumsIntersectionBVHVisitor.js

@@ -6,13 +6,11 @@ export class ThreeFrustumsIntersectionBVHVisitor extends BVHVisitor {
         super();
 
         /**
-         * Collection of THREE.js Frustums
+         * [plane_x, plane_y, plane_z, constant] collection, defining a frustum
          * @private
-         * @type {Frustum[]}
+         * @type {ArrayLike<number>|number[]}
          */
-        this.frustums = [];
-
-        this.frustumCount = 0;
+        this.frustum = [];
 
         /**
          *
@@ -23,49 +21,32 @@ export class ThreeFrustumsIntersectionBVHVisitor extends BVHVisitor {
 
     /**
      *
-     * @param {Frustum[]} frustums
+     * @param {ArrayLike<number>|number[]|Float32Array} frustum
      */
-    setFrustums(frustums) {
-        this.frustums = frustums;
-        this.frustumCount = frustums.length;
+    setFrustum(frustum) {
+        this.frustum = frustum;
     }
 
     visitLeaf(node) {
 
-        const n = this.frustumCount;
-
-        for (let i = 0; i < n; i++) {
+        const degree = node.intersectFrustumDegree_array(this.frustum);
 
-            const degree = node.intersectFrustumDegree(this.frustums[i]);
-
-            if (degree !== 0) {
-                this.collector.visitLeaf(node);
-                return;
-            }
+        if (degree !== 0) {
+            // at least partially visible
+            this.collector.visitLeaf(node);
         }
-
     }
 
     visitBinary(node) {
-        let flag = false;
-
-        const n = this.frustumCount;
-
-        for (let i = 0; i < n; i++) {
-
-            const degree = node.intersectFrustumDegree(this.frustums[i]);
 
-            if (degree === 2) {
-                //completely inside
-                traverseBinaryNodeUsingVisitor(node, this.collector);
-                return false;
-            } else if (degree === 1) {
-                //partially inside, continue traversal
-                flag = true;
-            }
+        const degree = node.intersectFrustumDegree_array(this.frustum);
 
+        if (degree === 2) {
+            //completely inside, do fast traversal
+            traverseBinaryNodeUsingVisitor(node, this.collector);
+            return false;
         }
 
-        return flag;
+        return degree === 1;
     }
 }

package/core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js

@@ -0,0 +1,52 @@
+/**
+ *
+ * @type {(BinaryNode|LeafNode)[]}
+ */
+const stack = [];
+
+
+/**
+ * @template T
+ * @param {T[]} destination
+ * @param {number} destinationOffset
+ * @param {BinaryNode<T>} root
+ * @param {ArrayLike<number>|number[]|Float32Array} frustum
+ * @returns {number} Number of results
+ */
+export function queryBinaryNode_FrustumIntersections_Data(destination, destinationOffset, root, frustum) {
+    let n;
+    let i = 0;
+    let stackPointer = 1;
+
+    stack[0] = root;
+
+    while (stackPointer > 0) {
+        stackPointer--;
+
+        n = stack[stackPointer];
+
+        if (!n.intersectFrustum_array(frustum)) {
+            continue;
+        }
+
+        if (n.isBinaryNode) {
+
+            if (n.right !== null) {
+                stack[stackPointer++] = n.right;
+            }
+
+            if (n.left !== null) {
+                stack[stackPointer++] = n.left;
+            }
+
+        } else {
+
+            destination[destinationOffset + i] = n.object;
+
+            i++;
+        }
+
+    }
+
+    return i;
+}

package/core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js

@@ -23,5 +23,5 @@ export function aabb3_computeDistanceAbovePlane(
     const pz = plane_normal_z > 0 ? _z1 : _z0;
 
     // dot(v4,v4) inlined for speed
-    return (plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz) + plane_constant;
+    return plane_constant + plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz;
 }

package/core/geom/3d/aabb/aabb3_matrix4_project.js

@@ -1,8 +1,7 @@
-
 /**
  * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
- * @param {number[]} result
- * @param {number[]} aabb
+ * @param {ArrayLike<number>|number[]|Float32Array} result
+ * @param {ArrayLike<number>|number[]|Float32Array} aabb
  * @param {number[]} matrix 4x4 matrix
  */
 export function aabb3_matrix4_project(result, aabb, matrix) {
@@ -15,7 +14,7 @@ export function aabb3_matrix4_project(result, aabb, matrix) {
     for (let i = 0; i < 3; i++) {
         for (let j = 0; j < 3; j++) {
 
-            const m_a = i * 4 + j;
+            const m_a = i + j * 4;
             const m_v = matrix[m_a];
 
             const a = m_v * aabb[j];

package/core/geom/3d/aabb/aabb3_matrix4_project.spec.js

@@ -1,4 +1,7 @@
 import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+import { compose_matrix4_array } from "../../../../engine/graphics/util/composeMatrix4.js";
+import Vector3 from "../../Vector3.js";
+import Quaternion from "../../Quaternion.js";
 
 test('identity', () => {
     const r = [];
@@ -39,3 +42,13 @@ test('scale case', () => {
 
     expect(r).toEqual([-5, 4, -27, -1, 14, -9]);
 });
+
+test('translation + scale case', () => {
+    const m4 = [];
+    compose_matrix4_array(m4, new Vector3(-1, 2, -3), Quaternion.identity, new Vector3(7, -11, 13));
+
+    const r = [];
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], m4);
+
+    expect(r).toEqual([6, -75, 36, 34, -20, 114]);
+});

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -95,9 +95,8 @@ export function computeTriangleRayIntersection(
     // Line intersects triangle, check if ray does.
     const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
 
-    // t < 0, no intersection
     if (QdN < 0) {
-
+        // t < 0, no intersection
         return false;
 
     }

package/core/geom/Quaternion.d.ts

@@ -22,4 +22,6 @@ export default class Quaternion {
     threeSetRotationMatrix(result: Matrix4): void
 
     setFromRotationMatrix(m: Matrix4): void
+
+    decodeFromUint32(uint: number): void
 }

package/core/geom/Vector3.js

@@ -523,21 +523,25 @@ class Vector3 {
     /**
      *
      * @param {THREE.Matrix4} matrix4
-     * @returns {Vector3}
      */
     applyMatrix4_three(matrix4) {
+        this.applyMatrix4(matrix4.elements);
+    }
 
+    /**
+     *
+     * @param {ArrayList<number>|number[]|Float32Array} m4
+     */
+    applyMatrix4(m4) {
         const x = this.x;
         const y = this.y;
         const z = this.z;
 
-        const e = matrix4.elements;
-
-        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
-        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
-        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+        const _x = m4[0] * x + m4[4] * y + m4[8] * z + m4[12];
+        const _y = m4[1] * x + m4[5] * y + m4[9] * z + m4[13];
+        const _z = m4[2] * x + m4[6] * y + m4[10] * z + m4[14];
 
-        return this.set(_x, _y, _z);
+        this.set(_x, _y, _z);
     }
 
     /**
@@ -589,11 +593,18 @@ class Vector3 {
      * @param {THREE.Matrix4} matrix4
      */
     threejs_setFromMatrixPosition(matrix4) {
-        const e = matrix4.elements;
+        this.setFromMatrixPosition(matrix4.elements);
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} matrix4 4x4 transform matrix
+     */
+    setFromMatrixPosition(matrix4) {
 
-        const _x = e[12];
-        const _y = e[13];
-        const _z = e[14];
+        const _x = matrix4[12];
+        const _y = matrix4[13];
+        const _z = matrix4[14];
 
         this.set(_x, _y, _z);
     }

package/engine/ecs/attachment/TransformAttachmentBinding.js

@@ -8,7 +8,6 @@ const scratch_m4_2 = new Float32Array(16);
 export class TransformAttachmentBinding extends AttachmentBinding {
     constructor() {
         super();
-
     }
 
     /**

package/engine/ecs/foliage/FoliageVisibilitySetBuilder.js

@@ -5,28 +5,13 @@ export class FoliageVisibilitySetBuilder extends BVHVisitor {
     constructor() {
         super();
 
-        /**
-         * Visibility filters
-         * @type {(function(LeafNode):boolean)[]}
-         */
-        this.filters = [];
-
         /**
          *
          * @type {BitSet}
          */
         this.visibleSet = new BitSet();
         //prevent re-allocation
-        this.visibleSet.__shrinkFactor = 0;
-    }
-
-    /**
-     *
-     * @param {(function(LeafNode):boolean)[]} filters
-     */
-    setFilters(filters) {
-        this.filters = filters;
-        this.filterCount = filters.length;
+        this.visibleSet.preventShrink();
     }
 
     initialize() {
@@ -34,21 +19,6 @@ export class FoliageVisibilitySetBuilder extends BVHVisitor {
     }
 
     visitLeaf(node) {
-
-        const n = this.filterCount;
-
-        const filters = this.filters;
-
-        for (let i = 0; i < n; i++) {
-            const visibilityFilter = filters[i];
-
-            if (!visibilityFilter(node)) {
-                //not visible
-                return;
-            }
-
-        }
-
         const index = node.object;
 
         //TODO check screen space size to decide if element should be seen or not

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.computeInstanceBoundsTight(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) {
+    computeInstanceBoundsTight(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 = [];
-