@woosh/meep-engine 3.53.0 → 3.55.0

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js

@@ -1,27 +1,30 @@
-import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { chunk_sample_volumetrics } from "../../deferred/chunk_sample_volumetrics.js";
 import { AVBOIT_EXTINCT_TRANSMITTANCE } from "../../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
-import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
 import { AVBOIT_DRAW_TARGETS } from "../../rasterize/native/avboit/avboit_draw_fragment_body.js";
-import { chunk_avboit_view_depth_to_virtual } from "../../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
+import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
 import { chunk_avboit_footprint_bias } from "../../rasterize/native/avboit/chunk_avboit_footprint_bias.js";
 import { chunk_avboit_sample_transmittance } from "../../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_avboit_view_depth_to_virtual } from "../../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
 import { chunk_view_mip_bias } from "../../view/chunk_view_mip_bias.js";
+import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
+import {
+    irradiance_clipmap_add_resources
+} from "../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "../../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
 import { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
 import { PARTICLE_SOFT_FADE_RANGE } from "../ParticleConstants.js";
 import { chunk_particle_avboit_contribution } from "./chunk_particle_avboit_contribution.js";
-import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
 import { chunk_particle_billboard_vertex } from "./chunk_particle_billboard_vertex.js";
 import { chunk_particle_lighting } from "./chunk_particle_lighting.js";
+import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
 
 /**
  * The particles' AVBOIT draw: the billboard quads at internal resolution, depth-tested against the
@@ -30,28 +33,13 @@ import { chunk_particle_lighting } from "./chunk_particle_lighting.js";
  *
  * Per fragment: the atlas sample times the particle colour, the soft-depth fade against the scene
  * depth, lighting for an emitter flagged `EMITTER_FLAG.LIGHTING` (`chunk_particle_lighting`: the
- * froxel irradiance volume: the lights and the indirect lighting), the volumetric fog composite exactly as the
- * mesh draw applies it, then the transmittance of everything in front from the integral texture —
- * and a fragment the volume already calls extinct is discarded unshaded. An emitter without the
- * flag is its own colour, which is what an additive one wants.
- *
- * What is written depends on how the particle blends:
- *
- * - **alpha / premultiplied** — a surface: `color += premultiplied × T`, `norm += coverage × T`,
- *   `extinction += -log(1 - coverage)`, the same three the meshes write, with an untinted
- *   `T_self = 1 - coverage`; the splat recorded exactly that.
- * - **additive** — light: `emission += premultiplied × T`, nothing else. It joins the resolve
- *   attenuated by what is in front of it and outside the coverage normalization, which is what an
- *   additive fragment means.
- *
- * The scene depth is bound twice: as the read-only depth attachment the pipeline tests against, and
- * as the texture the soft fade reads. Both are reads, which WebGPU allows within one pass; the pass
- * is recorded with the attachment read-only for that reason.
+ * world-space irradiance clipmap and cached far-field SH), the volumetric fog composite, then the
+ * transmittance of everything in front from the integral texture.
  */
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
+const group = resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
@@ -67,10 +55,10 @@ resources.createGroup()
     // volumetrics (composited inline)
     .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
     .addTexture("tVolumetrics", "float", "3d")
-    .addTexture("tSTBN_vec3", "float", "3d")
-    // lighting (chunk_particle_lighting): the froxel irradiance volume, trilinear through sLinear
-    .addTexture("tIrradianceY", "float", "3d")
-    .addTexture("tIrradianceCoCg", "float", "3d");
+    .addTexture("tSTBN_vec3", "float", "3d");
+
+// lighting (chunk_particle_lighting): world-space irradiance clipmap + cached far-field SH fallback
+irradiance_clipmap_add_resources(group, { include_far_field: true });
 
 const body = CodeChunk.from(
     /* language=wgsl */ `
@@ -111,16 +99,11 @@ fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32
 
 @fragment
 fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
-    let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
-    let uv_bias = view_uv_derivative_bias(view.upscale_ratio);
-    let uv_ddx = dpdx(in.uv) * uv_bias.x;
+    let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
+    let uv_bias = view_uv_derivative_bias(view.upscale_ratio);
+    let uv_ddx = dpdx(in.uv) * uv_bias.x;
     let uv_ddy = dpdy(in.uv) * uv_bias.y;
 
-    // a billboard, stretched or not, is built from the camera's right and up and lies in the view plane,
-    // so its footprint is zero; a horizontal, vertical or world-facing quad seen at an angle runs
-    // through depth across a voxel (avboit_footprint_bias). An additive particle writes nothing into
-    // the volume, so nothing of its own is there to occlude it, and takes none. The derivative is
-    // taken here, in uniform control flow, whatever the blend
     let footprint = select(
         avboit_footprint_bias(&warp, fwidth(avboit_view_depth_to_virtual(&warp, in.view_depth))),
         0.0,
@@ -170,7 +153,7 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
     chunk_sample_volumetrics,
     chunk_avboit_view_depth_to_virtual,
     chunk_avboit_footprint_bias,
-    chunk_avboit_sample_transmittance,
+    chunk_avboit_sample_transmittance,
     chunk_view_mip_bias,
 ]);
 

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

@@ -1 +1 @@
-{"version":3,"file":"fragment_shader_denoise_ao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/fragment_shader_denoise_ao.js"],"names":[],"mappings":"AAYA,kDAEG;AAsHH;;;GAGG;AACH,yCAFU,gBAAgB,CAMvB;AAEH,2DAKE;6BAlJ2B,mCAAmC;iCAQ/B,kCAAkC;4BAFvC,6BAA6B"}
+{"version":3,"file":"fragment_shader_denoise_ao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/fragment_shader_denoise_ao.js"],"names":[],"mappings":"AAaA,kDAEG;AAsHH;;;GAGG;AACH,yCAFU,gBAAgB,CAMvB;AAEH,2DAWE;6BAxJ2B,mCAAmC;iCAQ/B,kCAAkC;4BAFvC,6BAA6B"}

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

@@ -1,148 +1,155 @@
-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" }
-    ]
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+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,
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    targets: [
+        {
+            format: "rg16float",
+            // Background is skipped, so it keeps the clear: moments of visibility 1 (not occluded), zero variance.
+            // Downstream neighbourhoods read across silhouettes and must see background as unoccluded.
+            clearValue: [1, 1],
+        }
+    ]
 })

package/src/shade/renderer/postprocess/gtao/GTAO.d.ts

@@ -24,6 +24,7 @@ export class GTAO {
      * @param {FrameGraph} graph
      * @param {number} camera
      * @param {number} input_depth
+     * @param {number} input_hzb
      * @param {number} input_color
      * @param {number} input_depth_previous
      * @param {number} input_normal
@@ -34,7 +35,7 @@ export class GTAO {
      * @param {number[]} resolution
      * @returns {{occlusion:number, bent_normals:number, diffuse_indirect:number}}
      */
-    graph_pass({ graph, camera, input_depth, input_depth_previous, input_normal, input_velocity, input_occlusion, frame_index, output, resolution }: FrameGraph): {
+    graph_pass({ graph, camera, input_depth, input_hzb, input_depth_previous, input_normal, input_velocity, input_occlusion, frame_index, output, resolution }: FrameGraph): {
         occlusion: number;
         bent_normals: number;
         diffuse_indirect: number;

package/src/shade/renderer/postprocess/gtao/GTAO.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAQI;;;OAGG;IACH,uCAUC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;OAcG;IACH,8JAFa;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,gBAAgB,EAAC,MAAM,CAAA;KAAC,CA6F5E;;CACJ;8BA5JY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAQI;;;OAGG;IACH,uCAUC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yKAFa;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,gBAAgB,EAAC,MAAM,CAAA;KAAC,CAiG5E;;CACJ;8BAjKY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/gtao/GTAO.js

@@ -61,6 +61,7 @@ export class GTAO {
      * @param {FrameGraph} graph
      * @param {number} camera
      * @param {number} input_depth
+     * @param {number} input_hzb
      * @param {number} input_color
      * @param {number} input_depth_previous
      * @param {number} input_normal
@@ -75,6 +76,7 @@ export class GTAO {
                    graph,
                    camera,
                    input_depth,
+                   input_hzb,
                    input_depth_previous,
                    input_normal,
                    input_velocity,
@@ -102,6 +104,7 @@ export class GTAO {
             input_depth,
             inputs: {
                 tDepth: input_depth,
+                tHZB: input_hzb,
                 tNormal: input_normal,
                 camera,
                 settings: {
@@ -119,6 +122,7 @@ export class GTAO {
             graph,
             shader: shader_denoise_luminance_spatial,
             output_resolution: resolution,
+            input_depth,
             inputs: {
                 tInput: moments,
                 tDepth: input_depth,
@@ -134,6 +138,7 @@ export class GTAO {
             graph,
             shader: ao_reproject_shader,
             output: [moments_output],
+            input_depth,
             inputs: {
                 tInput: moments,
                 tHistory: moments_history,
@@ -164,4 +169,3 @@ export class GTAO {
         };
     }
 }
-

package/src/shade/renderer/postprocess/gtao/GTAO_CONSTANTS.d.ts

@@ -15,6 +15,14 @@ export const GTAO_QUALITY_PROFILES: any;
  * @type {number}
  */
 export const GTAO_DEPTH_MIP_LEVELS: number;
+/**
+ * Log2 offset applied to the screen-space step distance (in pixels) when selecting a depth pyramid mip level.
+ * Higher values stay on finer mips further out; lower values drop to coarser mips sooner.
+ *
+ * @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.h#L71
+ * @type {number}
+ */
+export const GTAO_DEPTH_MIP_SAMPLING_OFFSET: number;
 /**
  * distant samples contribute less
  * must be in [0, 1] range

package/src/shade/renderer/postprocess/gtao/GTAO_CONSTANTS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GTAO_CONSTANTS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO_CONSTANTS.js"],"names":[],"mappings":"gCAmBU,MAAM;;;;;;;AAShB;;;GAGG;AACH,wCAiBE;AAEF;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,8CAA+C;AAE/C;;;;GAIG;AACH,iCAFU,MAAM,CAEoB"}
+{"version":3,"file":"GTAO_CONSTANTS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO_CONSTANTS.js"],"names":[],"mappings":"gCAmBU,MAAM;;;;;;;AAShB;;;GAGG;AACH,wCAiBE;AAEF;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;GAMG;AACH,6CAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,8CAA+C;AAE/C;;;;GAIG;AACH,iCAFU,MAAM,CAEoB"}

package/src/shade/renderer/postprocess/gtao/GTAO_CONSTANTS.js

@@ -53,7 +53,16 @@ export const GTAO_QUALITY_PROFILES = {
  * see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.h#L55
  * @type {number}
  */
-export const GTAO_DEPTH_MIP_LEVELS = 0;
+export const GTAO_DEPTH_MIP_LEVELS = 5;
+
+/**
+ * Log2 offset applied to the screen-space step distance (in pixels) when selecting a depth pyramid mip level.
+ * Higher values stay on finer mips further out; lower values drop to coarser mips sooner.
+ *
+ * @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.h#L71
+ * @type {number}
+ */
+export const GTAO_DEPTH_MIP_SAMPLING_OFFSET = 3.30;
 
 /**
  * distant samples contribute less

package/src/shade/renderer/postprocess/gtao/ao_reproject_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AA+JA,8CASE;4BAnK0B,6BAA6B"}
+{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AAgKA,8CAaE;4BAvK0B,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/ao_reproject_shader.js

@@ -1,3 +1,4 @@
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
 import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
 import {
     chunk_texture_sample_catmullrom_hardware_5tap_uv
@@ -163,7 +164,11 @@ export const ao_reproject_shader = new ImageShader({
         body,
         resources,
     }),
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
     targets: [{
         format: "rg16float",
+        // Background is skipped, so it keeps the clear: moments of visibility 1 (not occluded), zero variance.
+        // This is also next frame's history, whose filtered fetch reaches across silhouettes.
+        clearValue: [1, 1],
     }]
 })

package/src/shade/renderer/postprocess/gtao/chunk_gtao_compute_mip_level.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Selects the depth pyramid mip level for a GTAO horizon step at `sample_offset_length` screen pixels
+ * from the center pixel.
+ *
+ * Follows Intel XeGTAO's `clamp(log2(sampleOffsetLength) - DepthMIPSamplingOffset, 0, GTAO_DEPTH_MIP_LEVELS - 1)`
+ * paired with a `MIP_POINT` sampler (`round` to nearest integer mip). Because Mip 0 lives in `tDepth`
+ * while Mips 1..4 live in `tHZB`, rounding here keeps the Mip 0 -> Mip 1 handoff at `lod = 0.5`
+ * (`~13.9 px`) rather than `lod > 0.0` (`~9.8 px`). With `GTAO_DEPTH_MIP_SAMPLING_OFFSET = 3.30`:
+ *   - Mip 0 (`< ~13.9 px`): full-resolution `tDepth`
+ *   - Mip 1 (`~13.9 .. 27.9 px`): HZB mip 0 (half-res)
+ *   - Mip 2 (`~27.9 .. 55.7 px`): HZB mip 1 (quarter-res)
+ *   - Mip 3 (`~55.7 .. 111.4 px`): HZB mip 2 (1/8-res)
+ *   - Mip 4 (`>= ~111.4 px`): HZB mip 3 (1/16-res)
+ *
+ * Every mip transition occurs when the tap is at least ~7 texels away at the target mip resolution.
+ *
+ * @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.hlsli#L244
+ * @type {CodeChunk}
+ */
+export const chunk_gtao_compute_mip_level: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_gtao_compute_mip_level.d.ts.map

package/src/shade/renderer/postprocess/gtao/chunk_gtao_compute_mip_level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_gtao_compute_mip_level.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/chunk_gtao_compute_mip_level.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,2CAFU,SAAS,CAUjB;0BAhCwB,oCAAoC"}

package/src/shade/renderer/postprocess/gtao/chunk_gtao_compute_mip_level.js

@@ -0,0 +1,33 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { GTAO_DEPTH_MIP_LEVELS, GTAO_DEPTH_MIP_SAMPLING_OFFSET } from "./GTAO_CONSTANTS.js";
+
+const MAX_MIP_LEVEL = Math.max(0, GTAO_DEPTH_MIP_LEVELS - 1);
+
+/**
+ * Selects the depth pyramid mip level for a GTAO horizon step at `sample_offset_length` screen pixels
+ * from the center pixel.
+ *
+ * Follows Intel XeGTAO's `clamp(log2(sampleOffsetLength) - DepthMIPSamplingOffset, 0, GTAO_DEPTH_MIP_LEVELS - 1)`
+ * paired with a `MIP_POINT` sampler (`round` to nearest integer mip). Because Mip 0 lives in `tDepth`
+ * while Mips 1..4 live in `tHZB`, rounding here keeps the Mip 0 -> Mip 1 handoff at `lod = 0.5`
+ * (`~13.9 px`) rather than `lod > 0.0` (`~9.8 px`). With `GTAO_DEPTH_MIP_SAMPLING_OFFSET = 3.30`:
+ *   - Mip 0 (`< ~13.9 px`): full-resolution `tDepth`
+ *   - Mip 1 (`~13.9 .. 27.9 px`): HZB mip 0 (half-res)
+ *   - Mip 2 (`~27.9 .. 55.7 px`): HZB mip 1 (quarter-res)
+ *   - Mip 3 (`~55.7 .. 111.4 px`): HZB mip 2 (1/8-res)
+ *   - Mip 4 (`>= ~111.4 px`): HZB mip 3 (1/16-res)
+ *
+ * Every mip transition occurs when the tap is at least ~7 texels away at the target mip resolution.
+ *
+ * @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.hlsli#L244
+ * @type {CodeChunk}
+ */
+export const chunk_gtao_compute_mip_level = CodeChunk.from(
+    //language=WGSL
+    `
+fn gtao_compute_mip_level(sample_offset_length: f32) -> f32 {
+    let mip_f = round(log2(max(1.0, sample_offset_length)) - ${GTAO_DEPTH_MIP_SAMPLING_OFFSET});
+    return clamp(mip_f, 0.0, f32(${MAX_MIP_LEVEL}));
+}
+`
+);

package/src/shade/renderer/postprocess/gtao/chunk_gtao_resolve_hzb_depth.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolves a single reverse-Z device depth from an HZB `(d_min, d_max)` pair (`hzb.x` = farthest,
+ * `hzb.y` = closest in the $2^m \times 2^m$ footprint) using a discontinuity-aware slope filter.
+ *
+ * Why neither pure `hzb.y` (closest) nor pure `0.5 * (hzb.x + hzb.y)` (average) suffices alone
+ * (cf. Intel XeGTAO `DepthMIPFilter` and Tomasz Stachowiak / h3r2tic's Tiny Glade linear + point
+ * depth-sampling analysis):
+ *   - On a continuous sloped surface, reverse-Z device depth $1 / (-z_{\text{view}})$ is affine in
+ *     screen space. Taking only `hzb.y` treats each coarse $2^m \times 2^m$ texel as a flat "Duplo
+ *     brick" protruding toward the camera, causing false self-occlusion on slopes; averaging
+ *     `0.5 * (hzb.x + hzb.y)` reconstructs the smooth plane across the footprint.
+ *   - Across a silhouette edge (depth discontinuity), averaging `hzb.x` and `hzb.y` creates a
+ *     mid-air "shrink-wrap" phantom surface between foreground and background (or erodes silhouettes
+ *     against the sky). Weighting `hzb.x` down to zero when `depth_far - depth_near` exceeds the
+ *     effect falloff collapses the filter to `hzb.y` (the foreground surface).
+ *
+ * @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/XeGTAO.hlsli#L622
+ * @type {CodeChunk}
+ */
+export const chunk_gtao_resolve_hzb_depth: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_gtao_resolve_hzb_depth.d.ts.map