@woosh/meep-engine 3.61.3 → 3.62.0

package/src/shade/renderer/material/standard/material_gbuffer_vertex.js

@@ -1,8 +1,10 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { MATERIAL_MASK_NONE } from "../MATERIAL_MASK.js";
 
 /**
  * Group 1 binding of the material-seen bitset the shared G-buffer vertex stage reads: bit
- * `id & 31` of word `id >> 5` is set when material `id` holds a pixel of the view.
+ * `place & 31` of word `place >> 5` is set when the material at that place in the G-buffer pass's
+ * list holds a pixel of the view.
  *
  * @type {number}
  */
@@ -10,20 +12,21 @@ export const MATERIAL_SEEN_BINDING = 4;
 
 /**
  * Shared vertex stage of every material template's G-buffer pipeline: a fullscreen triangle placed
- * at depth `material.id / 2^24`, matched against the material-depth mask with `depthCompare: 'equal'`
+ * at depth `place / MATERIAL_MASK_NONE`, matched against the material mask with `depthCompare: 'equal'`
  * so the fragment stage only runs on this material's pixels.
  *
- * The material id rides in the instance index — the material pass draws `draw(3, 1, 0, id)` — so a
- * template's group 0 can be laid out however the template needs, and is visible to the fragment
- * stage alone. A direct draw's `firstInstance` needs no device feature.
+ * The material's place in the pass's list rides in the instance index — the material pass draws
+ * `draw(3, 1, 0, place)` — so a template's group 0 can be laid out however the template needs, and
+ * is visible to the fragment stage alone. A direct draw's `firstInstance` needs no device feature.
  *
  * A material that holds no pixel of the view — its bit clear in `material_seen`, of the shared group
  * 1 — gets all three corners on one point: a triangle of no area, which rasterizes nothing, so the
- * draw costs three vertex invocations rather than a fullscreen pass of depth tests. An id past the
+ * draw costs three vertex invocations rather than a fullscreen pass of depth tests. A place past the
  * end of the bitset is drawn.
  *
- * `id / 16777216` is the expression the material-depth pass writes, and a division by a power of two
- * is exact for every id below 2^24, so the two meet at depth-equal.
+ * `place / MATERIAL_MASK_NONE` is the expression the material-depth pass writes, and both are
+ * quantised to the same 16-bit code for every place below MATERIAL_MASK_NONE, so the two meet at
+ * depth-equal.
  *
  * @type {string}
  */
@@ -45,20 +48,20 @@ struct VertexOutput {
 @vertex
 fn main(
   @builtin(vertex_index) id : u32,
-  @builtin(instance_index) material_id : u32,
+  @builtin(instance_index) place : u32,
 ) -> VertexOutput {
 
   var out: VertexOutput;
 
-  let word = material_id >> 5u;
+  let word = place >> 5u;
 
-  // an id past the bitset was not counted, so it is drawn as though seen
+  // a place past the bitset was not counted, so it is drawn as though seen
   let seen = word >= arrayLength(&material_seen)
-    || (material_seen[word] & (1u << (material_id & 31u))) != 0u;
+    || (material_seen[word] & (1u << (place & 31u))) != 0u;
 
   let ndc = select(pos[0], pos[id], seen);
 
-  out.position = vec4<f32>(ndc, f32(material_id)/16777216 , 1.0);
+  out.position = vec4<f32>(ndc, f32(place) / ${MATERIAL_MASK_NONE}.0, 1.0);
 
   return out;
 }

package/src/shade/renderer/material/template/ShadeMaterialTemplate.d.ts

@@ -9,7 +9,7 @@
  *
  * **Group 0 is the template's.** It is declared with fragment visibility, and one bind group per
  * material built on it serves the G-buffer pass and both alpha-tested passes. Groups 1 and 2 belong
- * to the passes, so a template must not reuse their names (`viz_buffer_triangle`, `viz_buffer_mesh`,
+ * to the passes, so a template must not reuse their names (`visibility`, `visible_meshlets`,
  * `view`, `camera`, `scene_database`, `geometries`, `meshlets`, `meshlet_metadata`, `meshlet_data`,
  * `materials`, `t_noise`) — nor those of the experimental compute material dispatch, which
  * assembles a laydown of its own around {@link gbuffer_surface} (`material_quads`, `g_buffer_pbr`,

package/src/shade/renderer/material/template/ShadeMaterialTemplate.js

@@ -25,7 +25,7 @@ let ordinal_counter = 0;
  *
  * **Group 0 is the template's.** It is declared with fragment visibility, and one bind group per
  * material built on it serves the G-buffer pass and both alpha-tested passes. Groups 1 and 2 belong
- * to the passes, so a template must not reuse their names (`viz_buffer_triangle`, `viz_buffer_mesh`,
+ * to the passes, so a template must not reuse their names (`visibility`, `visible_meshlets`,
  * `view`, `camera`, `scene_database`, `geometries`, `meshlets`, `meshlet_metadata`, `meshlet_data`,
  * `materials`, `t_noise`) — nor those of the experimental compute material dispatch, which
  * assembles a laydown of its own around {@link gbuffer_surface} (`material_quads`, `g_buffer_pbr`,

package/src/shade/renderer/postprocess/denoise/LigmaDenoiser.d.ts

@@ -27,7 +27,9 @@ export class LigmaDenoiser {
      * @param {number} options.frame_index
      * @param {number} options.input_current_depth
      * @param {number} options.input_previous_depth
-     * @param {number} options.input_current_normal
+     * @param {number} options.input_current_normal the G-buffer's shading normal, for the spatial filter
+     * @param {number} options.input_current_pbr the G-buffer's PBR target, for the face normal the temporal
+     *   reprojection weighs history by
      * @param {number} options.input_velocity
      * @param {number} options.input_mip_level
      * @param {number} options.input
@@ -38,12 +40,13 @@ export class LigmaDenoiser {
      * @param {number[]} options.resolution
      * @param {boolean} [options.denoise_spatial] should spatial denoising be applied?
      */
-    execute({ graph, frame_index, input_current_depth, input_previous_depth, input_current_normal, input_velocity, input_mip_level, input, camera_current, camera_previous, input_occlusion, jitter, resolution, denoise_spatial }: {
+    execute({ graph, frame_index, input_current_depth, input_previous_depth, input_current_normal, input_current_pbr, input_velocity, input_mip_level, input, camera_current, camera_previous, input_occlusion, jitter, resolution, denoise_spatial }: {
         graph: FrameGraph;
         frame_index: number;
         input_current_depth: number;
         input_previous_depth: number;
         input_current_normal: number;
+        input_current_pbr: number;
         input_velocity: number;
         input_mip_level: number;
         input: number;

package/src/shade/renderer/postprocess/denoise/LigmaDenoiser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LigmaDenoiser.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/LigmaDenoiser.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IASI;;;OAGG;IACH,sCAYC;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,yBAHW,MAAM,qBAOhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH;QAf+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,KAAK,EAArB,MAAM;QACoB,cAAc;QACd,eAAe;QACzB,eAAe,EAA/B,MAAM;QACY,MAAM,EAAxB,MAAM,EAAE;QACU,UAAU,EAA5B,MAAM,EAAE;QACU,eAAe,GAAjC,OAAO;YA0IjB;;CACJ"}
+{"version":3,"file":"LigmaDenoiser.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/LigmaDenoiser.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IASI;;;OAGG;IACH,sCAYC;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,yBAHW,MAAM,qBAOhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,iBAAiB,EAAjC,MAAM;QAEU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,KAAK,EAArB,MAAM;QACoB,cAAc;QACd,eAAe;QACzB,eAAe,EAA/B,MAAM;QACY,MAAM,EAAxB,MAAM,EAAE;QACU,UAAU,EAA5B,MAAM,EAAE;QACU,eAAe,GAAjC,OAAO;YA2IjB;;CACJ"}

package/src/shade/renderer/postprocess/denoise/LigmaDenoiser.js

@@ -71,7 +71,9 @@ export class LigmaDenoiser {
      * @param {number} options.frame_index
      * @param {number} options.input_current_depth
      * @param {number} options.input_previous_depth
-     * @param {number} options.input_current_normal
+     * @param {number} options.input_current_normal the G-buffer's shading normal, for the spatial filter
+     * @param {number} options.input_current_pbr the G-buffer's PBR target, for the face normal the temporal
+     *   reprojection weighs history by
      * @param {number} options.input_velocity
      * @param {number} options.input_mip_level
      * @param {number} options.input
@@ -88,6 +90,7 @@ export class LigmaDenoiser {
                 input_current_depth,
                 input_previous_depth,
                 input_current_normal,
+                input_current_pbr,
                 input_velocity,
                 input_mip_level = 0,
                 input,
@@ -132,7 +135,7 @@ export class LigmaDenoiser {
             const depth_current = resources.get(data.depth_current);
             const depth_previous = resources.get(data.depth_previous);
             const history = resources.get(data.history);
-            const normal = resources.get(data.normal);
+            const pbr = resources.get(data.pbr);
             const input_occlusion = resources.get(data.input_occlusion);
 
             const out = resources.get(data.output);
@@ -156,7 +159,7 @@ export class LigmaDenoiser {
                     VelocityBuffer: velocity.obtainView(input_view_descriptor),
                     DepthBuffer: depth_current.obtainView(input_view_descriptor),
                     PrevDepthBuffer: depth_previous.obtainView(input_view_descriptor),
-                    NormalBuffer: normal.obtainView(input_view_descriptor),
+                    PBRBuffer: pbr.obtainView(input_view_descriptor),
                     Jitter: jitter_buffer,
                     tOcclusion: input_occlusion.obtainView(input_view_descriptor),
                     camera_current: camera_current.buffer,
@@ -187,7 +190,7 @@ export class LigmaDenoiser {
         reprojection_data.depth_current = reprojection_builder.read(input_current_depth);
         reprojection_data.velocity = reprojection_builder.read(input_velocity);
         reprojection_data.depth_previous = reprojection_builder.read(input_previous_depth);
-        reprojection_data.normal = reprojection_builder.read(input_current_normal);
+        reprojection_data.pbr = reprojection_builder.read(input_current_pbr);
         reprojection_data.history = reprojection_builder.read(gr_history);
         reprojection_data.input_occlusion = reprojection_builder.read(input_occlusion);
         reprojection_data.output = reprojection_builder.write(gr_output);

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.d.ts

@@ -4,18 +4,18 @@
  * @param {FrameGraph} options.graph
  * @param {number} options.input_current_depth
  * @param {number} options.input_previous_depth
- * @param {number} options.input_current_normal
+ * @param {number} options.input_current_pbr the G-buffer's PBR target, for its face normal
  * @param {number} options.input_velocity
  * @param {GPUCameraContext} options.camera_current
  * @param {GPUCameraContext} options.camera_previous
  * @param {number[]} options.jitter
  * @param {number[]} options.resolution
  */
-export function graph_pass_debug_reprojection({ graph, input_current_depth, input_previous_depth, input_current_normal, input_velocity, camera_current, camera_previous, jitter, resolution }: {
+export function graph_pass_debug_reprojection({ graph, input_current_depth, input_previous_depth, input_current_pbr, input_velocity, camera_current, camera_previous, jitter, resolution }: {
     graph: FrameGraph;
     input_current_depth: number;
     input_previous_depth: number;
-    input_current_normal: number;
+    input_current_pbr: number;
     input_velocity: number;
     camera_current: GPUCameraContext;
     camera_previous: GPUCameraContext;

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_pass_debug_reprojection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;GAYG;AACH;IAV+B,KAAK;IACT,mBAAmB,EAAnC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,cAAc,EAA9B,MAAM;IACoB,cAAc;IACd,eAAe;IACvB,MAAM,EAAxB,MAAM,EAAE;IACU,UAAU,EAA5B,MAAM,EAAE;QAyGlB"}
+{"version":3,"file":"graph_pass_debug_reprojection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js"],"names":[],"mappings":"AA4FA;;;;;;;;;;;;GAYG;AACH;IAV+B,KAAK;IACT,mBAAmB,EAAnC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,iBAAiB,EAAjC,MAAM;IACU,cAAc,EAA9B,MAAM;IACoB,cAAc;IACd,eAAe;IACvB,MAAM,EAAxB,MAAM,EAAE;IACU,UAAU,EAA5B,MAAM,EAAE;QAyGlB"}

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js

@@ -5,7 +5,9 @@ import { TextureBindingLayout } from "../../../../descriptor/binding/TextureBind
 import { ComputePipelineDescriptor } from "../../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
 import { TextureResourceDescriptor } from "../../../../device/graph/TextureResourceDescriptor.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { draw_texture_as_rgba } from "../../../texture/draw_texture_as_rgba.js";
 import { chunk_compute_reprojection_weight } from "../chunk_compute_reprojection_weight.js";
@@ -22,7 +24,7 @@ const NUM_THREADS_Y = 8;
 @group(1) @binding(0) var VelocityBuffer: texture_2d<f32>;
 @group(1) @binding(1) var DepthBuffer: texture_2d<f32>;
 @group(1) @binding(2) var PrevDepthBuffer: texture_2d<f32>;
-@group(1) @binding(3) var NormalBuffer: texture_2d<u32>;
+@group(1) @binding(3) var PBRBuffer: texture_2d<f32>;
 @group(1) @binding(4) var<uniform> Jitter: vec2<f32>;
 @group(1) @binding(5) var<uniform> camera_current: ${CAMERA_UNIFORM_STRUCT.wgsl_ref};
 @group(1) @binding(6) var<uniform> camera_previous: ${CAMERA_UNIFORM_STRUCT.wgsl_ref};
@@ -44,7 +46,7 @@ fn main(
     
     let previous_coord = current_coord_f - velocity.xy;
 
-    let normal = decode_g_buffer_normal( textureLoad(NormalBuffer, current_coord, 0).zw );
+    let normal = decode_g_buffer_face_normal( textureLoad(PBRBuffer, current_coord, 0) );
         
     let texel = compute_reprojection_weight(
         current_coord_f,
@@ -62,7 +64,7 @@ fn main(
 `,[
     chunk_compute_reprojection_weight,
         CAMERA_UNIFORM_STRUCT.declaration_chunk,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
     ]).compile().text;
 
 const pipeline_descriptor = ComputePipelineDescriptor.simplified({
@@ -80,7 +82,7 @@ const pipeline_descriptor = ComputePipelineDescriptor.simplified({
             TextureBindingLayout.unfilterableFloat,
             TextureBindingLayout.unfilterableFloat,
             TextureBindingLayout.unfilterableFloat,
-            TextureBindingLayout.uint,
+            TextureBindingLayout.unfilterableFloat,
             BufferBindingLayout.uniform,
             BufferBindingLayout.uniform,
             BufferBindingLayout.uniform,
@@ -94,7 +96,7 @@ const pipeline_descriptor = ComputePipelineDescriptor.simplified({
  * @param {FrameGraph} options.graph
  * @param {number} options.input_current_depth
  * @param {number} options.input_previous_depth
- * @param {number} options.input_current_normal
+ * @param {number} options.input_current_pbr the G-buffer's PBR target, for its face normal
  * @param {number} options.input_velocity
  * @param {GPUCameraContext} options.camera_current
  * @param {GPUCameraContext} options.camera_previous
@@ -105,7 +107,7 @@ export function graph_pass_debug_reprojection({
                                                   graph,
                                                   input_current_depth,
                                                   input_previous_depth,
-                                                  input_current_normal,
+                                                  input_current_pbr,
                                                   input_velocity,
                                                   camera_current,
                                                   camera_previous,
@@ -129,7 +131,7 @@ export function graph_pass_debug_reprojection({
         const velocity = resources.get(data.velocity);
         const depth_current = resources.get(data.depth_current);
         const depth_previous = resources.get(data.depth_previous);
-        const normal = resources.get(data.normal);
+        const pbr = resources.get(data.pbr);
 
         const out = resources.get(data.output);
 
@@ -145,7 +147,7 @@ export function graph_pass_debug_reprojection({
                     velocity.obtainView(),
                     depth_current.obtainView(),
                     depth_previous.obtainView(),
-                    normal.obtainView(),
+                    pbr.obtainView(),
                     { buffer: jitter_buffer },
                     { buffer: camera_current.gpu_buffer },
                     { buffer: camera_previous.gpu_buffer },
@@ -168,7 +170,7 @@ export function graph_pass_debug_reprojection({
     reprojection_data.depth_current = reprojection_builder.read(input_current_depth);
     reprojection_data.velocity = reprojection_builder.read(input_velocity);
     reprojection_data.depth_previous = reprojection_builder.read(input_previous_depth);
-    reprojection_data.normal = reprojection_builder.read(input_current_normal);
+    reprojection_data.pbr = reprojection_builder.read(input_current_pbr);
     reprojection_data.history = reprojection_builder.create("fake history", TextureResourceDescriptor.from({
         resolution,
         format: "rgba8unorm",

package/src/shade/renderer/postprocess/denoise/fragment_shader_denoise_ao.js

@@ -59,7 +59,7 @@ fn main(
     var sum_visibility   = center_visibility;
     
     
-    let current_normal = decode_g_buffer_normal(textureLoad(tNormal, ipos, 0).xy);
+    let current_normal = decode_g_buffer_normal(textureLoad(tNormal, ipos, 0).x);
     let center_depth   = textureLoad(tDepth, ipos, 0).r;
     
     const offsets = array< vec2<i32>,8>(
@@ -92,7 +92,7 @@ fn main(
         
         let sample_visibility = textureLoad(tInput, p, 0).rg;
 
-        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).x);
         let sample_depth  = textureLoad(tDepth, p, 0).r;
 
         // compute the edge-stopping functions

package/src/shade/renderer/postprocess/denoise/shader_temporal_reprojection_luma.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_temporal_reprojection_luma.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/shader_temporal_reprojection_luma.js"],"names":[],"mappings":"AAkSA;;;GAGG;AACH,8DAII;8BA3R0B,+BAA+B"}
+{"version":3,"file":"shader_temporal_reprojection_luma.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/denoise/shader_temporal_reprojection_luma.js"],"names":[],"mappings":"AAoSA;;;GAGG;AACH,8DAII;8BA3R0B,+BAA+B"}

package/src/shade/renderer/postprocess/denoise/shader_temporal_reprojection_luma.js

@@ -1,6 +1,8 @@
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
-import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
 import {
     chunk_texture_sample_bilinear_exact
@@ -33,7 +35,7 @@ resources.createGroup()
     .addTexture("VelocityBuffer")
     .addTexture("DepthBuffer")
     .addTexture("PrevDepthBuffer")
-    .addTexture("NormalBuffer", "uint")
+    .addTexture("PBRBuffer")
     .addTexture("tOcclusion")
     .addUniform("Jitter","vec2<f32>")
     .addUniform("camera_current",CAMERA_UNIFORM_STRUCT)
@@ -184,7 +186,7 @@ fn main(
         // 0.5 to account for texel center offset
         let previous_coord = current_coord_f - velocity.xy - Jitter;
     
-        let normal = decode_g_buffer_normal( textureLoad(NormalBuffer, current_coord, 0).zw );
+        let normal = decode_g_buffer_face_normal( textureLoad(PBRBuffer, current_coord, 0) );
     
         let reprojection_confidence = textureLoad(tOcclusion, current_coord, 0).r;
         
@@ -276,7 +278,7 @@ fn main(
 
 `, [
 
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_clip_history_colour_YCoCg,
         chunk_texture_sample_red_min_st,
         chunk_taa_get_velocity,

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

@@ -26,9 +26,10 @@ export class GTAO {
      * @param {number} options.camera this frame's camera uniform
      * @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_normal the G-buffer's shading normal
+     * @param {number} options.input_pbr the G-buffer's PBR target, for the face normal it holds
+     * @param {number} options.input_pbr_previous last frame's PBR target, at the size last frame was drawn
+     *   at: its face normal says 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
@@ -36,16 +37,17 @@ export class GTAO {
      * @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 and
-     *   bend (`rgba16float`), `output` after the composite, and the accumulated bent normals, octahedral in
-     *   `rg16uint` as `input_normal` is
+     *   bend (`rgba16float`), `output` after the composite, and the accumulated bent normals, packed
+     *   into an `r32uint` as `input_normal` is
      */
-    graph_pass({ graph, camera, input_depth, input_hzb, input_normal, input_normal_previous, input_velocity, input_occlusion, frame_index, output, resolution }: {
+    graph_pass({ graph, camera, input_depth, input_hzb, input_normal, input_pbr, input_pbr_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_pbr: number;
+        input_pbr_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":"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"}
+{"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;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAlB+B,KAAK;QACT,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,kBAAkB,EAAlC,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,CAuHtE;;CACJ;8BA9LY,OAAO,6CAA6C,EAAE,eAAe"}

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

@@ -68,9 +68,10 @@ export class GTAO {
      * @param {number} options.camera this frame's camera uniform
      * @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_normal the G-buffer's shading normal
+     * @param {number} options.input_pbr the G-buffer's PBR target, for the face normal it holds
+     * @param {number} options.input_pbr_previous last frame's PBR target, at the size last frame was drawn
+     *   at: its face normal says 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
@@ -78,8 +79,8 @@ export class GTAO {
      * @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 and
-     *   bend (`rgba16float`), `output` after the composite, and the accumulated bent normals, octahedral in
-     *   `rg16uint` as `input_normal` is
+     *   bend (`rgba16float`), `output` after the composite, and the accumulated bent normals, packed
+     *   into an `r32uint` as `input_normal` is
      */
     graph_pass({
                    graph,
@@ -87,7 +88,8 @@ export class GTAO {
                    input_depth,
                    input_hzb,
                    input_normal,
-                   input_normal_previous,
+                   input_pbr,
+                   input_pbr_previous,
                    input_velocity,
                    input_occlusion,
                    frame_index,
@@ -112,7 +114,7 @@ export class GTAO {
         let bent_normals = graph.create_resource("bent normals", TextureResourceDescriptor.from({
             resolution,
             dimension: "2d",
-            format: "rg16uint",
+            format: "r32uint",
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT
         }));
 
@@ -166,7 +168,8 @@ export class GTAO {
                 tVelocity: input_velocity,
                 tOcclusion: input_occlusion,
                 tNormal: input_normal,
-                tNormalPrevious: input_normal_previous,
+                tPBR: input_pbr,
+                tPBRPrevious: input_pbr_previous,
                 settings: {
                     history_validity: history_valid ? 1 : 0,
                     frame_index,

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

@@ -2,13 +2,13 @@
  * 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.
+ * `tPBRPrevious` — last frame's G-buffer PBR target — 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.
+ * `normalize(shading normal + bend)`, packed into an `r32uint` as the G-buffer's shading normal is, which is what
+ * lighting reads.
  *
  * @type {ImageShader}
  */

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":"AAwRA;;;;;;;;;;;;;GAaG;AACH,kCAFU,WAAW,CAqBnB;4BA9S0B,6BAA6B"}
+{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AA6RA;;;;;;;;;;;;;GAaG;AACH,kCAFU,WAAW,CAqBnB;4BAhT0B,6BAA6B"}

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

@@ -1,5 +1,8 @@
 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_decode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_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";
@@ -39,8 +42,10 @@ resources.createGroup()
     .addTexture("tVelocity")
     .addTexture("tOcclusion")
     .addTexture("tNormal", "uint")
-    // last frame's G-buffer normal, at the size last frame was drawn at
-    .addTexture("tNormalPrevious", "uint")
+    // the G-buffer's PBR target, for its face normal: this frame's, and last frame's at the size it was
+    // drawn at
+    .addTexture("tPBR")
+    .addTexture("tPBRPrevious")
     .addTexture("tHistory","float")
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
 
@@ -102,7 +107,7 @@ 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);
+    let history_face_normal = decode_g_buffer_face_normal(textureLoad(tPBRPrevious, clamp(tap, vec2(0), size - 1), 0));
 
     return select(0.0, 1.0, dot(history_face_normal, face_normal) >= SAME_SURFACE_COS);
 }
@@ -110,7 +115,7 @@ fn history_texel_on_surface(tap: vec2<i32>, size: vec2<i32>, face_normal: vec3<f
 // 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 size = vec2<i32>(textureDimensions(tPBRPrevious));
 
     let st = prev_uv * vec2<f32>(size) - 0.5;
     let origin = vec2<i32>(floor(st));
@@ -137,7 +142,7 @@ 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>,
+    @location(1) bent_normal: u32,
 }
 
 @fragment
@@ -151,8 +156,7 @@ fn main(
 
     let occlusion_confidence = textureLoad(tOcclusion, screenST, 0).r;
     let current = textureLoad(tInput, screenST, 0);
-    let encoded_normal = textureLoad(tNormal, screenST, 0);
-    let shading_normal = decode_g_buffer_normal(encoded_normal.xy);
+    let shading_normal = decode_g_buffer_normal(textureLoad(tNormal, screenST, 0).x);
 
     // get velocity
     let velocity = taa_get_velocity( tVelocity, screenST );
@@ -233,7 +237,7 @@ fn main(
         // 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));
+        let surface_agreement = history_surface_agreement(prev_uv, decode_g_buffer_face_normal(textureLoad(tPBR, screenST, 0)));
 
         resolved = vec4(
             mix(current.x, clamped_visibility, history_weight),
@@ -271,6 +275,7 @@ fn main(
         chunk_texture_sample_catmullrom_hardware_5tap_uv,
         chunk_get_std_dev,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_encode_g_buffer_normal,
         chunk_f16_round_stochastic,
         chunk_pcg3d,
@@ -282,13 +287,13 @@ fn main(
  * 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.
+ * `tPBRPrevious` — last frame's G-buffer PBR target — 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.
+ * `normalize(shading normal + bend)`, packed into an `r32uint` as the G-buffer's shading normal is, which is what
+ * lighting reads.
  *
  * @type {ImageShader}
  */
@@ -308,7 +313,7 @@ export const ao_reproject_shader = new ImageShader({
         },
         {
             label: "Bent Normals",
-            format: "rg16uint",
+            format: "r32uint",
         },
     ]
 })

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

@@ -24,7 +24,7 @@ fn horizon_integrate_lighting_sample(
     let tex_coord = uv_to_texel_coordinate(uv, textureDimensions(tNormal).xy);
     let tex_coord_i = vec2<i32>(tex_coord);
 
-    let sample_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, tex_coord_i, 0).xy);
+    let sample_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, tex_coord_i, 0).x);
     
     let cos_vis = dot(ref_normal, sample_normal_ws);
     

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

@@ -131,7 +131,7 @@ fn main(
     let position_vs = project_view_position_from_depth(uv, device_depth, camera.projection_matrix_inverse);
     let view_direction_vs = normalize(-position_vs);
 
-    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).xy); // shading normal
+    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).x); // shading normal
 
     let noiseTexel = spatio_temporal_noise_r2_64(texel_position_u32, settings.frame_index, tNoise);
         

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

@@ -76,7 +76,7 @@ const STEPS = ${QUALITY_SETTINGS.steps};
 
 struct Output{
     @location(0) visibility: vec2<f32>, // first 2 moment
-    @location(1) bent_normal: vec2<u32>, // octahedral encoding
+    @location(1) bent_normal: u32, // octahedral, packed (encode_g_buffer_normal)
     @location(2) irradiance: u32, // rgbe9995
 }
 
@@ -111,7 +111,7 @@ fn main(
     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_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).x); // shading normal
 
     let noiseTexel = spatio_temporal_noise_r2_64(texel_position_u32, settings.frame_index, tNoise);
         
@@ -418,8 +418,8 @@ export const fragment_shader_gtao_with_irradiance = new ImageShader({
         },
         {
             label: "Bent Normals",
-            // Direction is encoded with octahedral
-            format: "rg16uint",
+            // Direction is encoded with octahedral, packed (encode_g_buffer_normal)
+            format: "r32uint",
         },
         {
             label: "Irradiance",