@woosh/meep-engine 2.108.2 → 2.108.4

package/src/engine/graphics/sh3/gi/material/build_vertex_shader.js

@@ -0,0 +1,256 @@
+import { insert_after } from "../../../../../core/primitives/strings/insert_after.js";
+
+const PREAMBLE = `
+    #ifndef LPV_SHADER_CHUNK_PREAMBLE
+        #define LPV_SHADER_CHUNK_PREAMBLE
+        
+        precision highp usampler2D;
+        precision highp usampler3D;
+        
+        uniform usampler2D lpv_t_mesh_vertices;
+        uniform usampler2D lpv_t_mesh_neighbours;
+        uniform usampler3D lpv_t_mesh_lookup;
+        
+        uniform sampler2D lpv_t_probe_positions;
+        uniform sampler2D lpv_t_probe_data;
+        
+        uniform uint lpv_u_mesh_tet_count;
+        uniform vec3 lpv_v3_bounds_min;
+        uniform vec3 lpv_v3_bounds_max;
+        
+        varying vec3[9] lpv_values;
+        
+        #define SEARCH_STEP_LIMIT 64u
+        #define INVALID_TET 1073741823u
+        
+        ivec2 lpv_index_to_256_coordinate(uint index){
+        
+            uint pixel_x = index % 256u;
+            uint pixel_y = index / 256u; 
+            
+            return ivec2(int(pixel_x), int(pixel_y));
+        }
+        
+        uvec4 lpv_mesh_getVertices(uint tet_index){
+            ivec2 p = lpv_index_to_256_coordinate(tet_index);
+                    
+            return texelFetch(lpv_t_mesh_vertices, p, 0);
+            
+        }
+        
+        uvec4 lpv_mesh_getNeighbours(uint tet_index){
+            ivec2 p = lpv_index_to_256_coordinate(tet_index);
+            
+            return texelFetch(lpv_t_mesh_neighbours, p, 0);
+        }
+        
+        vec3[9] lpv_probe_getData(uint probe_index){
+            
+            
+            int slot = int( probe_index % 256u );
+            int column = int(probe_index / 256u); 
+            
+            int offset_x = int(slot * 9);
+            
+            vec3[9] result;
+            
+            for(int i=0; i<9; i++){
+                result[i] = texelFetch(lpv_t_probe_data, ivec2(offset_x + i, column),0).rgb;
+            }
+            
+            return result;
+        }
+        
+        vec3 lpv_probe_getPosition(uint probe_index){
+            return texelFetch(lpv_t_probe_positions, lpv_index_to_256_coordinate(probe_index), 0).rgb;
+        }
+        
+        mat3 lpv_mesh_makeMatrix(vec3 p0, vec3 p1, vec3 p2, vec3 p3){
+        
+            return inverse(
+                mat3(
+                    p0 - p3,
+                    p1 - p3,
+                    p2 - p3
+                )
+            );
+        
+        }
+        
+        vec4 lpv_mesh_getBarycentricCoordinates(uint tet_index, vec3 position){
+            uvec4 vertices = lpv_mesh_getVertices(tet_index);
+               
+            vec3 p0 = lpv_probe_getPosition(vertices[0]);
+            vec3 p1 = lpv_probe_getPosition(vertices[1]);
+            vec3 p2 = lpv_probe_getPosition(vertices[2]);
+            vec3 p3 = lpv_probe_getPosition(vertices[3]);
+        
+            mat3 matrix = lpv_mesh_makeMatrix(p0, p1, p2, p3);
+            
+            vec3 mult = matrix * (position - p3);
+            
+            return vec4(mult, 1.0 - mult.x - mult.y - mult.z);
+        }
+        
+        void lpv_getTetrahedron(
+            in vec3 position ,
+            in uint tet_guess,
+            out uint tet_index,
+            out vec4 weights
+        ){
+            uint came_from = 0u;
+            
+            tet_index = tet_guess;
+                    
+            for(uint i=0u; i < SEARCH_STEP_LIMIT; i++){
+            
+                weights = lpv_mesh_getBarycentricCoordinates(tet_index, position);
+            
+                if(weights.x >= 0.0 && weights.y >= 0.0 && weights.z >= 0.0 && weights.w >= 0.0){
+                    return;
+                }
+                
+                uvec4 neighbors = lpv_mesh_getNeighbours(tet_index);
+                
+                uint next_tet;
+                
+                // Otherwise find the smallest barycentric coord and move in that direction
+                if (weights.x < weights.y && weights.x < weights.z && weights.x < weights.w) {
+                    next_tet = neighbors[0];
+                } else if (weights.y < weights.z && weights.y < weights.w) {
+                    next_tet = neighbors[1];
+                } else if (weights.z < weights.w) {
+                    next_tet = neighbors[2];
+                } else {
+                    next_tet = neighbors[3];
+                }
+                
+                if(next_tet == came_from){
+                    // numerical instability caused us to oscillate on the boundary
+                    return;
+                }
+                
+                came_from = tet_index;  
+                tet_index = next_tet;
+            }
+        
+            tet_index = INVALID_TET;
+        }
+        
+        vec3[9] lpv_interpolate_probes(vec4 weights, uint tet_index){
+            
+            uvec4 vertices = lpv_mesh_getVertices(tet_index);
+            
+            vec3[9] probe0 = lpv_probe_getData(vertices[0]);
+            vec3[9] probe1 = lpv_probe_getData(vertices[1]);
+            vec3[9] probe2 = lpv_probe_getData(vertices[2]);
+            vec3[9] probe3 = lpv_probe_getData(vertices[3]);
+        
+            vec3[9] result;
+            
+            for(int i=0; i< 9; i++){
+                
+                result[i] = probe0[i]* weights[0]
+                            + probe1[i]* weights[1]
+                            + probe2[i]* weights[2]
+                            + probe3[i]* weights[3];
+            
+            }
+            
+            return result;
+        }
+        
+        vec4 lpv_bias_weight_by_normal(const in vec3 position, const in vec3 normal, const in uint tet_index, const in vec4 weights){
+            
+            uvec4 vertices = lpv_mesh_getVertices(tet_index);
+            
+            vec4 result = weights;
+            
+            for(int i = 0; i< 4; i++){
+                vec3 p = lpv_probe_getPosition(vertices[i]) - position;
+                
+                if(dot(normal, p) <= 0.0){
+                    // behind the surface, bias to 0
+                    result[i] = 0.0;
+                }
+            }
+            
+            float total_weight = result.x + result.y + result.z + result.w;
+            
+            // needs to add up to 1
+            result = result / total_weight;
+            
+            return result;
+        }
+        
+        uint lpv_guess_initial_tet(vec3 position){
+            
+            vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
+            vec3 lpv_mesh_bounds_max = lpv_v3_bounds_max;
+            
+            vec3 lookup_coordinates = (position - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min) ;
+           
+            return textureLod( lpv_t_mesh_lookup, lookup_coordinates, 0.0 ).r;
+        
+        }
+        
+    #endif
+`;
+
+
+const SHADER_CHUNK_ACCUMULATION = `
+    {
+        // lookup nearby tet
+        vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
+        vec3 lpv_mesh_bounds_max = lpv_v3_bounds_max;
+        vec3 lookup_coordinates = (worldPosition.xyz - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min) ;
+        
+        uint nearest_tet = lpv_guess_initial_tet( worldPosition.xyz );
+    
+        uint tet;
+        vec4 weights;
+        lpv_getTetrahedron(worldPosition.xyz, nearest_tet, tet, weights);
+        
+        
+        if(tet == INVALID_TET){
+            lpv_values = vec3[](
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+            
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0),
+                vec3(0.0, 0.0, 0.0)
+            );
+        }else{
+            
+	        vec3 worldNormal = normalize(inverseTransformDirection( normalize(normal), viewMatrix ));
+            
+            //weights = lpv_bias_weight_by_normal(worldPosition.xyz, normal, tet, weights);
+        
+            lpv_values = lpv_interpolate_probes(weights, tet);
+        }
+    }
+`
+
+/**
+ *
+ * @param {string} source
+ */
+export function build_vertex_shader(source) {
+    let result = PREAMBLE + source;
+
+    result = insert_after(
+        result,
+        '#include <fog_vertex>',
+        SHADER_CHUNK_ACCUMULATION
+    );
+
+    // console.log(result)
+
+    return result;
+}

package/src/engine/graphics/sh3/gi/tetrahedral_mesh_to_texture.js

@@ -31,9 +31,6 @@ export function tetrahedral_mesh_to_texture(
     vertices.resize(tetrahedron_count);
     neighbours.resize(tetrahedron_count);
 
-    vertices.build()
-    neighbours.build();
-
     const vertices_data = vertices.data;
     const neighbours_data = neighbours.data;
 
@@ -44,8 +41,11 @@ export function tetrahedral_mesh_to_texture(
         for (let j = 0; j < 4; j++) {
             vertices_data[i4 + j] = mesh.getVertexIndex(i, j);
 
-            neighbours_data[i4 + j] = mesh.getNeighbour(i, j);
+            neighbours_data[i4 + j] = mesh.getNeighbour(i, j) >>> 2;
         }
 
     }
+
+    vertices.texture.needsUpdate = true;
+    neighbours.texture.needsUpdate = true;
 }

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

@@ -1,4 +1,5 @@
 export class LightProbeVolume {
+    get version(): number;
     __positions: any[];
     __mesh: TetrahedralMesh;
     __probe_data: any[];
@@ -53,10 +54,11 @@ export class LightProbeVolume {
     visualize_mesh({ ecd, color, opacity }: EntityComponentDataset): void;
     /**
      *
-     * @returns {TaskGroup}
      * @param {EntityComponentDataset} ecd
+     * @returns {TaskGroup}
      */
     build(ecd: EntityComponentDataset): TaskGroup;
+    #private;
 }
 import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
 import TaskGroup from "../../../../core/process/task/TaskGroup.js";

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":"AAiJA;IAEQ,mBAAqB;IAErB,wBAAmC;IAEnC,oBAAsB;IAEtB,iBAAiB;IAGrB,cAMC;IAED;;;OAGG;IACH,4BAEC;IAED,oBAEC;IAED,uBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;OAIG;IACH,mCAHa,SAAS,CA4CrB;IAED;;;;;OAKG;IACH,sEAWC;IAED;;;;;OAKG;IACH,sEAkBC;IAED;;;;OAIG;IACH,oCAHa,SAAS,CAMrB;CACJ;gCA1U+B,wDAAwD;sBAClE,4CAA4C"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAkJA;IAGI,sBAEC;IAGG,mBAAqB;IAErB,wBAAmC;IAEnC,oBAAsB;IAEtB,iBAAiB;IAGrB,cAQC;IAED;;;OAGG;IACH,4BAEC;IAED,oBAEC;IAED,uBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAchB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;OAIG;IACH,mCAHa,SAAS,CA8CrB;IAED;;;;;OAKG;IACH,sEAWC;IAED;;;;;OAKG;IACH,sEAkBC;IAED;;;;OAIG;IACH,oCAFa,SAAS,CAKrB;;CACJ;gCArV+B,wDAAwD;sBAClE,4CAA4C"}

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

@@ -42,6 +42,7 @@ class Baker {
         this.__min_bounce_count = 3;
         this.__max_bounce_count = 100;
 
+        // this._ren = new WebGLCubeProbeRenderer();
         this._ren = new PathTracerProbeRenderer();
     }
 
@@ -144,6 +145,12 @@ class Baker {
 }
 
 export class LightProbeVolume {
+    #version = 0;
+
+    get version() {
+        return this.#version;
+    }
+
     constructor() {
         this.__positions = [];
 
@@ -160,6 +167,8 @@ export class LightProbeVolume {
         this.__mesh.clear();
 
         this.__length = 0;
+
+        this.#version++;
     }
 
     /**
@@ -273,6 +282,8 @@ export class LightProbeVolume {
 
         const tFinish = actionTask(() => {
             baker.finish();
+
+            this.#version++;
         });
 
         tFinish.addDependency(tBake);
@@ -330,8 +341,8 @@ export class LightProbeVolume {
 
     /**
      *
-     * @returns {TaskGroup}
      * @param {EntityComponentDataset} ecd
+     * @returns {TaskGroup}
      */
     build(ecd) {
         this.build_mesh();

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

@@ -1,11 +1,12 @@
 /**
  *
+ * @param {LightProbeVolume} volume
  * @param {Engine} engine
  * @param {EntityComponentDataset} ecd
  * @param {AABB3} bounds
  * @param {number} [density]
  * @returns {Promise<LightProbeVolume>}
  */
-export function build_probes_for_scene({ engine, ecd, bounds, density }: Engine): Promise<LightProbeVolume>;
+export function build_probes_for_scene({ volume, engine, ecd, bounds, density }: LightProbeVolume): Promise<LightProbeVolume>;
 import { LightProbeVolume } from "./LightProbeVolume.js";
 //# sourceMappingURL=build_probes_for_scene.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build_probes_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/build_probes_for_scene.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,kFAFa,QAAQ,gBAAgB,CAAC,CA8GrC;iCAtHgC,uBAAuB"}
+{"version":3,"file":"build_probes_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/build_probes_for_scene.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,iFAPW,gBAAgB,GAKd,QAAQ,gBAAgB,CAAC,CA6GrC;iCAtHgC,uBAAuB"}

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

@@ -10,6 +10,7 @@ import { LightProbeVolume } from "./LightProbeVolume.js";
 
 /**
  *
+ * @param {LightProbeVolume} volume
  * @param {Engine} engine
  * @param {EntityComponentDataset} ecd
  * @param {AABB3} bounds
@@ -18,6 +19,7 @@ import { LightProbeVolume } from "./LightProbeVolume.js";
  */
 export async function build_probes_for_scene(
     {
+        volume = new LightProbeVolume(),
         engine,
         ecd,
         bounds,
@@ -25,8 +27,6 @@ export async function build_probes_for_scene(
     }
 ) {
 
-    const lpv = new LightProbeVolume();
-
     // lpv.add_point(10, 5, 10);
 
     // const desired_density = 8000;
@@ -58,7 +58,7 @@ export async function build_probes_for_scene(
     // }
 
     make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
-        lpv.add_point(x, y, z);
+        volume.add_point(x, y, z);
     });
 
     // lpv.add_point(10, 1, -10);
@@ -68,7 +68,7 @@ export async function build_probes_for_scene(
     //
     // console.profile('lpv build');
     //
-    const task = lpv.build(ecd);
+    const task = volume.build(ecd);
     // console.profileEnd('lpv build');
 
     const progress = makeSimpleTaskProgressView({
@@ -119,9 +119,9 @@ export async function build_probes_for_scene(
     //     0.2137442, -0.0547578, -0.3061700], 0);
 
 
-    console.log(lpv);
+    console.log(volume);
 
     await task.promise();
 
-    return lpv;
+    return volume;
 }

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

@@ -8,5 +8,13 @@ export function probe_volume_to_textures(lpv: LightProbeVolume): {
     probe_positions: AttributeDataTexture;
     probe_values: AttributeDataTexture;
 };
+/**
+ *
+ * @param {AttributeDataTexture} target
+ * @param {number[]} points
+ * @param {number} point_count
+ * @param {number} dimensions
+ */
+export function vector_buffer_to_attribute_texture(target: AttributeDataTexture, points: number[], point_count: number, dimensions?: number): void;
 import { AttributeDataTexture } from "../../texture/AttributeDataTexture.js";
 //# sourceMappingURL=probe_volume_to_textures.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"probe_volume_to_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/probe_volume_to_textures.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH;;;;;EAuDC;qCA9DoC,uCAAuC"}
+{"version":3,"file":"probe_volume_to_textures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/probe_volume_to_textures.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH;;;;;EAuDC;AAED;;;;;;GAMG;AACH,2DALW,oBAAoB,UACpB,MAAM,EAAE,eACR,MAAM,eACN,MAAM,QAiBhB;qCAtFoC,uCAAuC"}

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

@@ -72,7 +72,7 @@ export function probe_volume_to_textures(lpv) {
  * @param {number} point_count
  * @param {number} dimensions
  */
-function vector_buffer_to_attribute_texture(
+export function vector_buffer_to_attribute_texture(
     target,
     points,
     point_count,
@@ -83,7 +83,8 @@ function vector_buffer_to_attribute_texture(
     }
 
     target.resize(point_count);
-    target.build();
 
     array_copy(points, 0, target.data, 0, point_count * dimensions);
+
+    target.texture.needsUpdate = true;
 }

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":"AAsBA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAE1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,kBAAkB,CAAC,CAEjC;IAEtB;;;OAGG;IACH,UAFU,IAAI,MAAM,YAAY,CAEX;IAGrB;;;;OAIG;IACH,6BAA6C;IAE7C,iBAGC;IAED,uBAoCC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,kBAAkB,CAgB7B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QA6CvB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACL,MAAM,CAwCjB;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;oBA9VmB,mCAAmC;+BAaxB,qBAAqB;8BALtB,kDAAkD;mCAG7C,yBAAyB"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAuBA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAE1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,kBAAkB,CAAC,CAEjC;IAEtB;;;OAGG;IACH,UAFU,IAAI,MAAM,YAAY,CAEX;IAGrB;;;;OAIG;IACH,6BAA6C;IAE7C,iBAGC;IAED,uBAqCC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,kBAAkB,CAmB7B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QA6CvB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACL,MAAM,CAwCjB;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;oBAnWmB,mCAAmC;+BAcxB,qBAAqB;8BALtB,kDAAkD;mCAG7C,yBAAyB"}

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

@@ -7,6 +7,7 @@ import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matri
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { TextureAttachmentsByMaterialType } from "../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
+import { compute_geometry_polycount } from "../../geometry/compute_geometry_polycount.js";
 import { AbstractLight } from "../../render/forward_plus/model/AbstractLight.js";
 import { convertTexture2Sampler2D } from "../../texture/sampler/convertTexture2Sampler2D.js";
 import { ensureGeometryBoundingBox } from "../../util/ensureGeometryBoundingBox.js";
@@ -67,6 +68,7 @@ export class PathTracedScene {
     }
 
     async build() {
+
         for (const [id, mesh] of this.meshes) {
             const material = mesh.material;
 
@@ -116,13 +118,16 @@ export class PathTracedScene {
             return cached;
         }
 
-        const bvh8 = new GeometryBVHBatched();
+        const bvh = new GeometryBVHBatched();
 
-        bvh8.build(geo);
+        const label = `bvh build ${compute_geometry_polycount(geo)}`;
+        console.time(label);
+        bvh.build(geo);
+        console.timeEnd(label);
 
-        this.geo_cache.set(geo, bvh8);
+        this.geo_cache.set(geo, bvh);
 
-        return bvh8;
+        return bvh;
     }
 
     /**

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

@@ -1,14 +1,14 @@
 export class PathTracer {
     /**
      *
-     * @param {number[]} out
-     * @param {number[]} ray
+     * @param {number[]|Float32Array} out
+     * @param {number[]|Float32Array} ray
      * @param {number} max_distance
      * @param {number} min_bounce
      * @param {number} max_bounce
      * @param {function} random
      * @param {PathTracedScene} scene
      */
-    path_trace(out: number[], ray: number[], max_distance: number, min_bounce: number, max_bounce: number, random: Function, scene: PathTracedScene): void;
+    path_trace(out: number[] | Float32Array, ray: number[] | Float32Array, max_distance: number, min_bounce: number, max_bounce: number, random: Function, scene: PathTracedScene): void;
 }
 //# 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,OACR,MAAM,EAAE,gBACR,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":"AA2BA;IAGI;;;;;;;;;OASG;IACH,gBARW,MAAM,EAAE,GAAC,YAAY,OACrB,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,cACN,MAAM,cACN,MAAM,kDAgFhB;CACJ"}

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

@@ -30,8 +30,8 @@ export class PathTracer {
 
     /**
      *
-     * @param {number[]} out
-     * @param {number[]} ray
+     * @param {number[]|Float32Array} out
+     * @param {number[]|Float32Array} ray
      * @param {number} max_distance
      * @param {number} min_bounce
      * @param {number} max_bounce

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

@@ -6,7 +6,7 @@
  * @param {number[]|ArrayLike<number>} positions
  * @param {number} index_offset
  * @param {number} index_count
- * @param {number} d
+ * @param {number} dimension_count
  */
-export function compute_triangle_group_aabb3(output: number[] | Float32Array, output_offset: number, indices: number[] | ArrayLike<number>, positions: number[] | ArrayLike<number>, index_offset: number, index_count: number, d: number): void;
+export function compute_triangle_group_aabb3(output: number[] | Float32Array, output_offset: number, indices: number[] | ArrayLike<number>, positions: number[] | ArrayLike<number>, index_offset: number, index_count: number, dimension_count: number): void;
 //# sourceMappingURL=compute_triangle_group_aabb3.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compute_triangle_group_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,qDARW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,aAC1B,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,eACN,MAAM,KACN,MAAM,QAwBhB"}
+{"version":3,"file":"compute_triangle_group_aabb3.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,qDARW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,aAC1B,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,eACN,MAAM,mBACN,MAAM,QAkChB"}

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

@@ -1,5 +1,5 @@
-import { min2 } from "../../../../core/math/min2.js";
 import { max2 } from "../../../../core/math/max2.js";
+import { min2 } from "../../../../core/math/min2.js";
 
 /**
  * Compute AABB for a group of triangles based on index-buffer
@@ -9,27 +9,37 @@ import { max2 } from "../../../../core/math/max2.js";
  * @param {number[]|ArrayLike<number>} positions
  * @param {number} index_offset
  * @param {number} index_count
- * @param {number} d
+ * @param {number} dimension_count
  */
-export function compute_triangle_group_aabb3(output, output_offset, indices, positions, index_offset, index_count, d) {
+export function compute_triangle_group_aabb3(
+    output,
+    output_offset,
+    indices,
+    positions,
+    index_offset,
+    index_count,
+    dimension_count
+) {
 
     let i = 0;
-    for (; i < d; i++) {
+    for (; i < dimension_count; i++) {
+        // min bound
         output[output_offset + i] = Infinity;
-        output[output_offset + i + d] = -Infinity;
+        // max bound
+        output[output_offset + i + dimension_count] = -Infinity;
     }
 
     for (i = 0; i < index_count; i++) {
         for (let j = 0; j < 3; j++) {
             const index = indices[index_offset + i * 3 + j];
 
-            const i3 = index * d;
+            const i3 = index * dimension_count;
 
-            for (let k = 0; k < d; k++) {
+            for (let k = 0; k < dimension_count; k++) {
                 const v = positions[i3 + k];
 
                 output[output_offset + k] = min2(output[output_offset + k], v);
-                output[output_offset + k + d] = max2(output[output_offset + k + d], v);
+                output[output_offset + k + dimension_count] = max2(output[output_offset + k + dimension_count], v);
             }
         }
     }