@woosh/meep-engine 3.56.0 → 3.58.0

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

@@ -1,382 +1,377 @@
-import { BlendState } from "../../../descriptor/blend/BlendState.js";
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
-import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_project_view_position_from_depth } from "../../shader/chunk/camera/chunk_project_view_position_from_depth.js";
-import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
-import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
-import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_encode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js";
-import { chunk_v3_matrix4_rotate } from "../../shader/chunk/geometry/vec3/chunk_v3_matrix4_rotate.js";
-import { chunk_fast_acos } from "../../shader/chunk/math/fast/chunk_fast_acos.js";
-import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
-import { PI_HALF_DECLARATION } from "../../shader/chunk/math/PI_HALF_DECLARATION.js";
-import { chunk_spatio_temporal_noise_r2_64 } from "../../shader/chunk/noise/chunk_spatio_temporal_noise_r2_64.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 { HILBERT_R2_INDEX_TEXTURE } from "../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
-import { SAMPLER_NEAREST } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { chunk_gtao_compute_mip_level } from "./chunk_gtao_compute_mip_level.js";
-import { chunk_gtao_sample_depth } from "./chunk_gtao_sample_depth.js";
-import { chunk_integrate_bent_normal_fast } from "./chunk_integrate_bent_normal_fast.js";
-import {
-    GTAO_DEPTH_MIP_LEVELS,
-    GTAO_DEPTH_MIP_SAMPLING_OFFSET,
-    GTAO_EFFECT_FALLOFF_RANGE,
-    GTAO_EFFECT_RADIUS,
-    GTAO_QUALITY_PROFILES,
-    GTAO_QUALITY_TYPE
-} from "./GTAO_CONSTANTS.js";
-import { GTAO_RENDER_SETTINGS } from "./GTAO_RENDER_SETTINGS.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, four bytes, read-only: immediate data rather than a uniform buffer.
-//
-// The uniform carried a `frame_index: 0` default, which does not travel: immediate data has no
-// default, and a dispatch that never wrote its slots is refused rather than reading zero. GTAO
-// passes frame_index on every dispatch, so nothing relied on it.
-resources.setImmediate("settings", GTAO_RENDER_SETTINGS);
-resources.createGroup()
-    .addTexture("tDepth")
-    .addTexture("tHZB")
-    .addSampler("sPoint", "non-filtering", SAMPLER_NEAREST)
-    .addTexture("tNormal", "uint")
-    .addTexture("tNoise", "uint", "2d", false, HILBERT_R2_INDEX_TEXTURE)
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-;
-
-const QUALITY_SETTINGS = GTAO_QUALITY_PROFILES[GTAO_QUALITY_TYPE.Medium];
-
-// the import paths these already had, kept working
-export { GTAO_DEPTH_MIP_LEVELS, GTAO_DEPTH_MIP_SAMPLING_OFFSET, GTAO_EFFECT_FALLOFF_RANGE, GTAO_EFFECT_RADIUS };
-
-/*
-based on https://github.com/GameTechDev/XeGTAO/tree/e7698f874e90f2516fca26c696ec3cd2c70e505a
-
-The horizon search reconstructs its samples in view space (2026-10-16). Measured on an RTX 4090 (Chrome,
-D3D12), the VSM playground's courtyard, Medium quality, TAA on. Arms swapped by pipeline every 4 frames
-inside one capture, 3 captures of 6 s each. GTAO's time, and the old world-space path against the new:
-
-                   near view (walls close)    overview (geometry far)
-    1898 x 982     185 µs, old/new 1.00       84 µs, old/new 1.055 (p10 1.049)
-    2538 x 1342    364 µs, old/new 1.00       179 µs, old/new 1.041 (p10 1.048-1.055)
-
-Up close a 1 m radius spreads the 16 samples over hundreds of pixels and the pass waits on depth fetches:
-deleting the reconstruction outright bought nothing there (1.008, 1.010). At a distance the fetches hit
-cache and the arithmetic shows: deleting it bought 9.4% and 6.6%, and the view-space path recovers half.
-The same frame replayed through both: visibility differs in 0.1-0.18% of pixels, by one f16 step
-(0.00098); bent normals in 3-7% of pixels, by at most 0.014 degrees.
-
-HZB depth mipmap sampling (2026-10-23, `chunk_gtao_compute_mip_level` + `chunk_gtao_sample_depth`), same
-courtyard setup, 3 captures of 60 frames each, arms swapped by pipeline every 4 frames. `mip0` (all taps
-from `tDepth` mip 0) against `hzb_slope` (`gtao_resolve_hzb_depth` slope-aware filter) and `hzb_max`
-(`tHZB.y` only):
-
-                   near view (walls close)                        overview (geometry far)
-    1898 x 982     mip0 192.5 µs -> hzb_slope 72.7 µs (2.65x)     mip0 91.1 µs -> hzb_slope 88.1 µs (1.03x)
-                                 -> hzb_max   66.6 µs (2.89x)                  -> hzb_max   79.9 µs (1.14x)
-    2538 x 1342    mip0 362.5 µs -> hzb_slope 142.3 µs (2.55x)    mip0 180.2 µs -> hzb_slope 151.6 µs (1.19x)
-                                 -> hzb_max   123.9 µs (2.93x)                   -> hzb_max   135.2 µs (1.33x)
-
-Same-frame quality replay against `mip0` (1898 x 982 / 2538 x 1342):
-  - overview: `hzb_slope` PSNR 52.74 / 48.78 dB (mean |dv| 0.00016 / 0.00027, bent normal mean 0.012° / 0.021°),
-    beating `hzb_max` (50.50 / 47.15 dB, 3.5x larger mean |dv| and 10x stronger darkening bias on slopes) and
-    unfiltered `0.5*(hzb.x+hzb.y)` (46.92 / 42.96 dB, 2.0x higher RMSE from silhouette shrink-wrap).
-  - near: `hzb_slope` PSNR 26.04 / 26.25 dB (mean |dv| 0.0107 / 0.0102, bent normal mean 0.91° / 0.87°),
-    vs `hzb_max` (25.52 / 25.65 dB, 1.6x stronger darkening bias) and unfiltered avg (20.66 / 20.79 dB).
- */
-const body = CodeChunk.from(
-//language=WGSL
-    `
-const scale = 1.0;
-
-// small crevices more important than big surfaces
-const sampleDistributionPower = 2.0;
-
-const SLICE_COUNT = ${QUALITY_SETTINGS.slices};
-
-const STEPS = ${QUALITY_SETTINGS.steps};
-
-struct Output{
-    @location(0) visibility: vec2<f32>, // first 2 moment
-    @location(1) bent_normal: vec2<u32>, // octahedral encoding
-}
-
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-) -> Output {
-
-    // fadeout precompute optimisation
-    const falloffRange = ${GTAO_EFFECT_FALLOFF_RANGE} * ${GTAO_EFFECT_RADIUS};
-    
-    const falloffFrom       = ${GTAO_EFFECT_RADIUS} * (1.0 - ${GTAO_EFFECT_FALLOFF_RANGE});
-    const falloffMul        = -1.0 / ( falloffRange );
-    const falloffAdd        = falloffFrom / ( falloffRange ) + 1.0;
-    
-    let texel_position_u32 = vec2<u32>(coord.xy);
-
-    let ViewportSize = textureDimensions(tDepth);
-    let ViewportPixelSize =  1. / vec2<f32>(ViewportSize);
-        
-    var device_depth = textureLoad(tDepth, texel_position_u32, 0).r;
-    
-    // NOTE: no need to reject based on depth, already handled via depthStencil 
-        
-    var viewspaceZ = get_view_space_depth(device_depth, camera);
-            
-    // Move center pixel slightly towards camera to avoid imprecision artifacts due to depth buffer imprecision; offset depends on depth texture format used
-    viewspaceZ *= 0.99999;     // this is good for FP32 depth buffer
-    
-    let position_ws = project_position_from_depth(uv, device_depth, camera.view_projection_matrix_inverse );
-    let view_position_ws = mat4_extract_position(camera.view_matrix_inverse);
-    let view_direction_ws = normalize(view_position_ws - position_ws);
-
-    // The horizon search below only measures distances and angles, which the view rotation preserves, so it
-    // runs in view space: a sample there is 4 multiply-adds from the projection's inverse instead of 16
-    // from the view-projection's. Slices and the bent normal stay in world space.
-    let position_vs = project_view_position_from_depth(uv, device_depth, camera.projection_matrix_inverse);
-    let view_direction_vs = normalize(-position_vs);
-
-    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).xy); // shading normal
-
-    let noiseTexel = spatio_temporal_noise_r2_64(texel_position_u32, settings.frame_index, tNoise);
-        
-    let noiseSample = noiseTexel.x;
-    let noiseSlice = noiseTexel.y;
-    
-    // quality settings / tweaks / hacks
-    const pixelTooCloseThreshold  = 1.3;      // if the offset is under approx pixel size (pixelTooCloseThreshold), push it out to the minimum distance
-
-    // approx viewspace pixel size at pixCoord; approximation of NDCToViewspace( normalizedScreenPos.xy + consts.ViewportPixelSize.xy, pixCenterPos.z ).xy - pixCenterPos.xy;
-    // device_depth_to_view_space.z = 1/a = aspect * tan(fovY/2) = tan(fovX/2), pairs with horizontal pixel size.
-    // factor of 2 converts a single uv-step (= 1 pixel) into the matching ndc-step (range 2 wide).
-    let NDCToViewMul_x_PixelSize = 2.0 * camera.device_depth_to_view_space.z * ViewportPixelSize.x;
-    let pixelDirRBViewspaceSizeAtCenterZ  = viewspaceZ * NDCToViewMul_x_PixelSize;
-
-    let screenspaceRadius = abs( ${GTAO_EFFECT_RADIUS} / pixelDirRBViewspaceSizeAtCenterZ);
-
-    var visibility = 0.0;
-    var bent_normal:vec3<f32>;
-           
-    // this is the min distance to start sampling from to avoid sampling from the center pixel (no useful data obtained from sampling center pixel)
-    let minS = pixelTooCloseThreshold / screenspaceRadius;
-    
-    const INV_SLICE_COUNT = 1.0 / f32(SLICE_COUNT);
-       
-    for (var slice = 0; slice < SLICE_COUNT; slice++) {
-        
-        let sliceK = ( f32(slice) + noiseSlice ) * INV_SLICE_COUNT;
-        
-        // lines 5,6 from the paper
-        let phi = sliceK * PI; // slice angle
-        
-        let cosPhi = cos(phi);
-        let sinPhi = sin(phi);
-        
-        let omega = vec2(cosPhi, -sinPhi) * screenspaceRadius;
-        
-        // line 8 from the paper
-        let sliceViewDir = vec3(cosPhi, sinPhi, 0.0);
-        let sliceWorldDir = v3_matrix4_rotate(sliceViewDir, camera.view_matrix_inverse);
-
-        // line 9 from the paper
-        // NOTE: optimized with FMA, readability suffers
-        let orthoWorldDir = fma( vec3( -dot(sliceWorldDir, view_direction_ws) ), view_direction_ws, sliceWorldDir );
-        
-        // line 10 from the paper
-        // axisVec is orthogonal to sliceViewDir and viewVec, used to define projectedNormal
-        let axisVec = normalize( cross(orthoWorldDir, view_direction_ws) );
-        
-        // line 11 from paper
-        let projectedWorldNormal = fma( -axisVec, vec3( dot(view_normal_ws, axisVec) ), view_normal_ws );
-        
-        // line 13 from the paper
-        let signNorm = sign( dot( orthoWorldDir, projectedWorldNormal ) );
-            
-        // line 14 from the paper
-        var projectedNormalVecLength = length(projectedWorldNormal);
-        let norm_cos = saturate( dot( projectedWorldNormal, view_direction_ws ) / projectedNormalVecLength );
-         
-        // line 15 from the paper
-        let n = signNorm * fast_acos(norm_cos);
-            
-        // this is a lower weight target; not using -1 as in the original paper because it is under horizon, so a 'weight' has different meaning based on the normal
-        let lowHorizonCos0   = cos(n + PI_HALF);
-        let lowHorizonCos1   = -lowHorizonCos0; // cos(n - PI_HALF);
-        
-        // lines 17, 18 from the paper, manually unrolled the 'side' loop
-        var horizonCos0 = lowHorizonCos0; // -1
-        var horizonCos1 = lowHorizonCos1; // -1
-        
-        const INV_STEPS = 1.0 / f32(STEPS);
-                
-        for (var step_index = 0; step_index < STEPS; step_index++) {
-            
-            // R1 sequence (http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/)
-            // Standard multiplier is 0.6180339887498948482 = ( 1 / GOLDEN_RATION ) 
-            let stepBaseNoise = f32(slice + step_index * STEPS) * 0.6180339887498948482;
-            
-            let stepNoise = fract(noiseSample + stepBaseNoise); 
-            
-            // approx line 20 from the paper, with added noise
-            var s = ( f32(step_index) + stepNoise ) * INV_STEPS;
-            
-            // additional distribution modifier
-            s = pow( s, sampleDistributionPower );
-
-            // avoid sampling center pixel
-            s += minS;
-            
-            // approx lines 21-22 from the paper, unrolled
-            var sampleOffset = s * omega;
-
-            // omega = vec2(cosPhi, -sinPhi) * screenspaceRadius has length screenspaceRadius
-            let sampleOffsetLength = s * screenspaceRadius;
-            let mipLevel = gtao_compute_mip_level(sampleOffsetLength);
-
-            // Snap to pixel center (more correct direction math, avoids artifacts due to sampling pos not matching depth texel center - messes up slope - but adds other 
-            // artifacts due to them being pushed off the slice). Also use full precision for high res cases.
-            sampleOffset = round( sampleOffset ) * ViewportPixelSize;
-
-            let sampleScreenPos0 = uv + sampleOffset;
-            
-            let SZ0 = gtao_sample_depth(sampleScreenPos0, mipLevel, camera);
-            let samplePos0  = project_view_position_from_depth(sampleScreenPos0, SZ0, camera.projection_matrix_inverse);
-
-            let sampleScreenPos1 = uv - sampleOffset;
-            let SZ1 = gtao_sample_depth(sampleScreenPos1, mipLevel, camera);
-            let samplePos1 = project_view_position_from_depth(sampleScreenPos1, SZ1, camera.projection_matrix_inverse);
-
-            let sampleDelta0     = (samplePos0 - position_vs); // using lpfloat for sampleDelta causes precision issues
-            let sampleDelta1     = (samplePos1 - position_vs); // using lpfloat for sampleDelta causes precision issues
-            
-            let sampleDist0     = length( sampleDelta0 );
-            let sampleDist1     = length( sampleDelta1 );
-            
-            // approx lines 23, 24 from the paper, unrolled
-            let sampleHorizonVec0 = sampleDelta0 / sampleDist0;
-            let sampleHorizonVec1 = sampleDelta1 / sampleDist1;
-                
-            let weight0         = saturate( fma(sampleDist0, falloffMul, falloffAdd) );
-            let weight1         = saturate( fma(sampleDist1, falloffMul, falloffAdd) );
-            
-            // sample horizon cos
-            var shc0 = dot( sampleHorizonVec0, view_direction_vs );
-            var shc1 = dot( sampleHorizonVec1, view_direction_vs );
-            
-            // discard unwanted samples
-            shc0 = mix( lowHorizonCos0, shc0, weight0 ); // this would be more correct but too expensive: cos(lerp( acos(lowHorizonCos0), acos(shc0), weight0 ));
-            shc1 = mix( lowHorizonCos1, shc1, weight1 ); // this would be more correct but too expensive: cos(lerp( acos(lowHorizonCos1), acos(shc1), weight1 ));
-            
-            // this is a version where thicknessHeuristic is completely disabled
-            horizonCos0 = max( horizonCos0, shc0 );
-            horizonCos1 = max( horizonCos1, shc1 );
-                        
-        }
-        
-        // line ~27, unrolled
-        let h0 = -fast_acos(horizonCos1);
-        let h1 = fast_acos(horizonCos0);
-
-        let norm_sin = sin(n);
-        let norm_sin2 = 2.0 * norm_sin;
-
-        let iarc0 = ( fma( h0 , norm_sin2, norm_cos ) - cos( fma( 2.0, h0, - n)) ) * 0.25;
-        let iarc1 = ( fma( h1 , norm_sin2, norm_cos ) - cos( fma( 2.0, h1, - n)) ) * 0.25;
-
-        // Slight overdarkening on high slopes is compensated by tilting projected length toward 1.
-        // In the training set, 0.05 is close (PSNR 21.34) to disabled (PSNR 21.45).
-        // Scoped to the visibility branch so bent normals keep their unfudged slice weighting.
-        let visibilityProjLength = mix( projectedNormalVecLength, 1, 0.05 );
-        let localVisibility = visibilityProjLength * ( iarc0 + iarc1 );
-
-        visibility += localVisibility;
-
-
-        // see "Algorithm 2 Extension that computes bent normals b."
-        let slice_tangent_ws = normalize(orthoWorldDir);
-        let local_bent_ts = integrate_bent_normal(
-             horizonCos1,
-             horizonCos0,
-             norm_cos,
-             norm_sin,
-        );
-
-        let t0 = local_bent_ts.x;
-        let t1 = local_bent_ts.y;
-
-        var slice_bent_normal_ws = slice_tangent_ws * t0 + view_direction_ws * t1;
-
-        bent_normal = fma(slice_bent_normal_ws, vec3(projectedNormalVecLength), bent_normal);
-    }
-    
-    visibility *= INV_SLICE_COUNT;
-    
-    visibility = pow(visibility, scale);
-    
-    // disallow total occlusion (which wouldn't make any sense anyhow since pixel is visible but also helps with packing bent normals)
-    visibility = max(0.03, visibility);		
-    
-    bent_normal = normalize(bent_normal);
-        
-    var out: Output;
-    out.visibility = vec2(visibility, visibility * visibility);
-    out.bent_normal = encode_g_buffer_normal( bent_normal );
-    
-    return out;
-}
-`, [
-        chunk_get_view_space_depth,
-        PI_DECLARATION,
-        PI_HALF_DECLARATION,
-
-        chunk_decode_g_buffer_normal,
-        chunk_encode_g_buffer_normal,
-        chunk_spatio_temporal_noise_r2_64,
-
-        chunk_fast_acos,
-
-        chunk_mat4_extract_position,
-        chunk_project_position_from_depth,
-        chunk_project_view_position_from_depth,
-        chunk_v3_matrix4_rotate,
-        chunk_integrate_bent_normal_fast,
-        chunk_gtao_compute_mip_level,
-        chunk_gtao_sample_depth,
-    ]);
-
-export const fragment_shader_gtao = new ImageShader({
-    descriptor: ShaderDescriptor.from(
-        {
-            label: "GTAO",
-            resources,
-            body
-        },
-    ),
-    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
-    targets: [
-        {
-            label: "Occlusion",
-            // first 2 moments of visibility
-            format: "rg16float",
-            clearValue: [1, 1], // Stores visibility, so 1 == not occluded
-            blend: BlendState.from({
-                color: {
-                    operation: "add",
-                    srcFactor: "one",
-                    dstFactor: "zero",
-                }
-            })
-        },
-        {
-            label: "Bent Normals",
-            // Direction is encoded with octahedral
-            format: "rg16uint",
-        },
-    ]
-});
+import { BlendState } from "../../../descriptor/blend/BlendState.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_project_view_position_from_depth } from "../../shader/chunk/camera/chunk_project_view_position_from_depth.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_encode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js";
+import { chunk_v3_matrix4_rotate } from "../../shader/chunk/geometry/vec3/chunk_v3_matrix4_rotate.js";
+import { chunk_fast_acos } from "../../shader/chunk/math/fast/chunk_fast_acos.js";
+import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
+import { PI_HALF_DECLARATION } from "../../shader/chunk/math/PI_HALF_DECLARATION.js";
+import { chunk_spatio_temporal_noise_r2_64 } from "../../shader/chunk/noise/chunk_spatio_temporal_noise_r2_64.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 { HILBERT_R2_INDEX_TEXTURE } from "../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
+import { SAMPLER_NEAREST } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { chunk_gtao_compute_mip_level } from "./chunk_gtao_compute_mip_level.js";
+import { chunk_gtao_sample_depth } from "./chunk_gtao_sample_depth.js";
+import { chunk_integrate_bent_normal_fast } from "./chunk_integrate_bent_normal_fast.js";
+import {
+    GTAO_EFFECT_FALLOFF_RANGE,
+    GTAO_EFFECT_RADIUS,
+    GTAO_QUALITY_PROFILES,
+    GTAO_QUALITY_TYPE
+} from "./GTAO_CONSTANTS.js";
+import { GTAO_RENDER_SETTINGS } from "./GTAO_RENDER_SETTINGS.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, four bytes, read-only: immediate data rather than a uniform buffer.
+//
+// The uniform carried a `frame_index: 0` default, which does not travel: immediate data has no
+// default, and a dispatch that never wrote its slots is refused rather than reading zero. GTAO
+// passes frame_index on every dispatch, so nothing relied on it.
+resources.setImmediate("settings", GTAO_RENDER_SETTINGS);
+resources.createGroup()
+    .addTexture("tDepth")
+    .addTexture("tHZB")
+    .addSampler("sPoint", "non-filtering", SAMPLER_NEAREST)
+    .addTexture("tNormal", "uint")
+    .addTexture("tNoise", "uint", "2d", false, HILBERT_R2_INDEX_TEXTURE)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+;
+
+const QUALITY_SETTINGS = GTAO_QUALITY_PROFILES[GTAO_QUALITY_TYPE.Medium];
+
+/*
+based on https://github.com/GameTechDev/XeGTAO/tree/e7698f874e90f2516fca26c696ec3cd2c70e505a
+
+The horizon search reconstructs its samples in view space (2026-10-16). Measured on an RTX 4090 (Chrome,
+D3D12), the VSM playground's courtyard, Medium quality, TAA on. Arms swapped by pipeline every 4 frames
+inside one capture, 3 captures of 6 s each. GTAO's time, and the old world-space path against the new:
+
+                   near view (walls close)    overview (geometry far)
+    1898 x 982     185 µs, old/new 1.00       84 µs, old/new 1.055 (p10 1.049)
+    2538 x 1342    364 µs, old/new 1.00       179 µs, old/new 1.041 (p10 1.048-1.055)
+
+Up close a 1 m radius spreads the 16 samples over hundreds of pixels and the pass waits on depth fetches:
+deleting the reconstruction outright bought nothing there (1.008, 1.010). At a distance the fetches hit
+cache and the arithmetic shows: deleting it bought 9.4% and 6.6%, and the view-space path recovers half.
+The same frame replayed through both: visibility differs in 0.1-0.18% of pixels, by one f16 step
+(0.00098); bent normals in 3-7% of pixels, by at most 0.014 degrees.
+
+HZB depth mipmap sampling (2026-10-23, `chunk_gtao_compute_mip_level` + `chunk_gtao_sample_depth`), same
+courtyard setup, 3 captures of 60 frames each, arms swapped by pipeline every 4 frames. `mip0` (all taps
+from `tDepth` mip 0) against `hzb_slope` (`gtao_resolve_hzb_depth` slope-aware filter) and `hzb_max`
+(`tHZB.y` only):
+
+                   near view (walls close)                        overview (geometry far)
+    1898 x 982     mip0 192.5 µs -> hzb_slope 72.7 µs (2.65x)     mip0 91.1 µs -> hzb_slope 88.1 µs (1.03x)
+                                 -> hzb_max   66.6 µs (2.89x)                  -> hzb_max   79.9 µs (1.14x)
+    2538 x 1342    mip0 362.5 µs -> hzb_slope 142.3 µs (2.55x)    mip0 180.2 µs -> hzb_slope 151.6 µs (1.19x)
+                                 -> hzb_max   123.9 µs (2.93x)                   -> hzb_max   135.2 µs (1.33x)
+
+Same-frame quality replay against `mip0` (1898 x 982 / 2538 x 1342):
+  - overview: `hzb_slope` PSNR 52.74 / 48.78 dB (mean |dv| 0.00016 / 0.00027, bent normal mean 0.012° / 0.021°),
+    beating `hzb_max` (50.50 / 47.15 dB, 3.5x larger mean |dv| and 10x stronger darkening bias on slopes) and
+    unfiltered `0.5*(hzb.x+hzb.y)` (46.92 / 42.96 dB, 2.0x higher RMSE from silhouette shrink-wrap).
+  - near: `hzb_slope` PSNR 26.04 / 26.25 dB (mean |dv| 0.0107 / 0.0102, bent normal mean 0.91° / 0.87°),
+    vs `hzb_max` (25.52 / 25.65 dB, 1.6x stronger darkening bias) and unfiltered avg (20.66 / 20.79 dB).
+ */
+const body = CodeChunk.from(
+//language=WGSL
+    `
+const scale = 1.0;
+
+// small crevices more important than big surfaces
+const sampleDistributionPower = 2.0;
+
+const SLICE_COUNT = ${QUALITY_SETTINGS.slices};
+
+const STEPS = ${QUALITY_SETTINGS.steps};
+
+struct Output{
+    @location(0) visibility: vec2<f32>, // first 2 moment
+    @location(1) bent_normal: vec2<u32>, // octahedral encoding
+}
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> Output {
+
+    // fadeout precompute optimisation
+    const falloffRange = ${GTAO_EFFECT_FALLOFF_RANGE} * ${GTAO_EFFECT_RADIUS};
+    
+    const falloffFrom       = ${GTAO_EFFECT_RADIUS} * (1.0 - ${GTAO_EFFECT_FALLOFF_RANGE});
+    const falloffMul        = -1.0 / ( falloffRange );
+    const falloffAdd        = falloffFrom / ( falloffRange ) + 1.0;
+    
+    let texel_position_u32 = vec2<u32>(coord.xy);
+
+    let ViewportSize = textureDimensions(tDepth);
+    let ViewportPixelSize =  1. / vec2<f32>(ViewportSize);
+        
+    var device_depth = textureLoad(tDepth, texel_position_u32, 0).r;
+    
+    // NOTE: no need to reject based on depth, already handled via depthStencil 
+        
+    var viewspaceZ = get_view_space_depth(device_depth, camera);
+            
+    // Move center pixel slightly towards camera to avoid imprecision artifacts due to depth buffer imprecision; offset depends on depth texture format used
+    viewspaceZ *= 0.99999;     // this is good for FP32 depth buffer
+    
+    let position_ws = project_position_from_depth(uv, device_depth, camera.view_projection_matrix_inverse );
+    let view_position_ws = mat4_extract_position(camera.view_matrix_inverse);
+    let view_direction_ws = normalize(view_position_ws - position_ws);
+
+    // The horizon search below only measures distances and angles, which the view rotation preserves, so it
+    // runs in view space: a sample there is 4 multiply-adds from the projection's inverse instead of 16
+    // from the view-projection's. Slices and the bent normal stay in world space.
+    let position_vs = project_view_position_from_depth(uv, device_depth, camera.projection_matrix_inverse);
+    let view_direction_vs = normalize(-position_vs);
+
+    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).xy); // shading normal
+
+    let noiseTexel = spatio_temporal_noise_r2_64(texel_position_u32, settings.frame_index, tNoise);
+        
+    let noiseSample = noiseTexel.x;
+    let noiseSlice = noiseTexel.y;
+    
+    // quality settings / tweaks / hacks
+    const pixelTooCloseThreshold  = 1.3;      // if the offset is under approx pixel size (pixelTooCloseThreshold), push it out to the minimum distance
+
+    // approx viewspace pixel size at pixCoord; approximation of NDCToViewspace( normalizedScreenPos.xy + consts.ViewportPixelSize.xy, pixCenterPos.z ).xy - pixCenterPos.xy;
+    // device_depth_to_view_space.z = 1/a = aspect * tan(fovY/2) = tan(fovX/2), pairs with horizontal pixel size.
+    // factor of 2 converts a single uv-step (= 1 pixel) into the matching ndc-step (range 2 wide).
+    let NDCToViewMul_x_PixelSize = 2.0 * camera.device_depth_to_view_space.z * ViewportPixelSize.x;
+    let pixelDirRBViewspaceSizeAtCenterZ  = viewspaceZ * NDCToViewMul_x_PixelSize;
+
+    let screenspaceRadius = abs( ${GTAO_EFFECT_RADIUS} / pixelDirRBViewspaceSizeAtCenterZ);
+
+    var visibility = 0.0;
+    var bent_normal:vec3<f32>;
+           
+    // this is the min distance to start sampling from to avoid sampling from the center pixel (no useful data obtained from sampling center pixel)
+    let minS = pixelTooCloseThreshold / screenspaceRadius;
+    
+    const INV_SLICE_COUNT = 1.0 / f32(SLICE_COUNT);
+       
+    for (var slice = 0; slice < SLICE_COUNT; slice++) {
+        
+        let sliceK = ( f32(slice) + noiseSlice ) * INV_SLICE_COUNT;
+        
+        // lines 5,6 from the paper
+        let phi = sliceK * PI; // slice angle
+        
+        let cosPhi = cos(phi);
+        let sinPhi = sin(phi);
+        
+        let omega = vec2(cosPhi, -sinPhi) * screenspaceRadius;
+        
+        // line 8 from the paper
+        let sliceViewDir = vec3(cosPhi, sinPhi, 0.0);
+        let sliceWorldDir = v3_matrix4_rotate(sliceViewDir, camera.view_matrix_inverse);
+
+        // line 9 from the paper
+        // NOTE: optimized with FMA, readability suffers
+        let orthoWorldDir = fma( vec3( -dot(sliceWorldDir, view_direction_ws) ), view_direction_ws, sliceWorldDir );
+        
+        // line 10 from the paper
+        // axisVec is orthogonal to sliceViewDir and viewVec, used to define projectedNormal
+        let axisVec = normalize( cross(orthoWorldDir, view_direction_ws) );
+        
+        // line 11 from paper
+        let projectedWorldNormal = fma( -axisVec, vec3( dot(view_normal_ws, axisVec) ), view_normal_ws );
+        
+        // line 13 from the paper
+        let signNorm = sign( dot( orthoWorldDir, projectedWorldNormal ) );
+            
+        // line 14 from the paper
+        var projectedNormalVecLength = length(projectedWorldNormal);
+        let norm_cos = saturate( dot( projectedWorldNormal, view_direction_ws ) / projectedNormalVecLength );
+         
+        // line 15 from the paper
+        let n = signNorm * fast_acos(norm_cos);
+            
+        // this is a lower weight target; not using -1 as in the original paper because it is under horizon, so a 'weight' has different meaning based on the normal
+        let lowHorizonCos0   = cos(n + PI_HALF);
+        let lowHorizonCos1   = -lowHorizonCos0; // cos(n - PI_HALF);
+        
+        // lines 17, 18 from the paper, manually unrolled the 'side' loop
+        var horizonCos0 = lowHorizonCos0; // -1
+        var horizonCos1 = lowHorizonCos1; // -1
+        
+        const INV_STEPS = 1.0 / f32(STEPS);
+                
+        for (var step_index = 0; step_index < STEPS; step_index++) {
+            
+            // R1 sequence (http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/)
+            // Standard multiplier is 0.6180339887498948482 = ( 1 / GOLDEN_RATION ) 
+            let stepBaseNoise = f32(slice + step_index * STEPS) * 0.6180339887498948482;
+            
+            let stepNoise = fract(noiseSample + stepBaseNoise); 
+            
+            // approx line 20 from the paper, with added noise
+            var s = ( f32(step_index) + stepNoise ) * INV_STEPS;
+            
+            // additional distribution modifier
+            s = pow( s, sampleDistributionPower );
+
+            // avoid sampling center pixel
+            s += minS;
+            
+            // approx lines 21-22 from the paper, unrolled
+            var sampleOffset = s * omega;
+
+            // omega = vec2(cosPhi, -sinPhi) * screenspaceRadius has length screenspaceRadius
+            let sampleOffsetLength = s * screenspaceRadius;
+            let mipLevel = gtao_compute_mip_level(sampleOffsetLength);
+
+            // Snap to pixel center (more correct direction math, avoids artifacts due to sampling pos not matching depth texel center - messes up slope - but adds other 
+            // artifacts due to them being pushed off the slice). Also use full precision for high res cases.
+            sampleOffset = round( sampleOffset ) * ViewportPixelSize;
+
+            let sampleScreenPos0 = uv + sampleOffset;
+            
+            let SZ0 = gtao_sample_depth(sampleScreenPos0, mipLevel, camera);
+            let samplePos0  = project_view_position_from_depth(sampleScreenPos0, SZ0, camera.projection_matrix_inverse);
+
+            let sampleScreenPos1 = uv - sampleOffset;
+            let SZ1 = gtao_sample_depth(sampleScreenPos1, mipLevel, camera);
+            let samplePos1 = project_view_position_from_depth(sampleScreenPos1, SZ1, camera.projection_matrix_inverse);
+
+            let sampleDelta0     = (samplePos0 - position_vs); // using lpfloat for sampleDelta causes precision issues
+            let sampleDelta1     = (samplePos1 - position_vs); // using lpfloat for sampleDelta causes precision issues
+            
+            let sampleDist0     = length( sampleDelta0 );
+            let sampleDist1     = length( sampleDelta1 );
+            
+            // approx lines 23, 24 from the paper, unrolled
+            let sampleHorizonVec0 = sampleDelta0 / sampleDist0;
+            let sampleHorizonVec1 = sampleDelta1 / sampleDist1;
+                
+            let weight0         = saturate( fma(sampleDist0, falloffMul, falloffAdd) );
+            let weight1         = saturate( fma(sampleDist1, falloffMul, falloffAdd) );
+            
+            // sample horizon cos
+            var shc0 = dot( sampleHorizonVec0, view_direction_vs );
+            var shc1 = dot( sampleHorizonVec1, view_direction_vs );
+            
+            // discard unwanted samples
+            shc0 = mix( lowHorizonCos0, shc0, weight0 ); // this would be more correct but too expensive: cos(lerp( acos(lowHorizonCos0), acos(shc0), weight0 ));
+            shc1 = mix( lowHorizonCos1, shc1, weight1 ); // this would be more correct but too expensive: cos(lerp( acos(lowHorizonCos1), acos(shc1), weight1 ));
+            
+            // this is a version where thicknessHeuristic is completely disabled
+            horizonCos0 = max( horizonCos0, shc0 );
+            horizonCos1 = max( horizonCos1, shc1 );
+                        
+        }
+        
+        // line ~27, unrolled
+        let h0 = -fast_acos(horizonCos1);
+        let h1 = fast_acos(horizonCos0);
+
+        let norm_sin = sin(n);
+        let norm_sin2 = 2.0 * norm_sin;
+
+        let iarc0 = ( fma( h0 , norm_sin2, norm_cos ) - cos( fma( 2.0, h0, - n)) ) * 0.25;
+        let iarc1 = ( fma( h1 , norm_sin2, norm_cos ) - cos( fma( 2.0, h1, - n)) ) * 0.25;
+
+        // Slight overdarkening on high slopes is compensated by tilting projected length toward 1.
+        // In the training set, 0.05 is close (PSNR 21.34) to disabled (PSNR 21.45).
+        // Scoped to the visibility branch so bent normals keep their unfudged slice weighting.
+        let visibilityProjLength = mix( projectedNormalVecLength, 1, 0.05 );
+        let localVisibility = visibilityProjLength * ( iarc0 + iarc1 );
+
+        visibility += localVisibility;
+
+
+        // see "Algorithm 2 Extension that computes bent normals b."
+        let slice_tangent_ws = normalize(orthoWorldDir);
+        let local_bent_ts = integrate_bent_normal(
+             horizonCos1,
+             horizonCos0,
+             norm_cos,
+             norm_sin,
+        );
+
+        let t0 = local_bent_ts.x;
+        let t1 = local_bent_ts.y;
+
+        var slice_bent_normal_ws = slice_tangent_ws * t0 + view_direction_ws * t1;
+
+        bent_normal = fma(slice_bent_normal_ws, vec3(projectedNormalVecLength), bent_normal);
+    }
+    
+    visibility *= INV_SLICE_COUNT;
+    
+    visibility = pow(visibility, scale);
+    
+    // disallow total occlusion (which wouldn't make any sense anyhow since pixel is visible but also helps with packing bent normals)
+    visibility = max(0.03, visibility);		
+    
+    bent_normal = normalize(bent_normal);
+        
+    var out: Output;
+    out.visibility = vec2(visibility, visibility * visibility);
+    out.bent_normal = encode_g_buffer_normal( bent_normal );
+    
+    return out;
+}
+`, [
+        chunk_get_view_space_depth,
+        PI_DECLARATION,
+        PI_HALF_DECLARATION,
+
+        chunk_decode_g_buffer_normal,
+        chunk_encode_g_buffer_normal,
+        chunk_spatio_temporal_noise_r2_64,
+
+        chunk_fast_acos,
+
+        chunk_mat4_extract_position,
+        chunk_project_position_from_depth,
+        chunk_project_view_position_from_depth,
+        chunk_v3_matrix4_rotate,
+        chunk_integrate_bent_normal_fast,
+        chunk_gtao_compute_mip_level,
+        chunk_gtao_sample_depth,
+    ]);
+
+export const fragment_shader_gtao = new ImageShader({
+    descriptor: ShaderDescriptor.from(
+        {
+            label: "GTAO",
+            resources,
+            body
+        },
+    ),
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    targets: [
+        {
+            label: "Occlusion",
+            // first 2 moments of visibility
+            format: "rg16float",
+            clearValue: [1, 1], // Stores visibility, so 1 == not occluded
+            blend: BlendState.from({
+                color: {
+                    operation: "add",
+                    srcFactor: "one",
+                    dstFactor: "zero",
+                }
+            })
+        },
+        {
+            label: "Bent Normals",
+            // Direction is encoded with octahedral
+            format: "rg16uint",
+        },
+    ]
+});