@woosh/meep-engine 3.60.4 → 3.60.6

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts

@@ -5,12 +5,6 @@ export class GPUResidentMaterialContext {
      * @param {GraphicsContext} graphics
      */
     constructor(device: GPUDevice, graphics: GraphicsContext);
-    /**
-     * Sent with a material when it is repacked because its {@link ShadeMaterial#version} moved: the
-     * row the device reads changes with the next {@link update}. Not sent for a material's first pack.
-     * @type {Signal<ShadeMaterial>}
-     */
-    onMaterialRepacked: any;
     /**
      *
      * @returns {number}
@@ -26,10 +20,6 @@ export class GPUResidentMaterialContext {
      * @returns {GPUTextureContext}
      */
     get buffer_textures(): GPUTextureContext;
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_texture_means(): GPUBuffer;
     /**
      *
      * @returns {GPUTextureView}
@@ -54,8 +44,8 @@ export class GPUResidentMaterialContext {
      * Make a material resident, or repack it if its {@link ShadeMaterial#version} has moved since —
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
-     * {@link update}: the scene's drawn list, and the manager's materials whenever its version
-     * moves, so the check rides on walks that already happen.
+     * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
+     * version moves, or what a card capture traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}
@@ -75,6 +65,16 @@ export class GPUResidentMaterialContext {
      * @param {GPUSceneContext} scene_context
      */
     ensure_scene_materials(scene_context: GPUSceneContext): void;
+    /**
+     * Write what {@link obtain_material} made resident or repacked since the last commit, and the media
+     * that moved. Takes none of the manager's materials, unlike {@link update}: for a reader that makes
+     * resident only what it reads.
+     */
+    commit(): void;
+    /**
+     * Make every material the manager holds resident, then {@link commit}: for the readers that trace
+     * the whole scene.
+     */
     update(): void;
     destroy(): void;
     #private;

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAmIA;IAqMI;;;;OAIG;IACH,yCAFW,eAAe,EAyDzB;IA/PD;;;;OAIG;IACH,wBAAkC;IA4BlC;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAoBD;;OAEG;IACH,sCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IA6JD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAqBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA4DC;IAkJD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD,eAWC;IAGD,gBAMC;;CACJ;8BAh2BY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAnB5C,oCAAoC;AAatE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAgIA;IAqKI;;;;OAIG;IACH,yCAFW,eAAe,EAkDzB;IA9LD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IAsJD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAmBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA0DC;IAuFD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD;;;;OAIG;IACH,eAGC;IAED;;;OAGG;IACH,eAGC;IAGD,gBAIC;;CACJ;8BA9vBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAlB5C,oCAAoC;AAYtE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -1,13 +1,11 @@
 import { assert } from "../../../../core/assert.js";
 import { HashMap } from "../../../../core/collection/map/HashMap.js";
-import Signal from "../../../../core/events/signal/Signal.js";
 import IdPool from "../../../../core/IdPool.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
 import { ShadeGPUCommandContext } from "../../../device/ShadeGPUCommandContext.js";
 import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
-import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 import { MEDIA_TABLE_CAPACITY, MEDIA_TABLE_STRUCT } from "../../medium/MEDIA_TABLE_STRUCT.js";
 import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
 import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
@@ -25,7 +23,6 @@ import {
     RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
     RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION
 } from "./RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
-import { shader_resident_texture_means, shader_resident_texture_rows } from "./shader_resident_texture_means.js";
 
 /**
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
@@ -131,13 +128,6 @@ const NEUTRAL_SURFACE = Object.freeze({
 
 export class GPUResidentMaterialContext {
 
-    /**
-     * Sent with a material when it is repacked because its {@link ShadeMaterial#version} moved: the
-     * row the device reads changes with the next {@link update}. Not sent for a material's first pack.
-     * @type {Signal<ShadeMaterial>}
-     */
-    onMaterialRepacked = new Signal();
-
     /**
      * @type {GraphicsContext}
      */
@@ -200,31 +190,6 @@ export class GPUResidentMaterialContext {
         return this.#buffer_textures;
     }
 
-    /**
-     * Each texture slot's mean, `vec4<f32>`, of its texels as the atlas stores them: an albedo's colour
-     * premultiplied by its coverage. Written whenever the textures are (§6.6 of
-     * PROBE_CLIPMAP_PROPOSAL_2026_10_27.md): what a GI hit that no card sees takes of its material.
-     * Replaced when the slots outgrow it, so take it each frame.
-     *
-     * @type {GPUBuffer}
-     */
-    #buffer_texture_means;
-
-    /** The rows' sums the means are made of. @type {GPUBuffer|null} */
-    #buffer_texture_rows = null;
-
-    /** Slots the means hold. */
-    #texture_means_capacity = 0;
-
-    #texture_means_settings = { slot_count: 0 };
-
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_texture_means() {
-        return this.#buffer_texture_means;
-    }
-
     /**
      *
      * @returns {GPUTextureView}
@@ -368,13 +333,6 @@ export class GPUResidentMaterialContext {
             size: MEDIA_TABLE_STRUCT.size,
         });
 
-        // a slot's worth until the first textures are written
-        this.#buffer_texture_means = device.createBuffer({
-            label: 'Material Texture Means',
-            usage: GPUBufferUsage.STORAGE,
-            size: 16,
-        });
-
         this.#buffer_textures = new GPUTextureContext(device);
         const descriptor = this.#buffer_textures.descriptor;
 
@@ -485,8 +443,8 @@ export class GPUResidentMaterialContext {
      * Make a material resident, or repack it if its {@link ShadeMaterial#version} has moved since —
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
-     * {@link update}: the scene's drawn list, and the manager's materials whenever its version
-     * moves, so the check rides on walks that already happen.
+     * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
+     * version moves, or what a card capture traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}
@@ -505,8 +463,6 @@ export class GPUResidentMaterialContext {
             this.#pack_material(info);
         } else if (info.version !== material.version) {
             this.#pack_material(info);
-
-            this.onMaterialRepacked.send1(material);
         }
 
         return info;
@@ -592,8 +548,6 @@ export class GPUResidentMaterialContext {
             }
         }
 
-        this.#record_texture_means(encoder, textures);
-
         encoder.finish();
 
     }
@@ -683,65 +637,6 @@ export class GPUResidentMaterialContext {
         }
     }
 
-    /**
-     * Every texture slot's mean, after the slots are written (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6):
-     * the rows' sums, then the slots' means, which {@link buffer_texture_means} holds.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {TextureInfo[]} textures
-     */
-    #record_texture_means(encoder, textures) {
-        let slot_count = 0;
-
-        for (let i = 0; i < textures.length; i++) {
-            slot_count = Math.max(slot_count, textures[i].id + 1);
-        }
-
-        if (slot_count === 0) {
-            return;
-        }
-
-        if (this.#texture_means_capacity < slot_count) {
-            // textures arrive a few at a time as a scene loads: doubling replaces the buffers a
-            // logarithmic number of times
-            const capacity = Math.max(slot_count, 2 * this.#texture_means_capacity);
-
-            this.#buffer_texture_means.destroy();
-            this.#buffer_texture_rows?.destroy();
-
-            this.#texture_means_capacity = capacity;
-            this.#buffer_texture_means = this.#device.createBuffer({
-                label: 'Material Texture Means',
-                usage: GPUBufferUsage.STORAGE,
-                size: 16 * capacity,
-            });
-            this.#buffer_texture_rows = this.#device.createBuffer({
-                label: 'Material Texture Rows',
-                usage: GPUBufferUsage.STORAGE,
-                size: 16 * RESIDENT_MATERIAL_TEXTURE_RESOLUTION * capacity,
-            });
-        }
-
-        const settings = this.#texture_means_settings;
-
-        settings.slot_count = slot_count;
-
-        // a workgroup a slot, folded as folded_workgroup_index reads it: the array holds more slots than a
-        // dimension does
-        shader_resident_texture_rows.dispatch({
-            encoder,
-            group_count_x: Math.min(slot_count, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
-            group_count_y: Math.ceil(slot_count / WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
-            bindings: { settings, textures: this.textureView, texture_rows: this.#buffer_texture_rows },
-        });
-
-        shader_resident_texture_means.dispatch({
-            encoder,
-            group_count_x: Math.ceil(slot_count / 64),
-            bindings: { settings, texture_rows: this.#buffer_texture_rows, texture_means: this.#buffer_texture_means },
-        });
-    }
-
     build_materials() {
 
         /**
@@ -871,25 +766,29 @@ export class GPUResidentMaterialContext {
 
     }
 
-    update() {
-
-        this.#update_from_manager();
-
+    /**
+     * Write what {@link obtain_material} made resident or repacked since the last commit, and the media
+     * that moved. Takes none of the manager's materials, unlike {@link update}: for a reader that makes
+     * resident only what it reads.
+     */
+    commit() {
         this.#write_media();
-
-        if (this.#version === this.#version_commited) {
-            return;
-        }
-
         this.#commit();
     }
 
+    /**
+     * Make every material the manager holds resident, then {@link commit}: for the readers that trace
+     * the whole scene.
+     */
+    update() {
+        this.#update_from_manager();
+        this.commit();
+    }
+
 
     destroy() {
         this.#buffer_materials.destroy();
         this.#buffer_media.destroy();
         this.#buffer_textures.destroy();
-        this.#buffer_texture_means.destroy();
-        this.#buffer_texture_rows?.destroy();
     }
 }

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

@@ -27,21 +27,25 @@ 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, camera, input_depth, input_hzb, input_normal, input_velocity, input_occlusion, frame_index, output, resolution }: {
+    graph_pass({ graph, camera, input_depth, input_hzb, input_normal, input_normal_previous, input_velocity, input_occlusion, frame_index, output, resolution }: {
         graph: FrameGraph;
         camera: number;
         input_depth: number;
         input_hzb: number;
         input_normal: number;
+        input_normal_previous: number;
         input_velocity: number;
         input_occlusion: number;
         frame_index: number;

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

@@ -1 +1 @@
-{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAqBI;;;OAGG;IACH,uCAUC;IA5BD;;;;OAIG;IACH,eAFU,OAAO,CAEI;IAyBrB;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAd+B,KAAK;QACT,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,WAAW,EAA3B,MAAM;QAEU,MAAM,EAAtB,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACN;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA4GtE;;CACJ;8BA/KY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AASA;;GAEG;AAEH;IAqBI;;;OAGG;IACH,uCAWC;IA7BD;;;;OAIG;IACH,eAFU,OAAO,CAEI;IA0BrB;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB+B,KAAK;QACT,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,qBAAqB,EAArC,MAAM;QAEU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,WAAW,EAA3B,MAAM;QAEU,MAAM,EAAtB,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACN;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAqHtE;;CACJ;8BA3LY,OAAO,6CAA6C,EAAE,eAAe"}

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"}