(wip) parameter for screen distance blending

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/ScreenSpaceLightingEditor.cs

         protected SerializedDataParameter m_RayMaxIterations;
         protected SerializedDataParameter m_RayDepthSuccessBias;
         protected SerializedDataParameter m_ScreenWeightDistance;
+        protected SerializedDataParameter m_RayMaxScreenDistance;
+        protected SerializedDataParameter m_RayBlendScreenDistance;
 
         public override void OnEnable()
         {
             m_RayMaxIterations = Unpack(o.Find(x => x.rayMaxIterations));
             m_RayDepthSuccessBias = Unpack(o.Find(x => x.rayDepthSuccessBias));
             m_ScreenWeightDistance = Unpack(o.Find(x => x.screenWeightDistance));
+            m_RayMaxScreenDistance = Unpack(o.Find(x => x.rayMaxScreenDistance));
+            m_RayBlendScreenDistance = Unpack(o.Find(x => x.rayBlendScreenDistance));
         }
 
         public override void OnInspectorGUI()
             PropertyField(m_RayMaxLevel, CoreEditorUtils.GetContent("Ray Max Level"));
             PropertyField(m_RayMaxIterations, CoreEditorUtils.GetContent("Ray Max Iterations"));
             PropertyField(m_RayDepthSuccessBias, CoreEditorUtils.GetContent("Ray Depth Success Bias"));
+            PropertyField(m_RayMaxScreenDistance, CoreEditorUtils.GetContent("Ray Maximum Raymarched Screen Distance"));
+            PropertyField(m_RayBlendScreenDistance, CoreEditorUtils.GetContent("Ray Blended Raymarched Screen Distance"));
+
+            m_RayLevel.value.intValue = Mathf.Max(0, m_RayLevel.value.intValue);
+            m_RayMaxLinearIterationsLevel.value.intValue = Mathf.Max(0, m_RayMaxLinearIterationsLevel.value.intValue);
+            m_RayMinLevel.value.intValue = Mathf.Clamp(m_RayMinLevel.value.intValue, 0, m_RayMaxLevel.value.intValue);
+            m_RayMaxLevel.value.intValue = Mathf.Max(0, m_RayMaxLevel.value.intValue);
+            m_RayMaxIterations.value.intValue = Mathf.Max(0, m_RayMaxIterations.value.intValue);
+            m_RayDepthSuccessBias.value.floatValue = Mathf.Max(0.001f, m_RayDepthSuccessBias.value.floatValue);
+            m_RayMaxScreenDistance.value.floatValue = Mathf.Clamp(m_RayMaxScreenDistance.value.floatValue, 0.001f, 1.0f);
+            m_RayBlendScreenDistance.value.floatValue = Mathf.Clamp(m_RayBlendScreenDistance.value.floatValue, 0.0f, m_RayMaxScreenDistance.value.floatValue);
         }
 
         protected virtual void OnProxyInspectorGUI()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

             Shader.PropertyToID("_SSSBufferTexture3"),
         };
 
+        public static readonly int _SSRefractionRayMaxScreenDistance = Shader.PropertyToID("_SSRefractionRayMaxScreenDistance");
+        public static readonly int _SSRefractionRayBlendScreenDistance = Shader.PropertyToID("_SSRefractionRayBlendScreenDistance");
         public static readonly int _SSRefractionRayLevel = Shader.PropertyToID("_SSRefractionRayLevel");
         public static readonly int _SSRefractionRayMaxLinearIterations = Shader.PropertyToID("_SSRefractionRayMaxLinearIterations");
         public static readonly int _SSRefractionRayMinLevel = Shader.PropertyToID("_SSRefractionRayMinLevel");
         public static readonly int _SSRefractionInvScreenWeightDistance = Shader.PropertyToID("_SSRefractionInvScreenWeightDistance");
 
+        public static readonly int _SSReflectionRayMaxScreenDistance = Shader.PropertyToID("_SSReflectionRayMaxScreenDistance");
+        public static readonly int _SSReflectionRayBlendScreenDistance = Shader.PropertyToID("_SSReflectionRayBlendScreenDistance");
         public static readonly int _SSReflectionRayMaxLinearIterations = Shader.PropertyToID("_SSReflectionRayMaxLinearIterations");
         public static readonly int _SSReflectionRayLevel = Shader.PropertyToID("_SSReflectionRayLevel");
         public static readonly int _SSReflectionRayMinLevel = Shader.PropertyToID("_SSReflectionRayMinLevel");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ScreenSpaceLighting.cs

         int m_RayMaxIterationsID;
         int m_RayDepthSuccessBiasID;
         int m_InvScreenWeightDistanceID;
+        int m_RayMaxScreenDistanceID;
+        int m_RayBlendScreenDistanceID;
 
         public IntParameter                 rayLevel = new IntParameter(2);
         public IntParameter                 rayMaxLinearIterationsLevel = new IntParameter(2);
         public FloatParameter               rayDepthSuccessBias = new FloatParameter(0.1f);
         public ClampedFloatParameter        screenWeightDistance = new ClampedFloatParameter(0.1f, 0, 1);
+        public FloatParameter               rayMaxScreenDistance = new FloatParameter(0.3f);
+        public FloatParameter               rayBlendScreenDistance = new FloatParameter(0.1f);
 
         public virtual void PushShaderParameters(CommandBuffer cmd)
         {
             cmd.SetGlobalInt(m_RayMaxIterationsID, rayMaxIterations.value);
             cmd.SetGlobalFloat(m_RayDepthSuccessBiasID, rayDepthSuccessBias.value);
             cmd.SetGlobalFloat(m_InvScreenWeightDistanceID, 1f / screenWeightDistance.value);
+            cmd.SetGlobalFloat(m_RayMaxScreenDistanceID, rayMaxScreenDistance.value);
+            cmd.SetGlobalFloat(m_RayBlendScreenDistanceID, rayBlendScreenDistance.value);
         }
 
         protected abstract void FetchIDs(
             out int rayMaxLevelID,
             out int rayMaxIterationsID,
             out int rayDepthSuccessBiasID,
-            out int invScreenWeightDistanceID
+            out int invScreenWeightDistanceID,
+            out int rayMaxScreenDistanceID,
+            out int rayBlendScreenDistanceID
         );
 
         void Awake()
                 out m_RayMaxLevelID,
                 out m_RayMaxIterationsID,
                 out m_RayDepthSuccessBiasID,
-                out m_InvScreenWeightDistanceID
+                out m_InvScreenWeightDistanceID,
+                out m_RayMaxScreenDistanceID,
+                out m_RayBlendScreenDistanceID
             );
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ScreenSpaceReflection.cs

             out int rayMaxLevelID,
             out int rayMaxIterationsID,
             out int rayDepthSuccessBiasID,
-            out int screenWeightDistanceID
+            out int screenWeightDistanceID,
+            out int rayMaxScreenDistanceID,
+            out int rayBlendScreenDistanceID
         )
         {
             rayLevelID = HDShaderIDs._SSReflectionRayLevel;
             rayMaxIterationsID = HDShaderIDs._SSReflectionRayMaxIterations;
             rayDepthSuccessBiasID = HDShaderIDs._SSReflectionRayDepthSuccessBias;
             screenWeightDistanceID = HDShaderIDs._SSReflectionInvScreenWeightDistance;
+            rayMaxScreenDistanceID = HDShaderIDs._SSReflectionInvScreenWeightDistance;
+            rayBlendScreenDistanceID = HDShaderIDs._SSReflectionInvScreenWeightDistance;
         }
 
         public override void PushShaderParameters(CommandBuffer cmd)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ScreenSpaceRefraction.cs

             out int rayMaxLevelID,
             out int rayMaxIterationsID,
             out int rayDepthSuccessBiasID,
-            out int invScreenWeightDistanceID
+            out int invScreenWeightDistanceID,
+            out int rayMaxScreenDistanceID,
+            out int rayBlendScreenDistanceID
         )
         {
             rayLevelID = HDShaderIDs._SSRefractionRayLevel;
             rayMaxIterationsID = HDShaderIDs._SSRefractionRayMaxIterations;
             rayDepthSuccessBiasID = HDShaderIDs._SSRefractionRayDepthSuccessBias;
             invScreenWeightDistanceID = HDShaderIDs._SSRefractionInvScreenWeightDistance;
+            rayMaxScreenDistanceID = HDShaderIDs._SSRefractionRayMaxScreenDistance;
+            rayBlendScreenDistanceID = HDShaderIDs._SSRefractionRayBlendScreenDistance;
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ScreenSpaceTracing.hlsl

     ScreenSpaceRayHit hit,
     float2 startPositionSS,
     float invLinearDepth, 
-    float settingsRayDepthSuccessBias
+    float settingsRayDepthSuccessBias,
+    float settingsRayMaxScreenDistance,
+    float settingsRayBlendScreenDistance
-    const float maxScreenDistance = 0.3;
-    const float blendedScreenDistance = 0.05;
-
-    float2 screenDistanceWeights = clamp((maxScreenDistance - screenDistanceNDC) / blendedScreenDistance, 0, 1);
+    float2 screenDistanceWeights = clamp((settingsRayMaxScreenDistance - screenDistanceNDC) / settingsRayBlendScreenDistance, 0, 1);
     float screenDistanceWeight = min(screenDistanceWeights.x, screenDistanceWeights.y);
 
     return thicknessWeight * screenDistanceWeight;
 bool ScreenSpaceLinearRaymarch(
     ScreenSpaceRaymarchInput input,
     // Settings
-    int settingRayLevel,                    // Mip level to use to ray march depth buffer
-    uint settingsRayMaxIterations,          // Maximum number of iterations (= max number of depth samples)
-    float settingsRayDepthSuccessBias,      // Bias to use when trying to detect whenever we raymarch behind a surface
-    int settingsDebuggedAlgorithm,          // currently debugged algorithm (see PROJECTIONMODEL defines)
+    int settingRayLevel,                            // Mip level to use to ray march depth buffer
+    uint settingsRayMaxIterations,                  // Maximum number of iterations (= max number of depth samples)
+    float settingsRayDepthSuccessBias,              // Bias to use when trying to detect whenever we raymarch behind a surface
+    float settingsRayMaxScreenDistance,             // Maximum screen distance raymarched
+    float settingsRayBlendScreenDistance,           // Distance to blend before maximum screen distance is reached
+    int settingsDebuggedAlgorithm,                  // currently debugged algorithm (see PROJECTIONMODEL defines)
-    float3 startPositionSS,                 // Start position in Screen Space (x in pixel, y in pixel, z = 1/linearDepth)
-    float3 raySS,                           // Ray direction in Screen Space (dx in pixel, dy in pixel, z = 1/endPointLinearDepth - 1/startPointLinearDepth)
-    float rayEndDepth,                      // Linear depth of the end point used to calculate raySS.
-    uint2 bufferSize,                       // Texture size of screen buffers
+    float3 startPositionSS,                         // Start position in Screen Space (x in pixel, y in pixel, z = 1/linearDepth)
+    float3 raySS,                                   // Ray direction in Screen Space (dx in pixel, dy in pixel, z = 1/endPointLinearDepth - 1/startPointLinearDepth)
+    float rayEndDepth,                              // Linear depth of the end point used to calculate raySS.
+    uint2 bufferSize,                               // Texture size of screen buffers
     // Out
     out ScreenSpaceRayHit hit,
     out float hitWeight,
         hit,
         startPositionSS.xy,
         invLinearDepth,
-        settingsRayDepthSuccessBias
+        settingsRayDepthSuccessBias,
+        settingsRayMaxScreenDistance,
+        settingsRayBlendScreenDistance
     );
     if (hitWeight <= 0)
         hitSuccessful = false;
     int settingRayLevel,                    // Mip level to use to ray march depth buffer
     uint settingsRayMaxIterations,          // Maximum number of iterations (= max number of depth samples)
     float settingsRayDepthSuccessBias,      // Bias to use when trying to detect whenever we raymarch behind a surface
+    float settingsRayMaxScreenDistance,     // Maximum screen distance raymarched
+    float settingsRayBlendScreenDistance,   // Distance to blend before maximum screen distance is reached
     // Settings (common)
     int settingsDebuggedAlgorithm,          // currently debugged algorithm (see PROJECTIONMODEL defines)
     // Out
         settingRayLevel,
         settingsRayMaxIterations,
         settingsRayDepthSuccessBias,
+        settingsRayMaxScreenDistance,
+        settingsRayBlendScreenDistance,
         settingsDebuggedAlgorithm,
         // Precomputed properties
         startPositionSS,
     uint settingsRayMaxIterations,                  // Maximum number of iteration for the HiZ raymarching (= number of depth sample for HiZ)
     uint settingsRayMaxLinearIterations,            // Maximum number of iteration for the linear raymarching (= number of depth sample for linear)
     float settingsRayDepthSuccessBias,              // Bias to use when trying to detect whenever we raymarch behind a surface
+    float settingsRayMaxScreenDistance,             // Maximum screen distance raymarched
+    float settingsRayBlendScreenDistance,           // Distance to blend before maximum screen distance is reached
     int settingsDebuggedAlgorithm,                  // currently debugged algorithm (see PROJECTIONMODEL defines)
     // out
     out ScreenSpaceRayHit hit,
             settingsRayLevel,
             settingsRayMaxLinearIterations,
             settingsRayDepthSuccessBias,
+            settingsRayMaxScreenDistance,
+            settingsRayBlendScreenDistance,
             settingsDebuggedAlgorithm,
             // precomputed
             startPositionSS,
         hit,
         startPositionSS.xy,
         invLinearDepth, 
-        settingsRayDepthSuccessBias
+        settingsRayDepthSuccessBias,
+        settingsRayMaxScreenDistance,
+        settingsRayBlendScreenDistance
     );
     if (hitWeight <= 0)
         hitSuccessful = false;
 int SSRT_SETTING(RayMaxLinearIterations, SSRTID);
 int SSRT_SETTING(RayMaxIterations, SSRTID);
 float SSRT_SETTING(RayDepthSuccessBias, SSRTID);
+float SSRT_SETTING(RayMaxScreenDistance, SSRTID);
+float SSRT_SETTING(RayBlendScreenDistance, SSRTID);
 
 #ifdef DEBUG_DISPLAY
 int SSRT_SETTING(DebuggedAlgorithm, SSRTID);
         SSRT_SETTING(RayLevel, SSRTID),
         SSRT_SETTING(RayMaxIterations, SSRTID),
         max(0.01, SSRT_SETTING(RayDepthSuccessBias, SSRTID)),
+        SSRT_SETTING(RayMaxScreenDistance, SSRTID),
+        SSRT_SETTING(RayBlendScreenDistance, SSRTID),
 #ifdef DEBUG_DISPLAY
         SSRT_SETTING(DebuggedAlgorithm, SSRTID),
 #else
         SSRT_SETTING(RayMaxIterations, SSRTID),
         SSRT_SETTING(RayMaxLinearIterations, SSRTID),
         max(0.01, SSRT_SETTING(RayDepthSuccessBias, SSRTID)),
+        SSRT_SETTING(RayMaxScreenDistance, SSRTID),
+        SSRT_SETTING(RayBlendScreenDistance, SSRTID),
 #ifdef DEBUG_DISPLAY
         SSRT_SETTING(DebuggedAlgorithm, SSRTID),
 #else