@woosh/meep-engine 3.54.0 → 3.55.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.54.0",
+  "version": "3.55.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/shade/RENDERER_CONTRACT.md

@@ -47,12 +47,15 @@ Three consequences that shape everything below:
 The renderer requires a WebGPU device that meets a fixed floor. There is no feature detection
 beyond it and no branch that produces a lesser frame.
 
-**Required features** — the adapter must have both, or startup fails:
+**Required features** — the adapter must have all three, or startup fails:
 
 - `indirect-first-instance` — indirect draw is used throughout
 - `float32-blendable` — the MBOIT transparency mode blends into 32-bit float targets. The default mode,
   AVBOIT, blends `rgba16float` only and does not need it. The feature stays on the floor while MBOIT is
   selectable at all; retiring it from the floor means retiring MBOIT.
+- `texture-formats-tier1` — the hierarchical Z buffer is reduced in compute into `rg16float` storage
+  textures, which core WebGPU cannot write. Without it the HZB texture and every HZB pipeline fail
+  validation, and occlusion culling, SSR, screen-space shadows and light culling all read the HZB.
 
 **Required limits:**
 
@@ -65,7 +68,7 @@ The required features and the two fixed limits are one definition, `device/SHADE
 All of it is checked against the adapter before a device is requested, so a refusal names every
 feature and limit the adapter lacks, with the value it offers, rather than the first one found.
 
-**Taken when offered, never required:** `timestamp-query`, `subgroups`, `texture-formats-tier1`.
+**Taken when offered, never required:** `timestamp-query`, `subgroups`.
 `timestamp-query` drives GPU timers and nothing else, and some browsers withhold it on hardware that
 is otherwise fine — so the timers go quiet when it is absent rather than the renderer refusing to
 start.

package/src/shade/device/SHADE_DEVICE_FLOOR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SHADE_DEVICE_FLOOR.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/SHADE_DEVICE_FLOOR.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACI;;OAEG;cADO,cAAc,mBAAmB,CAAC;IAS5C;;OAEG;YADO,SAAS,OAAO,MAAM,EAAE,MAAM,CAAC,CAAC;GAO3C;oCAjCiC,sCAAsC"}
+{"version":3,"file":"SHADE_DEVICE_FLOOR.d.ts","sourceRoot":"","sources":["../../../../src/shade/device/SHADE_DEVICE_FLOOR.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACI;;OAEG;cADO,cAAc,mBAAmB,CAAC;IAW5C;;OAEG;YADO,SAAS,OAAO,MAAM,EAAE,MAAM,CAAC,CAAC;GAO3C;oCAnCiC,sCAAsC"}

package/src/shade/device/SHADE_DEVICE_FLOOR.js

@@ -21,6 +21,8 @@ export const SHADE_DEVICE_FLOOR = Object.freeze({
         WebGPUExtensionType.IndirectFirstInstance,
         // the MBOIT transparency mode blends into 32-bit float targets; stays while MBOIT is selectable
         WebGPUExtensionType.Float32Blendable,
+        // the HZB is reduced in compute into rg16float storage textures; core WebGPU has no rg16float storage
+        WebGPUExtensionType.TextureFormatsTier1,
     ]),
 
     /**

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -1562,7 +1562,6 @@ export class Renderer {
                 // for the sake of a feature the renderer does not need to run.
                 WebGPUExtensionType.TimestampQuery,
                 WebGPUExtensionType.Subgroups,
-                WebGPUExtensionType.TextureFormatsTier1,
                 /*
                  Compressed textures. Taken when offered and never required: a device with none of
                  them still loads every scene, because the asset layer asks what is supported before
@@ -2845,6 +2844,7 @@ export class Renderer {
                 input_velocity: gr_velocity,
                 input_normal: gr_texture_normal,
                 input_occlusion: gr_occlusion_clip,
+                input_hzb: gr_texture_hzb,
                 // NOTE: AO is blended into the G-buffer
                 output: gr_texture_material_albedo_ao,
                 camera: gr_buffer_camera_current,

package/src/shade/renderer/hiz/generate_downsampler_code.js

@@ -43,7 +43,7 @@ export function generate_downsampler_code({
     return CodeChunk.from(
         //language=WGSL
         `
-@compute @workgroup_size(8, 8, 1)
+@compute @workgroup_size(16, 16)
 fn main(
     @builtin(global_invocation_id) global_id: vec3<u32>,
 ) {

package/src/shade/renderer/hiz/shader_hzb_reduce_mip0_clip.js

@@ -31,7 +31,7 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-@compute @workgroup_size(8, 8, 1)
+@compute @workgroup_size(16, 16)
 fn main(
     @builtin(global_invocation_id) global_id: vec3<u32>,
 ) {

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