@woosh/meep-engine 3.61.2 → 3.62.0

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

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

@@ -1 +1 @@
-{"version":3,"file":"shader_generate_rays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/ray/staged/gen/shader_generate_rays.js"],"names":[],"mappings":"AA2BA,0CAEG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAkHvC,iDAIE;6BAvJ2B,yCAAyC;8BAoBxC,qCAAqC"}
+{"version":3,"file":"shader_generate_rays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/ray/staged/gen/shader_generate_rays.js"],"names":[],"mappings":"AA8BA,0CAEG;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AA+GvC,iDAIE;6BAvJ2B,yCAAyC;8BAuBxC,qCAAqC"}

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

@@ -7,6 +7,9 @@ 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";
@@ -53,6 +56,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)
 
@@ -92,13 +96,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, settings.frame_index, texture_noise);
 
@@ -134,6 +133,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/sdf/cascade/shader_scene_sdf_soft_shadows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_scene_sdf_soft_shadows.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/sdf/cascade/shader_scene_sdf_soft_shadows.js"],"names":[],"mappings":"AAuDA,sDA+GC;AAmED,wDASE;0BAjOwB,uCAAuC;4BACrC,gCAAgC"}
+{"version":3,"file":"shader_scene_sdf_soft_shadows.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/sdf/cascade/shader_scene_sdf_soft_shadows.js"],"names":[],"mappings":"AA2DA,sDA+GC;AAmED,wDASE;0BAlOwB,uCAAuC;4BACrC,gCAAgC"}

package/src/shade/renderer/shadow/sdf/cascade/shader_scene_sdf_soft_shadows.js

@@ -10,6 +10,9 @@ import { AABB3_STRUCT } from "../../../shader/chunk/geometry/aabb3/AABB3_STRUCT.
 import { chunk_aabb3_distance_to_ray_v2 } from "../../../shader/chunk/geometry/aabb3/chunk_aabb3_distance_to_ray_v2.js";
 import { chunk_mat4_compose_transform } from "../../../shader/chunk/geometry/mat4/chunk_mat4_compose_transform.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 { RAY_STRUCT } from "../../../shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
 import { chunk_light_get_sun } from "../../../shader/chunk/light/sky/chunk_sample_sky_color.js";
@@ -39,6 +42,7 @@ resources.createGroup()
 resources.createGroup({ label: "g-buffer" })
     .addTexture("gBufferDepth")
     .addTexture("gBufferNormals", "uint")
+    .addTexture("gBufferPBR")
 
 resources.createGroup()
     .addStorageBuffer("light_data", WebGPUArray.u32)
@@ -191,10 +195,9 @@ fn main(
     
     let jitter = spatio_temporal_noise_r2_64(i_coord, sdf_metadata.frame_index, tNoise);
 
-    let g_buffer_normals = textureLoad(gBufferNormals, i_coord, 0);
 
-    let geometric_normal = decode_g_buffer_normal(g_buffer_normals.zw);
-    let shading_normal = decode_g_buffer_normal(g_buffer_normals.xy);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, i_coord, 0));
+    let shading_normal = decode_g_buffer_normal(textureLoad(gBufferNormals, i_coord, 0).x);
     
     let position_ws = project_position_from_depth(uv, texel_depth, camera.view_projection_matrix_inverse);
     
@@ -222,6 +225,7 @@ fn main(
         chunk_light_get_sun,
         chunk_is_background,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_project_position_from_depth,
         chunk_texel_coordinate_to_uv,
         chunk_scene_sdf_ray_occlusion,

package/src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.d.ts

@@ -4,16 +4,18 @@
  * @param {FrameGraph} options.graph
  * @param {GPUViewContext} options.view
  * @param {number} options.input_depth
- * @param {number} options.input_normals
- * @param {number} options.input_viz_mesh
+ * @param {number} options.input_pbr the G-buffer's PBR target, for its face normal
+ * @param {number} options.input_visibility the visibility buffer
+ * @param {number} options.input_visible_meshlets the frame's visible-meshlet table, which resolves it
  * @returns {number} texture with shadows
  */
-export function graph_draw_sdf_shadows({ graph, view, input_depth, input_normals, input_viz_mesh, }: {
+export function graph_draw_sdf_shadows({ graph, view, input_depth, input_pbr, input_visibility, input_visible_meshlets, }: {
     graph: FrameGraph;
     view: GPUViewContext;
     input_depth: number;
-    input_normals: number;
-    input_viz_mesh: number;
+    input_pbr: number;
+    input_visibility: number;
+    input_visible_meshlets: number;
 }): number;
 export const shader_draw_sdf_shadows: ImageShader;
 import { ImageShader } from "../../shader/ImageShader.js";

package/src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_draw_sdf_shadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js"],"names":[],"mappings":"AAqHA;;;;;;;;;GASG;AACH;IAP+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,aAAa,EAA7B,MAAM;IACU,cAAc,EAA9B,MAAM;IACJ,MAAM,CA6FlB;AAhHD,kDASG;4BA9FyB,6BAA6B"}
+{"version":3,"file":"graph_draw_sdf_shadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IAR+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACU,sBAAsB,EAAtC,MAAM;IACJ,MAAM,CAgGlB;AApHD,kDASG;4BAjGyB,6BAA6B"}

package/src/shade/renderer/shadow/sdf/graph_draw_sdf_shadows.js

@@ -14,11 +14,17 @@ import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUC
 import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
 import { BVH_STRUCT } from "../../shader/chunk/bvh/BVH_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 { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_scene_sdf_soft_shadow } from "../../shader/chunk/sdf/chunk_scene_sdf_soft_shadow.js";
 import { chunk_sdf_hard_shadow } from "../../shader/chunk/sdf/chunk_sdf_hard_shadow.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    chunk_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../rasterize/visibility/chunk_visibility_decode.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
@@ -35,8 +41,9 @@ resources.createGroup()
     .add(MESH_SDF_ATLAS_RESOURCE)
     .add(MESH_SDF_SAMPLER_RESOURCE)
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormals", "uint")
-    .addTexture("vizBufferMesh", "uint")
+    .addTexture("gBufferPBR")
+    .addTexture("visibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
 
 resources.createGroup()
     .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
@@ -73,9 +80,10 @@ fn main(
         return vec4(1.0);
     }
     
-    let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormals, coord_i, 0).zw);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, coord_i, 0));
     
-    let mesh_id = textureLoad(vizBufferMesh, coord_i, 0).x;
+    // a surface is here: the depth is not the background's
+    let mesh_id = visibility_decode(textureLoad(visibility, coord_i, 0).x).mesh;
     
     let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
     
@@ -99,7 +107,8 @@ fn main(
 `, [
         RAY_STRUCT.declaration_chunk,
         chunk_project_position_from_depth,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
+        chunk_visibility_decode,
         chunk_scene_sdf_soft_shadow,
         chunk_sdf_hard_shadow,
     ]);
@@ -121,16 +130,18 @@ export const shader_draw_sdf_shadows = new ImageShader({
  * @param {FrameGraph} options.graph
  * @param {GPUViewContext} options.view
  * @param {number} options.input_depth
- * @param {number} options.input_normals
- * @param {number} options.input_viz_mesh
+ * @param {number} options.input_pbr the G-buffer's PBR target, for its face normal
+ * @param {number} options.input_visibility the visibility buffer
+ * @param {number} options.input_visible_meshlets the frame's visible-meshlet table, which resolves it
  * @returns {number} texture with shadows
  */
 export function graph_draw_sdf_shadows({
                                            graph,
                                            view,
                                            input_depth,
-                                           input_normals,
-                                           input_viz_mesh,
+                                           input_pbr,
+                                           input_visibility,
+                                           input_visible_meshlets,
                                        }) {
 
 
@@ -159,7 +170,7 @@ export function graph_draw_sdf_shadows({
         /**
          * @type {GPUTextureContext}
          */
-        const normals = resources.get(data.normals);
+        const pbr = resources.get(data.pbr);
         /**
          * @type {GPUTextureContext}
          */
@@ -167,7 +178,7 @@ export function graph_draw_sdf_shadows({
         /**
          * @type {GPUTextureContext}
          */
-        const viz_mesh = resources.get(data.viz_mesh);
+        const visibility = resources.get(data.visibility);
 
         const buffer_settings = {
             slice: pingpong(current_time_in_seconds() / 5, 1),
@@ -178,8 +189,9 @@ export function graph_draw_sdf_shadows({
             bindings: sdf.write_bindings({
                 settings: buffer_settings,
                 gBufferDepth: depth.obtainView(),
-                gBufferNormals: normals.obtainView(),
-                vizBufferMesh: viz_mesh.obtainView(),
+                gBufferPBR: pbr.obtainView(),
+                visibility: visibility.obtainView(),
+                visible_meshlets: resources.get(data.visible_meshlets),
                 geometries: geometries.buffer_metadata,
                 scene_database: view.scene.scene_database_buffer,
                 tlas: view.scene.tlas.buffer,
@@ -206,8 +218,9 @@ export function graph_draw_sdf_shadows({
     const pass_builder = graph.add("SDF shadows", pass_data, execute);
 
     pass_data.depth = pass_builder.read(input_depth);
-    pass_data.normals = pass_builder.read(input_normals);
-    pass_data.viz_mesh = pass_builder.read(input_viz_mesh);
+    pass_data.pbr = pass_builder.read(input_pbr);
+    pass_data.visibility = pass_builder.read(input_visibility);
+    pass_data.visible_meshlets = pass_builder.read(input_visible_meshlets);
 
     pass_data.output = pass_builder.create('sdf', TextureResourceDescriptor.from({
         format: "rgba8unorm",

package/src/shade/renderer/texture/virtual/VirtualTextureManager.d.ts

@@ -138,15 +138,15 @@ export class VirtualTextureManager {
      * @param {Object} args
      * @param {FrameGraph} args.graph
      * @param {GPUViewContext} args.view
-     * @param {number} args.texture_viz_mesh graph handle
-     * @param {number} args.texture_viz_triangle graph handle
+     * @param {number} args.texture_visibility graph handle, the visibility buffer
+     * @param {number} args.visible_meshlets graph handle, the frame's visible-meshlet table, which resolves it
      * @param {GPUBuffer} args.material_metadata_buffer
      */
-    graph_feedback({ graph, view, texture_viz_mesh, texture_viz_triangle, material_metadata_buffer, }: {
+    graph_feedback({ graph, view, texture_visibility, visible_meshlets, material_metadata_buffer, }: {
         graph: FrameGraph;
         view: GPUViewContext;
-        texture_viz_mesh: number;
-        texture_viz_triangle: number;
+        texture_visibility: number;
+        visible_meshlets: number;
         material_metadata_buffer: GPUBuffer;
     }): void;
     destroy(): void;

package/src/shade/renderer/texture/virtual/VirtualTextureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAmHA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,2EAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,uIAQC;IAED;;;;OAIG;IACH,+EAIC;IA8DD;;;;;;;OAOG;IACH,sBAHW,mBAAmB,GACjB,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,wBAFW,mBAAmB,QAgF7B;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eAkHC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK,EAAtB,UAAU;QACW,IAAI,EAAzB,cAAc;QACD,gBAAgB,EAA7B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACU,wBAAwB;aA6FlD;IAED,gBA8BC;;CACJ;yBAvvCY,OAAO,8DAA8D,EAAE,UAAU;uCACjF,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;6BACtD,OAAO,8BAA8B,EAAE,cAAc;kCACrD,OAAO,0BAA0B,EAAE,mBAAmB;gCAPnC,sBAAsB"}
+{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAmHA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,2EAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,uIAQC;IAED;;;;OAIG;IACH,+EAIC;IA8DD;;;;;;;OAOG;IACH,sBAHW,mBAAmB,GACjB,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,wBAFW,mBAAmB,QAgF7B;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eAkHC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK,EAAtB,UAAU;QACW,IAAI,EAAzB,cAAc;QACD,kBAAkB,EAA/B,MAAM;QACO,gBAAgB,EAA7B,MAAM;QACU,wBAAwB;aA6FlD;IAED,gBA8BC;;CACJ;yBAvvCY,OAAO,8DAA8D,EAAE,UAAU;uCACjF,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;6BACtD,OAAO,8BAA8B,EAAE,cAAc;kCACrD,OAAO,0BAA0B,EAAE,mBAAmB;gCAPnC,sBAAsB"}