@woosh/meep-engine 2.109.6 → 2.109.8

package/src/engine/graphics/sh3/gi/material/space_vertex/build_fragment_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_fragment_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/gi/material/space_vertex/build_fragment_shader.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,8CAFW,MAAM,UAchB"}

package/src/engine/graphics/sh3/gi/material/space_vertex/build_fragment_shader.js

@@ -0,0 +1,26 @@
+import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+
+import PREAMBLE from "./preable.frag.glsl";
+
+const ACCUMULATION = `
+    irradiance += getLightProbeIrradiance(lpv_values, geometryNormal )* lpv_f_intensity;
+`;
+
+
+/**
+ *
+ * @param {string} source
+ */
+export function build_fragment_shader(source) {
+
+    let result = PREAMBLE + source;
+
+
+    result = insert_after(
+        result,
+        '#include <lights_fragment_begin>',
+        ACCUMULATION
+    );
+
+    return result;
+}

package/src/engine/graphics/sh3/gi/material/space_vertex/build_vertex_shader.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param {string} source
+ */
+export function build_vertex_shader(source: string): string;
+//# sourceMappingURL=build_vertex_shader.d.ts.map

package/src/engine/graphics/sh3/gi/material/space_vertex/build_vertex_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_vertex_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/gi/material/space_vertex/build_vertex_shader.js"],"names":[],"mappings":"AA6CA;;;GAGG;AACH,4CAFW,MAAM,UAchB"}

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

@@ -0,0 +1,62 @@
+import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+import PREAMBLE_COMMON from "../common.glsl";
+
+import PREAMBLE from "./preable.vert.glsl";
+
+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);
+    
+        weights = lvp_mask_weights_by_visibility(worldPosition.xyz, 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 + PREAMBLE_COMMON + source;
+
+    result = insert_after(
+        result,
+        '#include <fog_vertex>',
+        SHADER_CHUNK_ACCUMULATION
+    );
+
+    // console.log(result)
+
+    return result;
+}

package/src/engine/graphics/sh3/gi/material/space_vertex/preable.frag.glsl

@@ -0,0 +1,43 @@
+uniform float lpv_f_intensity;
+
+varying vec3[9] lpv_values;
+
+// vec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
+//     // normal is assumed to have unit length
+//     float x = normal.x, y = normal.y, z = normal.z;
+//
+//     // band 0
+//     vec3 result = shCoefficients[ 0 ] * 0.886227;
+//
+//     // band 1
+//     result -= shCoefficients[ 1 ] * 2.0 * 0.511664 * y;
+//     result += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;
+//     result -= shCoefficients[ 3 ] * 2.0 * 0.511664 * x;
+//
+//     // band 2
+//     result += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;
+//     result -= shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;
+//     result += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );
+//     result -= shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;
+//     result += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );
+//
+//     return result;
+// }
+//
+// vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {
+//
+//     // matrix is assumed to be orthogonal
+//
+//     return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );
+//
+// }
+//
+// vec3 lpv_getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {
+//
+//     vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+//
+//     vec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );
+//
+//     return irradiance;
+//
+// }

package/src/engine/graphics/sh3/gi/material/space_vertex/preable.vert.glsl

@@ -0,0 +1,9 @@
+#ifndef LPV_SHADER_CHUNK_PREAMBLE
+#define LPV_SHADER_CHUNK_PREAMBLE
+
+precision highp usampler2D;
+precision highp usampler3D;
+
+varying vec3[9] lpv_values;
+
+#endif

package/src/engine/graphics/sh3/gi/material/space_vertex/space_vertex_transform_shader.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {{vertexShader, fragmentShader}} shader
+ */
+export function space_vertex_transform_shader(shader: {
+    vertexShader;
+    fragmentShader;
+}): void;
+//# sourceMappingURL=space_vertex_transform_shader.d.ts.map

package/src/engine/graphics/sh3/gi/material/space_vertex/space_vertex_transform_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space_vertex_transform_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/gi/material/space_vertex/space_vertex_transform_shader.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,sDAFW;IAAC,YAAY,CAAC;IAAC,cAAc,CAAA;CAAC,QAMxC"}

package/src/engine/graphics/sh3/gi/material/space_vertex/space_vertex_transform_shader.js

@@ -0,0 +1,12 @@
+import { build_fragment_shader } from "./build_fragment_shader.js";
+import { build_vertex_shader } from "./build_vertex_shader.js";
+
+/**
+ *
+ * @param {{vertexShader, fragmentShader}} shader
+ */
+export function space_vertex_transform_shader(shader) {
+
+    shader.vertexShader = build_vertex_shader(shader.vertexShader);
+    shader.fragmentShader = build_fragment_shader(shader.fragmentShader);
+}

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

@@ -8,6 +8,8 @@ export class LightProbeVolume {
     get mesh(): TetrahedralMesh;
     get points(): number[];
     get harmonics(): number[];
+    get depth_map_resolution(): number;
+    get depth(): number[];
     set count(arg: number);
     get count(): number;
     /**

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":"AAUA;IAmBI,sBAEC;IAED,cAQC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;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;gCAnJ+B,wDAAwD;2BAC7D,mCAAmC"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAED,mCAEC;IAED,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;gCAnL+B,wDAAwD;2BAC7D,mCAAmC"}

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

@@ -20,11 +20,25 @@ export class LightProbeVolume {
     #mesh = new TetrahedralMesh();
 
     /**
-     *
+     * Probe irradiance color data
+     * Base-3 spherical harmonics, 9 coefficients per color channel for a total of 27 coefficients per probe
      * @type {number[]}
      */
     #sh3_rgb = [];
 
+    /**
+     * Resolution of an individual depth map for a probe
+     * Depth map is stored as a 2d texture of size RESOLUTION x RESOLUTION
+     * @type {number}
+     */
+    #probe_depth_resolution = 16;
+
+    /**
+     * Octahedral-encoded depth map for each probe
+     * @type {number[]}
+     */
+    #probe_depth = [];
+
     #probe_count = 0;
 
     get version() {
@@ -32,8 +46,18 @@ export class LightProbeVolume {
     }
 
     clear() {
-        this.#probe_positions.splice(0, this.#probe_positions.length);
-        this.#sh3_rgb.splice(0, this.#sh3_rgb.length);
+        if (this.#probe_positions.length > 0) {
+            this.#probe_positions = [];
+        }
+
+        if (this.#sh3_rgb.length > 0) {
+            this.#sh3_rgb = [];
+        }
+
+        if (this.#probe_depth.length > 0) {
+            this.#probe_depth = [];
+        }
+
         this.#mesh.clear();
 
         this.#probe_count = 0;
@@ -57,6 +81,14 @@ export class LightProbeVolume {
         return this.#sh3_rgb;
     }
 
+    get depth_map_resolution() {
+        return this.#probe_depth_resolution;
+    }
+
+    get depth() {
+        return this.#probe_depth;
+    }
+
     get count() {
         return this.#probe_count;
     }

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":"AAMA;IAGI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CA+CrB;CACJ;wCA1DuC,8BAA8B;sBAJhD,4CAA4C"}
+{"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,CAgErB;CACJ;wCA1EuC,8BAA8B;sBALhD,4CAA4C"}

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

@@ -2,11 +2,11 @@ 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";
 import { promiseTask } from "../../../../core/process/task/util/promiseTask.js";
+import { find_max_depth_radius_for_point } from "./find_max_depth_radius_for_point.js";
 import { PathTracerProbeRenderer } from "./PathTracerProbeRenderer.js";
 
 export class LightProbeVolumeBaker {
 
-    // this._ren = new WebGLCubeProbeRenderer();
     _ren = new PathTracerProbeRenderer();
 
 
@@ -29,23 +29,40 @@ export class LightProbeVolumeBaker {
 
         const probe_count = lpv.count;
 
-        const tBake = countTask(0, probe_count, (i) => {
+        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 + 0.00001;
+
+            const depth_resolution = lpv.depth_map_resolution;
+
+            renderer.bake_depth_octahedral(
+                depth_resolution,
+                max_depth,
+                lpv.points, i * 3,
+                lpv.depth, i * depth_resolution * depth_resolution
+            );
+
         });
-        tBake.estimatedDuration = probe_count;
+        tBakeIrradiance.estimatedDuration = probe_count;
 
-        tBake.promise().then(() => {
+        tBakeIrradiance.promise().then(() => {
 
-            const duration = tBake.__executedCpuTime;
+            const duration = tBakeIrradiance.__executedCpuTime;
 
             console.log(`Baked ${probe_count} probes in ${duration}ms, ~${(duration / probe_count).toFixed(2)}ms per probe`);
 
-        })
+        });
 
         const tFinish = actionTask(() => {
             renderer.bake_end();
@@ -53,11 +70,11 @@ export class LightProbeVolumeBaker {
             lpv.incrementVersion();
         });
 
-        tFinish.addDependency(tBake);
-        tBake.addDependency(tPrepare);
+        tFinish.addDependency(tBakeIrradiance);
+        tBakeIrradiance.addDependency(tPrepare);
 
         return new TaskGroup([
-            tPrepare, tBake, tFinish
+            tPrepare, tBakeIrradiance, tFinish
         ], "LightProbeVolume Bake");
     }
 }

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

@@ -1,9 +1,19 @@
 export class PathTracerProbeRenderer extends ProbeRenderer {
     tracer: PathTracer;
+    max_bounce_count: number;
     sample_count: number;
     random: () => number;
     scene: PathTracedScene;
-    bake_depth(position: any, position_offset: any, output: any, output_offset: any): void;
+    /**
+     *
+     * @param {number} resolution
+     * @param {number} max_depth
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     */
+    bake_depth_octahedral(resolution: number, max_depth: number, position: number[], position_offset: number, output: number[], output_offset: number): void;
     bake(position: any, position_offset: any, output: any, output_offset: any): void;
     bake_start(): void;
     build_scene(ecd: any): void;

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

@@ -1 +1 @@
-{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AA2BA;IACI,mBAA0B;IAC1B,qBAAmB;IACnB,qBAAyB;IAEzB,uBAA6B;IAE7B,uFAoBC;IAED,iFAqCC;IAKD,mBACC;IAED,4BAsCC;CACJ;8BA3H6B,oBAAoB;2BADvB,8BAA8B;gCADzB,mCAAmC"}
+{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AAuBA;IACI,mBAA0B;IAC1B,yBAAqB;IACrB,qBAAmB;IACnB,qBAAyB;IAEzB,uBAA6B;IAE7B;;;;;;;;OAQG;IACH,kCAPW,MAAM,aACN,MAAM,YACN,MAAM,EAAE,mBACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAahB;IAED,iFAuCC;IAKD,mBACC;IAED,4BAKC;CACJ;8BA5F6B,oBAAoB;2BAHvB,8BAA8B;gCADzB,mCAAmC"}

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

@@ -8,15 +8,11 @@ import { sh3_vector_accumulate } from "../../../../core/geom/3d/sphere/harmonics
 import { randomPointOnSphere } from "../../../../core/geom/random/randomPointOnSphere.js";
 import { vector_scale_array } from "../../../../core/geom/vec/vector_scale_array.js";
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
-import { Light } from "../../ecs/light/Light.js";
-import { LightType } from "../../ecs/light/LightType.js";
-import { ShadedGeometry } from "../../ecs/mesh-v2/ShadedGeometry.js";
-import { DirectionalLight } from "../../render/forward_plus/model/DirectionalLight.js";
 import { PathTracedScene } from "../path_tracer/PathTracedScene.js";
 import { PathTracer } from "../path_tracer/PathTracer.js";
+import { populate_path_traced_scene_from_ecd } from "../path_tracer/populate_path_traced_scene_from_ecd.js";
+import { bake_octahedral_depth_map } from "./depth/octahedral/bake_octahedral_depth_map.js";
 import { ProbeRenderer } from "./ProbeRenderer.js";
-import { sh3_bake_depth } from "./sh3_bake_depth.js";
 
 const __shared_buffer = new ArrayBuffer((27 + 9) * 8);
 const sh_basis = new Float64Array(__shared_buffer, 0, 9);
@@ -27,31 +23,32 @@ const sampled_irradiance = new Float32Array(3);
 
 export class PathTracerProbeRenderer extends ProbeRenderer {
     tracer = new PathTracer();
-    sample_count = 256;
+    max_bounce_count = 7;
+    sample_count = 192;
     random = seededRandom(0);
 
     scene = new PathTracedScene()
 
-    bake_depth(position, position_offset, output, output_offset) {
-
-        sh3_bake_depth(
-            coefficients, 0, this.scene,
-            position[position_offset],
-            position[position_offset + 1],
-            position[position_offset + 2],
-            1.5
+    /**
+     *
+     * @param {number} resolution
+     * @param {number} max_depth
+     * @param {number[]} position
+     * @param {number} position_offset
+     * @param {number[]} output
+     * @param {number} output_offset
+     */
+    bake_depth_octahedral(
+        resolution, max_depth,
+        position, position_offset,
+        output, output_offset
+    ) {
+        bake_octahedral_depth_map(
+            output, output_offset,
+            this.scene,
+            position, position_offset,
+            resolution, max_depth
         );
-
-        sh3_dering_optimize_positive(coefficients, 0, coefficients, 0, 1);
-
-        for (let i = 0; i < 9; i++) {
-            const coefficient = coefficients[i];
-
-            for (let j = 0; j < 3; j++) {
-                output[output_offset + i * 3 + j] = coefficient;
-            }
-        }
-
     }
 
     bake(position, position_offset, output, output_offset) {
@@ -65,13 +62,15 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
 
         coefficients.fill(0);
 
+        const max_bounce = this.max_bounce_count;
+
         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, 1, 7, this.random, this.scene);
+            tracer.path_trace(sampled_irradiance, ray, 1, max_bounce, this.random, this.scene);
 
             sh3_basis_at(ray[3], ray[4], ray[5], sh_basis);
 
@@ -102,40 +101,7 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
     build_scene(ecd) {
 
         const scene = this.scene;
-
-        ecd.traverseEntities([ShadedGeometry, Transform],
-            /**
-             *
-             * @param {ShadedGeometry} sg
-             * @param {Transform} transform
-             */
-            (sg, transform) => {
-
-                scene.createMesh(sg.geometry, sg.material, transform.matrix)
-
-            });
-
-
-        ecd.traverseEntities([Light, Transform],
-            /**
-             *
-             * @param {Light} light
-             * @param {Transform} transform
-             */
-            (light, transform) => {
-
-                if (light.type.getValue() === LightType.DIRECTION) {
-
-                    const l = new DirectionalLight();
-
-                    l.color.copy(light.color);
-                    l.direction.copy(transform.forward);
-                    l.intensity.copy(light.intensity);
-
-                    scene.addLight(l);
-                }
-
-            });
+        populate_path_traced_scene_from_ecd(ecd, scene);
 
     }
 }

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":"AAWA;;;;;;;;GAQG;AACH,iFAPW,gBAAgB,GAKd,QAAQ,gBAAgB,CAAC,CAmFrC;iCA7FgC,uBAAuB"}
+{"version":3,"file":"build_probes_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/build_probes_for_scene.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,iFAPW,gBAAgB,GAKd,QAAQ,gBAAgB,CAAC,CAoFrC;iCA9FgC,uBAAuB"}

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

@@ -1,6 +1,7 @@
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { make_justified_point_grid } from "../../../../core/geom/3d/util/make_justified_point_grid.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
+import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { delay } from "../../../../core/process/delay.js";
 import Entity from "../../../ecs/Entity.js";
 import GUIElement from "../../../ecs/gui/GUIElement.js";
@@ -49,12 +50,13 @@ export async function build_probes_for_scene(
 
 
     // sg_hierarchy_compute_bounding_box_via_parent_entity(light_volume_bounds, composition.entity.entity, ecd);
+    const random = seededRandom(1);
 
-    // for (let i = 0; i < 100; i++) {
-    //     lpv.add_point(
-    //         randomFloatBetween(random, light_volume_bounds.x0, light_volume_bounds.x1),
-    //         randomFloatBetween(random,  light_volume_bounds.y0, light_volume_bounds.y1),
-    //         randomFloatBetween(random,  light_volume_bounds.z0, light_volume_bounds.z1),
+    // for (let i = 0; i < 1000; i++) {
+    //     volume.add_point(
+    //         randomFloatBetween(random, model_bounds.x0, model_bounds.x1),
+    //         randomFloatBetween(random, model_bounds.y0, model_bounds.y1),
+    //         randomFloatBetween(random, model_bounds.z0, model_bounds.z1),
     //     );
     // }
 
@@ -64,7 +66,7 @@ export async function build_probes_for_scene(
 
     // lpv.add_point(10, 1, -10);
 
-    await delay(2000);
+    await delay(1);
 
     //
     // console.profile('lpv build');

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

@@ -0,0 +1,17 @@
+export class OctahedralDepthDebuggerWidget {
+    update(): void;
+    /**
+     *
+     * @returns {Entity}
+     */
+    get entity(): Entity;
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {Engine} engine
+     */
+    build(ecd: EntityComponentDataset, engine: Engine): void;
+    #private;
+}
+import Entity from "../../../../../ecs/Entity.js";
+//# sourceMappingURL=OctahedralDepthDebuggerWidget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OctahedralDepthDebuggerWidget.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/OctahedralDepthDebuggerWidget.js"],"names":[],"mappings":"AAUA;IA6CI,eAYC;IAED;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,yDAeC;;CAEJ;mBAjGkB,8BAA8B"}

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

@@ -0,0 +1,100 @@
+import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, OctahedronBufferGeometry, RedFormat } from "three";
+import { TransformControls } from "../../../../../../../editor/tools/v2/TransformControls.js";
+import Entity from "../../../../../ecs/Entity.js";
+import { Transform } from "../../../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../../../../ecs/mesh-v2/ShadedGeometry.js";
+import { PathTracedScene } from "../../../path_tracer/PathTracedScene.js";
+import { populate_path_traced_scene_from_ecd } from "../../../path_tracer/populate_path_traced_scene_from_ecd.js";
+import { bake_octahedral_depth_map } from "./bake_octahedral_depth_map.js";
+import { OctahedralDepthVisualizationMaterial } from "./shader/OctahedralDepthVisualizationMaterial.js";
+
+export class OctahedralDepthDebuggerWidget {
+
+    /**
+     * @type {PathTracedScene}
+     */
+    #scene = new PathTracedScene();
+
+    #resolution = 64;
+
+    #texture = new DataTexture(
+        new Float32Array(this.#resolution * this.#resolution),
+        this.#resolution,
+        this.#resolution,
+        RedFormat,
+        FloatType
+    );
+
+    #entity = new Entity();
+
+    constructor() {
+        this.#texture.generateMipmaps = false;
+
+        this.#texture.magFilter = NearestFilter;
+        this.#texture.minFilter = NearestFilter;
+
+        this.#texture.wrapT = ClampToEdgeWrapping;
+        this.#texture.wrapS = ClampToEdgeWrapping;
+
+        this.#texture.flipY = false;
+
+
+        const material = new OctahedralDepthVisualizationMaterial();
+
+        material.texture = this.#texture;
+        material.scale = 10;
+
+        const transform = new Transform();
+        this.#entity.add(transform);
+        this.#entity.add(ShadedGeometry.from(new OctahedronBufferGeometry(1, 4), material));
+
+
+        transform.position.onChanged.add(this.update, this);
+
+    }
+
+    update() {
+
+        console.time('depth build');
+        bake_octahedral_depth_map(
+            this.#texture.image.data, 0,
+            this.#scene,
+            this.#entity.getComponentSafe(Transform).position, 0,
+            this.#resolution, 100
+        );
+        console.timeEnd('depth build');
+
+        this.#texture.needsUpdate = true;
+    }
+
+    /**
+     *
+     * @returns {Entity}
+     */
+    get entity() {
+        return this.#entity;
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {Engine} engine
+     */
+    build(ecd, engine) {
+
+        populate_path_traced_scene_from_ecd(ecd, this.#scene);
+
+        this.update();
+
+        this.#entity.build(ecd);
+
+
+        const gizmo = new TransformControls(engine.graphics.camera, engine.graphics.domElement, true);
+
+        gizmo.build(ecd);
+
+
+        gizmo.attach(this.#entity.id);
+    }
+
+}