SSR Improvement

com.unity.render-pipelines.high-definition/CHANGELOG.md

@@ -96,6 +96,7 @@ The version number for this package has increased due to a version update of a r
 - Added the support of eye shader for ray tracing.
 - Exposed Refraction Model to the material UI when using a Lit ShaderGraph.
 - Added bounding sphere support to screen-space axis-aligned bounding box generation pass.
+- Added new algorithm for SSR with temporal accumulation
 
 ### Fixed
 - Fixed several issues with physically-based DoF (TAA ghosting of the CoC buffer, smooth layer transitions, etc)

com.unity.render-pipelines.high-definition/Documentation~/Override-Screen-Space-Reflection.md

@@ -27,13 +27,15 @@ HDRP uses the [Volume](Volumes.md) framework to calculate SSR, so to enable and
 | **Property**                  | **Description**                                              |
 | ----------------------------- | ------------------------------------------------------------ |
 | **Enable**                    | Indicates whether HDRP processes SSR for Cameras in the influence of this effect's Volume . |
+| **Algorithm**                 | Unity provide two algorithm 'Approximation' and 'PBR Accumulation'. 'Approximation' is the regular one which try to have fast and less precise, 'PBR Accumulation' provide a more precise SSR by accumulating through multiple frames (controlable with 'Accumulation Factor'). |
 | **Minimum Smoothness**        | Use the slider to set the minimum amount of surface smoothness at which HDRP performs SSR tracing. Lower values result in HDRP performing SSR tracing for less smooth GameObjects. |
 | **Smoothness Fade Start**     | Use the slider to set the smoothness value at which SSR reflections begin to fade out. Lower values result in HDRP fading out SSR reflections for less smooth GameObjects |
 | **Reflect Sky**               | Indicates whether HDRP should use SSR to handle sky reflection. If you disable this property, pixels that reflect the sky use the next level of the [reflection hierarchy](Reflection-in-HDRP.md#ReflectionHierarchy).<br />**Note**: SSR uses the depth buffer to calculate reflection and HDRP does not add transparent GameObjects to the depth buffer. If you enable this property, transparent GameObject that appear over the sky in the color buffer can cause visual artifacts and incorrect looking reflection. This is a common limitation for SSR techniques. |
 | **Screen Edge Fade Distance** | Use the slider to control the distance at which HDRP fades out screen space reflections when the destination of the ray is near the boundaries of the screen. Increase this value to increase the distance from the screen edge at which HDRP fades out screen space reflections for a ray destination. |
 | **Object Thickness**          | Use the slider to control the thickness of the GameObjects on screen. Because the SSR algorithm can not distinguish thin GameObjects from thick ones, this property helps trace rays behind GameObjects. The algorithm applies this property to every GameObject uniformly. |
 | **Quality**                   | Specifies the quality level to use for this effect. Each quality level applies different preset values. Unity also stops you from editing the properties that the preset overrides. If you want to set your own values for every property, select **Custom**. |
 | **Max Ray Steps**             | Sets the maximum number of iterations that the algorithm can execute before it stops trying to find an intersection with a Mesh. For example, if you set the number of iterations to 1000 and the algorithm only needs 10 to find an intersection, the algorithm terminates after 10 iterations. If you set this value too low, the algorithm may terminate too early and abruptly stop reflections. |
+| **Accumulation Factor**       | Use the slider to control the speed of converge. 0 means no accumulation. 1 means accumulation is very slow which is useful for fixed image. Use carefuly to find a balance between convergence and ghosting. The more rough the reflection surfaces is, the more accumulation it will need to have a converged image without noise. |
 
 ## Limitations
 

com.unity.render-pipelines.high-definition/Documentation~/whats-new-10.md

@@ -199,6 +199,12 @@ This version of HDRP introduces a new injection point for custom post-processing
 
 HDRP, being a high-end modern renderer, contains a lot of compute shader passes. Up until now, to define variations of some compute shaders, HDRP had to manually declare new kernels for each variation. From this version, every compute shader in HDRP uses Unity's multi-compile API which makes maintenance easier, but more importantly allows HDRP to strip shaders that you do not need to improve compilation times.
 
+### Screen Space Reflection
+
+![](Images/HDRP-SSRImprovement.png)
+
+HDRP improves the Screen Space Reflection by providing a new implementation 'PBR Accumulation'
+
 ### Planar reflection probe filtering
 
 ![](Images/PlanarReflectionFiltering-Feature.png)

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/HDScreenSpaceReflectionEditor.cs

@@ -9,6 +9,7 @@ namespace UnityEditor.Rendering.HighDefinition
     class HDScreenSpaceReflectionEditor : VolumeComponentWithQualityEditor
     {
         SerializedDataParameter m_Enable;
+        SerializedDataParameter m_UsedAlgorithm;
         SerializedDataParameter m_RayTracing;
 
         // Shared data
@@ -20,6 +21,7 @@ class HDScreenSpaceReflectionEditor : VolumeComponentWithQualityEditor
         SerializedDataParameter m_ScreenFadeDistance;
         SerializedDataParameter m_RayMaxIterations;
         SerializedDataParameter m_DepthBufferThickness;
+        SerializedDataParameter m_AccumulationFactor;
 
         // Ray Tracing
         SerializedDataParameter m_LayerMask;
@@ -41,6 +43,7 @@ public override void OnEnable()
         {
             var o = new PropertyFetcher<ScreenSpaceReflection>(serializedObject);
             m_Enable                        = Unpack(o.Find(x => x.enabled));
+            m_UsedAlgorithm                 = Unpack(o.Find(x => x.usedAlgorithm));
             m_RayTracing                    = Unpack(o.Find(x => x.rayTracing));
 
             // Shared data
@@ -52,6 +55,7 @@ public override void OnEnable()
             m_DepthBufferThickness          = Unpack(o.Find(x => x.depthBufferThickness));
             m_RayMaxIterations              = Unpack(o.Find(x => x.rayMaxIterations));
             m_ScreenFadeDistance            = Unpack(o.Find(x => x.screenFadeDistance));
+            m_AccumulationFactor            = Unpack(o.Find(x => x.accumulationFactor));
 
             // Generic ray tracing
             m_LayerMask                     = Unpack(o.Find(x => x.layerMask));
@@ -72,12 +76,14 @@ public override void OnEnable()
             base.OnEnable();
         }
 
+        static public readonly GUIContent k_Algo = EditorGUIUtility.TrTextContent("Algorithm", "The screen space reflection algorithm used.");
         static public readonly GUIContent k_RayTracingText = EditorGUIUtility.TrTextContent("Ray Tracing (Preview)", "Enable ray traced reflections.");
         static public readonly GUIContent k_ReflectSkyText = EditorGUIUtility.TrTextContent("Reflect Sky", "When enabled, SSR handles sky reflection.");
         static public readonly GUIContent k_LayerMaskText = EditorGUIUtility.TrTextContent("Layer Mask", "Layer mask used to include the objects for screen space reflection.");
         static public readonly GUIContent k_MinimumSmoothnessText = EditorGUIUtility.TrTextContent("Minimum Smoothness", "Controls the smoothness value at which HDRP activates SSR and the smoothness-controlled fade out stops.");
         static public readonly GUIContent k_SmoothnessFadeStartText = EditorGUIUtility.TrTextContent("Smoothness Fade Start", "Controls the smoothness value at which the smoothness-controlled fade out starts. The fade is in the range [Min Smoothness, Smoothness Fade Start].");
         static public readonly GUIContent k_ScreenFaceDistanceText = EditorGUIUtility.TrTextContent("Screen Edge Fade Distance", "Controls the distance at which HDRP fades out SSR near the edge of the screen.");
+        static public readonly GUIContent k_AccumulationFactorText = EditorGUIUtility.TrTextContent("Accumulation Factor", "Controls Controls the amount of accumulation (0 no accumulation, 1 just accumulate).");
         static public readonly GUIContent k_DepthBufferThicknessText = EditorGUIUtility.TrTextContent("Object Thickness", "Controls the typical thickness of objects the reflection rays may pass behind.");
         static public readonly GUIContent k_RayMaxIterationsText = EditorGUIUtility.TrTextContent("Max Ray Steps", "Sets the maximum number of steps HDRP uses for raytracing. Affects both correctness and performance.");
         static public readonly GUIContent k_RayLengthText = EditorGUIUtility.TrTextContent("Max Ray Length", "Controls the maximal length of reflection rays. The higher this value is, the more expensive ray traced reflections are.");
@@ -106,7 +112,6 @@ void RayTracingQualityModeGUI()
             }
         }
 
-
         void RayTracingPerformanceModeGUI()
         {
             base.OnInspectorGUI();
@@ -191,12 +196,16 @@ public override void OnInspectorGUI()
             }
             else
             {
+                PropertyField(m_UsedAlgorithm, k_Algo);
+
                 // Shared Data
                 PropertyField(m_MinSmoothness, k_MinimumSmoothnessText);
                 PropertyField(m_SmoothnessFadeStart, k_SmoothnessFadeStartText);
                 PropertyField(m_ReflectSky, k_ReflectSkyText);
                 m_SmoothnessFadeStart.value.floatValue  = Mathf.Max(m_MinSmoothness.value.floatValue, m_SmoothnessFadeStart.value.floatValue);
-                PropertyField(m_ScreenFadeDistance, k_ScreenFaceDistanceText);
+
+                if (m_UsedAlgorithm.value.intValue != (int)ScreenSpaceReflectionAlgorithm.PBRAccumulation)
+                    PropertyField(m_ScreenFadeDistance, k_ScreenFaceDistanceText);
                 PropertyField(m_DepthBufferThickness, k_DepthBufferThicknessText);
 
                 m_DepthBufferThickness.value.floatValue = Mathf.Clamp(m_DepthBufferThickness.value.floatValue, 0.001f, 1.0f);
@@ -209,6 +218,8 @@ public override void OnInspectorGUI()
                     PropertyField(m_RayMaxIterations, k_RayMaxIterationsText);
                     m_RayMaxIterations.value.intValue = Mathf.Max(0, m_RayMaxIterations.value.intValue);
                 }
+                if (m_UsedAlgorithm.value.intValue == (int)ScreenSpaceReflectionAlgorithm.PBRAccumulation)
+                    PropertyField(m_AccumulationFactor, k_AccumulationFactorText);
             }
         }
         public override QualitySettingsBlob SaveCustomQualitySettingsAsObject(QualitySettingsBlob settings = null)

com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs

@@ -57,7 +57,7 @@ public enum FullScreenDebugMode
         MinLightingFullScreenDebug,
         /// <summary>Display Screen Space Ambient Occlusion buffer.</summary>
         ScreenSpaceAmbientOcclusion,
-        /// <summary>Display Screen Space Reflections buffer.</summary>
+        /// <summary>Display Screen Space Reflections buffer used for lighting.</summary>
         ScreenSpaceReflections,
         /// <summary>Display the Transparent Screen Space Reflections buffer.</summary>
         TransparentScreenSpaceReflections,
@@ -116,7 +116,12 @@ public enum FullScreenDebugMode
         /// <summary>Display specular Color validation mode.</summary>
         ValidateSpecularColor,
         /// <summary>Maximum Full Screen Material debug mode value (used internally).</summary>
-        MaxMaterialFullScreenDebug
+        MaxMaterialFullScreenDebug,
+        // TODO: Move before count for 11.0
+        /// <summary>Display Screen Space Reflections buffer of the previous frame accumulated.</summary>
+        ScreenSpaceReflectionsPrev,
+        /// <summary>Display Screen Space Reflections buffer of the current frame hit.</summary>
+        ScreenSpaceReflectionsAccum
     }
 
     /// <summary>
@@ -1944,7 +1949,7 @@ internal bool DebugNeedsExposure()
                     debugLighting == DebugLightingMode.DiffuseLighting || debugLighting == DebugLightingMode.SpecularLighting || debugLighting == DebugLightingMode.VisualizeCascade) ||
                     (data.lightingDebugSettings.overrideAlbedo || data.lightingDebugSettings.overrideNormal || data.lightingDebugSettings.overrideSmoothness || data.lightingDebugSettings.overrideSpecularColor || data.lightingDebugSettings.overrideEmissiveColor || data.lightingDebugSettings.overrideAmbientOcclusion) ||
                     (debugGBuffer == DebugViewGbuffer.BakeDiffuseLightingWithAlbedoPlusEmissive) || (data.lightingDebugSettings.debugLightFilterMode != DebugLightFilterMode.None) ||
-                    (data.fullScreenDebugMode == FullScreenDebugMode.PreRefractionColorPyramid || data.fullScreenDebugMode == FullScreenDebugMode.FinalColorPyramid || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceReflections || data.fullScreenDebugMode == FullScreenDebugMode.LightCluster || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceShadows || data.fullScreenDebugMode == FullScreenDebugMode.NanTracker || data.fullScreenDebugMode == FullScreenDebugMode.ColorLog) || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceGlobalIllumination ||
+                    (data.fullScreenDebugMode == FullScreenDebugMode.PreRefractionColorPyramid || data.fullScreenDebugMode == FullScreenDebugMode.FinalColorPyramid || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceReflections || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceReflectionsPrev || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceReflectionsAccum || data.fullScreenDebugMode == FullScreenDebugMode.LightCluster || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceShadows || data.fullScreenDebugMode == FullScreenDebugMode.NanTracker || data.fullScreenDebugMode == FullScreenDebugMode.ColorLog) || data.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceGlobalIllumination ||
                     (debugLighting == DebugLightingMode.ProbeVolume || debugProbeVolume == ProbeVolumeDebugMode.VisualizeAtlas);
         }
     }

com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs.hlsl

@@ -37,6 +37,8 @@
 #define FULLSCREENDEBUGMODE_VALIDATE_DIFFUSE_COLOR (27)
 #define FULLSCREENDEBUGMODE_VALIDATE_SPECULAR_COLOR (28)
 #define FULLSCREENDEBUGMODE_MAX_MATERIAL_FULL_SCREEN_DEBUG (29)
+#define FULLSCREENDEBUGMODE_SCREEN_SPACE_REFLECTIONS_PREV (30)
+#define FULLSCREENDEBUGMODE_SCREEN_SPACE_REFLECTIONS_ACCUM (31)
 
 // Generated from UnityEngine.Rendering.HighDefinition.ShaderVariablesDebugDisplay
 // PackingRules = Exact

com.unity.render-pipelines.high-definition/Runtime/Debug/DebugFullScreen.shader

@@ -306,7 +306,10 @@ Shader "Hidden/HDRP/DebugFullScreen"
 
                     return float4(fade.xxx, 0.0);
                 }
-                if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_SCREEN_SPACE_REFLECTIONS || _FullScreenDebugMode == FULLSCREENDEBUGMODE_TRANSPARENT_SCREEN_SPACE_REFLECTIONS)
+                if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_SCREEN_SPACE_REFLECTIONS ||
+                    _FullScreenDebugMode == FULLSCREENDEBUGMODE_SCREEN_SPACE_REFLECTIONS_PREV ||
+                    _FullScreenDebugMode == FULLSCREENDEBUGMODE_SCREEN_SPACE_REFLECTIONS_ACCUM ||
+                    _FullScreenDebugMode == FULLSCREENDEBUGMODE_TRANSPARENT_SCREEN_SPACE_REFLECTIONS)
                 {
                     float4 color = SAMPLE_TEXTURE2D_X(_DebugFullScreenTexture, s_point_clamp_sampler, input.texcoord) * GetCurrentExposureMultiplier();
                     return float4(color.rgb, 1.0f);

com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceReflection.cs

@@ -1,8 +1,35 @@
 using System;
+using System.Diagnostics;
 using UnityEngine.Serialization;
 
 namespace UnityEngine.Rendering.HighDefinition
 {
+    /// <summary>
+    /// Screen Space Reflection Algorithm
+    /// </summary>
+    public enum ScreenSpaceReflectionAlgorithm
+    {
+        /// <summary>Legacy SSR approximation.</summary>
+        Approximation,
+        /// <summary>Screen Space Reflection, Physically Based with Accumulation through multiple frame.</summary>
+        PBRAccumulation
+    }
+
+    /// <summary>
+    /// Screen Space Reflection Algorithm Type volume parameter.
+    /// </summary>
+    [Serializable, DebuggerDisplay(k_DebuggerDisplay)]
+    public sealed class SSRAlgoParameter : VolumeParameter<ScreenSpaceReflectionAlgorithm>
+    {
+        /// <summary>
+        /// Screen Space Reflection Algorithm Type volume parameter constructor.
+        /// </summary>
+        /// <param name="value">SSR Algo Type parameter.</param>
+        /// <param name="overrideState">Initial override state.</param>
+        public SSRAlgoParameter(ScreenSpaceReflectionAlgorithm value, bool overrideState = false)
+            : base(value, overrideState) { }
+    }
+
     /// <summary>
     /// A volume component that holds settings for screen space reflection and ray traced reflections.
     /// </summary>
@@ -26,6 +53,9 @@ bool UsesRayTracing()
         [Tooltip("Enable Screen Space Reflections.")]
         public BoolParameter enabled = new BoolParameter(true);
 
+        /// <summary>Screen Space Reflections Algorithm used.</summary>
+        public SSRAlgoParameter usedAlgorithm = new SSRAlgoParameter(ScreenSpaceReflectionAlgorithm.Approximation);
+
         /// <summary>
         /// Enable ray traced reflections.
         /// </summary>
@@ -78,6 +108,11 @@ public float smoothnessFadeStart
         /// </summary>
         public ClampedFloatParameter screenFadeDistance = new ClampedFloatParameter(0.1f, 0.0f, 1.0f);
 
+        /// <summary>
+        /// Controls the amount of accumulation (0 no accumulation, 1 just accumulate)
+        /// </summary>
+        public ClampedFloatParameter accumulationFactor = new ClampedFloatParameter(0.75f, 0.0f, 1.0f);
+
         /// <summary>
         /// Layer mask used to include the objects for screen space reflection.
         /// </summary>