@woosh/meep-engine 3.58.0 → 3.59.0

package/src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js

@@ -4,6 +4,7 @@ import {
     chunk_lpv_sample_depth_atlas,
     chunk_lpv_sample_depth_atlas_native
 } from "../../../shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js";
+import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { LPV_PROBES_RESOURCE } from "../../probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
@@ -24,34 +25,14 @@ fn lpv_get_visibility_mask(
 
     let direction = local_probe_offset / distance_to_probe;
 
-    let temp = lpv_sample_depth_atlas( direction, probe_index );
-
-    let mean = temp.x;
-    let mean2 = temp.y; // mean of squared distances
-
-    // prevent variance from going to 0, which would produce NaN
-    // NOTE: not sure if this is strictly necessary
-    const MIN_VARIANCE = 1e-6;
-    let variance = max(MIN_VARIANCE, abs(mean2 - mean * mean));
+    // the mean of distances and of their squares
+    let moments = lpv_sample_depth_atlas( direction, probe_index );
 
     // normalize distance. Depth is stored relative to probe.distance_max
     let distance_normalized = distance_to_probe / probe.distance_max;
 
-    // http://www.punkuser.net/vsm/vsm_paper.pdf; equation 5
-    // Need the max in the denominator because biasing can cause a negative displacement
-    let d = distance_normalized - mean;
-    
-    if(d <= 0.0){
-        // no occlusion
-        return 1.0;
-    }
-    
-    let chebyshev_weight = variance / (variance + d * d);
-    
-    
     // note that we don't clip visibility here for light-bleeding reduction, this is done outside in the weighting function
-    
-    return chebyshev_weight;
+    return probe_visibility_chebyshev(moments.xy, distance_normalized);
     
 }
     `,
@@ -59,6 +40,7 @@ fn lpv_get_visibility_mask(
         chunk_lpv_probe_get_position,
         chunk_lpv_sample_depth_atlas_native,
         chunk_inverse_lerp,
+        chunk_probe_visibility_weight,
     ]
 );
 

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts

@@ -14,7 +14,9 @@
  * and the settings on every frame the mode runs ({@link graph_update}). The clipmaps are made on the
  * first such frame, and made again when a frame is for another view or a structural setting has
  * changed; {@link release} gives them back on the first frame out of the mode, and {@link destroy}
- * with the renderer. Nothing is allocated before the mode first runs.
+ * with the renderer. Nothing is allocated before the mode first runs but the placeholders the probes'
+ * readers bind while there are no probes ({@link write_sampling_bindings}): seven objects of a few bytes,
+ * made on the first ask and kept until {@link destroy}.
  *
  * Each frame it holds the geometry caches and card sets its scene's SDF world draws
  * ({@link ProbeClipmapSceneHolds}), trims the caches nothing holds, and records their bake and the
@@ -56,8 +58,10 @@ export class GPUProbeClipmapGI {
      *   times run on
      * @param {number} [options.movers] the graph handle of the scene's mover list for the frame,
      *   which the world's bricks are built again over
+     * @param {number} options.shadowmap_atlas graph handle of the frame's shadow map atlas, which shadows
+     *   the local lights at the probes' hits
      */
-    graph_update({ graph, view, settings, depth, normal, stbn, time, movers }: {
+    graph_update({ graph, view, settings, depth, normal, stbn, time, movers, shadowmap_atlas }: {
         graph: FrameGraph;
         view: GPUViewContext;
         settings: ProbeClipmapSettings;
@@ -66,7 +70,24 @@ export class GPUProbeClipmapGI {
         stbn: any;
         time: number;
         movers?: number;
+        shadowmap_atlas: number;
     }): void;
+    /**
+     * Whether the probes are there to read: the mode has run a frame and not been left since.
+     * @returns {boolean}
+     */
+    get has_probes(): boolean;
+    /**
+     * Put what the probes' readers bind into `bindings`, `PROBE_CLIPMAP_SAMPLING_GROUP` but its sampler:
+     * once {@link has_probes}, the probes as this frame's {@link graph_update} left them
+     * (`GPUProbeClipmap.write_sampling_bindings`); before that, or out of the mode, a clipmap of no
+     * cascade, whose pick finds nothing. A shader that can take this mode's alternative binds the group in
+     * every mode, as its variants share their resources.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_sampling_bindings(bindings: any): any;
     /**
      * The debug view the settings ask for, in place of the frame's colour. Record it after
      * {@link graph_update} in the same frame.
@@ -85,8 +106,8 @@ export class GPUProbeClipmapGI {
         resolution: number[];
     }): number;
     /**
-     * Have a plugin write the world's bricks too, after the mesh provider and every provider added
-     * before it, over the same taken cells (§7.6).
+     * Have a plugin write the world's bricks too, after the engine's own providers and every
+     * provider added before it, over the same taken cells (§7.6).
      *
      * @param {BrickProvider} provider
      */

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IAmDI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACC,IAAI,EAApB,MAAM;QAEW,MAAM,GAAvB,MAAM;aAkGhB;IAED;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAQC;;CACJ;yBApWY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAf/B,4BAA4B;gCAM5B,4BAA4B;uCAErB,6BAA6B"}
+{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAgBA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAiEI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAb+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACC,IAAI,EAApB,MAAM;QAEW,MAAM,GAAvB,MAAM;QAEU,eAAe,EAA/B,MAAM;aAoGhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IA0CD;;;OAGG;IACH,gBAsBC;IAED,gBAcC;;CACJ;yBArdY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAlB/B,4BAA4B;gCAS5B,4BAA4B;uCAErB,6BAA6B"}

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js

@@ -1,10 +1,15 @@
 import { assert } from "../../../../core/assert.js";
+import { BufferDescriptor } from "../../../descriptor/buffer/BufferDescriptor.js";
+import { CLIPMAP_LEVEL_ARRAY } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { GPUBrickClipmap } from "./brick/GPUBrickClipmap.js";
 import { MeshSDFBrickProvider } from "./brick/mesh/MeshSDFBrickProvider.js";
+import { VGeoBrickProvider } from "./brick/vgeo/VGeoBrickProvider.js";
 import { graph_probe_clipmap_debug_brick_clipmap } from "./debug/graph_probe_clipmap_debug_brick_clipmap.js";
 import { graph_probe_clipmap_debug_mesh_cards } from "./debug/graph_probe_clipmap_debug_mesh_cards.js";
 import { graph_probe_clipmap_debug_mesh_sdf } from "./debug/graph_probe_clipmap_debug_mesh_sdf.js";
 import { ProbeClipmapDebugView } from "./debug/ProbeClipmapDebugView.js";
+import { PROBE_RECORD_STRUCT } from "./probe/chunk_probe_clipmap.js";
+import { PROBE_SAMPLING_STRUCT } from "./probe/chunk_probe_clipmap_pick.js";
 import { GPUProbeClipmap } from "./probe/GPUProbeClipmap.js";
 import { PROBE_DEPTH_TEXEL_RAYS } from "./probe/PROBE_CLIPMAP.js";
 import { ProbeClipmapSceneHolds } from "./ProbeClipmapSceneHolds.js";
@@ -26,7 +31,9 @@ import { ProbeClipmapSceneHolds } from "./ProbeClipmapSceneHolds.js";
  * and the settings on every frame the mode runs ({@link graph_update}). The clipmaps are made on the
  * first such frame, and made again when a frame is for another view or a structural setting has
  * changed; {@link release} gives them back on the first frame out of the mode, and {@link destroy}
- * with the renderer. Nothing is allocated before the mode first runs.
+ * with the renderer. Nothing is allocated before the mode first runs but the placeholders the probes'
+ * readers bind while there are no probes ({@link write_sampling_bindings}): seven objects of a few bytes,
+ * made on the first ask and kept until {@link destroy}.
  *
  * Each frame it holds the geometry caches and card sets its scene's SDF world draws
  * ({@link ProbeClipmapSceneHolds}), trims the caches nothing holds, and records their bake and the
@@ -68,8 +75,8 @@ export class GPUProbeClipmapGI {
     #destroyed = false;
 
     /**
-     * The plugins that write the world's bricks after the mesh provider, in the order they were
-     * added (§7.6).
+     * The plugins that write the world's bricks after the engine's own providers, in the order they
+     * were added (§7.6).
      * @type {BrickProvider[]}
      */
     #plugins = [];
@@ -81,11 +88,25 @@ export class GPUProbeClipmapGI {
     #mesh_provider = undefined;
 
     /**
-     * Every provider in its order, the mesh provider first: what a frame's build runs.
+     * The virtual geometry provider (§7.8), made with the clipmaps and given back with them.
+     * @type {VGeoBrickProvider|undefined}
+     */
+    #vgeo_provider = undefined;
+
+    /**
+     * Every provider in its order, the mesh provider first and the virtual geometry provider next:
+     * what a frame's build runs.
      * @type {BrickProvider[]}
      */
     #providers = [];
 
+    /**
+     * What the probes' readers bind while there are no probes: a clipmap of no cascade, so their pick
+     * finds nothing. Made on the first ask.
+     * @type {{buffers: GPUBuffer[], textures: GPUTexture[], bindings: Object}|undefined}
+     */
+    #placeholders = undefined;
+
     /**
      * @param {GraphicsContext} graphics
      */
@@ -132,13 +153,16 @@ export class GPUProbeClipmapGI {
      *   times run on
      * @param {number} [options.movers] the graph handle of the scene's mover list for the frame,
      *   which the world's bricks are built again over
+     * @param {number} options.shadowmap_atlas graph handle of the frame's shadow map atlas, which shadows
+     *   the local lights at the probes' hits
      */
-    graph_update({ graph, view, settings, depth, normal, stbn, time, movers = -1 }) {
+    graph_update({ graph, view, settings, depth, normal, stbn, time, movers = -1, shadowmap_atlas }) {
         assert.defined(graph, 'graph');
         assert.defined(view, 'view');
         assert.defined(settings, 'settings');
         assert.isNonNegativeInteger(depth, 'depth');
         assert.isNonNegativeInteger(normal, 'normal');
+        assert.isNonNegativeInteger(shadowmap_atlas, 'shadowmap_atlas');
         assert.isFinite(time, 'time');
         assert.notOk(this.#destroyed, 'destroyed');
 
@@ -227,9 +251,94 @@ export class GPUProbeClipmapGI {
             scene,
             materials,
             card_rows: this.#holds.rows_buffer,
+            shadowmap_atlas,
         });
     }
 
+    /**
+     * Whether the probes are there to read: the mode has run a frame and not been left since.
+     * @returns {boolean}
+     */
+    get has_probes() {
+        return this.#probe_clipmap !== undefined;
+    }
+
+    /**
+     * Put what the probes' readers bind into `bindings`, `PROBE_CLIPMAP_SAMPLING_GROUP` but its sampler:
+     * once {@link has_probes}, the probes as this frame's {@link graph_update} left them
+     * (`GPUProbeClipmap.write_sampling_bindings`); before that, or out of the mode, a clipmap of no
+     * cascade, whose pick finds nothing. A shader that can take this mode's alternative binds the group in
+     * every mode, as its variants share their resources.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_sampling_bindings(bindings) {
+        if (this.has_probes) {
+            return this.#probe_clipmap.write_sampling_bindings(bindings);
+        }
+
+        if (this.#placeholders === undefined) {
+            this.#placeholders = this.#make_placeholders();
+        }
+
+        return Object.assign(bindings, this.#placeholders.bindings);
+    }
+
+    /**
+     * A clipmap of no cascade, zeroed as made: its sampling uniform counts no cascade, so the pick selects
+     * none and reads nothing past the levels.
+     */
+    #make_placeholders() {
+        const device = this.#graphics.device;
+
+        const buffer = (name, size, usage) => device.createBuffer(BufferDescriptor.fromJSON({
+            label: `Probe clipmap / placeholder ${name}`,
+            size,
+            usage,
+        }));
+
+        const levels = buffer('levels', CLIPMAP_LEVEL_ARRAY.size, GPUBufferUsage.UNIFORM);
+        const sampling = buffer('sampling', PROBE_SAMPLING_STRUCT.size, GPUBufferUsage.UNIFORM);
+        // a state and a record, the least a binding of their arrays holds
+        const states = buffer('states', 8, GPUBufferUsage.STORAGE);
+        const records = buffer('records', PROBE_RECORD_STRUCT.size, GPUBufferUsage.STORAGE);
+
+        const indirection = device.createTexture({
+            label: 'Probe clipmap / placeholder indirection',
+            size: [1, 1, 1],
+            dimension: '3d',
+            format: 'r32uint',
+            usage: GPUTextureUsage.TEXTURE_BINDING,
+        });
+        const depth = device.createTexture({
+            label: 'Probe clipmap / placeholder depth',
+            size: [1, 1],
+            format: 'rg16float',
+            usage: GPUTextureUsage.TEXTURE_BINDING,
+        });
+        const radiance = device.createTexture({
+            label: 'Probe clipmap / placeholder radiance',
+            size: [1, 1],
+            format: 'rgba16float',
+            usage: GPUTextureUsage.TEXTURE_BINDING,
+        });
+
+        return {
+            buffers: [levels, sampling, states, records],
+            textures: [indirection, depth, radiance],
+            bindings: {
+                probe_levels: levels,
+                probe_sampling: sampling,
+                probe_indirection: indirection.createView(),
+                probe_states: states,
+                probe_records: records,
+                probe_depth: depth.createView(),
+                probe_radiance: radiance.createView(),
+            },
+        };
+    }
+
     /**
      * The debug view the settings ask for, in place of the frame's colour. Record it after
      * {@link graph_update} in the same frame.
@@ -261,8 +370,8 @@ export class GPUProbeClipmapGI {
     }
 
     /**
-     * Have a plugin write the world's bricks too, after the mesh provider and every provider added
-     * before it, over the same taken cells (§7.6).
+     * Have a plugin write the world's bricks too, after the engine's own providers and every
+     * provider added before it, over the same taken cells (§7.6).
      *
      * @param {BrickProvider} provider
      */
@@ -298,7 +407,7 @@ export class GPUProbeClipmapGI {
         providers.length = 0;
 
         if (this.#mesh_provider !== undefined) {
-            providers.push(this.#mesh_provider);
+            providers.push(this.#mesh_provider, this.#vgeo_provider);
         }
 
         providers.push(...this.#plugins);
@@ -312,6 +421,7 @@ export class GPUProbeClipmapGI {
         const device = this.#graphics.device;
 
         this.#mesh_provider = new MeshSDFBrickProvider(device);
+        this.#vgeo_provider = new VGeoBrickProvider(device);
         this.#order_providers();
 
         this.#brick_clipmap = new GPUBrickClipmap(device, {
@@ -348,8 +458,10 @@ export class GPUProbeClipmapGI {
         this.#brick_clipmap.destroy();
         this.#probe_clipmap.destroy();
         this.#mesh_provider.destroy();
+        this.#vgeo_provider.destroy();
 
         this.#mesh_provider = undefined;
+        this.#vgeo_provider = undefined;
         this.#order_providers();
 
         this.#brick_clipmap = undefined;
@@ -365,5 +477,11 @@ export class GPUProbeClipmapGI {
         this.#destroyed = true;
 
         this.release();
+
+        if (this.#placeholders !== undefined) {
+            this.#placeholders.buffers.forEach(buffer => buffer.destroy());
+            this.#placeholders.textures.forEach(texture => texture.destroy());
+            this.#placeholders = undefined;
+        }
     }
 }