@woosh/meep-engine 2.109.24 → 2.109.26

package/src/core/graph/{cluster_mesh_metis.js → metis/metis_cluster_bs.js}

@@ -1,5 +1,5 @@
-import { Metis } from "./metis/metis.js";
-import { metis_options } from "./metis/metis_options.js";
+import { Metis } from "./metis.js";
+import { metis_options } from "./metis_options.js";
 
 /**
  * How many times to retry partitioning before giving up
@@ -17,7 +17,14 @@ const MAX_STEPS = 50;
  * @param {number} patch_size
  * @returns {Promise<number>}
  */
-export async function metis_cluster_bs(result, node_count, edge_addresses, adjacency_uint32, edge_weights_uint32, patch_size) {
+export async function metis_cluster_bs(
+    result,
+    node_count,
+    edge_addresses,
+    adjacency_uint32,
+    edge_weights_uint32,
+    patch_size
+) {
 
     const metis = Metis.INSTANCE;
 
@@ -35,7 +42,7 @@ export async function metis_cluster_bs(result, node_count, edge_addresses, adjac
     const metisOptions = new metis_options();
     metisOptions.seed = 0xCAFE;
 
-    partition_loop: for (; ;) {
+    for (; ;) {
         passes++;
 
         if (passes > MAX_STEPS) {
@@ -97,9 +104,6 @@ export async function metis_cluster_bs(result, node_count, edge_addresses, adjac
         }
 
         // console.log(`${partition_count}`);
-
-        continue partition_loop;
-
     }
 
     // remap P values. Metis assigns unique unsigned integer values to each cluster, but they don't necessarily start at 0, to fix this we remap values
@@ -120,94 +124,4 @@ export async function metis_cluster_bs(result, node_count, edge_addresses, adjac
 
     result.set(p);
     return partition_count;
-}
-
-/**
- * @param {TopoTriangle[]} face_array
- */
-export function mesh_to_metis_graph(face_array) {
-    const input_face_count = face_array.length;
-
-
-    const edge_addresses = new Uint32Array(input_face_count + 1);
-    const adjacency = [];
-    const edge_weights = [];
-
-    const face_index_map = new Map();
-
-    for (let i = 0; i < input_face_count; i++) {
-        const face = face_array[i];
-        face_index_map.set(face, i);
-    }
-
-    let offset = 0;
-    edge_addresses[0] = 0;
-    for (let i = 0; i < input_face_count; i++) {
-        const face = face_array[i];
-
-        const edges = face.edges;
-
-        const edge_count = edges.length;
-        for (let j = 0; j < edge_count; j++) {
-            const topoEdge = edges[j];
-
-            const edge_faces = topoEdge.faces;
-
-            const edge_face_count = edge_faces.length;
-            for (let k = 0; k < edge_face_count; k++) {
-                const neighbour = edge_faces[k];
-
-                if (neighbour === face) {
-                    //skip self
-                    continue;
-                }
-
-                adjacency[offset] = face_index_map.get(neighbour);
-                edge_weights[offset] = 1;
-
-                offset++;
-            }
-        }
-
-        edge_addresses[i + 1] = offset;
-    }
-
-    const adjecency_uint32 = new Uint32Array(adjacency);
-    const edge_weights_uint32 = new Uint32Array(edge_weights);
-
-
-    return {
-        edge_addresses: edge_addresses,
-        adjacency: adjecency_uint32,
-        edge_weights: edge_weights_uint32
-    };
-}
-
-/**
- *
- * @param {Uint32Array} result
- * @param {TopoMesh} mesh
- * @param {number} patch_size
- * @returns {number}
- */
-export async function cluster_mesh_metis(result, mesh, patch_size) {
-
-    const face_set = mesh.getFaces();
-    const input_face_count = face_set.size;
-
-    const face_array = Array.from(face_set);
-
-    const metis_graph = mesh_to_metis_graph(face_array);
-
-    const partition_count = await metis_cluster_bs(
-        result,
-        input_face_count,
-        metis_graph.edge_addresses,
-        metis_graph.adjacency,
-        metis_graph.edge_weights,
-        patch_size
-    );
-
-    return partition_count;
-}
-
+}

package/src/core/graph/mn_graph_coarsen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mn_graph_coarsen.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_coarsen.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,gFAFW,MAAM,QAuBhB"}
+{"version":3,"file":"mn_graph_coarsen.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_coarsen.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,gFAFW,MAAM,QA2BhB"}

package/src/core/graph/mn_graph_coarsen.js

@@ -1,4 +1,4 @@
-import FastBinaryHeap from "../collection/heap/FastBinaryHeap.js";
+import BinaryHeap from "../collection/heap/BinaryHeap.js";
 import { mn_graph_collapse_weighted_edge } from "./mn_graph_collapse_weighted_edge.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 
@@ -15,7 +15,7 @@ export function mn_graph_coarsen(graph, max_node_limit) {
      *
      * @type {BinaryHeap<WeightedEdge>}
      */
-    const open_set = new FastBinaryHeap(WeightedEdge.extractNegativeWeight);
+    const open_set = new BinaryHeap(WeightedEdge.extractNegativeWeight);
 
     // add all edges to the heap
     const edges = graph.getEdges();
@@ -28,6 +28,10 @@ export function mn_graph_coarsen(graph, max_node_limit) {
         const edge = open_set.pop();
 
         // attempt collapse of the heaviest edge
-        mn_graph_collapse_weighted_edge(graph, edge, max_node_limit, open_set);
+        const collapsed = mn_graph_collapse_weighted_edge(graph, edge, max_node_limit, open_set);
+
+        if(!collapsed){
+            throw new Error(`Failed to collapse edge ${edge}`);
+        }
     }
 }

package/src/core/graph/mn_graph_coarsen.spec.js

@@ -14,6 +14,8 @@ test('coarsen 2 node graph with 1 edge', () => {
     graph.addEdge(new WeightedEdge(n0, n1));
 
     mn_graph_coarsen(graph, 2);
+
+    expect(graph.getNodeCount()).toBe(1);
 });
 
 test('coarsen chain, all nodes must still be linked', () => {

package/src/engine/animation/async/TimeSeries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TimeSeries.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/async/TimeSeries.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IA+BI;;;;OAIG;IACH,4CAFW,MAAM,EAuChB;IAxED;;OAEG;IACH,MAFU,iBAAiB,CAEvB;IAEJ;;OAEG;IACH,OAFU,aAAa,CAElB;IAEL,0BAAsB;IAyHtB;;;;OAIG;IACH,8BAHW,MAAM,OAOhB;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,6BAWC;IAED,oCAcC;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAQlB;IAED;;;OAGG;IACH,mCAIC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,SACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,iBACR,MAAM,QACN,MAAM,QAuBhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,OAShB;;CAEJ;kCAzRiC,qDAAqD;8BADzD,iDAAiD"}
+{"version":3,"file":"TimeSeries.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/async/TimeSeries.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH;IA+BI;;;;OAIG;IACH,4CAFW,MAAM,EAuChB;IAxED;;OAEG;IACH,MAFU,iBAAiB,CAEvB;IAEJ;;OAEG;IACH,OAFU,aAAa,CAElB;IAEL,0BAAsB;IAyHtB;;;;OAIG;IACH,8BAHW,MAAM,OAOhB;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,6BAWC;IAED,oCAcC;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAQlB;IAED;;;OAGG;IACH,mCAIC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,SACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,iBACR,MAAM,QACN,MAAM,QAuBhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,OAShB;;CAEJ;kCA7RiC,qDAAqD;8BADzD,iDAAiD"}

package/src/engine/animation/async/TimeSeries.js

@@ -7,8 +7,12 @@ import { lerp } from "../../../core/math/lerp.js";
 import { max2 } from "../../../core/math/max2.js";
 import { min2 } from "../../../core/math/min2.js";
 import { validate_enum_schema } from "../../../core/model/validate_enum_schema.js";
-import { findSampleIndex } from "./findSampleIndex.js";
+import { table_find_min_index_in_ordered_column } from "./table_find_min_index_in_ordered_column.js";
 
+/**
+ *
+ * @type {number[]}
+ */
 const scratch_row = [];
 
 /**
@@ -237,7 +241,7 @@ export class TimeSeries {
     findLowSampleIndexByTime(time) {
         const table = this.table;
         const time_column_index = this.time_column_index;
-        return max2(0, findSampleIndex(table, time, time_column_index))
+        return max2(0, table_find_min_index_in_ordered_column(table, time, time_column_index))
     }
 
     /**

package/src/engine/animation/async/table_find_min_index_in_ordered_column.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Given a column of ordered values in increasing order, returns low index of matching value
+ * @param {RowFirstTable} table
+ * @param {number} time
+ * @param {number} [column_index]
+ * @return {number}
+ */
+export function table_find_min_index_in_ordered_column(table: RowFirstTable, time: number, column_index?: number): number;
+//# sourceMappingURL=table_find_min_index_in_ordered_column.d.ts.map

package/src/engine/animation/async/table_find_min_index_in_ordered_column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table_find_min_index_in_ordered_column.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/async/table_find_min_index_in_ordered_column.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,mFAJW,MAAM,iBACN,MAAM,GACL,MAAM,CAwBjB"}

package/src/engine/animation/async/{findSampleIndex.js → table_find_min_index_in_ordered_column.js}

@@ -1,19 +1,20 @@
 import { min2 } from "../../../core/math/min2.js";
 
 /**
- *
+ * Given a column of ordered values in increasing order, returns low index of matching value
  * @param {RowFirstTable} table
  * @param {number} time
  * @param {number} [column_index]
  * @return {number}
  */
-export function findSampleIndex(table, time, column_index = 0) {
+export function table_find_min_index_in_ordered_column(table, time, column_index = 0) {
     let minIndex = 0;
     let maxIndex = table.length - 1;
 
     while (minIndex <= maxIndex) {
 
-        const pivotIndex = (minIndex + maxIndex) >> 1;
+        // low midpoint, this is essentially Math.floor( (minIndex + maxIndex) / 2 )
+        const pivotIndex = (minIndex + maxIndex) >>> 1;
 
         const cmp = time - table.readCellValue(pivotIndex, column_index);
 
@@ -22,7 +23,7 @@ export function findSampleIndex(table, time, column_index = 0) {
         } else if (cmp < 0) {
             maxIndex = pivotIndex - 1;
         } else {
-            //set low boundary for next step based on assumption that upper bound is higher than lower bound
+            // exactly on the pivot sample
             return pivotIndex;
         }
     }

package/src/engine/asset/AssetManager.js

@@ -1,7 +1,7 @@
 import { assert } from "../../core/assert.js";
 import { array_push_if_unique } from "../../core/collection/array/array_push_if_unique.js";
 import { array_remove_first } from "../../core/collection/array/array_remove_first.js";
-import FastBinaryHeap from "../../core/collection/heap/FastBinaryHeap.js";
+import BinaryHeap from "../../core/collection/heap/BinaryHeap.js";
 import { HashMap } from "../../core/collection/map/HashMap.js";
 import { ObservedMap } from "../../core/collection/map/ObservedMap.js";
 import { Deque } from "../../core/collection/queue/Deque.js";
@@ -68,7 +68,7 @@ export class AssetManager {
      * @type {BinaryHeap<PendingAsset>}
      * @private
      */
-    #pending_asset_wait_queue = new FastBinaryHeap(get_pending_asset_priority_score);
+    #pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
     /**
      * Assets currently being processed by #loaders
      * @type {Set<PendingAsset>}

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

@@ -24,6 +24,13 @@ const float lpv_max_thickness = 0.50; // in Meters
 #define SEARCH_STEP_LIMIT 32u
 #define INVALID_TET 1073741823u
 
+
+/** Slightly bump the location of the shadow test point away from the shadow casting surface.
+    The shadow casting surface is the boundary for shadow, so the nearer an imprecise value is
+    to it the more the light leaks.
+*/
+#define LPV_NORMAL_BIAS 0.0001f
+
 ivec2 lpv_index_to_256_coordinate(uint index) {
 
     uint pixel_x = index % 256u;
@@ -160,18 +167,15 @@ vec2 lpv_probe_getDepthTriangular(uint probe_index, vec3 direction) {
     frame1 += tile_offset;
     frame2 += tile_offset;
 
-    float samp0 = texelFetch(lpv_t_probe_depth, ivec2(frame0), 0).r;
-    float samp1 = texelFetch(lpv_t_probe_depth, ivec2(frame1), 0).r;
-    float samp2 = texelFetch(lpv_t_probe_depth, ivec2(frame2), 0).r;
+    vec2 samp0 = texelFetch(lpv_t_probe_depth, ivec2(frame0), 0).rg;
+    vec2 samp1 = texelFetch(lpv_t_probe_depth, ivec2(frame1), 0).rg;
+    vec2 samp2 = texelFetch(lpv_t_probe_depth, ivec2(frame2), 0).rg;
 
-    float d0 = samp0 * weights.x;
-    float d1 = samp1 * weights.y;
-    float d2 = samp2 * weights.z;
+    vec2 d0 = samp0 * weights.x;
+    vec2 d1 = samp1 * weights.y;
+    vec2 d2 = samp2 * weights.z;
 
-    float mean = d0 + d1 + d2;
-    float mean2 = samp0 * d0 + samp1 * d1 + samp2 * d2;
-
-    return vec2(mean, mean2);
+    return (d0 + d1 + d2);
 }
 
 float lpv_bilinear_lerp(float v00, float v01, float v10, float v11, vec2 fraction) {
@@ -182,6 +186,14 @@ float lpv_bilinear_lerp(float v00, float v01, float v10, float v11, vec2 fractio
     return mix(x0, x1, fraction.y);
 }
 
+vec2 lpv_bilinear_lerp(vec2 v00, vec2 v01, vec2 v10, vec2 v11, vec2 fraction) {
+
+    vec2 x0 = mix(v00, v01, fraction.x);
+    vec2 x1 = mix(v10, v11, fraction.x);
+
+    return mix(x0, x1, fraction.y);
+}
+
 vec2 lpv_sample_bilinear(sampler2D tex, ivec2 texel_position, vec2 fraction) {
 
     float texel_00 = texelFetch(tex, texel_position, 0).r;
@@ -191,13 +203,13 @@ vec2 lpv_sample_bilinear(sampler2D tex, ivec2 texel_position, vec2 fraction) {
 
     return vec2(
         lpv_bilinear_lerp(
-        texel_00, texel_01,
-        texel_10, texel_11,
-        fraction
-    ),
+            texel_00, texel_01,
+            texel_10, texel_11,
+            fraction
+        ),
         lpv_bilinear_lerp(
-            texel_00*texel_00, texel_01*texel_01,
-            texel_10*texel_10, texel_11*texel_11,
+            texel_00 * texel_00, texel_01 * texel_01,
+            texel_10 * texel_10, texel_11 * texel_11,
             fraction
         )
     );
@@ -246,27 +258,20 @@ vec2 lpv_probe_getDepthBilinear(uint probe_index, vec3 direction) {
     ivec2 tile_p_10;
     ivec2 tile_p_11;
 
-    tile_p_00 = wrapOctahedralTexelCoordinates(texel_position , depth_tile_resolution);
+    tile_p_00 = wrapOctahedralTexelCoordinates(texel_position, depth_tile_resolution);
     tile_p_01 = wrapOctahedralTexelCoordinates(texel_position + ivec2(1, 0), depth_tile_resolution);
     tile_p_10 = wrapOctahedralTexelCoordinates(texel_position + ivec2(0, 1), depth_tile_resolution);
     tile_p_11 = wrapOctahedralTexelCoordinates(texel_position + ivec2(1, 1), depth_tile_resolution);
 
-    float texel_00 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_00, 0).r;
-    float texel_01 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_01, 0).r;
-    float texel_10 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_10, 0).r;
-    float texel_11 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_11, 0).r;
+    vec2 texel_00 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_00, 0).rg;
+    vec2 texel_01 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_01, 0).rg;
+    vec2 texel_10 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_10, 0).rg;
+    vec2 texel_11 = texelFetch(lpv_t_probe_depth, tile_offset + tile_p_11, 0).rg;
 
-    return vec2(
-        lpv_bilinear_lerp(
-            texel_00, texel_01,
-            texel_10, texel_11,
-            gridFrac
-        ),
-        lpv_bilinear_lerp(
-            texel_00 * texel_00, texel_01 * texel_01,
-            texel_10 * texel_10, texel_11 * texel_11,
-            gridFrac
-        )
+    return lpv_bilinear_lerp(
+        texel_00, texel_01,
+        texel_10, texel_11,
+        gridFrac
     );
 }
 
@@ -353,7 +358,9 @@ float lpv_probe_getVisibilityMask(vec3 position, uint probe_index) {
     vec2 temp = lpv_probe_getDepthBilinear(probe_index, direction);
 
     float mean = temp.x;
-    float variance = abs(mean * mean - temp.y);
+    float mean2 = temp.y; // mean of squared distances
+
+    float variance = abs(mean * mean - mean2);
 
     // http://www.punkuser.net/vsm/vsm_paper.pdf; equation 5
     // Need the max in the denominator because biasing can cause a negative displacement
@@ -362,7 +369,7 @@ float lpv_probe_getVisibilityMask(vec3 position, uint probe_index) {
     float chebyshevWeight = variance / (variance + distance_delta * distance_delta);
 
     // Increase contrast in the weight
-//    chebyshevWeight = max(chebyshevWeight * chebyshevWeight * chebyshevWeight, 0.0);
+    chebyshevWeight = max(chebyshevWeight * chebyshevWeight * chebyshevWeight, 0.0);
 
     return (distToProbe <= mean) ? 1.0 : chebyshevWeight;
 }
@@ -400,12 +407,6 @@ vec4 lvp_mask_weights_by_visibility_by_normal(vec3 position, vec3 normal, uint t
 }
 
 
-/** Slightly bump the location of the shadow test point away from the shadow casting surface.
-    The shadow casting surface is the boundary for shadow, so the nearer an imprecise value is
-    to it the more the light leaks.
-*/
-#define LPV_NORMAL_BIAS 0.01f
-
 vec4 lvp_mask_weights_by_visibility(in vec3 position, in vec3 normal, in vec3 view_direction, in uint tet_index, in vec4 barycentric) {
 
     uvec4 vertices = lpv_mesh_getVertices(tet_index);
@@ -451,7 +452,7 @@ vec4 lvp_mask_weights_by_visibility(in vec3 position, in vec3 normal, in vec3 vi
             // The small offset at the end reduces the "going to zero" impact
             // where this is really close to exactly opposite
             float backface_term = max(0.0001, (dot(direction_to_probe, normal) + 1.0) * 0.5);
-            weight *= backface_term * backface_term + 0.2;
+            weight *= backface_term * backface_term + 0.05;
 
         }
 
@@ -559,30 +560,20 @@ vec4 lpv_renormalize_weights(in vec4 source) {
 
 vec3 lpv_sample_irradiance(vec3 position, vec3 normal, vec3 view_direction) {
 
-    // Bias the position at which visibility is computed; this
-    // avoids performing a shadow test *at* a surface, which is a
-    // dangerous location because that is exactly the line between
-    // shadowed and unshadowed. If the normal bias is too small,
-    // there will be light and dark leaks. If it is too large,
-    // then samples can pass through thin occluders to the other
-    // side (this can only happen if there are MULTIPLE occluders
-    // near each other, a wall surface won't pass through itself.)
-    vec3 lookup_position = position + (normal + view_direction * 3.0) * LPV_NORMAL_BIAS;
-
     // lookup nearby tet
     vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
     vec3 lpv_mesh_bounds_max = lpv_v3_bounds_max;
-    vec3 lookup_coordinates = (lookup_position - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min);
+    vec3 lookup_coordinates = (position - lpv_mesh_bounds_min) / (lpv_mesh_bounds_max - lpv_mesh_bounds_min);
 
 
-    uint nearest_tet = lpv_guess_initial_tet(lookup_position);
+    uint nearest_tet = lpv_guess_initial_tet(position);
 
     uint tet;
     vec4 barycentric_coordinates;
-    lpv_walk_to_tetrahedron(lookup_position, nearest_tet, tet, barycentric_coordinates);
+    lpv_walk_to_tetrahedron(position, nearest_tet, tet, barycentric_coordinates);
 
     // apply visibility term
-    vec4 weights = lvp_mask_weights_by_visibility(lookup_position, normal, view_direction, tet, barycentric_coordinates);
+    vec4 weights = lvp_mask_weights_by_visibility(position, normal, view_direction, tet, barycentric_coordinates);
 
     if (tet == INVALID_TET) {
         // do nothing

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

@@ -1 +1 @@
-{"version":3,"file":"makeOctahedralDepthAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,MAAM,GACJ,WAAW,CAsBvB;4BA3BqF,OAAO"}
+{"version":3,"file":"makeOctahedralDepthAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/makeOctahedralDepthAtlas.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,MAAM,GACJ,WAAW,CAwBvB;4BA7BoF,OAAO"}

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

@@ -1,4 +1,4 @@
-import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, RedFormat } from "three";
+import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, RGFormat } from "three";
 
 /**
  *
@@ -7,10 +7,10 @@ import { ClampToEdgeWrapping, DataTexture, FloatType, NearestFilter, RedFormat }
  */
 export function makeOctahedralDepthAtlas(resolution = 4096) {
     const texture = new DataTexture(
-        new Float32Array(resolution * resolution),
+        new Float32Array(resolution * resolution * 2),
         resolution,
         resolution,
-        RedFormat,
+        RGFormat,
         FloatType
     );
 
@@ -24,5 +24,7 @@ export function makeOctahedralDepthAtlas(resolution = 4096) {
 
     texture.needsUpdate = true;
 
+    texture.internalFormat = "RG32F";
+
     return texture;
 }

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

@@ -38,7 +38,7 @@ export class LightProbeVolume {
     #probe_depth_resolution = 16;
 
     /**
-     * Octahedral-encoded depth map for each probe
+     * Octahedral-encoded depth map for each probe, 2 channels for mean and mean squared for variance recovery in the shader
      * @type {number[]}
      */
     #probe_depth = [];

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

@@ -90,7 +90,7 @@ export class LightProbeVolumeBaker {
             depth_resolution,
             max_depth,
             lpv.points, position_offset,
-            lpv.depth, probe_index * probe_element_count
+            lpv.depth, probe_index * probe_element_count * 2
         );
     }
 }

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":"AAuBA;IACI,mBAA0B;IAC1B,yBAAqB;IACrB,qBAAoB;IACpB,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"}
+{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AAuBA;IACI,mBAA0B;IAC1B,yBAAqB;IAErB,qBAAoB;IACpB,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;8BA7F6B,oBAAoB;2BAHvB,8BAA8B;gCADzB,mCAAmC"}

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

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

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

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

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

@@ -7,6 +7,7 @@ import {
 import { Ray3 } from "../../../../../../core/geom/3d/Ray3.js";
 import { v3_distance } from "../../../../../../core/geom/vec3/v3_distance.js";
 import { v3_dot_array_array } from "../../../../../../core/geom/vec3/v3_dot_array_array.js";
+import { clamp } from "../../../../../../core/math/clamp.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { generate_hammersley_jitter } from "../../../../../../core/math/statistics/generate_hammersley_jitter.js";
 
@@ -14,7 +15,7 @@ import { generate_hammersley_jitter } from "../../../../../../core/math/statisti
  * Weights of rays that are aligned with the probe direction get exponentially weighted by this exponent
  * @type {number}
  */
-const DEPTH_SHARPNESS = 40;
+const DEPTH_SHARPNESS = 3;
 
 const scratch_ray = new Ray3();
 
@@ -28,7 +29,7 @@ const ray_hit = [];
  *
  * @type {number}
  */
-const SUB_SAMPLE_COUNT = 4;
+const SUB_SAMPLE_COUNT = 16;
 
 
 /**
@@ -71,7 +72,9 @@ export function bake_octahedral_depth_map(
      */
     const RESOLUTION_BIAS = Math.sin(texel_angular_coverage) * Math.SQRT2 * 2;
 
-    const NORMAL_BIAS = max2(0.01, max_depth * 0.01) + 1e-6;
+    // const NORMAL_BIAS = max2(1e-6, max_depth * 0.01);
+    const NORMAL_BIAS = 1e-6;
+    // const NORMAL_BIAS = clamp(max_depth * Math.sin(texel_angular_coverage),1e-6, max_depth*0.1);
 
     const ray_direction = scratch_ray.direction;
 
@@ -86,12 +89,18 @@ export function bake_octahedral_depth_map(
         for (let oct_y = 0; oct_y < resolution; oct_y++) {
 
             let distance_sum = 0;
+            let distance2_sum = 0;
             let weight_sum = 0;
 
             // offset position by half a pixel, as we are storing values for pixel centers
             const u = (oct_x + 0.5) / (resolution);
             const v = (oct_y + 0.5) / (resolution);
 
+            decode_octahedron_to_unit(
+                probe_direction, 0,
+                u * 2 - 1, v * 2 - 1
+            );
+
             for (let sub_sample_index = 0; sub_sample_index < SUB_SAMPLE_COUNT; sub_sample_index++) {
 
                 const sample_index2 = sub_sample_index * 2;
@@ -121,7 +130,7 @@ export function bake_octahedral_depth_map(
                     const surface_position_y = ray_hit[1];
                     const surface_position_z = ray_hit[2];
 
-                    const hit_normal_bias = -NORMAL_BIAS;
+                    const hit_normal_bias = NORMAL_BIAS;
 
                     // sink the contact into the surface along the hit normal
                     const biased_hit_x = surface_position_x + surface_normal_x * hit_normal_bias;
@@ -145,16 +154,19 @@ export function bake_octahedral_depth_map(
                 );
 
                 distance_sum += distance * weight;
+                distance2_sum += distance * distance * weight;
                 weight_sum += weight;
             }
 
             const pixel_index = oct_y * resolution + oct_x;
 
-            const address = result_offset + pixel_index;
+            const address = result_offset + pixel_index * 2;
 
-            const distance = distance_sum / weight_sum;
+            const mean = distance_sum / weight_sum;
+            const mean2 = distance2_sum / weight_sum;
 
-            result[address] = distance;
+            result[address] = mean;
+            result[address + 1] = mean2;
         }
     }