@woosh/meep-engine 2.109.20 → 2.109.22

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js

@@ -0,0 +1,147 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ *
+ * @param {number[]} result result is written as a 2d vector, since barycentrics add up to 1, we omit the last value
+ * @param {number} result_offset
+ * @param {number} px reference point
+ * @param {number} py reference point
+ * @param {number} pz reference point
+ * @param {number} ax Triangle apex A
+ * @param {number} ay Triangle apex A
+ * @param {number} az Triangle apex A
+ * @param {number} bx Triangle apex B
+ * @param {number} by Triangle apex B
+ * @param {number} bz Triangle apex B
+ * @param {number} cx Triangle apex C
+ * @param {number} cy Triangle apex C
+ * @param {number} cz Triangle apex C
+ * @returns {void}
+ */
+export function computeTriangleClosestPointToPointBarycentric(
+    result, result_offset,
+    px, py, pz,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+){
+
+    let v, w;
+
+    // algorithm thanks to Real-Time Collision Detection by Christer Ericson,
+    // published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
+    // under the accompanying license; see chapter 5.1.5 for detailed explanation.
+    // basically, we're distinguishing which of the voronoi regions of the triangle
+    // the point lies in with the minimum amount of redundant computation.
+
+    // localize coordinates with respect to A
+    const _vab_x = bx - ax;
+    const _vab_y = by - ay;
+    const _vab_z = bz - az;
+
+    const _vac_x = cx - ax;
+    const _vac_y = cy - ay;
+    const _vac_z = cz - az;
+
+    const _vap_x = px - ax;
+    const _vap_y = py - ay;
+    const _vap_z = pz - az;
+
+    const d1 = v3_dot(_vab_x, _vab_y, _vab_z,  _vap_x, _vap_y, _vap_z );
+    const d2 = v3_dot(_vac_x, _vac_y, _vac_z,  _vap_x, _vap_y, _vap_z );
+
+    if ( d1 <= 0 && d2 <= 0 ) {
+
+        // vertex region of A; barycentric coords (1, 0, 0)
+
+        result[result_offset] = 1;
+        result[result_offset+1] = 0;
+
+        return;
+
+    }
+
+    const _vbp_x = px - bx;
+    const _vbp_y = py - by;
+    const _vbp_z = pz - bz;
+
+    const d3 = v3_dot(_vab_x, _vab_y, _vab_z,  _vbp_x, _vbp_y, _vbp_z );
+    const d4 = v3_dot(_vac_x, _vac_y, _vac_z,  _vbp_x, _vbp_y, _vbp_z );
+
+    if ( d3 >= 0 && d4 <= d3 ) {
+
+        // vertex region of B; barycentric coords (0, 1, 0)
+
+        result[result_offset] = 0;
+        result[result_offset+1] = 1;
+
+        return;
+
+    }
+
+    const vc = d1 * d4 - d3 * d2;
+    if ( vc <= 0 && d1 >= 0 && d3 <= 0 ) {
+
+        v = d1 / ( d1 - d3 );
+        // edge region of AB; barycentric coords (1-v, v, 0)
+
+        result[result_offset] = 1-v;
+        result[result_offset+1] = v;
+
+        return;
+
+    }
+
+    const _vcp_x = px - cx;
+    const _vcp_y = py - cy;
+    const _vcp_z = pz - cz;
+
+    const d5 = v3_dot(_vab_x, _vab_y, _vab_z,  _vcp_x, _vcp_y, _vcp_z );
+    const d6 = v3_dot(_vac_x, _vac_y, _vac_z,  _vcp_x, _vcp_y, _vcp_z );
+
+    if ( d6 >= 0 && d5 <= d6 ) {
+
+        // vertex region of C; barycentric coords (0, 0, 1)
+
+        result[result_offset] = 0;
+        result[result_offset+1] = 0;
+
+        return;
+
+    }
+
+    const vb = d5 * d2 - d1 * d6;
+    if ( vb <= 0 && d2 >= 0 && d6 <= 0 ) {
+
+        w = d2 / ( d2 - d6 );
+
+        // edge region of AC; barycentric coords (1-w, 0, w)
+
+        result[result_offset] = 1-w;
+        result[result_offset+1] = 0;
+
+        return;
+
+    }
+
+    const va = d3 * d6 - d5 * d4;
+    if ( va <= 0 && ( d4 - d3 ) >= 0 && ( d5 - d6 ) >= 0 ) {
+
+        w = ( d4 - d3 ) / ( ( d4 - d3 ) + ( d5 - d6 ) );
+        // edge region of BC; barycentric coords (0, 1-w, w)
+
+        result[result_offset] = 0;
+        result[result_offset+1] = 1-w;
+
+        return;
+
+    }
+
+    // face region
+    const denom = 1 / ( va + vb + vc );
+    const u = va * denom
+    v = vb * denom;
+
+    result[result_offset] = u;
+    result[result_offset+1] = v;
+}

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=computeTriangleClosestPointToPointBarycentric.spec.d.ts.map

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeTriangleClosestPointToPointBarycentric.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.js"],"names":[],"mappings":""}

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.js

@@ -0,0 +1,100 @@
+import { computeTriangleClosestPointToPointBarycentric } from "./computeTriangleClosestPointToPointBarycentric.js";
+
+test("basics", () => {
+
+    const result = [];
+
+    // internal point
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 0.5, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0.25,0.25]);
+
+    // point lies on a vertex
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        -1, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([1,0]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        1, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,1]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 1, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,0]);
+
+    // point lies on an edge
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0.5,0.5]);
+
+    // point lies outside the triangle
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        - 2, 0, 0,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([1,0]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        2, 0, 0 ,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,1]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, 2, 0 ,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0,0]);
+
+    computeTriangleClosestPointToPointBarycentric(
+        result, 0,
+        0, -2, 0 ,
+        -1, 0, 0,
+        1, 0, 0,
+        0, 1, 0
+    );
+
+    expect(result).toEqual([0.5,0.5]);
+});

package/src/core/geom/octahedral_uv_crease_distance.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Distance to the nearest crease
+ * @param {number} u from 0 to 1
+ * @param {number} v from 0 to 1
+ * @returns {number}
+ */
+export function octahedral_uv_crease_distance(u: number, v: number): number;
+//# sourceMappingURL=octahedral_uv_crease_distance.d.ts.map

package/src/core/geom/octahedral_uv_crease_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"octahedral_uv_crease_distance.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/octahedral_uv_crease_distance.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,iDAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB"}

package/src/core/geom/octahedral_uv_crease_distance.js

@@ -0,0 +1,26 @@
+/**
+ * Distance to the nearest crease
+ * @param {number} u from 0 to 1
+ * @param {number} v from 0 to 1
+ * @returns {number}
+ */
+export function octahedral_uv_crease_distance(u, v) {
+
+    const cross_distance_u = Math.abs(u - 0.5);
+    const cross_distance_v = Math.abs(v - 0.5);
+
+    const cross_distance = Math.min(cross_distance_u, cross_distance_v);
+
+    const n_u = u * 2 - 1;
+    const n_v = v * 2 - 1;
+
+    // for the belt of the fold
+    const fold = 1 - Math.abs(n_u) - Math.abs(n_v);
+
+    const fold_distance = Math.abs(fold);
+
+    // distance to the edge of the map, which folds the welding crease
+    const welding_crease_distance = Math.min(Math.min(u, 1 - u), Math.min(v, 1 - v));
+
+    return Math.min(fold_distance, cross_distance, welding_crease_distance);
+}

package/src/core/math/random/generate_halton_jitter.js

@@ -13,8 +13,8 @@ export function generate_halton_jitter(point_count) {
 
     for (let i = 0; i < point_count; i++) {
         const i2 = i * 2;
-        result[i2] = 1 - halton_sequence(2, i) * 2;
-        result[i2 + 1] = 1 - halton_sequence(3, i) * 2;
+        result[i2] = halton_sequence(2, i) * 2 - 1;
+        result[i2 + 1] = halton_sequence(3, i) * 2 - 1;
     }
 
     return result;

package/src/core/math/statistics/generate_hammersley_jitter.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {number} sample_count
+ * @returns {Float32Array}
+ */
+export function generate_hammersley_jitter(sample_count: number): Float32Array;
+//# sourceMappingURL=generate_hammersley_jitter.d.ts.map

package/src/core/math/statistics/generate_hammersley_jitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_hammersley_jitter.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/generate_hammersley_jitter.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,yDAHW,MAAM,GACJ,YAAY,CAUxB"}

package/src/core/math/statistics/generate_hammersley_jitter.js

@@ -0,0 +1,16 @@
+import { hammersley_sequence_2d } from "./hammersley_sequence_2d.js";
+
+/**
+ *
+ * @param {number} sample_count
+ * @returns {Float32Array}
+ */
+export function generate_hammersley_jitter(sample_count) {
+    const result = new Float32Array(sample_count * 2);
+
+    for (let i = 0; i < sample_count; i++) {
+        hammersley_sequence_2d(result, i * 2, i, sample_count);
+    }
+
+    return result;
+}

package/src/core/math/statistics/hammersley_sequence_2d.js

@@ -14,4 +14,5 @@ export function hammersley_sequence_2d(
 
     output[output_offset] = i / N;
     output[output_offset + 1] = radical_inverse_VdC_base_2(i);
-}
+}
+

package/src/core/model/object/objectDeepEquals.d.ts

@@ -1 +1 @@
-export function objectDeepEquals(a: object, b: object): boolean
+export function objectDeepEquals<A extends object, B extends object>(a: A, b: B, value_equals: (a: A, b: B) => boolean, value_equals_context?: any): boolean

package/src/core/model/object/objectDeepEquals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"objectDeepEquals.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/objectDeepEquals.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,oDAFa,OAAO,CAuDnB"}
+{"version":3,"file":"objectDeepEquals.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/objectDeepEquals.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,8IAFa,OAAO,CAiFnB"}

package/src/core/model/object/objectDeepEquals.js

@@ -5,9 +5,16 @@ import { isArraysEqualWithComparator } from "../../collection/array/isArraysEqua
  * @template A,B
  * @param {A} a
  * @param {B} b
+ * @param {function(a:A, b:B):boolean} [value_equality_function] allows you to insert custom element comparison function
+ * @param {*} [value_equality_function_context]
  * @returns {boolean}
  */
-export function objectDeepEquals(a, b) {
+export function objectDeepEquals(
+    a, b,
+    value_equality_function = objectDeepEquals,
+    value_equality_function_context = null
+) {
+
     if (a === b) {
         // identity shortcut
         return true;
@@ -23,41 +30,62 @@ export function objectDeepEquals(a, b) {
     if (tA !== "object") {
         // primitive types, identity equality already checked
         return false;
-    } else {
+    }
+
+    if (a === null || b === null) {
+        // we know that A and B are not the same, so if one of them is a null - there is no possible equality
+        return false;
+    }
 
-        if (a === null || b === null) {
-            // we know that A and B are not the same, so if one of them is a null - there is no possible equality
+    if (Array.isArray(a)) {
+        // special fast path for arrays
+        if (!Array.isArray(b)) {
+            // one is an array, the other is not
             return false;
         }
+        return isArraysEqualWithComparator(a, b, value_equality_function, value_equality_function_context);
+    }
 
-        if (Array.isArray(a)) {
-            // special fast path for arrays
-            if (!Array.isArray(b)) {
-                // one is an array, the other is not
-                return false;
-            }
-            return isArraysEqualWithComparator(a, b, objectDeepEquals);
-        }
+    // try equals function
+    if (
+        typeof a.equals === "function"
+        && typeof b.equals === "function"
+    ) {
+        return a.equals(b);
+    }
 
-        const keys_a = Object.keys(a);
-        const keys_b = Object.keys(b);
+    const keys_a = Object.keys(a);
+    const keys_b = Object.keys(b);
 
-        if (!isArrayEqualStrict(keys_a, keys_b)) {
-            // different fields
-            return false;
-        }
+    // sort keys to eliminate ordering concerns
+    keys_a.sort();
+    keys_b.sort();
 
-        const key_count = keys_a.length;
+    if (!isArrayEqualStrict(keys_a, keys_b)) {
+        // different fields
+        return false;
+    }
 
-        for (let i = 0; i < key_count; i++) {
-            const key = keys_a[i];
+    const key_count = keys_a.length;
 
-            if (!objectDeepEquals(a[key], b[key])) {
-                return false;
-            }
-        }
+    for (let i = 0; i < key_count; i++) {
+        const key = keys_a[i];
 
-        return true;
+        const a_value = a[key];
+        const b_value = b[key];
+
+        const values_are_equal = value_equality_function.call(
+            value_equality_function_context,
+            a_value,
+            b_value
+        );
 
+        if (!values_are_equal) {
+            return false;
+        }
     }
+
+    // looks like we have equality
+    return true;
+
 }

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeGeometryEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryEquality.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,2CAJW,MAAM,cAAc,KACpB,MAAM,cAAc,GAClB,OAAO,CA+CnB"}
+{"version":3,"file":"computeGeometryEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryEquality.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,2CAJW,MAAM,cAAc,KACpB,MAAM,cAAc,GAClB,OAAO,CAmDnB"}

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.js

@@ -9,6 +9,10 @@ import { is_typed_array_equals } from "../../../../core/collection/array/typed/i
  * @returns {boolean}
  */
 export function computeGeometryEquality(a, b) {
+    if (a === b) {
+        // identity shortcut
+        return true;
+    }
 
     const a_index = a.getIndex();
     const b_index = b.getIndex();

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

@@ -362,7 +362,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;
 }

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

@@ -28,13 +28,6 @@ export class LightProbeVolume {
      * @param {number} z
      */
     add_point(x: number, y: number, z: number): void;
-    /**
-     *
-     * @param {number} index
-     * @param {number[]} source
-     * @param {number} source_offset
-     */
-    write_probe(index: number, source: number[], source_offset: number): void;
     /**
      * Build tetrahedral mesh
      */

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

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAMD;;;OAGG;IACH,sCAIC;IAZD,mCAEC;IAYD,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAIhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAjM+B,wDAAwD;2BAC7D,mCAAmC"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAMD;;;OAGG;IACH,sCAIC;IAZD,mCAEC;IAYD,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAvL+B,wDAAwD;2BAC7D,mCAAmC"}

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

@@ -1,5 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import {
     compute_delaunay_tetrahedral_mesh
 } from "../../../../core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js";
@@ -134,16 +133,6 @@ export class LightProbeVolume {
         this.#probe_count++;
     }
 
-    /**
-     *
-     * @param {number} index
-     * @param {number[]} source
-     * @param {number} source_offset
-     */
-    write_probe(index, source, source_offset) {
-        array_copy(source, source_offset, this.#sh3_rgb, index * 9 * 3, 9 * 3);
-    }
-
     /**
      * Build tetrahedral mesh
      */

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

@@ -7,6 +7,13 @@ export class LightProbeVolumeBaker {
      * @param {EntityComponentDataset} ecd
      */
     bake(lpv: LightProbeVolume, ecd: EntityComponentDataset): TaskGroup;
+    /**
+     *
+     * @param {PathTracerProbeRenderer} renderer
+     * @param {LightProbeVolume} lpv
+     * @param {number} probe_index
+     */
+    bake_probe(renderer: PathTracerProbeRenderer, lpv: LightProbeVolume, probe_index: number): void;
 }
 import { PathTracerProbeRenderer } from "./PathTracerProbeRenderer.js";
 import TaskGroup from "../../../../core/process/task/TaskGroup.js";

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":"AAOA;IAEI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CAkErB;CACJ;wCA5EuC,8BAA8B;sBALhD,4CAA4C"}
+{"version":3,"file":"LightProbeVolumeBaker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolumeBaker.js"],"names":[],"mappings":"AAQA;IAEI,8BAAqC;IAGrC;;;;;OAKG;IACH,0DAJa,SAAS,CA2CrB;IAED;;;;;OAKG;IACH,qBAJW,uBAAuB,sCAEvB,MAAM,QA8BhB;CACJ;wCAzFuC,8BAA8B;sBALhD,4CAA4C"}

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

@@ -1,3 +1,4 @@
+import { assert } from "../../../../core/assert.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";
@@ -29,31 +30,8 @@ export class LightProbeVolumeBaker {
 
         const probe_count = lpv.count;
 
-        const tBakeIrradiance = countTask(0, probe_count, (i) => {
-
-            // Bake color
-            renderer.bake(
-                lpv.points, i * 3,
-                lpv.harmonics, i * 9 * 3
-            );
-
-
-            // Bake depth
-            const max_distance = find_max_depth_radius_for_point(i, lpv.mesh, lpv.points);
-
-            // bias a little to ensure we capture everything
-            const max_depth = max_distance * 1.01 + 1e-6;
-
-            const depth_resolution = lpv.depth_map_resolution;
-
-            const probe_element_count = depth_resolution * depth_resolution;
-
-            renderer.bake_depth_octahedral(
-                depth_resolution,
-                max_depth,
-                lpv.points, i * 3,
-                lpv.depth, i * probe_element_count
-            );
+        const tBakeIrradiance = countTask(0, probe_count, (probe_index) => {
+            this.bake_probe(renderer, lpv, probe_index);
 
         });
         tBakeIrradiance.estimatedDuration = probe_count;
@@ -79,4 +57,40 @@ export class LightProbeVolumeBaker {
             tPrepare, tBakeIrradiance, tFinish
         ], "LightProbeVolume Bake");
     }
+
+    /**
+     *
+     * @param {PathTracerProbeRenderer} renderer
+     * @param {LightProbeVolume} lpv
+     * @param {number} probe_index
+     */
+    bake_probe(renderer, lpv, probe_index) {
+        assert.isNonNegativeInteger(probe_index, 'probe_index');
+
+        const position_offset = probe_index * 3;
+
+        // Bake color
+        renderer.bake(
+            lpv.points, position_offset,
+            lpv.harmonics, probe_index * 9 * 3
+        );
+
+
+        // Bake depth
+        const max_distance = find_max_depth_radius_for_point(probe_index, lpv.mesh, lpv.points);
+
+        // bias a little to ensure we capture everything
+        const max_depth = max_distance * 1.01 + 1e-6;
+
+        const depth_resolution = lpv.depth_map_resolution;
+
+        const probe_element_count = depth_resolution * depth_resolution;
+
+        renderer.bake_depth_octahedral(
+            depth_resolution,
+            max_depth,
+            lpv.points, position_offset,
+            lpv.depth, probe_index * probe_element_count
+        );
+    }
 }

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

@@ -24,7 +24,7 @@ const sampled_irradiance = new Float32Array(3);
 export class PathTracerProbeRenderer extends ProbeRenderer {
     tracer = new PathTracer();
     max_bounce_count = 7;
-    sample_count = 4096;
+    sample_count = 1024;
     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":"AA6BA;;;;;;;;;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":"AAiCA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,oCAEN,MAAM,EAAE,UAAQ,mBAChB,MAAM,cACN,MAAM,aACN,MAAM,QAuHhB"}