@woosh/meep-engine 3.61.2 → 3.62.0

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/volumetrics/chunk_frustum_unit_box_coverage_multisample.d.ts

@@ -1,3 +1,21 @@
+/**
+ * The share of a frustum's volume inside the unit box [-0.5, 0.5]³, estimated along 4 rays from its near
+ * face to its far face: the mean of the fraction of each ray inside the box.
+ *
+ * The rays cross the face at points `4 · round` to `4 · round + 3` of the shuffled, Owen-scrambled Sobol
+ * sequence of `seed` (`sample_sobol_2d`), in the face's (u, v), u from the left plane to the right and v
+ * from the bottom to the top. Each call's 4 points are one per quarter of the face along either axis, and one
+ * per quadrant. The 2^m calls of an aligned run of rounds put one point in each dyadic cell of area
+ * 2^-(m+2). The points depend only on the seed and the round, and a ray is the planes' blend at its point:
+ * the same frustum's planes carried into another space by a rigid or uniformly scaled map, each plane
+ * renormalized, cast the same rays there.
+ *
+ * ```wgsl
+ * fn frustum_unit_box_coverage(frustum: array<vec4f, 6>, round: u32, seed: u32) -> f32 // frustum planes [LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR]
+ * ```
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_frustum_unit_box_coverage_multisample: CodeChunk;
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_frustum_unit_box_coverage_multisample.d.ts.map

package/src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_frustum_unit_box_coverage_multisample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.js"],"names":[],"mappings":"AAIA,oEAsDE;0BAxDwB,iCAAiC"}
+{"version":3,"file":"chunk_frustum_unit_box_coverage_multisample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,0DAFU,SAAS,CA8CjB;0BAhEwB,iCAAiC"}

package/src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.js

@@ -1,39 +1,48 @@
 import { chunk_frustum_sample_point } from "../shader/chunk/geometry/frustum/chunk_frustum_sample_point.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
+import { chunk_sobol_sample_vec2 } from "../shader/chunk/noise/chunk_sobol_sample_vec2.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 
+/**
+ * The share of a frustum's volume inside the unit box [-0.5, 0.5]³, estimated along 4 rays from its near
+ * face to its far face: the mean of the fraction of each ray inside the box.
+ *
+ * The rays cross the face at points `4 · round` to `4 · round + 3` of the shuffled, Owen-scrambled Sobol
+ * sequence of `seed` (`sample_sobol_2d`), in the face's (u, v), u from the left plane to the right and v
+ * from the bottom to the top. Each call's 4 points are one per quarter of the face along either axis, and one
+ * per quadrant. The 2^m calls of an aligned run of rounds put one point in each dyadic cell of area
+ * 2^-(m+2). The points depend only on the seed and the round, and a ray is the planes' blend at its point:
+ * the same frustum's planes carried into another space by a rigid or uniformly scaled map, each plane
+ * renormalized, cast the same rays there.
+ *
+ * ```wgsl
+ * fn frustum_unit_box_coverage(frustum: array<vec4f, 6>, round: u32, seed: u32) -> f32 // frustum planes [LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR]
+ * ```
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_frustum_unit_box_coverage_multisample = CodeChunk.from(
     //language=WGSL
     `
 fn frustum_unit_box_coverage(
     frustum: array< vec4f, 6>,
+    round: u32,
+    seed: u32,
 ) -> f32 {
-    
-    // 4 Samples is usually the "Sweet Spot" for volumetrics.
-    // 1 = Hard Edges
-    // 4 = Smooth with slight noise (cleaned up by TAA)
-    // 16 = High quality but expensive
     const SAMPLE_COUNT = 4u;
-    
+
     var total_coverage = 0.0;
 
     for(var i = 0u; i < SAMPLE_COUNT; i++){
-    
-        // 1. Generate Random UVs
-        // This distributes rays across the face of the froxel.
-        let u = random();
-        let v = random();
-        
-        // 2. Construct Ray
-        // Note: We must re-calculate direction per-sample because 
-        // perspective frustums diverge (rays are not parallel).
-        let start = frustum_sample_point(frustum, vec3f(u, v, 0.0));
-        let end   = frustum_sample_point(frustum, vec3f(u, v, 1.0));
+        let uv = sample_sobol_2d(round * SAMPLE_COUNT + i, seed);
+
+        // perspective frustums diverge, so each ray takes its own direction
+        let start = frustum_sample_point(frustum, vec3f(uv, 0.0));
+        let end   = frustum_sample_point(frustum, vec3f(uv, 1.0));
 
         let dir = end - start;
         let inv_dir = 1.0 / (dir + vec3f(1e-5));
-        
-        // 3. Slab Method (Intersection with Unit Box -0.5 to 0.5)
+
+        // slab test against the unit box
         let t0 = (vec3f(-0.5) - start) * inv_dir;
         let t1 = (vec3f( 0.5) - start) * inv_dir;
 
@@ -43,7 +52,6 @@ fn frustum_unit_box_coverage(
         let enter = max(max(tmin.x, tmin.y), tmin.z);
         let exit  = min(min(tmax.x, tmax.y), tmax.z);
 
-        // 4. Accumulate Ratio
         let t_start = max(0.0, enter);
         let t_end   = min(1.0, exit);
 
@@ -54,6 +62,6 @@ fn frustum_unit_box_coverage(
 }
     `, [
         chunk_frustum_sample_point,
-        chunk_random
+        chunk_sobol_sample_vec2,
     ]
-);
+);

package/src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AA8QA,yEAIE;8BA3P4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AA6QA,yEAIE;8BA3P4B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js

@@ -18,8 +18,7 @@ import {
 } from "../shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js";
 import { chunk_mat4_extract_scale } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_scale.js";
 import { chunk_stbn_sample_vec3 } from "../shader/chunk/noise/chunk_stbn_sample_vec3.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
-import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
+import { chunk_pcg4d } from "../shader/chunk/random/pcg/chunk_pcg4d.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -69,7 +68,8 @@ fn main(
         return;
     }
     
-    random_initialize(voxel_coord, vec3(view.frame_index, 0xCAFEBEEF, 1337));
+    // the froxel's coverage points: a sequence of its own, a round of it a frame, the same points for every volume
+    let coverage_seed = pcg4d(vec4<u32>(voxel_coord, 0x1F83D9ABu)).x;
     
     let uv = vec2f(voxel_coord.xy) / vec2f(resolution.xy);
     
@@ -187,7 +187,7 @@ fn main(
         // volumetrics_froxel_containment.spec.js keeps the geometry proven if the balance changes.
 
         // estimate volume coverage to avoid aliasing and get a better overlap test
-        var volume_coverage = frustum_unit_box_coverage(local_frustum);
+        var volume_coverage = frustum_unit_box_coverage(local_frustum, view.frame_index, coverage_seed);
 
         if(volume_coverage == 0.0){
             // skip
@@ -252,8 +252,7 @@ fn main(
         chunk_frustum_transform_plane_matrix,
         chunk_aabb3_intersects_frustum,
         chunk_compute_near_far_from_projection,
-        chunk_random_initialize,
-        chunk_random,
+        chunk_pcg4d,
         chunk_rgb_to_luminance,
         chunk_frustum_unit_box_coverage_multisample,
         chunk_compute_volume_fade_factor,

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/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#279@#execute"(pass: any, resources: any, context: any): void;
+    static "__#281@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

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

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

@@ -20,7 +20,8 @@ import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import {
     SCREEN_DEPTH_RESOURCE,
     SCREEN_HZB_RESOURCE,
-    SCREEN_NORMAL_RESOURCE
+    SCREEN_NORMAL_RESOURCE,
+    SCREEN_PBR_RESOURCE
 } from "../shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js";
 import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -75,6 +76,7 @@ function water_resources(finalize = false) {
         .add(TRACE_RESOURCE)
         .add(SCREEN_DEPTH_RESOURCE)
         .add(SCREEN_NORMAL_RESOURCE)
+        .add(SCREEN_PBR_RESOURCE)
         .add(SCREEN_HZB_RESOURCE)
         .addTexture("tScene")
         .add(SCENE_DATABASE_RESOURCE)
@@ -383,7 +385,7 @@ fn water_hzb_crossing(origin: vec3f, direction: vec3f, budget: u32,
 fn water_exact_receiver(ray: Ray, input: ScreenSpaceRayHit) -> ScreenSpaceRayHit {
     var hit = input;
     if (hit.status != 0u) { return hit; }
-    let receiver = screen_space_ray_load_receiver(hit.uv, tDepth, tNormal,
+    let receiver = screen_space_ray_load_receiver(hit.uv, tDepth, tPBR,
         camera.projection_matrix_inverse, camera.view_matrix);
     let travel = plane_ray_raycast(ray.origin, ray.direction, receiver.plane);
     // Keep the analytic distance rather than the projection of the texel center onto the ray.
@@ -392,14 +394,14 @@ fn water_exact_receiver(ray: Ray, input: ScreenSpaceRayHit) -> ScreenSpaceRayHit
         hit.uv = project_position(ray_at(ray.origin, ray.direction, travel), camera.projection_matrix).xy;
         // Reprojection can change texel ownership at a silhouette. Validate that lookup
         // again; the analytic travel above already checked the ray's bounded interval.
-        let checked = screen_space_ray_validate(Ray(ray.origin,ray.direction,1e20),hit.uv,tDepth,tNormal,
+        let checked = screen_space_ray_validate(Ray(ray.origin,ray.direction,1e20),hit.uv,tDepth,tPBR,
             camera.projection_matrix,camera.projection_matrix_inverse,camera.view_matrix,trace.distance_tolerance);
         hit.status = checked.status;
         hit.residual = checked.residual;
         // The plane can carry a hit on the last texel before the sky across that edge. The texel the
         // traversal stopped on is still a receiver: accept it where it passes on its own.
         if (checked.status == 2u) {
-            let unsnapped = screen_space_ray_validate(ray, input.uv, tDepth, tNormal, camera.projection_matrix,
+            let unsnapped = screen_space_ray_validate(ray, input.uv, tDepth, tPBR, camera.projection_matrix,
                 camera.projection_matrix_inverse, camera.view_matrix, trace.distance_tolerance);
             if (unsnapped.status == 0u) { hit = unsnapped; }
         }
@@ -431,7 +433,7 @@ fn water_hzb_hit(ray: Ray, budget: u32) -> ScreenSpaceRayHit {
 `, [chunk_screen_space_newton_ray, chunk_ffx_sssr_advance_ray, chunk_ffx_sssr_load_depth, chunk_project_direction,
     chunk_ray_at]);
 
-for (const resource of [CAMERA_RESOURCE, TRACE_RESOURCE, SCREEN_DEPTH_RESOURCE, SCREEN_HZB_RESOURCE, SCREEN_NORMAL_RESOURCE]) {
+for (const resource of [CAMERA_RESOURCE, TRACE_RESOURCE, SCREEN_DEPTH_RESOURCE, SCREEN_HZB_RESOURCE, SCREEN_PBR_RESOURCE]) {
     chunk_water_screen_ray.requireResource(resource);
 }
 
@@ -448,7 +450,7 @@ struct WaterReceiver {
 // A screen-space receiver must lie below the surface point the ray entered at: the refracted ray runs
 // downward from it, so any point on the ray is lower, and one that is not is a root off the ray.
 fn water_receiver_submerged(uv: vec2f, surface: vec3f, normal: vec3f) -> bool {
-    let receiver = water_receiver_texel(tDepth, tNormal, vec2i(uv * vec2f(textureDimensions(tDepth, 0))),
+    let receiver = water_receiver_texel(tDepth, tNormal, tPBR, vec2i(uv * vec2f(textureDimensions(tDepth, 0))),
         camera.projection_matrix_inverse, camera.view_matrix_inverse);
     return dot(receiver.position - surface, normal) <= WATER_LEVEL_TOLERANCE;
 }
@@ -485,7 +487,7 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterRecei
     if (above && trace.mode == 0u) {
         // Mayer et al. §2.2: a root within one pixel of the ray is accepted as is. Like the paper,
         // this can converge past a thin occluder; traversal is only the fallback for failures.
-        hit = screen_space_newton_ray(ray, uv, tDepth, tNormal, camera.projection_matrix,
+        hit = screen_space_newton_ray(ray, uv, tDepth, tPBR, camera.projection_matrix,
             camera.projection_matrix_inverse, camera.view_matrix, trace.max_updates, trace.distance_tolerance);
         newton_updates = hit.iterations;
         newton_failure = hit.status;
@@ -569,7 +571,7 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
             // vignette validation. Its two-pixel rule must not reject normal-incidence refraction.
             let confidence = ffx_sssr_validate_hit(vec3f(reflected.uv, projected.z), uv,
                 reflection_direction, dimensions, max(trace.distance_tolerance, 0.02), 0.05);
-            let radiance = water_receiver_radiance(tScene, tDepth, tNormal, reflected.uv,
+            let radiance = water_receiver_radiance(tScene, tDepth, tNormal, tPBR, reflected.uv,
                 camera.projection_matrix_inverse, camera.view_matrix_inverse, in.world, interface_normal, false);
             reflection = mix(reflection, radiance.rgb,
                 confidence * min(radiance.a * 2.0, 1.0) * smoothstep(0.05, 0.5, reflected.distance)
@@ -584,14 +586,14 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     let lookup = select(uv, receiver_data.xy, valid);
     // The surface height here stands for the one above the displaced receiver: they differ by the
     // wave height across a few metres, against a tolerance the gather already allows.
-    let gathered = water_receiver_radiance(tScene, tDepth, tNormal, lookup,
+    let gathered = water_receiver_radiance(tScene, tDepth, tNormal, tPBR, lookup,
         camera.projection_matrix_inverse, camera.view_matrix_inverse, in.world, interface_normal, above);
     var path = bitcast<f32>(metadata.x);
     var color = original.rgb;
     // the receiver seen through the surface: refracted, or the pixel's own when there is none
     var receiver_coord = coord;
     if (valid && gathered.a > 0.0) {
-        path = min(water_receiver_path(tDepth, tNormal, lookup, camera.projection_matrix_inverse,
+        path = min(water_receiver_path(tDepth, tPBR, lookup, camera.projection_matrix_inverse,
             camera.view_matrix, origin), limit);
         color = gathered.rgb;
         receiver_coord = vec2i(lookup * dimensions);
@@ -600,7 +602,7 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     // (WATER_OPTICS_PLAN_2026_10_02.md §4.3). Seen from under the surface, the receiver is above it.
     // Its light is rebuilt on the normal it was shaded with: its triangle's turns at every edge of a
     // tessellated floor, and every edge would show through the water.
-    let receiver_texel = water_receiver_texel(tDepth, tNormal, receiver_coord, camera.projection_matrix_inverse,
+    let receiver_texel = water_receiver_texel(tDepth, tNormal, tPBR, receiver_coord, camera.projection_matrix_inverse,
         camera.view_matrix_inverse);
     if (above && !is_background(receiver_texel.depth)) {
         let camera_ws = camera.view_matrix_inverse[3].xyz;

package/src/shade/renderer/wind/GPUSceneWind.d.ts

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#169@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#174@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

package/src/shade/renderer/gbuffer/G_BUFFER_MIP_LEVELS.d.ts

@@ -1,7 +0,0 @@
-/**
- * How many mip levels to generate for each buffer
- * Lower resolution versions are used for further rendering passes that work on fractional resolution, such as 1/2 or 1/4
- * @type {number}
- */
-export const G_BUFFER_MIP_LEVELS: number;
-//# sourceMappingURL=G_BUFFER_MIP_LEVELS.d.ts.map

package/src/shade/renderer/gbuffer/G_BUFFER_MIP_LEVELS.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"G_BUFFER_MIP_LEVELS.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/gbuffer/G_BUFFER_MIP_LEVELS.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,kCAFU,MAAM,CAEqB"}

package/src/shade/renderer/gbuffer/G_BUFFER_MIP_LEVELS.js

@@ -1,6 +0,0 @@
-/**
- * How many mip levels to generate for each buffer
- * Lower resolution versions are used for further rendering passes that work on fractional resolution, such as 1/2 or 1/4
- * @type {number}
- */
-export const G_BUFFER_MIP_LEVELS = 5;