@woosh/meep-engine 3.54.0 → 3.56.0

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

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

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

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

@@ -0,0 +1,56 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { GTAO_EFFECT_FALLOFF_RANGE, GTAO_EFFECT_RADIUS } from "./GTAO_CONSTANTS.js";
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+fn gtao_resolve_hzb_depth(
+    hzb: vec2<f32>,
+    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+) -> f32 {
+    // If any texel in the footprint is background/sky (reverse-Z depth <= 0), do not blend across
+    // the silhouette into the sky (which also avoids 0 / 0 or inf - inf under an infinite far plane).
+    if (hzb.x <= 0.0) {
+        return hzb.y;
+    }
+
+    // XeGTAO DepthMIPFilter falloff: empirically 0.75 * effectRadius works well across mips.
+    const effect_radius = 0.75 * ${GTAO_EFFECT_RADIUS};
+    const falloff_range = ${GTAO_EFFECT_FALLOFF_RANGE} * effect_radius;
+    const falloff_from = effect_radius * (1.0 - ${GTAO_EFFECT_FALLOFF_RANGE});
+    const falloff_mul = -1.0 / falloff_range;
+    const falloff_add = falloff_from / falloff_range + 1.0;
+
+    let depth_far = get_view_space_depth(hzb.x, camera);
+    let depth_near = get_view_space_depth(hzb.y, camera);
+
+    let w = saturate(fma(depth_far - depth_near, falloff_mul, falloff_add));
+
+    return mix(hzb.y, hzb.x, w / (1.0 + w));
+}
+`,
+    [
+        chunk_get_view_space_depth,
+    ]
+);

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

@@ -0,0 +1,13 @@
+/**
+ * Samples reverse-Z device depth for a GTAO horizon tap at `uv` and `mip_level`.
+ *
+ * - `mip_level <= 0.0` reads full-resolution `tDepth` (mip 0).
+ * - `mip_level > 0.0` reads `tHZB` at `mip_level - 1.0` (since `tHZB` mip 0 is half-resolution, i.e.
+ *   screen mip 1) in normalized UV space (matching `HierarchicalZBuffer`'s alignment-padded reduction)
+ *   and resolves the `(min, max)` depth pair through {@link chunk_gtao_resolve_hzb_depth}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_gtao_sample_depth: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_gtao_sample_depth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_gtao_sample_depth.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/chunk_gtao_sample_depth.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,sCAFU,SAAS,CAqBjB;0BAnCwB,oCAAoC"}

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

@@ -0,0 +1,42 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { SCREEN_DEPTH_RESOURCE, SCREEN_HZB_RESOURCE } from "../../shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { chunk_gtao_resolve_hzb_depth } from "./chunk_gtao_resolve_hzb_depth.js";
+
+const POINT_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("sPoint", "non-filtering");
+
+/**
+ * Samples reverse-Z device depth for a GTAO horizon tap at `uv` and `mip_level`.
+ *
+ * - `mip_level <= 0.0` reads full-resolution `tDepth` (mip 0).
+ * - `mip_level > 0.0` reads `tHZB` at `mip_level - 1.0` (since `tHZB` mip 0 is half-resolution, i.e.
+ *   screen mip 1) in normalized UV space (matching `HierarchicalZBuffer`'s alignment-padded reduction)
+ *   and resolves the `(min, max)` depth pair through {@link chunk_gtao_resolve_hzb_depth}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_gtao_sample_depth = CodeChunk.from(
+    //language=WGSL
+    `
+fn gtao_sample_depth(
+    uv: vec2<f32>,
+    mip_level: f32,
+    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+) -> f32 {
+    if (mip_level <= 0.0) {
+        return textureSampleLevel(tDepth, sPoint, uv, 0.0).x;
+    }
+
+    let hzb = textureSampleLevel(tHZB, sPoint, uv, mip_level - 1.0).xy;
+    return gtao_resolve_hzb_depth(hzb, camera);
+}
+`,
+    [
+        chunk_gtao_resolve_hzb_depth,
+    ]
+);
+
+chunk_gtao_sample_depth.requireResource(SCREEN_DEPTH_RESOURCE);
+chunk_gtao_sample_depth.requireResource(SCREEN_HZB_RESOURCE);
+chunk_gtao_sample_depth.requireResource(POINT_SAMPLER_RESOURCE);