@woosh/meep-engine 2.109.25 → 2.110.0

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/core/math/interval/NumericInterval.d.ts

@@ -16,18 +16,17 @@ export class NumericInterval {
      * @type {number}
      */
     max: number;
-    onChanged: Signal<any, any, any, any, any, any, any, any>;
+    /**
+     * @readonly
+     * @type {Signal<number, number, number, number>}
+     */
+    readonly onChanged: Signal<number, number, number, number>;
     /**
      *
      * @param {number} min
      * @param {number} max
      */
     set(min: number, max: number): void;
-    /**
-     *
-     * @param {NumericInterval} other
-     */
-    copy(other: NumericInterval): void;
     /**
      *
      * @param {number} value
@@ -66,6 +65,7 @@ export class NumericInterval {
         min: number;
         max: number;
     };
+    toString(): string;
     /**
      *
      * @param {BinaryBuffer} buffer
@@ -76,6 +76,11 @@ export class NumericInterval {
      * @param {BinaryBuffer} buffer
      */
     fromBinaryBuffer(buffer: BinaryBuffer): void;
+    /**
+     *
+     * @param {NumericInterval} other
+     */
+    copy(other: NumericInterval): void;
     /**
      *
      * @param {NumericInterval} other
@@ -99,8 +104,9 @@ export class NumericInterval {
     readonly isNumericInterval: boolean;
 }
 export namespace NumericInterval {
-    let one_one: NumericInterval;
     let zero_zero: NumericInterval;
+    let zero_one: NumericInterval;
+    let one_one: NumericInterval;
 }
 import Signal from "../../events/signal/Signal.js";
 //# sourceMappingURL=NumericInterval.d.ts.map

package/src/core/math/interval/NumericInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NumericInterval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/interval/NumericInterval.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,kBAJW,MAAM,QACN,MAAM,EAwBhB;IAZG;;;OAGG;IACH,KAFU,MAAM,CAEF;IACd;;;OAGG;IACH,KAFU,MAAM,CAEF;IAEd,0DAA6B;IAIjC;;;;OAIG;IACH,SAHW,MAAM,OACN,MAAM,QAsBhB;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAahB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gCAFa,MAAM,CAMlB;IAED,0BAEC;IAED;;;MAKC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAGC;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,mBAEC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;;iBAUS,eAAe;mBAKf,eAAe;;mBA5MN,+BAA+B"}
+{"version":3,"file":"NumericInterval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/interval/NumericInterval.js"],"names":[],"mappings":"AAKA;IACI;;;;;OAKG;IACH,kBAJW,MAAM,QACN,MAAM,EA4BhB;IAhBG;;;OAGG;IACH,KAFU,MAAM,CAEF;IACd;;;OAGG;IACH,KAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,oBAFU,OAAO,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEnB;IAIjC;;;;OAIG;IACH,SAHW,MAAM,OACN,MAAM,QA0BhB;IAGD;;;OAGG;IACH,sBAFW,MAAM,QAahB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gCAFa,MAAM,CAMlB;IAED,0BAEC;IAED;;;MAKC;IAED,mBAEC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAGC;IAED;;;OAGG;IACH,YAFW,eAAe,QAIzB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,mBAEC;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;;mBAUS,eAAe;kBAMf,eAAe;iBAMf,eAAe;;mBAhON,+BAA+B"}

package/src/core/math/interval/NumericInterval.js

@@ -30,6 +30,10 @@ export class NumericInterval {
          */
         this.max = max;
 
+        /**
+         * @readonly
+         * @type {Signal<number, number, number, number>}
+         */
         this.onChanged = new Signal();
     }
 
@@ -51,24 +55,21 @@ export class NumericInterval {
         const oldMin = this.min;
         const oldMax = this.max;
 
-        if (min !== oldMin || max !== oldMax) {
-            this.min = min;
-            this.max = max;
+        if (min === oldMin && max === oldMax) {
+            return;
+        }
 
-            if (this.onChanged.hasHandlers()) {
-                this.onChanged.send4(min, max, oldMin, oldMax);
-            }
+        this.min = min;
+        this.max = max;
+
+        if (!this.onChanged.hasHandlers()) {
+            return;
         }
-    }
 
-    /**
-     *
-     * @param {NumericInterval} other
-     */
-    copy(other) {
-        this.set(other.min, other.max);
+        this.onChanged.send4(min, max, oldMin, oldMax);
     }
 
+
     /**
      *
      * @param {number} value
@@ -142,6 +143,10 @@ export class NumericInterval {
         };
     }
 
+    toString() {
+        return `NumericInterval{ min=${this.min}, max=${this.max} }`;
+    }
+
     /**
      *
      * @param {BinaryBuffer} buffer
@@ -160,6 +165,14 @@ export class NumericInterval {
         this.max = buffer.readFloat64();
     }
 
+    /**
+     *
+     * @param {NumericInterval} other
+     */
+    copy(other) {
+        this.set(other.min, other.max);
+    }
+
     /**
      *
      * @param {NumericInterval} other
@@ -200,10 +213,17 @@ NumericInterval.prototype.isNumericInterval = true;
  * @readonly
  * @type {NumericInterval}
  */
-NumericInterval.one_one = Object.freeze(new NumericInterval(1, 1));
+NumericInterval.zero_zero = Object.freeze(new NumericInterval(0, 0));
+
 /**
  * @readonly
  * @type {NumericInterval}
  */
-NumericInterval.zero_zero = Object.freeze(new NumericInterval(0, 0));
+NumericInterval.zero_one = Object.freeze(new NumericInterval(0, 1));
+
+/**
+ * @readonly
+ * @type {NumericInterval}
+ */
+NumericInterval.one_one = Object.freeze(new NumericInterval(1, 1));
 

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";
@@ -33,7 +33,7 @@ class Response {
 }
 
 /**
- * Used by the priority queue, so the priority is inverted as the FastBinaryHeap returns elements in ascending score order (from lowest)
+ * Used by the priority queue, so the priority is inverted as the BinaryHeap returns elements in ascending score order (from lowest)
  * @param {PendingAsset} pending_asset
  * @returns {number}
  */
@@ -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/camera/makeOrbitalCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"makeOrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/camera/makeOrbitalCameraController.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,8FANW,MAAM,GAIL,MAAM,CA8FjB;mBAxGkB,qBAAqB"}
+{"version":3,"file":"makeOrbitalCameraController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/camera/makeOrbitalCameraController.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,8FANW,MAAM,GAIL,MAAM,CA8FjB;mBA1GkB,qBAAqB"}

package/src/engine/graphics/camera/makeOrbitalCameraController.js

@@ -1,9 +1,9 @@
-import TopDownCameraController, { rotate_from_view } from "../ecs/camera/topdown/TopDownCameraController.js";
-import InputController from "../../input/ecs/components/InputController.js";
-import { decodeMouseEventButtons } from "../../input/devices/PointerDevice.js";
+import { clamp } from "../../../core/math/clamp.js";
 import Entity from "../../ecs/Entity.js";
+import { decodeMouseEventButtons } from "../../input/devices/mouse/decodeMouseEventButtons.js";
+import InputController from "../../input/ecs/components/InputController.js";
 import { Camera } from "../ecs/camera/Camera.js";
-import { clamp } from "../../../core/math/clamp.js";
+import TopDownCameraController, { rotate_from_view } from "../ecs/camera/topdown/TopDownCameraController.js";
 
 /**
  *

package/src/engine/graphics/geometry/VertexDataSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VertexDataSpec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/VertexDataSpec.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IAeI;;;;OAIG;IACH,2BAHW,aAAa,GACX,cAAc,CAQ1B;IAxBD;;;OAGG;IACH,YAFU,aAAa,EAAE,CAET;IAsBhB;;;;OAIG;IACH,yBAHW,MAAM,GACL,aAAa,GAAC,SAAS,CAgBlC;IAED;;;OAGG;IACH,8BAFW,MAAM,GADJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,oBAFW,aAAa,EAAE,QAOzB;IAED;;;;OAIG;IACH,eAHW,aAAa,GACZ,cAAc,CAkBzB;IAED;;;OAGG;IACH,0BAFW,aAAa,EAAE,QAYzB;IAED,cAKC;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAQnB;IAED,sBAEC;IAED,eAMC;IAED;;MAIC;IAED;;aAkBC;IAED;;;OAGG;IACH,eAFa,MAAM,CAelB;IAIL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;;CAPxC;8BA/M6B,oBAAoB"}
+{"version":3,"file":"VertexDataSpec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/VertexDataSpec.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IAeI;;;;OAIG;IACH,2BAHW,aAAa,GACX,cAAc,CAQ1B;IAxBD;;;OAGG;IACH,YAFU,aAAa,EAAE,CAET;IAsBhB;;;;OAIG;IACH,yBAHW,MAAM,GACL,aAAa,GAAC,SAAS,CAgBlC;IAED;;;OAGG;IACH,8BAFW,MAAM,GADJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,oBAFW,aAAa,EAAE,QAOzB;IAED;;;;OAIG;IACH,eAHW,aAAa,GACZ,cAAc,CAkBzB;IAED;;;OAGG;IACH,0BAFW,aAAa,EAAE,QAQzB;IAED,cAMC;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAQnB;IAED,sBAEC;IAED,eAMC;IAED;;MAIC;IAED;;aAkBC;IAED;;;OAGG;IACH,eAFa,MAAM,CAelB;IAIL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;;CAPxC;8BA5M6B,oBAAoB"}

package/src/engine/graphics/geometry/VertexDataSpec.js

@@ -118,23 +118,20 @@ export class VertexDataSpec {
     }
 
     /**
-     *
+     * Replace existing attributes
      * @param {AttributeSpec[]} attributes
      */
     setAttributes(attributes) {
 
         this.clear();
 
-        const n = attributes.length;
-
-        for (let i = 0; i < n; i++) {
-            this.add(attributes[i]);
-        }
+        this.addMany(attributes);
 
     }
 
     clear() {
-        this.attributes.splice(0, this.attributes.length);
+        const count = this.attributes.length;
+        this.attributes.splice(0, count);
 
         // reset hash to trigger hash update
         this.#hash = DEFAULT_HASH;

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
@@ -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

@@ -35,10 +35,10 @@ export class LightProbeVolume {
      * Depth map is stored as a 2d texture of size RESOLUTION x RESOLUTION
      * @type {number}
      */
-    #probe_depth_resolution = 64;
+    #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,QA4HhB"}
+{"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,6 +89,7 @@ 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
@@ -126,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;
@@ -150,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;
         }
     }
 

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/visualise.frag.glsl

@@ -168,6 +168,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;
@@ -264,22 +272,16 @@ vec2 lpv_probe_getDepthBilinear(uint probe_index, vec3 direction) {
     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;
 
-    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
-        )
+    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 lpv_bilinear_lerp(
+        texel_00, texel_01,
+        texel_10, texel_11,
+        gridFrac
     );
 }