@woosh/meep-engine 2.67.0 → 2.69.0

package/src/engine/graphics/ecs/mesh/Mesh.d.ts

@@ -1,6 +1,5 @@
 import {Object3D} from "three";
 import {AABB3} from "../../../../core/geom/3d/aabb/AABB3";
-import {LeafNode} from "../../../../core/bvh2/LeafNode";
 
 export default class Mesh {
     url: string

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometry.d.ts

@@ -7,11 +7,6 @@ export class ShadedGeometry {
     material: Material
     readonly mode: DrawMode
 
-    /**
-     * @deprecated
-     */
-    readonly bvh: Readonly<AABB3>
-
     getBoundingBox(destination: AABB3): void
 
     from(geometry: BufferGeometry, material: Material, draw_mode?: DrawMode): void

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -215,7 +215,6 @@ export class ShadedGeometry {
 
     /**
      * @deprecated
-     * @returns {LeafNode<ShadedGeometry>}
      */
     get bvh() {
         throw new Error('Deprecated, use #getBoundingBox method instead');

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts

@@ -1,11 +1,11 @@
 import {BufferGeometry, Plane} from "three";
-import Vector3 from "../../../../../core/geom/Vector3";
 import {SurfacePoint3} from "../../../../../core/geom/3d/SurfacePoint3";
+import Vector3 from "../../../../../core/geom/Vector3";
 
 export class GeometrySpatialQueryAccelerator {
     constructor(cache_size?: number)
 
-    queryContainmentViaClippingPlanes(geometry: BufferGeometry, planes: Plane[]): number
+    queryContainmentViaClippingPlanes(geometry: BufferGeometry, planes: Plane[]): boolean
 
     queryRaycastNearest(destination: SurfacePoint3, geometry: BufferGeometry, ray_origin: Vector3, ray_direction: Vector3): boolean
 

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -1,16 +1,21 @@
-import { Cache } from "../../../../../core/cache/Cache.js";
-import { buildUnsorted, buildUnsortedUnindexed } from "../../bvh/buffered/BinaryBVHFromBufferGeometry.js";
-import { ClippingPlaneContainmentComputingVisitor } from "./ClippingPlaneContainmentComputingVisitor.js";
-import { RaycastNearestHitComputingVisitor } from "./RaycastNearestHitComputingVisitor.js";
 import { assert } from "../../../../../core/assert.js";
+import { BinaryUint32BVH } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+import { Cache } from "../../../../../core/cache/Cache.js";
+import { read_three_planes_to_array } from "../../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
+import { bvh32_from_indexed_geometry } from "../../bvh/buffered/bvh32_from_indexed_geometry.js";
+import { bvh32_from_unindexed_geometry } from "../../bvh/buffered/bvh32_from_unindexed_geometry.js";
 import { deinterleaveBufferAttribute } from "../deinterleaveBufferAttribute.js";
+import { bvh32_geometry_overlap_clipping_volume } from "./bvh32_geometry_overlap_clipping_volume.js";
+import { bvh32_geometry_raycast } from "./bvh32_geometry_raycast.js";
+
+const scratch_planes = []
 
 export class GeometrySpatialQueryAccelerator {
     constructor(cache_size = 100 * 1024 * 1024) {
 
         /**
          *
-         * @type {Cache<THREE.BufferGeometry, IndexedBinaryBVH>}
+         * @type {Cache<THREE.BufferGeometry, BinaryUint32BVH>}
          */
         this.cache = new Cache({
             maxWeight: cache_size,
@@ -22,15 +27,13 @@ export class GeometrySpatialQueryAccelerator {
             },
             /**
              *
-             * @param {IndexedBinaryBVH} tree
+             * @param {BinaryUint32BVH} tree
              */
             valueWeigher(tree) {
                 return tree.estimateByteSize();
             }
         });
 
-        this.__visitor_clip = new ClippingPlaneContainmentComputingVisitor();
-        this.__visitor_raycast = new RaycastNearestHitComputingVisitor();
     }
 
     /**
@@ -53,23 +56,46 @@ export class GeometrySpatialQueryAccelerator {
      *
      * @param {THREE.BufferGeometry} geometry
      * @param {Plane[]} planes
-     * @returns {number} -1,0,1. -1 means fully outside, 0 means partially inside, 1 means fully inside
+     * @returns {boolean} true means some overlap exists, false otherwise
      */
     queryContainmentViaClippingPlanes(geometry, planes) {
         assert.notNull(geometry, 'geometry');
         assert.defined(geometry, 'geometry');
 
+
         const bvh = this.__acquireBVH(geometry);
 
-        this.__visitor_clip.reset();
+        read_three_planes_to_array(planes, scratch_planes);
+
+        const geometryIndices = geometry.getIndex()?.array;
+        const position_attribute = geometry.getAttribute('position');
+
+        let position_data;
+        let stride = 3;
+        let position_data_offset = 0;
+
+        if (position_attribute.isInterleavedBufferAttribute) {
 
-        this.__visitor_clip.setGeometry(geometry);
-        this.__visitor_clip.setPlanes(planes);
-        this.__visitor_clip.setRoot(bvh);
+            position_data = position_attribute.data.array;
 
-        bvh.traversePreOrderStack(this.__visitor_clip, 0);
+            stride = position_attribute.data.stride;
+            position_data_offset = position_attribute.offset;
+
+        } else {
 
-        return this.__visitor_clip.getContainment();
+            position_data = position_attribute.array;
+
+            stride = 3;
+            position_data_offset = 0;
+
+        }
+
+        return bvh32_geometry_overlap_clipping_volume(
+            bvh,
+            position_data, position_data_offset, stride,
+            geometryIndices,
+            scratch_planes, 0, planes.length
+        );
     }
 
     /**
@@ -119,11 +145,33 @@ export class GeometrySpatialQueryAccelerator {
             return false;
         }
 
-        this.__visitor_raycast.reset();
+        const geometryIndices = geometry.getIndex()?.array;
+        const position_attribute = geometry.getAttribute('position');
+
+        let position_data;
+        let stride = 3;
+        let position_data_offset = 0;
+
+        if (position_attribute.isInterleavedBufferAttribute) {
+
+            position_data = position_attribute.data.array;
 
-        this.__visitor_raycast.setGeometry(geometry);
-        this.__visitor_raycast.setRoot(bvh);
-        this.__visitor_raycast.setRay(
+            stride = position_attribute.data.stride;
+            position_data_offset = position_attribute.offset;
+
+        } else {
+
+            position_data = position_attribute.array;
+
+            stride = 3;
+            position_data_offset = 0;
+
+        }
+
+        return bvh32_geometry_raycast(
+            destination, bvh,
+            position_data, position_data_offset, stride,
+            geometryIndices,
             ray_origin_x,
             ray_origin_y,
             ray_origin_z,
@@ -132,16 +180,6 @@ export class GeometrySpatialQueryAccelerator {
             ray_direction_z
         );
 
-        bvh.traversePreOrderStack(this.__visitor_raycast, 0);
-
-        if (this.__visitor_raycast.isHitFound()) {
-
-            destination.copy(this.__visitor_raycast.getNearestHit());
-
-            return true;
-        } else {
-            return false;
-        }
     }
 
     /**
@@ -169,7 +207,7 @@ export class GeometrySpatialQueryAccelerator {
     /**
      * @private
      * @param {THREE.BufferGeometry} geometry
-     * @returns {IndexedBinaryBVH}
+     * @returns {BinaryUint32BVH}
      */
     __acquireBVH(geometry) {
         assert.notNull(geometry, 'geometry');
@@ -191,7 +229,7 @@ export class GeometrySpatialQueryAccelerator {
     /**
      * @private
      * @param {THREE.BufferGeometry} geometry
-     * @returns {IndexedBinaryBVH}
+     * @returns {BinaryUint32BVH}
      */
     __buildBVH(geometry) {
         const position_attribute = geometry.getAttribute('position');
@@ -200,14 +238,19 @@ export class GeometrySpatialQueryAccelerator {
         const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
         const vertices = de_interleaved_position_attribute.array;
 
+        const bvh = new BinaryUint32BVH();
+
         if (index_attribute === undefined || index_attribute === null) {
-            return buildUnsortedUnindexed(vertices);
-        }
+            bvh32_from_unindexed_geometry(bvh, vertices);
+        } else {
+
+            const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);
+            const indices = de_interleaved_index_attribute.array;
 
-        const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);
-        const indices = de_interleaved_index_attribute.array;
+            bvh32_from_indexed_geometry(bvh, vertices, indices);
+        }
 
-        return buildUnsorted(vertices, indices);
+        return bvh;
     }
 
 }

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js

@@ -0,0 +1,88 @@
+import { assert } from "../../../../../core/assert.js";
+import {
+    bvh32_query_user_data_overlaps_clipping_volume
+} from "../../../../../core/bvh2/binary/2/bvh32_query_user_data_overlaps_clipping_volume.js";
+import {
+    triangle_intersects_clipping_volume
+} from "../../../../../core/geom/3d/triangle/triangle_intersects_clipping_volume.js";
+
+const scratch_array = []
+
+/**
+ *
+ * @param {BinaryUint32BVH} bvh
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number[]|Float32Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @returns {boolean}
+ */
+export function bvh32_geometry_overlap_clipping_volume(
+    bvh,
+    vertices, vertex_offset, vertex_stride,
+    indices,
+    planes, planes_offset, plane_count
+) {
+
+    const hit_count = bvh32_query_user_data_overlaps_clipping_volume(
+        scratch_array, 0,
+        bvh,
+        planes, planes_offset, plane_count
+    );
+
+    let a, b, c;
+
+    for (let i = 0; i < hit_count; i++) {
+        const triangle_index = scratch_array[i];
+
+        const index3 = triangle_index * 3;
+
+        if (indices !== undefined) {
+            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
+            a = indices[index3];
+            b = indices[index3 + 1];
+            c = indices[index3 + 2];
+        } else {
+            // implicit indices
+            a = index3;
+            b = index3 + 1;
+            c = index3 + 2;
+        }
+
+        const a_address = a * vertex_stride + vertex_offset;
+        const b_address = b * vertex_stride + vertex_offset;
+        const c_address = c * vertex_stride + vertex_offset;
+
+        assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
+        assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
+        assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
+
+        const ax = vertices[a_address];
+        const ay = vertices[a_address + 1];
+        const az = vertices[a_address + 2];
+
+        const bx = vertices[b_address];
+        const by = vertices[b_address + 1];
+        const bz = vertices[b_address + 2];
+
+        const cx = vertices[c_address];
+        const cy = vertices[c_address + 1];
+        const cz = vertices[c_address + 2];
+
+        if (triangle_intersects_clipping_volume(
+            planes, planes_offset, plane_count,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        )) {
+            return true;
+        }
+
+    }
+
+    return false;
+}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js

@@ -0,0 +1,108 @@
+import { assert } from "../../../../../core/assert.js";
+import { bvh32_query_user_data_ray } from "../../../../../core/bvh2/binary/2/bvh32_query_user_data_ray.js";
+import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
+import { computeTriangleRayIntersection } from "../../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
+
+const scratch_array = []
+const scratch_hit = new SurfacePoint3()
+
+/**
+ *
+ * @param {SurfacePoint3} result
+ * @param {BinaryUint32BVH} bvh
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number} originX
+ * @param {number} originY
+ * @param {number} originZ
+ * @param {number} directionX
+ * @param {number} directionY
+ * @param {number} directionZ
+ * @returns {boolean}
+ */
+export function bvh32_geometry_raycast(
+    result,
+    bvh,
+    vertices, vertex_offset, vertex_stride,
+    indices,
+    originX, originY, originZ,
+    directionX, directionY, directionZ
+) {
+    let hit_found = false;
+
+    const hit_count = bvh32_query_user_data_ray(
+        scratch_array, 0,
+        bvh,
+        originX, originY, originZ,
+        directionX, directionY, directionZ
+    );
+
+    let best_distance = Infinity;
+
+    let a, b, c;
+
+    for (let i = 0; i < hit_count; i++) {
+        const triangle_index = scratch_array[i];
+
+        const index3 = triangle_index * 3;
+
+        if (indices !== undefined) {
+            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
+            a = indices[index3];
+            b = indices[index3 + 1];
+            c = indices[index3 + 2];
+        } else {
+            // implicit indices
+            a = index3;
+            b = index3 + 1;
+            c = index3 + 2;
+        }
+
+        const a_address = a * vertex_stride + vertex_offset;
+        const b_address = b * vertex_stride + vertex_offset;
+        const c_address = c * vertex_stride + vertex_offset;
+
+        assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
+        assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
+        assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
+
+        const ax = vertices[a_address];
+        const ay = vertices[a_address + 1];
+        const az = vertices[a_address + 2];
+
+        const bx = vertices[b_address];
+        const by = vertices[b_address + 1];
+        const bz = vertices[b_address + 2];
+
+        const cx = vertices[c_address];
+        const cy = vertices[c_address + 1];
+        const cz = vertices[c_address + 2];
+
+        const triangle_hit_found = computeTriangleRayIntersection(
+            scratch_hit,
+            originX, originY, originZ,
+            directionX, directionY, directionZ,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        )
+
+        if (!triangle_hit_found) {
+            continue;
+        }
+
+        hit_found = true;
+
+        const distance_sqr = scratch_hit.position._distanceSqrTo(originX, originY, originZ);
+
+        if (distance_sqr < best_distance) {
+            best_distance = distance_sqr;
+            result.copy(scratch_hit);
+        }
+    }
+
+    return hit_found;
+}

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

@@ -1,5 +1,4 @@
-import { max3 } from "../../../../../core/math/max3.js";
-import { min3 } from "../../../../../core/math/min3.js";
+import { bvh32_set_leaf_from_triangle } from "./bvh32_set_leaf_from_triangle.js";
 
 /**
  *
@@ -23,36 +22,11 @@ export function bvh32_from_indexed_geometry(bvh, vertices, indices) {
         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)
+        bvh32_set_leaf_from_triangle(bvh, i, vertices, iA, iB, iC);
     }
 
     // finalize build
     // bvh.sort_morton(MATRIX_4_IDENTITY);
     bvh.build();
-}
+}
+

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

@@ -0,0 +1,30 @@
+import { bvh32_set_leaf_from_triangle } from "./bvh32_set_leaf_from_triangle.js";
+
+/**
+ *
+ * @param {BinaryUint32BVH} bvh
+ * @param {Float32Array} vertices
+ */
+export function bvh32_from_unindexed_geometry(bvh, vertices) {
+
+    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;
+
+        // generate triangle vertex indices
+        const iA = index3;
+        const iB = index3 + 1;
+        const iC = index3 + 2;
+
+        bvh32_set_leaf_from_triangle(bvh, i, vertices, iA, iB, iC);
+    }
+
+    // finalize build
+    // bvh.sort_morton(MATRIX_4_IDENTITY);
+    bvh.build();
+}

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

@@ -0,0 +1,41 @@
+import { max3 } from "../../../../../core/math/max3.js";
+import { min3 } from "../../../../../core/math/min3.js";
+
+/**
+ *
+ * @param {BinaryUint32BVH} bvh
+ * @param {number} triangle_index
+ * @param {number[]|Float32Array} vertices
+ * @param {number} a_index
+ * @param {number} b_index
+ * @param {number} c_index
+ */
+export function bvh32_set_leaf_from_triangle(bvh, triangle_index, vertices, a_index, b_index, c_index) {
+    const a = a_index * 3;
+    const b = b_index * 3;
+    const c = c_index * 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(triangle_index, triangle_index, x0, y0, z0, x1, y1, z1)
+}

package/src/engine/graphics/material/optimization/prototypeMaterialOptimizer.js

@@ -1,15 +1,12 @@
-import { EngineHarness } from "../../../EngineHarness.js";
-import { EngineConfiguration } from "../../../EngineConfiguration.js";
-import { ShadedGeometrySystem } from "../../ecs/mesh-v2/ShadedGeometrySystem.js";
-import { AttachmentSystem } from "../../../ecs/attachment/AttachmentSystem.js";
-import { TransformAttachmentSystem } from "../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../asset/loaders/GLTFAssetLoader.js";
+import { AttachmentSystem } from "../../../ecs/attachment/AttachmentSystem.js";
+import { TransformAttachmentSystem } from "../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { EngineConfiguration } from "../../../EngineConfiguration.js";
+import { EngineHarness } from "../../../EngineHarness.js";
+import { ShadedGeometrySystem } from "../../ecs/mesh-v2/ShadedGeometrySystem.js";
 import { three_object_to_entity_composition } from "../../ecs/mesh-v2/three_object_to_entity_composition.js";
 import { MaterialOptimizationContext } from "./MaterialOptimizationContext.js";
-import {
-    bvh_traverse_pre_order_using_stack
-} from "../../../../core/bvh2/traversal/bvh_traverse_pre_order_using_stack.js";
 
 const eh = new EngineHarness();
 
@@ -23,17 +20,17 @@ function optimize(engine) {
 
     const optimizer = new MaterialOptimizationContext();
 
-    engine.graphics.layers.layers.forEach(l => {
-        bvh_traverse_pre_order_using_stack(l.bvh, node => {
-            if (node.isLeafNode) {
-                const object = l.extractRenderable(node.object);
-
-                if (object) {
-                    optimizer.addObject(object);
-                }
-            }
-        });
-    });
+    // engine.graphics.layers.layers.forEach(l => {
+    //     bvh_traverse_pre_order_using_stack(l.bvh, node => {
+    //         if (node.isLeafNode) {
+    //             const object = l.extractRenderable(node.object);
+    //
+    //             if (object) {
+    //                 optimizer.addObject(object);
+    //             }
+    //         }
+    //     });
+    // });
 
     optimizer.update();
 

package/src/engine/graphics/render/forward_plus/LightManager.js

@@ -26,7 +26,7 @@ import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
 import { arraySwapElements } from "../../../../core/collection/array/arraySwapElements.js";
 import { read_cluster_frustum_corners } from "../../../../core/geom/3d/frustum/read_cluster_frustum_corners.js";
-import { read_frustum_planes_to_array } from "../../../../core/geom/3d/frustum/read_frustum_planes_to_array.js";
+import { read_three_planes_to_array } from "../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
 import { slice_frustum_linear_to_points } from "../../../../core/geom/3d/frustum/slice_frustum_linear_to_points.js";
 import { v3_morton_encode_transformed } from "../../../../core/geom/3d/morton/v3_morton_encode_transformed.js";
 import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
@@ -727,7 +727,7 @@ export class LightManager {
 
         const nodes = [];
 
-        read_frustum_planes_to_array(this.__view_frustum.planes, scratch_frustum_planes)
+        read_three_planes_to_array(this.__view_frustum.planes, scratch_frustum_planes)
 
         /*
         Search is done in 2 phases: