@woosh/meep-engine 2.109.19 → 2.109.21

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.js

@@ -0,0 +1,100 @@
+import { computeTriangleClosestPointToPointBarycentric } from "./computeTriangleClosestPointToPointBarycentric.js";
+
+test("basics", () => {
+
+    const result = [];
+
+    // internal point
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 0.5, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0.25,0.25]);
+
+    // point lies on a vertex
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        -1, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([1,0]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        1, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,1]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 1, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,0]);
+
+    // point lies on an edge
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0.5,0.5]);
+
+    // point lies outside the triangle
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        - 2, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([1,0]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        2, 0, 0 ,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,1]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 2, 0 ,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,0]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, -2, 0 ,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0.5,0.5]);
+});

package/src/core/geom/octahedral_uv_crease_distance.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Distance to the nearest crease
+ * @param {number} u from 0 to 1
+ * @param {number} v from 0 to 1
+ * @returns {number}
+ */
+export function octahedral_uv_crease_distance(u: number, v: number): number;
+//# sourceMappingURL=octahedral_uv_crease_distance.d.ts.map

package/src/core/geom/octahedral_uv_crease_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"octahedral_uv_crease_distance.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/octahedral_uv_crease_distance.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,iDAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB"}

package/src/core/geom/octahedral_uv_crease_distance.js

@@ -0,0 +1,26 @@
+/**
+ * Distance to the nearest crease
+ * @param {number} u from 0 to 1
+ * @param {number} v from 0 to 1
+ * @returns {number}
+ */
+export function octahedral_uv_crease_distance(u, v) {
+
+    const cross_distance_u = Math.abs(u - 0.5);
+    const cross_distance_v = Math.abs(v - 0.5);
+
+    const cross_distance = Math.min(cross_distance_u, cross_distance_v);
+
+    const n_u = u * 2 - 1;
+    const n_v = v * 2 - 1;
+
+    // for the belt of the fold
+    const fold = 1 - Math.abs(n_u) - Math.abs(n_v);
+
+    const fold_distance = Math.abs(fold);
+
+    // distance to the edge of the map, which folds the welding crease
+    const welding_crease_distance = Math.min(Math.min(u, 1 - u), Math.min(v, 1 - v));
+
+    return Math.min(fold_distance, cross_distance, welding_crease_distance);
+}

package/src/core/math/random/generate_halton_jitter.js

@@ -13,8 +13,8 @@ export function generate_halton_jitter(point_count) {
 
     for (let i = 0; i < point_count; i++) {
         const i2 = i * 2;
-        result[i2] = 1 - halton_sequence(2, i) * 2;
-        result[i2 + 1] = 1 - halton_sequence(3, i) * 2;
+        result[i2] = halton_sequence(2, i) * 2 - 1;
+        result[i2 + 1] = halton_sequence(3, i) * 2 - 1;
     }
 
     return result;

package/src/core/math/statistics/generate_hammersley_jitter.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} sample_count
+ * @returns {Float32Array}
+ */
+export function generate_hammersley_jitter(sample_count: number): Float32Array;
+//# sourceMappingURL=generate_hammersley_jitter.d.ts.map

package/src/core/math/statistics/generate_hammersley_jitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_hammersley_jitter.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/generate_hammersley_jitter.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,yDAHW,MAAM,GACJ,YAAY,CAUxB"}

package/src/core/math/statistics/generate_hammersley_jitter.js

@@ -0,0 +1,16 @@
+import { hammersley_sequence_2d } from "./hammersley_sequence_2d.js";
+
+/**
+ *
+ * @param {number} sample_count
+ * @returns {Float32Array}
+ */
+export function generate_hammersley_jitter(sample_count) {
+    const result = new Float32Array(sample_count * 2);
+
+    for (let i = 0; i < sample_count; i++) {
+        hammersley_sequence_2d(result, i * 2, i, sample_count);
+    }
+
+    return result;
+}

package/src/core/math/statistics/hammersley_sequence_2d.js

@@ -14,4 +14,5 @@ export function hammersley_sequence_2d(
 
     output[output_offset] = i / N;
     output[output_offset + 1] = radical_inverse_VdC_base_2(i);
-}
+}
+

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeGeometryEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryEquality.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,2CAJW,MAAM,cAAc,KACpB,MAAM,cAAc,GAClB,OAAO,CA+CnB"}
+{"version":3,"file":"computeGeometryEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryEquality.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,2CAJW,MAAM,cAAc,KACpB,MAAM,cAAc,GAClB,OAAO,CAmDnB"}

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.js

@@ -9,6 +9,10 @@ import { is_typed_array_equals } from "../../../../core/collection/array/typed/i
  * @returns {boolean}
  */
 export function computeGeometryEquality(a, b) {
+    if (a === b) {
+        // identity shortcut
+        return true;
+    }
 
     const a_index = a.getIndex();
     const b_index = b.getIndex();

package/src/engine/graphics/sh3/gi/material/common.glsl

@@ -362,7 +362,7 @@ float lpv_probe_getVisibilityMask(vec3 position, uint probe_index) {
     float chebyshevWeight = variance / (variance + distance_delta * distance_delta);
 
     // Increase contrast in the weight
-    chebyshevWeight = max(chebyshevWeight * chebyshevWeight * chebyshevWeight, 0.0);
+//    chebyshevWeight = max(chebyshevWeight * chebyshevWeight * chebyshevWeight, 0.0);
 
     return (distToProbe <= mean) ? 1.0 : chebyshevWeight;
 }

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts

@@ -28,13 +28,6 @@ export class LightProbeVolume {
      * @param {number} z
      */
     add_point(x: number, y: number, z: number): void;
-    /**
-     *
-     * @param {number} index
-     * @param {number[]} source
-     * @param {number} source_offset
-     */
-    write_probe(index: number, source: number[], source_offset: number): void;
     /**
      * Build tetrahedral mesh
      */

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAMD;;;OAGG;IACH,sCAIC;IAZD,mCAEC;IAYD,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAjM+B,wDAAwD;2BAC7D,mCAAmC"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAMD;;;OAGG;IACH,sCAIC;IAZD,mCAEC;IAYD,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAvL+B,wDAAwD;2BAC7D,mCAAmC"}

package/src/engine/graphics/sh3/lpv/LightProbeVolume.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import {
     compute_delaunay_tetrahedral_mesh
 } from "../../../../core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js";
@@ -134,16 +133,6 @@ export class LightProbeVolume {
         this.#probe_count++;
     }
 
-    /**
-     *
-     * @param {number} index
-     * @param {number[]} source
-     * @param {number} source_offset
-     */
-    write_probe(index, source, source_offset) {
-        array_copy(source, source_offset, this.#sh3_rgb, index * 9 * 3, 9 * 3);
-    }
-
     /**
      * Build tetrahedral mesh
      */

package/src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.d.ts

@@ -7,6 +7,13 @@ export class LightProbeVolumeBaker {
      * @param {EntityComponentDataset} ecd
      */
     bake(lpv: LightProbeVolume, ecd: EntityComponentDataset): TaskGroup;
+    /**
+     *
+     * @param {PathTracerProbeRenderer} renderer
+     * @param {LightProbeVolume} lpv
+     * @param {number} probe_index
+     */
+    bake_probe(renderer: PathTracerProbeRenderer, lpv: LightProbeVolume, probe_index: number): void;
 }
 import { PathTracerProbeRenderer } from "./PathTracerProbeRenderer.js";
 import TaskGroup from "../../../../core/process/task/TaskGroup.js";

package/src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolumeBaker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.js"],"names":[],"mappings":"AAOA;IAEI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CAkErB;CACJ;wCA5EuC,8BAA8B;sBALhD,4CAA4C"}
+{"version":3,"file":"LightProbeVolumeBaker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.js"],"names":[],"mappings":"AAQA;IAEI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CA2CrB;IAED;;;;;OAKG;IACH,qBAJW,uBAAuB,sCAEvB,MAAM,QA8BhB;CACJ;wCAzFuC,8BAA8B;sBALhD,4CAA4C"}

package/src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../../core/assert.js";
 import TaskGroup from "../../../../core/process/task/TaskGroup.js";
 import { actionTask } from "../../../../core/process/task/util/actionTask.js";
 import { countTask } from "../../../../core/process/task/util/countTask.js";
@@ -29,31 +30,8 @@ export class LightProbeVolumeBaker {
 
         const probe_count = lpv.count;
 
-        const tBakeIrradiance = countTask(0, probe_count, (i) => {
-
-            // Bake color
-            renderer.bake(
-                lpv.points, i * 3,
-                lpv.harmonics, i * 9 * 3
-            );
-
-
-            // Bake depth
-            const max_distance = find_max_depth_radius_for_point(i, lpv.mesh, lpv.points);
-
-            // bias a little to ensure we capture everything
-            const max_depth = max_distance * 1.01 + 1e-6;
-
-            const depth_resolution = lpv.depth_map_resolution;
-
-            const probe_element_count = depth_resolution * depth_resolution;
-
-            renderer.bake_depth_octahedral(
-                depth_resolution,
-                max_depth,
-                lpv.points, i * 3,
-                lpv.depth, i * probe_element_count
-            );
+        const tBakeIrradiance = countTask(0, probe_count, (probe_index) => {
+            this.bake_probe(renderer, lpv, probe_index);
 
         });
         tBakeIrradiance.estimatedDuration = probe_count;
@@ -79,4 +57,40 @@ export class LightProbeVolumeBaker {
             tPrepare, tBakeIrradiance, tFinish
         ], "LightProbeVolume Bake");
     }
+
+    /**
+     *
+     * @param {PathTracerProbeRenderer} renderer
+     * @param {LightProbeVolume} lpv
+     * @param {number} probe_index
+     */
+    bake_probe(renderer, lpv, probe_index) {
+        assert.isNonNegativeInteger(probe_index, 'probe_index');
+
+        const position_offset = probe_index * 3;
+
+        // Bake color
+        renderer.bake(
+            lpv.points, position_offset,
+            lpv.harmonics, probe_index * 9 * 3
+        );
+
+
+        // Bake depth
+        const max_distance = find_max_depth_radius_for_point(probe_index, lpv.mesh, lpv.points);
+
+        // bias a little to ensure we capture everything
+        const max_depth = max_distance * 1.01 + 1e-6;
+
+        const depth_resolution = lpv.depth_map_resolution;
+
+        const probe_element_count = depth_resolution * depth_resolution;
+
+        renderer.bake_depth_octahedral(
+            depth_resolution,
+            max_depth,
+            lpv.points, position_offset,
+            lpv.depth, probe_index * probe_element_count
+        );
+    }
 }

package/src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js

@@ -24,7 +24,7 @@ const sampled_irradiance = new Float32Array(3);
 export class PathTracerProbeRenderer extends ProbeRenderer {
     tracer = new PathTracer();
     max_bounce_count = 7;
-    sample_count = 4096;
+    sample_count = 1024;
     random = seededRandom(0);
 
     scene = new PathTracedScene()

package/src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bake_octahedral_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js"],"names":[],"mappings":"AA6BA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QA4HhB"}
+{"version":3,"file":"bake_octahedral_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/bake_octahedral_depth_map.js"],"names":[],"mappings":"AAiCA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QAuHhB"}

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"}