@woosh/meep-engine 2.109.7 → 2.109.8

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.109.7",
+  "version": "2.109.8",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts

@@ -208,15 +208,15 @@ export class TetrahedralMesh {
      */
     removeTetrasConnectedToPoints(range_start: number, range_end: number): void;
     /**
-     *
+     * Note that this method does not guarantee to find the containing tet in case of concave mesh, that is - if there is a gap between the starting tet and the countaining tet
      * @param {number} x
      * @param {number} y
      * @param {number} z
      * @param {number[]} points Positions of vertices of tetrahedrons
-     * @param {number} [hint_tetrahedron]
+     * @param {number} [start_tetrahedron]
      * @returns {number} index of tetra or -1 if no containing tetra found
      */
-    findTetraContainingPoint(x: number, y: number, z: number, points: number[], hint_tetrahedron?: number): number;
+    walkToTetraContainingPoint(x: number, y: number, z: number, points: number[], start_tetrahedron?: number): number;
     /**
      * Relocate tetrahedron in memory, patches neighbourhood links as well
      * NOTE: The destination slot will be overwritten. This is a dangerous method that can break the topology, make sure you fully understand what you are doing when using it

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAQC;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,4BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CAyDlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA1tB4B,iCAAiC"}
+{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAQC;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CA8DlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA/tB4B,iCAAiC"}

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -522,19 +522,19 @@ export class TetrahedralMesh {
     }
 
     /**
-     *
+     * Note that this method does not guarantee to find the containing tet in case of concave mesh, that is - if there is a gap between the starting tet and the countaining tet
      * @param {number} x
      * @param {number} y
      * @param {number} z
      * @param {number[]} points Positions of vertices of tetrahedrons
-     * @param {number} [hint_tetrahedron]
+     * @param {number} [start_tetrahedron]
      * @returns {number} index of tetra or -1 if no containing tetra found
      */
-    findTetraContainingPoint(x, y, z, points, hint_tetrahedron = 0) {
+    walkToTetraContainingPoint(x, y, z, points, start_tetrahedron = 0) {
 
         let entering_face = 4;
 
-        let cur_tet = hint_tetrahedron;
+        let cur_tet = start_tetrahedron;
 
         let i;
         while (true) {
@@ -570,7 +570,12 @@ export class TetrahedralMesh {
                     // point is outside the tet on the neighbour's side, move in that direction
                     const neighbour = this.getNeighbour(cur_tet, i);
 
-                    assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
+                    if(neighbour === INVALID_NEIGHBOUR){
+                        // walked outside the mesh, point is not contained within
+                        return -1;
+                    }
+
+                    // assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
 
                     cur_tet = neighbour >>> 2;
                     entering_face = neighbour & 3;

package/src/core/model/node-graph/DataType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/DataType.js"],"names":[],"mappings":"AAEA;IAgDI;;;;OAIG;IACH,yBAFa,QAAQ,CAQpB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAYpB;IA3ED;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED,eAEC;IAED;;;aAMC;IAmCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}
+{"version":3,"file":"DataType.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/DataType.js"],"names":[],"mappings":"AAEA;IAyDI;;;;OAIG;IACH,yBAFa,QAAQ,CAQpB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,QAAQ,CAQpB;IAjFD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV,mBAEC;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;;OAIG;IACH,QAHW,MAAM,QACN,MAAM,QAQhB;IAED,eAEC;IAED;;;aAEC;IAgCL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B"}

package/src/core/model/node-graph/DataType.js

@@ -36,11 +36,12 @@ export class DataType {
             && this.name === other.name;
     }
 
-    toJSON() {
-        return {...this};
-    }
-
-    fromJSON({id, name}) {
+    /**
+     *
+     * @param {number} id
+     * @param {string} name
+     */
+    set(id, name) {
         assert.isNonNegativeInteger(id, 'id');
         assert.isString(name, 'name');
 
@@ -48,6 +49,14 @@ export class DataType {
         this.name = name;
     }
 
+    toJSON() {
+        return { ...this };
+    }
+
+    fromJSON({ id, name }) {
+        this.set(id, name);
+    }
+
     /**
      *
      * @param {*} j
@@ -61,6 +70,7 @@ export class DataType {
         return r;
     }
 
+
     /**
      *
      * @param {number} id
@@ -68,13 +78,9 @@ export class DataType {
      * @returns {DataType}
      */
     static from(id, name) {
-        assert.isNonNegativeInteger(id, 'id');
-        assert.isString(name, 'name');
-
         const r = new DataType();
 
-        r.id = id;
-        r.name = name;
+        r.set(id, name);
 
         return r;
     }

package/src/core/model/node-graph/ParametricDataType.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Loosely can be thought as implementing generics, allows creation of types that reference other types
+ * Useful for collection types, like lists
+ */
+export class ParametricDataType extends DataType {
+    /**
+     * @param {number} id
+     * @param {string} name
+     * @param {DataType[]} [parameters]
+     */
+    static from(id: number, name: string, parameters?: DataType[]): ParametricDataType;
+    /**
+     *
+     * @type {DataType[]}
+     */
+    parameters: DataType[];
+    /**
+     *
+     * @param {number} id
+     * @param {string} name
+     * @param {DataType[]} [parameters]
+     */
+    set(id: number, name: string, parameters?: DataType[]): void;
+    /**
+     *
+     * @param {ParametricDataType} other
+     * @returns {boolean}
+     */
+    equals(other: ParametricDataType): boolean;
+    toJSON(): void;
+    fromJSON(j: any): void;
+}
+import { DataType } from "./DataType.js";
+//# sourceMappingURL=ParametricDataType.d.ts.map

package/src/core/model/node-graph/ParametricDataType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParametricDataType.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/node-graph/ParametricDataType.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IAyCI;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,sBAUpB;IArDD;;;OAGG;IACH,YAFU,QAAQ,EAAE,CAEJ;IAGhB;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,eACN,QAAQ,EAAE,QAMpB;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAQnB;IAED,eAEC;IAED,uBAEC;CAgBJ;yBA7DwB,eAAe"}

package/src/core/model/node-graph/ParametricDataType.js

@@ -0,0 +1,63 @@
+import { isArrayEqual } from "../../collection/array/isArrayEqual.js";
+import { DataType } from "./DataType.js";
+
+/**
+ * Loosely can be thought as implementing generics, allows creation of types that reference other types
+ * Useful for collection types, like lists
+ */
+export class ParametricDataType extends DataType {
+    /**
+     *
+     * @type {DataType[]}
+     */
+    parameters = [];
+
+
+    /**
+     *
+     * @param {number} id
+     * @param {string} name
+     * @param {DataType[]} [parameters]
+     */
+    set(id, name, parameters = []) {
+        super.set(id, name);
+
+        this.parameters = parameters;
+    }
+
+    /**
+     *
+     * @param {ParametricDataType} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (!(other instanceof ParametricDataType)) {
+            return false;
+        }
+
+        return super.equals(other) && isArrayEqual(this.parameters, other.parameters);
+    }
+
+    toJSON() {
+        throw new Error('Unsupported Operation');
+    }
+
+    fromJSON(j) {
+        throw new Error('Unsupported Operation');
+    }
+
+    /**
+     * @param {number} id
+     * @param {string} name
+     * @param {DataType[]} [parameters]
+     */
+    static from(id, name, parameters = []) {
+
+        const r = new ParametricDataType();
+
+        r.set(id, name, parameters);
+
+        return r;
+
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/MaterialTransformer.js"],"names":[],"mappings":"AAiCA;IAuII;;;OAGG;IACH,0CAOC;IAnBD;;;OAGG;IACH,2BAEC;IAdD;;;OAGG;IACH,wBAEC;IAuBD,sBAIC;IAED,sBA2CC;IAED,eA2CC;IAED,4BA2BC;;CACJ;4CA3S2C,0DAA0D"}
+{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/gi/material/MaterialTransformer.js"],"names":[],"mappings":"AAiCA;IA0II;;;OAGG;IACH,0CAOC;IAnBD;;;OAGG;IACH,2BAEC;IAdD;;;OAGG;IACH,wBAEC;IAuBD,sBAIC;IAED,sBA2CC;IAED,eA+CC;IAED,4BA2BC;;CACJ;4CAlT2C,0DAA0D"}

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

@@ -109,6 +109,9 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
             type: "t",
             value: this.#textures.depth
         },
+        lpv_u_probe_depth_resolution: {
+            value: 1
+        },
         lpv_t_mesh_lookup: {
             type: "t",
             value: this.#mesh_lookup
@@ -215,7 +218,7 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
                     const w_y = n_y * bounds.getExtentsY() + bounds.y0;
                     const w_z = n_z * bounds.getExtentsZ() + bounds.z0;
 
-                    const tet = volume.mesh.findTetraContainingPoint(w_x, w_y, w_z, volume.points, last_tet);
+                    const tet = volume.mesh.walkToTetraContainingPoint(w_x, w_y, w_z, volume.points, last_tet);
 
                     if (tet !== -1) {
                         last_tet = tet;
@@ -243,15 +246,19 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
 
         this.update_lookup();
 
-        this.#uniforms.lpv_u_mesh_tet_count.value = lpv.mesh.count;
+        const uniforms = this.#uniforms;
 
-        this.#uniforms.lpv_v3_bounds_min.value.set(
+        uniforms.lpv_u_mesh_tet_count.value = lpv.mesh.count;
+
+        uniforms.lpv_v3_bounds_min.value.set(
             this.#mesh_bounds.x0, this.#mesh_bounds.y0, this.#mesh_bounds.z0
         );
-        this.#uniforms.lpv_v3_bounds_max.value.set(
+        uniforms.lpv_v3_bounds_max.value.set(
             this.#mesh_bounds.x1, this.#mesh_bounds.y1, this.#mesh_bounds.z1
         );
 
+        uniforms.lpv_u_probe_depth_resolution.value = lpv.depth_map_resolution;
+
         this.#uniform_version = lpv.version;
 
         console.time('prepareTextures');

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

@@ -8,14 +8,20 @@ uniform usampler3D lpv_t_mesh_lookup;
 
 uniform sampler2D lpv_t_probe_positions;
 uniform sampler2D lpv_t_probe_data;
+
 uniform sampler2D lpv_t_probe_depth;
+uniform uint lpv_u_probe_depth_resolution;
 
 uniform uint lpv_u_mesh_tet_count;
 uniform vec3 lpv_v3_bounds_min;
 uniform vec3 lpv_v3_bounds_max;
 
 
-#define SEARCH_STEP_LIMIT 64u
+const float lpv_min_thickness = 0.03; // in Meters
+const float lpv_max_thickness = 0.50; // in Meters
+
+
+#define SEARCH_STEP_LIMIT 32u
 #define INVALID_TET 1073741823u
 
 ivec2 lpv_index_to_256_coordinate(uint index) {
@@ -132,9 +138,9 @@ float SampleBlended(sampler2D tex, vec2 uv0, vec2 uv1, vec2 uv2, vec4 weights) {
     return samp0 * weights.x + samp1 * weights.y + samp2 * weights.z;
 }
 
-float lpv_probe_getDepth(uint probe_index, vec3 direction) {
+vec2 lpv_probe_getDepth(uint probe_index, vec3 direction) {
     // get offset
-    uint depth_tile_resolution = 24u;
+    uint depth_tile_resolution = lpv_u_probe_depth_resolution;
     uvec2 atlas_size = uvec2(4096u);
 
     uint tiles_per_row = atlas_size.x / depth_tile_resolution;
@@ -166,18 +172,14 @@ float lpv_probe_getDepth(uint probe_index, vec3 direction) {
     frame1 += tile_offset;
     frame2 += tile_offset;
 
-    vec2 uv0 = (frame0 + 0.5) / vec2(atlas_size);
-    vec2 uv1 = (frame1 + 0.5) / vec2(atlas_size);
-    vec2 uv2 = (frame2 + 0.5) / vec2(atlas_size);
-
-    return textureLod(lpv_t_probe_depth,uv0,0.0).r;
+    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;
 
+    float mean = samp0 * weights.x + samp1 * weights.y + samp2 * weights.z;
+    float mean2 = samp0 * samp0 * weights.x + samp1 * samp1 * weights.y + samp2 * samp2 * weights.z;
 
-    return SampleBlended(
-        lpv_t_probe_depth,
-        uv0, uv1, uv2,
-        weights
-    );
+    return vec2(mean, mean2);
 }
 
 vec3 lpv_probe_getPosition(uint probe_index) {
@@ -211,7 +213,7 @@ vec4 lpv_mesh_getBarycentricCoordinates(uint tet_index, vec3 position) {
     return vec4(mult, 1.0 - mult.x - mult.y - mult.z);
 }
 
-void lpv_getTetrahedron(
+void lpv_walk_to_tetrahedron(
 in vec3 position,
 in uint tet_guess,
 out uint tet_index,
@@ -262,14 +264,28 @@ float lpv_probe_getVisibilityMask(vec3 position, uint probe_index) {
 
     vec3 local_probe_offset = probe_position - position;
 
+    float distToProbe = length(local_probe_offset);
+
     vec3 direction = normalize(local_probe_offset);
 
-    float depth = lpv_probe_getDepth(probe_index, direction);
+    vec2 temp = lpv_probe_getDepth(probe_index, direction);
+
+    float mean = temp.x;
+    float variance = abs(mean * mean - temp.y);
 
-    return step(length(local_probe_offset), depth);
+    // http://www.punkuser.net/vsm/vsm_paper.pdf; equation 5
+    // Need the max in the denominator because biasing can cause a negative displacement
+    float distance_delta = max(distToProbe - mean, 0.0);
+
+    float chebyshevWeight = variance / (variance + distance_delta * distance_delta);
+
+    // Increase contrast in the weight
+//    chebyshevWeight = max(chebyshevWeight*chebyshevWeight*chebyshevWeight, 0.0);
+
+    return (distToProbe <= mean) ? 1.0 : chebyshevWeight;
 }
 
-vec4 lvp_mask_weights_by_visibility(vec3 position, uint tet_index, vec4 weights) {
+vec4 lvp_mask_weights_by_visibility_by_depth(vec3 position, uint tet_index, vec4 weights) {
 
     uvec4 vertices = lpv_mesh_getVertices(tet_index);
 
@@ -283,6 +299,36 @@ vec4 lvp_mask_weights_by_visibility(vec3 position, uint tet_index, vec4 weights)
     return visibility * weights;
 }
 
+float lpv_probe_visibility_weight(uint probe_index, vec3 position, vec3 normal) {
+    float weight = 1.0;
+
+    vec3 probe_position = lpv_probe_getPosition(probe_index);
+
+    vec3 direction_to_probe = normalize(probe_position - position);
+
+    // Smooth backface test
+
+
+    // The naive soft backface weight would ignore a probe when
+    // it is behind the surface. That's good for walls. But for small details inside of a
+    // room, the normals on the details might rule out all of the probes that have mutual
+    // visibility to the point. So, we instead use a "wrap shading" test below inspired by
+    // NPR work.
+    // weight *= max(0.0001, dot(direction_to_probe, normal));
+
+    // 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 *= lpv_probe_getVisibilityMask(position, probe_index);
+
+    // Avoid zero weight
+    weight = max(0.000001, weight);
+
+    return weight;
+}
+
 vec4 lvp_mask_weights_by_visibility_by_normal(vec3 position, vec3 normal, uint tet_index, vec4 weights) {
 
     uvec4 vertices = lpv_mesh_getVertices(tet_index);
@@ -294,12 +340,25 @@ vec4 lvp_mask_weights_by_visibility_by_normal(vec3 position, vec3 normal, uint t
 
         vec3 direction_to_probe = position - probe_position;
 
-       visibility[i] = step(dot(direction_to_probe, normal),0.0);
+        visibility[i] = step(dot(direction_to_probe, normal), 0.0);
     }
 
     return visibility * weights;
 }
 
+vec4 lvp_mask_weights_by_visibility(vec3 position, vec3 normal, uint tet_index) {
+
+    uvec4 vertices = lpv_mesh_getVertices(tet_index);
+
+    vec4 visibility;
+
+    for (int i = 0; i < 4; i++) {
+        visibility[i] = lpv_probe_visibility_weight(vertices[i], position, normal);
+    }
+
+    return visibility;
+}
+
 vec3[9] lpv_interpolate_probes(vec4 weights, uint tet_index) {
 
     uvec4 vertices = lpv_mesh_getVertices(tet_index);
@@ -323,29 +382,6 @@ vec3[9] lpv_interpolate_probes(vec4 weights, uint tet_index) {
     return result;
 }
 
-vec4 lpv_bias_weight_by_normal(const in vec3 position, const in vec3 normal, const in uint tet_index, const in vec4 weights) {
-
-    uvec4 vertices = lpv_mesh_getVertices(tet_index);
-
-    vec4 result = weights;
-
-    for (int i = 0; i < 4; i++) {
-        vec3 p = lpv_probe_getPosition(vertices[i]) - position;
-
-        if (dot(normal, p) <= 0.0) {
-            // behind the surface, bias to 0
-            result[i] = 0.0;
-        }
-    }
-
-    float total_weight = result.x + result.y + result.z + result.w;
-
-    // needs to add up to 1
-    result = result / total_weight;
-
-    return result;
-}
-
 uint lpv_guess_initial_tet(vec3 position) {
 
     vec3 lpv_mesh_bounds_min = lpv_v3_bounds_min;
@@ -358,75 +394,89 @@ uint lpv_guess_initial_tet(vec3 position) {
 }
 
 // source: https://graphics.stanford.edu/papers/envmap/envmap.pdf
-vec3 lpv_get_irradiance_at( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {
+vec3 lpv_get_irradiance_at(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.8862269254527579;
+    vec3 result = shCoefficients[0] * 0.8862269254527579;
 
     // band 1
-    result -= shCoefficients[ 1 ] * 1.0233267079464885 * y;
-    result += shCoefficients[ 2 ] * 1.0233267079464885 * z;
-    result -= shCoefficients[ 3 ] * 1.0233267079464885 * x;
+    result -= shCoefficients[1] * 1.0233267079464885 * y;
+    result += shCoefficients[2] * 1.0233267079464885 * z;
+    result -= shCoefficients[3] * 1.0233267079464885 * x;
 
     // band 2
-    result += shCoefficients[ 4 ] * 0.8580855308097834 * x * y;
-    result -= shCoefficients[ 5 ] * 0.8580855308097834 * y * z;
-    result += shCoefficients[ 6 ] * ( 0.7431238683011272 * z * z - 0.24770795610037571 );
-    result -= shCoefficients[ 7 ] * 0.8580855308097834 * x * z;
-    result += shCoefficients[ 8 ] * 0.4290427654048917 * ( x * x - y * y );
+    result += shCoefficients[4] * 0.8580855308097834 * x * y;
+    result -= shCoefficients[5] * 0.8580855308097834 * y * z;
+    result += shCoefficients[6] * (0.7431238683011272 * z * z - 0.24770795610037571);
+    result -= shCoefficients[7] * 0.8580855308097834 * x * z;
+    result += shCoefficients[8] * 0.4290427654048917 * (x * x - y * y);
 
     return result;
 }
 
-vec4 lpv_renormalize_weights(in vec4 source){
+vec4 lpv_renormalize_weights(in vec4 source) {
 
     float sum = source.x + source.y + source.z + source.w;
 
+    if (sum <= 0.0) {
+        return vec4(1.0);
+    }
+
     return source / sum;
 
 }
 
 
 
-#define LPV_NORMAL_BIAS 0.01
+/** 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
 
-vec3 lpv_sample_irradiance(vec3 position, vec3 normal){
+vec3 lpv_sample_irradiance(vec3 position, vec3 normal, vec3 view_direction) {
 
-    vec3 lookup_position = position + normal * LPV_NORMAL_BIAS;
+    // 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 = (lookup_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(lookup_position);
 
     uint tet;
     vec4 weights;
-    lpv_getTetrahedron(lookup_position, nearest_tet, tet, weights);
-
-    weights = lvp_mask_weights_by_visibility(lookup_position, tet, weights);
-//    weights = lvp_mask_weights_by_visibility_by_normal(lookup_position, normal, tet, weights);
+    lpv_walk_to_tetrahedron(lookup_position, nearest_tet, tet, weights);
 
-    // square weights to mimic irradiance influence
-    // weights = weights * weights;
+    // apply visibility term
+    //    weights = lvp_mask_weights_by_visibility_by_depth(lookup_position, tet, weights);
+    //    weights = lvp_mask_weights_by_visibility_by_normal(lookup_position,normal, tet, weights);
+    weights *= lvp_mask_weights_by_visibility(lookup_position, normal, tet);
 
     // re-normalize weights
-//    weights = normalize(weights);
     weights = lpv_renormalize_weights(weights);
 
-    if(tet == INVALID_TET){
+    if (tet == INVALID_TET) {
         // do nothing
         return vec3(0.0);
 
-    }else{
+    } else {
 
         vec3[9] lpv_values = lpv_interpolate_probes(weights, tet);
 
-        return lpv_get_irradiance_at( normal, lpv_values  );
+        return lpv_get_irradiance_at(normal, lpv_values);
 
     }
 }

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

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

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

@@ -22,12 +22,10 @@ const ACCUMULATION = `
     
         vec3 world_normal = normalize(inverseTransformDirection( geometry.normal, viewMatrix ));
         
-        vec3 probe_irradiance = lpv_sample_irradiance( vWorldPosition, world_normal );
+        vec3 probe_irradiance = lpv_sample_irradiance( vWorldPosition, world_normal, geometry.viewDir );
         
         irradiance += probe_irradiance * lpv_f_intensity;
-        // irradiance += vec3(1.0) * step(probe_irradiance.r,1.0);
-        //    
-        // material.diffuseColor.rgb = vec3(1.0) ;
+        
     }
 
 

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

@@ -31,7 +31,7 @@ export class LightProbeVolume {
      * Depth map is stored as a 2d texture of size RESOLUTION x RESOLUTION
      * @type {number}
      */
-    #probe_depth_resolution = 24;
+    #probe_depth_resolution = 16;
 
     /**
      * Octahedral-encoded depth map for each probe

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":"AAmDA;IAGI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CA6DrB;CACJ;wCAhHuC,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

@@ -1,57 +1,12 @@
-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 { find_max_depth_radius_for_point } from "./find_max_depth_radius_for_point.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();
     _ren = new PathTracerProbeRenderer();
 
 
@@ -86,11 +41,14 @@ export class LightProbeVolumeBaker {
             // 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_distance*1.05 + 0.00001,
+                max_depth,
                 lpv.points, i * 3,
                 lpv.depth, i * depth_resolution * depth_resolution
             );

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

@@ -1,9 +1,9 @@
 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

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":"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"}
+{"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

@@ -12,7 +12,6 @@ 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";
 
 const __shared_buffer = new ArrayBuffer((27 + 9) * 8);
@@ -24,33 +23,12 @@ const sampled_irradiance = new Float32Array(3);
 
 export class PathTracerProbeRenderer extends ProbeRenderer {
     tracer = new PathTracer();
+    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
-        );
-
-        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;
-            }
-        }
-
-    }
-
     /**
      *
      * @param {number} resolution
@@ -84,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);
 

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

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

@@ -6,6 +6,8 @@ import { Ray3 } from "../../../../../../core/geom/3d/Ray3.js";
 
 const scratch_ray = new Ray3();
 
+const ray_hit = [];
+
 /**
  *
  * @param {number[]} result
@@ -29,13 +31,11 @@ export function bake_octahedral_depth_map(
 
     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);
+            const u = (oct_x) / (resolution - 1);
+            const v = (oct_y) / (resolution - 1);
 
             decode_octahedron_to_unit(
                 ray_direction, 0,

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

@@ -1 +1 @@
-{"version":3,"file":"VLPDepthMapVisualisation.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js"],"names":[],"mappings":"AA0EA;IAYI;;;;OAIG;IACH,oCAFa,wBAAwB,CAQpC;IAfD,qBAEC;IAeD,gBA4CC;;CAEJ;mBAtIkB,iCAAiC"}
+{"version":3,"file":"VLPDepthMapVisualisation.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js"],"names":[],"mappings":"AA6EA;IAYI;;;;OAIG;IACH,oCAFa,wBAAwB,CAQpC;IAfD,qBAEC;IAeD,gBA4CC;;CAEJ;mBAzIkB,iCAAiC"}

package/src/engine/graphics/sh3/lpv/depth/octahedral/v2/VLPDepthMapVisualisation.js

@@ -49,6 +49,9 @@ function makeMaterial(lpv) {
             },
             lpv_t_probe_depth: {
                 value: depth_atlas
+            },
+            lpv_u_probe_depth_resolution:{
+                value: lpv.depth_map_resolution
             }
         }
     });

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

@@ -12,6 +12,8 @@ precision highp usampler3D;
 uniform sampler2D lpv_t_probe_positions;
 uniform sampler2D lpv_t_probe_depth;
 
+uniform uint lpv_u_probe_depth_resolution;
+
 #define SEARCH_STEP_LIMIT 64u
 #define INVALID_TET 1073741823u
 
@@ -84,7 +86,7 @@ float SampleBlended(sampler2D tex, vec2 uv0, vec2 uv1, vec2 uv2, vec4 weights) {
 
 float lpv_probe_getDepth(uint probe_index, vec3 direction) {
     // get offset
-    uint depth_tile_resolution = 24u;
+    uint depth_tile_resolution = lpv_u_probe_depth_resolution;
     uvec2 atlas_size = uvec2(4096u);
 
     uint tiles_per_row = atlas_size.x / depth_tile_resolution;
@@ -152,7 +154,7 @@ void main() {
     vec3 normal = normalize(vNormal);
     vec3 worldNormal = normalize(inverseTransformDirection(normal, viewMatrix));
 
-    float depth = lpv_probe_getDepth(instance_index , worldNormal) / 10.0;
+    float depth = lpv_probe_getDepth(instance_index , worldNormal) / 7.0;
 
     gl_FragColor = vec4(vec3(depth), 1.0);
 //    gl_FragColor = vec4( 1.0);

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

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} vertex_index
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} points
+ */
+export function find_max_depth_radius_for_point(vertex_index: number, mesh: TetrahedralMesh, points: number[]): number;
+//# sourceMappingURL=find_max_depth_radius_for_point.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"find_max_depth_radius_for_point.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/find_max_depth_radius_for_point.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,8DAJW,MAAM,iCAEN,MAAM,EAAE,UAiClB"}

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

@@ -0,0 +1,50 @@
+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";
+
+/**
+ *
+ * @type {number[]}
+ */
+const tets = [];
+
+/**
+ *
+ * @param {number} vertex_index
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} points
+ */
+export function find_max_depth_radius_for_point(vertex_index, mesh, points) {
+
+    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);
+}

package/src/engine/graphics/sh3/prototypeSH3Probe.js

@@ -364,7 +364,6 @@ async function main(engine) {
     // const path = 'data/models/samples/sd_macross_city_standoff_diorama/scene.gltf';
     // const path = 'data/models/sibenik/2/model.gltf';
     // const path = 'data/models/vokselia_spawn/model.gltf';
-    // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
     // const path = 'data/models/samples/just_a_girl/scene.gltf';
     // const path = 'data/models/samples/slum_house/scene.gltf';
     // const path = 'data/models/samples/jack_trigger/scene.gltf';
@@ -374,14 +373,15 @@ async function main(engine) {
     // const path = 'data/models/samples/ancient_bath_house_-_modular_set/scene.gltf';
     // const path = 'data/models/samples/environment_-_library/scene.gltf';
     // const path = 'data/models/Scans/green_car_wreck/scene.gltf';
-    // const path = 'data/models/pica_pica/pica_pica.gltf';
-    // const path = 'data/models/sibenik/3-window-less/model.gltf';
     // const path = 'data/models/samples/low_poly_classroom/no-glass/model.gltf';
     // const path = 'data/models/samples/the_attic_environment/scene1.gltf';
     // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/samples/cyberpunk_bike/scene.gltf';
+    // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
+    // const path = 'data/models/sibenik/3-window-less/model.gltf';
+    // const path = 'data/models/samples/gi_box_01/model.glb';
     // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
-    const path = 'data/models/samples/gi_box_01/model.glb';
+    const path = 'data/models/pica_pica/pica_pica.gltf';
 
     const mesh_asset = await engine.assetManager.promise(path, 'model/gltf+json');
     const gltf = mesh_asset.gltf;