@woosh/meep-engine 3.60.5 → 3.60.7

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

@@ -1,10 +1,11 @@
+import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { graph_import_texture } from "../../shader/graph/graph_import_texture.js";
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
-import { shader_denoise_luminance_spatial } from "../denoise/fragment_shader_denoise_ao.js";
 import { ao_reproject_shader } from "./ao_reproject_shader.js";
 import { fragment_shader_gtao } from "./fragment_shader_gtao.js";
 import { shader_ao_composit } from "./graph_composit_ao_to_gBuffer.js";
+import { shader_gtao_spatial_denoise } from "./shader_gtao_spatial_denoise.js";
 
 /**
  * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
@@ -40,7 +41,8 @@ export class GTAO {
         for (let i = 0; i < 2; i++) {
             const texture = new GPUTextureContext(graphics.device);
 
-            texture.descriptor.format = "rg16float";
+            // visibility, and the bend: the bent normal minus the shading normal
+            texture.descriptor.format = "rgba16float";
             texture.descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT;
 
             this.#history[i] = texture;
@@ -54,7 +56,7 @@ export class GTAO {
      */
     enquirePipelines(enquiry) {
         enquiry.render.push(fragment_shader_gtao.pipeline);
-        enquiry.render.push(shader_denoise_luminance_spatial.pipeline);
+        enquiry.render.push(shader_gtao_spatial_denoise.pipeline);
         enquiry.render.push(ao_reproject_shader.pipeline);
         enquiry.render.push(shader_ao_composit.pipeline);
     }
@@ -67,14 +69,17 @@ export class GTAO {
      * @param {number} options.input_depth this frame's depth
      * @param {number} options.input_hzb hierarchical depth built from it
      * @param {number} options.input_normal G-buffer normals
+     * @param {number} options.input_normal_previous last frame's G-buffer normals, at the size last frame was
+     *   drawn at: which surface each history texel was written on
      * @param {number} options.input_velocity per-pixel velocity, in this frame's pixels
      * @param {number} options.input_occlusion depth-clip pass output: history confidence in r
      * @param {number} options.frame_index the renderer's frame counter: drives the noise, the history
      *   ping-pong, and whether the history follows on from the last frame drawn
      * @param {number} options.output G-buffer albedo; AO is blended into its alpha
      * @param {number[]} options.resolution this frame's render size
-     * @returns {{visibility:number, occlusion:number, bent_normals:number}} the accumulated visibility
-     *   moments, `output` after the composite, and the raw bent normals
+     * @returns {{visibility:number, occlusion:number, bent_normals:number}} the accumulated visibility and
+     *   bend (`rgba16float`), `output` after the composite, and the accumulated bent normals, octahedral in
+     *   `rg16uint` as `input_normal` is
      */
     graph_pass({
                    graph,
@@ -82,6 +87,7 @@ export class GTAO {
                    input_depth,
                    input_hzb,
                    input_normal,
+                   input_normal_previous,
                    input_velocity,
                    input_occlusion,
                    frame_index,
@@ -102,8 +108,15 @@ export class GTAO {
         const moments_history = graph_import_texture(graph, h0, "ao_history");
         const moments_output = graph_import_texture(graph, h1, "ao_output");
 
+        // written by the reprojection beside the history, so it is asked of the graph rather than of a pass
+        let bent_normals = graph.create_resource("bent normals", TextureResourceDescriptor.from({
+            resolution,
+            dimension: "2d",
+            format: "rg16uint",
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT
+        }));
 
-        const [raw_occlusion, raw_bent_normals] = graph_image_pass({
+        const [raw_occlusion] = graph_image_pass({
             graph,
             shader: fragment_shader_gtao,
             output_resolution: resolution,
@@ -126,16 +139,13 @@ export class GTAO {
         // apply small spatial denoise
         [moments] = graph_image_pass({
             graph,
-            shader: shader_denoise_luminance_spatial,
+            shader: shader_gtao_spatial_denoise,
             output_resolution: resolution,
             input_depth,
             inputs: {
                 tInput: moments,
                 tDepth: input_depth,
                 tNormal: input_normal,
-                settings: {
-                    step_size: 1,
-                }
             }
         });
 
@@ -145,18 +155,21 @@ export class GTAO {
         this.reset_history = false;
         this.#history_frame_index = frame_index;
 
-        [moments] = graph_image_pass({
+        [moments, bent_normals] = graph_image_pass({
             graph,
             shader: ao_reproject_shader,
-            output: [moments_output],
+            output: [moments_output, bent_normals],
             input_depth,
             inputs: {
                 tInput: moments,
                 tHistory: moments_history,
                 tVelocity: input_velocity,
                 tOcclusion: input_occlusion,
+                tNormal: input_normal,
+                tNormalPrevious: input_normal_previous,
                 settings: {
                     history_validity: history_valid ? 1 : 0,
+                    frame_index,
                 },
             }
         });
@@ -179,7 +192,7 @@ export class GTAO {
         return {
             visibility: moments,
             occlusion: filtered_occlusion,
-            bent_normals: raw_bent_normals,
+            bent_normals: bent_normals,
         };
     }
 }

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

@@ -1,3 +1,17 @@
+/**
+ * Accumulates GTAO over time: visibility, and the bend that makes the bent normal.
+ *
+ * The bend takes the history only where the history was written on this texel's surface, by the face normals of
+ * `tNormalPrevious` — last frame's G-buffer normal — against this frame's.
+ *
+ * `tInput`, `tHistory` and the first target are `rgba16float`: visibility in `x`, and in `yzw` the world-space
+ * bend — the bent normal minus the shading normal. Each is clamped to this frame's 3x3 neighbourhood before it
+ * blends, visibility to a box and the bend to a ball. The second target is the bent normal itself,
+ * `normalize(shading normal + bend)`, octahedral in `rg16uint` as the G-buffer normal is, which is what lighting
+ * reads.
+ *
+ * @type {ImageShader}
+ */
 export const ao_reproject_shader: ImageShader;
 import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=ao_reproject_shader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AA4KA,8CAaE;4BAnL0B,6BAA6B"}
+{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AAwRA;;;;;;;;;;;;;GAaG;AACH,kCAFU,WAAW,CAqBnB;4BA9S0B,6BAA6B"}

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

@@ -1,5 +1,10 @@
 import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.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_f16_round_stochastic } from "../../shader/chunk/math/chunk_f16_round_stochastic.js";
 import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
+import { chunk_hash_to_float01 } from "../../shader/chunk/random/chunk_hash_to_float01.js";
+import { chunk_pcg3d } from "../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import {
     chunk_texture_sample_catmullrom_hardware_5tap_uv
 } from "../../shader/chunk/texture/sample/chunk_texture_sample_catmullrom_hardware_5tap_uv.js";
@@ -8,107 +13,174 @@ import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { chunk_taa_velocity_confidence } from "../taa/shader_taa.js";
 import { chunk_taa_get_velocity } from "../velocity/chunk_taa_get_velocity.js";
 
 const AO_REPROJECT_SETTINGS_STRUCT = WebGPUStruct.from({
     /**
-     * 1 to blend against the history, 0 to take this frame's moments alone: the first frame, a reset,
-     * or a frame that does not follow the one the history was written on.
+     * 1 to blend against the history, 0 to take this frame's alone: the first frame, a reset, or a frame that
+     * does not follow the one the history was written on.
      */
     history_validity: f32,
+    /**
+     * Seeds the stochastic rounding of the history's store, fresh each frame.
+     */
+    frame_index: u32,
 });
 
 const resources = new ShaderResourceSetDescriptor();
 
-// per-pass, 4 bytes, read-only: immediate data rather than a uniform buffer.
+// per-pass, 8 bytes, read-only: immediate data rather than a uniform buffer.
 resources.setImmediate("settings", AO_REPROJECT_SETTINGS_STRUCT);
 resources.createGroup()
     .addTexture("tInput")
     .addTexture("tVelocity")
     .addTexture("tOcclusion")
+    .addTexture("tNormal", "uint")
+    // last frame's G-buffer normal, at the size last frame was drawn at
+    .addTexture("tNormalPrevious", "uint")
     .addTexture("tHistory","float")
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
 
 const body = CodeChunk.from(
 //language=WGSL
     `
-fn compute_center_moments(
-    input_center: vec2<f32>,
+struct NeighbourhoodStatistics {
+    // visibility's first two moments
+    moments: vec2<f32>,
+    // the bend's mean, and the mean of its squared length
+    bend: vec3<f32>,
+    bend_square: f32,
+}
+
+fn compute_center_statistics(
+    input_center: vec4<f32>,
     input_coord: vec2<i32>,
     input_texture: texture_2d<f32>,
-) -> vec2<f32>{
-    
+) -> NeighbourhoodStatistics {
+
     const offsets = array< vec2<i32>, 8 >(
       vec2( -1, -1 ),
       vec2(  0, -1 ),
-      vec2(  1, -1 ), 
-      
-      vec2( -1,  0 ), 
-      vec2(  1,  0 ), 
-      
+      vec2(  1, -1 ),
+
+      vec2( -1,  0 ),
+      vec2(  1,  0 ),
+
       vec2( -1,  1 ),
-      vec2(  0,  1 ), 
-      vec2(  1,  1 ), 
+      vec2(  0,  1 ),
+      vec2(  1,  1 ),
    );
-    
+
     const iteratorMax = 8;
     const rcp_divider = 1.f / 9.f;
 
     var moments = vec2(input_center.x, input_center.x * input_center.x);
-    
+
+    var bend = input_center.yzw;
+    var bend_square = dot(input_center.yzw, input_center.yzw);
+
     for (var  i = 0; i < iteratorMax; i++ ) {
         let new_st = input_coord + offsets[ i ];
 
-        let texel = textureLoad(input_texture, new_st, 0 ).rg;
-        
+        let texel = textureLoad(input_texture, new_st, 0 );
+
         moments += vec2(texel.x, texel.x * texel.x);
+        bend += texel.yzw;
+        bend_square += dot(texel.yzw, texel.yzw);
     }
-    
-    return moments * rcp_divider;
+
+    return NeighbourhoodStatistics(moments * rcp_divider, bend * rcp_divider, bend_square * rcp_divider);
+}
+
+// A face this far from another is another surface: half a right angle, as UE's Lumen takes it
+// (r.Lumen.ScreenProbeGather.Temporal.NormalThreshold). A tessellated curve's faces sit well inside it, a
+// crease's well outside.
+const SAME_SURFACE_COS = 0.70710678;
+
+// 1 where the history texel at tap was written on this texel's surface, by its face normal: last frame's
+fn history_texel_on_surface(tap: vec2<i32>, size: vec2<i32>, face_normal: vec3<f32>) -> f32 {
+    let history_face_normal = decode_g_buffer_normal(textureLoad(tNormalPrevious, clamp(tap, vec2(0), size - 1), 0).zw);
+
+    return select(0.0, 1.0, dot(history_face_normal, face_normal) >= SAME_SURFACE_COS);
+}
+
+// The share of the history's bilinear footprint written on this texel's surface, read where the history is, in
+// the previous normal's own grid.
+fn history_surface_agreement(prev_uv: vec2<f32>, face_normal: vec3<f32>) -> f32 {
+    let size = vec2<i32>(textureDimensions(tNormalPrevious));
+
+    let st = prev_uv * vec2<f32>(size) - 0.5;
+    let origin = vec2<i32>(floor(st));
+    let f = st - floor(st);
+
+    let weights = vec4(
+        (1.0 - f.x) * (1.0 - f.y),
+        f.x * (1.0 - f.y),
+        (1.0 - f.x) * f.y,
+        f.x * f.y,
+    );
+
+    let on_surface = vec4(
+        history_texel_on_surface(origin, size, face_normal),
+        history_texel_on_surface(origin + vec2(1, 0), size, face_normal),
+        history_texel_on_surface(origin + vec2(0, 1), size, face_normal),
+        history_texel_on_surface(origin + vec2(1, 1), size, face_normal),
+    );
+
+    return dot(weights, on_surface);
+}
+
+struct Output {
+    // visibility and the bend, accumulated: next frame's history
+    @location(0) history: vec4<f32>,
+    // the bent normal, octahedral as the G-buffer's normals are
+    @location(1) bent_normal: vec2<u32>,
 }
 
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
     @location(0) uv: vec2<f32>,
-) -> @location(0) vec2<f32> {
+) -> Output {
     let screenST = vec2<i32>( coord.xy );
-    
+
     let resolution = textureDimensions(tInput);
-    
+
     let occlusion_confidence = textureLoad(tOcclusion, screenST, 0).r;
-    let current_moments = textureLoad(tInput, screenST, 0).rg;
-    
+    let current = textureLoad(tInput, screenST, 0);
+    let encoded_normal = textureLoad(tNormal, screenST, 0);
+    let shading_normal = decode_g_buffer_normal(encoded_normal.xy);
+
     // get velocity
     let velocity = taa_get_velocity( tVelocity, screenST );
-    
+
     let velocity_confidence = taa_velocity_confidence(velocity);
-    
-    
+
+
     // prev frame ST
     let prevFrameScreenST = coord.xy - velocity.xy;
-    
+
     const MIN_VARIANCE = 0.5f; // under motion
     const MAX_VARIANCE = 1.2f; // no motion
 
     let variance_scale = mix( MIN_VARIANCE, MAX_VARIANCE, velocity_confidence * velocity_confidence ) ;
-    
-    
+
+
     let history_within_screen = all( prevFrameScreenST >= vec2(0.0) ) && all( prevFrameScreenST < vec2f(resolution )) ;
-    
-    
+
+
     let confidence = velocity_confidence * occlusion_confidence * select(0.0, 1.0,history_within_screen) * settings.history_validity;
 
-    
-    var output: vec2<f32>;
-    
+
+    var resolved: vec4<f32>;
+
     if(
         confidence <= 0.001
     ) {
-         output = current_moments;
+         resolved = current;
     }else{
 
         // a uv over this frame's size: the history keeps the size it was written at across a
@@ -116,51 +188,81 @@ fn main(
         let prev_uv = prevFrameScreenST / vec2<f32>(resolution);
 
         let history = texture_sample_catmullrom_hardware_5tap_uv(tHistory, sLinear, prev_uv);
-        let history_moments = history.rg;
 
         // AABB sigma is calibrated against the spatially pre-filtered input.
         // The small spatial denoise upstream is what makes this clamp meaningful:
         // it stabilises the neighbourhood so the AABB is a tight, non-jittery
         // ghosting bound rather than chasing per-frame noise. (Standard
         // pre-blur-then-clamp pattern from SVGF-style and TAA literature.)
-        let filtered_center_moments = compute_center_moments( current_moments, screenST, tInput);
+        let statistics = compute_center_statistics( current, screenST, tInput);
 
-        let sigma = get_std_dev(filtered_center_moments.x, filtered_center_moments.y) * variance_scale;
+        let sigma = get_std_dev(statistics.moments.x, statistics.moments.y) * variance_scale;
 
         // clamp history mean to neighborhood AABB
-        let input_min = filtered_center_moments.x - sigma ;
-        let input_max = filtered_center_moments.x + sigma ;
+        let clamped_visibility = clamp(history.x, statistics.moments.x - sigma, statistics.moments.x + sigma);
+
+        // The bend is clamped to a ball about the neighbourhood's mean bend, its radius the same multiple of
+        // the bend's deviation as the visibility's box takes of its own. The bend is not a unit vector, so its
+        // variance has no cancellation to fight: a neighbourhood of one value has none, and clamps the history
+        // onto it.
+        let bend_variance = max(statistics.bend_square - dot(statistics.bend, statistics.bend), 0.0);
+        let bend_radius = sqrt(bend_variance) * variance_scale;
 
-        let clamped_history_m1 = clamp(history_moments.x, input_min, input_max);
+        let bend_offset = history.yzw - statistics.bend;
+        let bend_offset_length = length(bend_offset);
 
-        // Preserve history's variance under the mean clamp:
-        //   m2 = E[X²] = E[X]² + Var(X), so adjust m2 to track the clamped mean while
-        //   retaining the variance the temporal accumulator has built up.
-        let history_variance = max(history_moments.y - history_moments.x * history_moments.x, 0.0);
-        let clamped_history_m2 = clamped_history_m1 * clamped_history_m1 + history_variance;
+        // past the radius the offset's length is positive, so the division is safe where it is taken
+        let clamped_bend = select(
+            history.yzw,
+            statistics.bend + bend_offset * (bend_radius / bend_offset_length),
+            bend_offset_length > bend_radius
+        );
 
-        // Note: deliberately do NOT gate history_weight on history_variance.
+        // Note: deliberately do NOT gate history_weight on the neighbourhood's variance.
         // Mixing a clamped history mean with a current mean injects cross-term
         // variance (w·(1-w)·(Δmean)²) that compounds through the EMA whenever
         // history hasn't converged. Letting that drive history_confidence down
-        // collapses temporal accumulation. The AABB clamp already constrains
-        // ghosting; rely on it instead and trust history at a fixed rate.
+        // collapses temporal accumulation. The clamps already constrain
+        // ghosting; rely on them instead and trust history at a fixed rate.
         const HISTORY_WEIGHT_MAX = 0.95;
 
         let history_weight = HISTORY_WEIGHT_MAX * occlusion_confidence;
 
-        let resolved = mix(
-            current_moments,
-            vec2(clamped_history_m1, clamped_history_m2),
-            history_weight
-        );
+        // A bend means something only against the normal it was measured on. A texel on a crease lands on
+        // either side from frame to frame as the projection jitters, so its history holds the other surface's
+        // bend, which added to this surface's normal tilts the bent normal towards that surface: a line along
+        // every crease. The bend takes the history only for the share written on this texel's own surface.
+        // Visibility is not measured against the normal, and keeps all of it.
+        let surface_agreement = history_surface_agreement(prev_uv, decode_g_buffer_normal(encoded_normal.zw));
 
-        output = resolved;
+        resolved = vec4(
+            mix(current.x, clamped_visibility, history_weight),
+            mix(current.yzw, clamped_bend, history_weight * surface_agreement),
+        );
 
     }
-    
-    
-    return output;
+
+    // Halves round toward zero on the devices measured, so a blend stored as one stalls short of its target by
+    // up to a ULP over the history's 5% step. Rounded stochastically, it lands on its target in expectation.
+    let hash = pcg3d(vec3<u32>(vec2<u32>(screenST), settings.frame_index));
+    let noise = vec4<f32>(
+        hash_to_float01(hash.x),
+        hash_to_float01(hash.y),
+        hash_to_float01(hash.z),
+        hash_to_float01(pcg3d(hash).x),
+    );
+
+    // The bend rides on this frame's own shading normal, so the history adds nothing of the normal map's detail
+    // of the texels it was resampled from. An extreme bend can cancel the normal; the normal stands in then.
+    let bent = shading_normal + resolved.yzw;
+    let bent_length = length(bent);
+
+    var out: Output;
+
+    out.history = f16_round_stochastic(resolved, noise);
+    out.bent_normal = encode_g_buffer_normal(select(shading_normal, bent / bent_length, bent_length > 1e-4));
+
+    return out;
 }
     `,
     [
@@ -168,8 +270,28 @@ fn main(
         chunk_taa_velocity_confidence,
         chunk_texture_sample_catmullrom_hardware_5tap_uv,
         chunk_get_std_dev,
+        chunk_decode_g_buffer_normal,
+        chunk_encode_g_buffer_normal,
+        chunk_f16_round_stochastic,
+        chunk_pcg3d,
+        chunk_hash_to_float01,
     ]
 );
+
+/**
+ * Accumulates GTAO over time: visibility, and the bend that makes the bent normal.
+ *
+ * The bend takes the history only where the history was written on this texel's surface, by the face normals of
+ * `tNormalPrevious` — last frame's G-buffer normal — against this frame's.
+ *
+ * `tInput`, `tHistory` and the first target are `rgba16float`: visibility in `x`, and in `yzw` the world-space
+ * bend — the bent normal minus the shading normal. Each is clamped to this frame's 3x3 neighbourhood before it
+ * blends, visibility to a box and the bend to a ball. The second target is the bent normal itself,
+ * `normalize(shading normal + bend)`, octahedral in `rg16uint` as the G-buffer normal is, which is what lighting
+ * reads.
+ *
+ * @type {ImageShader}
+ */
 export const ao_reproject_shader = new ImageShader({
     descriptor: ShaderDescriptor.from({
         label: "AO Reproject",
@@ -177,10 +299,16 @@ export const ao_reproject_shader = new ImageShader({
         resources,
     }),
     depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
-    targets: [{
-        format: "rg16float",
-        // Background is skipped, so it keeps the clear: moments of visibility 1 (not occluded), zero variance.
-        // This is also next frame's history, whose filtered fetch reaches across silhouettes.
-        clearValue: [1, 1],
-    }]
-})
+    targets: [
+        {
+            format: "rgba16float",
+            // Background is skipped, so it keeps the clear: not occluded, not bent.
+            // This is also next frame's history, whose filtered fetch reaches across silhouettes.
+            clearValue: [1, 0, 0, 0],
+        },
+        {
+            label: "Bent Normals",
+            format: "rg16uint",
+        },
+    ]
+})

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_integrate_lighting_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/chunk_integrate_lighting_sample.js"],"names":[],"mappings":"AAIA,gEA6CC;0BAhDyB,oCAAoC"}
+{"version":3,"file":"chunk_integrate_lighting_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/chunk_integrate_lighting_sample.js"],"names":[],"mappings":"AAIA,gEAgDC;0BAnDyB,oCAAoC"}

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

@@ -34,7 +34,10 @@ fn horizon_integrate_lighting_sample(
     }
         
     // see "Horizon-Based Indirect Lighting (HBIL)" equation 18
-    let occlusion = integrate_solid_angle(_integrant, h0, h1);
+    // integrate_solid_angle integrates from its first angle to its second. The band this sample blocks runs from
+    // the new horizon, nearer the view ray, out to the previous one, so in that order it comes out positive; the
+    // other way round both terms flip, and a caller's choice of integrant can only undo that for the tangent's.
+    let occlusion = integrate_solid_angle(_integrant, h1, h0);
          
     let sample_color = textureLoad(tColor, tex_coord_i, 0).rgb  ;
     

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

@@ -1 +1 @@
-{"version":3,"file":"fragment_shader_gtao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js"],"names":[],"mappings":"AA2VA,+CA6BG;4BAzWyB,6BAA6B"}
+{"version":3,"file":"fragment_shader_gtao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js"],"names":[],"mappings":"AA6WA,+CAyBG;4BAxXyB,6BAA6B"}