Merge pull request #1159 from Unity-Technologies/feature/RefractionModes

Screen Space Refraction Projection Model

CHANGELOG.md

 ## [Unreleased]
 ### Added
  - Planar Reflection Probe support roughness (gaussian convolution of captured probe)
+ - Screen Space Refraction projection model (Proxy raycasting, HiZ raymarching)
+ - Screen Space Refraction settings as volume component
+ - Screen Space Refraction proxy model uses the proxy of the first environment light (Reflection probe/Planar probe) or the sky
 
 ## [0.1.6] - 2018-xx-yy
 

ScriptableRenderPipeline/Core/CoreRP/Debugging/DebugUI.Panel.cs

 
             public bool isEditorOnly { get { return (flags & Flags.EditorOnly) != 0; } }
             public bool isRuntimeOnly { get { return (flags & Flags.RuntimeOnly) != 0; } }
+            public bool editorForceUpdate { get { return (flags & Flags.EditorForceUpdate) != 0; } }
 
             public ObservableList<Widget> children { get; private set; }
             public event Action<Panel> onSetDirty = delegate { };

ScriptableRenderPipeline/Core/CoreRP/Debugging/DebugUI.cs

         {
             None        = 0,
             EditorOnly  = 1 << 1,
-            RuntimeOnly = 1 << 2
+            RuntimeOnly = 1 << 2,
+            EditorForceUpdate = 1 << 3
         }
 
         // Base class for all debug UI widgets

ScriptableRenderPipeline/Core/CoreRP/Debugging/MousePositionDebug.cs

             }
         }
 
+        public int debugStep
+        {
+            get
+            {
+#if UNITY_EDITOR
+                return m_DebugStep;
+#else
+                return 0;
+#endif
+            }
+        }
+
+        Vector2 m_MouseClickPosition = Vector2.zero;
+        int m_DebugStep = 0;
+            switch (Event.current.type)
+            {
+                case EventType.MouseDown:
+                    m_MouseClickPosition = m_mousePosition;
+                    break;
+                case EventType.KeyDown:
+                    switch (Event.current.keyCode)
+                    {
+                        case KeyCode.PageUp:
+                            ++m_DebugStep;
+                            sceneview.Repaint();
+                            break;
+                        case KeyCode.PageDown:
+                            m_DebugStep = Mathf.Max(0, m_DebugStep - 1);
+                            sceneview.Repaint();
+                            break;
+                        case KeyCode.End:
+                            // Usefull we you don't want to change the scene viewport but still update the mouse click position
+                            m_MouseClickPosition = m_mousePosition;
+                            sceneview.Repaint();
+                            break;
+                    }
+                    break;
+            }
         }
 #endif
 
             }
 #endif
             return mousePixelCoord;
+        }
+
+        public Vector2 GetMouseClickPosition(float ScreenHeight)
+        {
+#if UNITY_EDITOR
+            Vector2 mousePixelCoord = m_MouseClickPosition;
+            mousePixelCoord.y = (ScreenHeight - 1.0f) - mousePixelCoord.y;
+            return mousePixelCoord;
+#else
+            return Vector2.zero;
+#endif
         }
     }
 }

ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugWindow.cs

             // First init
             m_DebugTreeState = DebugManager.instance.GetState();
             UpdateWidgetStates();
+
+            EditorApplication.update -= Repaint;
+            var panels = DebugManager.instance.panels;
+            var selectedPanelIndex = m_Settings.selectedPanel;
+            if (selectedPanelIndex >= 0 
+                && selectedPanelIndex < panels.Count 
+                && panels[selectedPanelIndex].editorForceUpdate)
+                EditorApplication.update += Repaint;
         }
 
         // Note: this won't get called if the window is opened when the editor itself is closed
                         if (EditorGUI.EndChangeCheck())
                         {
                             Undo.RegisterCompleteObjectUndo(m_Settings, "Debug Panel Selection");
+                            var previousPanel = m_Settings.selectedPanel >= 0 && m_Settings.selectedPanel < panels.Count
+                                ? panels[m_Settings.selectedPanel]
+                                : null;
+                            if (previousPanel != null && previousPanel.editorForceUpdate && !panel.editorForceUpdate)
+                                EditorApplication.update -= Repaint;
+                            else if ((previousPanel == null || !previousPanel.editorForceUpdate) && panel.editorForceUpdate)
+                                EditorApplication.update += Repaint;
                             m_Settings.selectedPanel = i;
                         }
                     }

ScriptableRenderPipeline/Core/CoreRP/Editor/ShaderGenerator/CSharpToHLSL.cs

             s_TypeName = new Dictionary<string, ShaderTypeGenerator>();
 
             // Iterate over assemblyList, discover all applicable types with fully qualified names
-            var assemblyList = AppDomain.CurrentDomain.GetAssemblies().ToList();
+            var assemblyList = AppDomain.CurrentDomain.GetAssemblies()
+                // We need to exclude dynamic assemblies (their type can't be queried, throwing an exception below)
+                .Where(ass => !ass.IsDynamic)
+                .ToList();
 
             foreach (var assembly in assemblyList)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEditor;
 using UnityEngine.Experimental.Rendering.HDPipeline.Attributes;
 
         PreRefractionColorPyramid,
         DepthPyramid,
         FinalColorPyramid,
+        ScreenSpaceTracing,
         MaxLightingFullScreenDebug,
 
         // Rendering
         MaxRenderingFullScreenDebug
     }
 
+    [GenerateHLSL]
+    public struct ScreenSpaceTracingDebug
+    {
+                                                        // Used to debug SSRay model
+        // 1x32 bits
+        public Lit.RefractionSSRayModel tracingModel;
+
+        // 6x32 bits
+        public uint loopStartPositionSSX;                           // Proxy, HiZ
+        public uint loopStartPositionSSY;                           // Proxy, HiZ
+        public float loopStartLinearDepth;                          // Proxy, HiZ
+        public Vector3 loopRayDirectionSS;                          // HiZ
+        public uint loopMipLevelMax;                                // HiZ
+        public uint loopIterationMax;                               // HiZ
+
+        // 9x32 bits
+        public Vector3 iterationPositionSS;                         // HiZ
+        public uint iterationMipLevel;                              // HiZ
+        public uint iteration;                                      // HiZ
+        public float iterationLinearDepthBuffer;                    // HiZ
+        public Lit.HiZIntersectionKind iterationIntersectionKind;   // HiZ
+        public uint iterationCellSizeW;                             // HiZ
+        public uint iterationCellSizeH;                             // HiZ
+        public EnvShapeType proxyShapeType;                         // Proxy
+        public float projectionDistance;                            // Proxy
+
+        // 4x32 bits
+        public bool endHitSuccess;                                  // Proxy, HiZ
+        public float endLinearDepth;                                // Proxy, HiZ
+        public uint endPositionSSX;                                 // Proxy, HiZ
+        public uint endPositionSSY;                                 // Proxy, HiZ
+
+        // 0x32 bits (padding)
+
+        public Vector2 loopStartPositionSS { get { return new Vector2(loopStartPositionSSX, loopStartPositionSSY); } }
+        public Vector2 endPositionSS { get { return new Vector2(endPositionSSX, endPositionSSY); } }
+        public Vector2 iterationCellId { get { return new Vector2(((int)iterationPositionSS.x) >> (int)iterationMipLevel, ((int)iterationPositionSS.y) >> (int)iterationMipLevel); } }
+        public Vector2 iterationCellSize { get { return new Vector2(iterationCellSizeW, iterationCellSizeH); } }
+    }
+
     public class DebugDisplaySettings
     {
         public static string k_PanelDisplayStats = "Display Stats";
 
+        public static string k_PanelScreenSpaceTracing = "Screen Space Tracing";
+
+        static readonly string[] k_HiZIntersectionKind = { "None", "Depth", "Cell" };
+
+        DebugUI.Widget[] m_DebugScreenSpaceTracingItems;
+        
+        public bool showSSRayGrid = true;
+        public bool showSSRayDepthPyramid = true;
 
         public MaterialDebugSettings materialDebugSettings = new MaterialDebugSettings();
         public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
         public static int[] lightingFullScreenDebugValues = null;
         public static GUIContent[] renderingFullScreenDebugStrings = null;
         public static int[] renderingFullScreenDebugValues = null;
+        public static GUIContent[] debugScreenSpaceTracingProxyStrings = null;
+        public static int[] debugScreenSpaceTracingProxyValues = null;
+        public static GUIContent[] debugScreenSpaceTracingHiZStrings = null;
+        public static int[] debugScreenSpaceTracingHiZValues = null;
+
+        Lit.RefractionSSRayModel m_LastSSRayModel = Lit.RefractionSSRayModel.None;
+        ScreenSpaceTracingDebug m_ScreenSpaceTracingDebugData;
+        public ScreenSpaceTracingDebug screenSpaceTracingDebugData 
+        {
+            get { return m_ScreenSpaceTracingDebugData; }
+            internal set 
+            {
+                m_ScreenSpaceTracingDebugData = value; 
+                if (m_LastSSRayModel != m_ScreenSpaceTracingDebugData.tracingModel)
+                {
+                    m_LastSSRayModel = m_ScreenSpaceTracingDebugData.tracingModel;
+                    RefreshScreenSpaceTracingDebug<Lit.RefractionSSRayModel>(null, m_LastSSRayModel);
+                }
+
+                if (m_ScreenSpaceTracingDebugData.tracingModel != Lit.RefractionSSRayModel.HiZ)
+                {
+                    showSSRayDepthPyramid = false;
+                    showSSRayGrid = false;
+                }
+            }
+        }
+
+            var debugScreenSpaceTracingStrings = Enum.GetNames(typeof(DebugScreenSpaceTracing))
+                .Select(s => new GUIContent(s))
+                .ToArray();
+            var debugScreenSpaceTracingValues = (int[])Enum.GetValues(typeof(DebugScreenSpaceTracing));
+
+            var debugScreenSpaceTracingHiZStringsList = new List<GUIContent>();
+            var debugScreenSpaceTracingProxyStringsList = new List<GUIContent>();
+            var debugScreenSpaceTracingHiZValueList = new List<int>();
+            var debugScreenSpaceTracingProxyValueList = new List<int>();
+            for (int i = 0, c = debugScreenSpaceTracingStrings.Length; i < c; ++i)
+            {
+                var g = debugScreenSpaceTracingStrings[i];
+                var v = debugScreenSpaceTracingValues[i];
+                if (!g.text.StartsWith("Proxy"))
+                {
+                    debugScreenSpaceTracingHiZStringsList.Add(g);
+                    debugScreenSpaceTracingHiZValueList.Add(v);
+                }
+                if (!g.text.StartsWith("HiZ"))
+                {
+                    debugScreenSpaceTracingProxyStringsList.Add(g);
+                    debugScreenSpaceTracingProxyValueList.Add(v);
+                }
+            }
+
+            debugScreenSpaceTracingHiZStrings = debugScreenSpaceTracingHiZStringsList.ToArray();
+            debugScreenSpaceTracingHiZValues = debugScreenSpaceTracingHiZValueList.ToArray();
+            debugScreenSpaceTracingProxyStrings = debugScreenSpaceTracingProxyStringsList.ToArray();
+            debugScreenSpaceTracingProxyValues = debugScreenSpaceTracingProxyValueList.ToArray();
         }
 
         public int GetDebugMaterialIndex()
         public DebugLightingMode GetDebugLightingMode()
         {
             return lightingDebugSettings.debugLightingMode;
+        }
+
+        public int GetDebugLightingSubMode()
+        {
+            switch (lightingDebugSettings.debugLightingMode)
+            {
+                case DebugLightingMode.ScreenSpaceTracingRefraction:
+                case DebugLightingMode.ScreenSpaceTracingReflection:
+                    return (int)lightingDebugSettings.debugScreenSpaceTracingMode;
+                default:
+                    return 0;
+            }
         }
 
         public DebugMipMapMode GetDebugMipMapMode()
             mipMapDebugSettings.debugMipMapMode = value;
         }
 
+        bool IsScreenSpaceTracingRefractionDebugEnabled()
+        {
+            return fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing 
+                && lightingDebugSettings.debugLightingMode == DebugLightingMode.ScreenSpaceTracingRefraction;
+        }
+
+        void SetScreenSpaceTracingRefractionDebugEnabled(bool value)
+        {
+            if (value)
+            {
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.ScreenSpaceTracingRefraction;
+                fullScreenDebugMode = FullScreenDebugMode.ScreenSpaceTracing;
+            }
+            else
+            {
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.None;
+                fullScreenDebugMode = FullScreenDebugMode.None;
+            }
+        }
+
+        void SetScreenSpaceTracingRefractionDebugMode(int value)
+        {
+            var val = (DebugScreenSpaceTracing)value;
+            if (val != DebugScreenSpaceTracing.None)
+            {
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.ScreenSpaceTracingRefraction;
+                lightingDebugSettings.debugScreenSpaceTracingMode = (DebugScreenSpaceTracing)value;
+            }
+            else
+            {
+                lightingDebugSettings.debugLightingMode = DebugLightingMode.None;
+                lightingDebugSettings.debugScreenSpaceTracingMode = DebugScreenSpaceTracing.None;
+            }
+        }
+
         public void UpdateMaterials()
         {
             //if (mipMapDebugSettings.debugMipMapMode != 0)
             panel.children.Add(m_DebugDisplayStatsItems);
         }
 
+        void RegisterScreenSpaceTracingDebug()
+        {
+            var list = new List<DebugUI.Container>();
+
+            var refractionContainer = new DebugUI.Container
+            {
+                displayName = "Refraction",
+                children = 
+                {
+                    new DebugUI.BoolField { displayName = "Debug Enabled", getter = IsScreenSpaceTracingRefractionDebugEnabled, setter = SetScreenSpaceTracingRefractionDebugEnabled, onValueChanged = RefreshScreenSpaceTracingDebug },
+                }
+            };
+            list.Add(refractionContainer);
+
+            if (IsScreenSpaceTracingRefractionDebugEnabled())
+            {
+                var debugSettingsContainer = new DebugUI.Container
+                {
+                    displayName = "Debug Settings",
+                    children =
+                    {
+                        new DebugUI.Value { displayName = string.Empty, getter = () => "Click in the scene view, or press 'End' key to select the pixel under the mouse in the scene view to debug." },
+                        new DebugUI.Value { displayName = "SSRay Model", getter = () => screenSpaceTracingDebugData.tracingModel }
+                    }
+                };
+                refractionContainer.children.Add(debugSettingsContainer);
+
+                switch (screenSpaceTracingDebugData.tracingModel)
+                {
+                    case Lit.RefractionSSRayModel.Proxy:
+                    {
+                        debugSettingsContainer.children.Add(
+                            new DebugUI.EnumField { displayName = "Debug Mode", getter = GetDebugLightingSubMode, setter = SetScreenSpaceTracingRefractionDebugMode, enumNames = debugScreenSpaceTracingProxyStrings, enumValues = debugScreenSpaceTracingProxyValues, onValueChanged = RefreshScreenSpaceTracingDebug }
+                        );
+                        refractionContainer.children.Add(
+                            new DebugUI.Container
+                            {
+                                displayName = "Debug Values",
+                                children =
+                                {
+                                    new DebugUI.Value { displayName = "Hit Success", getter = () => screenSpaceTracingDebugData.endHitSuccess },
+                                    new DebugUI.Value { displayName = "Proxy Shape", getter = () => screenSpaceTracingDebugData.proxyShapeType },
+                                    new DebugUI.Value { displayName = "Projection Distance", getter = () => screenSpaceTracingDebugData.projectionDistance },
+                                    new DebugUI.Value { displayName = "Start Position", getter = () => screenSpaceTracingDebugData.loopStartPositionSS },
+                                    new DebugUI.Value { displayName = "Start Linear Depth", getter = () => screenSpaceTracingDebugData.loopStartLinearDepth },
+                                    new DebugUI.Value { displayName = "End Linear Depth", getter = () => screenSpaceTracingDebugData.endLinearDepth },
+                                    new DebugUI.Value { displayName = "End Position", getter = () => screenSpaceTracingDebugData.endPositionSS },
+                                }
+                            }
+                        );
+                        break;
+                    }
+                    case Lit.RefractionSSRayModel.HiZ:
+                    {
+                        debugSettingsContainer.children.Insert(1, new DebugUI.Value { displayName = string.Empty, getter = () => "Press PageUp/PageDown to Increase/Decrease the HiZ step." });
+                        debugSettingsContainer.children.Add(
+                            new DebugUI.EnumField { displayName = "Debug Mode", getter = GetDebugLightingSubMode, setter = SetScreenSpaceTracingRefractionDebugMode, enumNames = debugScreenSpaceTracingHiZStrings, enumValues = debugScreenSpaceTracingHiZValues, onValueChanged = RefreshScreenSpaceTracingDebug },
+                            new DebugUI.BoolField { displayName = "Display Grid", getter = () => showSSRayGrid, setter = v => showSSRayGrid = v },
+                            new DebugUI.BoolField { displayName = "Display Depth", getter = () => showSSRayDepthPyramid, setter = v => showSSRayDepthPyramid = v }
+                        );
+                        refractionContainer.children.Add(
+                            new DebugUI.Container
+                            {
+                                displayName = "Debug Values (loop)",
+                                children =
+                                {
+                                    new DebugUI.Value { displayName = "Hit Success", getter = () => screenSpaceTracingDebugData.endHitSuccess },
+                                    new DebugUI.Value { displayName = "Start Position", getter = () => screenSpaceTracingDebugData.loopStartPositionSS },
+                                    new DebugUI.Value { displayName = "Start Linear Depth", getter = () => screenSpaceTracingDebugData.loopStartLinearDepth },
+                                    new DebugUI.Value { displayName = "Ray Direction SS", getter = () => new Vector2(screenSpaceTracingDebugData.loopRayDirectionSS.x, screenSpaceTracingDebugData.loopRayDirectionSS.y) },
+                                    new DebugUI.Value { displayName = "Ray Depth", getter = () => 1f / screenSpaceTracingDebugData.loopRayDirectionSS.z },
+                                    new DebugUI.Value { displayName = "End Position", getter = () => screenSpaceTracingDebugData.endPositionSS },
+                                    new DebugUI.Value { displayName = "End Linear Depth", getter = () => screenSpaceTracingDebugData.endLinearDepth },
+                                }
+                            },
+                            new DebugUI.Container
+                            {
+                                displayName = "Debug Values (iteration)",
+                                children =
+                                {
+                                    new DebugUI.Value { displayName = "Iteration", getter = () => string.Format("{0}/{1}", screenSpaceTracingDebugData.iteration, screenSpaceTracingDebugData.loopIterationMax) },
+                                    new DebugUI.Value { displayName = "Position SS", getter = () => new Vector2(screenSpaceTracingDebugData.iterationPositionSS.x, screenSpaceTracingDebugData.iterationPositionSS.y) },
+                                    new DebugUI.Value { displayName = "Depth", getter = () => 1f / screenSpaceTracingDebugData.iterationPositionSS.z },
+                                    new DebugUI.Value { displayName = "Depth Buffer", getter = () => screenSpaceTracingDebugData.iterationLinearDepthBuffer },
+                                    new DebugUI.Value { displayName = "Mip Level", getter = () => string.Format("{0}/{1}", screenSpaceTracingDebugData.iterationMipLevel, screenSpaceTracingDebugData.loopMipLevelMax) },
+                                    new DebugUI.Value { displayName = "Intersection kind", getter = () => screenSpaceTracingDebugData.iterationIntersectionKind },
+                                    new DebugUI.Value { displayName = "Cell Id", getter = () => screenSpaceTracingDebugData.iterationCellId },
+                                    new DebugUI.Value { displayName = "Cell Size", getter = () => screenSpaceTracingDebugData.iterationCellSize },
+                                }
+                            }
+                        );
+                        break;
+                    }
+                }
+            }
+
+            m_DebugScreenSpaceTracingItems = list.ToArray();
+            var panel = DebugManager.instance.GetPanel(k_PanelScreenSpaceTracing, true);
+            panel.flags |= DebugUI.Flags.EditorForceUpdate;
+            panel.children.Add(m_DebugScreenSpaceTracingItems);
+        }
+
         public void RegisterMaterialDebug()
         {
             m_DebugMaterialItems = new DebugUI.Widget[]
         {
             UnregisterDebugItems(k_PanelLighting, m_DebugLightingItems);
             RegisterLightingDebug();
+        }
+
+        void RefreshScreenSpaceTracingDebug<T>(DebugUI.Field<T> field, T value)
+        {
+            UnregisterDebugItems(k_PanelScreenSpaceTracing, m_DebugScreenSpaceTracingItems);
+            RegisterScreenSpaceTracingDebug();
         }
 
         public void RegisterLightingDebug()
             RegisterMaterialDebug();
             RegisterLightingDebug();
             RegisterRenderingDebug();
+            RegisterScreenSpaceTracingDebug();
         }
 
         public void UnregisterDebug()
             UnregisterDebugItems(k_PanelLighting, m_DebugLightingItems);
             UnregisterDebugItems(k_PanelRendering, m_DebugRenderingItems);
+            UnregisterDebugItems(k_PanelScreenSpaceTracing, m_DebugScreenSpaceTracingItems);
         }
 
         void UnregisterDebugItems(string panelName, DebugUI.Widget[] items)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.cs.hlsl

 #define FULLSCREENDEBUGMODE_PRE_REFRACTION_COLOR_PYRAMID (4)
 #define FULLSCREENDEBUGMODE_DEPTH_PYRAMID (5)
 #define FULLSCREENDEBUGMODE_FINAL_COLOR_PYRAMID (6)
-#define FULLSCREENDEBUGMODE_MAX_LIGHTING_FULL_SCREEN_DEBUG (7)
-#define FULLSCREENDEBUGMODE_MIN_RENDERING_FULL_SCREEN_DEBUG (8)
-#define FULLSCREENDEBUGMODE_MOTION_VECTORS (9)
-#define FULLSCREENDEBUGMODE_NAN_TRACKER (10)
-#define FULLSCREENDEBUGMODE_MAX_RENDERING_FULL_SCREEN_DEBUG (11)
+#define FULLSCREENDEBUGMODE_SCREEN_SPACE_TRACING (7)
+#define FULLSCREENDEBUGMODE_MAX_LIGHTING_FULL_SCREEN_DEBUG (8)
+#define FULLSCREENDEBUGMODE_MIN_RENDERING_FULL_SCREEN_DEBUG (9)
+#define FULLSCREENDEBUGMODE_MOTION_VECTORS (10)
+#define FULLSCREENDEBUGMODE_NAN_TRACKER (11)
+#define FULLSCREENDEBUGMODE_MAX_RENDERING_FULL_SCREEN_DEBUG (12)
+
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.ScreenSpaceTracingDebug
+// PackingRules = Exact
+struct ScreenSpaceTracingDebug
+{
+    int tracingModel;
+    uint loopStartPositionSSX;
+    uint loopStartPositionSSY;
+    float loopStartLinearDepth;
+    float3 loopRayDirectionSS;
+    uint loopMipLevelMax;
+    uint loopIterationMax;
+    float3 iterationPositionSS;
+    uint iterationMipLevel;
+    uint iteration;
+    float iterationLinearDepthBuffer;
+    int iterationIntersectionKind;
+    uint iterationCellSizeW;
+    uint iterationCellSizeH;
+    int proxyShapeType;
+    float projectionDistance;
+    bool endHitSuccess;
+    float endLinearDepth;
+    uint endPositionSSX;
+    uint endPositionSSY;
+};
+
+//
+// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.ScreenSpaceTracingDebug
+//
+int GetTracingModel(ScreenSpaceTracingDebug value)
+{
+	return value.tracingModel;
+}
+uint GetLoopStartPositionSSX(ScreenSpaceTracingDebug value)
+{
+	return value.loopStartPositionSSX;
+}
+uint GetLoopStartPositionSSY(ScreenSpaceTracingDebug value)
+{
+	return value.loopStartPositionSSY;
+}
+float GetLoopStartLinearDepth(ScreenSpaceTracingDebug value)
+{
+	return value.loopStartLinearDepth;
+}
+float3 GetLoopRayDirectionSS(ScreenSpaceTracingDebug value)
+{
+	return value.loopRayDirectionSS;
+}
+uint GetLoopMipLevelMax(ScreenSpaceTracingDebug value)
+{
+	return value.loopMipLevelMax;
+}
+uint GetLoopIterationMax(ScreenSpaceTracingDebug value)
+{
+	return value.loopIterationMax;
+}
+float3 GetIterationPositionSS(ScreenSpaceTracingDebug value)
+{
+	return value.iterationPositionSS;
+}
+uint GetIterationMipLevel(ScreenSpaceTracingDebug value)
+{
+	return value.iterationMipLevel;
+}
+uint GetIteration(ScreenSpaceTracingDebug value)
+{
+	return value.iteration;
+}
+float GetIterationLinearDepthBuffer(ScreenSpaceTracingDebug value)
+{
+	return value.iterationLinearDepthBuffer;
+}
+int GetIterationIntersectionKind(ScreenSpaceTracingDebug value)
+{
+	return value.iterationIntersectionKind;
+}
+uint GetIterationCellSizeW(ScreenSpaceTracingDebug value)
+{
+	return value.iterationCellSizeW;
+}
+uint GetIterationCellSizeH(ScreenSpaceTracingDebug value)
+{
+	return value.iterationCellSizeH;
+}
+int GetProxyShapeType(ScreenSpaceTracingDebug value)
+{
+	return value.proxyShapeType;
+}
+float GetProjectionDistance(ScreenSpaceTracingDebug value)
+{
+	return value.projectionDistance;
+}
+bool GetEndHitSuccess(ScreenSpaceTracingDebug value)
+{
+	return value.endHitSuccess;
+}
+float GetEndLinearDepth(ScreenSpaceTracingDebug value)
+{
+	return value.endLinearDepth;
+}
+uint GetEndPositionSSX(ScreenSpaceTracingDebug value)
+{
+	return value.endPositionSSX;
+}
+uint GetEndPositionSSY(ScreenSpaceTracingDebug value)
+{
+	return value.endPositionSSY;
+}
 
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.hlsl

 CBUFFER_START(UnityDebugDisplay)
 // Set of parameters available when switching to debug shader mode
 int _DebugLightingMode; // Match enum DebugLightingMode
+int _DebugLightingSubMode;
+int _DebugStep;
+float4 _MouseClickPixelCoord;  // xy unorm, zw norm
+RWStructuredBuffer<ScreenSpaceTracingDebug> _DebugScreenSpaceTracingData;
 
 void GetPropertiesDataDebug(uint paramId, inout float3 result, inout bool needLinearToSRGB)
 {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader

 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "CoreRP/ShaderLibrary/Color.hlsl"
+            #include "CoreRP/ShaderLibrary/Debug.hlsl"
+            #include "HDRP/Material/Lit/Lit.cs.hlsl"
-            TEXTURE2D(_DebugFullScreenTexture);
+            CBUFFER_START (UnityDebug)
+            float _ShowGrid;
+            float _ShowDepthPyramidDebug;
+            CBUFFER_END
+
+            TEXTURE2D(_DebugFullScreenTexture);
+            TEXTURE2D(_DepthPyramidTexture);
+            StructuredBuffer<ScreenSpaceTracingDebug> _DebugScreenSpaceTracingData;
 
             struct Attributes
             {
                     PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP);
                     float linearDepth = frac(posInput.linearDepth * 0.1);
                     return float4(linearDepth.xxx, 1.0);
+                }
+                if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_SCREEN_SPACE_TRACING)
+                {
+                    const float circleRadius = 3.5;
+                    const float ringSize = 1.5;
+                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, s_point_clamp_sampler, input.texcoord);
+
+                    ScreenSpaceTracingDebug debug = _DebugScreenSpaceTracingData[0];
+
+                    // Fetch Depth Buffer and Position Inputs
+                    const float deviceDepth = LOAD_TEXTURE2D_LOD(_DepthPyramidTexture, int2(input.positionCS.xy) >> debug.iterationMipLevel, debug.iterationMipLevel).r;
+                    PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, deviceDepth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP);
+
+                    float4 col = float4(0, 0, 0, 1);
+
+                    // Common Pre Specific
+                    // Fetch debug data
+                    const uint2 loopStartPositionSS = uint2(debug.loopStartPositionSSX, debug.loopStartPositionSSY);
+                    const uint2 endPositionSS = uint2(debug.endPositionSSX, debug.endPositionSSY);
+
+                    float distanceToPosition = FLT_MAX;
+                    float positionSDF = 0;
+                    // Start position dot rendering
+                    const float distanceToStartPosition = length(int2(posInput.positionSS) - int2(loopStartPositionSS));
+                    const float startPositionSDF = clamp(circleRadius - distanceToStartPosition, 0, 1);
+                    // Line rendering
+                    const float distanceToRaySegment = DistanceToSegment(posInput.positionSS, loopStartPositionSS, endPositionSS);
+                    const float raySegmentSDF = clamp(1 - distanceToRaySegment, 0, 1);
+
+                    float cellSDF = 0;
+                    float debugLinearDepth = 0;
+                    if (debug.tracingModel == REFRACTIONSSRAYMODEL_HI_Z)
+                    {
+                        const uint2 iterationCellSize = uint2(debug.iterationCellSizeW, debug.iterationCellSizeH);
+                        const float hasData = iterationCellSize.x != 0 || iterationCellSize.y != 0;
+
+                        // Position dot rendering
+                        distanceToPosition = length(int2(posInput.positionSS) - int2(debug.iterationPositionSS.xy));
+                        positionSDF = clamp(circleRadius - distanceToPosition, 0, 1);
+
+                        // Grid rendering
+                        float2 distanceToCell = float2(posInput.positionSS % iterationCellSize);
+                        distanceToCell = min(distanceToCell, float2(iterationCellSize) - distanceToCell);
+                        distanceToCell = clamp(1 - distanceToCell, 0, 1);
+                        cellSDF = max(distanceToCell.x, distanceToCell.y) * _ShowGrid;
+
+                        debugLinearDepth = posInput.linearDepth;
+                    }
+
+                    col = float4(
+                        ( GetIndexColor(1) * startPositionSDF
+                        + GetIndexColor(3) * positionSDF
+                        + GetIndexColor(5) * cellSDF
+                        + GetIndexColor(7) * raySegmentSDF
+                        ),
+                        col.a
+                    );
+
+                    // Common Post Specific
+                    // Calculate SDF to draw a ring on both dots
+                    const float startPositionRingDistance = abs(distanceToStartPosition - circleRadius);
+                    const float startPositionRingSDF = clamp(ringSize - startPositionRingDistance, 0, 1);
+                    const float positionRingDistance = abs(distanceToPosition - circleRadius);
+                    const float positionRingSDF = clamp(ringSize - positionRingDistance, 0, 1);
+                    const float w = clamp(1 - startPositionRingSDF - positionRingSDF, 0, 1);
+                    col.rgb = col.rgb * w + float3(1, 1, 1) * (1 - w);
+
+                    if (_ShowDepthPyramidDebug == 1)
+                        color.rgb = frac(float3(debugLinearDepth, debugLinearDepth, debugLinearDepth) * 0.1);
+
+                    col = float4(col.rgb * col.a + color.rgb, 1);
+
+                    return col;
                 }
 
                 return float4(0.0, 0.0, 0.0, 0.0);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/LightingDebug.cs

         IndirectSpecularGtaoFromSsao,
         EnvironmentProxyVolume,
         EnvironmentSampleCoordinates,
+        ScreenSpaceTracingRefraction,
+        ScreenSpaceTracingReflection
+    }
+
+    [GenerateHLSL]
+    public enum DebugScreenSpaceTracing
+    {
+        None,
+        Color,
+        RayDirWS,
+        HitDepth,
+        HitSuccess,
+        HiZPositionNDC,
+        HiZRayDirNDC,
+        HiZIterationCount,
+        HiZMaxUsedMipLevel,
+        HiZIntersectionKind
     }
 
     public enum ShadowMapDebugMode
         }
 
         public DebugLightingMode    debugLightingMode = DebugLightingMode.None;
+        public DebugScreenSpaceTracing debugScreenSpaceTracingMode = DebugScreenSpaceTracing.None;
         public ShadowMapDebugMode   shadowDebugMode = ShadowMapDebugMode.None;
         public bool                 shadowDebugUseSelection = false;
         public uint                 shadowMapIndex = 0;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/LightingDebug.cs.hlsl

 #define DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_GTAO_FROM_SSAO (8)
 #define DEBUGLIGHTINGMODE_ENVIRONMENT_PROXY_VOLUME (9)
 #define DEBUGLIGHTINGMODE_ENVIRONMENT_SAMPLE_COORDINATES (10)
+#define DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION (11)
+#define DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFLECTION (12)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.DebugScreenSpaceTracing:  static fields
+//
+#define DEBUGSCREENSPACETRACING_NONE (0)
+#define DEBUGSCREENSPACETRACING_COLOR (1)
+#define DEBUGSCREENSPACETRACING_RAY_DIR_WS (2)
+#define DEBUGSCREENSPACETRACING_HIT_DEPTH (3)
+#define DEBUGSCREENSPACETRACING_HIT_SUCCESS (4)
+#define DEBUGSCREENSPACETRACING_HI_ZPOSITION_NDC (5)
+#define DEBUGSCREENSPACETRACING_HI_ZRAY_DIR_NDC (6)
+#define DEBUGSCREENSPACETRACING_HI_ZITERATION_COUNT (7)
+#define DEBUGSCREENSPACETRACING_HI_ZMAX_USED_MIP_LEVEL (8)
+#define DEBUGSCREENSPACETRACING_HI_ZINTERSECTION_KIND (9)
 
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/LitUI.cs

             public static GUIContent normalMapSpaceWarning = new GUIContent("Object space normal can't be use with triplanar mapping.");
 
             // Transparency
-            public static string refractionModeText = "Refraction Mode";
+            public static string refractionModelText = "Refraction Model";
+            public static GUIContent refractionSSRayModelText = new GUIContent("SSRay Model", "Screen Space Ray Model");
             public static GUIContent refractionIorText = new GUIContent("Index of refraction", "Index of refraction");
             public static GUIContent refractionThicknessText = new GUIContent("Refraction Thickness", "Thickness for rough refraction");
             public static GUIContent refractionThicknessMultiplierText = new GUIContent("Refraction Thickness multiplier (m)", "Thickness multiplier");
         protected const string kATDistance = "_ATDistance";
         protected MaterialProperty thicknessMultiplier = null;
         protected const string kThicknessMultiplier = "_ThicknessMultiplier";
-        protected MaterialProperty refractionMode = null;
-        protected const string kRefractionMode = "_RefractionMode";
+        protected MaterialProperty refractionModel = null;
+        protected const string kRefractionModel = "_RefractionModel";
+        protected MaterialProperty refractionSSRayModel = null;
+        protected const string kRefractionSSRayModel = "_RefractionSSRayModel";
-            get { return refractionMode == null || refractionMode.floatValue == 0f; }
+            get { return refractionModel == null || refractionModel.floatValue == 0f; }
         }
 
         protected void FindMaterialLayerProperties(MaterialProperty[] props)
             coatMaskMap = FindProperty(kCoatMaskMap, props);
 
             // Transparency
-            refractionMode = FindProperty(kRefractionMode, props, false);
+            refractionModel = FindProperty(kRefractionModel, props, false);
+            refractionSSRayModel = FindProperty(kRefractionSSRayModel, props, false);
             transmittanceColor = FindProperty(kTransmittanceColor, props, false);
             transmittanceColorMap = FindProperty(kTransmittanceColorMap, props, false);
             atDistance = FindProperty(kATDistance, props, false);
 
             var surfaceTypeValue = (SurfaceType)surfaceType.floatValue;
             if (surfaceTypeValue == SurfaceType.Transparent
-                && refractionMode != null)
+                && refractionModel != null)
             {
                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField(StylesBaseUnlit.TransparencyInputsText, EditorStyles.boldLabel);
-                if (refractionMode != null
+                if (refractionModel != null
-                    m_MaterialEditor.ShaderProperty(refractionMode, Styles.refractionModeText);
-                    var mode = (Lit.RefractionMode)refractionMode.floatValue;
-                    if (mode != Lit.RefractionMode.None)
+                    m_MaterialEditor.ShaderProperty(refractionModel, Styles.refractionModelText);
+                    var mode = (Lit.RefractionModel)refractionModel.floatValue;
+                    if (mode != Lit.RefractionModel.None)
+                        m_MaterialEditor.ShaderProperty(refractionSSRayModel, Styles.refractionSSRayModelText);
                         m_MaterialEditor.ShaderProperty(ior, Styles.refractionIorText);
 
                         blendMode.floatValue = (float)BlendMode.Alpha;
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_IRIDESCENCE", materialId == BaseLitGUI.MaterialId.LitIridescence);
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SPECULAR_COLOR", materialId == BaseLitGUI.MaterialId.LitSpecular);
 
-            var refractionModeValue = (Lit.RefractionMode)material.GetFloat(kRefractionMode);
+            var refractionModelValue = (Lit.RefractionModel)material.GetFloat(kRefractionModel);
+            var refractionSSRayModelValue = (Lit.RefractionSSRayModel)material.GetFloat(kRefractionSSRayModel);
-            CoreUtils.SetKeyword(material, "_REFRACTION_PLANE", (refractionModeValue == Lit.RefractionMode.Plane) && canHaveRefraction);
-            CoreUtils.SetKeyword(material, "_REFRACTION_SPHERE", (refractionModeValue == Lit.RefractionMode.Sphere) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_PLANE", (refractionModelValue == Lit.RefractionModel.Plane) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_SPHERE", (refractionModelValue == Lit.RefractionModel.Sphere) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_SSRAY_PROXY", (refractionSSRayModelValue == Lit.RefractionSSRayModel.Proxy) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_SSRAY_HIZ", (refractionSSRayModelValue == Lit.RefractionSSRayModel.HiZ) && canHaveRefraction);
         }
     }
 } // namespace UnityEditor

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 
         FrameSettings m_FrameSettings; // Init every frame
 
+        ComputeBuffer m_DebugScreenSpaceTracingData = null;
+        ScreenSpaceTracingDebug[] m_DebugScreenSpaceTracingDataArray = new ScreenSpaceTracingDebug[1];
+
         public HDRenderPipeline(HDRenderPipelineAsset asset)
         {
             m_ValidAPI = true;
             // We don't need the debug of Scene View at runtime (each camera have its own debug settings)
             FrameSettings.RegisterDebug("Scene View", m_Asset.GetFrameSettings());
 #endif
+            m_DebugScreenSpaceTracingData = new ComputeBuffer(1, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ScreenSpaceTracingDebug)));
 
             InitializeRenderTextures();
 
 
             RTHandle.Release(m_DebugColorPickerBuffer);
             RTHandle.Release(m_DebugFullScreenTempBuffer);
+            
+            m_DebugScreenSpaceTracingData.Release();
         }
 
 
                 m_DbufferManager.PushGlobalParams(cmd, m_FrameSettings);
 
                 m_VolumetricLightingSystem.PushGlobalParams(hdCamera, cmd);
+
+                var ssrefraction = VolumeManager.instance.stack.GetComponent<ScreenSpaceRefraction>()
+                    ?? ScreenSpaceRefraction.@default;
+                ssrefraction.PushShaderParameters(cmd);
             }
         }
 
                         }
                     }
 #endif
+                    PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, hdCamera, FullScreenDebugMode.ScreenSpaceTracing);
                     // Caution: RenderDebug need to take into account that we have flip the screen (so anything capture before the flip will be flipped)
                     RenderDebug(hdCamera, cmd);
 
 
                 CommandBufferPool.Release(cmd);
                 renderContext.Submit();
+
+                if (m_CurrentDebugDisplaySettings.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing)
+                {
+                    m_DebugScreenSpaceTracingData.GetData(m_DebugScreenSpaceTracingDataArray);
+                    var data = m_DebugScreenSpaceTracingDataArray[0];
+                    m_CurrentDebugDisplaySettings.screenSpaceTracingDebugData = data;
+                }
             } // For each camera
         }
 
                 }
                 else
                 {
+                    // Assign debug data
+                    if (m_CurrentDebugDisplaySettings.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing
+                        && pass == ForwardPass.Transparent)
+                    {
+                        cmd.SetGlobalBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
+                        cmd.SetRandomWriteTarget(1, m_DebugScreenSpaceTracingData);
+                    }
+
                     HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer);
                     if (m_FrameSettings.enableDBuffer) // enable d-buffer flag value is being interpreted more like enable decals in general now that we have clustered
                     {
+
+                    if (m_CurrentDebugDisplaySettings.fullScreenDebugMode == FullScreenDebugMode.ScreenSpaceTracing
+                        && pass == ForwardPass.Transparent)
+                    {
+                        cmd.ClearRandomWriteTargets();
+                    }
                 }
             }
         }
 
                 cmd.SetGlobalInt(HDShaderIDs._DebugViewMaterial, (int)m_CurrentDebugDisplaySettings.GetDebugMaterialIndex());
                 cmd.SetGlobalInt(HDShaderIDs._DebugLightingMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingMode());
+                cmd.SetGlobalInt(HDShaderIDs._DebugLightingSubMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingSubMode());
                 cmd.SetGlobalInt(HDShaderIDs._DebugMipMapMode, (int)m_CurrentDebugDisplaySettings.GetDebugMipMapMode());
 
                 cmd.SetGlobalVector(HDShaderIDs._DebugLightingAlbedo, debugAlbedo);
 
                 cmd.SetGlobalVector(HDShaderIDs._MousePixelCoord, HDUtils.GetMouseCoordinates(hdCamera));
+                cmd.SetGlobalVector(HDShaderIDs._MouseClickPixelCoord, HDUtils.GetMouseClickCoordinates(hdCamera));
+                cmd.SetGlobalInt(HDShaderIDs._DebugStep, HDUtils.debugStep);
+                cmd.SetGlobalInt(HDShaderIDs._ShowGrid, m_CurrentDebugDisplaySettings.showSSRayGrid ? 1 : 0);
+                cmd.SetGlobalInt(HDShaderIDs._ShowDepthPyramidDebug, m_CurrentDebugDisplaySettings.showSSRayDepthPyramid ? 1 : 0);
 
                 // The DebugNeedsExposure test allows us to set a neutral value if exposure is not needed. This way we don't need to make various tests inside shaders but only in this function.
                 cmd.SetGlobalFloat(HDShaderIDs._DebugExposure, m_CurrentDebugDisplaySettings.DebugNeedsExposure() ? lightingDebugSettings.debugExposure : 0.0f);
                     // Everything we have capture is flipped (as it happen before FinalPass/postprocess/Blit. So if we are not in SceneView
                     // (i.e. we have perform a flip, we need to flip the input texture)
                     m_DebugFullScreen.SetFloat(HDShaderIDs._RequireToFlipInputTexture, hdCamera.camera.cameraType != CameraType.SceneView ? 1.0f : 0.0f);
+                    m_DebugFullScreen.SetBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
+                    m_DebugFullScreen.SetTexture(HDShaderIDs._DepthPyramidTexture, m_BufferPyramid.depthPyramid);
                     HDUtils.DrawFullScreen(cmd, hdCamera, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
 
                     PushColorPickerDebugTexture(cmd, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget, hdCamera);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

 
         public static readonly int _ViewTilesFlags = Shader.PropertyToID("_ViewTilesFlags");
         public static readonly int _MousePixelCoord = Shader.PropertyToID("_MousePixelCoord");
+        public static readonly int _MouseClickPixelCoord = Shader.PropertyToID("_MouseClickPixelCoord");
+        public static readonly int _DebugStep = Shader.PropertyToID("_DebugStep");
+        public static readonly int _DebugScreenSpaceTracingData = Shader.PropertyToID("_DebugScreenSpaceTracingData");
+        public static readonly int _ShowGrid = Shader.PropertyToID("_ShowGrid");
+        public static readonly int _ShowDepthPyramidDebug = Shader.PropertyToID("_ShowDepthPyramidDebug");
+        public static readonly int _DebugLightingSubMode = Shader.PropertyToID("_DebugLightingSubMode");
         public static readonly int _DebugLightingAlbedo = Shader.PropertyToID("_DebugLightingAlbedo");
         public static readonly int _DebugLightingSmoothness = Shader.PropertyToID("_DebugLightingSmoothness");
         public static readonly int _DebugLightingNormal = Shader.PropertyToID("_DebugLightingNormal");
             Shader.PropertyToID("_SSSBufferTexture2"),
             Shader.PropertyToID("_SSSBufferTexture3"),
         };
+
+        public static readonly int _SSRefractionRayMinLevel = Shader.PropertyToID("_SSRefractionRayMinLevel");
+        public static readonly int _SSRefractionRayMaxLevel = Shader.PropertyToID("_SSRefractionRayMaxLevel");
+        public static readonly int _SSRefractionRayMaxIterations = Shader.PropertyToID("_SSRefractionRayMaxIterations");
+        public static readonly int _SSRefractionRayDepthSuccessBias = Shader.PropertyToID("_SSRefractionRayDepthSuccessBias");
+        public static readonly int _SSRefractionInvScreenWeightDistance = Shader.PropertyToID("_SSRefractionInvScreenWeightDistance");
 
         public static readonly int _VelocityTexture = Shader.PropertyToID("_VelocityTexture");
         public static readonly int _ShadowMaskTexture = Shader.PropertyToID("_ShadowMaskTexture");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDUtils.cs

                 return null;
             }
         }
+        public static int debugStep { get { return MousePositionDebug.instance.debugStep; } }
 
         static MaterialPropertyBlock s_PropertyBlock = new MaterialPropertyBlock();
 
         public static Vector4 GetMouseCoordinates(HDCamera camera)
         {
             Vector2 mousePixelCoord = MousePositionDebug.instance.GetMousePosition(camera.screenSize.y);
+            return new Vector4(mousePixelCoord.x, mousePixelCoord.y, camera.scaleBias.x * mousePixelCoord.x / camera.screenSize.x, camera.scaleBias.y * mousePixelCoord.y / camera.screenSize.y);
+        }
+
+        // Returns mouse click coordinates: (x,y) in pixels and (z,w) normalized inside the render target (not the viewport)
+        public static Vector4 GetMouseClickCoordinates(HDCamera camera)
+        {
+            Vector2 mousePixelCoord = MousePositionDebug.instance.GetMouseClickPosition(camera.screenSize.y);
             return new Vector4(mousePixelCoord.x, mousePixelCoord.y, camera.scaleBias.x * mousePixelCoord.x / camera.screenSize.x, camera.scaleBias.y * mousePixelCoord.y / camera.screenSize.y);
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

                             m_DebugViewTilesMaterial.SetInt(HDShaderIDs._NumTiles, numTiles);
                             m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileClusterDebugByCategory);
                             m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, HDUtils.GetMouseCoordinates(hdCamera));
+                            m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MouseClickPixelCoord, HDUtils.GetMouseClickCoordinates(hdCamera));
                             m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_TileList, s_TileList);
                             m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_DispatchIndirectBuffer, s_DispatchIndirectBuffer);
                             m_DebugViewTilesMaterial.EnableKeyword("USE_FPTL_LIGHTLIST");
                         // lightCategories
                         m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileClusterDebugByCategory);
                         m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, HDUtils.GetMouseCoordinates(hdCamera));
+                        m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MouseClickPixelCoord, HDUtils.GetMouseClickCoordinates(hdCamera));
                         m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_vLightListGlobal, bUseClustered ? s_PerVoxelLightLists : s_LightList);
                         m_DebugViewTilesMaterial.EnableKeyword(bUseClustered ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                         m_DebugViewTilesMaterial.DisableKeyword(!bUseClustered ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.hlsl

     float reflectionHierarchyWeight = 0.0; // Max: 1.0
     float refractionHierarchyWeight = 0.0; // Max: 1.0
 
-    if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
+    // First loop iteration is:
+    //  1. Screen Space Refraction / Reflection
+    //  2. Environment Reflection / Refraction
+    //  3. Sky Reflection / Refraction
+    //
+    // Following loop iterations are:
+    //  1. Environment Reflection / Refraction
+    //  2. Sky Reflection / Refraction
+
+    // Common variable for all iterations
+    // Define macro for a better understanding of the loop
+#ifdef LIGHTLOOP_TILE_PASS
+    uint envLightStart;
+# define FETCHINDEX(index) FetchIndex(envLightStart, index);
+#else
+# define FETCHINDEX(index) index
+#endif
+    uint envLightCount;
+
+#define CONCAT(L, R) L##R
+#define EVALUATE_BSDF_ENV(envLightData, TYPE, type) {\
+    IndirectLighting lighting = EvaluateBSDF_Env(   context, V, posInput, preLightData, envLightData, bsdfData, \
+    envLightData.influenceShapeType, \
+    CONCAT(GPUIMAGEBASEDLIGHTINGTYPE_, TYPE), CONCAT(type, HierarchyWeight)); \
+    AccumulateIndirectLighting(lighting, aggregateLighting);\
+}
+
+    // First loop iteration
+    if (featureFlags & (
+              LIGHTFEATUREFLAGS_ENV 
+            | LIGHTFEATUREFLAGS_SKY
+            | LIGHTFEATUREFLAGS_SSREFRACTION
+            | LIGHTFEATUREFLAGS_SSREFLECTION
+        )
+    )
-        IndirectLighting lighting = EvaluateBSDF_SSLighting(
-            context,
-            V,
-            posInput,
-            preLightData,
-            bsdfData,
-            GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION,
-            refractionHierarchyWeight);
-        AccumulateIndirectLighting(lighting, aggregateLighting);
-    }
+        // Fetch first env light to provide the scene proxy for screen space computation
+        EnvLightData envLightData;
+        ZERO_INITIALIZE(EnvLightData, envLightData);
+        {
+            #ifdef LIGHTLOOP_TILE_PASS
+                GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
+            #else
+                envLightCount = _EnvLightCount;
+            #endif
+            if (envLightCount > 0)
+            {
+                uint envLightIndex = FETCHINDEX(0);
+                envLightData = _EnvLightDatas[envLightIndex];
+            }
+            else
+                envLightData = InitSkyEnvLightData(0);
+        }
+
+        if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
+        {
+            IndirectLighting lighting = EvaluateBSDF_SSLighting(    context, V, posInput, preLightData, bsdfData, envLightData,
+                                                                    GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION, refractionHierarchyWeight);
+            AccumulateIndirectLighting(lighting, aggregateLighting);
+        }
+
+        if (featureFlags & LIGHTFEATUREFLAGS_SSREFLECTION)
+        {
+            IndirectLighting lighting = EvaluateBSDF_SSLighting(    context, V, posInput, preLightData, bsdfData, envLightData,
+                                                                    GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION, reflectionHierarchyWeight);
+            AccumulateIndirectLighting(lighting, aggregateLighting);
+        }
+
+        if ((featureFlags & LIGHTFEATUREFLAGS_ENV) && envLightCount > 0)
+        {
+            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
+            
+            EVALUATE_BSDF_ENV(envLightData, REFLECTION, reflection);
+
+            if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
+                EVALUATE_BSDF_ENV(envLightData, REFRACTION, refraction);
+        }
+
+        // Only apply the sky IBL if the sky texture is available
+        if ((featureFlags & LIGHTFEATUREFLAGS_SKY) && _EnvLightSkyEnabled)
+        {
+            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-    if (featureFlags & LIGHTFEATUREFLAGS_SSREFLECTION)
-    {
-        IndirectLighting lighting = EvaluateBSDF_SSLighting(
-            context,
-            V,
-            posInput,
-            preLightData,
-            bsdfData,
-            GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION,
-            reflectionHierarchyWeight);
-        AccumulateIndirectLighting(lighting, aggregateLighting);
+            // The sky data are generated on the fly so the compiler can optimize the code
+            EnvLightData envLightSky = InitSkyEnvLightData(0);
+            EVALUATE_BSDF_ENV(envLightSky, REFLECTION, reflection);
+
+            if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
+                EVALUATE_BSDF_ENV(envLightSky, REFRACTION, refraction);
+        }
+    // Following loop iterations
     if (featureFlags & LIGHTFEATUREFLAGS_ENV || featureFlags & LIGHTFEATUREFLAGS_SKY)
     {
         // Reflection probes are sorted by volume (in the increasing order).
 
-        #ifdef LIGHTLOOP_TILE_PASS
-            uint envLightStart;
-            uint envLightCount;
-            GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
-        #else
-            uint envLightCount = _EnvLightCount;
-        #endif
-
-            #ifdef LIGHTLOOP_TILE_PASS
-                uint envLightIndex = FetchIndex(envLightStart, i);
-            #else
-                uint envLightIndex = i;
-            #endif
-                IndirectLighting lighting = EvaluateBSDF_Env(   context, V, posInput, preLightData, _EnvLightDatas[envLightIndex], bsdfData,
-                                                                _EnvLightDatas[envLightIndex].influenceShapeType,
-                                                                GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION, reflectionHierarchyWeight);
-                AccumulateIndirectLighting(lighting, aggregateLighting);
+                uint envLightIndex = FETCHINDEX(i);
+                EVALUATE_BSDF_ENV(_EnvLightDatas[envLightIndex], REFLECTION, reflection);
             }
 
             // Refraction probe and reflection probe will process exactly the same weight. It will be good for performance to be able to share this computation
             {
                 for (i = 0; i < envLightCount && refractionHierarchyWeight < 1.0; ++i)
                 {
-                #ifdef LIGHTLOOP_TILE_PASS
-                    uint envLightIndex = FetchIndex(envLightStart, i);
-                #else
-                    uint envLightIndex = i;
-                #endif
-                    IndirectLighting lighting = EvaluateBSDF_Env(   context, V, posInput, preLightData, _EnvLightDatas[envLightIndex], bsdfData,
-                                                                    _EnvLightDatas[envLightIndex].influenceShapeType,
-                                                                    GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION, refractionHierarchyWeight);
-                    AccumulateIndirectLighting(lighting, aggregateLighting);
+                    uint envLightIndex = FETCHINDEX(i);
+                    EVALUATE_BSDF_ENV(_EnvLightDatas[envLightIndex], REFRACTION, refraction);
                 }
             }
         }
 
                 // The sky data are generated on the fly so the compiler can optimize the code
                 EnvLightData envLightSky = InitSkyEnvLightData(0);
-
-                IndirectLighting lighting = EvaluateBSDF_Env(       context, V, posInput, preLightData, envLightSky, bsdfData, 
-                                                                    ENVSHAPETYPE_SKY, 
-                                                                    GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION, reflectionHierarchyWeight);
-                AccumulateIndirectLighting(lighting, aggregateLighting);
+                EVALUATE_BSDF_ENV(envLightSky, REFLECTION, reflection);
             }
 
             if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
                     
                     // The sky data are generated on the fly so the compiler can optimize the code
                     EnvLightData envLightSky = InitSkyEnvLightData(0);
-
-                    IndirectLighting lighting = EvaluateBSDF_Env(       context, V, posInput, preLightData, envLightSky, bsdfData, 
-                                                                        ENVSHAPETYPE_SKY, 
-                                                                        GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION, refractionHierarchyWeight);
-                    AccumulateIndirectLighting(lighting, aggregateLighting);
+                    EVALUATE_BSDF_ENV(envLightSky, REFRACTION, refraction);
+#undef EVALUATE_BSDF_ENV
+#undef CONCAT
+#undef FETCHINDEX
 
     // Also Apply indiret diffuse (GI)
     // PostEvaluateBSDF will perform any operation wanted by the material and sum everything into diffuseLighting and specularLighting

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs

             LitClearCoat            = 1 << 6
         };
 
-        [GenerateHLSL(PackingRules.Exact)]
-        public enum RefractionMode
+        public enum RefractionModel
+
+        [GenerateHLSL]
+        public enum RefractionSSRayModel
+        {
+            None = 0,
+            Proxy = 1,
+            HiZ = 2
+        };
+
+        [GenerateHLSL]
+        public enum HiZIntersectionKind
+        {
+            None,
+            Cell,
+            Depth
+        }
 
         //-----------------------------------------------------------------------------
         // SurfaceData

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs.hlsl

 #define MATERIALFEATUREFLAGS_LIT_CLEAR_COAT (64)
 
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.Lit+RefractionMode:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.Lit+RefractionSSRayModel:  static fields
+//
+#define REFRACTIONSSRAYMODEL_NONE (0)
+#define REFRACTIONSSRAYMODEL_PROXY (1)
+#define REFRACTIONSSRAYMODEL_HI_Z (2)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Lit+HiZIntersectionKind:  static fields
-#define REFRACTIONMODE_NONE (0)
-#define REFRACTIONMODE_PLANE (1)
-#define REFRACTIONMODE_SPHERE (2)
+#define HIZINTERSECTIONKIND_NONE (0)
+#define HIZINTERSECTIONKIND_CELL (1)
+#define HIZINTERSECTIONKIND_DEPTH (2)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+SurfaceData:  static fields

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

 // Depth pyramid (width, height, lodcount, Unused)
 TEXTURE2D(_DepthPyramidTexture);
 
-CBUFFER_START(UnityGaussianPyramidParameters)
+CBUFFER_START(UnityLightingParameters)
+// Buffer pyramid
+
+// Screen space lighting
+float _SSRefractionInvScreenWeightDistance;     // Distance for screen space smoothstep with fallback
+
+// Ambiant occlusion
+float4 _AmbientOcclusionParam; // xyz occlusion color, w directLightStrenght
-
-CBUFFER_START(UnityAmbientOcclusionParameters)
-float4 _AmbientOcclusionParam; // xyz occlusion color, w directLightStrenght
-CBUFFER_END
 
 // Area light textures
 // TODO: This one should be set into a constant Buffer at pass frequency (with _Screensize)
 #define GBufferType2 float4
 #define GBufferType3 float4
 
-#define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE))
+#define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE)) && (defined(_REFRACTION_SSRAY_PROXY) || defined(_REFRACTION_SSRAY_HIZ))
 
 #define DEFAULT_SPECULAR_VALUE 0.04
 
 
 #if HAS_REFRACTION
 # include "CoreRP/ShaderLibrary/Refraction.hlsl"
+# include "HDRP/Lighting/Reflection/VolumeProjection.hlsl"
+# include "HDRP/Lighting/LightDefinition.cs.hlsl"
+# define SSRTID Refraction
+# include "HDRP/Lighting/Reflection/ScreenSpaceTracing.hlsl"
+# undef SSRTID
 
 # if defined(_REFRACTION_PLANE)
 #  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelPlane(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
-#endif
-
-float3 EstimateRaycast(float3 V, PositionInputs posInputs, float3 positionWS, float3 rayWS)
-{
-    // For all refraction approximation, to calculate the refracted point in world space,
-    //   we approximate the scene as a plane (back plane) with normal -V at the depth hit point.
-    //   (We avoid to raymarch the depth texture to get the refracted point.)
-
-    uint2 depthSize = uint2(_DepthPyramidSize.xy);
-
-    // Get the depth of the approximated back plane
-    float pyramidDepth = LOAD_TEXTURE2D_LOD(_DepthPyramidTexture, posInputs.positionNDC * (depthSize >> 2), 2).r;
-    float depth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
-    // Distance from point to the back plane
-    float depthFromPositionInput = depth - posInputs.linearDepth;
-
-    float offset = dot(-V, positionWS - posInputs.positionWS);
-    float depthFromPosition = depthFromPositionInput - offset;
-
-    float hitDistanceFromPosition = depthFromPosition / dot(-V, rayWS);
-
-    return positionWS + rayWS * hitDistanceFromPosition;
-}
+# if defined(_REFRACTION_SSRAY_PROXY)
+#  define REFRACTION_SSRAY_IN ScreenSpaceProxyRaycastInput
+#  define REFRACTION_SSRAY_QUERY(input, hit) ScreenSpaceProxyRaycastRefraction(input, hit)
+# elif defined(_REFRACTION_SSRAY_HIZ)
+#  define REFRACTION_SSRAY_IN ScreenSpaceHiZRaymarchInput
+#  define REFRACTION_SSRAY_QUERY(input, hit) ScreenSpaceHiZRaymarchRefraction(input, hit)
+# endif
+#endif
 
 // This method allows us to know at compile time what material features should be removed from the code by Tile (Indepenently of the value of material feature flag per pixel).
 // This is only useful for classification during lighting, so it's not needed in EncodeIntoGBuffer and ConvertSurfaceDataToBSDFData (where we always know exactly what the material feature is)
 IndirectLighting EvaluateBSDF_SSLighting(LightLoopContext lightLoopContext,
                                             float3 V, PositionInputs posInput,
                                             PreLightData preLightData, BSDFData bsdfData,
+                                            EnvLightData envLightData,
                                             int GPUImageBasedLightingType,
                                             inout float hierarchyWeight)
 {
         case GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION:
         {
 #if HAS_REFRACTION
+
             // Refraction process:
             //  1. Depending on the shape model, we calculate the refracted point in world space and the optical depth
             //  2. We calculate the screen space position of the refracted point
 
-            float3 refractedBackPointWS = EstimateRaycast(V, posInput, preLightData.transparentPositionWS, preLightData.transparentRefractV);
+            float3 rayOriginWS      = preLightData.transparentPositionWS;
+            float3 rayDirWS         = preLightData.transparentRefractV;
+#if DEBUG_DISPLAY
+            int debugMode           = DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION;
+            bool debug              = _DebugLightingMode == debugMode
+                && !any(int2(_MouseClickPixelCoord.xy) - int2(posInput.positionSS));
+#endif
+
+            // Initialize screen space tracing
+            REFRACTION_SSRAY_IN ssRayInput;
+            ZERO_INITIALIZE(REFRACTION_SSRAY_IN, ssRayInput);
+
+            // Common initialization
+            ssRayInput.rayOriginWS = rayOriginWS;
+            ssRayInput.rayDirWS = rayDirWS;
+#if DEBUG_DISPLAY
+            ssRayInput.debug = debug;
+#endif
+            // Algorithm specific initialization
+#ifdef _REFRACTION_SSRAY_HIZ
+            ssRayInput.maxIterations = uint(-1);
+#elif _REFRACTION_SSRAY_PROXY
+            ssRayInput.proxyData = envLightData;
+#endif
-            // Calculate screen space coordinates of refracted point in back plane
-            float2 refractedBackPointNDC = ComputeNormalizedDeviceCoordinates(refractedBackPointWS, UNITY_MATRIX_VP);
-            uint2 depthSize = uint2(_DepthPyramidSize.xy);
-            float refractedBackPointDepth = LinearEyeDepth(LOAD_TEXTURE2D_LOD(_DepthPyramidTexture, refractedBackPointNDC * depthSize, 0).r, _ZBufferParams);
+            // Perform ray query
+            ScreenSpaceRayHit hit;
+            ZERO_INITIALIZE(ScreenSpaceRayHit, hit);
+            bool hitSuccessful = REFRACTION_SSRAY_QUERY(ssRayInput, hit);
+
+            // Debug screen space tracing
+#ifdef DEBUG_DISPLAY
+            if (_DebugLightingMode == debugMode
+                && _DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
+            {
+                float weight = 1.0;
+                UpdateLightingHierarchyWeights(hierarchyWeight, weight);
+                lighting.specularTransmitted = hit.debugOutput;
+                return lighting;
+            }
+#endif
+
+            if (!hitSuccessful)
+                return lighting;
+
+            float2 weightNDC = clamp(min(hit.positionNDC, 1 - hit.positionNDC) * _SSRefractionInvScreenWeightDistance, 0, 1);
+            weightNDC = weightNDC * weightNDC * (3 - 2 * weightNDC);
+            float weight = weightNDC.x * weightNDC.y;
+
+            float hitDeviceDepth = LOAD_TEXTURE2D_LOD(_DepthPyramidTexture, hit.positionSS, 0).r;
+            float hitLinearDepth = LinearEyeDepth(hitDeviceDepth, _ZBufferParams);
-            if (refractedBackPointDepth < posInput.linearDepth
-                || any(refractedBackPointNDC < 0.0)
-                || any(refractedBackPointNDC > 1.0))
+            if (hitLinearDepth < posInput.linearDepth
+                || weight == 0)
-            // Map the roughness to the correct mip map level of the color pyramid
-            lighting.specularTransmitted = SAMPLE_TEXTURE2D_LOD(_ColorPyramidTexture, s_trilinear_clamp_sampler, refractedBackPointNDC * _ColorPyramidScale.xy, preLightData.transparentSSMipLevel).rgb;
+            UpdateLightingHierarchyWeights(hierarchyWeight, weight); // Shouldn't be needed, but safer in case we decide to change hierarchy priority
-            // Beer-Lamber law for absorption
-            lighting.specularTransmitted *= preLightData.transparentTransmittance;
+            float3 preLD = SAMPLE_TEXTURE2D_LOD(
+                _ColorPyramidTexture, 
+                s_trilinear_clamp_sampler, 
+                hit.positionNDC * _ColorPyramidScale.xy, 
+                preLightData.transparentSSMipLevel
+            ).rgb;
-            float weight = 1.0;
-            UpdateLightingHierarchyWeights(hierarchyWeight, weight); // Shouldn't be needed, but safer in case we decide to change hierarchy priority
-            lighting.specularTransmitted *= (1.0 - preLightData.specularFGD) * weight;
+            float3 F = preLightData.specularFGD;
+            lighting.specularTransmitted = (1.0 - F) * preLD.rgb * preLightData.transparentTransmittance * weight;
 #else
             // No refraction, no need to go further
             hierarchyWeight = 1.0;
 
 #ifdef DEBUG_DISPLAY
 
-    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    switch(_DebugLightingMode)
+        case DEBUGLIGHTINGMODE_LUX_METER:
-    }
-    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION_FROM_SSAO)
-    {
+            break;
+        case DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION_FROM_SSAO:
-    }
-    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION_FROM_SSAO)
-    {
+            break;
+        case DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION_FROM_SSAO:
-    }
+            break;
-    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_GTAO_FROM_SSAO)
-    {
+        case DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_GTAO_FROM_SSAO:
-    }
-    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_GTAO_FROM_SSAO)
-    {
+            break;
+        case DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_GTAO_FROM_SSAO:
-    }
+            break;
-    else if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
+        case DEBUGMIPMAPMODE_NONE:
+            diffuseLighting = bsdfData.diffuseColor;
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            break;
+        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION:
+            if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
-        diffuseLighting = bsdfData.diffuseColor;
+                diffuseLighting = lighting.indirect.specularTransmitted;
+    }
+            break;
     }
 #endif
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

         _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
         // Transparency
-        [Enum(None, 0, Plane, 1, Sphere, 2)]_RefractionMode("Refraction Mode", Int) = 0
+        [Enum(None, 0, Plane, 1, Sphere, 2)]_RefractionModel("Refraction Model", Int) = 0
+        [Enum(Proxy, 1, HiZ, 2)]_RefractionSSRayModel("Refraction SSRay Model", Int) = 0
         _Ior("Index Of Refraction", Range(1.0, 2.5)) = 1.0
         _ThicknessMultiplier("Thickness Multiplier", Float) = 1.0
         _TransmittanceColor("Transmittance Color", Color) = (1.0, 1.0, 1.0)
     #pragma shader_feature _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
     #pragma shader_feature _VERTEX_WIND
     #pragma shader_feature _ _REFRACTION_PLANE _REFRACTION_SPHERE
+    #pragma shader_feature _ _REFRACTION_SSRAY_PROXY _REFRACTION_SSRAY_HIZ
 
     #pragma shader_feature _ _EMISSIVE_MAPPING_PLANAR _EMISSIVE_MAPPING_TRIPLANAR
     #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

         _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
         // Transparency
-        [Enum(None, 0, Plane, 1, Sphere, 2)]_RefractionMode("Refraction Mode", Int) = 0
+        [Enum(None, 0, Plane, 1, Sphere, 2)]_RefractionModel("Refraction Model", Int) = 0
+        [Enum(Proxy, 1, HiZ, 2)]_RefractionSSRayModel("Refraction SSRay Model", Int) = 0
         _Ior("Index Of Refraction", Range(1.0, 2.5)) = 1.0
         _ThicknessMultiplier("Thickness Multiplier", Float) = 1.0
         _TransmittanceColor("Transmittance Color", Color) = (1.0, 1.0, 1.0)
     #pragma shader_feature _VERTEX_WIND
     #pragma shader_feature _ _TESSELLATION_PHONG
     #pragma shader_feature _ _REFRACTION_PLANE _REFRACTION_SPHERE
+    #pragma shader_feature _ _REFRACTION_SSRAY_PROXY _REFRACTION_SSRAY_HIZ
 
     #pragma shader_feature _ _EMISSIVE_MAPPING_PLANAR _EMISSIVE_MAPPING_TRIPLANAR
     #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/Materials/PreRefractionPassTester.mat

   m_Name: PreRefractionPassTester
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _ENABLE_FOG_ON_TRANSPARENT _NORMALMAP_TANGENT_SPACE
-    _REFRACTION_PLANE _SURFACE_TYPE_TRANSPARENT
+    _REFRACTION_PLANE _REFRACTION_SSRAY_PROXY _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 1
+    - _RefractionModel: 1
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Default_Sky.asset

   components:
   - {fileID: 114827887035766406}
   - {fileID: 114408460862325740}
+  - {fileID: 114596847542454078}
 --- !u!114 &114408460862325740
 MonoBehaviour:
   m_ObjectHideFlags: 3
   hdriSky:
     m_OverrideState: 1
     m_Value: {fileID: 8900000, guid: fb0bf2eac2381484187ba8a68cdca165, type: 3}
+--- !u!114 &114596847542454078
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5e17fad69ea181b4483974138b566975, type: 3}
+  m_Name: ScreenSpaceRefraction
+  m_EditorClassIdentifier: 
+  active: 1
+  rayMinLevel:
+    m_OverrideState: 0
+    m_Value: 2
+  rayMaxLevel:
+    m_OverrideState: 0
+    m_Value: 6
+  rayMaxIterations:
+    m_OverrideState: 0
+    m_Value: 32
+  rayDepthSuccessBias:
+    m_OverrideState: 0
+    m_Value: 0.2
+  screenWeightDistance:
+    m_OverrideState: 1
+    m_Value: 0.05
+    min: 0
+    max: 1
 --- !u!114 &114827887035766406
 MonoBehaviour:
   m_ObjectHideFlags: 3

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Plane_NM.mat

   m_Name: Lit_Refraction_Plane_NM
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _SURFACE_TYPE_TRANSPARENT
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _REFRACTION_SSRAY_PROXY
+    _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 1
+    - _RefractionModel: 1
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Plane_NM_Thickness.mat

   m_Name: Lit_Refraction_Plane_NM_Thickness
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _SURFACE_TYPE_TRANSPARENT
-    _THICKNESSMAP
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _REFRACTION_SSRAY_PROXY
+    _SURFACE_TYPE_TRANSPARENT _THICKNESSMAP
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 1
+    - _RefractionModel: 1
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Plane_Thickness.mat

   m_Name: Lit_Refraction_Plane_Thickness
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _SURFACE_TYPE_TRANSPARENT _THICKNESSMAP
+    _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _REFRACTION_SSRAY_PROXY _SURFACE_TYPE_TRANSPARENT
+    _THICKNESSMAP
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 1
+    - _RefractionModel: 1
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Sphere_NM.mat

   m_Name: Lit_Refraction_Sphere_NM
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _SURFACE_TYPE_TRANSPARENT
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _REFRACTION_SSRAY_PROXY
+    _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 2
+    - _RefractionModel: 2
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Sphere_NM_Thickness.mat

   m_Name: Lit_Refraction_Sphere_NM_Thickness
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _SURFACE_TYPE_TRANSPARENT
-    _THICKNESSMAP
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _REFRACTION_SSRAY_PROXY
+    _SURFACE_TYPE_TRANSPARENT _THICKNESSMAP
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 2
+    - _RefractionModel: 2
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Sphere_Thickness.mat

   m_Name: Lit_Refraction_Sphere_Thickness
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _SURFACE_TYPE_TRANSPARENT _THICKNESSMAP
+    _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _REFRACTION_SSRAY_PROXY _SURFACE_TYPE_TRANSPARENT
+    _THICKNESSMAP
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 2
+    - _RefractionModel: 2
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Sphere_HiZ.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: Lit_Refraction_Sphere
+  m_Name: Lit_Refraction_Sphere_HiZ
-    _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _SURFACE_TYPE_TRANSPARENT
+    _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _REFRACTION_SSRAY_HIZ _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 2
+    - _RefractionModel: 2
+    - _RefractionSSRayModel: 2
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Plane_HiZ.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: Lit_Refraction_Plane
+  m_Name: Lit_Refraction_Plane_HiZ
-    _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _SURFACE_TYPE_TRANSPARENT
+    _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _REFRACTION_SSRAY_HIZ _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 1
+    - _RefractionModel: 1
+    - _RefractionSSRayModel: 2
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/9xxx_Other/9002_Deferred-and-Forward/ComplexMaterial_Flipped/ComplexMaterial_Flipped.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: ComplexMaterial_Flipped
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _DEPTHOFFSET_ON _DISPLACEMENT_LOCK_TILING_SCALE _NORMALMAP_TANGENT_SPACE
-    _PIXEL_DISPLACEMENT _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
+  m_ShaderKeywords: _DEPTHOFFSET_ON _DISPLACEMENT_LOCK_TILING_SCALE _HEIGHTMAP _MASKMAP
+    _NORMALMAP _NORMALMAP_TANGENT_SPACE _PIXEL_DISPLACEMENT _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _BaseColorMap:
-        m_Texture: {fileID: 2800000, guid: b6df07666246e084ca55b5b8350198d5, type: 3}
+        m_Texture: {fileID: 2800000, guid: 2634cf73e49fcb441be8dd497e2c6e8e, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _BentNormalMap:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _HeightMap:
-        m_Texture: {fileID: 2800000, guid: c3ec713a6f2b97f4ea724a902595594b, type: 3}
+        m_Texture: {fileID: 2800000, guid: 918d9a75a9ac1754db592f3548a52f7c, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _IridescenceMaskMap:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MainTex:
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 2800000, guid: 2634cf73e49fcb441be8dd497e2c6e8e, type: 3}
-        m_Texture: {fileID: 2800000, guid: e20e6361c7446a1479f49d10c5d054c3, type: 3}
+        m_Texture: {fileID: 2800000, guid: 9fb31f0c9b4bb5045985f56fac81d86e, type: 3}
-        m_Texture: {fileID: 2800000, guid: 260e01b71437c7649a10c1dad5b7ca70, type: 3}
+        m_Texture: {fileID: 2800000, guid: 754c4d2de266018488c6400f53842b7b, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _NormalMapOS:
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 0
+    - _RefractionModel: 0
+    - _RefractionSSRayModel: 0
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/9xxx_Other/9002_Deferred-and-Forward/ComplexMaterial_Flipped/Textures/ComplexMat_H.png.meta

   mipmaps:
     mipMapMode: 0
     enableMipMap: 1
-    sRGBTexture: 1
+    sRGBTexture: 0
     linearTexture: 0
     fadeOut: 0
     borderMipMap: 0
   platformSettings:
   - serializedVersion: 2
     buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: PS4
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/9xxx_Other/9002_Deferred-and-Forward/ComplexMaterial_Flipped/Textures/ComplexMat__N.png.meta

   mipmaps:
     mipMapMode: 0
     enableMipMap: 1
-    sRGBTexture: 1
+    sRGBTexture: 0
     linearTexture: 0
     fadeOut: 0
     borderMipMap: 0
   alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1
-  textureType: 0
+  textureType: 1
   textureShape: 1
   singleChannelComponent: 0
   maxTextureSizeSet: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/9xxx_Other/9002_Deferred-and-Forward/GlassLike.mat

   m_Name: GlassLike
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _SURFACE_TYPE_TRANSPARENT
+    _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _REFRACTION_SSRAY_PROXY _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _PPDPrimitiveWidth: 1
     - _PreRefractionPass: 0
     - _RefractionMode: 2
+    - _RefractionModel: 2
+    - _RefractionSSRayModel: 1
     - _SSSAndTransmissionType: 0
     - _ShiverDirectionality: 0.5
     - _ShiverDrag: 0.2

Tests/Scripts/GraphicTests/Framework/TestFrameworkTools.cs

 #if UNITY_EDITOR
                 string absoluteScenesPath = s_Path.Aggregate(s_RootPath, Path.Combine);
 
-                string assetScenesPath = absoluteScenesPath.Replace(Application.dataPath, "");
-                assetScenesPath = Path.Combine("Assets", assetScenesPath.Remove(0, 1));
+                string assetScenesPath = absoluteScenesPath.Substring(absoluteScenesPath.IndexOf("Assets"));
 
                 string filesPath = Path.Combine(assetScenesPath, _pipelinePath);
 

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

+using System.Collections;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Experimental.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [CanEditMultipleObjects]
+    [VolumeComponentEditor(typeof(ScreenSpaceRefraction))]
+    public class ScreenSpaceRefractionEditor : VolumeComponentEditor
+    {
+        SerializedDataParameter m_RayMinLevel;
+        SerializedDataParameter m_RayMaxLevel;
+        SerializedDataParameter m_RayMaxIterations;
+        SerializedDataParameter m_RayDepthSuccessBias;
+        SerializedDataParameter m_ScreenWeightDistance;
+
+        public override void OnEnable()
+        {
+            var o = new PropertyFetcher<ScreenSpaceRefraction>(serializedObject);
+
+            m_RayMinLevel = Unpack(o.Find(x => x.rayMinLevel));
+            m_RayMaxLevel = Unpack(o.Find(x => x.rayMaxLevel));
+            m_RayMaxIterations = Unpack(o.Find(x => x.rayMaxIterations));
+            m_RayDepthSuccessBias = Unpack(o.Find(x => x.rayDepthSuccessBias));
+            m_ScreenWeightDistance = Unpack(o.Find(x => x.screenWeightDistance));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.LabelField(CoreEditorUtils.GetContent("HiZ Settings"));
+            PropertyField(m_RayMinLevel, CoreEditorUtils.GetContent("Ray Min Level"));
+            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"));
+
+            EditorGUILayout.Separator();
+            EditorGUILayout.LabelField(CoreEditorUtils.GetContent("Common Settings"));
+            PropertyField(m_ScreenWeightDistance, CoreEditorUtils.GetContent("Screen Weight Distance"));
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/ScreenSpaceRefractionEditor.cs.meta

+fileFormatVersion: 2
+guid: 5b3212fe1b5bb3c4397c9427bb77c207
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public class ScreenSpaceRefraction : VolumeComponent
+    {
+        static ScreenSpaceRefraction s_Default = null;
+        public static ScreenSpaceRefraction @default
+        {
+            get
+            {
+                if (s_Default == null)
+                {
+                    s_Default = ScriptableObject.CreateInstance<ScreenSpaceRefraction>();
+                    s_Default.hideFlags = HideFlags.HideAndDontSave;
+                }
+                return s_Default;
+            }
+        }
+
+        public IntParameter                 rayMinLevel = new IntParameter(2);
+        public IntParameter                 rayMaxLevel = new IntParameter(6);
+        public IntParameter                 rayMaxIterations = new IntParameter(32);
+        public FloatParameter               rayDepthSuccessBias = new FloatParameter(0.1f);
+        public ClampedFloatParameter        screenWeightDistance = new ClampedFloatParameter(0.1f, 0, 1);
+
+        public void PushShaderParameters(CommandBuffer cmd)
+        {
+            cmd.SetGlobalInt(HDShaderIDs._SSRefractionRayMinLevel, rayMinLevel.value);
+            cmd.SetGlobalInt(HDShaderIDs._SSRefractionRayMaxLevel, rayMaxLevel.value);
+            cmd.SetGlobalInt(HDShaderIDs._SSRefractionRayMaxIterations, rayMaxIterations.value);
+            cmd.SetGlobalFloat(HDShaderIDs._SSRefractionRayDepthSuccessBias, rayDepthSuccessBias.value);
+            cmd.SetGlobalFloat(HDShaderIDs._SSRefractionInvScreenWeightDistance, 1f / screenWeightDistance.value);
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 5e17fad69ea181b4483974138b566975
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+#ifndef UNITY_SCREEN_SPACE_TRACING_INCLUDED
+#define UNITY_SCREEN_SPACE_TRACING_INCLUDED
+
+// -------------------------------------------------
+// Algorithm uniform parameters
+// -------------------------------------------------
+
+const float DepthPlaneBias = 1E-5;
+
+// -------------------------------------------------
+// Output
+// -------------------------------------------------
+
+struct ScreenSpaceRayHit
+{
+    uint2 positionSS;       // Position of the hit point (SS)
+    float2 positionNDC;     // Position of the hit point (NDC)
+    float linearDepth;      // Linear depth of the hit point
+
+#ifdef DEBUG_DISPLAY
+    float3 debugOutput;
+#endif
+};
+
+struct ScreenSpaceHiZRaymarchInput
+{
+    float3 rayOriginWS;         // Ray origin (WS)
+    float3 rayDirWS;            // Ray direction (WS)
+    uint maxIterations;          // Number of iterations before failing
+
+#ifdef DEBUG_DISPLAY
+    bool debug;
+#endif
+};
+
+struct ScreenSpaceProxyRaycastInput
+{
+    float3 rayOriginWS;         // Ray origin (WS)
+    float3 rayDirWS;            // Ray direction (WS)
+    EnvLightData proxyData;
+
+#ifdef DEBUG_DISPLAY
+    bool debug;
+#endif
+};
+
+// -------------------------------------------------
+// Utilities
+// -------------------------------------------------
+
+// Calculate the ray origin and direction in SS
+// out positionSS  : (x, y, 1/depth)
+// out raySS       : (x, y, 1/depth)
+void CalculateRaySS(
+    float3 rayOriginWS,
+    float3 rayDirWS,
+    uint2 bufferSize,
+    out float3 positionSS,
+    out float3 raySS
+)
+{
+    float3 positionWS = rayOriginWS;
+    float3 rayEndWS = rayOriginWS + rayDirWS * 10;
+
+    float4 positionCS = ComputeClipSpacePosition(positionWS, GetWorldToHClipMatrix());
+    float4 rayEndCS = ComputeClipSpacePosition(rayEndWS, GetWorldToHClipMatrix());
+
+    float2 positionNDC = ComputeNormalizedDeviceCoordinates(positionWS, GetWorldToHClipMatrix());
+    float2 rayEndNDC = ComputeNormalizedDeviceCoordinates(rayEndWS, GetWorldToHClipMatrix());
+
+    float3 rayStartSS = float3(
+        positionNDC.xy * bufferSize,
+        1.0 / positionCS.w); // Screen space depth interpolate properly in 1/z
+
+    float3 rayEndSS = float3(
+        rayEndNDC.xy * bufferSize,
+        1.0 / rayEndCS.w); // Screen space depth interpolate properly in 1/z
+
+    positionSS = rayStartSS;
+    raySS = rayEndSS - rayStartSS;
+}
+
+// Check whether the depth of the ray is above the sampled depth
+// Arguments are inversed linear depth
+bool IsPositionAboveDepth(float rayDepth, float invLinearDepth)
+{
+    // as depth is inverted, we must invert the check as well
+    // rayZ > HiZ <=> 1/rayZ < 1/HiZ
+    return rayDepth > invLinearDepth;
+}
+
+// Sample the Depth buffer at a specific mip and linear depth
+float LoadDepth(float2 positionSS, int level)
+{
+    float pyramidDepth = LOAD_TEXTURE2D_LOD(_DepthPyramidTexture, int2(positionSS.xy) >> level, level).r;
+    float linearDepth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
+    return linearDepth;
+}
+
+// Sample the Depth buffer at a specific mip and return 1/linear depth
+float LoadInvDepth(float2 positionSS, int level)
+{
+    float linearDepth = LoadDepth(positionSS, level);
+    float invLinearDepth = 1 / linearDepth;
+    return invLinearDepth;
+}
+
+bool CellAreEquals(int2 cellA, int2 cellB)
+{
+    return cellA.x == cellB.x && cellA.y == cellB.y;
+}
+
+// Calculate intersection between the ray and the depth plane
+// positionSS.z is 1/depth
+// raySS.z is 1/depth
+float3 IntersectDepthPlane(float3 positionSS, float3 raySS, float invDepth)
+{
+    // The depth of the intersection with the depth plane is: positionSS.z + raySS.z * t = invDepth
+    float t = (invDepth - positionSS.z) / raySS.z;
+
+    // (t<0) When the ray is going away from the depth plane,
+    //  put the intersection away.
+    // Instead the intersection with the next tile will be used.
+    // (t>=0) Add a small distance to go through the depth plane.
+    t = t >= 0.0f ? (t + DepthPlaneBias) : 1E5;
+
+    // Return the point on the ray
+    return positionSS + raySS * t;
+}
+
+// Calculate intersection between a ray and a cell
+float3 IntersectCellPlanes(
+    float3 positionSS,
+    float3 raySS,
+    float2 invRaySS,
+    int2 cellId,
+    uint2 cellSize,
+    int2 cellPlanes,
+    float2 crossOffset
+)
+{
+    const float SQRT_2 = sqrt(2);
+    const float CellPlaneBias = 1E-2;
+
+    // Planes to check
+    int2 planes = (cellId + cellPlanes) * cellSize;
+    // Hit distance to each planes
+    float2 distanceToCellAxes = float2(planes - positionSS.xy) * invRaySS; // (distance to x axis, distance to y axis)
+    float t = min(distanceToCellAxes.x, distanceToCellAxes.y)
+        // Offset by 1E-3 to ensure cell boundary crossing
+        // This assume that length(raySS.xy) == 1;
+        + CellPlaneBias;
+    // Interpolate screen space to get next test point
+    float3 testHitPositionSS = positionSS + raySS * t;
+
+    return testHitPositionSS;
+}
+
+#ifdef DEBUG_DISPLAY
+// -------------------------------------------------
+// Debug Utilities
+// -------------------------------------------------
+
+void DebugComputeCommonOutput(
+    float3 rayDirWS,
+    bool hitSuccessful,
+    inout ScreenSpaceRayHit hit
+)
+{
+    switch (_DebugLightingSubMode)
+    {
+    case DEBUGSCREENSPACETRACING_RAY_DIR_WS:
+        hit.debugOutput =  rayDirWS * 0.5 + 0.5;
+        break;
+    case DEBUGSCREENSPACETRACING_HIT_DEPTH:
+        hit.debugOutput =  frac(hit.linearDepth * 0.1);
+        break;
+    case DEBUGSCREENSPACETRACING_HIT_SUCCESS:
+        hit.debugOutput =  hitSuccessful;
+        break;
+    }
+}
+
+void DebugComputeHiZOutput(
+    int iteration,
+    float3 startPositionSS,
+    float3 rayDirSS,
+    int maxIterations,
+    int maxUsedLevel,
+    int maxMipLevel,
+    int intersectionKind,
+    inout ScreenSpaceRayHit hit
+)
+{
+    switch (_DebugLightingSubMode)
+    {
+    case DEBUGSCREENSPACETRACING_HI_ZPOSITION_NDC:
+        hit.debugOutput =  float3(float2(startPositionSS.xy) * _ScreenSize.zw, 0);
+        break;
+    case DEBUGSCREENSPACETRACING_HI_ZITERATION_COUNT:
+        hit.debugOutput =  float(iteration) / float(maxIterations);
+        break;
+    case DEBUGSCREENSPACETRACING_HI_ZRAY_DIR_NDC:
+        hit.debugOutput =  float3(rayDirSS.xy * 0.5 + 0.5, frac(0.1 / rayDirSS.z));
+        break;
+    case DEBUGSCREENSPACETRACING_HI_ZMAX_USED_MIP_LEVEL:
+        hit.debugOutput =  float(maxUsedLevel) / float(maxMipLevel);
+        break;
+    case DEBUGSCREENSPACETRACING_HI_ZINTERSECTION_KIND:
+        hit.debugOutput =  GetIndexColor(intersectionKind);
+        break;
+    }
+}
+#endif
+#endif
+
+// -------------------------------------------------
+// Algorithm: Proxy raycast
+// -------------------------------------------------
+
+#ifdef SSRTID
+
+#define SSRT_SETTING(name, SSRTID) _SS ## SSRTID ## name
+#define SSRT_FUNC(name, SSRTID) name ## SSRTID
+
+CBUFFER_START(SSRT_FUNC(UnityScreenSpaceRaymarching, SSRTID))
+int SSRT_SETTING(RayMinLevel, SSRTID);
+int SSRT_SETTING(RayMaxLevel, SSRTID);
+int SSRT_SETTING(RayMaxIterations, SSRTID);
+float SSRT_SETTING(RayDepthSuccessBias, SSRTID);
+CBUFFER_END
+
+bool SSRT_FUNC(ScreenSpaceProxyRaycast, SSRTID)(
+    ScreenSpaceProxyRaycastInput input,
+    out ScreenSpaceRayHit hit
+)
+{
+    ZERO_INITIALIZE(ScreenSpaceRayHit, hit);
+
+    float3x3 worldToPS      = WorldToProxySpace(input.proxyData);
+    float3 rayOriginPS      = WorldToProxyPosition(input.proxyData, worldToPS, input.rayOriginWS);
+    float3 rayDirPS         = mul(input.rayDirWS, worldToPS);
+
+    float projectionDistance = 0.0;
+
+    switch(input.proxyData.influenceShapeType)
+    {
+        case ENVSHAPETYPE_SPHERE:
+        case ENVSHAPETYPE_SKY:
+        {
+            projectionDistance = IntersectSphereProxy(input.proxyData, rayDirPS, rayOriginPS);
+            break;
+        }
+        case ENVSHAPETYPE_BOX:
+            projectionDistance = IntersectBoxProxy(input.proxyData, rayDirPS, rayOriginPS);
+            break;
+    }
+
+    float3 hitPositionWS    = input.rayOriginWS + input.rayDirWS * projectionDistance;
+    float4 hitPositionCS    = ComputeClipSpacePosition(hitPositionWS, GetWorldToHClipMatrix());
+    float4 rayOriginCS      = ComputeClipSpacePosition(input.rayOriginWS, GetWorldToHClipMatrix());
+    float2 hitPositionNDC   = ComputeNormalizedDeviceCoordinates(hitPositionWS, GetWorldToHClipMatrix());
+    uint2 hitPositionSS     = uint2(hitPositionNDC *_ScreenSize.xy);
+    float hitLinearDepth    = hitPositionCS.w;
+
+    hit.positionNDC         = hitPositionNDC;
+    hit.positionSS          = hitPositionSS;
+    hit.linearDepth         = hitLinearDepth;
+
+    bool hitSuccessful      = true;
+
+#ifdef DEBUG_DISPLAY
+    DebugComputeCommonOutput(input.rayDirWS, hitSuccessful, hit);
+    
+    if (input.debug)
+    {
+        ScreenSpaceTracingDebug debug;
+        ZERO_INITIALIZE(ScreenSpaceTracingDebug, debug);
+
+        float2 rayOriginNDC         = ComputeNormalizedDeviceCoordinates(input.rayOriginWS, GetWorldToHClipMatrix());
+        uint2 rayOriginSS           = uint2(rayOriginNDC * _ScreenSize.xy);
+
+        debug.tracingModel          = REFRACTIONSSRAYMODEL_PROXY;
+        debug.loopStartPositionSSX  = rayOriginSS.x;
+        debug.loopStartPositionSSY  = rayOriginSS.y;
+        debug.loopStartLinearDepth  = rayOriginCS.w;
+        debug.endHitSuccess         = hitSuccessful;
+        debug.endLinearDepth        = hitLinearDepth;
+        debug.endPositionSSX        = hitPositionSS.x;
+        debug.endPositionSSY        = hitPositionSS.y;
+        debug.proxyShapeType        = input.proxyData.influenceShapeType;
+        debug.projectionDistance    = projectionDistance;
+        
+        _DebugScreenSpaceTracingData[0] = debug;
+    }
+#endif
+
+    return hitSuccessful;
+}
+
+// -------------------------------------------------
+// Algorithm: HiZ raymarching
+// -------------------------------------------------
+
+// Based on Yasin Uludag, 2014. "Hi-Z Screen-Space Cone-Traced Reflections", GPU Pro5: Advanced Rendering Techniques
+
+bool SSRT_FUNC(ScreenSpaceHiZRaymarch, SSRTID)(
+    ScreenSpaceHiZRaymarchInput input,
+    out ScreenSpaceRayHit hit
+)
+{
+    const float2 CROSS_OFFSET = float2(1, 1);
+
+    // Initialize loop
+    ZERO_INITIALIZE(ScreenSpaceRayHit, hit);
+    bool hitSuccessful = true;
+    uint iteration = 0u;
+    int minMipLevel = max(SSRT_SETTING(RayMinLevel, SSRTID), 0);
+    int maxMipLevel = min(SSRT_SETTING(RayMaxLevel, SSRTID), int(_DepthPyramidScale.z));
+    uint2 bufferSize = uint2(_DepthPyramidSize.xy);
+    uint maxIterations = min(input.maxIterations, SSRT_SETTING(RayMaxIterations, SSRTID));
+
+    float3 startPositionSS;
+    float3 raySS;
+    CalculateRaySS(
+        input.rayOriginWS,
+        input.rayDirWS,
+        bufferSize,
+        startPositionSS,
+        raySS
+    );
+
+#ifdef DEBUG_DISPLAY
+    // Initialize debug variables
+    int debugLoopMipMaxUsedLevel = minMipLevel;
+    int debugIterationMipLevel = minMipLevel;
+    uint2 debugIterationCellSize = uint2(0u, 0u);
+    float3 debugIterationPositionSS = float3(0, 0, 0);
+    uint debugIteration = 0u;
+    uint debugIterationIntersectionKind = 0u;
+    float debugIterationLinearDepthBuffer = 0;
+#endif
+
+    int intersectionKind = 0;
+    float raySSLength = length(raySS.xy);
+    raySS /= raySSLength;
+    // Initialize raymarching
+    float2 invRaySS = float2(1, 1) / raySS.xy;
+
+    // Calculate planes to intersect for each cell
+    int2 cellPlanes = sign(raySS.xy);
+    float2 crossOffset = CROSS_OFFSET * cellPlanes;
+    cellPlanes = clamp(cellPlanes, 0, 1);
+
+    int currentLevel = minMipLevel;
+    uint2 cellCount = bufferSize >> currentLevel;
+    uint2 cellSize = uint2(1, 1) << currentLevel;
+
+    float3 positionSS = startPositionSS;
+    float invHiZDepth = 0;
+
+    while (currentLevel >= minMipLevel)
+    {
+        if (iteration >= maxIterations)
+        {
+            hitSuccessful = false;
+            break;
+        }
+
+        cellCount = bufferSize >> currentLevel;
+        cellSize = uint2(1, 1) << currentLevel;
+
+
+#ifdef DEBUG_DISPLAY
+        // Fetch pre iteration debug values
+        if (input.debug && _DebugStep >= iteration)
+            debugIterationMipLevel = currentLevel;
+#endif
+
+        // Go down in HiZ levels by default
+        int mipLevelDelta = -1;
+
+        // Sampled as 1/Z so it interpolate properly in screen space.
+        invHiZDepth = LoadInvDepth(positionSS.xy, currentLevel);
+        intersectionKind = HIZINTERSECTIONKIND_NONE;
+
+        if (IsPositionAboveDepth(positionSS.z, invHiZDepth))
+        {
+            float3 candidatePositionSS = IntersectDepthPlane(positionSS, raySS, invHiZDepth);
+
+            intersectionKind = HIZINTERSECTIONKIND_DEPTH;
+
+            const int2 cellId = int2(positionSS.xy) / cellSize;
+            const int2 candidateCellId = int2(candidatePositionSS.xy) / cellSize;
+
+            // If we crossed the current cell
+            if (!CellAreEquals(cellId, candidateCellId))
+            {
+                candidatePositionSS = IntersectCellPlanes(
+                    positionSS,
+                    raySS,
+                    invRaySS,
+                    cellId,
+                    cellSize,
+                    cellPlanes,
+                    crossOffset);
+
+                intersectionKind = HIZINTERSECTIONKIND_CELL;
+
+                // Go up a level to go faster
+                mipLevelDelta = 1;
+            }
+
+            positionSS = candidatePositionSS;
+        }
+
+        currentLevel = min(currentLevel + mipLevelDelta, maxMipLevel);
+        
+#ifdef DEBUG_DISPLAY
+        // Fetch post iteration debug values
+        if (input.debug && _DebugStep >= iteration)
+        {
+            debugLoopMipMaxUsedLevel = max(debugLoopMipMaxUsedLevel, currentLevel);
+            debugIterationPositionSS = positionSS;
+            debugIterationLinearDepthBuffer = 1 / invHiZDepth;
+            debugIteration = iteration;
+            debugIterationIntersectionKind = intersectionKind;
+            debugIterationCellSize = cellSize;
+        }
+#endif
+
+        // Check if we are out of the buffer
+        if (any(int2(positionSS.xy) > int2(bufferSize))
+            || any(positionSS.xy < 0)
+            )
+        {
+            hitSuccessful = false;
+            break;
+        }
+
+        ++iteration;
+    }
+
+    hit.linearDepth = 1 / positionSS.z;
+    hit.positionNDC = float2(positionSS.xy) / float2(bufferSize);
+    hit.positionSS = uint2(positionSS.xy);
+
+    if (hit.linearDepth > (1 / invHiZDepth) + SSRT_SETTING(RayDepthSuccessBias, SSRTID))
+        hitSuccessful = false;
+
+#ifdef DEBUG_DISPLAY
+    DebugComputeCommonOutput(input.rayDirWS, hitSuccessful, hit);
+    DebugComputeHiZOutput(
+        iteration,
+        startPositionSS,
+        raySS,
+        SSRT_SETTING(RayMaxIterations, SSRTID),
+        debugLoopMipMaxUsedLevel,
+        maxMipLevel,
+        intersectionKind,
+        hit
+    );
+
+    if (input.debug)
+    {
+        // Build debug structure
+        ScreenSpaceTracingDebug debug;
+        ZERO_INITIALIZE(ScreenSpaceTracingDebug, debug);
+
+        debug.tracingModel                  = REFRACTIONSSRAYMODEL_HI_Z;
+        debug.loopStartPositionSSX          = uint(startPositionSS.x);
+        debug.loopStartPositionSSY          = uint(startPositionSS.y);
+        debug.loopStartLinearDepth          = 1 / startPositionSS.z;
+        debug.loopRayDirectionSS            = raySS;
+        debug.loopMipLevelMax               = debugLoopMipMaxUsedLevel;
+        debug.loopIterationMax              = iteration;
+        debug.iterationPositionSS           = debugIterationPositionSS;
+        debug.iterationMipLevel             = debugIterationMipLevel;
+        debug.iteration                     = debugIteration;
+        debug.iterationLinearDepthBuffer    = debugIterationLinearDepthBuffer;
+        debug.iterationIntersectionKind     = debugIterationIntersectionKind;
+        debug.iterationCellSizeW            = debugIterationCellSize.x;
+        debug.iterationCellSizeH            = debugIterationCellSize.y;
+        debug.endHitSuccess                 = hitSuccessful;
+        debug.endLinearDepth                = hit.linearDepth;
+        debug.endPositionSSX                = hit.positionSS.x;
+        debug.endPositionSSY                = hit.positionSS.y;
+
+        _DebugScreenSpaceTracingData[0] = debug;
+    }
+#endif
+
+    return hitSuccessful;
+}
+
+#undef SSRT_SETTING
+#undef SSRT_FUNC
+#endif

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

+fileFormatVersion: 2
+guid: aee64cd8304a9fa46a29f5533aa77b29
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Plane_HiZ.mat.meta

+fileFormatVersion: 2
+guid: a674d63420e0d5c4091de0387c17c3b3
+timeCreated: 1509349727
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Plane_Proxy.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Lit_Refraction_Plane_Proxy
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
+    _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _REFRACTION_SSRAY_PROXY _SURFACE_TYPE_TRANSPARENT
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - DistortionVectors
+  - TransparentBackfaceDebugDisplay
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - MOTIONVECTORS
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMapIridescence:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatCoverage: 1
+    - _CoatIOR: 0.5
+    - _CoatMask: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 1
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 1
+    - _DistortionDepthTest: 0
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 10
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableMotionVectorForVertexAnimation: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableWind: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.099999994
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 1
+    - _HeightMax: 5
+    - _HeightMin: -5
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 10
+    - _HeightTessAmplitude: 10
+    - _HeightTessCenter: 0.5
+    - _IOR: 1.5
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PreRefractionPass: 0
+    - _RefractionMode: 1
+    - _RefractionModel: 1
+    - _RefractionSSRayModel: 1
+    - _SSSAndTransmissionType: 0
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 1
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _StencilRefMV: 128
+    - _StencilWriteMask: 7
+    - _StencilWriteMaskMV: 128
+    - _Stiffness: 1
+    - _SubsurfaceMask: 1
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SupportDBuffer: 1
+    - _SurfaceType: 1
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThicknessIridescence: 1
+    - _ThicknessMultiplier: 2
+    - _TransmissionEnable: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _ZTestDepthEqualForOpaque: 4
+    - _ZTestGBuffer: 4
+    - _ZTestMode: 8
+    - _ZTestModeDistortion: 8
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _ThicknessRemapIridescence: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Sphere_HiZ.mat.meta

+fileFormatVersion: 2
+guid: 673e03d5b17ddb8488587a4d090626c0
+timeCreated: 1509349727
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction/Lit_Refraction_Sphere_Proxy.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Lit_Refraction_Sphere_Proxy
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
+    _NORMALMAP_TANGENT_SPACE _REFRACTION_SPHERE _REFRACTION_SSRAY_PROXY _SURFACE_TYPE_TRANSPARENT
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - DistortionVectors
+  - TransparentBackfaceDebugDisplay
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - MOTIONVECTORS
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMapIridescence:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatCoverage: 1
+    - _CoatIOR: 0.5
+    - _CoatMask: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 1
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 1
+    - _DistortionDepthTest: 0
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 10
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableMotionVectorForVertexAnimation: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableWind: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.099999994
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 1
+    - _HeightMax: 5
+    - _HeightMin: -5
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 10
+    - _HeightTessAmplitude: 10
+    - _HeightTessCenter: 0.5
+    - _IOR: 1.5
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PreRefractionPass: 0
+    - _RefractionMode: 2
+    - _RefractionModel: 2
+    - _RefractionSSRayModel: 1
+    - _SSSAndTransmissionType: 0
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 1
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _StencilRefMV: 128
+    - _StencilWriteMask: 7
+    - _StencilWriteMaskMV: 128
+    - _Stiffness: 1
+    - _SubsurfaceMask: 1
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SupportDBuffer: 1
+    - _SurfaceType: 1
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThicknessIridescence: 1
+    - _ThicknessMultiplier: 2
+    - _TransmissionEnable: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _ZTestDepthEqualForOpaque: 4
+    - _ZTestGBuffer: 4
+    - _ZTestMode: 8
+    - _ZTestModeDistortion: 8
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
+    - _Color: {r: 1, g: 1, b: 1, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _ThicknessRemapIridescence: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}