@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts

@@ -1,26 +1,28 @@
 /**
  * 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}
  */
 export const MATERIAL_SEEN_BINDING: number;
 /**
  * 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}
  */

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,kDAFU,MAAM,CAqCE"}
+{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,kDAFU,MAAM,CAqCE"}

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/path_tracer/shader/INDIRECT_TEXTURE_FILTER.d.ts

@@ -4,7 +4,7 @@
  * or the other by the pipeline they are linked into.
  *
  * Whether the pass averages its reads is the pass's, so it is fixed per shader: `Stochastic`, the
- * default, for every pass that never sets it; `Exact` for the card capture, which stores each read.
+ * default, for every pass that never sets it; `Exact` for the surface caches' bake, which stores each read.
  *
  * @type {ShaderSwitch}
  */

package/src/shade/renderer/path_tracer/shader/INDIRECT_TEXTURE_FILTER.js

@@ -7,7 +7,7 @@ import { IndirectTextureFilter } from "./IndirectTextureFilter.js";
  * or the other by the pipeline they are linked into.
  *
  * Whether the pass averages its reads is the pass's, so it is fixed per shader: `Stochastic`, the
- * default, for every pass that never sets it; `Exact` for the card capture, which stores each read.
+ * default, for every pass that never sets it; `Exact` for the surface caches' bake, which stores each read.
  *
  * @type {ShaderSwitch}
  */

package/src/shade/renderer/path_tracer/shader/IndirectTextureFilter.js

@@ -10,6 +10,6 @@ export const IndirectTextureFilter = {
      * gives on average, for a pass that averages many reads into each result — the path tracer.
      */
     Stochastic: 0,
-    /** The filter itself, every tap weighed: for a pass that keeps each read as it is — the card capture. */
+    /** The filter itself, every tap weighed: for a pass that keeps each read as it is — the surface caches' bake. */
     Exact: 1,
 };

package/src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The resident material texture level a beam reads a triangle's material at: its footprint on the
+ * triangle, in texels of a slot's level 0, as `sample_material_data` and `sample_material_alpha` take
+ * their `texture_level`:
+ *
+ * ```wgsl
+ * fn beam_texture_level(triangle: TriangleVertices, along: vec3<f32>, step_u: vec3<f32>, step_v: vec3<f32>) -> f32
+ * ```
+ *
+ * The beam runs along `along` and spans `step_u` and `step_v` across, all in the triangle's space;
+ * `along` need not be unit length. Each step is carried along the beam onto the triangle's plane and
+ * through the triangle's uv per position. For a step s, direction d and normal n that is
+ * s − d (n·s)/(n·d) on the plane, taken here times n·d, so a triangle turning edge-on, whose footprint
+ * grows without bound, reaches the last level with nothing divided by 0, as a raster's would.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_beam_texture_level: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_beam_texture_level.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_beam_texture_level.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0CZ;0BA3DmB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.js

@@ -0,0 +1,65 @@
+import {
+    RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
+    RESIDENT_MATERIAL_TEXTURE_RESOLUTION
+} from "../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
+import { TRIANGLE_VERTICES_STRUCT } from "../../shader/chunk/geometry/triangle/TRIANGLE_VERTICES_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The resident material texture level a beam reads a triangle's material at: its footprint on the
+ * triangle, in texels of a slot's level 0, as `sample_material_data` and `sample_material_alpha` take
+ * their `texture_level`:
+ *
+ * ```wgsl
+ * fn beam_texture_level(triangle: TriangleVertices, along: vec3<f32>, step_u: vec3<f32>, step_v: vec3<f32>) -> f32
+ * ```
+ *
+ * The beam runs along `along` and spans `step_u` and `step_v` across, all in the triangle's space;
+ * `along` need not be unit length. Each step is carried along the beam onto the triangle's plane and
+ * through the triangle's uv per position. For a step s, direction d and normal n that is
+ * s − d (n·s)/(n·d) on the plane, taken here times n·d, so a triangle turning edge-on, whose footprint
+ * grows without bound, reaches the last level with nothing divided by 0, as a raster's would.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_beam_texture_level = CodeChunk.from(
+    //language=WGSL
+    `
+fn beam_texture_level(
+    triangle: ${TRIANGLE_VERTICES_STRUCT.wgsl_ref},
+    along: vec3<f32>,
+    step_u: vec3<f32>,
+    step_v: vec3<f32>,
+) -> f32 {
+    let edge_1 = triangle.b.position - triangle.a.position;
+    let edge_2 = triangle.c.position - triangle.a.position;
+    let normal = cross(edge_1, edge_2);
+
+    // an offset in the plane is a·edge_1 + b·edge_2, a and b its dots with these
+    let dual_1 = cross(edge_2, normal) / dot(normal, normal);
+    let dual_2 = cross(normal, edge_1) / dot(normal, normal);
+
+    let uv_1 = triangle.b.uv - triangle.a.uv;
+    let uv_2 = triangle.c.uv - triangle.a.uv;
+
+    let facing = dot(normal, along);
+
+    let on_plane_u = facing * step_u - along * dot(normal, step_u);
+    let on_plane_v = facing * step_v - along * dot(normal, step_v);
+
+    let uv_step_u = dot(on_plane_u, dual_1) * uv_1 + dot(on_plane_u, dual_2) * uv_2;
+    let uv_step_v = dot(on_plane_v, dual_1) * uv_1 + dot(on_plane_v, dual_2) * uv_2;
+
+    let span = ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}.0 * max(length(uv_step_u), length(uv_step_v));
+    let reach = abs(facing);
+
+    // a footprint of a slot or more, edge-on included, is the last level
+    return select(
+        ${RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT - 1}.0,
+        log2(max(span, reach) / reach),
+        span < ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}.0 * reach
+    );
+}
+`, [
+        TRIANGLE_VERTICES_STRUCT.declaration_chunk,
+    ]);

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}
  */