npm - @woosh/meep-engine - Versions diffs - 3.54.0 → 3.55.0 - Mend

@woosh/meep-engine 3.54.0 → 3.55.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (78) hide show

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

@@ -1,357 +1,382 @@
-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_integrate_bent_normal_fast } from "./chunk_integrate_bent_normal_fast.js";
-import {
-    GTAO_DEPTH_MIP_LEVELS,
-    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")
-    .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_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.
- */
-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;
-            // note: when sampling, using point_point_point or point_point_linear sampler works, but linear_linear_linear will cause unwanted interpolation between neighbouring depth values on the same MIP level!
-            const mipLevel = 0; // Disabled currently
-            // 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 = textureSampleLevel(tDepth, sPoint, sampleScreenPos0, mipLevel).x;
-            let samplePos0  = project_view_position_from_depth(sampleScreenPos0, SZ0, camera.projection_matrix_inverse);
-            let sampleScreenPos1 = uv - sampleOffset;
-            let SZ1 = textureSampleLevel(tDepth, sPoint, sampleScreenPos1, mipLevel).x;
-            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,
-    ]);
-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_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",
+        },
+    ]
+});