@woosh/meep-engine 3.14.2 → 3.14.3

package/src/shade/renderer/postprocess/taa/TAA.d.ts

@@ -21,14 +21,14 @@ export class TAA {
     /**
      *
      * @param {FrameGraph} graph
-     * @param {number} texture_velocity
+     * @param {number} texture_velocity raw velocity buffer, internal resolution
      * @param {number} texture_color_current
      * @param {number} texture_color_history
      * @param {number} texture_output
-     * @param {number} texture_occlusion
+     * @param {number} texture_occlusion depth-clip pass output: confidence in r, nearest-depth offset in g
      * @param view
      */
-    graph_pass({ graph, texture_velocity, texture_color_current, texture_color_history, texture_output, camera_current, camera_previous, texture_occlusion, }: FrameGraph): number;
+    graph_pass({ graph, texture_velocity, texture_color_current, texture_color_history, texture_output, texture_occlusion, }: FrameGraph): number;
     #private;
 }
 //# sourceMappingURL=TAA.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAQA;IAEI,iBAAgB;IAChB,sBAAqB;IAErB;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA0BtB;;;OAGG;IACH,sCAIC;IAED,mCAEC;IAED;;;OAGG;IACH,6BAmBC;IAED;;;;;;;;;OASG;IACH,+KAmCC;;CACJ"}
+{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAQA;IAEI,iBAAgB;IAChB,sBAAqB;IAErB;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA0BtB;;;OAGG;IACH,sCAIC;IAED,mCAEC;IAED;;;OAGG;IACH,6BAmBC;IAED;;;;;;;;;OASG;IACH,8IA+BC;;CACJ"}

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

@@ -84,11 +84,11 @@ export class TAA {
     /**
      *
      * @param {FrameGraph} graph
-     * @param {number} texture_velocity
+     * @param {number} texture_velocity raw velocity buffer, internal resolution
      * @param {number} texture_color_current
      * @param {number} texture_color_history
      * @param {number} texture_output
-     * @param {number} texture_occlusion
+     * @param {number} texture_occlusion depth-clip pass output: confidence in r, nearest-depth offset in g
      * @param view
      */
     graph_pass({
@@ -97,8 +97,6 @@ export class TAA {
                    texture_color_current = -1,
                    texture_color_history = -1,
                    texture_output,
-                   camera_current = -1,
-                   camera_previous = -1,
                    texture_occlusion = -1,
                }) {
 
@@ -115,8 +113,6 @@ export class TAA {
                 HistoryTexture: texture_color_history,
                 ColourTexture: texture_color_current,
                 tOcclusion: texture_occlusion,
-                camera_current,
-                camera_previous,
                 settings: {
                     jitter: this.Jitter,
                     history_validity,

package/src/shade/renderer/postprocess/taa/chunk_depth_clip_offset_codec.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The depth-clip pass picks one of the 9 texels around a pixel by nearest depth and computes the
+ * history confidence for the velocity found there. It publishes that choice in the g channel of its
+ * rg8unorm output, so a consumer can fetch exactly the velocity the confidence was computed for from
+ * the raw velocity buffer: no repeated search, no second velocity texture.
+ *
+ * Encoding: index / 8 with index = (dy + 1) * 3 + (dx + 1), in [0, 8]. Every index survives 8-bit
+ * unorm quantisation with a margin of at least 0.48 before the decode rounds, pinned in
+ * shader_depth_occlusion_clip.spec.js.
+ *
+ * depth_clip_validated_velocity is the consumer side: given the depth-clip output and the raw
+ * velocity buffer, the velocity the confidence at `coord` was computed for. TAA and ReSTIR temporal
+ * reuse both reproject with it, so a pixel's confidence and its reprojection always agree.
+ * @type {CodeChunk}
+ */
+export const chunk_depth_clip_offset_codec: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_depth_clip_offset_codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_depth_clip_offset_codec.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_depth_clip_offset_codec.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,4CAFU,SAAS,CAoBjB;0BAnCwB,oCAAoC"}

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

@@ -0,0 +1,36 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The depth-clip pass picks one of the 9 texels around a pixel by nearest depth and computes the
+ * history confidence for the velocity found there. It publishes that choice in the g channel of its
+ * rg8unorm output, so a consumer can fetch exactly the velocity the confidence was computed for from
+ * the raw velocity buffer: no repeated search, no second velocity texture.
+ *
+ * Encoding: index / 8 with index = (dy + 1) * 3 + (dx + 1), in [0, 8]. Every index survives 8-bit
+ * unorm quantisation with a margin of at least 0.48 before the decode rounds, pinned in
+ * shader_depth_occlusion_clip.spec.js.
+ *
+ * depth_clip_validated_velocity is the consumer side: given the depth-clip output and the raw
+ * velocity buffer, the velocity the confidence at `coord` was computed for. TAA and ReSTIR temporal
+ * reuse both reproject with it, so a pixel's confidence and its reprojection always agree.
+ * @type {CodeChunk}
+ */
+export const chunk_depth_clip_offset_codec = CodeChunk.from(
+    //language=WGSL
+    `
+fn depth_clip_encode_offset(offset: vec2<i32>) -> f32 {
+    let index = (offset.y + 1) * 3 + (offset.x + 1);
+    return f32(index) / 8.0;
+}
+
+fn depth_clip_decode_offset(encoded: f32) -> vec2<i32> {
+    let index = i32(round(encoded * 8.0));
+    return vec2<i32>(index % 3 - 1, index / 3 - 1);
+}
+
+fn depth_clip_validated_velocity(depth_clip: texture_2d<f32>, velocity: texture_2d<f32>, coord: vec2<i32>) -> vec2<f32> {
+    let encoded = textureLoad(depth_clip, coord, 0).g;
+    return textureLoad(velocity, coord + depth_clip_decode_offset(encoded), 0).rg;
+}
+    `
+);

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_taa_history_color_bounding_box_YCoCg.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_history_color_bounding_box_YCoCg.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,yDAFU,SAAS,CAiElB;0BAzEyB,oCAAoC"}
+{"version":3,"file":"chunk_taa_history_color_bounding_box_YCoCg.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_taa_history_color_bounding_box_YCoCg.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,yDAFU,SAAS,CAoElB;0BA5EyB,oCAAoC"}

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

@@ -43,8 +43,11 @@ fn taa_history_color_bounding_box_YCoCg(
     var moment1 = current_color_YCoCg;
     var moment2 = moment1 * moment1;
     
+    // clamp the gather to the texture: an out-of-bounds textureLoad is implementation-defined in WGSL
+    let last_texel = vec2<i32>(textureDimensions(current_color_texture)) - 1;
+
     for (var  i = 0; i < iteratorMax; i++ ) {
-        let new_st = in_screen_st + offsets[ i ];
+        let new_st = clamp(in_screen_st + offsets[ i ], vec2(0), last_texel);
 
         let new_colour =  taa_encode_color( textureLoad(current_color_texture, new_st, 0 ).rgb );
         

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

@@ -1 +1 @@
-{"version":3,"file":"shader_depth_occlusion_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_depth_occlusion_clip.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,2CAFU,SAAS,CA0DjB;AAkCF,sDAYG;0BA1HuB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_depth_occlusion_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_depth_occlusion_clip.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,2CAFU,SAAS,CA0DjB;AAqCF,sDAaG;0BA/HuB,oCAAoC;4BAClC,6BAA6B"}

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

@@ -4,6 +4,7 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_depth_clip_offset_codec } from "./chunk_depth_clip_offset_codec.js";
 import { chunk_fsr2_compute_depth_clip } from "./chunk_fsr2_compute_depth_clip.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -84,7 +85,7 @@ const body = CodeChunk.from(
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
-) -> @location(0) f32 {
+) -> @location(0) vec2<f32> {
     let render_size = vec2<i32>(textureDimensions(DepthBuffer));
     
     let screenST = vec2<i32>( coord.xy );
@@ -93,8 +94,8 @@ fn main(
     var iNearestDepthCoord:vec2<i32>;
     let depth = ffx_find_nearest_depth( DepthBuffer, screenST, render_size, &iNearestDepthCoord );
 
-    // Velocity is already dilated to the nearest-depth pixel via iNearestDepthCoord
-    // (FSR2's strategy). Don't chain a second magnitude-based dilation on top.
+    // Velocity at the nearest-depth pixel (FSR2's strategy). The choice is published in g below so
+    // the TAA resolve reprojects with the same velocity; don't chain a second dilation on top.
     let velocity = textureLoad( VelocityBuffer, iNearestDepthCoord, 0 ).rg;
 
     let prevFrameScreenST = coord.xy - velocity.xy;
@@ -102,11 +103,14 @@ fn main(
     // get depth confidence factor, larger then 0, assume the history is valid
     let confidence = fsr2_compute_depth_clip( prevFrameScreenST, depth, render_size );
 
-    return saturate(confidence);
+    // r: history confidence. g: which texel won the nearest-depth search, so a consumer can fetch
+    // the velocity this confidence was computed for from the raw velocity buffer.
+    return vec2(saturate(confidence), depth_clip_encode_offset(iNearestDepthCoord - screenST));
 }
     `, [
         chunk_fsr2_compute_depth_clip,
-        chunk_ffx_find_nearest_depth
+        chunk_ffx_find_nearest_depth,
+        chunk_depth_clip_offset_codec,
     ]
 )
 
@@ -117,9 +121,10 @@ export const shader_depth_occlusion_clip = new ImageShader({
         resources,
     }),
     targets: [
-        // Confidence is in [0, 1] post-saturate; r8unorm is sufficient and halves
-        // memory/bandwidth vs r16float. All consumers point-sample this texture.
-        { format: "r8unorm" }
+        // Both channels are point-sampled. r: confidence in [0, 1] post-saturate, 8 bits is enough.
+        // g: nearest-depth offset, see chunk_depth_clip_offset_codec. One byte per pixel over the
+        // old r8unorm buys the TAA resolve the exact velocity this pass validated.
+        { format: "rg8unorm" },
     ]
 
 });

package/src/shade/renderer/postprocess/taa/shader_taa.d.ts

@@ -1,6 +1,6 @@
 export const TAA_VELOCITY_IN_PIXELS_LIMIT: 128;
 /**
- * calculate confidence factor based on the velocity of current pixel, everything moving faster than FRAME_VELOCITY_IN_PIXELS_DIFF frame-to-frame will be marked as no-history
+ * calculate confidence factor based on the velocity of current pixel, everything moving faster than TAA_VELOCITY_IN_PIXELS_LIMIT output pixels frame-to-frame will be marked as no-history
  * @type {CodeChunk}
  */
 export const chunk_taa_velocity_confidence: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AA4CA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA0KF,qCAaG;0BA9PuB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AAuCA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA6LF,qCAaG;0BA9QuB,oCAAoC;4BAClC,6BAA6B"}

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

@@ -1,8 +1,6 @@
 import { f32, vec2f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
-import { chunk_uv_to_texel_coordinate } from "../../shader/chunk/texture/chunk_uv_to_texel_coordinate.js";
 import {
     chunk_texture_sample_catmullrom_hardware_5tap_uv
 } from "../../shader/chunk/texture/sample/chunk_texture_sample_catmullrom_hardware_5tap_uv.js";
@@ -11,8 +9,8 @@ import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { chunk_taa_get_velocity } from "../velocity/chunk_taa_get_velocity.js";
 import { chunk_color_clip_to_aabb3 } from "./chunk_color_clip_to_aabb3.js";
+import { chunk_depth_clip_offset_codec } from "./chunk_depth_clip_offset_codec.js";
 import { chunk_taa_decode_color } from "./chunk_taa_decode_color.js";
 import { chunk_taa_encode_color } from "./chunk_taa_encode_color.js";
 import { chunk_taa_history_color_bounding_box_YCoCg } from "./chunk_taa_history_color_bounding_box_YCoCg.js";
@@ -27,17 +25,14 @@ const TAA_SETTINGS_STRUCT = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// per-pass, 16 bytes, read-only: immediate data rather than a uniform buffer. The two camera
-// uniforms beside it are scene state and stay bound.
+// per-pass, 16 bytes, read-only: immediate data rather than a uniform buffer.
 resources.setImmediate("settings", TAA_SETTINGS_STRUCT);
 resources.createGroup()
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
-    .addTexture("VelocityBuffer", "float") // velocities, in pixels, at internal resolution
+    .addTexture("VelocityBuffer", "float") // raw velocity, in internal pixels
     .addTexture("HistoryTexture", "float") // previous resolved frame, at output resolution.
     .addTexture("ColourTexture", "float") // incoming frame, drawn at internal resolution. Typically lower than output.
-    .addTexture("tOcclusion", "float") // disocclusion, at internal resolution
-    .addUniform("camera_current", CAMERA_UNIFORM_STRUCT)
-    .addUniform("camera_previous", CAMERA_UNIFORM_STRUCT)
+    .addTexture("tOcclusion", "float") // depth-clip pass output at internal resolution: r confidence, g nearest-depth offset
 ;
 
 
@@ -46,7 +41,7 @@ export const TAA_VELOCITY_IN_PIXELS_LIMIT = 128;
 
 
 /**
- * calculate confidence factor based on the velocity of current pixel, everything moving faster than FRAME_VELOCITY_IN_PIXELS_DIFF frame-to-frame will be marked as no-history
+ * calculate confidence factor based on the velocity of current pixel, everything moving faster than TAA_VELOCITY_IN_PIXELS_LIMIT output pixels frame-to-frame will be marked as no-history
  * @type {CodeChunk}
  */
 export const chunk_taa_velocity_confidence = CodeChunk.from(
@@ -111,24 +106,30 @@ fn main(
     let resolution_ratio = vec2<f32>(resolution_internal.xy) / vec2<f32>(resolution_output.xy);
     let upscale_ratio = f32(resolution_output.x) / f32(resolution_internal.x);
 
-    let internal_st = vec2<i32>( output_st.xy * resolution_ratio );
-    
-    // note, we're in reverse-z projection, so jitter is negative
+    // positive jitter shifts rendered content right/down by settings.jitter internal pixels (see
+    // GPUCameraContext), so the un-jittered content of this output pixel sits at uv + jitter / resolution
     let jittered_uv = uv + ( settings.jitter ) / vec2<f32>(resolution_internal);
     let internal_jittered_st = jittered_uv * vec2<f32>(resolution_internal);
+
+    // the internal texel the current colour comes from. Velocity and occlusion are read at the same
+    // texel, so all three describe one surface when the jitter crosses a texel boundary. Clamped:
+    // at the border the jitter can push the position just outside the texture.
+    let internal_st = clamp(vec2<i32>(floor(internal_jittered_st)), vec2(0), vec2<i32>(resolution_internal) - 1);
     
-    // get velocity
-    let velocity = taa_get_velocity( VelocityBuffer, internal_st ) / resolution_ratio;
+    // depth-clip pass output for this texel: r = history confidence, g = which of the 3x3 texels won
+    // its nearest-depth search. The raw velocity at that texel is exactly the velocity the confidence
+    // was computed for; dilating again here would move the reprojection away from what was validated.
+    let occlusion_confidence = textureLoad( tOcclusion, internal_st, 0 ).r;
+
+    // velocity in output pixels
+    let velocity = depth_clip_validated_velocity( tOcclusion, VelocityBuffer, internal_st ) / resolution_ratio;
     
-    // calculate confidence factor based on the velocity of current pixel, everything moving faster than FRAME_VELOCITY_IN_PIXELS_DIFF frame-to-frame will be marked as no-history
+    // calculate confidence factor based on the velocity of current pixel, everything moving faster than TAA_VELOCITY_IN_PIXELS_LIMIT output pixels frame-to-frame will be marked as no-history
     let velocityConfidenceFactor = taa_velocity_confidence(velocity.xy);
 
     // prev frame ST and UV
     let prevFrameScreenST = output_st.xy - velocity.xy;
     
-    // get depth confidence factor, larger then 0, assume the history is valid
-    let occlusion_confidence =  textureLoad(tOcclusion, internal_st, 0).r;
-
     // do we have a valid history?
     let uvWeight = uv_within_screen( prevFrameScreenST ) ;
     
@@ -168,13 +169,12 @@ fn main(
         // sample current colour 
         let color_current_YCoCg = taa_encode_color(color_current_raw);
 
-        // default incoming contribution
-        var blend = 0.05;
-                
-        let history_confidence = color_history_raw.a * velocityConfidenceFactor * occlusion_confidence;
-        
-        // blend less history if hitstory has low confidence or under motion
-        blend = mix(1.0, blend, history_confidence);
+        // accumulated-sample proxy carried in history alpha: n/(n+1) after n samples. Saturated because
+        // the Catmull-Rom taps overshoot across alpha steps.
+        let sample_confidence = saturate(color_history_raw.a);
+
+        // how far this frame trusts the history sample: accumulated count, motion, disocclusion
+        let history_confidence = sample_confidence * velocityConfidenceFactor * occlusion_confidence;
         
         var min_c: vec3<f32>;
         var max_c: vec3<f32>;
@@ -182,7 +182,7 @@ fn main(
         taa_history_color_bounding_box_YCoCg(
             ColourTexture,
             color_current_YCoCg,
-            vec2<i32>(internal_jittered_st),
+            internal_st,
             variance_scale,
             &min_c,
             &max_c,
@@ -196,17 +196,26 @@ fn main(
             max_c,
         );
         
-        // We detect when clamp would occur and dampen the incoming sample's contribution to counteract it. 
-        // see "High Quality Temporal Supersampling" by Brian Karis, EpicGames SIGGRAPH 2014
+        // Tension of the clipped history against the neighbourhood box on its tightest axis: 0 at
+        // the current colour, 1 on a wall, which is where a clipped history always lands.
         let t_clamp = saturate(aabb3_normalized_dist_from_center(
             color_current_YCoCg,
             clipped_history_YCoCg,
             min_c,
             max_c,
         ));
-        
-        blend *= mix(0.2, 1.0, t_clamp * t_clamp);
-        
+
+        // incoming contribution at full confidence. History near the clamp wall gets less of it, down
+        // to a quarter on the wall, which is where a clipped history lands: a clip is an impulse, and
+        // damping the sample that caused it keeps the next frame's clip from taking it straight back,
+        // which reads as flicker. "High Quality Temporal Supersampling" (Karis, SIGGRAPH 2014,
+        // slide 45); the same rule and constants as chunk_volumetrics_taa_resolve.
+        var blend = 0.05 * mix(1.0, 0.25, t_clamp * t_clamp);
+
+        // no confidence: take the current frame outright. Full confidence: the rate above. The
+        // dampening sits inside this mix so zero-confidence history can never reach the output.
+        blend = mix(1.0, blend, history_confidence);
+
         // prevent blending from going to 0
         blend = max(blend, 0.004);
         
@@ -214,7 +223,12 @@ fn main(
         
         var weight_history = (1.0 - blend);
                 
-        let confidence_new = saturate(  1.f  / (  2.0f  - history_confidence ) );
+        // next frame's sample count, from how much of the history this frame kept. At full confidence
+        // the count keeps growing as n/(n+1); a rejected or disoccluded history restarts at one sample
+        // (0.5), the value the no-history branch stores. Motion feeds back through this: under
+        // sustained motion the count settles below converged, so the blend sits above what the
+        // per-frame velocity confidence alone would give.
+        let confidence_new = 1.0 / (2.0 - history_confidence);
  
         let mixed_color = taa_decode_color( mix(color_current_YCoCg, clipped_history_YCoCg, weight_history));
 
@@ -224,8 +238,10 @@ fn main(
     
         // no valid history, or disocclusion
         
-        // initialize with full confidence
-        final_colour = vec4(color_current_raw, 1.0);
+        // one sample. Store the confidence the valid path gives a single sample (confidence_new at
+        // zero history confidence) so the 1/N ramp restarts here; anything higher makes the next
+        // frame treat this lone jittered sample as converged history.
+        final_colour = vec4(color_current_raw, 0.5);
         
     }
     
@@ -235,15 +251,13 @@ fn main(
 `, [
         chunk_taa_decode_color,
         chunk_taa_encode_color,
-        chunk_taa_get_velocity,
         chunk_taa_history_color_bounding_box_YCoCg,
         chunk_color_clip_to_aabb3,
+        chunk_depth_clip_offset_codec,
         chunk_taa_velocity_confidence,
         chunk_taa_velocity_variance_scale,
         chunk_aabb3_normalized_dist,
         chunk_texture_sample_catmullrom_hardware_5tap_uv,
-
-        chunk_uv_to_texel_coordinate,
     ]);
 
 

package/src/shade/renderer/restir/di/chunk_restir_temporal_reuse.d.ts

@@ -6,8 +6,10 @@
  * reprojected location, following the RTXDI temporal pattern (combine each
  * finalized reservoir, then FinalizeResampling once).
  *
- * History validity reuses the existing depth-occlusion-clip confidence (the same
- * reprojection TAA gates on) plus a bounds check, so disocclusions don't ghost.
+ * History validity reuses the depth-occlusion-clip confidence plus a bounds check, so
+ * disocclusions don't ghost, and the reprojection uses the velocity that confidence was
+ * computed for: the depth-clip output's g channel names the nearest-depth texel, and
+ * depth_clip_validated_velocity fetches the raw velocity there, exactly as TAA does.
  * The previous sample's target function is recomputed at the CURRENT surface
  * (never reuse the stored targetPdf), and the previous M is clamped so stale
  * history can't dominate — both are required for an unbiased, lag-bounded result.

package/src/shade/renderer/restir/di/chunk_restir_temporal_reuse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_restir_temporal_reuse.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_temporal_reuse.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0CAFU,SAAS,CA8EjB;0BArGwB,oCAAoC"}
+{"version":3,"file":"chunk_restir_temporal_reuse.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_temporal_reuse.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,0CAFU,SAAS,CA+EjB;0BAxGwB,oCAAoC"}

package/src/shade/renderer/restir/di/chunk_restir_temporal_reuse.js

@@ -4,8 +4,8 @@ import { chunk_rtxdi_unpack_reservoir } from "../reservoir/chunk_rtxdi_unpack_re
 import { RTXDI_Reservoir } from "../reservoir/RTXDI_Reservoir.js";
 import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
 import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
+import { chunk_depth_clip_offset_codec } from "../../postprocess/taa/chunk_depth_clip_offset_codec.js";
 import { chunk_random } from "../../shader/chunk/random/chunk_random.js";
-import { chunk_taa_get_velocity } from "../../postprocess/velocity/chunk_taa_get_velocity.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_restir_get_light_info } from "./chunk_restir_get_light_info.js";
 import { chunk_restir_light_ref } from "./chunk_restir_light_ref.js";
@@ -20,8 +20,10 @@ import { chunk_restir_target_function } from "./chunk_restir_target_function.js"
  * reprojected location, following the RTXDI temporal pattern (combine each
  * finalized reservoir, then FinalizeResampling once).
  *
- * History validity reuses the existing depth-occlusion-clip confidence (the same
- * reprojection TAA gates on) plus a bounds check, so disocclusions don't ghost.
+ * History validity reuses the depth-occlusion-clip confidence plus a bounds check, so
+ * disocclusions don't ghost, and the reprojection uses the velocity that confidence was
+ * computed for: the depth-clip output's g channel names the nearest-depth texel, and
+ * depth_clip_validated_velocity fetches the raw velocity there, exactly as TAA does.
  * The previous sample's target function is recomputed at the CURRENT surface
  * (never reuse the stored targetPdf), and the previous M is clamped so stale
  * history can't dominate — both are required for an unbiased, lag-bounded result.
@@ -59,8 +61,9 @@ fn restir_temporal_reuse(
     // a static camera) into a full +/-1 pixel read error, which shows up as the
     // reservoir field crawling/scrolling across surfaces. + 0.5 then floor is
     // round-to-nearest and is stable for sub-pixel motion (matches the engine's
-    // pixel-centre minus velocity reprojection convention, e.g. GTAO/TAA).
-    let velocity = taa_get_velocity(VelocityBuffer, vec2<i32>(i_coord));
+    // pixel-centre minus velocity reprojection convention, e.g. GTAO/TAA). The velocity is the
+    // one the depth-clip confidence below was evaluated with, so the two cannot disagree.
+    let velocity = depth_clip_validated_velocity(tOcclusionClip, VelocityBuffer, vec2<i32>(i_coord));
     let prev_coord = vec2<i32>(floor(vec2<f32>(i_coord) + vec2<f32>(0.5) - velocity));
 
     // History validity: disocclusion confidence at the current pixel + bounds.
@@ -98,7 +101,7 @@ fn restir_temporal_reuse(
         chunk_rtxdi_combine_reservoirs,
         chunk_rtxdi_finalize_resampling,
         chunk_rtxdi_unpack_reservoir,
-        chunk_taa_get_velocity,
+        chunk_depth_clip_offset_codec,
         chunk_restir_get_light_info,
         chunk_restir_light_ref,
         chunk_restir_reservoir_address,