[path_tracing] bug fixes

Author: PanosK92

data/shaders/common_resources.hlsl

@@ -53,15 +53,20 @@ Texture2D tex_perlin : register(t14);
 Texture3D tex3d_cloud_shape  : register(t20); // 128^3 Perlin-Worley + Worley FBM
 Texture3D tex3d_cloud_detail : register(t21); // 32^3 high-frequency detail
 // restir reservoir textures (shared across path tracing, temporal, and spatial passes)
+// kept contiguous so a single loop can bind all six slots starting from tex_reservoir_prev0
+// the 6th slot carries the source primary g-buffer for the chosen path so the temporal and
+// spatial passes can evaluate the source brdf and reconnection jacobian without resampling
+// the current frame's g-buffer at a reprojected pixel (which is wrong on motion)
 Texture2D<float4> tex_reservoir_prev0 : register(t22);
 Texture2D<float4> tex_reservoir_prev1 : register(t23);
 Texture2D<float4> tex_reservoir_prev2 : register(t24);
 Texture2D<float4> tex_reservoir_prev3 : register(t25);
 Texture2D<float4> tex_reservoir_prev4 : register(t26);
+Texture2D<float4> tex_reservoir_prev5 : register(t27);
 
 // wind field, baked once per frame, sampled by all wind-driven geometry
 // rg = flow vector (signed, [-1,1]), b = gust pressure (0..1), a = micro turbulence (0..1)
-Texture2D<float4> tex_wind_field : register(t27);
+Texture2D<float4> tex_wind_field : register(t29);
 
 // geometry info buffer for ray tracing (per-blas-instance offsets)
 RWStructuredBuffer<GeometryInfo> geometry_infos : register(u20);
@@ -72,6 +77,7 @@ RWTexture2D<float4> tex_reservoir1 : register(u22);
 RWTexture2D<float4> tex_reservoir2 : register(u23);
 RWTexture2D<float4> tex_reservoir3 : register(u24);
 RWTexture2D<float4> tex_reservoir4 : register(u25);
+RWTexture2D<float4> tex_reservoir5 : register(u26);
 
 // bindless arrays
 Texture2D material_textures[]                            : register(t15, space1);

data/shaders/restir_pt.hlsl

@@ -0,0 +1,124 @@
+/*
+Copyright(c) 2015-2026 Panos Karabelas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+//= INCLUDES ===================
+#include "common.hlsl"
+#include "restir_reservoir.hlsl"
+//==============================
+
+// debug visualization for restir state
+// reads the denoised gi (rgb = color, alpha = variance from the svgf temporal pass), the previous frame reservoirs (M, W, confidence), and produces a viridis heatmap of the requested quantity
+// the result is written to tex_uav in place of the gi color so the composite remultiplies by albedo as usual, producing a tinted but readable overlay
+//
+// debug_mode values match the r.restir_pt_debug_mode cvar list in RenderOptions:
+//   1 = confidence (alpha of reservoir.tex4.w, mapped 0..1)
+//   2 = reservoir M (0..RESTIR_M_CAP)
+//   3 = reservoir W (log scaled since W has high dynamic range)
+//   4 = reuse ratio (placeholder, shows confidence for now)
+//   5 = temporal rejection (placeholder, shows 1 - confidence)
+//   6 = variance (alpha of the denoised gi, log scaled, the svgf per pixel luminance variance)
+
+// viridis colormap, approximated via a small polynomial fit, returns a perceptually uniform color from a [0,1] input
+float3 viridis(float t)
+{
+    t = saturate(t);
+    float3 c0 = float3(0.2777f, 0.0054f, 0.3340f);
+    float3 c1 = float3(0.1056f, 1.4046f, 1.3845f);
+    float3 c2 = float3(-0.3308f, 0.2148f, 0.0950f);
+    float3 c3 = float3(-4.6342f, -5.7991f, -19.3324f);
+    float3 c4 = float3(6.2289f, 14.1799f, 56.6905f);
+    float3 c5 = float3(4.7763f, -13.7451f, -65.3530f);
+    float3 c6 = float3(-5.4354f, 4.6458f, 26.3124f);
+    return saturate(c0 + t * (c1 + t * (c2 + t * (c3 + t * (c4 + t * (c5 + t * c6))))));
+}
+
+[numthreads(THREAD_GROUP_COUNT_X, THREAD_GROUP_COUNT_Y, 1)]
+void main_cs(uint3 dispatch_id : SV_DispatchThreadID)
+{
+    uint2 pixel = dispatch_id.xy;
+    uint resolution_x, resolution_y;
+    tex_uav.GetDimensions(resolution_x, resolution_y);
+    uint2 resolution = uint2(resolution_x, resolution_y);
+
+    if (pixel.x >= resolution.x || pixel.y >= resolution.y)
+    {
+        return;
+    }
+
+    uint mode = uint(buffer_frame.restir_pt_debug_mode);
+    if (mode == 0)
+    {
+        return;
+    }
+
+    // sample what we need based on the mode
+    // reservoir packing matches pack_reservoir / unpack_reservoir in restir_reservoir.hlsl
+    float visualization_t = 0.0f;
+    [branch] switch (mode)
+    {
+        case 1: // confidence (high f16 of tex4.w)
+        {
+            uint  age_conf  = asuint(tex_reservoir_prev4[pixel].w);
+            float confidence = saturate(f16tof32(age_conf >> 16u));
+            visualization_t = confidence;
+            break;
+        }
+        case 2: // reservoir M, normalized by RESTIR_M_CAP for [0,1]
+        {
+            float M = tex_reservoir_prev2[pixel].w;
+            visualization_t = saturate(M / float(RESTIR_M_CAP));
+            break;
+        }
+        case 3: // reservoir W, log scaled since W spans many decades
+        {
+            float W = tex_reservoir_prev3[pixel].x;
+            visualization_t = saturate(log2(W + 1.0f) / 8.0f);
+            break;
+        }
+        case 4: // reuse ratio placeholder, shows confidence (proxy for how much we have reused this reservoir)
+        {
+            uint  age_conf   = asuint(tex_reservoir_prev4[pixel].w);
+            float confidence = saturate(f16tof32(age_conf >> 16u));
+            visualization_t  = confidence;
+            break;
+        }
+        case 5: // temporal rejection placeholder, shows 1 - confidence so freshly rejected pixels are hot
+        {
+            uint  age_conf   = asuint(tex_reservoir_prev4[pixel].w);
+            float confidence = saturate(f16tof32(age_conf >> 16u));
+            visualization_t  = saturate(1.0f - confidence);
+            break;
+        }
+        case 6: // variance (alpha of the denoised gi, log scaled because per pixel variance spans several decades on disocclusion edges)
+        {
+            float variance = max(tex_uav[pixel].a, 0.0f);
+            visualization_t = saturate(log2(variance + 1.0f) / 4.0f);
+            break;
+        }
+    }
+
+    // composition adds light_gi directly when restir is enabled, no albedo remultiply is done
+    // so we write the viridis color straight into the gi slot, the confidence stored in alpha
+    // is preserved so downstream bilateral upsampling still has a sane weight
+    float3 heatmap   = viridis(visualization_t);
+    float  alpha_in  = tex_uav[pixel].a;
+    tex_uav[pixel]   = float4(heatmap, alpha_in);
+}

data/shaders/restir_pt_debug.hlsl

@@ -145,7 +145,8 @@ void main_cs(uint3 dispatch_id : SV_DispatchThreadID)
         tex_reservoir_prev1[pixel],
         tex_reservoir_prev2[pixel],
         tex_reservoir_prev3[pixel],
-        tex_reservoir_prev4[pixel]
+        tex_reservoir_prev4[pixel],
+        tex_reservoir_prev5[pixel]
     );
 
     if (!is_reservoir_valid(center))
@@ -224,7 +225,8 @@ void main_cs(uint3 dispatch_id : SV_DispatchThreadID)
             tex_reservoir_prev1[neighbor_pixel],
             tex_reservoir_prev2[neighbor_pixel],
             tex_reservoir_prev3[neighbor_pixel],
-            tex_reservoir_prev4[neighbor_pixel]
+            tex_reservoir_prev4[neighbor_pixel],
+            tex_reservoir_prev5[neighbor_pixel]
         );
 
         if (!is_reservoir_valid(neighbor) || neighbor.M <= 0.0f || neighbor.W <= 0.0f)
@@ -360,28 +362,32 @@ void main_cs(uint3 dispatch_id : SV_DispatchThreadID)
     combined.confidence = saturate(max(center_confidence, merged_confidence));
     combined.age        = center.age;
 
-    float4 t0, t1, t2, t3, t4;
-    pack_reservoir(combined, t0, t1, t2, t3, t4);
+    // re-stamp source primary g-buffer onto the chosen sample, the spatial combine may have
+    // copied a neighbor's reservoir into combined.sample so the src_* fields may belong to
+    // that neighbor's pixel, downstream passes always want the current pixel's primary as the
+    // source for shifts originating from this pixel
+    combined.sample.src_pos       = pos_ws;
+    combined.sample.src_normal    = normal_ws;
+    combined.sample.src_albedo    = albedo;
+    combined.sample.src_roughness = roughness;
+    combined.sample.src_metallic  = metallic;
+
+    float4 t0, t1, t2, t3, t4, t5;
+    pack_reservoir(combined, t0, t1, t2, t3, t4, t5);
     tex_reservoir0[pixel] = t0;
     tex_reservoir1[pixel] = t1;
     tex_reservoir2[pixel] = t2;
     tex_reservoir3[pixel] = t3;
     tex_reservoir4[pixel] = t4;
+    tex_reservoir5[pixel] = t5;
 
     float3 gi = shade_reservoir_path(combined, pos_ws, normal_ws, view_dir, albedo, roughness, metallic);
     if (any(isnan(gi)) || any(isinf(gi)))
         gi = float3(0, 0, 0);
 
-    // primary direct from all analytical lights with ray-traced visibility
-    // light.hlsl skips analytical lights entirely when restir_pt is enabled, so this is the only
-    // path that adds direct contribution from the sun, area, point, and spot lights to the gi buffer
-    // ibl / sky / emissive geometry remain handled by light_image_based.hlsl and indirect bounces
-    uint direct_seed = create_seed_for_pass(pixel, buffer_frame.frame, 6 + spatial_pass_index);
-    float3 geometric_normal = normal_ws;
-    float3 direct = direct_lighting_at_primary_analytical(
-        pos_ws, normal_ws, geometric_normal, view_dir, albedo, roughness, metallic, direct_seed);
-    if (any(isnan(direct)) || any(isinf(direct)))
-        direct = float3(0, 0, 0);
-
-    tex_uav[pixel] = float4(gi + direct, saturate(combined.confidence));
+    // analytical direct lighting is no longer added here, the initial ris pass already streams
+    // light nee samples into the reservoir alongside brdf samples, so all primary direct +
+    // indirect contributions live inside the reservoir's chosen sample and are shaded above by
+    // shade_reservoir_path, doing both would double count the sun and the area lights
+    tex_uav[pixel] = float4(gi, saturate(combined.confidence));
 }

data/shaders/restir_pt_spatial.hlsl

@@ -123,7 +123,8 @@ void main_cs(uint3 dispatch_id : SV_DispatchThreadID)
         tex_reservoir1[pixel],
         tex_reservoir2[pixel],
         tex_reservoir3[pixel],
-        tex_reservoir4[pixel]
+        tex_reservoir4[pixel],
+        tex_reservoir5[pixel]
     );
 
     if (!is_reservoir_valid(current))
@@ -165,27 +166,23 @@ void main_cs(uint3 dispatch_id : SV_DispatchThreadID)
                 tex_reservoir_prev1[prev_pixel],
                 tex_reservoir_prev2[prev_pixel],
                 tex_reservoir_prev3[prev_pixel],
-                tex_reservoir_prev4[prev_pixel]
+                tex_reservoir_prev4[prev_pixel],
+                tex_reservoir_prev5[prev_pixel]
             );
 
             if (is_reservoir_valid(temporal) && temporal.M > 0.0f && temporal.W > 0.0f)
             {
-                // reconstruct the source primary world position from the reprojected pixel so
-                // the reconnection jacobian correctly recovers the area-measure change between
-                // the previous primary (where the reservoir was built) and the current primary.
-                // for static geometry this is exact, for moving geometry the disocclusion gate
-                // above already rejects large depth deltas so the residual error stays bounded
-                float3 src_primary_pos = get_position(prev_uv);
-
-                // approximate src primary material with current g-buffer at prev_uv; for static
-                // surfaces this is exact, and the disocclusion gate above already rejected
-                // mismatched surfaces so the residual error stays bounded
-                float4 src_material  = tex_material.SampleLevel(GET_SAMPLER(sampler_point_clamp), prev_uv, 0);
-                float3 src_albedo    = saturate(tex_albedo.SampleLevel(GET_SAMPLER(sampler_point_clamp), prev_uv, 0).rgb);
-                float  src_roughness = max(src_material.r, 0.04f);
-                float  src_metallic  = src_material.g;
-                float3 src_normal_ws = get_normal(prev_uv);
-                float3 src_view_dir  = normalize(get_camera_position() - src_primary_pos);
+                // use the stored source primary g-buffer that was captured at the time the
+                // reservoir was generated, this is the actual previous-frame primary surface
+                // and is correct even for moving objects, sampling the current g-buffer at
+                // prev_uv was wrong on motion and caused ghosting / inflated reconnection
+                // jacobians on dynamic scenes
+                float3 src_primary_pos = temporal.sample.src_pos;
+                float3 src_normal_ws   = temporal.sample.src_normal;
+                float3 src_albedo      = temporal.sample.src_albedo;
+                float  src_roughness   = max(temporal.sample.src_roughness, 0.04f);
+                float  src_metallic    = temporal.sample.src_metallic;
+                float3 src_view_dir    = normalize(get_camera_position() - src_primary_pos);
 
                 ShiftResult shift_t_to_c = try_hybrid_shift(
                     temporal.sample,
@@ -310,13 +307,23 @@ void main_cs(uint3 dispatch_id : SV_DispatchThreadID)
     combined.age        = have_temporal ? (temporal.age + 1.0f) : 0.0f;
     combined.confidence = saturate(max(current.confidence, have_temporal ? temporal.confidence * temporal_confidence : 0.0f));
 
-    float4 t0, t1, t2, t3, t4;
-    pack_reservoir(combined, t0, t1, t2, t3, t4);
+    // re-stamp source primary g-buffer onto the chosen sample, the temporal combine may have
+    // copied a reservoir whose chosen sample came from this pixel (canonical) or from the
+    // previous frame, either way the source primary for downstream shifts is the current pixel
+    combined.sample.src_pos       = pos_ws;
+    combined.sample.src_normal    = normal_ws;
+    combined.sample.src_albedo    = albedo;
+    combined.sample.src_roughness = roughness;
+    combined.sample.src_metallic  = metallic;
+
+    float4 t0, t1, t2, t3, t4, t5;
+    pack_reservoir(combined, t0, t1, t2, t3, t4, t5);
     tex_reservoir0[pixel] = t0;
     tex_reservoir1[pixel] = t1;
     tex_reservoir2[pixel] = t2;
     tex_reservoir3[pixel] = t3;
     tex_reservoir4[pixel] = t4;
+    tex_reservoir5[pixel] = t5;
 
     float3 gi = shade_reservoir_path(combined, pos_ws, normal_ws, view_dir, albedo, roughness, metallic);
     if (any(isnan(gi)) || any(isinf(gi)))