@woosh/meep-engine 2.43.18 → 2.43.19

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -5,10 +5,10 @@ import { assert } from "../../assert.js";
 import { typed_array_copy } from "../../collection/array/typed/typed_array_copy.js";
 import { array_copy } from "../../collection/array/copyArray.js";
 
-const COLUMN_PARENT = 6;
+export const COLUMN_PARENT = 6;
 export const COLUMN_CHILD_1 = 7;
 export const COLUMN_CHILD_2 = 8;
-const COLUMN_HEIGHT = 9;
+export const COLUMN_HEIGHT = 9;
 
 /**
  * A non-leaf node have both CHILD_1 and CHILD_2 set, when CHILD_1 is not set - it's a leaf node
@@ -281,6 +281,15 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_CHILD_1];
     }
 
+    /**
+     *
+     * @param {number} node
+     * @param {number} child1
+     */
+    node_set_child1(node, child1) {
+        this.__data_uint32[ELEMENT_WORD_COUNT * node + COLUMN_CHILD_1] = child1;
+    }
+
     /**
      *
      * @param {number} id
@@ -291,6 +300,54 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_CHILD_2];
     }
 
+    /**
+     *
+     * @param {number} node
+     * @param {number} child2
+     */
+    node_set_child2(node, child2) {
+        this.__data_uint32[ELEMENT_WORD_COUNT * node + COLUMN_CHILD_2] = child2;
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_parent(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_PARENT];
+    }
+
+    /**
+     *
+     * @param {number} node
+     * @param {number} parent
+     */
+    node_set_parent(node, parent) {
+        this.__data_uint32[ELEMENT_WORD_COUNT * node + COLUMN_PARENT] = parent;
+    }
+
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_height(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_HEIGHT];
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} height
+     */
+    node_set_height(id, height) {
+        assert.isNonNegativeInteger(id, 'id');
+        this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_HEIGHT] = height;
+    }
 
     /**
      *
@@ -1046,119 +1103,5 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
         return true;
     }
-
-
-    /**
-     * Sort live nodes in the traversal order.
-     * This makes most queries have linear access, resulting in near-optimal cache usage
-     * NOTE: assumes that there are no free nodes
-     */
-    sort_for_traversal_depth_first() {
-        const stack = [];
-
-        stack[0] = 0;
-        stack[1] = this.__size - 1;
-
-        let stack_pointer = 2;
-        let i, j;
-
-        const uint32 = this.__data_uint32;
-        const float32 = this.__data_float32;
-
-        while (stack_pointer > 0) {
-            stack_pointer -= 2;
-
-            const right = stack[stack_pointer + 1];
-            const left = stack[stack_pointer];
-
-            i = left;
-            j = right;
-
-            const pivotIndex = (left + right) >> 1;
-
-            /* partition */
-            while (i <= j) {
-
-                while (traversal_sort_compare_nodes(uint32, float32, i, pivotIndex) > 0) {
-                    i++;
-                }
-
-                while (traversal_sort_compare_nodes(uint32, float32, j, pivotIndex) < 0) {
-                    j--;
-                }
-
-                if (i <= j) {
-
-                    if (i !== j) {
-                        //do swap
-                        this.swap_nodes(i, j);
-                    }
-
-                    i++;
-                    j--;
-                }
-            }
-
-            /* recursion */
-            if (left < j) {
-                stack[stack_pointer++] = left;
-                stack[stack_pointer++] = j;
-            }
-            if (i < right) {
-                stack[stack_pointer++] = i;
-                stack[stack_pointer++] = right;
-            }
-        }
-    }
 }
 
-/**
- *
- * @param {Uint32Array} uint32
- * @param {number} node_index
- * @return {number}
- */
-function compute_traversal_index_upper_bound(uint32, node_index) {
-    let n = node_index;
-
-    let parent = uint32[node_index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
-
-    let result = 0;
-    let x = 0;
-
-    while (parent !== NULL_NODE) {
-
-        if (uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === n) {
-            result += Math.pow(2, x);
-        }
-
-        x++;
-
-        n = parent;
-        parent = uint32[n * ELEMENT_WORD_COUNT + COLUMN_PARENT];
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {Uint32Array} uint32
- * @param {Float32Array} float32
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-function traversal_sort_compare_nodes(uint32, float32, a, b) {
-    const a_height = uint32[a * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
-    const b_height = uint32[b * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
-
-    const height_delta = a_height - b_height;
-
-    if (height_delta !== 0) {
-        return height_delta;
-    }
-
-    return compute_traversal_index_upper_bound(uint32, a) - compute_traversal_index_upper_bound(uint32, b);
-
-}

package/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js

@@ -0,0 +1,34 @@
+import { min2 } from "../../math/min2.js";
+import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
+
+/**
+ * Build the BVH by relying on BVH's own incremental insertion mechanism
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|Float32Array} index_array
+ * @param {number[]|Float32Array} positions_array
+ * @param {number} [batch_size] can batch triangles in groups of up-to this many triangles per BVH leaf
+ */
+export function ebvh_build_for_geometry_incremental(bvh, index_array, positions_array, batch_size = 1) {
+    bvh.release_all();
+    const triangle_count = index_array.length / 3;
+
+    const leaf_node_count = Math.ceil(triangle_count / batch_size);
+
+    const leaf_aabb = [];
+
+    for (let i = 0; i < leaf_node_count; i++) {
+
+        const index_start = i * batch_size;
+        const index_end = min2(triangle_count, index_start + batch_size);
+
+        const group_size = index_end - index_start;
+
+        compute_triangle_group_aabb3(leaf_aabb, 0, index_array, positions_array, index_start * 3, group_size, 3);
+
+        const node_index = bvh.allocate_node();
+        bvh.node_set_aabb(node_index, leaf_aabb);
+        bvh.node_set_user_data(node_index, i);
+
+        bvh.insert_leaf(node_index);
+    }
+}

package/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -0,0 +1,175 @@
+import { AABB3 } from "../aabb3/AABB3.js";
+import { aabb3_from_v3_array } from "../aabb3/aabb3_from_v3_array.js";
+import morton from "../../geom/3d/morton/Morton.js";
+import { arrayQuickSort } from "../../collection/array/arrayQuickSort.js";
+import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ * Build the BVH bottom-up using spatial hash sorting
+ * Resulting BVH is produced very quickly, has perfect balance and is of decent quality
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|Float32Array} index_array
+ * @param {number[]|Float32Array} position_array
+ */
+export function ebvh_build_for_geometry_morton(bvh, index_array, position_array) {
+    // clear out existing BVH
+    bvh.release_all();
+
+    const aabb3 = new AABB3();
+
+    // get bounds for the entire geometry
+    aabb3_from_v3_array(aabb3, position_array, position_array.length);
+
+    const aabb_x0 = aabb3.x0;
+    const aabb_y0 = aabb3.y0;
+    const aabb_z0 = aabb3.z0;
+
+    const aabb_size_x = aabb3.getExtentsX();
+    const aabb_size_y = aabb3.getExtentsY();
+    const aabb_size_z = aabb3.getExtentsZ();
+
+    const morton_scale_x = aabb_size_x === 0 ? 0 : 1023 / aabb_size_x;
+    const morton_scale_y = aabb_size_y === 0 ? 0 : 1023 / aabb_size_y;
+    const morton_scale_z = aabb_size_z === 0 ? 0 : 1023 / aabb_size_z;
+
+    // allocate nodes
+    const tri_count = index_array.length / 3;
+    const node_leaf_count = tri_count;
+    const node_bin_count = Math.ceil(node_leaf_count / 2) * 2 - 1;
+
+    const node_total_count = node_leaf_count + node_bin_count;
+
+    const nodes = new Uint32Array(node_total_count);
+
+    // skip allocation calls, allocate exactly as many nodes as we need
+    bvh.__set_capacity(node_total_count);
+    bvh.__size = node_total_count;
+
+    for (let i = 0; i < node_total_count; i++) {
+        // store nodes in reverse order so that top-level nodes end up on top
+        nodes[i] = (node_total_count - 1) - i;
+    }
+
+    // for (let i = node_total_count - 1; i >= 0; i--) {
+    //     // store nodes in reverse order so that top-level nodes end up on top
+    //     nodes[i] = bvh.allocate_node();
+    // }
+
+    const morton_codes = new Uint32Array(tri_count);
+    const sorted_triangle_order = new Uint32Array(tri_count);
+
+    // compute morton codes
+    for (let i = 0; i < tri_count; i++) {
+
+        sorted_triangle_order[i] = i;
+
+        const i3 = i * 3;
+
+        const a = index_array[i3];
+        const b = index_array[i3 + 1];
+        const c = index_array[i3 + 2];
+
+        const a_address = a * 3;
+        const ax = position_array[a_address];
+        const ay = position_array[a_address + 1];
+        const az = position_array[a_address + 2];
+
+        const b_address = b * 3;
+        const bx = position_array[b_address];
+        const by = position_array[b_address + 1];
+        const bz = position_array[b_address + 2];
+
+        const c_address = c * 3;
+        const cx = position_array[c_address];
+        const cy = position_array[c_address + 1];
+        const cz = position_array[c_address + 2];
+
+        const center_x = (ax + bx + cx) * 0.333333333;
+        const center_y = (ay + by + cy) * 0.333333333;
+        const center_z = (az + bz + cz) * 0.333333333;
+
+
+        // normalize to bounds
+        const ncx = (center_x - aabb_x0) * morton_scale_x;
+        const ncy = (center_y - aabb_y0) * morton_scale_y;
+        const ncz = (center_z - aabb_z0) * morton_scale_z;
+
+        const morton_code = morton(
+            Math.round(ncx),
+            Math.round(ncy),
+            Math.round(ncz)
+        );
+
+        morton_codes[i] = morton_code;
+    }
+
+    // sort leaves by morton codes
+    arrayQuickSort(sorted_triangle_order, (triangle_index) => morton_codes[triangle_index], null, 0, tri_count - 1);
+
+    let used_index = 0;
+    const unprocessed_nodes = new Uint32Array(tri_count);
+    // assign leaves
+    const aabb_array = new Float32Array(6);
+    for (let i = 0; i < tri_count; i++) {
+        const node = nodes[used_index++];
+
+        const triangle_index = sorted_triangle_order[i];
+
+        bvh.node_set_child1(node, NULL_NODE);
+        bvh.node_set_user_data(node, triangle_index);
+
+        bvh.node_set_height(node, 0);
+
+        compute_triangle_group_aabb3(aabb_array, 0, index_array, position_array, triangle_index * 3, 1, 3);
+
+        bvh.node_set_aabb(node, aabb_array);
+
+        unprocessed_nodes[i] = node;
+    }
+
+    // Assemble hierarchy
+    let unprocessed_node_count = tri_count;
+
+
+    while (used_index < node_total_count) {
+
+        let added_nodes = 0;
+        let cursor = 0;
+
+        while (cursor + 1 < unprocessed_node_count) {
+            const child_1 = unprocessed_nodes[cursor++];
+            const child_2 = unprocessed_nodes[cursor++];
+
+            const parent = nodes[used_index++];
+
+            bvh.node_set_combined_aabb(parent, child_1, child_2);
+
+            bvh.node_set_parent(child_1, parent);
+            bvh.node_set_parent(child_2, parent);
+
+            bvh.node_set_child1(parent, child_1);
+            bvh.node_set_child2(parent, child_2);
+
+            bvh.node_set_height(parent,
+                1 + max2(
+                    bvh.node_get_height(child_1),
+                    bvh.node_get_height(child_2)
+                )
+            );
+
+            unprocessed_nodes[added_nodes++] = parent;
+        }
+
+        while (cursor < unprocessed_node_count) {
+            // dangling nodes, push them onto the next level
+            unprocessed_nodes[added_nodes++] = unprocessed_nodes[cursor++];
+        }
+
+        unprocessed_node_count = added_nodes;
+    }
+
+    // assign root
+    bvh.__root = nodes[nodes.length - 1];
+}

package/core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js

@@ -0,0 +1,122 @@
+import {
+    COLUMN_CHILD_1,
+    COLUMN_HEIGHT,
+    COLUMN_PARENT,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+
+/**
+ * Sort live nodes in the traversal order.
+ * This makes most queries have linear access, resulting in near-optimal cache usage
+ * NOTE: assumes that there are no free nodes
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ */
+export function ebvh_sort_for_traversal_depth_first(bvh) {
+    const stack = [];
+
+    stack[0] = 0;
+    stack[1] = bvh.__size - 1;
+
+    let stack_pointer = 2;
+    let i, j;
+
+    const uint32 = bvh.__data_uint32;
+    const float32 = bvh.__data_float32;
+
+    while (stack_pointer > 0) {
+        stack_pointer -= 2;
+
+        const right = stack[stack_pointer + 1];
+        const left = stack[stack_pointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        /* partition */
+        while (i <= j) {
+
+            while (traversal_sort_compare_nodes(uint32, float32, i, pivotIndex) > 0) {
+                i++;
+            }
+
+            while (traversal_sort_compare_nodes(uint32, float32, j, pivotIndex) < 0) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    bvh.swap_nodes(i, j);
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack[stack_pointer++] = left;
+            stack[stack_pointer++] = j;
+        }
+        if (i < right) {
+            stack[stack_pointer++] = i;
+            stack[stack_pointer++] = right;
+        }
+    }
+}
+
+/**
+ *
+ * @param {Uint32Array} uint32
+ * @param {number} node_index
+ * @return {number}
+ */
+function compute_traversal_index_upper_bound(uint32, node_index) {
+    let n = node_index;
+
+    let parent = uint32[node_index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+
+    let result = 0;
+    let x = 0;
+
+    while (parent !== NULL_NODE) {
+
+        if (uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === n) {
+            result += Math.pow(2, x);
+        }
+
+        x++;
+
+        n = parent;
+        parent = uint32[n * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {Uint32Array} uint32
+ * @param {Float32Array} float32
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function traversal_sort_compare_nodes(uint32, float32, a, b) {
+    const a_height = uint32[a * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
+    const b_height = uint32[b * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
+
+    const height_delta = a_height - b_height;
+
+    if (height_delta !== 0) {
+        return height_delta;
+    }
+
+    return compute_traversal_index_upper_bound(uint32, a) - compute_traversal_index_upper_bound(uint32, b);
+
+}

package/core/bvh2/bvh3/{bvh_collect_user_data.js → query/bvh_collect_user_data.js}

@@ -1,6 +1,6 @@
 //
 
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.d.ts";
 
 const traversal_stack = [];
 /**

package/core/bvh2/bvh3/{bvh_query_leaves_generic.js → query/bvh_query_leaves_generic.js}

@@ -1,4 +1,4 @@
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 
 /**
  *

package/core/bvh2/bvh3/{bvh_query_leaves_ray.js → query/bvh_query_leaves_ray.js}

@@ -1,10 +1,10 @@
-import { aabb3_intersects_ray } from "../aabb3/aabb3_intersects_ray.js";
+import { aabb3_intersects_ray } from "../../aabb3/aabb3_intersects_ray.js";
 import {
     COLUMN_CHILD_1,
     COLUMN_CHILD_2,
     ELEMENT_WORD_COUNT,
     NULL_NODE
-} from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+} from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 
 /**
  *
@@ -93,6 +93,5 @@ export function bvh_query_leaves_ray(
         }
     } while (traversal_cursor > 0);
 
-    // drop stack frame
     return result_cursor - result_offset;
 }

package/core/bvh2/bvh3/{bvh_query_user_data_generic.js → query/bvh_query_user_data_generic.js}

@@ -1,4 +1,4 @@
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 
 /**
  *

package/core/bvh2/bvh3/{bvh_query_user_data_nearest_to_point.js → query/bvh_query_user_data_nearest_to_point.js}

@@ -1,6 +1,6 @@
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
-import { aabb3_signed_distance_sqr_to_point } from "../aabb3/aabb3_signed_distance_sqr_to_point.js";
-import { max2 } from "../../math/max2.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { aabb3_signed_distance_sqr_to_point } from "../../aabb3/aabb3_signed_distance_sqr_to_point.js";
+import { max2 } from "../../../math/max2.js";
 
 /**
  *

package/core/bvh2/bvh3/{bvh_query_user_data_nearest_to_point.spec.js → query/bvh_query_user_data_nearest_to_point.spec.js}

@@ -1,4 +1,4 @@
-import { ExplicitBinaryBoundingVolumeHierarchy } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { bvh_query_user_data_nearest_to_point } from "./bvh_query_user_data_nearest_to_point.js";
 
 /**

package/core/bvh2/bvh3/{bvh_query_user_data_overlaps_frustum.js → query/bvh_query_user_data_overlaps_frustum.js}

@@ -1,6 +1,6 @@
 //
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
-import { aabb3_array_intersects_frustum_degree } from "../aabb3/aabb3_array_intersects_frustum_degree.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { aabb3_array_intersects_frustum_degree } from "../../aabb3/aabb3_array_intersects_frustum_degree.js";
 import { bvh_collect_user_data } from "./bvh_collect_user_data.js";
 
 const traversal_stack = [];

package/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js

@@ -4,7 +4,7 @@
 import { array_copy } from "../../../collection/array/copyArray.js";
 import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { aabb3_array_intersects_frustum_degree } from "../../aabb3/aabb3_array_intersects_frustum_degree.js";
-import { bvh_collect_user_data } from "../bvh_collect_user_data.js";
+import { bvh_collect_user_data } from "./bvh_collect_user_data.js";
 import { v3_distance_above_plane } from "../../../geom/v3_distance_above_plane.js";
 
 const traversal_stack = [];

package/core/collection/array/arrayQuickSort.js

@@ -4,7 +4,7 @@ const stack = [];
 
 /**
  * @template T
- * @param {T[]} data
+ * @param {T[]|ArrayLike<number>|Uint32Array} data
  * @param {function(T):number} score_function
  * @param {*} score_function_context
  * @param {number} start

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -11,7 +11,7 @@ import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_comp
 import {
     ExplicitBinaryBoundingVolumeHierarchy
 } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
-import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/bvh_query_leaves_generic.js";
+import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
 import { BVHQueryIntersectsRay } from "../../../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
 import Task from "../../../../core/process/task/Task.js";
 import { RuntimeDrawMethodOptimizer } from "./render/optimization/RuntimeDrawMethodOptimizer.js";
@@ -19,7 +19,7 @@ import { TaskSignal } from "../../../../core/process/task/TaskSignal.js";
 import TaskState from "../../../../core/process/task/TaskState.js";
 import {
     bvh_query_user_data_overlaps_frustum
-} from "../../../../core/bvh2/bvh3/bvh_query_user_data_overlaps_frustum.js";
+} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 
 
 /**

package/engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js

@@ -7,6 +7,14 @@ export const SGMeshFlags = {
     Loaded: 4
 };
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_FLAGS = SGMeshFlags.CastShadow
+    | SGMeshFlags.ReceiveShadow
+;
+
 export class SGMesh {
     constructor() {
         /**
@@ -33,7 +41,7 @@ export class SGMesh {
          *
          * @type {number}
          */
-        this.flags = 0;
+        this.flags = DEFAULT_FLAGS;
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/render/ShadedGeometryRendererContext.js

@@ -5,7 +5,7 @@ import { assert } from "../../../../../core/assert.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";
 import {
     bvh_query_user_data_overlaps_frustum
-} from "../../../../../core/bvh2/bvh3/bvh_query_user_data_overlaps_frustum.js";
+} from "../../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
 
 /**

package/engine/graphics/render/forward_plus/model/DirectionalLight.js

@@ -0,0 +1,40 @@
+import { AbstractLight } from "./AbstractLight.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { Color } from "../../../../../core/color/Color.js";
+import Vector1 from "../../../../../core/geom/Vector1.js";
+
+export class DirectionalLight extends AbstractLight {
+constructor() {
+    super();
+
+    /**
+     *
+     * @type {Vector3}
+     */
+    this.position = new Vector3();
+
+    /**
+     *
+     * @type {Vector3}
+     */
+    this.direction = new Vector3();
+
+    /**
+     * @readonly
+     * @type {Color}
+     */
+    this.color = new Color(1, 1, 1);
+
+    /**
+     *
+     * @type {Vector1}
+     */
+    this.intensity = new Vector1(1);
+}
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+DirectionalLight.prototype.isDirectionalLight = true;

package/engine/graphics/sh3/path_tracer/GeometryBVHBatched.js

@@ -1,13 +1,12 @@
 import {
     ExplicitBinaryBoundingVolumeHierarchy
 } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { compute_triangle_group_aabb3 } from "./compute_triangle_group_aabb3.js";
-import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/bvh_query_leaves_ray.js";
+import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
 import { aabb3_signed_distance_sqr_to_point } from "../../../../core/bvh2/aabb3/aabb3_signed_distance_sqr_to_point.js";
 import {
     computeTriangleRayIntersectionBarycentric
 } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
+import { ebvh_build_for_geometry_morton } from "../../../../core/bvh2/bvh3/ebvh_build_for_geometry_morton.js";
 
 /**
  *
@@ -19,10 +18,10 @@ const leaf_buffer = [];
  * @type {number[]}
  */
 const v3_scratch_0 = [];
-const BVH_BATCH_SIZE = 1;
 
 const temp_aabb3 = new Float32Array(6);
 
+
 export class GeometryBVHBatched {
     constructor() {
         /**
@@ -69,10 +68,6 @@ export class GeometryBVHBatched {
     build(geometry) {
         this.__geometry = geometry;
 
-        const bvh = this.__bvh;
-
-        bvh.release_all();
-
         const index = geometry.getIndex();
         const index_array = index.array;
 
@@ -83,32 +78,15 @@ export class GeometryBVHBatched {
         this.__geometry_positions = array_positions;
         this.__geometry_index = index_array;
 
-        const triangle_count = index_array.length / 3;
-
-        this.__triangle_count = triangle_count;
-
-        const leaf_node_count = Math.ceil(triangle_count / BVH_BATCH_SIZE);
-
-        const leaf_aabb = [];
-
-        for (let i = 0; i < leaf_node_count; i++) {
+        this.__triangle_count = index_array.length / 3;
 
-            const index_start = i * BVH_BATCH_SIZE;
-            const index_end = min2(triangle_count, index_start + BVH_BATCH_SIZE);
-
-            const group_size = index_end - index_start;
-
-            compute_triangle_group_aabb3(leaf_aabb, 0, index_array, array_positions, index_start * 3, group_size, 3);
-
-            const node_index = bvh.allocate_node();
-            bvh.node_set_aabb(node_index, leaf_aabb);
-            bvh.node_set_user_data(node_index, i);
+        const bvh = this.__bvh;
 
-            bvh.insert_leaf(node_index);
-        }
+        ebvh_build_for_geometry_morton(bvh, index_array, array_positions);
+        //
+        // ebvh_build_for_geometry_incremental(bvh, index_array, array_positions, 1);
 
         bvh.trim();
-        bvh.sort_for_traversal_depth_first();
     }
 
     /**
@@ -119,7 +97,7 @@ export class GeometryBVHBatched {
      * @param {number} u
      * @param {number} v
      */
-    construct_output(output, face_index, t, u, v) {
+    construct_ray_hit(output, face_index, t, u, v) {
         const indices = this.__geometry_index;
         const positions = this.__geometry_positions;
 
@@ -129,7 +107,6 @@ export class GeometryBVHBatched {
         const b = indices[index_offset + 1];
         const c = indices[index_offset + 2];
 
-
         const a_address = a * 3;
         const b_address = b * 3;
         const c_address = c * 3;
@@ -146,15 +123,7 @@ export class GeometryBVHBatched {
         const cy = positions[c_address + 1];
         const cz = positions[c_address + 2];
 
-        // read out interpolated buffer values
-        // const w = 1 - u - v;
-
-        // output[0] = ax * u + bx * v + cx * w;
-        // output[1] = ay * u + by * v + cy * w;
-        // output[2] = az * u + bz * v + cz * w;
-
         // normal
-        // v3_compute_triangle_normal(output, 3, ax, ay, ax, bx, by, bz, cx, cy, cz);
 
         // edge1 = a - b
         const edge1_x = bx - ax;
@@ -173,7 +142,6 @@ export class GeometryBVHBatched {
         const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
         const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
 
-
         output[3] = normal_x;
         output[4] = normal_y;
         output[5] = normal_z;
@@ -207,6 +175,7 @@ export class GeometryBVHBatched {
 
         const bvh = this.__bvh;
 
+        // TODO we can unify BVH traversal with ray checks to reduce number of checks
         const count = bvh_query_leaves_ray(
             bvh, leaf_buffer, 0,
             origin_x, origin_y, origin_z,
@@ -220,18 +189,13 @@ export class GeometryBVHBatched {
         let best_v = 0;
 
         for (let i = 0; i < count; i++) {
-            const leaf_node_id = leaf_buffer[i];
-
-            const triangle_batch_index = bvh.node_get_user_data(leaf_node_id);
+            const node_id = leaf_buffer[i];
 
-            const index_start = triangle_batch_index * BVH_BATCH_SIZE;
-
-            const index_end = min2(index_start + BVH_BATCH_SIZE, this.__triangle_count);
 
             if (best_t < max_distance) {
                 // early bail-out
 
-                bvh.node_get_aabb(leaf_node_id, temp_aabb3);
+                bvh.node_get_aabb(node_id, temp_aabb3);
 
                 const distance = aabb3_signed_distance_sqr_to_point(temp_aabb3[0], temp_aabb3[1], temp_aabb3[2], temp_aabb3[3], temp_aabb3[4], temp_aabb3[5], ray[0], ray[1], ray[2]);
 
@@ -241,71 +205,48 @@ export class GeometryBVHBatched {
                 }
             }
 
-            for (let j = index_start; j < index_end; j++) {
-                const index_offset = j * 3;
-
-                const a = indices[index_offset];
-                const b = indices[index_offset + 1];
-                const c = indices[index_offset + 2];
-
-
-                const a_address = a * 3;
-                const b_address = b * 3;
-                const c_address = c * 3;
-
-
-                const ax = positions[a_address];
-                const ay = positions[a_address + 1];
-                const az = positions[a_address + 2];
-
-                const bx = positions[b_address];
-                const by = positions[b_address + 1];
-                const bz = positions[b_address + 2];
-
-                const cx = positions[c_address];
-                const cy = positions[c_address + 1];
-                const cz = positions[c_address + 2];
-
-                // const sp3 = new SurfacePoint3();
-                //
-                // const intersection_found = computeTriangleRayIntersection(
-                //     sp3,
-                //     origin_x, origin_y, origin_z,
-                //     direction_x, direction_y, direction_z,
-                //     ax, ay, az,
-                //     bx, by, bz,
-                //     cx, cy, cz);
-                //
-                // v3_scratch_0[0] = sp3.position.distanceTo(new Vector3(origin_x, origin_y, origin_z));
-
-                const intersection_found = computeTriangleRayIntersectionBarycentric(
-                    v3_scratch_0,
-                    origin_x, origin_y, origin_z,
-                    direction_x, direction_y, direction_z,
-                    ax, ay, az,
-                    bx, by, bz,
-                    cx, cy, cz
-                );
-
-                if (intersection_found && v3_scratch_0[0] < best_t && v3_scratch_0[0] > min_distance) {
-                    best_t = v3_scratch_0[0];
-
-                    best_index = j;
-                    best_u = v3_scratch_0[1];
-                    best_v = v3_scratch_0[2];
-
-
-                    // output[0] = v3_scratch_0[0];
-                    // output[1] = v3_scratch_0[1];
-                    // output[2] = v3_scratch_0[2];
-                    //
-                    // output[3] = v3_scratch_0[3];
-                    // output[4] = v3_scratch_0[4];
-                    // output[5] = v3_scratch_0[5];
-
-                    // uv
-                    //TODO
-                }
+            const triangle_index = bvh.node_get_user_data(node_id);
+
+            const index_offset = triangle_index * 3;
+
+            const a = indices[index_offset];
+            const b = indices[index_offset + 1];
+            const c = indices[index_offset + 2];
+
+
+            const a_address = a * 3;
+            const b_address = b * 3;
+            const c_address = c * 3;
+
+
+            const ax = positions[a_address];
+            const ay = positions[a_address + 1];
+            const az = positions[a_address + 2];
+
+            const bx = positions[b_address];
+            const by = positions[b_address + 1];
+            const bz = positions[b_address + 2];
+
+            const cx = positions[c_address];
+            const cy = positions[c_address + 1];
+            const cz = positions[c_address + 2];
+
+            const intersection_found = computeTriangleRayIntersectionBarycentric(
+                v3_scratch_0,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z,
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
+            );
+
+            if (intersection_found && v3_scratch_0[0] < best_t && v3_scratch_0[0] > min_distance) {
+                best_t = v3_scratch_0[0];
+
+                best_index = triangle_index;
+                best_u = v3_scratch_0[1];
+                best_v = v3_scratch_0[2];
+
             }
         }
 
@@ -317,7 +258,7 @@ export class GeometryBVHBatched {
         output[1] = origin_y + direction_y * best_t;
         output[2] = origin_z + direction_z * best_t;
 
-        this.construct_output(output, best_index, best_t, best_u, best_v);
+        this.construct_ray_hit(output, best_index, best_t, best_u, best_v);
 
         return best_t;
     }

package/engine/graphics/sh3/path_tracer/PathTracer.js

@@ -1,7 +1,7 @@
 import {
     ExplicitBinaryBoundingVolumeHierarchy
 } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
-import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/bvh_query_leaves_ray.js";
+import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import { mat4, vec3 } from "gl-matrix";
@@ -25,6 +25,12 @@ import { sample_triangle_attribute } from "./sample_triangle_attribute.js";
 import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
 import { make_sky_rtiw } from "./make_sky_rtiw.js";
 import { apply_texture_clamping_to_coordinate } from "./apply_texture_clamping_to_coordinate.js";
+import { ebvh_sort_for_traversal_depth_first } from "../../../../core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+import { v3_dot } from "../../../../core/geom/v3_dot.js";
+import { LightType } from "../../ecs/light/LightType.js";
+import { make_zero_vector3 } from "./make_zero_vector3.js";
+import { make_one_vector3 } from "./make_one_vector3.js";
 
 /*
  Ray hit data layout:
@@ -47,7 +53,8 @@ const trace_result = [];
 
 const _ray = [];
 
-const tmp = [];
+const tmp_0 = [];
+const tmp_1 = [];
 
 
 export class PathTracer {
@@ -67,9 +74,9 @@ export class PathTracer {
 
         /**
          *
-         * @type {Map<number, Light>}
+         * @type {AbstractLight[]}
          */
-        this.lights = new Map();
+        this.__lights = [];
 
         /**
          *
@@ -88,7 +95,7 @@ export class PathTracer {
          * @type {function}
          * @private
          */
-        this.__background_sampler = make_sky_rtiw();
+        this.__background_sampler = make_one_vector3();
     }
 
     /**
@@ -114,7 +121,7 @@ export class PathTracer {
 
     optimize() {
         this.bvh_top_level.trim();
-        this.bvh_top_level.sort_for_traversal_depth_first();
+        ebvh_sort_for_traversal_depth_first(this.bvh_top_level);
     }
 
     async build() {
@@ -155,6 +162,14 @@ export class PathTracer {
         }
     }
 
+    /**
+     *
+     * @param {THREE.Light} light
+     */
+    addLight(light) {
+        this.__lights.push(light);
+    }
+
     /**
      *
      * @param {THREE.BufferGeometry} geo
@@ -366,14 +381,14 @@ export class PathTracer {
 
             const mesh = this.meshes.get(node_user_data);
 
-            const distance_to_hit = mesh.hit(tmp, ray, min_distance, nearest_hit_distance);
+            const distance_to_hit = mesh.hit(tmp_0, ray, min_distance, nearest_hit_distance);
 
             if (distance_to_hit >= 0) {
                 // since raycast in leaf nodes is already bound by maximum distance, any hit we get is necessarily a closer hit than before
                 nearest_hit_distance = distance_to_hit;
                 nearest_mesh = mesh;
 
-                array_copy(tmp, 0, out, 0, 11);
+                array_copy(tmp_0, 0, out, 0, 11);
             }
         }
 
@@ -395,9 +410,53 @@ export class PathTracer {
      * @param {number} direction_offset
      */
     sample_background(out, out_offset, direction, direction_offset) {
+        this.__background_sampler(out, out_offset, direction, direction_offset);
+    }
 
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number[]} hit_info
+     * @param {number} hit_info_address
+     */
+    sample_lights(out, out_offset, hit_info, hit_info_address) {
+        let lights_sampled = false;
 
-        this.__background_sampler(out, out_offset, direction, direction_offset);
+        const lights = this.__lights;
+        const light_count = lights.length;
+
+        for (let i = 0; i < 3; i++) {
+            out[out_offset + i] = 0;
+        }
+
+        for (let i = 0; i < light_count; i++) {
+            const light = lights[i];
+
+            if (light.isDirectionalLight === true) {
+                const dir = light.direction;
+
+                // check if there are any obstacles in the direction of the light
+                if (this.trace([], [
+                    hit_info[hit_info_address + 0],
+                    hit_info[hit_info_address + 1],
+                    hit_info[hit_info_address + 2],
+                    -dir.x, -dir.y, -dir.z
+                ], 0.0001, Infinity) > 0) {
+                    // light is occluded
+                    break;
+                }
+
+                const dotNL = clamp01(v3_dot(hit_info[hit_info_address + 3], hit_info[hit_info_address + 4], hit_info[hit_info_address + 5], -dir.x, -dir.y, -dir.z));
+
+                for (let j = 0; j < 3; j++) {
+                    // irradiance
+                    out[out_offset + j] += dotNL * light.color[j] * light.intensity.getValue();
+                }
+            }
+        }
+
+        return lights_sampled;
     }
 
     path_trace(out, ray, max_distance, max_bounce, random = Math.random) {
@@ -405,9 +464,9 @@ export class PathTracer {
 
         array_copy(ray, 0, _ray, 0, 6);
 
-        irradiance[0] = 1;
-        irradiance[1] = 1;
-        irradiance[2] = 1;
+        irradiance[0] = 0;
+        irradiance[1] = 0;
+        irradiance[2] = 0;
 
         let got_emission = false;
 
@@ -421,9 +480,9 @@ export class PathTracer {
 
                 // sample "environment" and terminate path as there is nothing to reflect off of
 
-                this.sample_background(tmp, 0, _ray, 3);
+                this.sample_background(tmp_0, 0, _ray, 3);
 
-                vec3.multiply(irradiance, irradiance, tmp);
+                vec3.multiply(irradiance, irradiance, tmp_0);
 
                 got_emission = true;
 
@@ -434,16 +493,22 @@ export class PathTracer {
             // irradiance[0] += m;
             // irradiance[1] += m;
             // irradiance[2] += m;
-            this.sample_material(tmp, trace_result);
+            this.sample_material(tmp_0, trace_result);
+
+            // adjust normal on the hit
+            // array_copy(tmp_0, 3, trace_result, 3, 3);
+
+            // sample light
+            this.sample_lights(tmp_1, 0, trace_result, 0);
+            vec3.add(irradiance, irradiance, tmp_1);
 
             // reflect ray
             array_copy(trace_result, 0, _ray, 0, 3);
 
             // getBiasedNormalSample(_ray, 3, tmp, 3, 1, random);
-            random_in_hemisphere(random, _ray, 3, tmp, 3);
-
-            vec3.multiply(irradiance, irradiance, tmp);
+            random_in_hemisphere(random, _ray, 3, tmp_0, 3);
 
+            vec3.multiply(irradiance, irradiance, tmp_0);
         }
 
         if (got_emission === false) {

package/engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js

@@ -3,7 +3,7 @@ import { max2 } from "../../../../core/math/max2.js";
 
 /**
  * Compute AABB for a group of triangles based on index-buffer
- * @param {number[]} output
+ * @param {number[]|Float32Array} output
  * @param {number} output_offset
  * @param {number[]|ArrayLike<number>} indices
  * @param {number[]|ArrayLike<number>} positions

package/engine/graphics/sh3/path_tracer/make_one_vector3.js

@@ -0,0 +1,7 @@
+export function make_one_vector3() {
+    return (out, out_offset, direction, direction_offset) => {
+        out[out_offset] = 1;
+        out[out_offset + 1] = 1;
+        out[out_offset + 2] = 1;
+    }
+}

package/engine/graphics/sh3/path_tracer/make_sky_rtiw.js

@@ -13,3 +13,5 @@ export function make_sky_rtiw() {
         out[out_offset + 2] = lerp(1, 1, t);
     }
 }
+
+

package/engine/graphics/sh3/path_tracer/make_zero_vector3.js

@@ -0,0 +1,7 @@
+export function make_zero_vector3() {
+    return (out, out_offset, direction, direction_offset) => {
+        out[out_offset] = 0;
+        out[out_offset + 1] = 0;
+        out[out_offset + 2] = 0;
+    }
+}

package/engine/graphics/sh3/path_tracer/prototypePathTracer.js

@@ -37,6 +37,7 @@ import { noop } from "../../../../core/function/Functions.js";
 import { Color } from "../../../../core/color/Color.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { makeGeometryIndexed } from "../../geometry/buffered/makeGeometryIndexed.js";
+import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
 
 document.body.style.margin = 0;
 document.body.style.overflow = "hidden";
@@ -108,20 +109,30 @@ function prepare_scene_sphere_01(pt, camera) {
     camera.lookAt(0, 0, 0);
     pt.addMesh(
         new SphereBufferGeometry(1, 16, 16),
-        new MeshStandardMaterial({ color: '#FF0000' }),
+        // new MeshStandardMaterial({ color: '#FF0000' }),
+        new MeshStandardMaterial({ color: '#FFFFFF' }),
         Transform.fromJSON({
             scale: 0.5
         }).matrix
     );
 
     const ground_material = new MeshStandardMaterial({
-        color: '#00FF00'
+        color: '#FFFFFF'
     });
     pt.addMesh(new PlaneBufferGeometry(), ground_material, Transform.fromJSON({
         position: new Vector3(0, -0.5, 0),
         scale: 50,
         rotation: Quaternion.fromEulerAngles(-Math.PI / 2, 0, 0)
     }).matrix);
+
+
+    const light = new DirectionalLight();
+    light.color.setRGB(1, 0, 0);
+    light.intensity.set(1);
+    light.direction.set(-1, -1, 0);
+    light.direction.normalize();
+
+    pt.addLight(light);
 }
 
 function promise_ply(url) {
@@ -365,7 +376,7 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
     const pixel_scale_x = 1 / (width - 1);
     const pixel_scale_y = 1 / (height - 1);
 
-    const pixel_sample_count = 500;
+    const pixel_sample_count = 64;
 
     progress.total = width * height;
 
@@ -465,11 +476,12 @@ const camera = new PerspectiveCamera();
 async function start_renderer(camera) {
     camera.aspect = vCanvas.size.x / vCanvas.size.y;
 
-    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
 
     // await prepare_scene_lucy(pt, camera);
-    await prepare_scene_rtiow(pt, camera);
-    // await prepare_scene_sphere_01(pt, camera);
+    // await prepare_scene_rtiow(pt, camera);
+    await prepare_scene_sphere_01(pt, camera);
     // await prepare_scene_gltf(pt, camera, path);
 
     pt.build();

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.18",
+  "version": "2.43.19",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",