SSR: properly handle depth vs camera z

Also, don't use isnan (fix #219)

Author: TheMostDiligent

Shaders/Common/public/PostFX_Common.fxh

@@ -136,4 +136,42 @@ float ComputeSpatialWeight(float Distance, float Sigma)
     return exp(-(Distance) / (2.0 * Sigma * Sigma));
 }
 
+// Samples a depth buffer at the given unnormalized coordinates and returns the interpolated
+// camera space Z value.
+float SampleCameraZFromDepthUC(Texture2D<float> DepthBuffer, 
+                               int2             Dimensions,
+                               float2           Location,
+                               int              MipLevel,
+                               float4x4         Proj)
+{
+    Location -= float2(0.5, 0.5);
+    
+    float2 Location00 = floor(Location);
+    float2 Weights    = Location - Location00;
+    
+    int i0 = clamp(int(Location00.x),     0, Dimensions.x - 1);
+    int j0 = clamp(int(Location00.y),     0, Dimensions.y - 1);
+    int i1 = clamp(int(Location00.x) + 1, 0, Dimensions.x - 1);
+    int j1 = clamp(int(Location00.y) + 1, 0, Dimensions.y - 1);
+ 
+    float Z00 = DepthToCameraZ(DepthBuffer.Load(int3(i0, j0, MipLevel)), Proj);
+    float Z10 = DepthToCameraZ(DepthBuffer.Load(int3(i1, j0, MipLevel)), Proj);
+    float Z01 = DepthToCameraZ(DepthBuffer.Load(int3(i0, j1, MipLevel)), Proj);
+    float Z11 = DepthToCameraZ(DepthBuffer.Load(int3(i1, j1, MipLevel)), Proj);
+    
+    return lerp(lerp(Z00, Z10, Weights.x), 
+                lerp(Z01, Z11, Weights.x),
+                Weights.y);
+}
+
+float SampleCameraZFromDepthUC(Texture2D<float> DepthBuffer, 
+                               float2           Location,
+                               int              MipLevel,
+                               float4x4         Proj)
+{
+    int2 Dimensions;
+    DepthBuffer.GetDimensions(Dimensions.x, Dimensions.y);
+    return SampleCameraZFromDepthUC(DepthBuffer, Dimensions, Location, MipLevel, Proj);
+}
+
 #endif // _POST_FX_COMMON_FXH_

Shaders/PostProcess/ScreenSpaceReflection/private/SSR_ComputeBilateralCleanup.fx

@@ -20,47 +20,47 @@ Texture2D<float>  g_TextureRoughness;
 Texture2D<float4> g_TextureRadiance;
 Texture2D<float>  g_TextureVariance;
 
-float SampleDepth(int2 PixelCoord)
+float LoadDepth(int2 PixelCoord)
 {
     return g_TextureDepth.Load(int3(PixelCoord, 0));
 }
 
-float SampleRoughness(int2 PixelCoord)
+float LoadRoughness(int2 PixelCoord)
 {
     return g_TextureRoughness.Load(int3(PixelCoord, 0));
 }
 
-float3 SampleNormalWS(int2 PixelCoord)
+float3 LoadNormalWS(int2 PixelCoord)
 {
     return g_TextureNormal.Load(int3(PixelCoord, 0));
 }
 
-float4 SampleRadiance(int2 PixelCoord)
+float4 LoadRadiance(int2 PixelCoord)
 {
     return g_TextureRadiance.Load(int3(PixelCoord, 0));
 }
 
-float SampleVariance(int2 PixelCoord)
+float LoadVariance(int2 PixelCoord)
 {
     return g_TextureVariance.Load(int3(PixelCoord, 0));
 }
 
 SSR_ATTRIBUTE_EARLY_DEPTH_STENCIL
 float4 ComputeBilateralCleanupPS(in FullScreenTriangleVSOutput VSOut) : SV_Target0
 {
-    float4 Position = VSOut.f4PixelPos;
+    int2 PixelCoord = int2(VSOut.f4PixelPos.xy);
 
-    float  Roughness   = SampleRoughness(int2(Position.xy));
-    float  Variance    = SampleVariance(int2(Position.xy));
-    float3 NormalWS    = SampleNormalWS(int2(Position.xy));
-    float  LinearDepth = DepthToCameraZ(SampleDepth(int2(Position.xy)), g_Camera.mProj);
-    float2 GradDepth   = float2(ddx(LinearDepth), ddy(LinearDepth));
+    float  Roughness = LoadRoughness(PixelCoord);
+    float  Variance  = LoadVariance(PixelCoord);
+    float3 NormalWS  = LoadNormalWS(PixelCoord);
+    float  CameraZ   = DepthToCameraZ(LoadDepth(PixelCoord), g_Camera.mProj);
+    float2 GradCamZ  = float2(ddx(CameraZ), ddy(CameraZ));
 
     float RoughnessTarget = saturate(float(SSR_BILATERAL_ROUGHNESS_FACTOR) * Roughness);
     float Radius = lerp(0.0, Variance > SSS_BILATERAL_VARIANCE_ESTIMATE_THRESHOLD ? 2.0 : 0.0, RoughnessTarget);
     float Sigma = g_SSRAttribs.BilateralCleanupSpatialSigmaFactor;
     int EffectiveRadius = int(min(2.0 * Sigma, Radius));
-    float4 RadianceResult = SampleRadiance(int2(Position.xy));
+    float4 RadianceResult = LoadRadiance(PixelCoord);
 
     if (Variance > SSR_BILATERAL_VARIANCE_EXIT_THRESHOLD && EffectiveRadius > 0)
     {
@@ -70,24 +70,23 @@ float4 ComputeBilateralCleanupPS(in FullScreenTriangleVSOutput VSOut) : SV_Targe
         {
             for (int y = -EffectiveRadius; y <= EffectiveRadius; y++)
             {
-                int2 Location = ClampScreenCoord(int2(Position.xy) + int2(x, y), int2(g_Camera.f4ViewportSize.xy));
-                float  SampledDepth     = SampleDepth(Location);
-                float  SampledRoughness = SampleRoughness(Location);
-                float4 SampledRadiance  = SampleRadiance(Location);
-                float3 SampledNormalWS  = SampleNormalWS(Location);
+                int2 Location = ClampScreenCoord(PixelCoord + int2(x, y), int2(g_Camera.f4ViewportSize.xy));
+                float  SampledDepth     = LoadDepth(Location);
+                float  SampledRoughness = LoadRoughness(Location);
+                float4 SampledRadiance  = LoadRadiance(Location);
+                float3 SampledNormalWS  = LoadNormalWS(Location);
 
                 if (IsReflectionSample(SampledRoughness, SampledDepth, g_SSRAttribs.RoughnessThreshold))
                 {
-                    float SampledLinearDepth = DepthToCameraZ(SampledDepth, g_Camera.mProj);
+                    float SampledCameraZ = DepthToCameraZ(SampledDepth, g_Camera.mProj);
                     float WeightS = exp(-0.5 * dot(float2(x, y), float2(x, y)) / (Sigma * Sigma));
-                    float WeightZ = exp(-abs(LinearDepth - SampledLinearDepth) / (SSR_BILATERAL_SIGMA_DEPTH * (abs(dot(float2(x, y), GradDepth)) + 1e-6)));
+                    float WeightZ = exp(-abs(CameraZ - SampledCameraZ) / (SSR_BILATERAL_SIGMA_DEPTH * (abs(dot(float2(x, y), GradCamZ)) + 1e-6)));
                     float WeightN = pow(max(0.0, dot(NormalWS, SampledNormalWS)), SSR_BILATERAL_SIGMA_NORMAL);
                     float Weight = WeightS * WeightN * WeightZ;
 
                     WeightSum += Weight;
                     ColorSum  += Weight * SampledRadiance;
                 }
-                
             }
         }
 

Shaders/PostProcess/ScreenSpaceReflection/private/SSR_ComputeHierarchicalDepthBuffer.fx

@@ -5,28 +5,34 @@
 Texture2D<float> g_TextureLastMip;
 #else
 Texture2D<float> g_TextureMips;
-SamplerState     g_TextureMips_sampler;
 #endif
 
 #if SUPPORTED_SHADER_SRV
-float SampleDepth(int2 Location, int2 Offset, int3 Dimension)
+float LoadDepth(int2 Location, int3 Dimension)
 {
-    int2 Position = ClampScreenCoord(Location + Offset, Dimension.xy);
+    int2 Position = ClampScreenCoord(Location, Dimension.xy);
     return g_TextureLastMip.Load(int3(Position, 0));
 }
 #else
-float SampleDepth(int2 Location, int2 Offset, int3 Dimension)
+float LoadDepth(int2 Location, int3 Dimension)
 {
-    int2 Position = ClampScreenCoord(Location + Offset, Dimension.xy);
+    int2 Position = ClampScreenCoord(Location, Dimension.xy);
     return g_TextureMips.Load(int3(Position, Dimension.z));
 }
 #endif
 
+void UpdateClosestDepth(int2 Location, int3 LastMipDimension, inout float MinDepth)
+{
+    float Depth = LoadDepth(Location, LastMipDimension);
+    MinDepth = ClosestDepth(MinDepth, Depth);
+}
+
 float ComputeHierarchicalDepthBufferPS(in FullScreenTriangleVSOutput VSOut) : SV_Target0
 {
     int3 LastMipDimension;
 #if SUPPORTED_SHADER_SRV
     g_TextureLastMip.GetDimensions(LastMipDimension.x, LastMipDimension.y);
+    LastMipDimension.z = 0; // Unused
 #else
     int Dummy;
     g_TextureMips.GetDimensions(0, LastMipDimension.x, LastMipDimension.y, Dummy);
@@ -37,35 +43,30 @@ float ComputeHierarchicalDepthBufferPS(in FullScreenTriangleVSOutput VSOut) : SV
 
     int2 RemappedPosition = int2(2.0 * floor(VSOut.f4PixelPos.xy)); 
 
-    float4 SampledPixels;
-    SampledPixels.x = SampleDepth(RemappedPosition, int2(0, 0), LastMipDimension);
-    SampledPixels.y = SampleDepth(RemappedPosition, int2(0, 1), LastMipDimension);
-    SampledPixels.z = SampleDepth(RemappedPosition, int2(1, 0), LastMipDimension);
-    SampledPixels.w = SampleDepth(RemappedPosition, int2(1, 1), LastMipDimension);
-
-    float MinDepth = ClosestDepth(ClosestDepth(SampledPixels.x, SampledPixels.y),
-                                  ClosestDepth(SampledPixels.z, SampledPixels.w));
+    float MinDepth = DepthFarPlane;
+    UpdateClosestDepth(RemappedPosition + int2(0, 0), LastMipDimension, MinDepth);
+    UpdateClosestDepth(RemappedPosition + int2(0, 1), LastMipDimension, MinDepth);
+    UpdateClosestDepth(RemappedPosition + int2(1, 0), LastMipDimension, MinDepth);
+    UpdateClosestDepth(RemappedPosition + int2(1, 1), LastMipDimension, MinDepth);
 
     bool IsWidthOdd  = (LastMipDimension.x & 1) != 0;
     bool IsHeightOdd = (LastMipDimension.y & 1) != 0;
 
     if (IsWidthOdd)
     {
-        SampledPixels.x = SampleDepth(RemappedPosition, int2(2, 0), LastMipDimension);
-        SampledPixels.y = SampleDepth(RemappedPosition, int2(2, 1), LastMipDimension);
-        MinDepth = ClosestDepth(MinDepth, ClosestDepth(SampledPixels.x, SampledPixels.y));
+        UpdateClosestDepth(RemappedPosition + int2(2, 0), LastMipDimension, MinDepth);
+        UpdateClosestDepth(RemappedPosition + int2(2, 1), LastMipDimension, MinDepth);
     }
 
     if (IsHeightOdd)
     {
-        SampledPixels.x = SampleDepth(RemappedPosition, int2(0, 2), LastMipDimension);
-        SampledPixels.y = SampleDepth(RemappedPosition, int2(1, 2), LastMipDimension);
-        MinDepth = ClosestDepth(MinDepth, ClosestDepth(SampledPixels.x, SampledPixels.y));
+        UpdateClosestDepth(RemappedPosition + int2(0, 2), LastMipDimension, MinDepth);
+        UpdateClosestDepth(RemappedPosition + int2(1, 2), LastMipDimension, MinDepth);
     }
 
     if (IsWidthOdd && IsHeightOdd)
     {
-        MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, int2(2, 2), LastMipDimension));
+        UpdateClosestDepth(RemappedPosition + int2(2, 2), LastMipDimension, MinDepth);
     }
 
     return MinDepth;

Shaders/PostProcess/ScreenSpaceReflection/private/SSR_ComputeIntersection.fx

@@ -28,49 +28,37 @@ Texture2D<float2> g_TextureMotion;
 Texture2D<float2> g_TextureBlueNoise;
 Texture2D<float>  g_TextureDepthHierarchy;
 
-SamplerState g_TextureDepthHierarchy_sampler;
-
-float3 ScreenSpaceToViewSpace(float3 ScreenCoordUV)
-{
-    return InvProjectPosition(ScreenCoordUV, g_Camera.mProjInv);
-}
-
-float3 ScreenSpaceToWorldSpace(float3 ScreenCoordUV)
-{
-    return InvProjectPosition(ScreenCoordUV, g_Camera.mViewProjInv);
-}
-
 float2 GetMipResolution(float2 ScreenDimensions, int MipLevel)
 {
     return ScreenDimensions * rcp(float(1 << MipLevel));
 }
 
-float2 SampleRandomVector2D(int2 PixelCoord)
+float2 LoadRandomVector2D(int2 PixelCoord)
 {
     return g_TextureBlueNoise.Load(int3(PixelCoord & 127, 0));
 }
 
-float SampleRoughness(int2 PixelCoord)
+float LoadRoughness(int2 PixelCoord)
 {
     return g_TextureRoughness.Load(int3(PixelCoord, 0));
 }
 
-float3 SampleNormalWS(int2 PixelCoord)
+float3 LoadNormalWS(int2 PixelCoord)
 {
     return g_TextureNormal.Load(int3(PixelCoord, 0));
 }
 
-float SampleDepthHierarchy(int2 PixelCoord, int MipLevel)
+float LoadDepthHierarchy(int2 PixelCoord, int MipLevel)
 {
     return g_TextureDepthHierarchy.Load(int3(PixelCoord, MipLevel));
 }
 
-float2 SampleMotion(int2 PixelCoord)
+float2 LoadMotion(int2 PixelCoord)
 {
     return g_TextureMotion.Load(int3(PixelCoord, 0)) * F3NDC_XYZ_TO_UVD_SCALE.xy;
 }
 
-float3 SampleRadiance(int2 PixelCoord)
+float3 LoadRadiance(int2 PixelCoord)
 {
     return g_TextureRadiance.Load(int3(PixelCoord, 0));
 }
@@ -182,7 +170,7 @@ float3 HierarchicalRaymarch(float3 Origin, float3 Direction, float2 ScreenSize,
     while (Idx < MaxTraversalIntersections && CurrentMip >= MostDetailedMip)
     {
         float2 CurrentMipPosition = CurrentMipResolution * Position.xy;
-        float SurfaceDepth = SampleDepthHierarchy(int2(CurrentMipPosition), CurrentMip);
+        float SurfaceDepth = LoadDepthHierarchy(int2(CurrentMipPosition), CurrentMip);
         bool SkippedTile = AdvanceRay(Origin, Direction, InvDirection, CurrentMipPosition, InvCurrentMipResolution, FloorOffset, UVOffset, SurfaceDepth, Position, CurrentT);
 
         // Don't increase mip further than this because we did not generate it
@@ -224,13 +212,13 @@ float ValidateHit(float3 Hit, float2 ScreenCoordUV, float3 RayDirectionWS, float
 
     // Don't lookup radiance from the background.
     int2 TexelCoords = int2(ScreenSize * Hit.xy);
-    float SurfaceDepth = SampleDepthHierarchy(TexelCoords, 0);
+    float SurfaceDepth = LoadDepthHierarchy(TexelCoords, 0);
 
     if (IsBackground(SurfaceDepth))
         return 0.0;
 
     // We check if we hit the surface from the back, these should be rejected.
-    float3 HitNormalWS = SampleNormalWS(TexelCoords);
+    float3 HitNormalWS = LoadNormalWS(TexelCoords);
     if (dot(HitNormalWS, RayDirectionWS) > 0.0)
         return 0.0;
 
@@ -271,7 +259,7 @@ float4 SampleReflectionVector(float3 View, float3 Normal, float Roughness, int2
     float3 B = cross(T, N);
     float3x3 TangentToWorld = MatrixFromRows(T, B, N);
 
-    float2 Xi = SampleRandomVector2D(PixelCoord);
+    float2 Xi = LoadRandomVector2D(PixelCoord);
     Xi.y = lerp(Xi.y, 0.0, g_SSRAttribs.GGXImportanceSampleBias);
 
     float3 ViewDirTS = mul(TangentToWorld, View);
@@ -300,15 +288,15 @@ PSOutput ComputeIntersectionPS(in FullScreenTriangleVSOutput VSOut)
 #endif
 
     float2 ScreenCoordUV = Position * g_Camera.f4ViewportSize.zw;
-    float3 NormalWS = SampleNormalWS(int2(Position));
+    float3 NormalWS = LoadNormalWS(int2(Position));
     float3 NormalVS = mul(float4(NormalWS, 0.0), g_Camera.mView).xyz;
-    float Roughness = SampleRoughness(int2(Position));
+    float Roughness = LoadRoughness(int2(Position));
 
     bool IsMirror = IsMirrorReflection(Roughness);
     int MostDetailedMip = IsMirror ? 0 : int(g_SSRAttribs.MostDetailedMip);
     float2 MipResolution = GetMipResolution(g_Camera.f4ViewportSize.xy, MostDetailedMip);
 
-    float3 RayOriginSS = float3(ScreenCoordUV, SampleDepthHierarchy(int2(ScreenCoordUV * MipResolution), MostDetailedMip));
+    float3 RayOriginSS = float3(ScreenCoordUV, LoadDepthHierarchy(int2(ScreenCoordUV * MipResolution), MostDetailedMip));
     float3 RayOriginVS = ScreenXYDepthToViewSpace(RayOriginSS, g_Camera.mProj);
 
     float4 RayDirectionVS = SampleReflectionVector(-normalize(RayOriginVS), NormalVS, Roughness, int2(VSOut.f4PixelPos.xy));
@@ -320,13 +308,13 @@ PSOutput ComputeIntersectionPS(in FullScreenTriangleVSOutput VSOut)
     float3 SurfaceHitVS = ScreenXYDepthToViewSpace(SurfaceHitSS, g_Camera.mProj);
 
 #if SSR_OPTION_PREVIOUS_FRAME
-    float2 Motion = SampleMotion(int2(g_Camera.f4ViewportSize.xy * SurfaceHitSS.xy));
+    float2 Motion = LoadMotion(int2(g_Camera.f4ViewportSize.xy * SurfaceHitSS.xy));
     float2 SurfaceHitSSPrev = SurfaceHitSS.xy - Motion;
     float Confidence = ValidHit ? ValidateHit(SurfaceHitSS, SurfaceHitSSPrev, ScreenCoordUV, RayDirectionWS, g_Camera.f4ViewportSize.xy, g_SSRAttribs.DepthBufferThickness) : 0.0;
-    float3 ReflectionRadiance = Confidence > 0.0f ? SampleRadiance(int2(g_Camera.f4ViewportSize.xy * SurfaceHitSSPrev)) : float3(0.0, 0.0, 0.0);
+    float3 ReflectionRadiance = Confidence > 0.0f ? LoadRadiance(int2(g_Camera.f4ViewportSize.xy * SurfaceHitSSPrev)) : float3(0.0, 0.0, 0.0);
 #else
     float Confidence = ValidHit ? ValidateHit(SurfaceHitSS, ScreenCoordUV, RayDirectionWS, g_Camera.f4ViewportSize.xy, g_SSRAttribs.DepthBufferThickness) : 0.0;
-    float3 ReflectionRadiance = Confidence > 0.0f ? SampleRadiance(int2(g_Camera.f4ViewportSize.xy * SurfaceHitSS.xy)) : float3(0.0, 0.0, 0.0);
+    float3 ReflectionRadiance = Confidence > 0.0f ? LoadRadiance(int2(g_Camera.f4ViewportSize.xy * SurfaceHitSS.xy)) : float3(0.0, 0.0, 0.0);
 #endif
 
     //TODO: Try to store inverse RayDirectionWS for more accuracy.