npm - @woosh/meep-engine - Versions diffs - 3.60.5 → 3.60.7 - Mend

@woosh/meep-engine 3.60.5 → 3.60.7

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 (376) hide show

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

@@ -1,414 +1,430 @@
-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_direction_view_to_world } from "../../shader/chunk/camera/chunk_direction_view_to_world.js";
-import { chunk_direction_world_to_view } from "../../shader/chunk/camera/chunk_direction_world_to_view.js";
-import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_rgbe9995_encode } from "../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.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 { BLACK_PIXEL_TEXTURE } from "../../texture/util/BLACK_PIXEL_TEXTURE.js";
-import { SAMPLER_NEAREST } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.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 { chunk_horizon_integrate_lighting_sample } from "./chunk_integrate_lighting_sample.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();
-// see fragment_shader_gtao — the same per-pass settings, carried as immediate data
-resources.setImmediate("settings", GTAO_RENDER_SETTINGS);
-resources.createGroup()
-    .addTexture("tDepth")
-    .addTexture("tHZB")
-    .addSampler("sPoint", "non-filtering", SAMPLER_NEAREST)
-    .addTexture("tNormal", "uint")
-    .addTexture("tColor", "unfilterable-float", "2d", false, BLACK_PIXEL_TEXTURE)
-    .addTexture("tNoise", "uint", "2d", false, HILBERT_R2_INDEX_TEXTURE)
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-;
-/**
- * One step below the AO-only shader's Medium, because every sample here also integrates incoming
- * radiance. A deliberate difference, unlike the ones this fork used to carry by accident.
- * @type {{slices:number,steps:number}}
- */
-const QUALITY_SETTINGS = GTAO_QUALITY_PROFILES[GTAO_QUALITY_TYPE.Low];
-// this is our own thickness heuristic that relies on sooner discarding samples behind the center
-const GTAO_DEFAULT_THIN_OCCLUDER_COMPENSATION = 0.0;
-/*
-based on https://github.com/GameTechDev/XeGTAO/tree/e7698f874e90f2516fca26c696ec3cd2c70e505a
- */
-const body = CodeChunk.from(
-//language=WGSL
-    `
-const scale = 1.0;
-const thinOccluderCompensation = ${GTAO_DEFAULT_THIN_OCCLUDER_COMPENSATION};
-// 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
-    @location(2) irradiance: u32, // rgbe9995
-}
-@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);
-    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).xy); // shading normal
-    let view_normal_vs = direction_world_to_view(view_normal_ws, camera);
-    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).
-    // This read .w — tan(fovY/2) — with no factor of 2, i.e. 2*aspect too small, 3.56x at 16:9, which
-    // put every AO sample that much further out than the effect radius asked for.
-    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);
-    // fade out for small screen radii
-    var visibility = 0.0;
-    var bent_normal:vec3<f32>;
-    var lighting: vec3<f32>;
-    var lighting_weight_total = 0.0;
-    // 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);
-        // Calculate lighting integrant factors correctly in view space.
-        let light_integrant_front = 0.5 * vec2(dot(view_normal_vs.xy, sliceViewDir.xy), view_normal_vs.z);
-        // The back-side integrant has a flipped X component because the slice direction is flipped.
-        let light_integrant_back = vec2(-light_integrant_front.x, light_integrant_front.y);
-        var sliceLighting: vec3<f32>;
-        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_position_from_depth(sampleScreenPos0, SZ0, camera.view_projection_matrix_inverse);
-            let sampleScreenPos1 = uv - sampleOffset;
-            let SZ1 = gtao_sample_depth(sampleScreenPos1, mipLevel, camera);
-            let samplePos1 = project_position_from_depth(sampleScreenPos1, SZ1, camera.view_projection_matrix_inverse);
-            let sampleDelta0     = (samplePos0 - position_ws); // using lpfloat for sampleDelta causes precision issues
-            let sampleDelta1     = (samplePos1 - position_ws); // 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_ws );
-            var shc1 = dot( sampleHorizonVec1, view_direction_ws );
-            // 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 ));
-            if(shc0 > horizonCos0 && !is_background(SZ0) ){
-                let s0 = horizon_integrate_lighting_sample(
-                    sampleScreenPos0,
-                    view_normal_ws,      // ref_normal
-                    sampleHorizonVec0,   // ref_direction
-                    horizonCos0,         // h0 (previous horizon)
-                    shc0,                // h1 (new horizon)
-                    light_integrant_back
-                );
-                sliceLighting += s0;
-            }
-            if(shc1 > horizonCos1 && !is_background(SZ1) ){
-                let s1 = horizon_integrate_lighting_sample(
-                    sampleScreenPos1,
-                    view_normal_ws,      // ref_normal
-                    sampleHorizonVec1,   // ref_direction
-                    horizonCos1,         // h0 (previous horizon)
-                    shc1,                // h1 (new horizon)
-                    light_integrant_front
-                );
-                sliceLighting += s1;
-            }
-            // 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 — this
-        // used to assign back into projectedNormalVecLength, so the bent-normal accumulation below got
-        // the fudged weight too.
-        let visibilityProjLength = mix( projectedNormalVecLength, 1, 0.05 );
-        let localVisibility = visibilityProjLength * ( iarc0 + iarc1 );
-        visibility += localVisibility;
-        // unfudged, like the bent normal below: the fudge corrects the visibility integral only
-        sliceLighting *= projectedNormalVecLength;
-        lighting += sliceLighting;
-        // 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);
-    lighting *= PI * INV_SLICE_COUNT;
-    var out: Output;
-    out.visibility = vec2(visibility, visibility * visibility);
-    out.bent_normal = encode_g_buffer_normal( bent_normal );
-    out.irradiance = rgbe9995_encode( lighting );
-    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_direction_world_to_view,
-        chunk_direction_view_to_world,
-        chunk_is_background,
-        chunk_mat4_extract_position,
-        chunk_project_position_from_depth,
-        chunk_v3_matrix4_rotate,
-        chunk_integrate_bent_normal_fast,
-        chunk_gtao_compute_mip_level,
-        chunk_gtao_sample_depth,
-        //
-        chunk_rgbe9995_encode,
-        chunk_horizon_integrate_lighting_sample,
-    ]);
-export const fragment_shader_gtao_with_irradiance = 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",
-        },
-        {
-            label: "Irradiance",
-            // encoded as RGBE9995
-            format:"r32uint"
-        }
-    ]
-});
+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_direction_view_to_world } from "../../shader/chunk/camera/chunk_direction_view_to_world.js";
+import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_rgbe9995_encode } from "../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.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 { BLACK_PIXEL_TEXTURE } from "../../texture/util/BLACK_PIXEL_TEXTURE.js";
+import { SAMPLER_NEAREST } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.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 { chunk_horizon_integrate_lighting_sample } from "./chunk_integrate_lighting_sample.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();
+// see fragment_shader_gtao — the same per-pass settings, carried as immediate data
+resources.setImmediate("settings", GTAO_RENDER_SETTINGS);
+resources.createGroup()
+    .addTexture("tDepth")
+    .addTexture("tHZB")
+    .addSampler("sPoint", "non-filtering", SAMPLER_NEAREST)
+    .addTexture("tNormal", "uint")
+    .addTexture("tColor", "unfilterable-float", "2d", false, BLACK_PIXEL_TEXTURE)
+    .addTexture("tNoise", "uint", "2d", false, HILBERT_R2_INDEX_TEXTURE)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+;
+/**
+ * One step below the AO-only shader's Medium, because every sample here also integrates incoming
+ * radiance. A deliberate difference, unlike the ones this fork used to carry by accident.
+ * @type {{slices:number,steps:number}}
+ */
+const QUALITY_SETTINGS = GTAO_QUALITY_PROFILES[GTAO_QUALITY_TYPE.Low];
+// this is our own thickness heuristic that relies on sooner discarding samples behind the center
+const GTAO_DEFAULT_THIN_OCCLUDER_COMPENSATION = 0.0;
+/*
+based on https://github.com/GameTechDev/XeGTAO/tree/e7698f874e90f2516fca26c696ec3cd2c70e505a
+ */
+const body = CodeChunk.from(
+//language=WGSL
+    `
+const scale = 1.0;
+const thinOccluderCompensation = ${GTAO_DEFAULT_THIN_OCCLUDER_COMPENSATION};
+// 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
+    @location(2) irradiance: u32, // rgbe9995
+}
+@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);
+    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).
+    // This read .w — tan(fovY/2) — with no factor of 2, i.e. 2*aspect too small, 3.56x at 16:9, which
+    // put every AO sample that much further out than the effect radius asked for.
+    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);
+    // fade out for small screen radii
+    var visibility = 0.0;
+    var bent_normal:vec3<f32>;
+    var lighting: vec3<f32>;
+    var lighting_weight_total = 0.0;
+    // 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;
+    // The slices' angle is measured around the view ray, from the camera's right made perpendicular to it: at
+    // the screen's centre that is the screen's own x, as the paper has it. The ray never runs along it inside a
+    // frustum. See fragment_shader_gtao, which this follows in world space.
+    let camera_right_ws = v3_matrix4_rotate(vec3(1.0, 0.0, 0.0), camera.view_matrix_inverse);
+    let slice_basis_x = normalize(fma(vec3(-dot(camera_right_ws, view_direction_ws)), view_direction_ws, camera_right_ws));
+    let slice_basis_y = cross(view_direction_ws, slice_basis_x);
+    let center_clip = camera.view_projection_matrix * vec4(position_ws, 1.0);
+    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);
+        // line 8 from the paper, with phi the slice's angle around this texel's own view ray: the integrals below
+        // are written in that angle. The paper takes phi on screen, which is the same angle only at the screen's
+        // centre; off it, slices spread evenly on screen bunch around the view ray, the two of a frame stop
+        // cancelling, and an open plane's bent normal leans by degrees towards the screen's edges.
+        let sliceWorldDir = cosPhi * slice_basis_x + sinPhi * slice_basis_y;
+        // The slice's plane holds the view ray, so on screen it is a line through this texel, along the
+        // projection's derivative in the slice's direction: (d(clip.xy) * clip.w - clip.xy * d(clip.w)) / clip.w^2,
+        // its scale dropped, into uv and then pixels.
+        let slice_clip = camera.view_projection_matrix * vec4(sliceWorldDir, 0.0);
+        let slice_screen = (slice_clip.xy * center_clip.w - center_clip.xy * slice_clip.w) * vec2(0.5, -0.5) * vec2<f32>(ViewportSize);
+        let omega = normalize(slice_screen) * screenspaceRadius;
+        // 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);
+        // The lighting integrant's factors, in the slice's own frame: a direction in it is
+        // cos(theta) * view + sin(theta) * tangent, so N.w splits into N.tangent and N.view. At the screen's
+        // centre that is the view-space N.xy along the slice and N.z this read before the slices followed the ray.
+        let slice_tangent_ws = normalize(orthoWorldDir);
+        let light_integrant_front = 0.5 * vec2(dot(view_normal_ws, slice_tangent_ws), dot(view_normal_ws, view_direction_ws));
+        // Sample 0 lies along the tangent and sample 1 against it, so the back side, sample 1's, has the tangent's
+        // term flipped.
+        let light_integrant_back = vec2(-light_integrant_front.x, light_integrant_front.y);
+        var sliceLighting: vec3<f32>;
+        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 is a unit screen direction times screenspaceRadius, so 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_position_from_depth(sampleScreenPos0, SZ0, camera.view_projection_matrix_inverse);
+            let sampleScreenPos1 = uv - sampleOffset;
+            let SZ1 = gtao_sample_depth(sampleScreenPos1, mipLevel, camera);
+            let samplePos1 = project_position_from_depth(sampleScreenPos1, SZ1, camera.view_projection_matrix_inverse);
+            let sampleDelta0     = (samplePos0 - position_ws); // using lpfloat for sampleDelta causes precision issues
+            let sampleDelta1     = (samplePos1 - position_ws); // 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_ws );
+            var shc1 = dot( sampleHorizonVec1, view_direction_ws );
+            // 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 ));
+            if(shc0 > horizonCos0 && !is_background(SZ0) ){
+                let s0 = horizon_integrate_lighting_sample(
+                    sampleScreenPos0,
+                    view_normal_ws,      // ref_normal
+                    sampleHorizonVec0,   // ref_direction
+                    horizonCos0,         // h0 (previous horizon)
+                    shc0,                // h1 (new horizon)
+                    light_integrant_front
+                );
+                sliceLighting += s0;
+            }
+            if(shc1 > horizonCos1 && !is_background(SZ1) ){
+                let s1 = horizon_integrate_lighting_sample(
+                    sampleScreenPos1,
+                    view_normal_ws,      // ref_normal
+                    sampleHorizonVec1,   // ref_direction
+                    horizonCos1,         // h0 (previous horizon)
+                    shc1,                // h1 (new horizon)
+                    light_integrant_back
+                );
+                sliceLighting += s1;
+            }
+            // 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 — this
+        // used to assign back into projectedNormalVecLength, so the bent-normal accumulation below got
+        // the fudged weight too.
+        let visibilityProjLength = mix( projectedNormalVecLength, 1, 0.05 );
+        let localVisibility = visibilityProjLength * ( iarc0 + iarc1 );
+        visibility += localVisibility;
+        // Not weighted by projectedNormalVecLength, as the visibility and the bent normal are: those integrate
+        // against the projected normal made unit, and put its length back. The lighting's integrant dots the
+        // whole normal with directions in the slice, which already is the projected normal, length and all.
+        lighting += sliceLighting;
+        // see "Algorithm 2 Extension that computes bent normals b."
+        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);
+    lighting *= PI * INV_SLICE_COUNT;
+    var out: Output;
+    out.visibility = vec2(visibility, visibility * visibility);
+    out.bent_normal = encode_g_buffer_normal( bent_normal );
+    out.irradiance = rgbe9995_encode( lighting );
+    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_direction_view_to_world,
+        chunk_is_background,
+        chunk_mat4_extract_position,
+        chunk_project_position_from_depth,
+        chunk_v3_matrix4_rotate,
+        chunk_integrate_bent_normal_fast,
+        chunk_gtao_compute_mip_level,
+        chunk_gtao_sample_depth,
+        //
+        chunk_rgbe9995_encode,
+        chunk_horizon_integrate_lighting_sample,
+    ]);
+export const fragment_shader_gtao_with_irradiance = 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",
+        },
+        {
+            label: "Irradiance",
+            // encoded as RGBE9995
+            format:"r32uint"
+        }
+    ]
+});