@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/postprocess/gtao/ao_reproject_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AAwRA;;;;;;;;;;;;;GAaG;AACH,kCAFU,WAAW,CAqBnB;4BA9S0B,6BAA6B"}
+{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AA6RA;;;;;;;;;;;;;GAaG;AACH,kCAFU,WAAW,CAqBnB;4BAhT0B,6BAA6B"}

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

@@ -1,5 +1,8 @@
 import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.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_encode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js";
 import { chunk_f16_round_stochastic } from "../../shader/chunk/math/chunk_f16_round_stochastic.js";
 import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
@@ -39,8 +42,10 @@ resources.createGroup()
     .addTexture("tVelocity")
     .addTexture("tOcclusion")
     .addTexture("tNormal", "uint")
-    // last frame's G-buffer normal, at the size last frame was drawn at
-    .addTexture("tNormalPrevious", "uint")
+    // the G-buffer's PBR target, for its face normal: this frame's, and last frame's at the size it was
+    // drawn at
+    .addTexture("tPBR")
+    .addTexture("tPBRPrevious")
     .addTexture("tHistory","float")
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
 
@@ -102,7 +107,7 @@ const SAME_SURFACE_COS = 0.70710678;
 
 // 1 where the history texel at tap was written on this texel's surface, by its face normal: last frame's
 fn history_texel_on_surface(tap: vec2<i32>, size: vec2<i32>, face_normal: vec3<f32>) -> f32 {
-    let history_face_normal = decode_g_buffer_normal(textureLoad(tNormalPrevious, clamp(tap, vec2(0), size - 1), 0).zw);
+    let history_face_normal = decode_g_buffer_face_normal(textureLoad(tPBRPrevious, clamp(tap, vec2(0), size - 1), 0));
 
     return select(0.0, 1.0, dot(history_face_normal, face_normal) >= SAME_SURFACE_COS);
 }
@@ -110,7 +115,7 @@ fn history_texel_on_surface(tap: vec2<i32>, size: vec2<i32>, face_normal: vec3<f
 // The share of the history's bilinear footprint written on this texel's surface, read where the history is, in
 // the previous normal's own grid.
 fn history_surface_agreement(prev_uv: vec2<f32>, face_normal: vec3<f32>) -> f32 {
-    let size = vec2<i32>(textureDimensions(tNormalPrevious));
+    let size = vec2<i32>(textureDimensions(tPBRPrevious));
 
     let st = prev_uv * vec2<f32>(size) - 0.5;
     let origin = vec2<i32>(floor(st));
@@ -137,7 +142,7 @@ struct Output {
     // visibility and the bend, accumulated: next frame's history
     @location(0) history: vec4<f32>,
     // the bent normal, octahedral as the G-buffer's normals are
-    @location(1) bent_normal: vec2<u32>,
+    @location(1) bent_normal: u32,
 }
 
 @fragment
@@ -151,8 +156,7 @@ fn main(
 
     let occlusion_confidence = textureLoad(tOcclusion, screenST, 0).r;
     let current = textureLoad(tInput, screenST, 0);
-    let encoded_normal = textureLoad(tNormal, screenST, 0);
-    let shading_normal = decode_g_buffer_normal(encoded_normal.xy);
+    let shading_normal = decode_g_buffer_normal(textureLoad(tNormal, screenST, 0).x);
 
     // get velocity
     let velocity = taa_get_velocity( tVelocity, screenST );
@@ -233,7 +237,7 @@ fn main(
         // bend, which added to this surface's normal tilts the bent normal towards that surface: a line along
         // every crease. The bend takes the history only for the share written on this texel's own surface.
         // Visibility is not measured against the normal, and keeps all of it.
-        let surface_agreement = history_surface_agreement(prev_uv, decode_g_buffer_normal(encoded_normal.zw));
+        let surface_agreement = history_surface_agreement(prev_uv, decode_g_buffer_face_normal(textureLoad(tPBR, screenST, 0)));
 
         resolved = vec4(
             mix(current.x, clamped_visibility, history_weight),
@@ -271,6 +275,7 @@ fn main(
         chunk_texture_sample_catmullrom_hardware_5tap_uv,
         chunk_get_std_dev,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_encode_g_buffer_normal,
         chunk_f16_round_stochastic,
         chunk_pcg3d,
@@ -282,13 +287,13 @@ fn main(
  * Accumulates GTAO over time: visibility, and the bend that makes the bent normal.
  *
  * The bend takes the history only where the history was written on this texel's surface, by the face normals of
- * `tNormalPrevious` — last frame's G-buffer normal — against this frame's.
+ * `tPBRPrevious` — last frame's G-buffer PBR target — against this frame's.
  *
  * `tInput`, `tHistory` and the first target are `rgba16float`: visibility in `x`, and in `yzw` the world-space
  * bend — the bent normal minus the shading normal. Each is clamped to this frame's 3x3 neighbourhood before it
  * blends, visibility to a box and the bend to a ball. The second target is the bent normal itself,
- * `normalize(shading normal + bend)`, octahedral in `rg16uint` as the G-buffer normal is, which is what lighting
- * reads.
+ * `normalize(shading normal + bend)`, packed into an `r32uint` as the G-buffer's shading normal is, which is what
+ * lighting reads.
  *
  * @type {ImageShader}
  */
@@ -308,7 +313,7 @@ export const ao_reproject_shader = new ImageShader({
         },
         {
             label: "Bent Normals",
-            format: "rg16uint",
+            format: "r32uint",
         },
     ]
 })

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

@@ -24,7 +24,7 @@ fn horizon_integrate_lighting_sample(
     let tex_coord = uv_to_texel_coordinate(uv, textureDimensions(tNormal).xy);
     let tex_coord_i = vec2<i32>(tex_coord);
 
-    let sample_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, tex_coord_i, 0).xy);
+    let sample_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, tex_coord_i, 0).x);
     
     let cos_vis = dot(ref_normal, sample_normal_ws);
     

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

@@ -131,7 +131,7 @@ fn main(
     let position_vs = project_view_position_from_depth(uv, device_depth, camera.projection_matrix_inverse);
     let view_direction_vs = normalize(-position_vs);
 
-    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).xy); // shading normal
+    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).x); // shading normal
 
     let noiseTexel = spatio_temporal_noise_r2_64(texel_position_u32, settings.frame_index, tNoise);
         

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

@@ -76,7 +76,7 @@ const STEPS = ${QUALITY_SETTINGS.steps};
 
 struct Output{
     @location(0) visibility: vec2<f32>, // first 2 moment
-    @location(1) bent_normal: vec2<u32>, // octahedral encoding
+    @location(1) bent_normal: u32, // octahedral, packed (encode_g_buffer_normal)
     @location(2) irradiance: u32, // rgbe9995
 }
 
@@ -111,7 +111,7 @@ fn main(
     let view_position_ws = mat4_extract_position(camera.view_matrix_inverse);    
     let view_direction_ws = normalize(view_position_ws - position_ws);
     
-    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).xy); // shading normal
+    let view_normal_ws = decode_g_buffer_normal(textureLoad(tNormal, texel_position_u32, 0).x); // shading normal
 
     let noiseTexel = spatio_temporal_noise_r2_64(texel_position_u32, settings.frame_index, tNoise);
         
@@ -418,8 +418,8 @@ export const fragment_shader_gtao_with_irradiance = new ImageShader({
         },
         {
             label: "Bent Normals",
-            // Direction is encoded with octahedral
-            format: "rg16uint",
+            // Direction is encoded with octahedral, packed (encode_g_buffer_normal)
+            format: "r32uint",
         },
         {
             label: "Irradiance",

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/nss/NSS.d.ts

@@ -51,7 +51,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#214@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#216@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

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