@woosh/meep-engine 3.17.2 → 3.18.0

package/src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js

@@ -1,143 +1,167 @@
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
-import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
-import {
-    chunk_texture_channel_gaussian_3x3
-} from "../../shader/chunk/texture/chunk_texture_channel_gaussian_3x3.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { chunk_luma_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
-import { ATORUS_UNIFORMS_STRUCT } from "../denoise/fragment_shader_denoise_ao.js";
-import {
-    chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight
-} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight.js";
-import {
-    chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight
-} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, four bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("settings", ATORUS_UNIFORMS_STRUCT);
-resources.createGroup()
-    .addTexture("tInput")
-    .addTexture("tDepth")
-    .addTexture("tNormal", "uint");
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const phi_visibility = 10.0;
-const phi_normal = 32.0;
-const sigma_depth = 1.0;
- 
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec4<f32>{
-    let ipos = vec2<i32>(coord.xy);
-    let screen_size = vec2<i32>(textureDimensions(tInput));
-    
-    const eps_variance      = 1e-10;
-    const kernel_weights = array<f32,3>( 1.0, 2.0 / 3.0, 1.0 / 6.0 );
-    
-    // constant samplers to prevent the compiler from generating code which
-    // fetches the sampler descriptor from memory for each texture access
-    let center_color = textureLoad(tInput, ipos, 0);
-    
-    let center_color_luma = rgb_to_luminance(center_color.rgb);
-
-    // variance for direct and indirect, filtered using 3x3 gaussin blur
-    let variance = max(0.0, texture_channel_gaussian_3x3( ipos, tInput, 3));
-            
-    // explicitly store/accumulate center pixel with weight 1 to prevent issues
-    // with the edge-stopping functions
-    var sum_weight = 1.0;
-    var sum_color   = center_color;
-    
-    
-    let current_normal = decode_g_buffer_normal( textureLoad(tNormal, ipos, 0).xy );
-    let center_depth   = textureLoad(tDepth, ipos, 0).r;
-    
-    const offsets = array< vec2<i32>,8>(
-      vec2( -1, -1 ),
-      vec2(  0, -1 ) ,
-      vec2(  1, -1 ), 
-      vec2( -1,  0 ), 
-      vec2(  1,  0 ), 
-      vec2( -1,  1 ),
-      vec2(  0,  1 ), 
-      vec2(  1,  1 ), 
-   );
-    
-    const num_samples = 8;
-    
-    let std_dev =  safe_sqrt(variance);
-    
-    for(var i = 0; i < num_samples; i++){
-        let offset = offsets[i];
-                
-        let p      = ipos + offset * settings.step_size;
-        let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
-        
-        if(!inside){
-            // off-screen
-            continue;
-        }
-        
-        let kernel = kernel_weights[ abs(offset.x) ] * kernel_weights[ abs(offset.y) ];
-        
-        let sample_color = textureLoad(tInput, p, 0);
-        let sample_color_luma = rgb_to_luminance(sample_color.rgb);
-
-        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
-        let sample_depth  = textureLoad(tDepth, p, 0).r;
-
-        // compute the edge-stopping functions
-        var weight = 1.0;
-        
-        let phi_luma = max(0.001,std_dev * phi_visibility);
-
-        weight *= ffx_dnsr_reflections_get_edge_stopping_normal_weight(current_normal, sample_normal);
-        weight *= ffx_dnsr_reflections_get_edge_stopping_depth_weight(center_depth, sample_depth);
-        weight *= exp(-luma_edge_stopping_weight(center_color_luma,sample_color_luma,phi_luma));
-        
-        let w_visibility = weight * kernel;
-
-        // alpha channel contains the variance, therefore the weights need to be squared, see paper for the formula
-        sum_weight += w_visibility;
-        sum_color += vec4(vec3(w_visibility), w_visibility * w_visibility) * sample_color;
-    }
-    
-    let out_visibility = sum_color / vec4(vec3(sum_weight), sum_weight * sum_weight);
-    
-    return vec4(out_visibility);
-}
-    `,
-    [
-        ATORUS_UNIFORMS_STRUCT.declaration_chunk,
-        chunk_texture_channel_gaussian_3x3,
-        chunk_decode_g_buffer_normal,
-        chunk_rgb_to_luminance,
-        chunk_rgb_to_YCoCg,
-        chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight,
-        chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight,
-        chunk_luma_edge_stopping_weight,
-        chunk_safe_sqrt,
-    ]);
-
-export const ssr_spatial_denoise_shader = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "SSR / spatial denoise",
-        body,
-        resources
-    }),
-    targets: [
-        {
-            format: "rgba16float"
-        }
-    ]
-})
+import { chunk_ssr_spatial_variance } from "./chunk_ssr_spatial_variance.js";
+import { chunk_ssr_metadata } from "./chunk_ssr_metadata.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
+import {
+    chunk_texture_channel_gaussian_3x3
+} from "../../shader/chunk/texture/chunk_texture_channel_gaussian_3x3.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_luma_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
+import { ATORUS_UNIFORMS_STRUCT } from "../denoise/fragment_shader_denoise_ao.js";
+import {
+    chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight
+} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight.js";
+import {
+    chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight
+} from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight.js";
+
+function create_spatial_shader(with_metadata) {
+    const resources = new ShaderResourceSetDescriptor();
+
+    // per-pass, four bytes, read-only: immediate data rather than a uniform buffer
+    resources.setImmediate("settings", ATORUS_UNIFORMS_STRUCT);
+    const group = resources.createGroup()
+        .addTexture("tInput")
+        .addTexture("tDepth")
+        .addTexture("tNormal", "uint");
+    if (with_metadata) { group.addTexture("tMetadata", "unfilterable-float"); }
+
+    const body = CodeChunk.from(
+        //language=WGSL
+    `
+const phi_visibility = 10.0;
+const phi_normal = 32.0;
+const sigma_depth = 1.0;
+ 
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> ${with_metadata ? "SSRResolveOutput" : "@location(0) vec4f"}{
+    let ipos = vec2<i32>(coord.xy);
+    let screen_size = vec2<i32>(textureDimensions(tInput));
+    
+    const eps_variance      = 1e-10;
+    const kernel_weights = array<f32,3>( 1.0, 2.0 / 3.0, 1.0 / 6.0 );
+    
+    // constant samplers to prevent the compiler from generating code which
+    // fetches the sampler descriptor from memory for each texture access
+    let center_color = textureLoad(tInput, ipos, 0);
+    
+    let center_color_luma = rgb_to_luminance(center_color.rgb);
+
+    // variance for direct and indirect, filtered using 3x3 gaussin blur
+    let input_variance = max(0.0, texture_channel_gaussian_3x3(ipos, tInput, 3));
+${with_metadata ? `    let bootstrap_variance = ssr_spatial_variance(tInput,tDepth,tNormal,ipos);
+    let variance = max(input_variance,bootstrap_variance);
+    var sum_squared_weights = 1.0;` : `    let variance = input_variance;`}
+            
+    // explicitly store/accumulate center pixel with weight 1 to prevent issues
+    // with the edge-stopping functions
+    var sum_weight = 1.0;
+    var sum_color   = center_color;
+${with_metadata ? `    let center_metadata = textureLoad(tMetadata, ipos, 0).rg;
+    var distance_moments = ssr_distance_moments(center_metadata.x, center_metadata.y, 1.0);` : ""}
+    
+    
+    let current_normal = decode_g_buffer_normal( textureLoad(tNormal, ipos, 0).xy );
+    let center_depth   = textureLoad(tDepth, ipos, 0).r;
+    
+    const offsets = array< vec2<i32>,8>(
+      vec2( -1, -1 ),
+      vec2(  0, -1 ) ,
+      vec2(  1, -1 ), 
+      vec2( -1,  0 ), 
+      vec2(  1,  0 ), 
+      vec2( -1,  1 ),
+      vec2(  0,  1 ), 
+      vec2(  1,  1 ), 
+   );
+    
+    const num_samples = 8;
+    
+    let std_dev =  safe_sqrt(variance);
+    
+    for(var i = 0; i < num_samples; i++){
+        let offset: vec2i = offsets[i];
+                
+        let p      = ipos + offset * settings.step_size;
+        let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
+        
+        if(!inside){
+            // off-screen
+            continue;
+        }
+        
+        let kernel = kernel_weights[ abs(offset.x) ] * kernel_weights[ abs(offset.y) ];
+        
+        let sample_color = textureLoad(tInput, p, 0);
+        let sample_color_luma = rgb_to_luminance(sample_color.rgb);
+
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_depth  = textureLoad(tDepth, p, 0).r;
+
+        // compute the edge-stopping functions
+        var weight = 1.0;
+        
+        let phi_luma = max(0.001,std_dev * phi_visibility);
+
+        weight *= ffx_dnsr_reflections_get_edge_stopping_normal_weight(current_normal, sample_normal);
+        weight *= ffx_dnsr_reflections_get_edge_stopping_depth_weight(center_depth, sample_depth);
+        weight *= exp(-luma_edge_stopping_weight(center_color_luma,sample_color_luma,phi_luma));
+        
+        let w_visibility = weight * kernel;
+${with_metadata ? `        let metadata = textureLoad(tMetadata, p, 0).rg;
+        distance_moments += ssr_distance_moments(metadata.x, metadata.y, w_visibility);` : ""}
+
+        // alpha channel contains the variance, therefore the weights need to be squared, see paper for the formula
+        sum_weight += w_visibility;
+${with_metadata ? `        sum_squared_weights += w_visibility*w_visibility;` : ""}
+        sum_color += vec4(vec3(w_visibility), w_visibility * w_visibility) * sample_color;
+    }
+    
+    var out_visibility = sum_color / vec4(vec3(sum_weight), sum_weight * sum_weight);
+${with_metadata ? `    // Carry bootstrap uncertainty forward so the next passes do not freeze again.
+    out_visibility.w = max(out_visibility.w,bootstrap_variance*sum_squared_weights/(sum_weight*sum_weight));` : ""}
+    
+${with_metadata ? `    var output: SSRResolveOutput;
+    output.radiance = out_visibility;
+    output.metadata = ssr_resolve_metadata(distance_moments, 1.0);
+    return output;` : "    return out_visibility;"}
+}
+        `,
+        [
+            chunk_ssr_metadata,
+            ...(with_metadata ? [chunk_ssr_spatial_variance] : []),
+            ATORUS_UNIFORMS_STRUCT.declaration_chunk,
+            chunk_texture_channel_gaussian_3x3,
+            chunk_decode_g_buffer_normal,
+            chunk_rgb_to_luminance,
+            chunk_rgb_to_YCoCg,
+            chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight,
+            chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight,
+            chunk_luma_edge_stopping_weight,
+            chunk_safe_sqrt,
+        ]);
+
+    return new ImageShader({
+        descriptor: ShaderDescriptor.from({
+            label: with_metadata ? "SSR / spatial denoise with metadata" : "SSR / spatial denoise",
+            body,
+            resources
+        }),
+        targets: [
+            {
+                format: "rgba16float"
+            },
+            ...(with_metadata ? [{ format: "rg32float" }] : [])
+        ]
+    })
+}
+
+export const ssr_spatial_denoise_shader = create_spatial_shader(false);
+export const ssr_spatial_denoise_metadata_shader = create_spatial_shader(true);

package/src/shade/renderer/shader/graph/graph_create_buffer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A transient buffer with no producing pass of its own, for a binding a shader both reads and
+ * writes — the compute pass helpers create a buffer only for write-only bindings, and a read-write
+ * one wants a handle to thread.
+ *
+ * The buffer is created by an empty pass so the graph has a producer to hang it off; the pass
+ * executes nothing.
+ *
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} graph
+ * @param {string} label
+ * @param {import("../../../device/graph/BufferResourceDescriptor.js").BufferResourceDescriptor} descriptor
+ * @returns {number} the graph handle
+ */
+export function graph_create_buffer(graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph, label: string, descriptor: import("../../../device/graph/BufferResourceDescriptor.js").BufferResourceDescriptor): number;
+//# sourceMappingURL=graph_create_buffer.d.ts.map

package/src/shade/renderer/shader/graph/graph_create_buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_create_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_create_buffer.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,2CALW,OAAO,8DAA8D,EAAE,UAAU,SACjF,MAAM,cACN,OAAO,mDAAmD,EAAE,wBAAwB,GAClF,MAAM,CAMlB"}

package/src/shade/renderer/shader/graph/graph_create_buffer.js

@@ -0,0 +1,20 @@
+import { noop } from "../../../../core/function/noop.js";
+
+/**
+ * A transient buffer with no producing pass of its own, for a binding a shader both reads and
+ * writes — the compute pass helpers create a buffer only for write-only bindings, and a read-write
+ * one wants a handle to thread.
+ *
+ * The buffer is created by an empty pass so the graph has a producer to hang it off; the pass
+ * executes nothing.
+ *
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} graph
+ * @param {string} label
+ * @param {import("../../../device/graph/BufferResourceDescriptor.js").BufferResourceDescriptor} descriptor
+ * @returns {number} the graph handle
+ */
+export function graph_create_buffer(graph, label, descriptor) {
+    const pass = graph.add(`${label} / create`, {}, noop);
+
+    return pass.create(label, descriptor);
+}

package/src/shade/renderer/view/GPUViewContext.d.ts

@@ -45,10 +45,9 @@ export class GPUViewContext {
      * @param {number} y
      */
     setJitterDelta(x: number, y: number): void;
-    /**
-     *
-     * @returns {Uint32Array}
-     */
+    /** Current raster jitter in internal pixels. @returns {Float32Array} */
+    get jitter(): Float32Array;
+    /** @returns {Uint32Array} */
     get resolution(): Uint32Array;
     /**
      *

package/src/shade/renderer/view/GPUViewContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/view/GPUViewContext.js"],"names":[],"mappings":";;;;;;;;AAyBA;;GAEG;AACH;IAiOI;;;;;OAKG;IACH,uEAFW,gBAAgB,EAuB1B;IA1PD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,OAFU,MAAM,CAEL;IAuBX;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAQhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,KACN,MAAM,QAOhB;IAED;;;OAGG;IACH,8BAEC;IAQD;;;OAGG;IACH,0BAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAUhB;IAgBD;;;OAGG;IACH,oDAEC;IAdD;;;OAGG;IACH,iDAEC;IAgBD;;;OAGG;IACH,qCAEC;IAQD;;;OAGG;IACH,sCAEC;IA4BD;;;OAGG;IACH,qDAEC;IAdD;;;OAGG;IACH,kDAEC;IAgBD;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,6BAEC;IA+BD;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAWnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED,wBA6BC;IAGD;;;OAGG;IACH,mCASC;IAED;;OAEG;IACH,wDAOC;IAED,gBAgBC;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;;CANxC;oCArXmC,+BAA+B;+BAFpC,6BAA6B;mCAGzB,sCAAsC;iCAFxC,+BAA+B"}
+{"version":3,"file":"GPUViewContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/view/GPUViewContext.js"],"names":[],"mappings":";;;;;;;;AAyBA;;GAEG;AACH;IAiOI;;;;;OAKG;IACH,uEAFW,gBAAgB,EAuB1B;IA1PD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,OAFU,MAAM,CAEL;IAuBX;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAQhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,KACN,MAAM,QAOhB;IAED,wEAAwE;IACxE,2BAAqC;IAErC,6BAA6B;IAC7B,8BAEC;IAQD;;;OAGG;IACH,0BAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,KACN,MAAM,QAUhB;IAgBD;;;OAGG;IACH,oDAEC;IAdD;;;OAGG;IACH,iDAEC;IAgBD;;;OAGG;IACH,qCAEC;IAQD;;;OAGG;IACH,sCAEC;IA4BD;;;OAGG;IACH,qDAEC;IAdD;;;OAGG;IACH,kDAEC;IAgBD;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,6BAEC;IA+BD;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAWnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED,wBA6BC;IAGD;;;OAGG;IACH,mCASC;IAED;;OAEG;IACH,wDAOC;IAED,gBAgBC;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;;CANxC;oCArXmC,+BAA+B;+BAFpC,6BAA6B;mCAGzB,sCAAsC;iCAFxC,+BAA+B"}

package/src/shade/renderer/view/GPUViewContext.js

@@ -108,10 +108,10 @@ export class GPUViewContext {
         this.#jitter[1] = y;
     }
 
-    /**
-     *
-     * @returns {Uint32Array}
-     */
+    /** Current raster jitter in internal pixels. @returns {Float32Array} */
+    get jitter() { return this.#jitter; }
+
+    /** @returns {Uint32Array} */
     get resolution() {
         return this.#resolution;
     }
@@ -386,4 +386,4 @@ export class GPUViewContext {
  * @readonly
  * @type {boolean}
  */
-GPUViewContext.prototype.isGPUViewContext = true;
+GPUViewContext.prototype.isGPUViewContext = true;

package/src/core/binary/meshopt/__meshopt_test_streams.d.ts

@@ -1,24 +0,0 @@
-/**
- * Build an attribute ("mode 0") stream.
- *
- * @param {Uint8Array} data `count * byte_stride` bytes
- * @param {number} count
- * @param {number} byte_stride
- * @param {Object} [options]
- * @param {number} [options.version] 0 or 1
- * @param {number[]} [options.channel_modes] one mode byte per aligned four byte positions;
- *   version 1 only, defaults to all zero (byte deltas)
- * @returns {Uint8Array}
- */
-export function encode_meshopt_attributes(data: Uint8Array, count: number, byte_stride: number, options?: {
-    version?: number;
-    channel_modes?: number[];
-}): Uint8Array;
-/**
- * Build an index-sequence ("mode 2") stream. Every delta is taken against baseline 0.
- *
- * @param {number[]} indices
- * @returns {Uint8Array}
- */
-export function encode_meshopt_index_sequence(indices: number[]): Uint8Array;
-//# sourceMappingURL=__meshopt_test_streams.d.ts.map

package/src/core/binary/meshopt/__meshopt_test_streams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"__meshopt_test_streams.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/meshopt/__meshopt_test_streams.js"],"names":[],"mappings":"AAuFA;;;;;;;;;;;GAWG;AACH,gDATW,UAAU,SACV,MAAM,eACN,MAAM;IAEW,OAAO,GAAxB,MAAM;IACa,aAAa,GAAhC,MAAM,EAAE;IAEN,UAAU,CAyGtB;AAED;;;;;GAKG;AACH,uDAHW,MAAM,EAAE,GACN,UAAU,CA4BtB"}