@woosh/meep-engine 3.61.3 → 3.62.0

package/src/shade/renderer/shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js

@@ -13,7 +13,14 @@ export const SCREEN_DEPTH_RESOURCE = ShaderResourceDescriptor.texture("tDepth");
 export const SCREEN_HZB_RESOURCE = ShaderResourceDescriptor.texture("tHZB");
 
 /**
- * The scene's normals, encoded.
+ * The scene's shading normal, encoded (`decode_g_buffer_normal`).
  * @type {ShaderResourceDescriptor}
  */
 export const SCREEN_NORMAL_RESOURCE = ShaderResourceDescriptor.texture("tNormal", "uint");
+
+/**
+ * The G-buffer's PBR target, for the face normal it holds (`decode_g_buffer_face_normal`): the plane of the
+ * triangle a pixel shows.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCREEN_PBR_RESOURCE = ShaderResourceDescriptor.texture("tPBR");

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_load_world_space_normal.js

@@ -7,7 +7,7 @@ export const chunk_ffx_sssr_load_world_space_normal = CodeChunk.from(
     `
 fn ffx_sssr_load_world_space_normal(texel_coord: vec2<i32>)-> vec3<f32>{
     // Using shading normal
-    return decode_g_buffer_normal( textureLoad(tNormal, texel_coord, 0).xy );
+    return decode_g_buffer_normal( textureLoad(tNormal, texel_coord, 0).x );
 }    
     `, [
         chunk_decode_g_buffer_normal

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.js

@@ -1,6 +1,6 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_is_background } from "../depth/chunk_is_background.js";
-import { chunk_decode_g_buffer_normal } from "../geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_decode_g_buffer_face_normal } from "../geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_plane_from_normal_and_point } from "../geometry/plane/chunk_plane_from_normal_and_point.js";
 import { chunk_plane_ray_raycast } from "../geometry/plane/chunk_plane_ray_raycast.js";
 import { RAY_STRUCT } from "../geometry/ray/RAY_STRUCT.js";
@@ -35,10 +35,10 @@ struct ScreenSpaceRayReceiver {
     plane: vec4<f32>,
 }
 
-// One G-buffer fetch. Depth is stored at the texel center; .zw is the geometric
-// face normal, while .xy includes material normal mapping.
+// One G-buffer texel: its depth, stored at the texel center, and its face normal, read from the PBR
+// target. The shading normal includes material normal mapping and is not the surface's plane.
 fn screen_space_ray_load_receiver(
-    uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    uv: vec2<f32>, depth: texture_2d<f32>, pbr: texture_2d<f32>,
     inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
 ) -> ScreenSpaceRayReceiver {
     let size = textureDimensions(depth, 0);
@@ -46,7 +46,7 @@ fn screen_space_ray_load_receiver(
     let d = textureLoad(depth, coord, 0).r;
     let center = (vec2<f32>(coord) + 0.5) / vec2<f32>(size);
     let position = inv_project_position(vec3<f32>(center, d), inverse_projection);
-    let normal = (world_to_view * vec4<f32>(decode_g_buffer_normal(textureLoad(normals, coord, 0).zw), 0.0)).xyz;
+    let normal = (world_to_view * vec4<f32>(decode_g_buffer_face_normal(textureLoad(pbr, coord, 0)), 0.0)).xyz;
     return ScreenSpaceRayReceiver(d, plane_from_normal_and_point(normal, position));
 }
 
@@ -86,12 +86,12 @@ fn screen_space_ray_accept(
 }
 
 fn screen_space_ray_validate(
-    ray: Ray, uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    ray: Ray, uv: vec2<f32>, depth: texture_2d<f32>, pbr: texture_2d<f32>,
     projection: mat4x4<f32>, inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
     distance_tolerance: f32,
 ) -> ScreenSpaceRayHit {
     if (!screen_space_ray_in_bounds(uv)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, 0u, 1u); }
-    let receiver = screen_space_ray_load_receiver(uv, depth, normals, inverse_projection, world_to_view);
+    let receiver = screen_space_ray_load_receiver(uv, depth, pbr, inverse_projection, world_to_view);
     if (is_background(receiver.depth)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, 0u, 2u); }
     return screen_space_ray_accept(ray, uv, receiver, vec2<f32>(textureDimensions(depth, 0)),
         projection, inverse_projection, distance_tolerance);
@@ -100,7 +100,7 @@ fn screen_space_ray_validate(
 // One G-buffer fetch per lookup, as in the paper: the plane that rejects lookup n
 // is also the tangent plane of update n+1. max_updates updates read max_updates+1 texels.
 fn screen_space_newton_ray(
-    ray: Ray, seed_uv: vec2<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
+    ray: Ray, seed_uv: vec2<f32>, depth: texture_2d<f32>, pbr: texture_2d<f32>,
     projection: mat4x4<f32>, inverse_projection: mat4x4<f32>, world_to_view: mat4x4<f32>,
     max_updates: u32, distance_tolerance: f32,
 ) -> ScreenSpaceRayHit {
@@ -112,7 +112,7 @@ fn screen_space_newton_ray(
     for (var i = 0u; i <= updates; i++) {
         let iterations = max(i, 1u);
         if (!screen_space_ray_in_bounds(uv)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, iterations, 1u); }
-        let receiver = screen_space_ray_load_receiver(uv, depth, normals, inverse_projection, world_to_view);
+        let receiver = screen_space_ray_load_receiver(uv, depth, pbr, inverse_projection, world_to_view);
         if (is_background(receiver.depth)) { return ScreenSpaceRayHit(uv, 0.0, 1e20, iterations, 2u); }
         // The seed is the undisplaced background, not an update; only updated lookups are accepted.
         if (i > 0u) {
@@ -130,6 +130,6 @@ fn screen_space_newton_ray(
     }
     return hit;
 }
-`, [RAY_STRUCT.declaration_chunk, chunk_is_background, chunk_decode_g_buffer_normal,
+`, [RAY_STRUCT.declaration_chunk, chunk_is_background, chunk_decode_g_buffer_face_normal,
     chunk_plane_from_normal_and_point, chunk_plane_ray_raycast, chunk_ray_at,
     chunk_ray_nearest_point, chunk_inv_project_position, chunk_project_position]);

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts

@@ -28,6 +28,14 @@ export class RenderPassDescriptor {
      * @type {RenderPassDepthStencilAttachmentDescriptor}
      */
     depthStencilAttachment: RenderPassDepthStencilAttachmentDescriptor;
+    /**
+     * Whether the pipeline writes each draw's `instance_index` as a slot of the frame's visible-meshlet
+     * table, as the visibility raster does: a draw under it must take its meshlets from that table — see
+     * `graph_meshlets_rasterize`.
+     *
+     * @type {boolean}
+     */
+    visible_meshlet_slots: boolean;
     /**
      * @param {Object} options
      * @param {GPUTextureContext[]} [options.colorTargets]

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;;;;;OAMG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAElB;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;;OAWG;IACH;QAVyC,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACnB,MAAM;QACL,OAAO;QACR,WAAW;QACV,YAAY;QACb,WAAW;QACV,YAAY;gCAwE3C;IAED;;;;;;;;;;;OAWG;IACH;QAT2C,OAAO;QACT,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACtB,QAAQ;QACA,eAAe;QACpB,MAAM;QACL,OAAO;kCAuCtC;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACpB,OAAO;QACT,cAAc,GAA/B,MAAM;QACW,QAAQ;QACH,aAAa;aAgB7C;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DAnM0D,iDAAiD"}
+{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;;;;;OAMG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAElB;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAE1E;;;;;;OAMG;IACH,uBAFU,OAAO,CAEa;IAG9B;;;;;;;;;;;OAWG;IACH;QAVyC,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACnB,MAAM;QACL,OAAO;QACR,WAAW;QACV,YAAY;QACb,WAAW;QACV,YAAY;gCAwE3C;IAED;;;;;;;;;;;OAWG;IACH;QAT2C,OAAO;QACT,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACtB,QAAQ;QACA,eAAe;QACpB,MAAM;QACL,OAAO;kCAuCtC;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACpB,OAAO;QACT,cAAc,GAA/B,MAAM;QACW,QAAQ;QACH,aAAa;aAgB7C;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DA5M0D,iDAAiD"}

package/src/shade/renderer/shader/pass/RenderPassDescriptor.js

@@ -37,6 +37,15 @@ export class RenderPassDescriptor {
      */
     depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
 
+    /**
+     * Whether the pipeline writes each draw's `instance_index` as a slot of the frame's visible-meshlet
+     * table, as the visibility raster does: a draw under it must take its meshlets from that table — see
+     * `graph_meshlets_rasterize`.
+     *
+     * @type {boolean}
+     */
+    visible_meshlet_slots = false;
+
 
     /**
      * @param {Object} options

package/src/shade/renderer/shader/util/shader_decode_octahedral_normal.js

@@ -18,7 +18,7 @@ fn main(
 ) -> @location(0) vec4<f32>{
     let texel = textureLoad(tInput, vec2u(coord.xy), 0);
 
-    let normal = decode_g_buffer_normal(texel.xy);
+    let normal = decode_g_buffer_normal(texel.x);
     
     return vec4(normal, 1.0);   
 }

package/src/shade/renderer/shadow/contact/graph_contact_shadow_linear.d.ts

@@ -5,17 +5,17 @@
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {number} options.depth the depth buffer
- * @param {number} options.normal the G-buffer normals
+ * @param {number} options.pbr the G-buffer's PBR target, for its face normal
  * @param {GPUBuffer} options.camera the view's camera uniforms, whose projection drew `depth`
  * @param {ArrayLike<number>} options.resolution of `depth`
  * @param {{to_light: ArrayLike<number>, length: number, steps: number, thickness: number, jitter_frame: number}} options.settings
  *        see {@link CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT}
  * @returns {number} the visibility texture
  */
-export function graph_contact_shadow_linear({ graph, depth, normal, camera, resolution, settings }: {
+export function graph_contact_shadow_linear({ graph, depth, pbr, camera, resolution, settings }: {
     graph: FrameGraph;
     depth: number;
-    normal: number;
+    pbr: number;
     camera: GPUBuffer;
     resolution: ArrayLike<number>;
     settings: {

package/src/shade/renderer/shadow/contact/graph_contact_shadow_linear.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/graph_contact_shadow_linear.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH;IAT+B,KAAK;IACT,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACa,MAAM;IACE,UAAU,EAArC,UAAU,MAAM,CAAC;IAC8F,QAAQ,EAAvH;QAAC,QAAQ,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAC;IAEnG,MAAM,CAsBlB"}
+{"version":3,"file":"graph_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/graph_contact_shadow_linear.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH;IAT+B,KAAK;IACT,KAAK,EAArB,MAAM;IACU,GAAG,EAAnB,MAAM;IACa,MAAM;IACE,UAAU,EAArC,UAAU,MAAM,CAAC;IAC8F,QAAQ,EAAvH;QAAC,QAAQ,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAC;IAEnG,MAAM,CAsBlB"}

package/src/shade/renderer/shadow/contact/graph_contact_shadow_linear.js

@@ -9,14 +9,14 @@ import { shader_contact_shadow_linear } from "./shader_contact_shadow_linear.js"
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {number} options.depth the depth buffer
- * @param {number} options.normal the G-buffer normals
+ * @param {number} options.pbr the G-buffer's PBR target, for its face normal
  * @param {GPUBuffer} options.camera the view's camera uniforms, whose projection drew `depth`
  * @param {ArrayLike<number>} options.resolution of `depth`
  * @param {{to_light: ArrayLike<number>, length: number, steps: number, thickness: number, jitter_frame: number}} options.settings
  *        see {@link CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT}
  * @returns {number} the visibility texture
  */
-export function graph_contact_shadow_linear({ graph, depth, normal, camera, resolution, settings }) {
+export function graph_contact_shadow_linear({ graph, depth, pbr, camera, resolution, settings }) {
     const width = resolution[0];
     const height = resolution[1];
 
@@ -27,7 +27,7 @@ export function graph_contact_shadow_linear({ graph, depth, normal, camera, reso
         bindings: {
             settings,
             gBufferDepth: depth,
-            gBufferNormal: normal,
+            gBufferPBR: pbr,
             camera,
             tContactShadow: TextureResourceDescriptor.from({
                 resolution: [width, height],

package/src/shade/renderer/shadow/contact/shader_contact_shadow_linear.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/shader_contact_shadow_linear.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,oDAFU,YAAY,CAQY;AA+ElC;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;6BAnH0B,mCAAmC;8BAHlC,+BAA+B"}
+{"version":3,"file":"shader_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/shader_contact_shadow_linear.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH,oDAFU,YAAY,CAQY;AA+ElC;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;6BAnH0B,mCAAmC;8BAHlC,+BAA+B"}

package/src/shade/renderer/shadow/contact/shader_contact_shadow_linear.js

@@ -1,7 +1,9 @@
 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_is_background } from "../../shader/chunk/depth/chunk_is_background.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_interleaved_gradient_noise } from "../../shader/chunk/noise/chunk_interleaved_gradient_noise.js";
 import { chunk_screen_space_linear_ray } from "../../shader/chunk/screen_space/chunk_screen_space_linear_ray.js";
 import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
@@ -40,7 +42,7 @@ resources.setImmediate("settings", CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT);
 
 resources.createGroup()
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferPBR")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addStorageTexture("tContactShadow", "r32float", "2d", "write-only");
 
@@ -63,7 +65,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     }
 
     let to_light = settings.to_light;
-    let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, id.xy, 0).zw);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, id.xy, 0));
 
     if (dot(geometric_normal, to_light) <= 0.0) {
         // facing away: the shadow map's term is already 0, nothing to add to it
@@ -102,7 +104,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 `, [
         CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT.declaration_chunk,
         chunk_is_background,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_texel_coordinate_to_uv,
         chunk_uv_to_ndc,
         chunk_project_position_from_depth,

package/src/shade/renderer/shadow/ray/RTXShadows.d.ts

@@ -13,7 +13,8 @@ export class RTXShadows {
      * [02/05/2025] tested on Sponza, inline approach is 1.66ms, staged is 2.40 so it's slower
      * @param {FrameGraph} graph
      * @param {number} input_position
-     * @param {number} input_normal
+     * @param {number} input_normal the G-buffer's shading normal
+     * @param {number} input_pbr the G-buffer's PBR target, for its face normal
      * @param {number} input_depth
      * @param {number} input_depth_previous
      * @param {number} input_velocity
@@ -22,12 +23,13 @@ export class RTXShadows {
      * @param {number[]} jitter
      * @returns {number} output texture
      */
-    execute2({ graph, input_normal, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
+    execute2({ graph, input_normal, input_pbr, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
     /**
      *
      * @param {FrameGraph} graph
      * @param {number} input_position
-     * @param {number} input_normal
+     * @param {number} input_normal the G-buffer's shading normal
+     * @param {number} input_pbr the G-buffer's PBR target, for its face normal
      * @param {number} input_depth
      * @param {number} input_depth_previous
      * @param {number} input_velocity
@@ -36,7 +38,7 @@ export class RTXShadows {
      * @param {number[]} jitter
      * @returns {number} output texture
      */
-    execute({ graph, input_normal, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
+    execute({ graph, input_normal, input_pbr, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
     #private;
 }
 import { LigmaDenoiser } from "../../postprocess/denoise/LigmaDenoiser.js";

package/src/shade/renderer/shadow/ray/RTXShadows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RTXShadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/RTXShadows.js"],"names":[],"mappings":"AAeA;IAkBI;;;OAGG;IACH,uCAKC;IAzBD;;OAEG;IACH,UAFU,aAAa,CAEf;IAwBR;;;;;;;;;;;;;OAaG;IACH,iIAFa,MAAM,CA4BlB;IAED;;;;;;;;;;;;OAYG;IACH,gIAFa,MAAM,CAmJlB;;CACJ;8BAhP6B,4CAA4C"}
+{"version":3,"file":"RTXShadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/RTXShadows.js"],"names":[],"mappings":"AAcA;IAkBI;;;OAGG;IACH,uCAKC;IAzBD;;OAEG;IACH,UAFU,aAAa,CAEf;IAwBR;;;;;;;;;;;;;;OAcG;IACH,4IAFa,MAAM,CA8BlB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAFa,MAAM,CA2JlB;;CACJ;8BA5P6B,4CAA4C"}

package/src/shade/renderer/shadow/ray/RTXShadows.js

@@ -2,7 +2,6 @@ import { assert } from "../../../../core/assert.js";
 import { current_time_in_seconds } from "../../../../core/time/current_time_in_seconds.js";
 import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
-import { G_BUFFER_MIP_LEVELS } from "../../gbuffer/G_BUFFER_MIP_LEVELS.js";
 import { LigmaDenoiser } from "../../postprocess/denoise/LigmaDenoiser.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { HILBERT_R2_INDEX_TEXTURE } from "../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
@@ -47,7 +46,8 @@ export class RTXShadows {
      * [02/05/2025] tested on Sponza, inline approach is 1.66ms, staged is 2.40 so it's slower
      * @param {FrameGraph} graph
      * @param {number} input_position
-     * @param {number} input_normal
+     * @param {number} input_normal the G-buffer's shading normal
+     * @param {number} input_pbr the G-buffer's PBR target, for its face normal
      * @param {number} input_depth
      * @param {number} input_depth_previous
      * @param {number} input_velocity
@@ -59,6 +59,7 @@ export class RTXShadows {
     execute2({
                  graph,
                  input_normal = -1,
+                 input_pbr = -1,
                  input_depth = -1,
                  input_depth_previous = -1,
                  input_velocity = -1,
@@ -72,6 +73,7 @@ export class RTXShadows {
             view,
             resolution: view.resolution,
             input_normals: input_normal,
+            input_pbr,
             input_depth: input_depth,
         })
 
@@ -88,7 +90,8 @@ export class RTXShadows {
      *
      * @param {FrameGraph} graph
      * @param {number} input_position
-     * @param {number} input_normal
+     * @param {number} input_normal the G-buffer's shading normal
+     * @param {number} input_pbr the G-buffer's PBR target, for its face normal
      * @param {number} input_depth
      * @param {number} input_depth_previous
      * @param {number} input_velocity
@@ -100,6 +103,7 @@ export class RTXShadows {
     execute({
                 graph,
                 input_normal = -1,
+                input_pbr = -1,
                 input_depth = -1,
                 input_depth_previous = -1,
                 input_velocity = -1,
@@ -114,8 +118,6 @@ export class RTXShadows {
 
         const trace_mip_level = this.#trace_mip_level;
 
-        assert.lessThan(trace_mip_level, G_BUFFER_MIP_LEVELS);
-
         const resolution_x = (resolution[0] >>> trace_mip_level);
         const resolution_y = (resolution[1] >>> trace_mip_level);
 
@@ -134,10 +136,16 @@ export class RTXShadows {
         function execute(data, resources, context) {
 
             const in_normal = resources.get(data.normals);
+            const in_pbr = resources.get(data.pbr);
 
             const out = resources.get(data.output);
             const depth = resources.get(data.depth);
 
+            // the trace reads its inputs at its own level, so they must carry it
+            assert.lessThan(trace_mip_level, depth.descriptor.mipLevelCount, 'trace_mip_level');
+            assert.lessThan(trace_mip_level, in_normal.descriptor.mipLevelCount, 'trace_mip_level');
+            assert.lessThan(trace_mip_level, in_pbr.descriptor.mipLevelCount, 'trace_mip_level');
+
             const scene_ctx = view.scene;
             const b_tlas = scene_ctx.tlas.buffer;
 
@@ -168,6 +176,7 @@ export class RTXShadows {
                 bindings: {
                     texture_depth: depth.obtainView(g_buffer_view),
                     texture_normal: in_normal.obtainView(g_buffer_view),
+                    texture_pbr: in_pbr.obtainView(g_buffer_view),
                     texture_noise: noise_texture.obtainView(),
                     camera: view.camera.buffer,
                     view: view.uniform_buffer,
@@ -190,6 +199,7 @@ export class RTXShadows {
         const pass = graph.add('Screen-space shadows', pass_data, execute);
 
         pass_data.normals = pass.read(input_normal);
+        pass_data.pbr = pass.read(input_pbr);
 
         pass_data.depth = pass.read(input_depth);
         pass_data.output = pass.create('shadow hits', TextureResourceDescriptor.from({
@@ -208,6 +218,7 @@ export class RTXShadows {
             input_current_depth: input_depth,
             input_previous_depth: input_depth_previous,
             input_current_normal: input_normal,
+            input_current_pbr: input_pbr,
             input_occlusion,
             input_velocity,
             input_mip_level: trace_mip_level,

package/src/shade/renderer/shadow/ray/shader_ray_shadow_code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_ray_shadow_code.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/shader_ray_shadow_code.js"],"names":[],"mappings":"AA6KA,mDAII;8BA5J0B,+BAA+B"}
+{"version":3,"file":"shader_ray_shadow_code.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/shader_ray_shadow_code.js"],"names":[],"mappings":"AA6KA,mDAII;8BAzJ0B,+BAA+B"}

package/src/shade/renderer/shadow/ray/shader_ray_shadow_code.js

@@ -5,6 +5,9 @@ import { chunk_ray_shaded_query_occluded } from "../../path_tracer/shader/chunk_
 import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.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_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_offset_ray_from_depth } from "../../shader/chunk/geometry/ray/chunk_offset_ray_from_depth.js";
 import { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
@@ -44,6 +47,7 @@ resources.createGroup()
 resources.createGroup()
     .addTexture("texture_depth")
     .addTexture("texture_normal", "uint")
+    .addTexture("texture_pbr")
     .addTexture("texture_noise", "uint", "2d", false, HILBERT_R2_INDEX_TEXTURE)
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addUniform("view", VIEW_UNIFORM_STRUCT)
@@ -100,13 +104,8 @@ fn main(
                 camera.view_projection_matrix_inverse 
             );
             
-            let g_buffer_sample_normal = textureLoad( texture_normal,
-                pixel_position,
-                0
-            );
-            
-            let geometric_normal = decode_g_buffer_normal( g_buffer_sample_normal.zw );
-            let shading_normal = decode_g_buffer_normal( g_buffer_sample_normal.xy );
+            let geometric_normal = decode_g_buffer_face_normal( textureLoad( texture_pbr, pixel_position, 0 ) );
+            let shading_normal = decode_g_buffer_normal( textureLoad( texture_normal, pixel_position, 0 ).x );
     
             let jitter = spatio_temporal_noise_r2_64(pixel_position, view.frame_index, texture_noise);
 
@@ -158,6 +157,7 @@ fn main(
 
 `, [
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_directional_lights_iteration_mask,
         chunk_sample_directional_light_record,
         chunk_spatio_temporal_noise_r2_64,

package/src/shade/renderer/shadow/ray/shader_shadow_upscale.js

@@ -69,7 +69,7 @@ fn main(
     let hi_res_depth_linear = get_view_space_depth(hi_res_depth, camera);
 
     let g_buffer_sample_normal = textureLoad(tNormals, current_coord, 0);
-    let hi_res_normal = decode_g_buffer_normal(g_buffer_sample_normal.xy);
+    let hi_res_normal = decode_g_buffer_normal(g_buffer_sample_normal.x);
 
     // input was produced with NEAREST sampling, to undo the bias of that, we compute distance of the current output pixel relative to input pixel's sampling source
     let input_texel_coarse_coord = uv_to_texel_coordinate(uv, coarse_size);
@@ -105,7 +105,7 @@ fn main(
         // decode the COARSE tap — decoding g_buffer_sample_normal (the hi-res centre) here made
         // coarse_normal identical to hi_res_normal, so w_normal was always 1 and normal-based
         // edge stopping was defeated (shadow bleed across creases).
-        let coarse_normal = decode_g_buffer_normal(coarse_normal_sample.xy);
+        let coarse_normal = decode_g_buffer_normal(coarse_normal_sample.x);
         
         let sample_value = textureLoad(tInput, input_texel_position, 0).r;
     

package/src/shade/renderer/shadow/ray/staged/gen/graph_gen_rays.d.ts

@@ -3,15 +3,17 @@
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {number[]} options.resolution
- * @param {number} options.input_normals
+ * @param {number} options.input_normals the G-buffer's shading normal
+ * @param {number} options.input_pbr the G-buffer's PBR target, for its face normal
  * @param {number} options.input_depth
  * @param {GPUViewContext} options.view
  * @returns {number} buffer of rays
  */
-export function graph_gen_rays({ graph, resolution, input_normals, input_depth, view, }: {
+export function graph_gen_rays({ graph, resolution, input_normals, input_pbr, input_depth, view, }: {
     graph: FrameGraph;
     resolution: number[];
     input_normals: number;
+    input_pbr: number;
     input_depth: number;
     view: GPUViewContext;
 }): number;

package/src/shade/renderer/shadow/ray/staged/gen/graph_gen_rays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_gen_rays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/ray/staged/gen/graph_gen_rays.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH;IAP+B,KAAK;IACP,UAAU,EAA5B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,WAAW,EAA3B,MAAM;IACkB,IAAI;IAC1B,MAAM,CA8DlB"}
+{"version":3,"file":"graph_gen_rays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/ray/staged/gen/graph_gen_rays.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH;IAR+B,KAAK;IACP,UAAU,EAA5B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,WAAW,EAA3B,MAAM;IACkB,IAAI;IAC1B,MAAM,CAkElB"}

package/src/shade/renderer/shadow/ray/staged/gen/graph_gen_rays.js

@@ -1,75 +1,80 @@
-import { BufferResourceDescriptor } from "../../../../../device/graph/BufferResourceDescriptor.js";
-import { HILBERT_R2_INDEX_TEXTURE } from "../../../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
-import { PACKED_RAY_WORD_COUNT, PUSH_CONSTANTS, shader_generate_rays } from "./shader_generate_rays.js";
-
-/**
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {number[]} options.resolution
- * @param {number} options.input_normals
- * @param {number} options.input_depth
- * @param {GPUViewContext} options.view
- * @returns {number} buffer of rays
- */
-export function graph_gen_rays({
-                                   graph,
-                                   resolution,
-                                   input_normals = -1,
-                                   input_depth = -1,
-                                   view,
-                               }) {
-
-    const data = {};
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-
-        const output = resources.get(data.output);
-        const depth = resources.get(data.depth);
-        const normals = resources.get(data.normals);
-
-        const noise_texture = context.graphics.textures.obtain(HILBERT_R2_INDEX_TEXTURE);
-
-        const settings = {
-            frame_index: view.frame_index,
-        };
-
-        const scene_ctx = view.scene;
-
-        shader_generate_rays.dispatchThreads({
-            encoder: context.encoder,
-            thread_count_x: resolution[0],
-            thread_count_y: resolution[1],
-            bindings: {
-                settings,
-                camera: view.camera.buffer.buffer,
-                texture_noise: noise_texture.obtainView(),
-                output,
-                texture_depth: depth,
-                texture_normal: normals,
-                light_data: scene_ctx.lights.buffer_data,
-            }
-        })
-    }
-
-    const pass = graph.add("generate rays", data, execute);
-
-    const pixel_count = resolution[0] * resolution[1];
-
-    data.depth = pass.read(input_depth);
-    data.normals = pass.read(input_normals);
-
-    data.output = pass.create("output", BufferResourceDescriptor.from(
-        16 + PACKED_RAY_WORD_COUNT * 4 * pixel_count,
-        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-        0, 16
-    ));
-
-    return data.output;
+import { BufferResourceDescriptor } from "../../../../../device/graph/BufferResourceDescriptor.js";
+import { HILBERT_R2_INDEX_TEXTURE } from "../../../../texture/noise/HILBERT_R2_INDEX_TEXTURE.js";
+import { PACKED_RAY_WORD_COUNT, PUSH_CONSTANTS, shader_generate_rays } from "./shader_generate_rays.js";
+
+/**
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number[]} options.resolution
+ * @param {number} options.input_normals the G-buffer's shading normal
+ * @param {number} options.input_pbr the G-buffer's PBR target, for its face normal
+ * @param {number} options.input_depth
+ * @param {GPUViewContext} options.view
+ * @returns {number} buffer of rays
+ */
+export function graph_gen_rays({
+                                   graph,
+                                   resolution,
+                                   input_normals = -1,
+                                   input_pbr = -1,
+                                   input_depth = -1,
+                                   view,
+                               }) {
+
+    const data = {};
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+
+        const output = resources.get(data.output);
+        const depth = resources.get(data.depth);
+        const normals = resources.get(data.normals);
+        const pbr = resources.get(data.pbr);
+
+        const noise_texture = context.graphics.textures.obtain(HILBERT_R2_INDEX_TEXTURE);
+
+        const settings = {
+            frame_index: view.frame_index,
+        };
+
+        const scene_ctx = view.scene;
+
+        shader_generate_rays.dispatchThreads({
+            encoder: context.encoder,
+            thread_count_x: resolution[0],
+            thread_count_y: resolution[1],
+            bindings: {
+                settings,
+                camera: view.camera.buffer.buffer,
+                texture_noise: noise_texture.obtainView(),
+                output,
+                texture_depth: depth,
+                texture_normal: normals,
+                texture_pbr: pbr,
+                light_data: scene_ctx.lights.buffer_data,
+            }
+        })
+    }
+
+    const pass = graph.add("generate rays", data, execute);
+
+    const pixel_count = resolution[0] * resolution[1];
+
+    data.depth = pass.read(input_depth);
+    data.normals = pass.read(input_normals);
+    data.pbr = pass.read(input_pbr);
+
+    data.output = pass.create("output", BufferResourceDescriptor.from(
+        16 + PACKED_RAY_WORD_COUNT * 4 * pixel_count,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        0, 16
+    ));
+
+    return data.output;
 }