@woosh/meep-engine 2.109.20 → 2.109.22

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js

@@ -1,15 +1,20 @@
+import { assert } from "../../../../../../core/assert.js";
+import { UINT32_MAX } from "../../../../../../core/binary/UINT32_MAX.js";
 import { array_copy } from "../../../../../../core/collection/array/array_copy.js";
 import {
     decode_octahedron_to_unit
 } from "../../../../../../core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js";
 import { Ray3 } from "../../../../../../core/geom/3d/Ray3.js";
 import { v3_distance } from "../../../../../../core/geom/vec3/v3_distance.js";
-import { v3_dot } from "../../../../../../core/geom/vec3/v3_dot.js";
 import { v3_dot_array_array } from "../../../../../../core/geom/vec3/v3_dot_array_array.js";
-import { clamp01 } from "../../../../../../core/math/clamp01.js";
 import { max2 } from "../../../../../../core/math/max2.js";
-import { PI_HALF } from "../../../../../../core/math/PI_HALF.js";
-import { generate_halton_jitter } from "../../../../../../core/math/random/generate_halton_jitter.js";
+import { generate_hammersley_jitter } from "../../../../../../core/math/statistics/generate_hammersley_jitter.js";
+
+/**
+ * Weights of rays that are aligned with the probe direction get exponentially weighted by this exponent
+ * @type {number}
+ */
+const DEPTH_SHARPNESS = 40;
 
 const scratch_ray = new Ray3();
 
@@ -23,9 +28,8 @@ const ray_hit = [];
  *
  * @type {number}
  */
-const SUB_SAMPLE_COUNT = 1;
+const SUB_SAMPLE_COUNT = 4;
 
-const DEPTH_SHARPNESS = 7;
 
 /**
  *
@@ -45,9 +49,16 @@ export function bake_octahedral_depth_map(
     max_depth
 ) {
 
+    assert.lessThan(result_offset + resolution * resolution, UINT32_MAX, 'Result overflow');
+
     scratch_ray.tMax = max_depth;
     array_copy(position, position_offset, scratch_ray, 0, 3);
 
+    /**
+     * In radians, how wide of an arc does a single texel cover
+     * @type {number}
+     */
+    const texel_angular_coverage = (Math.PI) / resolution;
 
     /**
      * Resolution bias is to compensate for discontinuities between samples
@@ -58,9 +69,9 @@ export function bake_octahedral_depth_map(
      * xMath.SQRT2 is to allow for diagonals between pixels
      * @type {number}
      */
-    const RESOLUTION_BIAS = Math.sin(PI_HALF / resolution) * Math.SQRT2;
+    const RESOLUTION_BIAS = Math.sin(texel_angular_coverage) * Math.SQRT2 * 2;
 
-    const NORMAL_BIAS = max_depth * 0.01 + 1e-6;
+    const NORMAL_BIAS = max2(0.01, max_depth * 0.01) + 1e-6;
 
     const ray_direction = scratch_ray.direction;
 
@@ -68,7 +79,7 @@ export function bake_octahedral_depth_map(
 
     const texel_uv_scale = 0.5 / (resolution);
 
-    const jittered_sub_samples = generate_halton_jitter(SUB_SAMPLE_COUNT);
+    const jittered_sub_samples = generate_hammersley_jitter(SUB_SAMPLE_COUNT);
 
 
     for (let oct_x = 0; oct_x < resolution; oct_x++) {
@@ -78,23 +89,18 @@ export function bake_octahedral_depth_map(
             let weight_sum = 0;
 
             // offset position by half a pixel, as we are storing values for pixel centers
-            const u = (oct_x ) / (resolution);
-            const v = (oct_y ) / (resolution);
-
-            // const u = (oct_x + 0.5) / (resolution - 1);
-            // const v = (oct_y + 0.5) / (resolution - 1);
-
-            decode_octahedron_to_unit(
-                probe_direction, 0,
-                u * 2 - 1, v * 2 - 1
-            );
+            const u = (oct_x + 0.5) / (resolution);
+            const v = (oct_y + 0.5) / (resolution);
 
             for (let sub_sample_index = 0; sub_sample_index < SUB_SAMPLE_COUNT; sub_sample_index++) {
 
                 const sample_index2 = sub_sample_index * 2;
 
-                const ray_u = u + jittered_sub_samples[sample_index2] * texel_uv_scale;
-                const ray_v = v + jittered_sub_samples[sample_index2 + 1] * texel_uv_scale;
+                const sample_u = jittered_sub_samples[sample_index2];
+                const sample_v = jittered_sub_samples[sample_index2 + 1];
+
+                const ray_u = u + (sample_u * 2 - 1) * texel_uv_scale;
+                const ray_v = v + (sample_v * 2 - 1) * texel_uv_scale;
 
                 decode_octahedron_to_unit(
                     ray_direction, 0,
@@ -115,27 +121,18 @@ export function bake_octahedral_depth_map(
                     const surface_position_y = ray_hit[1];
                     const surface_position_z = ray_hit[2];
 
-                    // check for possible miss
-                    const hit_angle_cos = -v3_dot(
-                        surface_normal_x, surface_normal_y, surface_normal_z,
-                        ray_direction[0], ray_direction[1], ray_direction[2]
-                    );
-
-                    const resolution_bias_offset = max_depth * RESOLUTION_BIAS;
-
-                    const hit_normal_bias = clamp01( 1-hit_angle_cos) * (resolution_bias_offset) + NORMAL_BIAS;
+                    const hit_normal_bias = -NORMAL_BIAS;
 
                     // sink the contact into the surface along the hit normal
-                    const biased_hit_x = surface_position_x - surface_normal_x * hit_normal_bias;
-                    const biased_hit_y = surface_position_y - surface_normal_y * hit_normal_bias;
-                    const biased_hit_z = surface_position_z - surface_normal_z * hit_normal_bias;
+                    const biased_hit_x = surface_position_x + surface_normal_x * hit_normal_bias;
+                    const biased_hit_y = surface_position_y + surface_normal_y * hit_normal_bias;
+                    const biased_hit_z = surface_position_z + surface_normal_z * hit_normal_bias;
 
                     distance = v3_distance(
                         scratch_ray[0], scratch_ray[1], scratch_ray[2],
                         biased_hit_x, biased_hit_y, biased_hit_z
                     );
 
-                    // distance += resolution_bias_offset;
                 }
 
                 const direction_dot_product = v3_dot_array_array(ray_direction, 0, probe_direction, 0);
@@ -155,7 +152,9 @@ export function bake_octahedral_depth_map(
 
             const address = result_offset + pixel_index;
 
-            result[address] = distance_sum / weight_sum;
+            const distance = distance_sum / weight_sum;
+
+            result[address] = distance;
         }
     }
 

package/src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.d.ts

@@ -40,6 +40,23 @@ export class BufferedGeometryBVH {
      * @returns {boolean}
      */
     occluded(ray: Ray3): boolean;
+    /**
+     *
+     * @param {SurfacePoint3} result
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {boolean} true if result is found, only false when geometry is empty
+     */
+    nearestSurfacePoint(result: SurfacePoint3, x: number, y: number, z: number): boolean;
+    /**
+     * Code is largely inlined, to avoid extra checks
+     * NOTE: raycast is performed in local coordinate space
+     * @param {number[]} output
+     * @param {number[]|Ray3} ray
+     * @returns {number} distance along the ray, negative if no hit
+     */
+    raycast2(output: number[], ray: number[] | Ray3): number;
     /**
      * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output
@@ -50,4 +67,5 @@ export class BufferedGeometryBVH {
     #private;
 }
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 //# sourceMappingURL=BufferedGeometryBVH.d.ts.map

package/src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AAyBA;IAkBI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAIG;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,WAFW,MAAM,cAAc,QAwC9B;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAkDnB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CA2ElB;;CACJ;sBAnQqB,wCAAwC"}
+{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AA+CA;IAkBI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAIG;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,WAFW,MAAM,cAAc,QAwC9B;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAmHnB;IAED;;;;;;;OAOG;IACH,4BANW,aAAa,KACb,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAqKnB;IAGD;;;;;;OAMG;IACH,iBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CAoIlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CA2ElB;;CACJ;sBA3oBqB,wCAAwC;8BAKhC,2CAA2C"}

package/src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js

@@ -1,12 +1,30 @@
-import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import {
+    BVH,
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    COLUMN_USER_DATA,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "../../../../core/bvh2/bvh3/BVH.js";
 import { ebvh_build_for_geometry_morton } from "../../../../core/bvh2/bvh3/ebvh_build_for_geometry_morton.js";
 import { bvh_query_user_data_ray_segment } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { aabb3_intersects_ray_segment } from "../../../../core/geom/3d/aabb/aabb3_intersects_ray_segment.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import {
+    computeTriangleClosestPointToPointBarycentric
+} from "../../../../core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js";
 
 import {
     computeTriangleRayIntersectionBarycentricGeometry
 } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js";
+import { v3_compute_triangle_normal } from "../../../../core/geom/3d/v3_compute_triangle_normal.js";
+import { v3_distance_sqr } from "../../../../core/geom/vec3/v3_distance_sqr.js";
 import Vector4 from "../../../../core/geom/Vector4.js";
 import { makeGeometryIndexed } from "../../geometry/buffered/makeGeometryIndexed.js";
 import { computeBoundingSphereFromVertexData } from "../../geometry/computeBoundingSphereFromVertexData.js";
@@ -23,6 +41,10 @@ const scratch_uint32_array = new Uint32Array(4096);
  */
 const v3_scratch_0 = [];
 
+const scratch_contact = new SurfacePoint3();
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
 export class BufferedGeometryBVH {
     /**
      * @type {Uint32Array}
@@ -147,40 +169,418 @@ export class BufferedGeometryBVH {
 
         const bvh = this.#bvh;
 
-        const count = bvh_query_user_data_ray_segment(
-            bvh, bvh.root,
-            scratch_uint32_array, 0,
-            origin_x, origin_y, origin_z,
-            direction_x, direction_y, direction_z,
-            0, max_distance
-        );
+        const root = bvh.root;
 
-        // check triangles found via BVH
-        for (let i = 0; i < count; i++) {
-            const triangle_index = scratch_uint32_array[i];
+        if (root === NULL_NODE) {
+            return -1;
+        }
 
-            const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
-                v3_scratch_0,
+        /**
+         * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+         * @type {number}
+         */
+        let pointer = stack.pointer;
+
+        /**
+         *
+         * @type {number}
+         */
+        const stack_top = pointer;
+
+        stack[pointer++] = root;
+
+
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
+        const uint32 = bvh.__data_uint32;
+
+        const inv_direction_x = 1 / direction_x;
+        const inv_direction_y = 1 / direction_y;
+        const inv_direction_z = 1 / direction_z;
+
+        do {
+
+            --pointer;
+
+            /**
+             *
+             * @type {number}
+             */
+            const node = stack[pointer];
+
+            const address = node * ELEMENT_WORD_COUNT;
+
+            // test node against the ray
+            const intersects = aabb3_intersects_ray_segment(
+                float32[address], float32[address + 1], float32[address + 2],
+                float32[address + 3], float32[address + 4], float32[address + 5],
                 origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z,
-                indices, triangle_index,
-                positions
+                inv_direction_x, inv_direction_y, inv_direction_z,
+                0, max_distance
             );
 
-            if (!intersection_found) {
+            if (!intersects) {
                 continue;
             }
 
-            const t = v3_scratch_0[0];
+            // get fist child to check if this is a leaf node or not
+            const child_1 = uint32[address + COLUMN_CHILD_1];
+
+            if (child_1 !== NULL_NODE) {
+
+                // this is not a leaf node, push children onto traversal stack
+                const child_2 = uint32[address + COLUMN_CHILD_2];
+
+                stack[pointer++] = child_2;
+                stack[pointer++] = child_1;
+
+
+            } else {
+                // leaf node
+
+                const triangle_index = uint32[address + COLUMN_USER_DATA];
+
+                const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
+                    v3_scratch_0,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z,
+                    indices, triangle_index,
+                    positions
+                );
+
+                if (!intersection_found) {
+                    continue;
+                }
+
+                const t = v3_scratch_0[0];
+
+                if (t < max_distance && t > 0) {
+                    return true;
+
+                }
 
-            if (t < max_distance && t > 0) {
-                return true;
             }
-        }
+        } while (pointer > stack_top);
+
 
         return false;
     }
 
+    /**
+     *
+     * @param {SurfacePoint3} result
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {boolean} true if result is found, only false when geometry is empty
+     */
+    nearestSurfacePoint(result, x, y, z) {
+
+        const indices = this.__geometry_index;
+        const positions = this.__geometry_positions;
+
+        const bvh = this.#bvh;
+
+        const root = bvh.root;
+
+        if (root === NULL_NODE) {
+            return false;
+        }
+
+        /**
+         * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+         * @type {number}
+         */
+        let pointer = stack.pointer;
+
+        /**
+         *
+         * @type {number}
+         */
+        const stack_top = pointer;
+
+        stack[pointer++] = root;
+
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
+        const uint32 = bvh.__data_uint32;
+
+        let nearest_distance_sqr = Infinity;
+
+
+        do {
+            --pointer;
+
+            /**
+             *
+             * @type {number}
+             */
+            const node = stack[pointer];
+
+            const address = node * ELEMENT_WORD_COUNT;
+
+            // test node against the ray
+
+
+            // get fist child to check if this is a leaf node or not
+            const child_1 = uint32[address + COLUMN_CHILD_1];
+
+            if (child_1 !== NULL_NODE) {
+
+                // this is not a leaf node, push children onto traversal stack
+                const child_2 = uint32[address + COLUMN_CHILD_2];
+
+                // to achieve faster convergence, we sort children before adding them to the stack by their proximity to the reference point
+                const child_1_address = child_1 * ELEMENT_WORD_COUNT;
+
+                const distance_sqr_to_child1 = aabb3_unsigned_distance_sqr_to_point(
+                    float32[child_1_address], float32[child_1_address + 1], float32[child_1_address + 2],
+                    float32[child_1_address + 3], float32[child_1_address + 4], float32[child_1_address + 5],
+                    x, y, z
+                );
+
+                const child_2_address = child_2 * ELEMENT_WORD_COUNT;
+
+                const distance_sqr_to_child2 = aabb3_unsigned_distance_sqr_to_point(
+                    float32[child_2_address], float32[child_2_address + 1], float32[child_2_address + 2],
+                    float32[child_2_address + 3], float32[child_2_address + 4], float32[child_2_address + 5],
+                    x, y, z
+                );
+
+                if (distance_sqr_to_child1 < distance_sqr_to_child2) {
+
+                    if (distance_sqr_to_child2 < nearest_distance_sqr) {
+                        stack[pointer++] = child_2;
+                    }
+
+                    if (distance_sqr_to_child1 < nearest_distance_sqr) {
+                        stack[pointer++] = child_1;
+                    }
+
+                } else {
+
+                    if (distance_sqr_to_child1 < nearest_distance_sqr) {
+                        stack[pointer++] = child_1;
+                    }
+
+                    if (distance_sqr_to_child2 < nearest_distance_sqr) {
+                        stack[pointer++] = child_2;
+                    }
+
+                }
+
+
+            } else {
+                // leaf node
+                // read triangle data
+                const triangle_index = uint32[address + COLUMN_USER_DATA];
+
+                const a = indices[triangle_index];
+                const b = indices[triangle_index + 1];
+                const c = indices[triangle_index + 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];
+
+                computeTriangleClosestPointToPointBarycentric(
+                    v3_scratch_0, 0,
+                    x, y, z,
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
+                );
+
+                const u = v3_scratch_0[0];
+                const v = v3_scratch_0[1];
+
+                // construct edge
+
+                const contact_x = (bx - ax) * u + (cx - ax) * v + ax;
+                const contact_y = (by - ay) * u + (cy - ay) * v + ay;
+                const contact_z = (bz - az) * u + (cz - az) * v + az;
+
+                const distance_to_triangle_sqr = v3_distance_sqr(contact_x, contact_y, contact_z, x, y, z);
+
+                if (distance_to_triangle_sqr >= nearest_distance_sqr) {
+                    continue;
+                }
+
+                nearest_distance_sqr = distance_to_triangle_sqr;
+
+                result.position.set(contact_x, contact_y, contact_z);
+
+                v3_compute_triangle_normal(result.normal, 0,
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
+                );
+
+                result.index = triangle_index;
+            }
+        } while (pointer > stack_top);
+
+
+        return true;
+    }
+
+
+    /**
+     * Code is largely inlined, to avoid extra checks
+     * NOTE: raycast is performed in local coordinate space
+     * @param {number[]} output
+     * @param {number[]|Ray3} ray
+     * @returns {number} distance along the ray, negative if no hit
+     */
+    raycast2(output, ray) {
+
+        const indices = this.__geometry_index;
+        const positions = this.__geometry_positions;
+
+        const origin_x = ray[0];
+        const origin_y = ray[1];
+        const origin_z = ray[2];
+
+        const direction_x = ray[3];
+        const direction_y = ray[4];
+        const direction_z = ray[5];
+
+        const max_distance = ray[6];
+
+        const bvh = this.#bvh;
+
+        const root = bvh.root;
+
+        if (root === NULL_NODE) {
+            return -1;
+        }
+
+        /**
+         * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+         * @type {number}
+         */
+        let pointer = stack.pointer;
+
+        let nearest_hit_distance = max_distance;
+
+        let best_index = -1;
+        let best_u = 0;
+        let best_v = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        const stack_top = pointer;
+
+        stack[pointer++] = root;
+
+
+        /*
+         For performance, we bind data directly to avoid extra copies required to read out AABB
+         */
+        const float32 = bvh.__data_float32;
+        const uint32 = bvh.__data_uint32;
+
+
+        const inv_direction_x = 1 / direction_x;
+        const inv_direction_y = 1 / direction_y;
+        const inv_direction_z = 1 / direction_z;
+
+        do {
+
+            --pointer;
+
+            /**
+             *
+             * @type {number}
+             */
+            const node = stack[pointer];
+
+            const address = node * ELEMENT_WORD_COUNT;
+
+            // test node against the ray
+            const intersects = aabb3_intersects_ray_segment(
+                float32[address], float32[address + 1], float32[address + 2],
+                float32[address + 3], float32[address + 4], float32[address + 5],
+                origin_x, origin_y, origin_z,
+                inv_direction_x, inv_direction_y, inv_direction_z,
+                0, nearest_hit_distance
+            );
+
+            if (!intersects) {
+                continue;
+            }
+
+            // get fist child to check if this is a leaf node or not
+            const child_1 = uint32[address + COLUMN_CHILD_1];
+
+            if (child_1 !== NULL_NODE) {
+
+                // this is not a leaf node, push children onto traversal stack
+                const child_2 = uint32[address + COLUMN_CHILD_2];
+
+                stack[pointer++] = child_2;
+                stack[pointer++] = child_1;
+
+            } else {
+                // leaf node
+
+                const triangle_index = uint32[address + COLUMN_USER_DATA];
+
+                const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
+                    v3_scratch_0,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z,
+                    indices, triangle_index,
+                    positions
+                );
+
+                if (!intersection_found) {
+                    continue;
+                }
+
+                const t = v3_scratch_0[0];
+
+                if (t < nearest_hit_distance && t > 0) {
+                    nearest_hit_distance = t;
+
+                    best_index = triangle_index;
+                    best_u = v3_scratch_0[1];
+                    best_v = v3_scratch_0[2];
+
+                }
+
+            }
+        } while (pointer > stack_top);
+
+        if (nearest_hit_distance === max_distance) {
+            // no hit
+            return -1;
+        }
+
+        construct_ray_hit_from_geometry(output, indices, positions, best_index, nearest_hit_distance, best_u, best_v);
+
+        return nearest_hit_distance;
+    }
+
     /**
      * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output

package/src/engine/graphics/sh3/path_tracer/PathTracedMesh.js

@@ -126,7 +126,7 @@ export class PathTracedMesh {
 
         local_ray.applyMatrix4(m4);
 
-        let distance_to_hit = this.bvh.raycast(out, local_ray);
+        let distance_to_hit = this.bvh.raycast2(out, local_ray);
 
         if (distance_to_hit >= 0) {
             // transform output

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

@@ -67,8 +67,8 @@ vCanvas.css({
  * How many rays to use per-pixel
  * @type {number}
  */
-const PIXEL_SAMPLE_COUNT = 1;
-const PIXEL_RENDER_RATIO = 0.5;
+const PIXEL_SAMPLE_COUNT = 16;
+const PIXEL_RENDER_RATIO = 1;
 
 const scene = new PathTracedScene();
 const pt = new PathTracer();
@@ -534,8 +534,8 @@ async function start_renderer(camera) {
     // await prepare_scene_lucy(scene, camera);
     // await prepare_scene_rtiow(pt, camera);
     // await prepare_scene_sphere_01(pt, camera);
-    // await prepare_gi_box_scene(scene, camera);
-    await prepare_sponza(scene, camera);
+    await prepare_gi_box_scene(scene, camera);
+    // await prepare_sponza(scene, camera);
     // await prepare_attic_scene(scene, camera);
     // await prepare_scene_gltf({scene, camera, path, url: path});