@woosh/meep-engine 2.109.4 → 2.109.5

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

@@ -1,4 +1,5 @@
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import { sh3_basis_at } from "../../../../core/geom/3d/sphere/harmonics/sh3_basis_at.js";
 import {
     sh3_dering_optimize_positive
@@ -21,7 +22,7 @@ const __shared_buffer = new ArrayBuffer((27 + 9) * 8);
 const sh_basis = new Float64Array(__shared_buffer, 0, 9);
 const coefficients = new Float64Array(__shared_buffer, 9 * 8, 27);
 
-const ray = new Float32Array(6);
+const ray = new Ray3();
 const sampled_irradiance = new Float32Array(3);
 
 export class PathTracerProbeRenderer extends ProbeRenderer {
@@ -67,8 +68,10 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
         for (let i = 0; i < this.sample_count; i++) {
 
             randomPointOnSphere(this.random, ray, 3);
+            ray.tMax = Infinity;
+            ray.tMin = 0;
 
-            tracer.path_trace(sampled_irradiance, ray, Infinity, 1, 7, this.random, this.scene);
+            tracer.path_trace(sampled_irradiance, ray, 1, 7, this.random, this.scene);
 
             sh3_basis_at(ray[3], ray[4], ray[5], sh_basis);
 
@@ -94,7 +97,6 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
     }
 
     bake_start() {
-        return this.scene.build();
     }
 
     build_scene(ecd) {

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

@@ -1 +1 @@
-{"version":3,"file":"sh3_bake_depth.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/sh3_bake_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,uCATW,MAAM,EAAE,iBACR,MAAM,sCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,eACN,MAAM,QAqDhB"}
+{"version":3,"file":"sh3_bake_depth.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/sh3_bake_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,uCATW,MAAM,EAAE,iBACR,MAAM,sCAEN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,eACN,MAAM,QAsDhB"}

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

@@ -32,6 +32,7 @@ export function sh3_bake_depth(
     const sh = new Float32Array(9);
 
     ray.origin.set(position_x, position_y, position_z);
+    ray.tMax = max_depth;
 
     const encoder = new OctahedralUvEncoder();
 
@@ -42,7 +43,7 @@ export function sh3_bake_depth(
 
             encoder.uv_to_unit(ray.direction, [u, v])
 
-            let distance = scene.trace(ray_hit, ray, 0, max_depth);
+            let distance = scene.trace(ray_hit, ray);
 
             if (distance < 0) {
                 distance = 100;

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

@@ -33,15 +33,20 @@ export class BufferedGeometryBVH {
      * @param {THREE.BufferGeometry} geometry
      */
     build(geometry: THREE.BufferGeometry): void;
+    /**
+     * Tests ray for occlusion
+     * Returns true if ray hits anything at all
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray: Ray3): boolean;
     /**
      * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
+     * @param {number[]|Ray3} ray
      * @returns {number} distance along the ray, negative if no hit
      */
-    raycast(output: number[], ray: number[], min_distance: number, max_distance: number): number;
+    raycast(output: number[], ray: number[] | Ray3): number;
     #private;
 }
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";

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":"AAwBA;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,gBAFW,MAAM,cAAc,QAsC9B;IAGD;;;;;;;OAOG;IACH,gBANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAyElB;;CACJ;sBAzMqB,wCAAwC"}
+{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AAwBA;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,gBAFW,MAAM,cAAc,QAsC9B;IAED;;;;;OAKG;IACH,qBAFa,OAAO,CAkDnB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,GACX,MAAM,CA2ElB;;CACJ;sBAhQqB,wCAAwC"}

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

@@ -122,16 +122,69 @@ export class BufferedGeometryBVH {
         r.toArray(this.#bounds_sphere);
     }
 
+    /**
+     * Tests ray for occlusion
+     * Returns true if ray hits anything at all
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(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 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
+        );
+
+        // check triangles found via BVH
+        for (let i = 0; i < count; i++) {
+            const triangle_index = scratch_uint32_array[i];
+
+            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;
+            }
+        }
+
+        return false;
+    }
 
     /**
      * NOTE: raycast is performed in local coordinate space
      * @param {number[]} output
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
+     * @param {number[]|Ray3} ray
      * @returns {number} distance along the ray, negative if no hit
      */
-    raycast(output, ray, min_distance, max_distance) {
+    raycast(output, ray) {
 
         const indices = this.__geometry_index;
         const positions = this.__geometry_positions;
@@ -144,6 +197,8 @@ export class BufferedGeometryBVH {
         const direction_y = ray[4];
         const direction_z = ray[5];
 
+        const max_distance = ray[6];
+
         const bvh = this.#bvh;
 
         const count = bvh_query_user_data_ray_segment(
@@ -151,7 +206,7 @@ export class BufferedGeometryBVH {
             scratch_uint32_array, 0,
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_z,
-            min_distance, max_distance
+            0, max_distance
         );
 
         if (count === 0) {
@@ -184,7 +239,7 @@ export class BufferedGeometryBVH {
 
             const t = v3_scratch_0[0];
 
-            if (t < nearest_hit_distance && t > min_distance) {
+            if (t < nearest_hit_distance && t > 0) {
                 nearest_hit_distance = t;
 
                 best_index = triangle_index;

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

@@ -24,20 +24,27 @@ export class PathTracedMesh {
      * @type {StandardMaterial|null}
      */
     material: StandardMaterial | null;
+    get transform_inverse(): Float32Array;
     build_tight_bounds(): void;
     update_bounds(): void;
     set transform(arg: Float32Array);
     get transform(): Float32Array;
+    /**
+     *
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray: Ray3): boolean;
     /**
      *
      * @param {number[]} out
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
+     * @param {number[]|Ray3} ray
+     * @param {number} ray_limit overrides Ray.tMax
      * @returns {number} distance along the ray to contact
      */
-    hit(out: number[], ray: number[], min_distance: number, max_distance: number): number;
+    hit(out: number[], ray: number[] | Ray3, ray_limit: number): number;
     #private;
 }
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 //# sourceMappingURL=PathTracedMesh.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracedMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedMesh.js"],"names":[],"mappings":"AAmBA;IACI;;;OAGG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,MAFU,KAAK,CAEI;IAEnB;;;OAGG;IACH,KAFU,sBAAoB,IAAI,CAEvB;IAGX;;;OAGG;IACH,UAFU,MAAM,cAAc,GAAC,IAAI,CAEnB;IAEhB;;;OAGG;IACH,UAFU,mBAAiB,IAAI,CAEf;IAKhB,2BAqBC;IAED,sBAGC;IAED,iCAQC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,SANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAmDlB;;CACJ;sBAxJqB,wCAAwC"}
+{"version":3,"file":"PathTracedMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedMesh.js"],"names":[],"mappings":"AAeA;IACI;;;OAGG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,MAFU,KAAK,CAEI;IAEnB;;;OAGG;IACH,KAFU,sBAAoB,IAAI,CAEvB;IAGX;;;OAGG;IACH,UAFU,MAAM,cAAc,GAAC,IAAI,CAEnB;IAEhB;;;OAGG;IACH,UAFU,mBAAiB,IAAI,CAEf;IAKhB,sCAEC;IAED,2BAqBC;IAED,sBAGC;IAED,iCAQC;IAED,8BAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAWnB;IAED;;;;;;OAMG;IACH,SALW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,aACb,MAAM,GACJ,MAAM,CA4BlB;;CACJ;sBAhJqB,wCAAwC;qBAIzC,kCAAkC"}

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

@@ -4,17 +4,13 @@ import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array_transformed } from "../../../../core/geom/3d/aabb/aabb3_from_v3_array_transformed.js";
 import { decompose_matrix_4_array } from "../../../../core/geom/3d/decompose_matrix_4_array.js";
 import { allocate_m4 } from "../../../../core/geom/3d/mat4/allocate_m4.js";
-import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
-import { ray3_shift_origin_along_direction } from "../../../../core/geom/3d/ray/ray3_shift_origin_along_direction.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import Quaternion from "../../../../core/geom/Quaternion.js";
-import { v3_array_displace_in_direction } from "../../../../core/geom/vec3/v3_array_displace_in_direction.js";
 import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
-import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { ray_hit_apply_transform } from "./ray_hit_apply_transform.js";
 
-const local_ray = new Float32Array(6);
-const scratch_v3 = new Float32Array(3);
+const local_ray = new Ray3();
 let mesh_id_counter = 0;
 
 export class PathTracedMesh {
@@ -52,6 +48,10 @@ export class PathTracedMesh {
     #transform = allocate_m4();
     #transform_inverse = allocate_m4();
 
+    get transform_inverse() {
+        return this.#transform_inverse;
+    }
+
     build_tight_bounds() {
         const position = new Vector3();
         const rotation = new Quaternion();
@@ -96,45 +96,37 @@ export class PathTracedMesh {
 
     /**
      *
-     * @param {number[]} out
-     * @param {number[]} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
-     * @returns {number} distance along the ray to contact
+     * @param {Ray3} ray
+     * @returns {boolean}
      */
-    hit(out, ray, min_distance, max_distance) {
-        //transform ray
-        const m4 = this.#transform_inverse;
-
-        // shift ray forward by "min distance"
-        ray3_shift_origin_along_direction(local_ray, 0, ray, 0, min_distance);
+    occluded(ray) {
 
+        const m4 = this.#transform_inverse;
 
-        ray3_array_apply_matrix4(local_ray, 0, local_ray, 0, m4);
+        local_ray.copy(ray);
+        local_ray.applyMatrix4(m4);
 
+        return this.bvh.occluded(local_ray);
 
-        let max_distance_local = Infinity;
+    }
 
-        if (max_distance !== Infinity) {
-            // compute position of point at max_distance along the ray
-            v3_array_displace_in_direction(
-                scratch_v3, 0,
-                ray[0], ray[1], ray[2],
-                ray[3], ray[4], ray[5],
-                max_distance-min_distance
-            );
+    /**
+     *
+     * @param {number[]} out
+     * @param {number[]|Ray3} ray
+     * @param {number} ray_limit overrides Ray.tMax
+     * @returns {number} distance along the ray to contact
+     */
+    hit(out, ray, ray_limit) {
+        //transform ray
+        const m4 = this.#transform_inverse;
 
-            // move far point into local coordinate space
-            v3_matrix4_multiply(scratch_v3, 0, scratch_v3, 0, m4);
+        local_ray.copy(ray);
+        local_ray.tMax = ray_limit;
 
-            // compute far distance in local space
-            max_distance_local = v3_distance(
-                local_ray[0], local_ray[1], local_ray[2],
-                scratch_v3[0], scratch_v3[1], scratch_v3[2]
-            );
-        }
+        local_ray.applyMatrix4(m4);
 
-        let distance_to_hit = this.bvh.raycast(out, local_ray, 0, max_distance_local);
+        let distance_to_hit = this.bvh.raycast(out, local_ray);
 
         if (distance_to_hit >= 0) {
             // transform output

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

@@ -26,7 +26,6 @@ export class PathTracedScene {
      */
     private __background_sampler;
     optimize(): void;
-    build(): Promise<void>;
     /**
      *
      * @param {THREE.BufferGeometry} geo
@@ -56,6 +55,12 @@ export class PathTracedScene {
      * @returns {boolean}
      */
     removeMesh(mesh: PathTracedMesh): boolean;
+    /**
+     * Retrieves pre-cached material or build one from scratch, caches it and returns the result
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    obtainMaterial(material: THREE.Material): StandardMaterial;
     /**
      *
      * @param {THREE.BufferGeometry} geometry
@@ -67,17 +72,22 @@ export class PathTracedScene {
      *
      * @param {number[]} out [color_r, color_g, color_b, normal_x, normal_y, normal_z]
      * @param {number[]} hit
+     * @param {Ray3} incoming_ray
      */
-    sample_material(out: number[], hit: number[]): void;
+    sample_material(out: number[], hit: number[], incoming_ray: Ray3): void;
+    /**
+     * Tests ray for occlusion
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray: Ray3): boolean;
     /**
      *
      * @param {number[]} out
      * @param {number[]|Ray3} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
      * @return {number} distance to contact, or -1 if no contact found
      */
-    trace(out: number[], ray: number[] | Ray3, min_distance: number, max_distance: number): number;
+    trace(out: number[], ray: number[] | Ray3): number;
     /**
      *
      * @param {number[]} out
@@ -91,14 +101,13 @@ export class PathTracedScene {
      * @param {number[]} out
      * @param {number} out_offset
      * @param {number[]} ray
-     * @param {number} ray_address
-     * @returns {boolean}
      */
-    sample_lights(out: number[], out_offset: number, ray: number[], ray_address: number): boolean;
+    sample_lights(out: number[], out_offset: number, ray: number[]): void;
     #private;
 }
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { PathTracedMesh } from "./PathTracedMesh.js";
 import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
 import { BufferedGeometryBVH } from "./BufferedGeometryBVH.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 //# sourceMappingURL=PathTracedScene.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AA6CA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAiF7C,iBAOC;IAED,uBAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,gBACb,MAAM,gBACN,MAAM,GACL,MAAM,CA8CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,CAmEnB;;CACJ;oBA9d8B,mCAAmC;+BAiBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAgCA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAiF7C,iBAOC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,yBAHW,MAAM,QAAQ,oBAKxB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,IAAI,QAgCd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAsCnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,GACZ,MAAM,CA+CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,QAkElB;;CACJ;oBArgB8B,mCAAmC;+BAkBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B;qBALzC,kCAAkC"}

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

@@ -9,6 +9,7 @@ import { strictEquals } from "../../../../core/function/strictEquals.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { v3_morton_encode_bounded } from "../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { compute_geometry_polycount } from "../../geometry/compute_geometry_polycount.js";
@@ -25,24 +26,10 @@ import { sample_material } from "./texture/sample_material.js";
  */
 const scratch_uint32_array = new Uint32Array(4096);
 
-const _ray_1 = [];
-const tmp_0 = new Float64Array(11);
-const null_output = [];
+const _ray_1 = new Ray3();
 
 const DEFAULT_CONVERTER = new MaterialConverter();
 
-
-/**
- *
- * @param {Uint32Array} result
- * @param {number} result_offset
- * @param {number} count
- * @param {BVH} bvh
- */
-function bvh_build_query_cache(result, result_offset, count, bvh) {
-
-}
-
 export class PathTracedScene {
 
 
@@ -183,10 +170,6 @@ export class PathTracedScene {
         this.#rebuild_bvh();
     }
 
-    async build() {
-
-    }
-
     /**
      *
      * @param {THREE.BufferGeometry} geo
@@ -289,6 +272,15 @@ export class PathTracedScene {
         return true;
     }
 
+    /**
+     * Retrieves pre-cached material or build one from scratch, caches it and returns the result
+     * @param {THREE.Material} material
+     * @returns {StandardMaterial}
+     */
+    obtainMaterial(material) {
+        return this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
+    }
+
     /**
      *
      * @param {THREE.BufferGeometry} geometry
@@ -296,7 +288,7 @@ export class PathTracedScene {
      * @param {mat4|number[]} transform
      */
     createMesh(geometry, material, transform) {
-        const standard_material = this.#material_cache.getOrCompute(material, DEFAULT_CONVERTER.convert, DEFAULT_CONVERTER);
+        const standard_material = this.obtainMaterial(material);
 
         const mesh = new PathTracedMesh();
         mesh.geometry = geometry;
@@ -312,8 +304,9 @@ export class PathTracedScene {
      *
      * @param {number[]} out [color_r, color_g, color_b, normal_x, normal_y, normal_z]
      * @param {number[]} hit
+     * @param {Ray3} incoming_ray
      */
-    sample_material(out, hit) {
+    sample_material(out, hit, incoming_ray) {
         const primitive_id = hit[9];
         const instance_id = hit[10];
         const u = hit[7];
@@ -336,17 +329,65 @@ export class PathTracedScene {
 
         sample_material(out, mesh, primitive_id, u, v);
 
+        // const pdf = mesh.material.scattering_pdf(
+        //     incoming_ray[3],incoming_ray[4],incoming_ray[5],
+        //     out[3],out[4],out[5],
+        //     incoming_ray[3],incoming_ray[4],incoming_ray[5],
+        // );
+
+
+    }
+
+    /**
+     * Tests ray for occlusion
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    occluded(ray) {
+
+        const bvh = this.bvh_top_level;
+
+        const ray_origin_x = ray[0];
+        const ray_origin_y = ray[1];
+        const ray_origin_z = ray[2];
+
+        const ray_direction_x = ray[3];
+        const ray_direction_y = ray[4];
+        const ray_direction_z = ray[5];
+
+        const max_distance = ray[6];
+
+        const hit_count = bvh_query_user_data_ray_segment(
+            bvh, bvh.root,
+            scratch_uint32_array, 0,
+            ray_origin_x, ray_origin_y, ray_origin_z,
+            ray_direction_x, ray_direction_y, ray_direction_z,
+            0, max_distance
+        );
+
+
+        for (let i = 0; i < hit_count; i++) {
+
+            const node_user_data = scratch_uint32_array[i];
+
+            const mesh = this.meshes.get(node_user_data);
+
+            if (mesh.occluded(ray)) {
+                return true;
+            }
+
+        }
+
+        return false;
     }
 
     /**
      *
      * @param {number[]} out
      * @param {number[]|Ray3} ray
-     * @param {number} min_distance
-     * @param {number} max_distance
      * @return {number} distance to contact, or -1 if no contact found
      */
-    trace(out, ray, min_distance, max_distance) {
+    trace(out, ray) {
 
         const bvh = this.bvh_top_level;
 
@@ -358,13 +399,14 @@ export class PathTracedScene {
         const ray_direction_y = ray[4];
         const ray_direction_z = ray[5];
 
+        const max_distance = ray[6];
 
         const hit_count = bvh_query_user_data_ray_segment(
             bvh, bvh.root,
             scratch_uint32_array, 0,
             ray_origin_x, ray_origin_y, ray_origin_z,
             ray_direction_x, ray_direction_y, ray_direction_z,
-            min_distance, max_distance
+            0, max_distance
         );
 
         let nearest_hit_distance = max_distance;
@@ -375,7 +417,7 @@ export class PathTracedScene {
 
             const mesh = this.meshes.get(node_user_data);
 
-            const distance_to_hit = mesh.hit(out, ray, min_distance, nearest_hit_distance);
+            const distance_to_hit = mesh.hit(out, ray, 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
@@ -408,11 +450,8 @@ export class PathTracedScene {
      * @param {number[]} out
      * @param {number} out_offset
      * @param {number[]} ray
-     * @param {number} ray_address
-     * @returns {boolean}
      */
-    sample_lights(out, out_offset, ray, ray_address) {
-        let lights_sampled = false;
+    sample_lights(out, out_offset, ray) {
 
         const lights = this.__lights;
         const light_count = lights.length;
@@ -430,9 +469,9 @@ export class PathTracedScene {
 
                 // see https://github.com/mrdoob/three.js/blob/f0a9e0cf90a2f1ba5017fcb7fd46f02748b920cf/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js#L172
 
-                const ray_direction_x = ray[ray_address + 3];
-                const ray_direction_y = ray[ray_address + 4];
-                const ray_direction_z = ray[ray_address + 5];
+                const ray_direction_x = ray[3];
+                const ray_direction_y = ray[4];
+                const ray_direction_z = ray[5];
 
                 const light_dir_inv_x = -dir.x;
                 const light_dir_inv_y = -dir.y;
@@ -448,33 +487,33 @@ export class PathTracedScene {
                     continue;
                 }
 
-                const ray_origin_x = ray[ray_address + 0];
-                const ray_origin_y = ray[ray_address + 1];
-                const ray_origin_z = ray[ray_address + 2];
+                const ray_origin_x = ray[0];
+                const ray_origin_y = ray[1];
+                const ray_origin_z = ray[2];
 
                 ray3_array_compose(_ray_1,
                     ray_origin_x, ray_origin_y, ray_origin_z,
                     light_dir_inv_x, light_dir_inv_y, light_dir_inv_z
                 );
 
+                _ray_1.tMax = Infinity;
+
                 // check if there are any obstacles in the direction of the light
-                if (this.trace(null_output, _ray_1, 0.0001, Infinity) > 0) {
+                if (this.occluded(_ray_1)) {
                     // light is occluded
                     continue;
                 }
 
 
                 const intensity = dotNL * light.intensity.getValue();
+                const light_color = light.color;
+
+                out[out_offset] += light_color.r * intensity;
+                out[out_offset + 1] += light_color.g * intensity;
+                out[out_offset + 2] += light_color.b * intensity;
 
-                for (let j = 0; j < 3; j++) {
-                    // irradiance
-                    out[out_offset + j] += light.color[j] * intensity;
-                }
 
-                lights_sampled = true;
             }
         }
-
-        return lights_sampled;
     }
 }

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

@@ -2,13 +2,13 @@ export class PathTracer {
     /**
      *
      * @param {number[]|Float32Array} out
-     * @param {number[]|Float32Array} ray
-     * @param {number} max_distance
+     * @param {number[]|Float32Array|Ray3} ray
      * @param {number} min_bounce
      * @param {number} max_bounce
      * @param {function} random
      * @param {PathTracedScene} scene
      */
-    path_trace(out: number[] | Float32Array, ray: number[] | Float32Array, max_distance: number, min_bounce: number, max_bounce: number, random: Function, scene: PathTracedScene): void;
+    path_trace(out: number[] | Float32Array, ray: number[] | Float32Array | Ray3, min_bounce: number, max_bounce: number, random: Function, scene: PathTracedScene): void;
 }
+import { Ray3 } from "../../../../core/geom/3d/Ray3.js";
 //# sourceMappingURL=PathTracer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracer.js"],"names":[],"mappings":"AA2BA;IAGI;;;;;;;;;OASG;IACH,gBARW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,cACN,MAAM,cACN,MAAM,kDAgFhB;CACJ"}
+{"version":3,"file":"PathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracer.js"],"names":[],"mappings":"AAiCA;IAGI;;;;;;;;OAQG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,EAAE,GAAC,YAAY,GAAC,IAAI,cAC1B,MAAM,cACN,MAAM,kDAkFhB;CACJ;qBA1HoB,kCAAkC"}