@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js

@@ -22,6 +22,10 @@ export const ACCUMULATING_RT_UNIFORMS_STRUCT = WebGPUStruct.from({
     alpha: f32,
 });
 
+// per-dispatch, 24 bytes, read-only: immediate data rather than a uniform buffer. camera and the
+// material table beside it are scene state and stay bound.
+resources.setImmediate("settings", ACCUMULATING_RT_UNIFORMS_STRUCT);
+
 sr_create_group_RTX(resources);
 
 resources.createGroup()
@@ -33,7 +37,6 @@ resources.createGroup()
     .addTexture("tEnvironment", "unfilterable-float", "2d");
 
 resources.createGroup()
-    .addUniform("settings", ACCUMULATING_RT_UNIFORMS_STRUCT)
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addTexture("history_texture", "unfilterable-float", "2d")
     .addStorageTexture("output_texture", "rgba32float", "2d", "write-only");

package/src/shade/renderer/postprocess/bloom/shader_bloom_mix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bloom_mix.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/bloom/shader_bloom_mix.js"],"names":[],"mappings":"AAsCA,2CAYG;4BA/CyB,6BAA6B"}
+{"version":3,"file":"shader_bloom_mix.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/bloom/shader_bloom_mix.js"],"names":[],"mappings":"AAwCA,2CAYG;4BAjDyB,6BAA6B"}

package/src/shade/renderer/postprocess/bloom/shader_bloom_mix.js

@@ -12,11 +12,13 @@ const BLOOM_SETTINGS_STRUCT = WebGPUStruct.from({
 })
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", BLOOM_SETTINGS_STRUCT);
 resources.createGroup()
     .addTexture("tBloom", "float")
     .addTexture("tSource")
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
-    .addUniform("settings", BLOOM_SETTINGS_STRUCT)
 ;
 
 const body = CodeChunk.from(

package/src/shade/renderer/postprocess/cas/shader_ffx_rcas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_ffx_rcas.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/cas/shader_ffx_rcas.js"],"names":[],"mappings":"AA6GA,0CAKG;4BAhHyB,6BAA6B"}
+{"version":3,"file":"shader_ffx_rcas.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/cas/shader_ffx_rcas.js"],"names":[],"mappings":"AA+GA,0CAKG;4BAlHyB,6BAA6B"}

package/src/shade/renderer/postprocess/cas/shader_ffx_rcas.js

@@ -8,9 +8,11 @@ import { F32_CONTAINER_STRUCT } from "../../shader/type/F32_CONTAINER_STRUCT.js"
 
 const resources = new ShaderResourceSetDescriptor();
 
+// per-pass, four bytes, read-only: immediate data rather than a uniform buffer holding one f32
+resources.setImmediate("uSharpness", F32_CONTAINER_STRUCT);
+
 resources.createGroup()
-    .addTexture("tInput")
-    .addUniform("uSharpness", F32_CONTAINER_STRUCT);
+    .addTexture("tInput");
 
 
 const body = CodeChunk.from(

package/src/shade/renderer/postprocess/denoise/fragment_shader_denoise_ao.js

@@ -1,148 +1,148 @@
-import { i32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import {
-    chunk_texture_channel_compute_variance_center
-} from "../../shader/chunk/texture/chunk_texture_channel_compute_variance_center.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_compute_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
-
-export const ATORUS_UNIFORMS_STRUCT = WebGPUStruct.from({
-    step_size: i32
-});
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addTexture("tInput")
-    .addTexture("tDepth")
-    .addTexture("tNormal", "uint");
-
-resources.createGroup()
-    .addUniform("settings", ATORUS_UNIFORMS_STRUCT);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const phi_visibility = 4.0;
-const phi_normal = 128.0;
-const sigma_depth = 1.0;
- 
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec2<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_visibility = textureLoad(tInput, ipos, 0).rg;
-
-    // variance estimate from per-pixel moments, filtered using 3x3 gaussian blur
-    let variance = texture_channel_compute_variance_center( ipos, tInput);
-
-    let std_dev = sqrt(max(0.0, eps_variance + variance));
-
-    let phi_visibility = phi_visibility * std_dev;
-    
-    // explicitly store/accumulate center pixel with weight 1 to prevent issues
-    // with the edge-stopping functions
-    var sum_w_visibility = 1.0;
-    var sum_visibility   = center_visibility;
-    
-    
-    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;
-    
-    for(var i=0; i< num_samples; i++){
-        let offset = offsets[i];
-        
-        let xx = offset.x;
-        let yy = offset.y;
-        
-        let p      = ipos + offset * settings.step_size;
-        let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
-        
-        if(!inside){
-            continue;
-        }
-        
-        let kernel = kernel_weights[ abs(xx) ] * kernel_weights[ abs(yy) ];
-        
-        let sample_visibility = textureLoad(tInput, p, 0).rg;
-
-        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
-        let w = compute_edge_stopping_weight(
-            center_depth,
-            sample_depth,
-            sigma_depth,
-            
-            current_normal,
-            sample_normal,
-            phi_normal,
-            
-            center_visibility.r,
-            sample_visibility.r,
-            phi_visibility
-        );
-
-        let w_visibility = w * kernel;
-
-        // both channels carry moments (E[X], E[X²]) - average linearly so the
-        // pair remains a valid moment estimate that downstream get_std_dev can interpret.
-        sum_w_visibility += w_visibility;
-        sum_visibility += w_visibility * sample_visibility;
-    }
-
-    // output first two moments
-    let out_visibility = sum_visibility / sum_w_visibility;
-
-    return out_visibility;
-}
-    `,
-    [
-        ATORUS_UNIFORMS_STRUCT.declaration_chunk,
-        chunk_texture_channel_compute_variance_center,
-        chunk_decode_g_buffer_normal,
-        chunk_compute_edge_stopping_weight,
-    ]);
-
-/**
- * Based on REBLUR paper, a type of Gaussian blur with edge-stopping
- * @type {ShaderDescriptor}
- */
-export const fragment_shader_denoise_ao = ShaderDescriptor.from({
-    label: "A-torus Denoise",
-    resources,
-    body
-});
-
-export const shader_denoise_luminance_spatial = ImageShader.from({
-    descriptor: fragment_shader_denoise_ao,
-    targets: [
-        { format: "rg16float" }
-    ]
+import { i32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_texture_channel_compute_variance_center
+} from "../../shader/chunk/texture/chunk_texture_channel_compute_variance_center.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_compute_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
+
+export const ATORUS_UNIFORMS_STRUCT = WebGPUStruct.from({
+    step_size: i32
+});
+
+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 = 4.0;
+const phi_normal = 128.0;
+const sigma_depth = 1.0;
+ 
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec2<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_visibility = textureLoad(tInput, ipos, 0).rg;
+
+    // variance estimate from per-pixel moments, filtered using 3x3 gaussian blur
+    let variance = texture_channel_compute_variance_center( ipos, tInput);
+
+    let std_dev = sqrt(max(0.0, eps_variance + variance));
+
+    let phi_visibility = phi_visibility * std_dev;
+    
+    // explicitly store/accumulate center pixel with weight 1 to prevent issues
+    // with the edge-stopping functions
+    var sum_w_visibility = 1.0;
+    var sum_visibility   = center_visibility;
+    
+    
+    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;
+    
+    for(var i=0; i< num_samples; i++){
+        let offset = offsets[i];
+        
+        let xx = offset.x;
+        let yy = offset.y;
+        
+        let p      = ipos + offset * settings.step_size;
+        let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
+        
+        if(!inside){
+            continue;
+        }
+        
+        let kernel = kernel_weights[ abs(xx) ] * kernel_weights[ abs(yy) ];
+        
+        let sample_visibility = textureLoad(tInput, p, 0).rg;
+
+        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
+        let w = compute_edge_stopping_weight(
+            center_depth,
+            sample_depth,
+            sigma_depth,
+            
+            current_normal,
+            sample_normal,
+            phi_normal,
+            
+            center_visibility.r,
+            sample_visibility.r,
+            phi_visibility
+        );
+
+        let w_visibility = w * kernel;
+
+        // both channels carry moments (E[X], E[X²]) - average linearly so the
+        // pair remains a valid moment estimate that downstream get_std_dev can interpret.
+        sum_w_visibility += w_visibility;
+        sum_visibility += w_visibility * sample_visibility;
+    }
+
+    // output first two moments
+    let out_visibility = sum_visibility / sum_w_visibility;
+
+    return out_visibility;
+}
+    `,
+    [
+        ATORUS_UNIFORMS_STRUCT.declaration_chunk,
+        chunk_texture_channel_compute_variance_center,
+        chunk_decode_g_buffer_normal,
+        chunk_compute_edge_stopping_weight,
+    ]);
+
+/**
+ * Based on REBLUR paper, a type of Gaussian blur with edge-stopping
+ * @type {ShaderDescriptor}
+ */
+export const fragment_shader_denoise_ao = ShaderDescriptor.from({
+    label: "A-torus Denoise",
+    resources,
+    body
+});
+
+export const shader_denoise_luminance_spatial = ImageShader.from({
+    descriptor: fragment_shader_denoise_ao,
+    targets: [
+        { format: "rg16float" }
+    ]
 })

package/src/shade/renderer/postprocess/denoise/graph_atorus_denoise_luma.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_atorus_denoise_luma.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/graph_atorus_denoise_luma.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;GAUG;AACH,kJAFa,MAAM,CA6FlB"}
+{"version":3,"file":"graph_atorus_denoise_luma.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/graph_atorus_denoise_luma.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;GAUG;AACH,kJAFa,MAAM,CA+FlB"}

package/src/shade/renderer/postprocess/denoise/graph_atorus_denoise_luma.js

@@ -1,120 +1,122 @@
-import { assert } from "../../../../core/assert.js";
-import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
-import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
-import { create_full_quad_pipeline_descriptor } from "../../shader/fullscreen/create_full_quad_pipeline_descriptor.js";
-import { ATORUS_UNIFORMS_STRUCT, fragment_shader_denoise_ao } from "./fragment_shader_denoise_ao.js";
-
-const render_pipeline_descriptor_denoise = create_full_quad_pipeline_descriptor({
-    label: "A-torus Denoise",
-    fragment_code: fragment_shader_denoise_ao.source,
-    layout: fragment_shader_denoise_ao.resources.generatePipelineLayout(GPUShaderStage.FRAGMENT),
-    targets: [
-        {
-            format: "rg16float"
-        }
-    ]
-});
-
-/**
- *
- * @param {FrameGraph} graph
- * @param {number} input_luma
- * @param {number} input_depth
- * @param {number} input_normal
- * @param {number} [iterations]
- * @param {number} input_mip_level what mip level to read input resources at, needed for denoising half-resolution render targets
- * @param {number[]} resolution
- * @returns {number}
- */
-export function graph_atorus_denoise_luma({
-                                              graph,
-                                              input_luma = -1,
-                                              input_depth = -1,
-                                              input_normal = -1,
-                                              iterations = 3,
-                                              input_mip_level = 0,
-                                              resolution
-                                          }) {
-
-    assert.isNonNegativeInteger(input_mip_level, 'input_mip_level');
-
-    let input = input_luma;
-
-    for (let i = 0; i < iterations; i++) {
-
-        const denoise_data = {};
-
-        const denoise_iteration = i;
-
-        /**
-         *
-         * @param data
-         * @param {FramePassResources} resources
-         * @param {GraphicsExecutionContext} context
-         */
-        function pass_denoise(data, resources, context) {
-
-            const texture_depth = resources.get(data.input_depth);
-            const texture_normal = resources.get(data.input_normal);
-            const texture_luminance = resources.get(data.input_luminance);
-
-            const output = resources.get(data.output);
-
-            const encoder = context.encoder;
-
-            const buffer_settings = encoder.allocateTransientValueBuffer(
-                ATORUS_UNIFORMS_STRUCT,
-                {
-                    // with 3 iterations this gives us step sizes of: 1, 2, 4
-                    // this is based on AMD's shadow denoiser presentation
-                    step_size: 1 << denoise_iteration,
-                },
-                GPUBufferUsage.UNIFORM
-            );
-
-            const input_view_descriptor = TextureViewDescriptor.from({
-                baseMipLevel: input_mip_level,
-                mipLevelCount: 1
-            });
-
-            const pass = encoder.constructRenderPass({
-                pipeline: render_pipeline_descriptor_denoise,
-                bindings: fragment_shader_denoise_ao.resources.generateBindings({
-                    tInput: texture_luminance.obtainView(),
-                    tDepth: texture_depth.obtainView(input_view_descriptor),
-                    tNormal: texture_normal.obtainView(input_view_descriptor),
-                    settings: buffer_settings
-                }),
-                colorAttachments: [
-                    {
-                        loadOp: "clear",
-                        storeOp: "store",
-                        clearValue: [0, 0, 0, 0],
-                        view: output.obtainView()
-                    }
-                ]
-            });
-
-            pass.draw(3);
-
-            pass.end();
-        }
-
-        const denoise_builder = graph.add(`Spatial Denoise ${(i + 1)}/${iterations}`, denoise_data, pass_denoise);
-
-        denoise_data.input_depth = denoise_builder.read(input_depth);
-        denoise_data.input_normal = denoise_builder.read(input_normal);
-        denoise_data.input_luminance = denoise_builder.read(input);
-
-        input = denoise_builder.create("denoised", TextureResourceDescriptor.from({
-            resolution: resolution,
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
-            format: "rg16float",
-        }));
-
-        denoise_data.output = input;
-
-    }
-
-    return input;
+import { assert } from "../../../../core/assert.js";
+import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
+import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
+import { create_full_quad_pipeline_descriptor } from "../../shader/fullscreen/create_full_quad_pipeline_descriptor.js";
+import { fragment_shader_denoise_ao } from "./fragment_shader_denoise_ao.js";
+
+const render_pipeline_descriptor_denoise = create_full_quad_pipeline_descriptor({
+    label: "A-torus Denoise",
+    fragment_code: fragment_shader_denoise_ao.source,
+    layout: fragment_shader_denoise_ao.resources.generatePipelineLayout(GPUShaderStage.FRAGMENT),
+    targets: [
+        {
+            format: "rg16float"
+        }
+    ]
+});
+
+/**
+ *
+ * @param {FrameGraph} graph
+ * @param {number} input_luma
+ * @param {number} input_depth
+ * @param {number} input_normal
+ * @param {number} [iterations]
+ * @param {number} input_mip_level what mip level to read input resources at, needed for denoising half-resolution render targets
+ * @param {number[]} resolution
+ * @returns {number}
+ */
+export function graph_atorus_denoise_luma({
+                                              graph,
+                                              input_luma = -1,
+                                              input_depth = -1,
+                                              input_normal = -1,
+                                              iterations = 3,
+                                              input_mip_level = 0,
+                                              resolution
+                                          }) {
+
+    assert.isNonNegativeInteger(input_mip_level, 'input_mip_level');
+
+    let input = input_luma;
+
+    for (let i = 0; i < iterations; i++) {
+
+        const denoise_data = {};
+
+        const denoise_iteration = i;
+
+        /**
+         *
+         * @param data
+         * @param {FramePassResources} resources
+         * @param {GraphicsExecutionContext} context
+         */
+        function pass_denoise(data, resources, context) {
+
+            const texture_depth = resources.get(data.input_depth);
+            const texture_normal = resources.get(data.input_normal);
+            const texture_luminance = resources.get(data.input_luminance);
+
+            const output = resources.get(data.output);
+
+            const encoder = context.encoder;
+
+            const input_view_descriptor = TextureViewDescriptor.from({
+                baseMipLevel: input_mip_level,
+                mipLevelCount: 1
+            });
+
+            const bindings = {
+                tInput: texture_luminance.obtainView(),
+                tDepth: texture_depth.obtainView(input_view_descriptor),
+                tNormal: texture_normal.obtainView(input_view_descriptor),
+                settings: {
+                    // with 3 iterations this gives us step sizes of: 1, 2, 4
+                    // this is based on AMD's shadow denoiser presentation
+                    step_size: 1 << denoise_iteration,
+                },
+            };
+
+            const resource_set = fragment_shader_denoise_ao.resources;
+
+            const pass = encoder.constructRenderPass({
+                pipeline: render_pipeline_descriptor_denoise,
+                bindings: resource_set.generateBindings(bindings),
+                // this pass is built by hand rather than through ImageShader.draw, so the immediate
+                // `settings` has to be written here — the pipeline layout above already declares
+                // its size, and a pass whose slots were never written is refused
+                immediate: encoder.writeImmediate(resource_set, bindings),
+                colorAttachments: [
+                    {
+                        loadOp: "clear",
+                        storeOp: "store",
+                        clearValue: [0, 0, 0, 0],
+                        view: output.obtainView()
+                    }
+                ]
+            });
+
+            pass.draw(3);
+
+            pass.end();
+        }
+
+        const denoise_builder = graph.add(`Spatial Denoise ${(i + 1)}/${iterations}`, denoise_data, pass_denoise);
+
+        denoise_data.input_depth = denoise_builder.read(input_depth);
+        denoise_data.input_normal = denoise_builder.read(input_normal);
+        denoise_data.input_luminance = denoise_builder.read(input);
+
+        input = denoise_builder.create("denoised", TextureResourceDescriptor.from({
+            resolution: resolution,
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
+            format: "rg16float",
+        }));
+
+        denoise_data.output = input;
+
+    }
+
+    return input;
 }

package/src/shade/renderer/postprocess/dof/gather/graph_postprocess_dof2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_postprocess_dof2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/gather/graph_postprocess_dof2.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAb4B,KAAK;IACT,WAAW,EAAxB,MAAM;IACO,KAAK,EAAlB,MAAM;IACiB,MAAM,EAA7B,YAAU,MAAM;IACH,SAAS,EAAtB,MAAM;IACS,UAAU,EAAzB,MAAM,EAAE;IACK,QAAQ,EAArB,MAAM;IACS,IAAI,GAAnB,OAAO;IACS,oBAAoB;IACpB,mBAAmB;IACtB,gBAAgB,EAA7B,MAAM;IACJ,MAAM,CAsJlB"}
+{"version":3,"file":"graph_postprocess_dof2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/gather/graph_postprocess_dof2.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAb4B,KAAK;IACT,WAAW,EAAxB,MAAM;IACO,KAAK,EAAlB,MAAM;IACiB,MAAM,EAA7B,YAAU,MAAM;IACH,SAAS,EAAtB,MAAM;IACS,UAAU,EAAzB,MAAM,EAAE;IACK,QAAQ,EAArB,MAAM;IACS,IAAI,GAAnB,OAAO;IACS,oBAAoB;IACpB,mBAAmB;IACtB,gBAAgB,EAA7B,MAAM;IACJ,MAAM,CAsJlB"}

package/src/shade/renderer/postprocess/dof/gather/graph_postprocess_dof2.js

@@ -1,7 +1,6 @@
 import { assert } from "../../../../../core/assert.js";
 import { graph_image_pass } from "../../../shader/graph/graph_image_pass.js";
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
-import { DOF_AUTOFOCUS_PARAMS_STRUCT } from "../DOF_AUTOFOCUS_PARAMS_STRUCT.js";
 import { shader_dof_autofocus } from "../shader_dof_autofocus.js";
 import { DOF2_TILE_SIZE } from "./DOF2_CONFIG.js";
 import { shader_dof2_gather_far } from "./shader_dof2_gather_far.js";
@@ -76,7 +75,7 @@ export function graph_postprocess_dof2({
     const af_data = {};
     const af_execute = (data, resources, context) => {
         const encoder = context.encoder;
-        const params_buffer = encoder.allocateTransientValueBuffer(DOF_AUTOFOCUS_PARAMS_STRUCT, autofocus_params);
+        const params_buffer = autofocus_params;
 
         shader_dof_autofocus.dispatch({
             encoder,

package/src/shade/renderer/postprocess/dof/gather/shader_dof2_gather_far.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dof2_gather_far.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/gather/shader_dof2_gather_far.js"],"names":[],"mappings":"AAsHA;;;;;;;;;;;GAWG;AACH,qCAFU,WAAW,CAWlB;4BAvIyB,gCAAgC"}
+{"version":3,"file":"shader_dof2_gather_far.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/gather/shader_dof2_gather_far.js"],"names":[],"mappings":"AAyHA;;;;;;;;;;;GAWG;AACH,qCAFU,WAAW,CAWlB;4BA1IyB,gCAAgC"}

package/src/shade/renderer/postprocess/dof/gather/shader_dof2_gather_far.js

@@ -14,6 +14,10 @@ import { DOF2_SETTINGS_STRUCT } from "./DOF2_SETTINGS_STRUCT.js";
 import { DOF2_FIELD_FORMAT } from "./DOF2_TEXTURE_FORMAT.js";
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, under 64 bytes, read-only: immediate data rather than a uniform buffer. focus_state
+// beside it stays bound — the autofocus pass writes it on the GPU, so there is no CPU value.
+resources.setImmediate("dof", DOF2_SETTINGS_STRUCT);
 resources.createGroup()
     // Half-res far field (colour.rgb, far CoC magnitude in .a) from setup.
     .addTexture("tFar", "float")
@@ -23,7 +27,6 @@ resources.createGroup()
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
     // Spatio-temporal blue noise (NVIDIA STBN) for the aperture phase.
     .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
-    .addUniform("dof", DOF2_SETTINGS_STRUCT)
 ;
 
 const body = CodeChunk.from(