SSR: a few fixes to support reverse depth (#228)

TheMostDiligent · TheMostDiligent · commit 4eae4512d4d7 · 2025-01-11T12:42:03.000-08:00
diff --git a/Hydrogent/src/Tasks/HnPostProcessTask.cpp b/Hydrogent/src/Tasks/HnPostProcessTask.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2023-2024 Diligent Graphics LLC
+ *  Copyright 2023-2025 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -637,7 +637,10 @@ void HnPostProcessTask::Prepare(pxr::HdTaskContext* TaskCtx,
 
     const TextureDesc& FinalColorDesc = m_FinalColorRTV->GetTexture()->GetDesc();
 
-    m_PostFXContext->PrepareResources(pDevice, {pRenderParam->GetFrameNumber(), FinalColorDesc.Width, FinalColorDesc.Height}, PostFXContext::FEATURE_FLAG_NONE);
+    const PostFXContext::FEATURE_FLAGS PostFXFlags = pRenderParam->GetConfig().UseReverseDepth ?
+        PostFXContext::FEATURE_FLAG_REVERSED_DEPTH :
+        PostFXContext::FEATURE_FLAG_NONE;
+    m_PostFXContext->PrepareResources(pDevice, {pRenderParam->GetFrameNumber(), FinalColorDesc.Width, FinalColorDesc.Height}, PostFXFlags);
     m_SSAO->PrepareResources(pDevice, pCtx, m_PostFXContext.get(), m_Params.SSAOFeatureFlags);
     m_SSR->PrepareResources(pDevice, pCtx, m_PostFXContext.get(), m_Params.SSRFeatureFlags);
     m_TAA->PrepareResources(pDevice, pCtx, m_PostFXContext.get(), m_Params.TAAFeatureFlags);
diff --git a/PostProcess/Common/interface/PostFXContext.hpp b/PostProcess/Common/interface/PostFXContext.hpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2024 Diligent Graphics LLC
+ *  Copyright 2024-2025 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -51,7 +51,7 @@ class PostFXContext
     enum FEATURE_FLAGS : Uint32
     {
         FEATURE_FLAG_NONE                 = 0u,
-        FEATURE_FLAG_REVERSED_DEPTH       = 1u << 0u, // Not implemented
+        FEATURE_FLAG_REVERSED_DEPTH       = 1u << 0u,
         FEATURE_FLAG_HALF_PRECISION_DEPTH = 1u << 1u
     };
 
@@ -154,6 +154,11 @@ class PostFXContext
         return m_SupportedFeatures;
     }
 
+    FEATURE_FLAGS GetFeatureFlags() const
+    {
+        return m_FeatureFlags;
+    }
+
     const FrameDesc& GetFrameDesc() const
     {
         return m_FrameDesc;
diff --git a/PostProcess/ScreenSpaceReflection/interface/ScreenSpaceReflection.hpp b/PostProcess/ScreenSpaceReflection/interface/ScreenSpaceReflection.hpp
@@ -56,17 +56,15 @@ class ScreenSpaceReflection
 public:
     enum FEATURE_FLAGS : Uint32
     {
-        FEATURE_FLAG_NONE           = 0u,
-        FEATURE_FLAG_REVERSED_DEPTH = 1u << 0u, // Not implemented
-        FEATURE_FLAG_PACKED_NORMAL  = 1u << 1u, // Nor implemented
+        FEATURE_FLAG_NONE = 0u,
 
         // When using this flag, you only need to pass the color buffer of the previous frame.
         // We find the intersection using the depth buffer of the current frame, and when an intersection is found,
         // we make the corresponding offset by the velocity vector at the intersection point, for sampling from the color buffer.
-        FEATURE_FLAG_PREVIOUS_FRAME = 1u << 2u,
+        FEATURE_FLAG_PREVIOUS_FRAME = 1u << 0u,
 
         // When this flag is used, ray tracing step is executed at half resolution
-        FEATURE_FLAG_HALF_RESOLUTION = 1u << 3u
+        FEATURE_FLAG_HALF_RESOLUTION = 1u << 1u
     };
 
     struct RenderAttributes
diff --git a/PostProcess/ScreenSpaceReflection/src/ScreenSpaceReflection.cpp b/PostProcess/ScreenSpaceReflection/src/ScreenSpaceReflection.cpp
diff --git a/Shaders/PostProcess/ScreenSpaceReflection/private/SSR_Common.fxh b/Shaders/PostProcess/ScreenSpaceReflection/private/SSR_Common.fxh
@@ -4,10 +4,10 @@
 #include "PostFX_Common.fxh"
 
 #if SSR_OPTION_INVERTED_DEPTH
-    #define MipConvFunc max
+    #define ClosestDepth max
     #define DepthFarPlane 0.0
 #else
-    #define MipConvFunc min
+    #define ClosestDepth min
     #define DepthFarPlane 1.0
 #endif // SSR_OPTION_INVERTED_DEPTH
 
@@ -48,9 +48,9 @@ float2 MapSquareToDisk(float2 Point)
 bool IsBackground(float Depth)
 {
 #if SSR_OPTION_INVERTED_DEPTH
-    return Depth < 1.0e-6f;
+    return Depth < 1.0e-6;
 #else
-    return Depth >= (1.0f - 1.0e-6f);
+    return Depth >= (1.0 - 1.0e-6);
 #endif // SSR_OPTION_INVERTED_DEPTH
 }
 
diff --git a/Shaders/PostProcess/ScreenSpaceReflection/private/SSR_ComputeDownsampledStencilMask.fx b/Shaders/PostProcess/ScreenSpaceReflection/private/SSR_ComputeDownsampledStencilMask.fx
@@ -49,7 +49,7 @@ void ComputeDownsampledStencilMaskPS(in FullScreenTriangleVSOutput VSOut)
     for (uint SampleIdx = 0u; SampleIdx < 4u; ++SampleIdx)
     {
         uint2 Offset = uint2(SampleIdx & 0x01u, SampleIdx >> 1u);
-        MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));
+        MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));
         MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, Offset, TextureDimension));
     }
 
@@ -61,7 +61,7 @@ void ComputeDownsampledStencilMaskPS(in FullScreenTriangleVSOutput VSOut)
         for (uint SampleIdx = 0u; SampleIdx < 2u; ++SampleIdx)
         {
             uint2 Offset = uint2(2u, SampleIdx);
-            MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));
+            MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));
             MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, Offset, TextureDimension));
         }
     }
@@ -71,14 +71,14 @@ void ComputeDownsampledStencilMaskPS(in FullScreenTriangleVSOutput VSOut)
         for (uint SampleIdx = 0u; SampleIdx < 2u; ++SampleIdx)
         {
             uint2 Offset = uint2(SampleIdx, 2);
-            MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));
+            MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));
             MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, Offset, TextureDimension));
         }
     }
     
     if (IsWidthOdd && IsHeightOdd)
     {
-        MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, uint2(2, 2), TextureDimension));
+        MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, uint2(2, 2), TextureDimension));
         MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, uint2(2, 2), TextureDimension));
     }
 
diff --git a/Shaders/PostProcess/ScreenSpaceReflection/private/SSR_ComputeHierarchicalDepthBuffer.fx b/Shaders/PostProcess/ScreenSpaceReflection/private/SSR_ComputeHierarchicalDepthBuffer.fx
@@ -43,7 +43,8 @@ float ComputeHierarchicalDepthBufferPS(in FullScreenTriangleVSOutput VSOut) : SV
     SampledPixels.z = SampleDepth(RemappedPosition, int2(1, 0), LastMipDimension);
     SampledPixels.w = SampleDepth(RemappedPosition, int2(1, 1), LastMipDimension);
 
-    float MinDepth = MipConvFunc(MipConvFunc(SampledPixels.x, SampledPixels.y), MipConvFunc(SampledPixels.z, SampledPixels.w));
+    float MinDepth = ClosestDepth(ClosestDepth(SampledPixels.x, SampledPixels.y),
+                                  ClosestDepth(SampledPixels.z, SampledPixels.w));
 
     bool IsWidthOdd  = (LastMipDimension.x & 1) != 0;
     bool IsHeightOdd = (LastMipDimension.y & 1) != 0;
@@ -52,19 +53,19 @@ float ComputeHierarchicalDepthBufferPS(in FullScreenTriangleVSOutput VSOut) : SV
     {
         SampledPixels.x = SampleDepth(RemappedPosition, int2(2, 0), LastMipDimension);
         SampledPixels.y = SampleDepth(RemappedPosition, int2(2, 1), LastMipDimension);
-        MinDepth = MipConvFunc(MinDepth, MipConvFunc(SampledPixels.x, SampledPixels.y));
+        MinDepth = ClosestDepth(MinDepth, ClosestDepth(SampledPixels.x, SampledPixels.y));
     }
     
     if (IsHeightOdd)
     {
         SampledPixels.x = SampleDepth(RemappedPosition, int2(0, 2), LastMipDimension);
         SampledPixels.y = SampleDepth(RemappedPosition, int2(1, 2), LastMipDimension);
-        MinDepth = MipConvFunc(MinDepth, MipConvFunc(SampledPixels.x, SampledPixels.y));
+        MinDepth = ClosestDepth(MinDepth, ClosestDepth(SampledPixels.x, SampledPixels.y));
     }
     
     if (IsWidthOdd && IsHeightOdd)
     {
-        MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, int2(2, 2), LastMipDimension));
+        MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, int2(2, 2), LastMipDimension));
     }
 
     return MinDepth;

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright 2024 Diligent Graphics LLC`
	`2`	`+ * Copyright 2024-2025 Diligent Graphics LLC`
`3`	`3`	`*`
`4`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`5`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -51,7 +51,7 @@ class PostFXContext`
`51`	`51`	`enum FEATURE_FLAGS : Uint32`
`52`	`52`	`{`
`53`	`53`	`FEATURE_FLAG_NONE = 0u,`
`54`		`- FEATURE_FLAG_REVERSED_DEPTH = 1u << 0u, // Not implemented`
	`54`	`+ FEATURE_FLAG_REVERSED_DEPTH = 1u << 0u,`
`55`	`55`	`FEATURE_FLAG_HALF_PRECISION_DEPTH = 1u << 1u`
`56`	`56`	`};`
`57`	`57`
`@@ -154,6 +154,11 @@ class PostFXContext`
`154`	`154`	`return m_SupportedFeatures;`
`155`	`155`	`}`
`156`	`156`
	`157`	`+ FEATURE_FLAGS GetFeatureFlags() const`
	`158`	`+ {`
	`159`	`+ return m_FeatureFlags;`
	`160`	`+ }`
	`161`	`+`
`157`	`162`	`const FrameDesc& GetFrameDesc() const`
`158`	`163`	`{`
`159`	`164`	`return m_FrameDesc;`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ void ComputeDownsampledStencilMaskPS(in FullScreenTriangleVSOutput VSOut)`
`49`	`49`	`for (uint SampleIdx = 0u; SampleIdx < 4u; ++SampleIdx)`
`50`	`50`	`{`
`51`	`51`	`uint2 Offset = uint2(SampleIdx & 0x01u, SampleIdx >> 1u);`
`52`		`- MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));`
	`52`	`+ MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));`
`53`	`53`	`MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, Offset, TextureDimension));`
`54`	`54`	`}`
`55`	`55`
`@@ -61,7 +61,7 @@ void ComputeDownsampledStencilMaskPS(in FullScreenTriangleVSOutput VSOut)`
`61`	`61`	`for (uint SampleIdx = 0u; SampleIdx < 2u; ++SampleIdx)`
`62`	`62`	`{`
`63`	`63`	`uint2 Offset = uint2(2u, SampleIdx);`
`64`		`- MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));`
	`64`	`+ MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));`
`65`	`65`	`MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, Offset, TextureDimension));`
`66`	`66`	`}`
`67`	`67`	`}`
`@@ -71,14 +71,14 @@ void ComputeDownsampledStencilMaskPS(in FullScreenTriangleVSOutput VSOut)`
`71`	`71`	`for (uint SampleIdx = 0u; SampleIdx < 2u; ++SampleIdx)`
`72`	`72`	`{`
`73`	`73`	`uint2 Offset = uint2(SampleIdx, 2);`
`74`		`- MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));`
	`74`	`+ MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, Offset, TextureDimension));`
`75`	`75`	`MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, Offset, TextureDimension));`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`if (IsWidthOdd && IsHeightOdd)`
`80`	`80`	`{`
`81`		`- MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, uint2(2, 2), TextureDimension));`
	`81`	`+ MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, uint2(2, 2), TextureDimension));`
`82`	`82`	`MaxRoughness = max(MaxRoughness, SampleRoughness(RemappedPosition, uint2(2, 2), TextureDimension));`
`83`	`83`	`}`
`84`	`84`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,8 @@ float ComputeHierarchicalDepthBufferPS(in FullScreenTriangleVSOutput VSOut) : SV`
`43`	`43`	`SampledPixels.z = SampleDepth(RemappedPosition, int2(1, 0), LastMipDimension);`
`44`	`44`	`SampledPixels.w = SampleDepth(RemappedPosition, int2(1, 1), LastMipDimension);`
`45`	`45`
`46`		`- float MinDepth = MipConvFunc(MipConvFunc(SampledPixels.x, SampledPixels.y), MipConvFunc(SampledPixels.z, SampledPixels.w));`
	`46`	`+ float MinDepth = ClosestDepth(ClosestDepth(SampledPixels.x, SampledPixels.y),`
	`47`	`+ ClosestDepth(SampledPixels.z, SampledPixels.w));`
`47`	`48`
`48`	`49`	`bool IsWidthOdd = (LastMipDimension.x & 1) != 0;`
`49`	`50`	`bool IsHeightOdd = (LastMipDimension.y & 1) != 0;`
`@@ -52,19 +53,19 @@ float ComputeHierarchicalDepthBufferPS(in FullScreenTriangleVSOutput VSOut) : SV`
`52`	`53`	`{`
`53`	`54`	`SampledPixels.x = SampleDepth(RemappedPosition, int2(2, 0), LastMipDimension);`
`54`	`55`	`SampledPixels.y = SampleDepth(RemappedPosition, int2(2, 1), LastMipDimension);`
`55`		`- MinDepth = MipConvFunc(MinDepth, MipConvFunc(SampledPixels.x, SampledPixels.y));`
	`56`	`+ MinDepth = ClosestDepth(MinDepth, ClosestDepth(SampledPixels.x, SampledPixels.y));`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`if (IsHeightOdd)`
`59`	`60`	`{`
`60`	`61`	`SampledPixels.x = SampleDepth(RemappedPosition, int2(0, 2), LastMipDimension);`
`61`	`62`	`SampledPixels.y = SampleDepth(RemappedPosition, int2(1, 2), LastMipDimension);`
`62`		`- MinDepth = MipConvFunc(MinDepth, MipConvFunc(SampledPixels.x, SampledPixels.y));`
	`63`	`+ MinDepth = ClosestDepth(MinDepth, ClosestDepth(SampledPixels.x, SampledPixels.y));`
`63`	`64`	`}`
`64`	`65`
`65`	`66`	`if (IsWidthOdd && IsHeightOdd)`
`66`	`67`	`{`
`67`		`- MinDepth = MipConvFunc(MinDepth, SampleDepth(RemappedPosition, int2(2, 2), LastMipDimension));`
	`68`	`+ MinDepth = ClosestDepth(MinDepth, SampleDepth(RemappedPosition, int2(2, 2), LastMipDimension));`
`68`	`69`	`}`
`69`	`70`
`70`	`71`	`return MinDepth;`