@woosh/meep-engine 3.61.3 → 3.62.0

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

package/src/shade/renderer/texture/virtual/VirtualTextureManager.js

@@ -1171,15 +1171,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,
+                       texture_visibility,
+                       visible_meshlets,
                        material_metadata_buffer,
                    }) {
 
@@ -1228,8 +1228,8 @@ export class VirtualTextureManager {
                 group_count_y,
                 group_count_z: 1,
                 bindings: {
-                    viz_buffer_triangle: resources.get(data.viz_triangle).obtainView(),
-                    viz_buffer_mesh: resources.get(data.viz_mesh).obtainView(),
+                    visibility: resources.get(data.visibility).obtainView(),
+                    visible_meshlets: resources.get(data.visible_meshlets),
                     view: view.uniform_buffer.buffer,
                     vt_params: { stride, jitter, mip_bias },
                     scene_database: scene_ctx.scene_database_buffer,
@@ -1242,8 +1242,8 @@ export class VirtualTextureManager {
             });
         });
 
-        pass_data.viz_mesh = pass.read(texture_viz_mesh);
-        pass_data.viz_triangle = pass.read(texture_viz_triangle);
+        pass_data.visibility = pass.read(texture_visibility);
+        pass_data.visible_meshlets = pass.read(visible_meshlets);
 
         pass_data.requests = pass.create("vt_requests", BufferResourceDescriptor.from(
             config.hash_capacity * 4,

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

@@ -1 +1 @@
-{"version":3,"file":"build_shader_vt_feedback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/build_shader_vt_feedback.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAJ6B,eAAe,EAAjC,SAAS;IACM,aAAa,EAA5B,MAAM;IACJ,aAAa,CAmKzB;AA9MD;;;;;;;;GAQG;AACH,qDAI8B;AAS9B,2CAA4C;0BA9BlB,oCAAoC;8BAChC,+BAA+B;6BAjBhC,mCAAmC"}
+{"version":3,"file":"build_shader_vt_feedback.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/build_shader_vt_feedback.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAJ6B,eAAe,EAAjC,SAAS;IACM,aAAa,EAA5B,MAAM;IACJ,aAAa,CAkKzB;AA7MD;;;;;;;;GAQG;AACH,qDAI8B;AAS9B,2CAA4C;0BA9BlB,oCAAoC;8BAChC,+BAA+B;6BAjBhC,mCAAmC"}

package/src/shade/renderer/texture/virtual/build_shader_vt_feedback.js

@@ -4,14 +4,14 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
 import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+    chunk_visibility_decode,
+    VISIBLE_MESHLETS_RESOURCE
+} from "../../rasterize/visibility/chunk_visibility_decode.js";
 import { MATERIAL_METADATA_STRUCT } from "../../material/MATERIAL_METADATA_STRUCT.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
 import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
 import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
 import { chunk_barycentric_interpolate_uv } from "../../shader/chunk/geometry/triangle/chunk_barycentric_interpolate_uv.js";
-import { chunk_decode_meshlet_element } from "../../shader/chunk/geometry/meshlet/chunk_decode_meshlet_element.js";
 import {
     chunk_read_meshlet_triangle_vertices
 } from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_vertices.js";
@@ -77,8 +77,8 @@ export function build_shader_vt_feedback({ chunk_vt_lookup, hash_capacity }) {
     resources.setImmediate("vt_params", VT_FEEDBACK_PARAMS_STRUCT);
 
     resources.createGroup()
-        .addTexture("viz_buffer_triangle", "uint")
-        .addTexture("viz_buffer_mesh", "uint")
+        .addTexture("visibility", "uint")
+        .add(VISIBLE_MESHLETS_RESOURCE)
         .addUniform("view", VIEW_UNIFORM_STRUCT)
         .addStorageBuffer("scene_database", WebGPUArray.from(u32))
         .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
@@ -149,13 +149,15 @@ fn main(
         return;
     }
 
-    let mesh_index = textureLoad(viz_buffer_mesh, vec2<i32>(pixel), 0).r;
+    let visibility_word = textureLoad(visibility, vec2<i32>(pixel), 0).r;
 
-    if (mesh_index == ${VIZ_BUFFER_INVALID_MESH_VALUE}u) {
+    if (visibility_word == VISIBILITY_NONE) {
         return;
     }
 
-    let mesh = scene_read_mesh(&scene_database, mesh_index);
+    let visibility_texel = visibility_decode(visibility_word);
+
+    let mesh = scene_read_mesh(&scene_database, visibility_texel.mesh);
 
     let stack_id = material_metadata[mesh.material].vt_stack;
 
@@ -166,11 +168,8 @@ fn main(
     let info = vt_stacks[stack_id];
 
     // ── UV + gradients, mirroring fragment_gbuffer ──────────────────
-    let encoded_meshlet_triangle = textureLoad(viz_buffer_triangle, vec2<i32>(pixel), 0).r;
-
-    let decoded = decode_meshlet_element(encoded_meshlet_triangle);
-    let meshlet_id = decoded[0];
-    let meshlet_triangle_id = decoded[1];
+    let meshlet_id = visibility_texel.meshlet;
+    let meshlet_triangle_id = visibility_texel.triangle;
 
     let node = scene_read_node(&scene_database, mesh.node);
 
@@ -218,7 +217,7 @@ fn main(
             chunk_vt_request_key,
             chunk_hash_lowbias32,
             chunk_scene_database_access,
-            chunk_decode_meshlet_element,
+            chunk_visibility_decode,
             chunk_read_meshlet_triangle_vertices,
             chunk_barycentric_full,
             chunk_barycentric_interpolate_uv,

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -36,13 +36,14 @@ export class GPUWaterRenderer {
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
     request_probe(uv: any): Promise<any>;
     dispose(): void;
-    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches, probes }: {
+    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, pbr_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches, probes }: {
         graph: any;
         view_ctx: any;
         camera: any;
         color_texture: any;
         depth_texture: any;
         normal_texture: any;
+        pbr_texture: any;
         hzb_texture: any;
         environment_texture: any;
         light_cluster_parameters: any;

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAsBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAvX+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAsBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;;MA2IC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAzX+B,uCAAuC"}

package/src/shade/renderer/water/GPUWaterRenderer.js

@@ -152,7 +152,7 @@ export class GPUWaterRenderer {
         pass.make_side_effect();
     }
 
-    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture,
+    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, pbr_texture,
         hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data,
         shadowmap_atlas, shader_switches = ShaderSwitchSet.EMPTY, probes }) {
         assert.defined(probes, 'probes');
@@ -196,6 +196,7 @@ export class GPUWaterRenderer {
                 trace: encoder.allocateTransientValueBuffer(WATER_TRACE_STRUCT, settings),
                 tDepth: resources.get(data.scene_depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
                 tNormal: resources.get(data.normal).obtainView(),
+                tPBR: resources.get(data.pbr).obtainView(),
                 tHZB: resources.get(data.hzb).obtainView(),
                 tScene: resources.get(data.color).obtainView(),
             };
@@ -212,7 +213,7 @@ export class GPUWaterRenderer {
             render.end();
         });
         for (const [name, handle] of Object.entries({ camera, color: color_texture, scene_depth: depth_texture,
-            normal: normal_texture, hzb: hzb_texture })) { data[name] = pass.read(handle); }
+            normal: normal_texture, pbr: pbr_texture, hzb: hzb_texture })) { data[name] = pass.read(handle); }
         const target = (name, format) => pass.create(`Water ${name}`, TextureResourceDescriptor.from({
             resolution, format, usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
                 | (probe !== null && format !== "depth32float" ? GPUTextureUsage.COPY_SRC : 0),
@@ -240,7 +241,8 @@ export class GPUWaterRenderer {
             const shared = {
                 camera: resources.get(d.camera), trace: encoder.allocateTransientValueBuffer(WATER_TRACE_STRUCT, settings),
                 tDepth: resources.get(d.scene_depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
-                tNormal: resources.get(d.normal).obtainView(), tHZB: resources.get(d.hzb).obtainView(),
+                tNormal: resources.get(d.normal).obtainView(), tPBR: resources.get(d.pbr).obtainView(),
+                tHZB: resources.get(d.hzb).obtainView(),
                 tScene: resources.get(d.color).obtainView(),
                 receiver: resources.get(d.receiver).obtainView(), trace_metadata: resources.get(d.trace_metadata).obtainView(),
                 ...geometry_bindings(graphics, encoder, resources, d),
@@ -274,7 +276,7 @@ export class GPUWaterRenderer {
             draw(render, resources.get(d.commands), graphics.device);
             render.end();
         });
-        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','interface_depth',
+        for (const key of ['camera','scene_depth','normal','pbr','hzb','color','receiver','trace_metadata','interface_depth',
             'lod_bodies','candidates','cells','commands']) {
             finalize_data[key] = finalize.read(data[key]);
         }

package/src/shade/renderer/water/chunk_water_transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAUA,0DAEG;AAEH,8CAsBG;AAIH,mDAU6F;AAI7F,sDAmCoE;0BAzF1C,iCAAiC"}
+{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAWA,0DAEG;AAEH,8CAsBG;AAIH,mDAWmC;AAInC,sDAmCoE;0BA3F1C,iCAAiC"}

package/src/shade/renderer/water/chunk_water_transport.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from '../shader/compiler/CodeChunk.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_inv_project_position } from '../shader/chunk/screen_space/chunk_inv_project_position.js';
 import { chunk_is_background } from '../shader/chunk/depth/chunk_is_background.js';
 import { chunk_screen_space_newton_ray } from '../shader/chunk/screen_space/chunk_screen_space_newton_ray.js';
@@ -40,30 +41,31 @@ fn water_transport(event: WaterEvent, original: vec3f, receiver: vec3f,
 // is where the surface is, and the normal it was shaded with, which is what lit it.
 export const chunk_water_receiver_texel = CodeChunk.from(/* language=WGSL */ `
 struct WaterReceiverTexel { depth: f32, position: vec3f, face_normal: vec3f, shading_normal: vec3f }
-fn water_receiver_texel(depth: texture_2d<f32>, normals: texture_2d<u32>, coord: vec2i,
+fn water_receiver_texel(depth: texture_2d<f32>, normals: texture_2d<u32>, pbr: texture_2d<f32>, coord: vec2i,
     inverse_projection: mat4x4f, inverse_view: mat4x4f) -> WaterReceiverTexel {
     let d = textureLoad(depth, coord, 0).r;
     let center = texel_coordinate_to_uv(vec2f(coord), textureDimensions(depth, 0));
     let position = inverse_view * vec4f(inv_project_position(vec3f(center, d), inverse_projection), 1.0);
-    let encoded = textureLoad(normals, coord, 0);
-    return WaterReceiverTexel(d, position.xyz, decode_g_buffer_normal(encoded.zw), decode_g_buffer_normal(encoded.xy));
+    return WaterReceiverTexel(d, position.xyz, decode_g_buffer_face_normal(textureLoad(pbr, coord, 0)),
+        decode_g_buffer_normal(textureLoad(normals, coord, 0).x));
 }
-`, [chunk_decode_g_buffer_normal, chunk_inv_project_position, chunk_texel_coordinate_to_uv]);
+`, [chunk_decode_g_buffer_normal, chunk_decode_g_buffer_face_normal, chunk_inv_project_position,
+    chunk_texel_coordinate_to_uv]);
 
 // Filtering radiance across a silhouette must not introduce a surface that the ray never hit.
 // The center depth/face normal define receiver ownership; taps must lie on that same local plane.
 export const chunk_water_receiver_radiance = CodeChunk.from(/* language=WGSL */ `
 // Depth is stored at the texel center. Reconstruct the lookup on that texel's tangent
 // plane so subpixel lookup motion does not quantize water thickness.
-fn water_receiver_path(depth: texture_2d<f32>, normals: texture_2d<u32>, uv: vec2f,
+fn water_receiver_path(depth: texture_2d<f32>, pbr: texture_2d<f32>, uv: vec2f,
     inverse_projection: mat4x4f, world_to_view: mat4x4f, origin: vec3f) -> f32 {
-    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);
     return distance(origin, screen_space_ray_lookup_position(uv, receiver, inverse_projection).xyz);
 }
 fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
-    uv: vec2f, inverse_projection: mat4x4f, inverse_view: mat4x4f, surface: vec3f, surface_normal: vec3f, below_interface: bool) -> vec4f {
+    pbr: texture_2d<f32>, uv: vec2f, inverse_projection: mat4x4f, inverse_view: mat4x4f, surface: vec3f, surface_normal: vec3f, below_interface: bool) -> vec4f {
     let size = vec2i(textureDimensions(depth, 0));
-    let center = water_receiver_texel(depth, normals, clamp(vec2i(uv * vec2f(size)), vec2i(0), size-1),
+    let center = water_receiver_texel(depth, normals, pbr, clamp(vec2i(uv * vec2f(size)), vec2i(0), size-1),
         inverse_projection, inverse_view);
     if (is_background(center.depth)
         || (below_interface && dot(center.position - surface, surface_normal) > WATER_LEVEL_TOLERANCE)) { return vec4f(0.0); }
@@ -75,7 +77,7 @@ fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, norma
     for (var y = 0; y < 2; y++) {
         for (var x = 0; x < 2; x++) {
             let coord = clamp(base + vec2i(x,y), vec2i(0), size-1);
-            let tap = water_receiver_texel(depth, normals, coord, inverse_projection, inverse_view);
+            let tap = water_receiver_texel(depth, normals, pbr, coord, inverse_projection, inverse_view);
             if (is_background(tap.depth) || (below_interface && dot(tap.position - surface, surface_normal) > WATER_LEVEL_TOLERANCE)
                 || dot(center.face_normal, tap.face_normal) < 0.95
                 || abs(dot(tap.position - center.position, center.face_normal)) > 0.02) { continue; }

package/src/shade/renderer/water/shader_water.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAwpBA,kEAAsH;AACtH,gFAAgF;AAChF,wFAEC;AArmBD,8CAKwB;AAwCxB;;;;GAIG;AACH,mEAA8D;AAgP9D,+CAsFmB;AA2MnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCA5nBA,8DAA8D;6BA2B1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AA0pBA,kEAAsH;AACtH,gFAAgF;AAChF,wFAEC;AAtmBD,8CAKwB;AAyCxB;;;;GAIG;AACH,mEAA8D;AAgP9D,+CAsFmB;AA2MnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCA9nBA,8DAA8D;6BA4B1E,gCAAgC;4CAJjB,mDAAmD;0BARrE,iCAAiC;iCAS1B,+BAA+B"}