@woosh/meep-engine 3.60.5 → 3.60.6

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.d.ts

@@ -9,7 +9,8 @@
  *   `GPU_DATABASE_NULL` until then and for a row out of the SDF world.
  *
  * A row is in the SDF world when its `flags` carry `MESH_FLAG_SDF_WORLD`, whatever its geometry: a
- * virtual geometry's cache is held as a mesh's is, and comes from its own source (`VGeoSDFProxies`).
+ * virtual geometry's cache is held as a mesh's is, and is its proxy's once `VGeoSDFProxies` aliases it: the
+ * hold and its side move to the proxy, and the pair's card set captures the proxy's layout.
  * A skinned row draws a clone: the hold and the pair are its source's,
  * whose unskinned field and cards the clone's header is aliased to (§6.3). A row written again moves
  * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA1mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;iCACvD,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,0BAA0B,EAAE,eAAe"}
+{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA3mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;iCACvD,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,0BAA0B,EAAE,eAAe"}

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js

@@ -65,7 +65,8 @@ class Pair {
  *   `GPU_DATABASE_NULL` until then and for a row out of the SDF world.
  *
  * A row is in the SDF world when its `flags` carry `MESH_FLAG_SDF_WORLD`, whatever its geometry: a
- * virtual geometry's cache is held as a mesh's is, and comes from its own source (`VGeoSDFProxies`).
+ * virtual geometry's cache is held as a mesh's is, and is its proxy's once `VGeoSDFProxies` aliases it: the
+ * hold and its side move to the proxy, and the pair's card set captures the proxy's layout.
  * A skinned row draws a clone: the hold and the pair are its source's,
  * whose unskinned field and cards the clone's header is aliased to (§6.3). A row written again moves
  * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.d.ts

@@ -10,8 +10,8 @@
  * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
  * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
  * its source's, the hook), and its box resolves in the cascade (`brick_provider_resolves`). A virtual
- * geometry's field is the one baked for its proxy and adopted into it (§7.8), so its rows are taken as
- * a mesh's are, once it is resident.
+ * geometry's header is an alias of its proxy's (§7.8), so its rows are taken as a mesh's are, once the
+ * proxy's field is resident.
  *
  * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
  * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.js

@@ -19,8 +19,8 @@ import { MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
  * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
  * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
  * its source's, the hook), and its box resolves in the cascade (`brick_provider_resolves`). A virtual
- * geometry's field is the one baked for its proxy and adopted into it (§7.8), so its rows are taken as
- * a mesh's are, once it is resident.
+ * geometry's header is an alias of its proxy's (§7.8), so its rows are taken as a mesh's are, once the
+ * proxy's field is resident.
  *
  * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
  * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,

package/src/shade/renderer/material/GPUMaterialManager.d.ts

@@ -38,13 +38,16 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} options.view
      * @param {number} options.texture_viz_mesh
      * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
-    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, }: {
+    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, texture_normal, }: {
         graph: FrameGraph;
         view: GPUViewContext;
         texture_viz_mesh: number;
         texture_viz_triangle: number;
+        texture_normal: number;
     }): {
         g_pbr: number;
         g_normal: number;

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAr4BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA4LnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAl4BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -467,6 +467,8 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} options.view
      * @param {number} options.texture_viz_mesh
      * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
     graph_viz_render({
@@ -474,9 +476,11 @@ export class GPUMaterialManager {
                          view,
                          texture_viz_mesh,
                          texture_viz_triangle,
+                         texture_normal,
                      }) {
 
         assert.defined(graph, 'graph');
+        assert.isNonNegativeInteger(texture_normal, 'texture_normal');
         assert.defined(view, 'view');
 
         /**
@@ -620,14 +624,7 @@ export class GPUMaterialManager {
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
             })
         );
-        pass_data.g_normal = pass.create(
-            "g-buffer / Normal",
-            TextureResourceDescriptor.from({
-                format: 'rgba16uint',
-                resolution: view.resolution,
-                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
-            })
-        );
+        pass_data.g_normal = pass.write(texture_normal);
         pass_data.g_albedo = pass.create(
             "g-buffer / Albedo",
             TextureResourceDescriptor.from({

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