@woosh/meep-engine 2.109.6 → 2.109.7

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 = 24;
+
+    /**
+     * 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":"AAmDA;IAGI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CA6DrB;CACJ;wCAhHuC,8BAA8B;sBAJhD,4CAA4C"}

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

@@ -1,9 +1,54 @@
+import { v3_distance_sqr } from "../../../../core/geom/vec3/v3_distance_sqr.js";
+import {
+    tetrahedral_mesh_find_tets_attached_to_vertex
+} from "../../../../core/geometry/3d/tetrahedra/tetrahedral_mesh_find_tets_attached_to_vertex.js";
+import { max2 } from "../../../../core/math/max2.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";
 import { promiseTask } from "../../../../core/process/task/util/promiseTask.js";
 import { PathTracerProbeRenderer } from "./PathTracerProbeRenderer.js";
 
+/**
+ *
+ * @param {number} vertex_index
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} points
+ */
+function find_max_depth_radius_for_point(vertex_index, mesh, points) {
+    const tets = [];
+
+    const count = tetrahedral_mesh_find_tets_attached_to_vertex(
+        tets, 0,
+        mesh,
+        vertex_index
+    );
+
+    const ref_x = points[vertex_index * 3];
+    const ref_y = points[vertex_index * 3 + 1];
+    const ref_z = points[vertex_index * 3 + 2];
+
+    let radius_sqr = 0;
+
+    for (let i = 0; i < count; i++) {
+        const tet = tets[i];
+
+        for (let j = 0; j < 4; j++) {
+            const v = mesh.getVertexIndex(tet, j);
+
+            const x = points[v * 3];
+            const y = points[v * 3 + 1];
+            const z = points[v * 3 + 2];
+
+            const r2 = v3_distance_sqr(ref_x, ref_y, ref_z, x, y, z);
+
+            radius_sqr = max2(r2, radius_sqr);
+        }
+    }
+
+    return Math.sqrt(radius_sqr);
+}
+
 export class LightProbeVolumeBaker {
 
     // this._ren = new WebGLCubeProbeRenderer();
@@ -29,23 +74,37 @@ 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);
+
+            const depth_resolution = lpv.depth_map_resolution;
+
+            renderer.bake_depth_octahedral(
+                depth_resolution,
+                max_distance*1.05 + 0.00001,
+                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 +112,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

@@ -4,6 +4,16 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
     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":"AAwBA;IACI,mBAA0B;IAC1B,qBAAmB;IACnB,qBAAyB;IAEzB,uBAA6B;IAE7B,uFAoBC;IAED;;;;;;;;OAQG;IACH,kCAPW,MAAM,aACN,MAAM,YACN,MAAM,EAAE,mBACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAahB;IAED,iFAqCC;IAKD,mBACC;IAED,4BAKC;CACJ;8BA/G6B,oBAAoB;2BAJvB,8BAA8B;gCADzB,mCAAmC"}

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

@@ -8,15 +8,12 @@ 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 { sh3_bake_depth } from "./depth/sh3_bake_depth.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,7 +24,7 @@ const sampled_irradiance = new Float32Array(3);
 
 export class PathTracerProbeRenderer extends ProbeRenderer {
     tracer = new PathTracer();
-    sample_count = 256;
+    sample_count = 192;
     random = seededRandom(0);
 
     scene = new PathTracedScene()
@@ -54,6 +51,28 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
 
     }
 
+    /**
+     *
+     * @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
+        );
+    }
+
     bake(position, position_offset, output, output_offset) {
 
 
@@ -102,40 +121,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/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);
+    }
+
+}

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

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {PathTracedScene} scene
+ * @param {number[]|Vector3} position
+ * @param {number} position_offset
+ * @param {number} resolution
+ * @param {number} max_depth
+ */
+export function bake_octahedral_depth_map(result: number[], result_offset: number, scene: PathTracedScene, position: number[] | Vector3, position_offset: number, resolution: number, max_depth: number): void;
+//# sourceMappingURL=bake_octahedral_depth_map.d.ts.map

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

@@ -0,0 +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":"AAQA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QAyChB"}

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

@@ -0,0 +1,58 @@
+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";
+
+const scratch_ray = new Ray3();
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {PathTracedScene} scene
+ * @param {number[]|Vector3} position
+ * @param {number} position_offset
+ * @param {number} resolution
+ * @param {number} max_depth
+ */
+export function bake_octahedral_depth_map(
+    result, result_offset,
+    scene,
+    position, position_offset,
+    resolution,
+    max_depth
+) {
+
+    scratch_ray.tMax = max_depth;
+    array_copy(position, position_offset, scratch_ray, 0, 3);
+
+    const ray_direction = scratch_ray.direction;
+
+    const ray_hit = [];
+
+    for (let oct_x = 0; oct_x < resolution; oct_x++) {
+        for (let oct_y = 0; oct_y < resolution; oct_y++) {
+
+            const u = oct_x / (resolution - 1);
+            const v = oct_y / (resolution - 1);
+
+            decode_octahedron_to_unit(
+                ray_direction, 0,
+                u * 2 - 1, v * 2 - 1
+            );
+
+            let distance = scene.trace(ray_hit, scratch_ray);
+
+            if (distance < 0) {
+                // no hit
+                distance = max_depth;
+            }
+
+            const pixel_index = oct_y * resolution + oct_x;
+
+            result[result_offset + pixel_index] = distance;
+        }
+    }
+
+}

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

@@ -0,0 +1,11 @@
+export class OctahedralDepthVisualizationMaterial extends ShaderMaterial {
+    constructor();
+    set scale(arg: any);
+    /**
+     *
+     * @param {THREE.DataTexture} v
+     */
+    set texture(arg: import("three").DataTexture);
+}
+import { ShaderMaterial } from "three";
+//# sourceMappingURL=OctahedralDepthVisualizationMaterial.d.ts.map