@woosh/meep-engine 3.61.3 → 3.62.0

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.js

@@ -65,7 +65,7 @@ fn main(
 
     let phi_luma = phi_visibility * std_dev;
 
-    let current_normal = decode_g_buffer_normal(textureLoad(tNormal, ipos, 0).xy);
+    let current_normal = decode_g_buffer_normal(textureLoad(tNormal, ipos, 0).x);
     let center_depth   = textureLoad(tDepth, ipos, 0).r;
 
     // the centre at weight 1, so the edge-stopping functions cannot leave nothing
@@ -91,7 +91,7 @@ fn main(
 
         let texel = textureLoad(tInput, p, 0);
 
-        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).x);
         let sample_depth  = textureLoad(tDepth, p, 0).r;
 
         let w = compute_edge_stopping_weight(

package/src/shade/renderer/postprocess/ssr/chunk_ssr_spatial_variance.js

@@ -1,41 +1,41 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
-import { chunk_is_on_screen_i32 } from "../../shader/chunk/texture/chunk_is_on_screen_i32.js";
-import { chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight } from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight.js";
-import { chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight } from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight.js";
-
-/** Bootstrap variance from spatial samples when resolve has too few rays to estimate noise. */
-export const chunk_ssr_spatial_variance = CodeChunk.from(/* language=WGSL */ `
-fn ssr_spatial_variance(
-    radiance: texture_2d<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>, p: vec2i,
-) -> f32 {
-    let center_luma = rgb_to_luminance(textureLoad(radiance,p,0).rgb);
-    let center_normal = decode_g_buffer_normal(textureLoad(normals,p,0).xy);
-    let center_depth = textureLoad(depth,p,0).r;
-    let size = vec2i(textureDimensions(radiance));
-    let kernel = array<f32,3>(0.25,0.125,0.0625);
-    var moments = vec2f(0.0);
-    var sum_weight = 0.0;
-    for (var y = -1; y <= 1; y++) {
-        for (var x = -1; x <= 1; x++) {
-            let q = p + vec2i(x,y);
-            if (!is_on_screen_i32(q,size)) { continue; }
-            let sample_normal = decode_g_buffer_normal(textureLoad(normals,q,0).xy);
-            let sample_depth = textureLoad(depth,q,0).r;
-            let weight = kernel[abs(x)+abs(y)]
-                * ffx_dnsr_reflections_get_edge_stopping_normal_weight(center_normal,sample_normal)
-                * ffx_dnsr_reflections_get_edge_stopping_depth_weight(center_depth,sample_depth);
-            // Differences about the centre avoid cancellation for a constant HDR signal.
-            let delta = rgb_to_luminance(textureLoad(radiance,q,0).rgb)-center_luma;
-            moments += vec2f(delta,delta*delta)*weight;
-            sum_weight += weight;
-        }
-    }
-    moments /= max(sum_weight,1e-8);
-    let sigma = get_std_dev(moments.x,moments.y);
-    return sigma*sigma;
-}
-`, [chunk_rgb_to_luminance, chunk_decode_g_buffer_normal, chunk_get_std_dev, chunk_is_on_screen_i32,
-    chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight, chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight]);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
+import { chunk_is_on_screen_i32 } from "../../shader/chunk/texture/chunk_is_on_screen_i32.js";
+import { chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight } from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight.js";
+import { chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight } from "./prefilter/chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight.js";
+
+/** Bootstrap variance from spatial samples when resolve has too few rays to estimate noise. */
+export const chunk_ssr_spatial_variance = CodeChunk.from(/* language=WGSL */ `
+fn ssr_spatial_variance(
+    radiance: texture_2d<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>, p: vec2i,
+) -> f32 {
+    let center_luma = rgb_to_luminance(textureLoad(radiance,p,0).rgb);
+    let center_normal = decode_g_buffer_normal(textureLoad(normals,p,0).x);
+    let center_depth = textureLoad(depth,p,0).r;
+    let size = vec2i(textureDimensions(radiance));
+    let kernel = array<f32,3>(0.25,0.125,0.0625);
+    var moments = vec2f(0.0);
+    var sum_weight = 0.0;
+    for (var y = -1; y <= 1; y++) {
+        for (var x = -1; x <= 1; x++) {
+            let q = p + vec2i(x,y);
+            if (!is_on_screen_i32(q,size)) { continue; }
+            let sample_normal = decode_g_buffer_normal(textureLoad(normals,q,0).x);
+            let sample_depth = textureLoad(depth,q,0).r;
+            let weight = kernel[abs(x)+abs(y)]
+                * ffx_dnsr_reflections_get_edge_stopping_normal_weight(center_normal,sample_normal)
+                * ffx_dnsr_reflections_get_edge_stopping_depth_weight(center_depth,sample_depth);
+            // Differences about the centre avoid cancellation for a constant HDR signal.
+            let delta = rgb_to_luminance(textureLoad(radiance,q,0).rgb)-center_luma;
+            moments += vec2f(delta,delta*delta)*weight;
+            sum_weight += weight;
+        }
+    }
+    moments /= max(sum_weight,1e-8);
+    let sigma = get_std_dev(moments.x,moments.y);
+    return sigma*sigma;
+}
+`, [chunk_rgb_to_luminance, chunk_decode_g_buffer_normal, chunk_get_std_dev, chunk_is_on_screen_i32,
+    chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight, chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight]);

package/src/shade/renderer/postprocess/ssr/prefilter/chunk_load_neighbourhood_sample.js

@@ -22,7 +22,7 @@ fn load_neighbourhood_sample(
     sample.radiance = rv.xyz;
     
     // shading normal
-    sample.normal = decode_g_buffer_normal( textureLoad(tNormal, texel_coordinate, 0).xy );
+    sample.normal = decode_g_buffer_normal( textureLoad(tNormal, texel_coordinate, 0).x );
     
     sample.depth = get_view_space_depth( 
         textureLoad(tDepth, texel_coordinate, 0).r,

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.js

@@ -1,7 +1,7 @@
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
+import { chunk_is_finite } from "../../../shader/chunk/math/chunk_is_finite.js";
 import { F16_MAX_DEFINITION } from "../../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
 import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
@@ -45,7 +45,7 @@ fn ssr_temporal_accumulate(current: vec4f, previous: vec4f, previous_age: f32,
     // uncertainty keeps a chance cluster of misses from clipping a valid mean to
     // black. Real geometry and coherent lighting changes can still rectify it.
     let size = vec2i(textureDimensions(tInput));
-    let center_normal = decode_g_buffer_normal(textureLoad(tNormal, st, 0).xy);
+    let center_normal = decode_g_buffer_normal(textureLoad(tNormal, st, 0).x);
     let center_depth = textureLoad(tDepth, st, 0).r;
     let center_roughness = decode_g_buffer_roughness(textureLoad(tPBR, st, 0));
     var first = vec3f(0.0);
@@ -71,7 +71,7 @@ fn ssr_temporal_accumulate(current: vec4f, previous: vec4f, previous_age: f32,
             for (var x = -2; x <= 2; x++) {
                 let p = st + vec2i(x,y);
                 if (any(p < vec2i(0)) || any(p >= size)) { continue; }
-                let normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+                let normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).x);
                 let depth = textureLoad(tDepth, p, 0).r;
                 if (is_background(depth)) { continue; }
                 let roughness = decode_g_buffer_roughness(textureLoad(tPBR, p, 0));

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_add_hit_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,4CAFU,wBAAwB,CAQhC;AAEF;;;GAGG;AACH,gDAFU,SAAS,CAcR;AAEX;;;;;GAKG;AACH,+CAFU,SAAS,CAyBZ;AAKP;;;;;;;;GAQG;AACH,yDAFU,SAAS,CAsBZ;AAKP;;;;;;;;;;;GAWG;AACH,2CAFU,eAAe,CAE2D;yCAnH3C,sDAAsD;0BAJrE,uCAAuC;gCACjC,6CAA6C"}
+{"version":3,"file":"chunk_ssr_add_hit_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,4CAFU,wBAAwB,CAQhC;AAEF;;;GAGG;AACH,gDAFU,SAAS,CAcR;AAEX;;;;;GAKG;AACH,+CAFU,SAAS,CA0BZ;AAKP;;;;;;;;GAQG;AACH,yDAFU,SAAS,CAuBZ;AAKP;;;;;;;;;;;GAWG;AACH,2CAFU,eAAe,CAE2D;yCArH3C,sDAAsD;0BAJrE,uCAAuC;gCACjC,6CAA6C"}

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js

@@ -2,6 +2,7 @@ import { INDIRECT_LIGHTING } from "../../../INDIRECT_LIGHTING.js";
 import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
 import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
 import { chunk_lpv_sample_irradiance } from "../../../shader/chunk/light/lpv/chunk_lpv_sample_irradiance.js";
+import { chunk_decode_g_buffer_albedo } from "../../../shader/chunk/material/chunk_decode_g_buffer_albedo.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
@@ -63,13 +64,14 @@ fn ssr_add_hit_irradiance(
         let hit_position_ws = v3_matrix4_project(hit_position_vs, camera.view_matrix_inverse);
         let hit_direction_ws = normalize(hit_position_ws - position_ws);
         let hit_irradiance = lpv_sample_irradiance(hit_position_ws, hit_normal_ws, hit_direction_ws);
-        let hit_albedo = textureLoad(tAlbedoAO, hit_coord, 0).rgb;
+        let hit_albedo = decode_g_buffer_albedo(textureLoad(tAlbedoAO, hit_coord, 0).rgb);
         *result += hit_albedo * hit_irradiance * RECIPROCAL_PI;
     }
 }
     `, [
         chunk_lpv_sample_irradiance,
         chunk_v3_matrix4_project,
+        chunk_decode_g_buffer_albedo,
         RECIPROCAL_PI_DECLARATION,
     ]);
 
@@ -98,12 +100,13 @@ fn ssr_add_hit_irradiance(
 ) {
     if (confidence > 0.05) {
         let hit_irradiance = textureLoad(tIndirectDiffuse, hit_coord, 0).rgb;
-        let hit_albedo = textureLoad(tAlbedoAO, hit_coord, 0).rgb;
+        let hit_albedo = decode_g_buffer_albedo(textureLoad(tAlbedoAO, hit_coord, 0).rgb);
 
         *result += hit_albedo * hit_irradiance * RECIPROCAL_PI;
     }
 }
     `, [
+        chunk_decode_g_buffer_albedo,
         RECIPROCAL_PI_DECLARATION,
     ]);
 

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js

@@ -148,7 +148,7 @@ fn main(
     let this_pbr = textureLoad(tPBR, coord_i, 0);
     let this_roughness = decode_g_buffer_roughness(this_pbr);
 
-    let this_normal_ws = decode_g_buffer_normal( textureLoad(tNormal, coord_i, 0).xy );
+    let this_normal_ws = decode_g_buffer_normal( textureLoad(tNormal, coord_i, 0).x );
     let this_normal_vs = direction_world_to_view(this_normal_ws, camera);
 
     let this_position_vs = screen_coordinate_to_view(vec2u(coord_i), tDepth, camera);
@@ -176,7 +176,7 @@ fn main(
             let candidate_distance = length(candidate_position - this_position_vs);
             if (is_finite(candidate_distance) && candidate_distance > 1e-6) {
                 this_hit_position_vs = candidate_position;
-                this_hit_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, this_hit.position, 0).xy);
+                this_hit_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, this_hit.position, 0).x);
                 let hit_normal_vs = direction_world_to_view(this_hit_normal_ws, camera);
                 let mip = get_ray_mip_level(this_position_vs, this_hit_position_vs, hit_normal_vs, this_roughness, focal_length_px);
                 this_hit_color_sample = textureSampleLevel(tColor, sLinear, this_hit_uv, mip).rgb;
@@ -210,7 +210,7 @@ fn main(
         let neighbour_coord = coord_i + NEIGHBOR_OFFSETS[heighbour_index];
         if (!is_on_screen_i32(neighbour_coord, vec2i(render_resolution))) { continue; }
 
-        let neighbour_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, neighbour_coord, 0).xy);
+        let neighbour_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, neighbour_coord, 0).x);
         let neighbour_normal_vs = direction_world_to_view(neighbour_normal_ws, camera);
 
         let neighbour_pbr = textureLoad(tPBR, neighbour_coord, 0);
@@ -234,7 +234,7 @@ fn main(
         let sample_direction = (sample_hit_position_vs - this_position_vs) / sample_distance;
 
         // check visibility
-        let sample_hit_normal_ws = decode_g_buffer_normal( textureLoad(tNormal, sample_hit.position.xy, 0).xy );
+        let sample_hit_normal_ws = decode_g_buffer_normal( textureLoad(tNormal, sample_hit.position.xy, 0).x );
         let sample_hit_normal_vs = direction_world_to_view(sample_hit_normal_ws, camera);
 
         let ray_hit_valid = step( 0, dot(-sample_direction, sample_hit_normal_vs));

package/src/shade/renderer/postprocess/ssr/ssr_combine_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_combine_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_combine_shader.js"],"names":[],"mappings":"AA0HA,6CAWG;4BA3HyB,6BAA6B"}
+{"version":3,"file":"ssr_combine_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_combine_shader.js"],"names":[],"mappings":"AA4HA,6CAWG;4BA5HyB,6BAA6B"}

package/src/shade/renderer/postprocess/ssr/ssr_combine_shader.js

@@ -4,6 +4,7 @@ import { chunk_DFGApprox } from "../../shader/chunk/brdf/dfg/chunk_DFGApprox.js"
 import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_decode_g_buffer_albedo } from "../../shader/chunk/material/chunk_decode_g_buffer_albedo.js";
 import { chunk_decode_g_buffer_metalness } from "../../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
 import { chunk_decode_g_buffer_roughness } from "../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
 import { chunk_metalness_to_specular_color } from "../../shader/chunk/material/chunk_metalness_to_specular_color.js";
@@ -65,9 +66,9 @@ fn main(
     }
     
     let reflection_color = textureLoad(tReflection, coord_i, 0).rgb;
-    let normal_ws = decode_g_buffer_normal(textureLoad(tNormal, coord_i, 0).xy);
+    let normal_ws = decode_g_buffer_normal(textureLoad(tNormal, coord_i, 0).x);
     let albedo_ao = textureLoad(tAlbedoAO, coord_i, 0);
-    let albedo = albedo_ao.rgb;
+    let albedo = decode_g_buffer_albedo(albedo_ao.rgb);
     let occlusion = albedo_ao.a;
     
     let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
@@ -114,6 +115,7 @@ fn main(
         chunk_env_brdf_approx,
         chunk_metalness_to_specular_color,
         chunk_decode_g_buffer_roughness,
+        chunk_decode_g_buffer_albedo,
         chunk_decode_g_buffer_metalness,
         chunk_compute_specular_occlusion,
         chunk_is_background,

package/src/shade/renderer/postprocess/ssr/ssr_graph_prefilter_color.d.ts

@@ -7,7 +7,8 @@
  * @param {FrameGraph} options.graph
  * @param {number} options.input_color
  * @param {number} options.input_depth
- * @param {number} options.mip_count
+ * @param {number} options.mip_count how many levels below the full-size copy to filter; a texture too small to
+ *   have that many gets the levels it has
  * @param {number[]} options.resolution
  */
 export function ssr_graph_prefilter_color({ graph, input_color, input_depth, mip_count, resolution, }: {

package/src/shade/renderer/postprocess/ssr/ssr_graph_prefilter_color.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_graph_prefilter_color.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_graph_prefilter_color.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH;IAN+B,KAAK;IACT,WAAW,EAA3B,MAAM;IACU,WAAW,EAA3B,MAAM;IACU,SAAS,EAAzB,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;QAsGlB"}
+{"version":3,"file":"ssr_graph_prefilter_color.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_graph_prefilter_color.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH;IAP+B,KAAK;IACT,WAAW,EAA3B,MAAM;IACU,WAAW,EAA3B,MAAM;IACU,SAAS,EAAzB,MAAM;IAEY,UAAU,EAA5B,MAAM,EAAE;QA6GlB"}

package/src/shade/renderer/postprocess/ssr/ssr_graph_prefilter_color.js

@@ -15,7 +15,8 @@ import { downsample_karis } from "./downsample_karis.js";
  * @param {FrameGraph} options.graph
  * @param {number} options.input_color
  * @param {number} options.input_depth
- * @param {number} options.mip_count
+ * @param {number} options.mip_count how many levels below the full-size copy to filter; a texture too small to
+ *   have that many gets the levels it has
  * @param {number[]} options.resolution
  */
 export function ssr_graph_prefilter_color({
@@ -55,6 +56,13 @@ export function ssr_graph_prefilter_color({
             ]
         });
 
+        // the full chain of a texture under 2^mip_count texels along its longer side is shorter than that
+        const filtered_levels = Math.min(mip_count, output.descriptor.mipLevelCount - 1);
+
+        if (filtered_levels === 0) {
+            return;
+        }
+
         const sampler = context.graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE);
 
         let source_view = output.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR);
@@ -78,7 +86,7 @@ export function ssr_graph_prefilter_color({
             }]
         })
 
-        for (let i = 1; i < mip_count; i++) {
+        for (let i = 1; i < filtered_levels; i++) {
 
             source_view = destination_view;
             destination_view = output.obtainView(TextureViewDescriptor.from({

package/src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js

@@ -49,7 +49,7 @@ fn main(@builtin(position) coord: vec4f) -> SSRTemporalOutput {
     let st = vec2i(coord.xy);
     let current = textureLoad(tInput, st, 0);
     let metadata = textureLoad(tMetadata, st, 0).rg;
-    let normal = decode_g_buffer_normal(textureLoad(tNormal, st, 0).xy);
+    let normal = decode_g_buffer_normal(textureLoad(tNormal, st, 0).x);
     let roughness = decode_g_buffer_roughness(textureLoad(tPBR, st, 0));
     var output: SSRTemporalOutput;
     output.radiance = current;

package/src/shade/renderer/postprocess/ssr/ssr_spatial_denoise_shader.js

@@ -4,7 +4,7 @@ import { SSR_DENOISE_TILE_SIZE } from "./SSR_DENOISE_TILE_SIZE.js";
 import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_rgb_to_YCoCg } from "../../shader/chunk/color/YCoCg/chunk_rgb_to_YCoCg.js";
 import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
+import { chunk_safe_sqrt } from "../../shader/chunk/math/chunk_safe_sqrt.js";
 import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import {
     chunk_texture_channel_gaussian_3x3
@@ -77,7 +77,7 @@ ${with_metadata ? `    let center_metadata = textureLoad(tMetadata, ipos, 0).rg;
     var distance_moments = ssr_distance_moments(center_metadata.x, center_metadata.y, 1.0);` : ""}
     
     
-    let current_normal = decode_g_buffer_normal( textureLoad(tNormal, ipos, 0).xy );
+    let current_normal = decode_g_buffer_normal( textureLoad(tNormal, ipos, 0).x );
     let center_depth   = textureLoad(tDepth, ipos, 0).r;
     
     const offsets = array< vec2<i32>,8>(
@@ -111,7 +111,7 @@ ${with_metadata ? `    let center_metadata = textureLoad(tMetadata, ipos, 0).rg;
         let sample_color = textureLoad(tInput, p, 0);
         let sample_color_luma = rgb_to_luminance(sample_color.rgb);
 
-        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).x);
         let sample_depth  = textureLoad(tDepth, p, 0).r;
 
         // compute the edge-stopping functions
@@ -154,7 +154,7 @@ ${with_metadata ? `    var output: SSRResolveOutput;
             chunk_ffx_dnsr_reflections_get_edge_stopping_normal_weight,
             chunk_ffx_dnsr_reflections_get_edge_stopping_depth_weight,
             chunk_luma_edge_stopping_weight,
-            F16_MAX_DEFINITION,
+            F16_MAX_DEFINITION,
             chunk_safe_sqrt,
         ]);
 

package/src/shade/renderer/postprocess/taa/shader_reprojection_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_reprojection_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_reprojection_map.js"],"names":[],"mappings":"AAyBA,wDAeE;AAyFF,kDAWE;0BApIwB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_reprojection_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_reprojection_map.js"],"names":[],"mappings":"AA2BA,wDAeE;AAyFF,kDAWE;0BApIwB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/postprocess/taa/shader_reprojection_map.js

@@ -2,7 +2,9 @@ import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../depth/DEPTH_BACKGROUND_VALUE.js";
 import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_get_view_space_position } from "../../shader/chunk/depth/chunk_get_view_space_position.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_v3_matrix4_rotate } from "../../shader/chunk/geometry/vec3/chunk_v3_matrix4_rotate.js";
 import { chunk_texture_gather_channel } from "../../shader/chunk/texture/chunk_texture_gather_channel.js";
 import { chunk_get_bilinear_weights } from "../../shader/chunk/texture/sample/chunk_get_bilinear_weights.js";
@@ -17,7 +19,7 @@ const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
     .addTexture("tDepthCurrent")
     .addTexture("tDepthPrevious")
-    .addTexture("tNormal", "uint")
+    .addTexture("tPBR")
     .addTexture("tVelocity")
     .addUniform("camera_current", CAMERA_UNIFORM_STRUCT)
     .addUniform("camera_previous", CAMERA_UNIFORM_STRUCT)
@@ -75,7 +77,7 @@ fn main(
     let distance_to_point = position_vs.z;
     
     // get geometric normal
-    let normal_ws = decode_g_buffer_normal( textureLoad(tNormal, coord_i, 0).zw );
+    let normal_ws = decode_g_buffer_face_normal( textureLoad(tPBR, coord_i, 0) );
     
     // move normal to view space
     var normal_vs = v3_matrix4_rotate(normal_ws, camera_current.transform_inverse);
@@ -118,7 +120,7 @@ fn main(
 }
     `, [
         chunk_get_view_space_position,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_v3_matrix4_rotate,
         chunk_texture_gather_channel,
         chunk_get_view_space_depth_vec4,

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts

@@ -7,7 +7,7 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
 /**
  * Per-pixel motion-vector pass with three branches:
  *
- *  1. **Background** (no rasterized geometry, `viz_mesh == INVALID`)
+ *  1. **Background** (no rasterized geometry, `VISIBILITY_NONE`)
  *     — rotation-only reprojection of the current pixel through the
  *     camera's frame-over-frame rotation delta. Suitable for skybox
  *     / infinite background.
@@ -39,8 +39,8 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  * @param {object} args
  * @param {FrameGraph} args.graph
  * @param {number} args.texture_depth
- * @param {number} args.texture_viz_mesh
- * @param {number} args.texture_viz_triangle
+ * @param {number} args.texture_visibility the visibility buffer
+ * @param {number} args.buffer_visible_meshlets the frame's visible-meshlet table, which resolves it
  * @param {number} args.buffer_scene_database
  * @param {number} args.buffer_meshlet_metadata
  * @param {number} args.buffer_meshlet_data
@@ -51,14 +51,13 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @param {boolean} [args.enable_mipmap]
  * @returns {number} FrameGraph handle to the velocity texture (rg16float)
  */
-export function graph_add_per_object_velocity({ graph, texture_depth, texture_viz_mesh, texture_viz_triangle, buffer_scene_database, buffer_meshlet_metadata, buffer_meshlet_data, buffer_prev_position_offsets, buffer_prev_positions, skinning_active, resolution, view, enable_mipmap, }: {
+export function graph_add_per_object_velocity({ graph, texture_depth, texture_visibility, buffer_visible_meshlets, buffer_scene_database, buffer_meshlet_metadata, buffer_meshlet_data, buffer_prev_position_offsets, buffer_prev_positions, skinning_active, resolution, view, }: {
     graph: FrameGraph;
     texture_depth: number;
-    texture_viz_mesh: number;
-    texture_viz_triangle: number;
+    texture_visibility: number;
+    buffer_visible_meshlets: number;
     buffer_scene_database: number;
     buffer_meshlet_metadata: number;
     buffer_meshlet_data: number;
@@ -67,7 +66,6 @@ export function graph_add_per_object_velocity({ graph, texture_depth, texture_vi
     skinning_active: boolean;
     resolution: number[];
     view: GPUViewContext;
-    enable_mipmap?: boolean;
 }): number;
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=graph_add_per_object_velocity.d.ts.map

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AAmRA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAjB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,gBAAgB,EAA7B,MAAM;IACO,oBAAoB,EAAjC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACV,aAAa,GAA5B,OAAO;IACL,MAAM,CAgFlB;8BArXY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AAkRA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA8ElB;8BAhXY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -9,8 +9,9 @@ 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 {
     chunk_scene_database_access
 } from "../../scene/chunk_scene_database_access.js";
@@ -44,8 +45,8 @@ const resources = new ShaderResourceSetDescriptor();
 
 resources.createGroup()
     .addTexture("tDepth")
-    .addTexture("tVizMesh", "uint")
-    .addTexture("tVizTriangle", "uint")
+    .addTexture("tVisibility", "uint")
+    .add(VISIBLE_MESHLETS_RESOURCE)
     .addUniform("mReprojectionRotation", mat4x4f)
     // Un-jittered current-frame inverse view-projection and
     // un-jittered previous-frame view-projection. TAA wants
@@ -78,7 +79,6 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const VIZ_INVALID: u32 = ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
 const PREV_POS_OFFSET_INVALID: u32 = 0xFFFFFFFFu;
 
 fn read_prev_position(base: u32, vertex_index: u32) -> vec3<f32> {
@@ -97,14 +97,14 @@ fn main(
 
     let cur_px = coord.xy;
     let texel = vec2<u32>(cur_px);
-    let mesh_id = textureLoad(tVizMesh, texel, 0).r;
+    let visibility_word = textureLoad(tVisibility, texel, 0).r;
 
     // ── Background: rotation-only reprojection ──────────────────
     //
-    // Visibility-buffer clears leave mesh_id == VIZ_INVALID on sky
+    // Visibility-buffer clears leave VISIBILITY_NONE on sky
     // pixels, where reverse-Z depth is always 0.0. Passing 0.0
     // directly avoids a tDepth textureLoad on every background pixel.
-    if mesh_id == VIZ_INVALID {
+    if visibility_word == VISIBILITY_NONE {
         let position_previous = v3_matrix4_project(
             vec3<f32>(cur_px, 0.0),
             mReprojectionRotation
@@ -123,16 +123,16 @@ fn main(
     let cur_world_h = mInvViewProjCurrent * vec4<f32>(cur_ndc, 1.0);
     let cur_world = cur_world_h.xyz / cur_world_h.w;
 
-    let mesh = scene_read_mesh(&scene_database, mesh_id);
+    let visibility_texel = visibility_decode(visibility_word);
+
+    let mesh = scene_read_mesh(&scene_database, visibility_texel.mesh);
     let node = scene_read_node(&scene_database, mesh.node);
 
     // ── Skinned vs static fork ─────────────────────────────────
     //
-    // viz_triangle encodes (meshlet_id, triangle_local) via
-    // encode_meshlet_element — upper 24 bits meshlet, lower 8 bits
-    // triangle-within-meshlet. Look up the per-meshlet
-    // prev-position offset; sentinel means "not a skinned clone,
-    // use rigid per-object math".
+    // The visibility word names the meshlet and the triangle within
+    // it. Look up the per-meshlet prev-position offset; sentinel
+    // means "not a skinned clone, use rigid per-object math".
     //
     // The per-vertex skinning path reads prev_position_offsets /
     // prev_positions, which only hold valid data when a skinned mesh is
@@ -140,17 +140,15 @@ fn main(
     // bindings (the scene_database buffer) and reading them would feed
     // garbage offsets into the skinned branch — a non-sentinel word
     // there sends a static triangle down the per-vertex path and
-    // fabricates a constant phantom velocity. Gate both the tVizTriangle
-    // textureLoad and the offset buffer read on skinning_active so
-    // non-skinned scenes skip the full-screen tVizTriangle fetch and
-    // every pixel takes the rigid per-object path.
+    // fabricates a constant phantom velocity. Gate the offset buffer
+    // read on skinning_active so every pixel of a non-skinned scene
+    // takes the rigid per-object path.
     var meshlet_id = 0u;
     var tri_local = 0u;
     var prev_pos_base = PREV_POS_OFFSET_INVALID;
     if skinning_active.value != 0u {
-        let triangle_packed = textureLoad(tVizTriangle, texel, 0).r;
-        meshlet_id = (triangle_packed >> 8u) & 0x00FFFFFFu;
-        tri_local = triangle_packed & 0xFFu;
+        meshlet_id = visibility_texel.meshlet;
+        tri_local = visibility_texel.triangle;
         prev_pos_base = prev_position_offsets[meshlet_id];
     }
 
@@ -253,6 +251,7 @@ fn main(
         chunk_read_meshlet_resolved_index,
         chunk_read_meshlet_vertex_position,
         MESHLET_METADATA_STRUCT.declaration_chunk,
+        chunk_visibility_decode,
     ]
 );
 
@@ -285,7 +284,7 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
 /**
  * Per-pixel motion-vector pass with three branches:
  *
- *  1. **Background** (no rasterized geometry, `viz_mesh == INVALID`)
+ *  1. **Background** (no rasterized geometry, `VISIBILITY_NONE`)
  *     — rotation-only reprojection of the current pixel through the
  *     camera's frame-over-frame rotation delta. Suitable for skybox
  *     / infinite background.
@@ -317,8 +316,8 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  * @param {object} args
  * @param {FrameGraph} args.graph
  * @param {number} args.texture_depth
- * @param {number} args.texture_viz_mesh
- * @param {number} args.texture_viz_triangle
+ * @param {number} args.texture_visibility the visibility buffer
+ * @param {number} args.buffer_visible_meshlets the frame's visible-meshlet table, which resolves it
  * @param {number} args.buffer_scene_database
  * @param {number} args.buffer_meshlet_metadata
  * @param {number} args.buffer_meshlet_data
@@ -329,14 +328,13 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @param {boolean} [args.enable_mipmap]
  * @returns {number} FrameGraph handle to the velocity texture (rg16float)
  */
 export function graph_add_per_object_velocity({
                                                   graph,
                                                   texture_depth,
-                                                  texture_viz_mesh,
-                                                  texture_viz_triangle,
+                                                  texture_visibility,
+                                                  buffer_visible_meshlets,
                                                   buffer_scene_database,
                                                   buffer_meshlet_metadata,
                                                   buffer_meshlet_data,
@@ -345,13 +343,12 @@ export function graph_add_per_object_velocity({
                                                   skinning_active,
                                                   resolution,
                                                   view,
-                                                  enable_mipmap = false,
                                               }) {
 
     assert.defined(view, 'view');
     assert.isNonNegativeInteger(texture_depth, 'texture_depth');
-    assert.isNonNegativeInteger(texture_viz_mesh, 'texture_viz_mesh');
-    assert.isNonNegativeInteger(texture_viz_triangle, 'texture_viz_triangle');
+    assert.isNonNegativeInteger(texture_visibility, 'texture_visibility');
+    assert.isNonNegativeInteger(buffer_visible_meshlets, 'buffer_visible_meshlets');
     assert.isNonNegativeInteger(buffer_scene_database, 'buffer_scene_database');
     assert.isNonNegativeInteger(buffer_meshlet_metadata, 'buffer_meshlet_metadata');
     assert.isNonNegativeInteger(buffer_meshlet_data, 'buffer_meshlet_data');
@@ -395,8 +392,8 @@ export function graph_add_per_object_velocity({
         shader,
         inputs: {
             tDepth: texture_depth,
-            tVizMesh: texture_viz_mesh,
-            tVizTriangle: texture_viz_triangle,
+            tVisibility: texture_visibility,
+            visible_meshlets: buffer_visible_meshlets,
             mReprojectionRotation: reprojection_matrix_pixels_rotation,
             mInvViewProjCurrent: scratch_unjit_inv_view_proj_curr_f32,
             mViewProjPrevious: scratch_unjit_view_proj_prev_f32,
@@ -408,6 +405,5 @@ export function graph_add_per_object_velocity({
             prev_positions: buffer_prev_positions,
         },
         output_resolution: resolution,
-        output_mipmaps: enable_mipmap,
     })[0];
 }

package/src/shade/renderer/rasterize/TemplatePassDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TemplatePassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/TemplatePassDescriptor.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA0CI;;;;OAIG;IACH,mBAJW,MAAM,gBACG,qBAAqB,QAAE,eAAe,KAAG,wBAAwB,EAWpF;IA3CD;;OAEG;IACH,gCAEC;IAwCD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,sBAAsB,CAwBlC;IAED;;;;;;;OAOG;IACH,gHAEC;IAED;;;OAGG;IACH,cAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,uCAHW,qBAAqB,GACnB,wBAAwB,CAYpC;IAED;;;;;OAKG;IACH,kCALW,qBAAqB,YACrB,qBAAqB,6CAsC/B;IAGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;;CANxD;uCAlMY,OAAO,8DAA8D,EAAE,wBAAwB;uCAC/F,OAAO,uDAAuD,EAAE,wBAAwB;oCACxF,OAAO,gDAAgD,EAAE,qBAAqB;oCAC9E,OAAO,+CAA+C,EAAE,qBAAqB;qCANrD,wCAAwC;gCAD7C,uCAAuC"}
+{"version":3,"file":"TemplatePassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/TemplatePassDescriptor.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA0CI;;;;OAIG;IACH,mBAJW,MAAM,gBACG,qBAAqB,QAAE,eAAe,KAAG,wBAAwB,EAWpF;IA3CD;;OAEG;IACH,gCAEC;IAwCD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,sBAAsB,CAyBlC;IAED;;;;;;;OAOG;IACH,gHAEC;IAED;;;OAGG;IACH,cAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,uCAHW,qBAAqB,GACnB,wBAAwB,CAYpC;IAED;;;;;OAKG;IACH,kCALW,qBAAqB,YACrB,qBAAqB,6CAsC/B;IAGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;;CANxD;uCAnMY,OAAO,8DAA8D,EAAE,wBAAwB;uCAC/F,OAAO,uDAAuD,EAAE,wBAAwB;oCACxF,OAAO,gDAAgD,EAAE,qBAAqB;oCAC9E,OAAO,+CAA+C,EAAE,qBAAqB;qCANrD,wCAAwC;gCAD7C,uCAAuC"}