Merge remote-tracking branch 'refs/remotes/origin/master' into shadows-biasing

ScriptableRenderPipeline/Core/CoreRP/Camera/FreeCamera.cs

         public float m_LookSpeedController = 120f;
         public float m_LookSpeedMouse = 10.0f;
         public float m_MoveSpeed = 10.0f;
+        public float m_MoveSpeedIncrement = 2.5f;
         public float m_Turbo = 10.0f;
 
         private static string kMouseX = "Mouse X";
         private static string kVertical = "Vertical";
         private static string kHorizontal = "Horizontal";
 
+        private static string kYAxis = "YAxis";
+        private static string kSpeedAxis = "Speed Axis";
+
         void OnEnable()
         {
             RegisterInputs();
         {
 #if UNITY_EDITOR
-            List <InputManagerEntry> inputEntries = new List<InputManagerEntry>();
+            List<InputManagerEntry> inputEntries = new List<InputManagerEntry>();
+            inputEntries.Add(new InputManagerEntry { name = kYAxis, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "page up", altBtnPositive = "joystick button 5", btnNegative = "page down", altBtnNegative = "joystick button 4", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f });
+
+            inputEntries.Add(new InputManagerEntry { name = kSpeedAxis, kind = InputManagerEntry.Kind.KeyOrButton, btnPositive = "home", btnNegative = "end", gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f });
+            inputEntries.Add(new InputManagerEntry { name = kSpeedAxis, kind = InputManagerEntry.Kind.Axis, axis = InputManagerEntry.Axis.Seventh, gravity = 1000.0f, deadZone = 0.001f, sensitivity = 1000.0f });
+
             InputRegistering.RegisterInputs(inputEntries);
 #endif
         }
             // If the debug menu is running, we don't want to conflict with its inputs.
-            if(DebugMenuManager.instance.menuUI.isEnabled)
+            if (DebugMenuManager.instance.menuUI.isEnabled)
                 return;
 
             float inputRotateAxisX = 0.0f;
             inputRotateAxisX += (Input.GetAxis(kRightStickX) * m_LookSpeedController * Time.deltaTime);
             inputRotateAxisY += (Input.GetAxis(kRightStickY) * m_LookSpeedController * Time.deltaTime);
 
+            float inputChangeSpeed = Input.GetAxis(kSpeedAxis);
+            if (inputChangeSpeed != 0.0f)
+            {
+                m_MoveSpeed += inputChangeSpeed * m_MoveSpeedIncrement;
+                if (m_MoveSpeed < m_MoveSpeedIncrement) m_MoveSpeed = m_MoveSpeedIncrement;
+            }
+
+            float inputYAxis = Input.GetAxis(kYAxis);
-            bool moved = inputRotateAxisX != 0.0f || inputRotateAxisY != 0.0f || inputVertical != 0.0f || inputHorizontal != 0.0f;
+            bool moved = inputRotateAxisX != 0.0f || inputRotateAxisY != 0.0f || inputVertical != 0.0f || inputHorizontal != 0.0f || inputYAxis != 0.0f;
             if (moved)
             {
                 float rotationX = transform.localEulerAngles.x;
                     moveSpeed *= Input.GetAxis("Fire1") > 0.0f ? m_Turbo : 1.0f;
                 transform.position += transform.forward * moveSpeed * inputVertical;
                 transform.position += transform.right * moveSpeed * inputHorizontal;
+                transform.position += Vector3.up * moveSpeed * inputYAxis;
             }
         }
     }

ScriptableRenderPipeline/Core/CoreRP/CoreUtils.cs

             baseDesc.depthBufferBits = depthBufferBits;
             baseDesc.colorFormat = format;
             baseDesc.sRGB = (readWrite != RenderTextureReadWrite.Linear);
-            // TODO: Explicit MSAA support will come in later
+
+            // Depth-only needs bindMS in order to use with CopyTexture
+            if ((format == RenderTextureFormat.Depth) && (baseDesc.msaaSamples > 1))
+                baseDesc.bindMS = true;
 
             return new RenderTexture(baseDesc);
         }
-            RenderTextureReadWrite readWrite = RenderTextureReadWrite.Default, int msaaSamples = 1, bool enableRandomWrite = false)
+            RenderTextureReadWrite readWrite = RenderTextureReadWrite.Default, int msaaSamplesOverride = 0, bool enableRandomWrite = false)
-            UpdateRenderTextureDescriptor(ref baseDesc, depthBufferBits, format, readWrite, msaaSamples, enableRandomWrite);
+            if (msaaSamplesOverride > 0)
+                UpdateRenderTextureDescriptor(ref baseDesc, depthBufferBits, format, readWrite, msaaSamplesOverride, enableRandomWrite);
+            else
+                UpdateRenderTextureDescriptor(ref baseDesc, depthBufferBits, format, readWrite, baseDesc.msaaSamples, enableRandomWrite);
+
 
             cmd.GetTemporaryRT(nameID, baseDesc, filter);
         }
             baseDesc.depthBufferBits = depthBufferBits;
             baseDesc.colorFormat = format;
             baseDesc.sRGB = (readWrite != RenderTextureReadWrite.Linear);
+
+            Debug.Assert(!enableRandomWrite || (msaaSamples == 1));
             baseDesc.msaaSamples = msaaSamples;
             baseDesc.enableRandomWrite = enableRandomWrite;
         }

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 
 
 #ifndef INTRINSIC_WAVEREADFIRSTLANE
-    // Warning: for correctness, the argument must have the same value across the wave!
+    // Warning: for correctness, the argument's value must be the same across all lanes of the wave.
     TEMPLATE_1_REAL(WaveReadFirstLane, scalarValue, return scalarValue)
     TEMPLATE_1_INT(WaveReadFirstLane, scalarValue, return scalarValue)
 #endif
     return faceID;
 }
 #endif // INTRINSIC_CUBEMAP_FACE_ID
-
-// Intrinsic isnan can't be used because it require /Gic to be enabled on fxc that we can't do. So use IsNAN instead
+
+// Intrinsic isnan can't be used because it require /Gic to be enabled on fxc that we can't do. So use IsNAN instead
 bool IsNAN(float n)
 {
     return (n < 0.0 || n > 0.0 || n == 0.0) ? false : true;
 bool IsNAN(float4 v)
 {
     return (IsNAN(v.x) || IsNAN(v.y) || IsNAN(v.z) || IsNAN(v.w)) ? true : false;
-}
+}
 
 // ----------------------------------------------------------------------------
 // Common math functions
 // 'z' is the view-space Z position (linear depth).
 // saturate() the output of the function to clamp them to the [0, 1] range.
 // encodingParams = { n, log2(f/n), 1/n, 1/log2(f/n) }
+// TODO: plot and modify the distribution to be a little more linear.
 float EncodeLogarithmicDepth(float z, float4 encodingParams)
 {
     return log2(max(0, z * encodingParams.z)) * encodingParams.w;
 // saturate(d) to clamp the output of the function to the [n, f] range.
 // encodingParams = { n, log2(f/n), 1/n, 1/log2(f/n) }
+// TODO: plot and modify the distribution to be a little more linear.
 float DecodeLogarithmicDepth(float d, float4 encodingParams)
 {
     return encodingParams.x * exp2(d * encodingParams.y);
                                        0, 1, 0, 0,
                                        0, 0, 1, 0,
                                        0, 0, 0, 1};
-
+
 // Use case examples:
 // (position = positionCS) => (clipSpaceTransform = use default)
 // (position = positionVS) => (clipSpaceTransform = UNITY_MATRIX_P)
 #endif
 
     return positionCS;
-}
+}
 
 // Use case examples:
 // (position = positionCS) => (clipSpaceTransform = use default)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/VolumeRendering.hlsl

 real HenyeyGreensteinPhasePartVarying(real asymmetry, real cosTheta)
 {
     real g = asymmetry;
+    real f = rsqrt(1 + g * g - 2 * g * cosTheta); // x^(-1/2)
-    return pow(abs(1 + g * g - 2 * g * cosTheta), -1.5);
+    return f * f * f; // x^(-3/2)
 }
 
 real HenyeyGreensteinPhaseFunction(real asymmetry, real cosTheta)
 real CornetteShanksPhasePartVarying(real asymmetry, real cosTheta)
 {
     real g = asymmetry;
+    real f = rsqrt(1 + g * g - 2 * g * cosTheta); // x^(-1/2)
+    real h = (1 + cosTheta * cosTheta);
-    return (1 + cosTheta * cosTheta) * pow(abs(1 + g * g - 2 * g * cosTheta), -1.5);
+    return h * (f * f * f); // h * f^(-3/2)
 }
 
 // A better approximation of the Mie phase function.
     real x = 1 - exp(-extinction * intervalLength);
 
     // Avoid division by 0.
-    real rcpExt = extinction != 0 ? rcp(extinction) : 0;
+    real rcpExt = (extinction != 0) ? rcp(extinction) : 0;
 
     weight = x * rcpExt;
     offset = -log(1 - rndVal * x) * rcpExt;

ScriptableRenderPipeline/Core/package.json

 {
     "name": "com.unity.render-pipelines.core",
     "description": "Core library for Unity render pipelines.",
-    "version": "0.1.26",
+    "version": "0.1.27",
-        "com.unity.postprocessing": "0.1.7"
+        "com.unity.postprocessing": "0.1.8"
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

                 tempDesc = new RenderTextureDescriptor(camera.pixelWidth, camera.pixelHeight);
             }
 
-            tempDesc.msaaSamples = 1; // will be updated later, deferred will always set to 1
+            if (frameSettings.enableMSAA)
+            {
+                // this is already pre-validated to be a valid sample count by InitializeFrameSettings
+                var sampleCount = QualitySettings.antiAliasing;
+                tempDesc.msaaSamples = sampleCount;
+            }
+            else
+            {
+                tempDesc.msaaSamples = 1;
+            }
             tempDesc.depthBufferBits = 0;
             tempDesc.autoGenerateMips = false;
             tempDesc.useMipMap = false;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs

             }
 
             EditorGUILayout.PropertyField(p.influenceSphereRadius, CoreEditorUtils.GetContent("Radius"));
+            EditorGUILayout.PropertyField(p.boxOffset, CoreEditorUtils.GetContent("Sphere Offset|The center of the sphere in which the reflections will be applied to objects. The value is relative to the position of the Game Object."));
+
             EditorGUILayout.PropertyField(p.boxProjection, CoreEditorUtils.GetContent("Sphere Projection|Sphere projection causes reflections to appear to change based on the object's position within the probe's sphere, while still using a single probe as the source of the reflection. This works well for reflections on objects that are moving through enclosed spaces such as corridors and rooms. Setting sphere projection to False and the cubemap reflection will be treated as coming from infinitely far away. Note that this feature can be globally disabled from Graphics Settings -> Tier Settings"));
         }
         #endregion

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

         {
             var objs = new List<Object>();
             for (var i = 0; i < serializedObject.targetObjects.Length; i++)
-                objs.Add(((PlanarReflectionProbe)serializedObject.targetObjects[i]).proxyVolumeReference);
-            reflectionProxyVolume = new SerializedReflectionProxyVolumeComponent(new SerializedObject(objs.ToArray()));
+            {
+                var p = ((PlanarReflectionProbe)serializedObject.targetObjects[i]).proxyVolumeReference;
+                if (p != null)
+                    objs.Add(p);
+            }
+
+            reflectionProxyVolume = objs.Count > 0
+                    ? new SerializedReflectionProxyVolumeComponent(new SerializedObject(objs.ToArray()))
+                    : null;
         }
 
         public void Update()
-            var updateProxyVolume = serializedObject.targetObjects.Length != reflectionProxyVolume.serializedObject.targetObjects.Length;
-            if (!updateProxyVolume)
+            var updateProxyVolume = reflectionProxyVolume != null
+                && serializedObject.targetObjects.Length != reflectionProxyVolume.serializedObject.targetObjects.Length;
+            if (!updateProxyVolume && reflectionProxyVolume != null)
             {
                 var proxyVolumeTargets = reflectionProxyVolume.serializedObject.targetObjects;
                 for (var i = 0; i < serializedObject.targetObjects.Length; i++)
         public void Apply()
         {
             serializedObject.ApplyModifiedProperties();
-            reflectionProxyVolume.Apply();
+            if (reflectionProxyVolume != null)
+                reflectionProxyVolume.Apply();
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/Volume/ProxyVolumeUI.cs

         public override void Update()
         {
             base.Update();
-            SetIsSectionExpanded_Shape((ShapeType)data.shapeType.intValue);
+            if (data != null)
+                SetIsSectionExpanded_Shape((ShapeType)data.shapeType.intValue);
         }
 
         void SetIsSectionExpanded_Shape(ShapeType shape)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/Volume/ReflectionProxyVolumeComponentUI.cs

 
         public override void Reset(SerializedReflectionProxyVolumeComponent data, UnityAction repaint)
         {
-            proxyVolume.Reset(data.proxyVolume, repaint);
+            if (data != null)
+                proxyVolume.Reset(data.proxyVolume, repaint);
             base.Reset(data, repaint);
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/LayeredLit/LayeredLitUI.cs

                 string uvBase = string.Format("{0}{1}", kUVBase, i);
                 string uvDetail = string.Format("{0}{1}", kUVDetail, i);
 
-                if (((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV2) ||
-                    ((UVBaseMapping)material.GetFloat(uvBase) == UVBaseMapping.UV2))
+                if (((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV2) || ((UVBaseMapping)material.GetFloat(uvBase) == UVBaseMapping.UV2))
-                if (((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV3) ||
-                    ((UVBaseMapping)material.GetFloat(uvBase) == UVBaseMapping.UV3))
+                if (((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV3) || ((UVBaseMapping)material.GetFloat(uvBase) == UVBaseMapping.UV3))
                 {
                     needUV3 = true;
                     break; // If we find it UV3 let's early out
             // NB RenderQueue editor is not shown on purpose: we want to override it based on blend mode
             EditorGUI.indentLevel++;
             m_MaterialEditor.EnableInstancingField();
+            m_MaterialEditor.ShaderProperty(enableSpecularOcclusion, Styles.enableSpecularOcclusionText);
             EditorGUI.indentLevel--;
 
             if (layerChanged || optionsChanged)

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

             public static GUIContent specularOcclusionWarning = new GUIContent("Require a cosine weighted bent normal and ambient occlusion maps");
 
             // Emissive
-            public static string lightingText = "Lighting Inputs";
+            public static string emissiveLabelText = "Emissive Inputs";
             public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
             public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
             public static GUIContent albedoAffectEmissiveText = new GUIContent("Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.");
         protected void DoEmissiveGUI(Material material)
         {
             EditorGUILayout.Space();
-            EditorGUILayout.LabelField(Styles.lightingText, EditorStyles.boldLabel);
+            EditorGUILayout.LabelField(Styles.emissiveLabelText, EditorStyles.boldLabel);
-            m_MaterialEditor.ShaderProperty(enableSpecularOcclusion, Styles.enableSpecularOcclusionText);
             // TODO: display warning if we don't have bent normal (either OS or TS) and ambient occlusion
             //if (enableSpecularOcclusion.floatValue > 0.0f)
             {
             DoLayerGUI(material, 0);
             DoEmissiveGUI(material);
             // The parent Base.ShaderPropertiesGUI will call DoEmissionArea
+        }
+
+        protected override void MaterialPropertiesAdvanceGUI(Material material)
+        {
+            m_MaterialEditor.ShaderProperty(enableSpecularOcclusion, Styles.enableSpecularOcclusionText);
         }
 
         protected override bool ShouldEmissionBeEnabled(Material mat)
             CoreUtils.SetKeyword(material, "_THICKNESSMAP", material.GetTexture(kThicknessMap));
             CoreUtils.SetKeyword(material, "_SPECULARCOLORMAP", material.GetTexture(kSpecularColorMap));
 
-            bool needUV2 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV2 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;
-            bool needUV3 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV3 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0;
+            bool needUV2 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV2 || (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV2;
+            bool needUV3 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV3 || (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV3;
 
             if (needUV3)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Unlit/BaseUnlitUI.cs

         protected abstract void FindMaterialProperties(MaterialProperty[] props);
         protected abstract void SetupMaterialKeywordsAndPassInternal(Material material);
         protected abstract void MaterialPropertiesGUI(Material material);
+        protected abstract void MaterialPropertiesAdvanceGUI(Material material);
         protected abstract void VertexAnimationPropertiesGUI();
         // This function will say if emissive is used or not regarding enlighten/PVR
         protected abstract bool ShouldEmissionBeEnabled(Material material);
                 // NB RenderQueue editor is not shown on purpose: we want to override it based on blend mode
                 EditorGUI.indentLevel++;
                 m_MaterialEditor.EnableInstancingField();
+                MaterialPropertiesAdvanceGUI(material);
                 EditorGUI.indentLevel--;
             }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Unlit/UnlitUI.cs

             }
         }
 
+        protected override void MaterialPropertiesAdvanceGUI(Material material)
+        {
+        }
+
         protected override void VertexAnimationPropertiesGUI()
         {
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

         // Detect when windows size is changing
         int m_CurrentWidth;
         int m_CurrentHeight;
+        int m_CurrentMSAASampleCount;
 
         // Use to detect frame changes
         int m_FrameCount;
                 if (m_CameraStencilBufferCopy != null)
                     m_CameraStencilBufferCopy.Release();
 
+                // TODO: This might fail allocation with MSAA
                 m_CameraStencilBufferCopy = CoreUtils.CreateRenderTexture(hdCamera.renderTextureDesc, 0, RenderTextureFormat.R8, RenderTextureReadWrite.Linear); // DXGI_FORMAT_R8_UINT is not supported by Unity
                 m_CameraStencilBufferCopy.filterMode = FilterMode.Point;
                 m_CameraStencilBufferCopy.Create();
             var desc = hdCamera.renderTextureDesc;
             var texWidth = desc.width;
             var texHeight = desc.height;
+            var sampleCount = desc.msaaSamples;
-            bool resolutionChanged = (texWidth != m_CurrentWidth) || (texHeight != m_CurrentHeight);
+            bool resolutionChanged = (texWidth != m_CurrentWidth) || 
+                                     (texHeight != m_CurrentHeight) || 
+                                     (sampleCount != m_CurrentMSAASampleCount);
-                m_SSSBufferManager.Resize(hdCamera);
+
+                if (m_FrameSettings.enableSubsurfaceScattering)
+                {
+                    // TODO: The R8 target doesn't allocate with MSAA support...
+                    m_SSSBufferManager.Resize(hdCamera);
+                }
             }
 
             if (resolutionChanged || m_LightLoop.NeedResize())
             // update recorded window resolution
             m_CurrentWidth = texWidth;
             m_CurrentHeight = texHeight;
+            m_CurrentMSAASampleCount = sampleCount;
         }
 
         public void PushGlobalParams(HDCamera hdCamera, CommandBuffer cmd, DiffusionProfileSettings sssParameters)
                         using (new ProfilingSample(cmd, "Deferred directional shadows", CustomSamplerId.RenderDeferredDirectionalShadow.GetSampler()))
                         {
                             cmd.ReleaseTemporaryRT(m_DeferredShadowBuffer);
+
+                            // TODO: For MSAA, we are overriding to 1x, but we'll need to add a Draw path in order to support MSAA properly
                             CoreUtils.CreateCmdTemporaryRT(cmd, m_DeferredShadowBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1, true);
                             m_LightLoop.RenderDeferredDirectionalShadow(hdCamera, m_DeferredShadowBufferRT, GetDepthTexture(), cmd);
                             PushFullScreenDebugTexture(cmd, m_DeferredShadowBuffer, hdCamera, FullScreenDebugMode.DeferredShadows);
                 if (settings.IsEnabledAndSupported(null))
                 {
                     cmd.ReleaseTemporaryRT(HDShaderIDs._AmbientOcclusionTexture);
-                    CoreUtils.CreateCmdTemporaryRT(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera.renderTextureDesc, 0, FilterMode.Bilinear, RenderTextureFormat.R8, RenderTextureReadWrite.Linear, msaaSamples: 1, enableRandomWrite: true);
+                    CoreUtils.CreateCmdTemporaryRT(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera.renderTextureDesc, 0, FilterMode.Bilinear, RenderTextureFormat.R8, RenderTextureReadWrite.Linear, msaaSamplesOverride: 1, enableRandomWrite: true);
                     postProcessLayer.BakeMSVOMap(cmd, camera, HDShaderIDs._AmbientOcclusionTexture, GetDepthTexture(), true);
                     cmd.SetGlobalVector(HDShaderIDs._AmbientOcclusionParam, new Vector4(settings.color.value.r, settings.color.value.g, settings.color.value.b, settings.directLightingStrength.value));
                     PushFullScreenDebugTexture(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera, FullScreenDebugMode.SSAO);
 
                     cmd.ReleaseTemporaryRT(m_CameraColorBuffer);
                     cmd.ReleaseTemporaryRT(m_CameraSssDiffuseLightingBuffer);
-                    CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraColorBuffer,              hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf,       RenderTextureReadWrite.Linear, 1, true); // Enable UAV
-                    CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraSssDiffuseLightingBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
-
+                    if (m_FrameSettings.enableMSAA)
+                    {
+                        CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraColorBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
+                        CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraSssDiffuseLightingBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear);
+                    }
+                    else
+                    {
+                        CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraColorBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                        CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraSssDiffuseLightingBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+                    }
 
                     // Color and depth pyramids
                     m_GaussianPyramidColorBufferDesc = BuildPyramidDescriptor(hdCamera, PyramidType.Color, m_FrameSettings.enableStereo);
             desc.depthBufferBits = 0;
             desc.useMipMap = true;
             desc.autoGenerateMips = false;
+
+            desc.msaaSamples = 1; // These are approximation textures, they don't need MSAA
 
             var pyramidSize = CalculatePyramidSize((int)hdCamera.screenSize.x, (int)hdCamera.screenSize.y);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.asset

       cubeCookieTexArraySize: 16
       reflectionProbeCacheSize: 128
       planarReflectionProbeCacheSize: 128
-      reflectionCubemapSize: 512
-      planarReflectionTextureSize: 512
+      reflectionCubemapSize: 128
+      planarReflectionTextureSize: 128
       reflectionCacheCompressed: 0
       planarReflectionCacheCompressed: 0
       maxPlanarReflectionProbes: 128

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

         static ComputeBuffer s_PerVoxelOffset = null;
         static ComputeBuffer s_PerTileLogBaseTweak = null;
         static ComputeBuffer s_GlobalLightListAtomic = null;
+
+        public enum ClusterPrepassSource : int
+        {
+            None = 0,
+            BigTile = 1,
+            Count = 2,
+        }
+
+        public enum ClusterDepthSource : int
+        {
+            NoDepth = 0,
+            Depth = 1,
+            MSAA_Depth = 2,
+            Count = 3,
+        }
+
+        static string[,] s_ClusterKernelNames = new string[(int)ClusterPrepassSource.Count, (int)ClusterDepthSource.Count]
+        {
+            { "TileLightListGen_NoDepthRT", "TileLightListGen_DepthRT", "TileLightListGen_DepthRT_MSAA" },
+            { "TileLightListGen_NoDepthRT_SrcBigTile", "TileLightListGen_DepthRT_SrcBigTile", "TileLightListGen_DepthRT_MSAA_SrcBigTile" }
+        };
         // clustered light list specific buffers and data end
 
         static int[] s_TempIntArray = new int[2]; // Used to avoid GC stress when calling SetComputeIntParams
 
             // Cluster
             {
-                var kernelName = m_FrameSettings.lightLoopSettings.enableBigTilePrepass ? (k_UseDepthBuffer ? "TileLightListGen_DepthRT_SrcBigTile" : "TileLightListGen_NoDepthRT_SrcBigTile") : (k_UseDepthBuffer ? "TileLightListGen_DepthRT" : "TileLightListGen_NoDepthRT");
+                var clustPrepassSourceIdx = m_FrameSettings.lightLoopSettings.enableBigTilePrepass ? ClusterPrepassSource.BigTile : ClusterPrepassSource.None;
+                var clustDepthSourceIdx = ClusterDepthSource.NoDepth;
+                if (k_UseDepthBuffer)
+                {
+                    if (m_FrameSettings.enableMSAA)
+                        clustDepthSourceIdx = ClusterDepthSource.MSAA_Depth;
+                    else
+                        clustDepthSourceIdx = ClusterDepthSource.Depth;
+                }
+                var kernelName = s_ClusterKernelNames[(int)clustPrepassSourceIdx, (int)clustDepthSourceIdx];
+
                 s_GenListPerVoxelKernel = buildPerVoxelLightListShader.FindKernel(kernelName);
             }
 
             if (probe.planarReflectionProbe != null)
             {
                 envIndex = m_ReflectionPlanarProbeCache.FetchSlice(cmd, probe.texture);
-                envIndex = envIndex << 1 | (int)EnvCacheType.Texture2D;
+                envIndex = (envIndex << 1) | (int)EnvCacheType.Texture2D;
 
                 float nearClipPlane, farClipPlane, aspect, fov;
                 Color backgroundColor;
                         }
                         else
                         {
-                            probeIndex = probeIndex - cullResults.visibleReflectionProbes.Count;
-                            var probe = reflectionProbeCullResults.visiblePlanarReflectionProbes[probeIndex];
+                            var planarProbeIndex = probeIndex - cullResults.visibleReflectionProbes.Count;
+                            var probe = reflectionProbeCullResults.visiblePlanarReflectionProbes[planarProbeIndex];
 
                             // probe.texture can be null when we are adding a reflection probe in the editor
                             if (probe.texture == null || envLightCount >= k_MaxEnvLightsOnScreen)
 
                             var logVolume = CalculateProbeLogVolume(probe.bounds);
 
-                            sortKeys[sortCount++] = PackProbeKey(logVolume, lightVolumeType, 1u, probeIndex); // Sort by volume
+                            sortKeys[sortCount++] = PackProbeKey(logVolume, lightVolumeType, 1u, planarProbeIndex); // Sort by volume
                         }
                     }
 

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

 #define SINGLE_PASS_CONTEXT_SAMPLE_SKY 1
 
 #ifdef DEBUG_DISPLAY
-float4 ApplyDebugProjectionVolume(float4 color, float3 texCoord, float scale)
+float4 ApplyDebugProjectionVolume(float4 color, float3 radiusToProxy, float scale)
-    float l = length(texCoord);
+    float l = length(radiusToProxy);
     l = pow(l / (1 + l), scale);
     return float4(l.xxx * 0.7 + color.rgb * 0.3, color.a);
 }
             float4 color = SAMPLE_TEXTURE2D_ARRAY_LOD(_Env2DTextures, s_trilinear_clamp_sampler, ndc.xy, index, 0);
             color.a = any(ndc.xyz < 0) || any(ndc.xyz > 1) ? 0 : 1;
             
-#ifdef DEBUG_DISPLAY
-            if (_DebugLightingMode == DEBUGLIGHTINGMODE_ENVIRONMENT_PROXY_VOLUME)
-                return ApplyDebugProjectionVolume(color, texCoord, _DebugEnvironmentProxyDepthScale);
-#endif
             return color;
         }
         else if (cacheType == ENVCACHETYPE_CUBEMAP)

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

             // Deferred opaque are always using Fptl. Forward opaque can use Fptl or Cluster, transparent use cluster.
             // When MSAA is enabled we disable Fptl as it become expensive compare to cluster
             // In HD, MSAA is only supported for forward only rendering, no MSAA in deferred mode (for code complexity reasons)
-            aggregate.enableFptlForForwardOpaque = aggregate.enableFptlForForwardOpaque && aggregateFrameSettings.enableMSAA;
+            aggregate.enableFptlForForwardOpaque = aggregate.enableFptlForForwardOpaque && !aggregateFrameSettings.enableMSAA;
             // If Deferred, enable Fptl. If we are forward renderer only and not using Fptl for forward opaque, disable Fptl
             aggregate.isFptlEnabled = !aggregateFrameSettings.enableForwardRenderingOnly || aggregate.enableFptlForForwardOpaque;
         }

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

         [SerializeField]
         Texture m_BakedTexture;
         [SerializeField]
-        RenderTexture m_RealtimeTexture;
-        [SerializeField]
         FrameSettings m_FrameSettings;
         [SerializeField]
         float m_CaptureNearPlane = 1;
         [SerializeField]
         [Range(0, 180)]
         float m_FieldOfViewOverride = 90;
-        
+
+        RenderTexture m_RealtimeTexture;
+
         public bool overrideFieldOfView { get { return m_OverrideFieldOfView; } }
         public float fieldOfViewOverride { get { return m_FieldOfViewOverride; } }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/Resources/VolumetricLighting.compute

 #pragma kernel VolumetricLightingClustered       VolumetricLighting=VolumetricLightingClustered       ENABLE_REPROJECTION=0 LIGHTLOOP_TILE_PASS   USE_CLUSTERED_LIGHTLIST
 #pragma kernel VolumetricLightingClusteredReproj VolumetricLighting=VolumetricLightingClusteredReproj ENABLE_REPROJECTION=1 LIGHTLOOP_TILE_PASS   USE_CLUSTERED_LIGHTLIST
 
-// #pragma debug
-
-#define DEBUG_REPROJECTION 0
+// #pragma enable_d3d11_debug_symbols
 
 #include "../../../ShaderPass/ShaderPass.cs.hlsl"
 #define SHADERPASS SHADERPASS_VOLUMETRIC_LIGHTING
     #define VBUFFER_SLICE_COUNT 256
 #endif
 
+#define SUPPORT_ASYMMETRY 1 // Support asymmetric phase functions
+
 #define GROUP_SIZE_1D 16
 #define GROUP_SIZE_2D (GROUP_SIZE_1D * GROUP_SIZE_1D)
 
 #include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
 #include "CoreRP/ShaderLibrary/SpaceFillingCurves.hlsl"
 
+#include "../../../ShaderVariables.hlsl"
-#include "../../../ShaderVariables.hlsl"
+#include "../VBuffer.hlsl"
-#include "../../../Lighting/Lighting.hlsl" // Includes Material.hlsl
-#include "../../../Lighting/LightEvaluation.hlsl"
-#include "../../../Lighting/VBuffer.hlsl"
+#include "../../Lighting.hlsl" // Includes Material.hlsl
+#include "../../LightEvaluation.hlsl"
 
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs
 // Implementation
 //--------------------------------------------------------------------------------------------------
 
-#define HG 0
-
-struct Ray
+struct DualRay
-    float3 directionWS; // Normalized, stratified
-    float  ratioLenToZ; // 1 / ViewSpaceZ
-    float3 centerDirWS; // Not normalized, centered
+    float3 strataDirWS;       // Normalized, tile-stratified
+    float3 centerDirWS;       // Normalized, tile-centered
+    float  strataDirInvViewZ; // 1 / ViewSpace(strataDirWS).z
+    float  twoDirRatioViewZ;  // ViewSpace(strataDirWS).z / ViewSpace(centerDirWS).z
-float3 GetPointAtDistance(Ray ray, float t)
+// Returns a point along the stratified direction.
+float3 GetPointAtDistance(DualRay ray, float t)
-    return ray.originWS + t * ray.directionWS;
+    return ray.originWS + t * ray.strataDirWS;
-float3 GetCenterAtDistance(Ray ray, float t)
+// Returns a point along the centered direction. It has a special property:
+// ViewSpace(GetPointAtDistance(ray, t)).z = ViewSpace(GetCenterAtDistance(ray, t)).z,
+// e.i. both points computed from the same value of 't' reside on the same Z-plane in the view space.
+float3 GetCenterAtDistance(DualRay ray, float t)
+    t *= ray.twoDirRatioViewZ; // Perform the Z-coordinate conversion
+struct VoxelLighting
+{
+    float3 radianceComplete;
+    float3 radianceNoPhase;
+};
+
-float3 EvaluateVoxelLighting(LightLoopContext context, uint featureFlags, PositionInputs posInput,
-                             Ray ray, float t0, float t1, float dt, float rndVal, float extinction, float asymmetry
-                         #ifdef LIGHTLOOP_TILE_PASS
-                           , uint clusterIndices[2], float clusterDepths[2])
-                         #else
-                             )
-                         #endif
+VoxelLighting EvaluateVoxelLighting(LightLoopContext context, uint featureFlags, PositionInputs posInput, float3 centerWS,
+                                    DualRay ray, float t0, float t1, float dt, float rndVal, float extinction, float asymmetry
+                                #ifdef LIGHTLOOP_TILE_PASS
+                                    , uint clusterIndices[2], float clusterDepths[2])
+                                #else
+                                    )
+                                #endif
-    float3 voxelRadiance = 0;
+    VoxelLighting lighting;
+    ZERO_INITIALIZE(VoxelLighting, lighting);
 
     BakeLightingData unused; // Unused for now, so define once
 
             EvaluateLight_Directional(context, posInput, light, unused, 0, L,
                                       color, attenuation);
 
-            float cosTheta = dot(L, ray.directionWS);
-        #if HG
-            float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
-        #else
+            // Important:
+            // Ideally, all scattering calculations should use the stratified versions
+            // of the sample position and the ray direction. However, correct reprojection
+            // of asymmetrically scattered lighting (affected by an anisotropic phase
+            // function) is not possible. We work around this issue by reprojecting
+            // lighting not affected by the phase function. This basically removes
+            // the phase function from the temporal integration process. It is a hack.
+            // The downside is that asymmetry no longer benefits from temporal averaging,
+            // and any temporal instability of asymmetry causes causes visible jitter.
+            // In order to stabilize the image, we use the voxel center for all
+            // asymmetry-related calculations.
+            float cosTheta = dot(L, ray.centerDirWS);
-        #endif
-            float intensity = attenuation * (phase * weight);
+            float intensity = attenuation * weight;
-            voxelRadiance += intensity * color;
+            lighting.radianceNoPhase  += intensity * color;
+            lighting.radianceComplete += phase * intensity * color;
         }
     }
 
     do
     {
-        float tMin = max(t0, ray.ratioLenToZ * clusterDepths[cluster]);
+        float tMin = max(t0, ray.strataDirInvViewZ * clusterDepths[cluster]);
-            tMax = min(t1, ray.ratioLenToZ * clusterDepths[1]);
+            tMax = min(t1, ray.strataDirInvViewZ * clusterDepths[1]);
         }
 #else
         float tMin = t0;
                         float3 coneAxisX = lenMul * light.right;
                         float3 coneAxisY = lenMul * light.up;
 
-                        sampleLight = IntersectRayCone(ray.originWS, ray.directionWS,
+                        sampleLight = IntersectRayCone(ray.originWS, ray.strataDirWS,
                                                        light.positionWS, light.forward,
                                                        coneAxisX, coneAxisY,
                                                        tMin, tMax, tEntr, tExit);
 
                         float t, distSq, rcpPdf;
                         ImportanceSamplePunctualLight(rndVal, light.positionWS,
-                                                      ray.originWS, ray.directionWS,
+                                                      ray.originWS, ray.strataDirWS,
                                                       tEntr, tExit, t, distSq, rcpPdf,
                                                       hackMinDistSq);
 
                         EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
                                                distances, color, attenuation);
 
-                        float cosTheta = dot(L, ray.directionWS);
-                    #if HG
-                        float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
-                    #else
-                        float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
-                    #endif
+                        // Important:
+                        // Ideally, all scattering calculations should use the stratified versions
+                        // of the sample position and the ray direction. However, correct reprojection
+                        // of asymmetrically scattered lighting (affected by an anisotropic phase
+                        // function) is not possible. We work around this issue by reprojecting
+                        // lighting not affected by the phase function. This basically removes
+                        // the phase function from the temporal integration process. It is a hack.
+                        // The downside is that asymmetry no longer benefits from temporal averaging,
+                        // and any temporal instability of asymmetry causes causes visible jitter.
+                        // In order to stabilize the image, we use the voxel center for all
+                        // asymmetry-related calculations.
+                        float3 centerL = light.positionWS - centerWS;
+                        float  cosTheta = dot(centerL, ray.centerDirWS) * rsqrt(dot(centerL, centerL));
+                        float  phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
-                        float intensity = attenuation * (phase * rcpPdf);
+                        float intensity = attenuation * rcpPdf;
-                        voxelRadiance += color * intensity;
+                        lighting.radianceNoPhase  += intensity * color;
+                        lighting.radianceComplete += phase * intensity * color;
                     }
 
                     light = FetchLight(lightStart, min(++i, last));
                     float3x3 rotMat = float3x3(light.right, light.up, light.forward);
 
                     float3 o = mul(rotMat, ray.originWS - light.positionWS);
-                    float3 d = mul(rotMat, ray.directionWS);
+                    float3 d = mul(rotMat, ray.strataDirWS);
 
                     float  range  = light.size.x;
                     float3 boxPt0 = float3(-1, -1, 0);
                         EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
                                                distances, color, attenuation);
 
-                        float cosTheta = dot(L, ray.directionWS);
-                    #if HG
-                        float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
-                    #else
-                        float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
-                    #endif
+                        // Important:
+                        // Ideally, all scattering calculations should use the stratified versions
+                        // of the sample position and the ray direction. However, correct reprojection
+                        // of asymmetrically scattered lighting (affected by an anisotropic phase
+                        // function) is not possible. We work around this issue by reprojecting
+                        // lighting not affected by the phase function. This basically removes
+                        // the phase function from the temporal integration process. It is a hack.
+                        // The downside is that asymmetry no longer benefits from temporal averaging,
+                        // and any temporal instability of asymmetry causes causes visible jitter.
+                        // In order to stabilize the image, we use the voxel center for all
+                        // asymmetry-related calculations.
+                        float3 centerL = light.positionWS - centerWS;
+                        float  cosTheta = dot(centerL, ray.centerDirWS) * rsqrt(dot(centerL, centerL));
+                        float  phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
-                        float intensity = attenuation * (phase * weight);
+                        float intensity = attenuation * weight;
-                        voxelRadiance += intensity * color;
+                        lighting.radianceNoPhase  += intensity * color;
+                        lighting.radianceComplete += phase * intensity * color;
                     }
                 }
             }
     } while ((cluster < 2) && (clusterIndices[0] != clusterIndices[1]));
 #endif // LIGHTLOOP_TILE_PASS
 
-    return voxelRadiance;
+    return lighting;
-                                  PositionInputs posInput, Ray ray)
+                                  PositionInputs posInput, DualRay ray)
-    float z0 = _VBufferDepthEncodingParams.x;   // Start integration from the near plane
-    float t0 = ray.ratioLenToZ * z0;
-    float de = rcp(VBUFFER_SLICE_COUNT);        // Log-encoded distance between slices
+    float z0 = _VBufferDepthEncodingParams.x; // Start integration from the near plane
+    float t0 = ray.strataDirInvViewZ * z0;    // Convert view space Z to distance along the stratified ray
+    float de = rcp(VBUFFER_SLICE_COUNT);      // Log-encoded distance between slices
 
     float3 totalRadiance = 0;
     float  opticalDepth  = 0;
     {
         float e1 = slice * de + de; // (slice + 1) / sliceCount
         float z1 = DecodeLogarithmicDepth(e1, _VBufferDepthEncodingParams);
-        float t1 = ray.ratioLenToZ * z1;
+        float t1 = ray.strataDirInvViewZ * z1; // Convert view space Z to distance along the stratified ray
         float dt = t1 - t0;
 
     #ifdef LIGHTLOOP_TILE_PASS
 
         // Compute the -exact- position of the center of the voxel.
         // It's important since the accumulated value of the integral is stored at the center.
-        // We will use it for participating media sampling and reprojection.
+        // We will use it for participating media sampling, asymmetric scattering and reprojection.
         float  tc       = t0 + 0.5 * dt;
         float3 centerWS = GetCenterAtDistance(ray, tc);
 
         float rndVal = 0.5;
     #endif
 
-        float3 voxelRadiance = EvaluateVoxelLighting(context, featureFlags, posInput,
-                                                     ray, t0, t1, dt, rndVal, extinction, asymmetry
-                                                #ifdef LIGHTLOOP_TILE_PASS
-                                                   , clusterIndices, clusterDepths);
-                                                #else
-                                                     );
-                                                #endif
+        VoxelLighting lighting = EvaluateVoxelLighting(context, featureFlags, posInput, centerWS,
+                                                       ray, t0, t1, dt, rndVal, extinction, asymmetry
+                                                   #ifdef LIGHTLOOP_TILE_PASS
+                                                       , clusterIndices, clusterDepths);
+                                                   #else
+                                                       );
+                                                   #endif
+
+    #if (SUPPORT_ASYMMETRY == 0)
+        lighting.radianceComplete = lighting.radianceNoPhase;
+    #endif
 
     #if ENABLE_REPROJECTION
         // Reproject the history at 'centerWS'.
         // Both radiance values are obtained by integrating over line segments of different length.
         // Blending only makes sense if the length of both intervals is the same.
         // Therefore, the reprojected radiance needs to be rescaled by (frame_dt / reproj_dt).
+        // Important: reprojection must be performed without the phase function! Otherwise,
+        // some kind of per-light angle correction is required, which is intractable in practice.
-        float3 blendedRadiance = (1 - blendFactor) * voxelRadiance + blendFactor * lengthScale * reprojRadiance;
+        float3 blendedRadiance = (1 - blendFactor) * lighting.radianceNoPhase + blendFactor * lengthScale * reprojRadiance;
 
         // Store the feedback for the voxel.
         // TODO: dynamic lights (which update their position, rotation, cookie or shadow at runtime)
         _VBufferLightingFeedback[uint3(posInput.positionSS, slice)] = float4(blendedRadiance, dt);
+
+        // Extrapolate the influence of the phase function on the results of the current frame.
+        // TODO: how to ensure we do not divide by 0?
+        float3 phaseCurrFrame = lighting.radianceComplete / lighting.radianceNoPhase;
+        blendedRadiance *= phaseCurrFrame;
-        float3 blendedRadiance = voxelRadiance;
-    #endif
-
-    #if DEBUG_REPROJECTION
-        if (distance(voxelRadiance, reprojValue.rgb) > 0.1) blendedRadiance = float3(1000, 0, 0);
-    #endif
+        float3 blendedRadiance = lighting.radianceComplete;
+    #endif // ENABLE_REPROJECTION
-    #if HG
-        float phase = HenyeyGreensteinPhasePartConstant(asymmetry);
+    #if SUPPORT_ASYMMETRY
+        float phase = CornetteShanksPhasePartConstant(asymmetry);
-        float phase = CornetteShanksPhasePartConstant(asymmetry);
+        float phase = IsotropicPhaseFunction();
     #endif
 
         // Integral{a, b}{Transmittance(0, t) * L_s(t) dt} = Transmittance(0, a) * Integral{a, b}{Transmittance(0, t - a) * L_s(t) dt}.
 
     float2 centerCoord = voxelCoord + 0.5;
 #if ENABLE_REPROJECTION
-    float2 sampleCoord = centerCoord + _VBufferSampleOffset.xy;
+    float2 strataCoord = centerCoord + _VBufferSampleOffset.xy;
-    float2 sampleCoord = centerCoord;
+    float2 strataCoord = centerCoord;
-    // Compute the (stratified) ray direction s.t. its ViewSpaceZ = 1.
-    float3 rayDir = mul(-float3(sampleCoord, 1), (float3x3)_VBufferCoordToViewDirWS);
-    float  lenSq  = dot(rayDir, rayDir);
-    float  lenRcp = rsqrt(lenSq);
-    float  len    = lenSq * lenRcp;
+    // Compute the (tile-stratified) ray direction s.t. its ViewSpace(rayDirWS).z = 1.
+    float3 strataDirWS     = mul(-float3(strataCoord, 1), (float3x3)_VBufferCoordToViewDirWS);
+    float  strataDirLenSq  = dot(strataDirWS, strataDirWS);
+    float  strataDirLenRcp = rsqrt(strataDirLenSq);
+    float  strataDirLen    = strataDirLenSq * strataDirLenRcp;
+
+    // Compute the (tile-centered) ray direction s.t. its ViewSpace(rayDirWS).z = 1.
+    float3 centerDirWS     = mul(-float3(centerCoord, 1), (float3x3)_VBufferCoordToViewDirWS);
+    float  centerDirLenSq  = dot(centerDirWS, centerDirWS);
+    float  centerDirLenRcp = rsqrt(centerDirLenSq);
+    float  centerDirLen    = centerDirLenSq * centerDirLenRcp;
-#if ENABLE_REPROJECTION
-    // Compute the ray direction which passes through the center of the voxel s.t. its ViewSpaceZ = 1.
-    float3 rayCenterDir = mul(-float3(centerCoord, 1), (float3x3)_VBufferCoordToViewDirWS);
-#else
-    float3 rayCenterDir = rayDir;
-#endif
+    DualRay ray;
-    Ray ray;
-    ray.originWS    = GetCurrentViewPosition();
-    ray.ratioLenToZ = len;
-    ray.directionWS = rayDir * lenRcp;
-    ray.centerDirWS = rayCenterDir * lenRcp;
+    ray.originWS          = GetCurrentViewPosition();
+    ray.strataDirWS       = strataDirWS * strataDirLenRcp;  // Normalize
+    ray.centerDirWS       = centerDirWS * centerDirLenRcp;  // Normalize
+    ray.strataDirInvViewZ = strataDirLen;                   // View space Z
+    ray.twoDirRatioViewZ  = centerDirLen * strataDirLenRcp; // View space Z ratio
 
     // TODO
     LightLoopContext context;

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

         weight = InfluenceBoxWeight(lightData, bsdfData, positionWS, positionIS, dirIS);
     }
 
-    // 2. Process the influence
-    //if (influenceShapeType == ENVSHAPETYPE_SPHERE)
-    //    weight = InfluenceSphereWeight(lightData, bsdfData, positionWS, positionIS, dirIS);
-    //else if (influenceShapeType == ENVSHAPETYPE_BOX)
-    //    weight = InfluenceBoxWeight(lightData, bsdfData, positionWS, positionIS, dirIS);
+#ifdef DEBUG_DISPLAY
+    float3 radiusToProxy = R;
+#endif
 
     // When we are rough, we tend to see outward shifting of the reflection when at the boundary of the projection volume
     // Also it appear like more sharp. To avoid these artifact and at the same time get better match to reference we lerp to original unmodified reflection.
     float3 F = preLightData.specularFGD;
     float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness);
 
+
+
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_ENVIRONMENT_PROXY_VOLUME)
+        preLD = ApplyDebugProjectionVolume(preLD, radiusToProxy, _DebugEnvironmentProxyDepthScale);
+#endif
 
     // Smooth weighting
     weight = Smoothstep01(weight);

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

         [Enum(Flip, 0, Mirror, 1)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
-        [Enum(UV0, 0, Planar, 4, TriPlanar, 5)] _UVBase("UV Set for base", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase("UV Set for base", Float) = 0
         _TexWorldScale("Scale to apply on world coordinate", Float) = 1.0
         [HideInInspector] _InvTilingScale("Inverse tiling scale = 2 / (abs(_BaseColorMap_ST.x) + abs(_BaseColorMap_ST.y))", Float) = 1
         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [ToggleUI] _LinkDetailsWithBase("LinkDetailsWithBase", Float) = 1.0
 
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
-        [Enum(UV0, 0, Planar, 4, TriPlanar, 5)] _UVEmissive("UV Set for emissive", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVEmissive("UV Set for emissive", Float) = 0
         _TexWorldScaleEmissive("Scale to apply on world coordinate", Float) = 1.0
         [HideInInspector] _UVMappingMaskEmissive("_UVMappingMaskEmissive", Color) = (1, 0, 0, 0)
 

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

 
     // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
     #ifndef LAYERED_LIT_SHADER
-    ComputeLayerTexCoord(input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3, float4(1.0, 0.0, 0.0, 0.0), float4(1.0, 0.0, 0.0, 0.0),
+    ComputeLayerTexCoord(
-    ComputeLayerTexCoord0(input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3, _UVMappingMaskEmissive, _UVMappingMaskEmissive,
+    ComputeLayerTexCoord0(
+                            input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3, _UVMappingMaskEmissive, _UVMappingMaskEmissive,
                             _EmissiveColorMap_ST.xy, _EmissiveColorMap_ST.zw, float2(0.0, 0.0), float2(0.0, 0.0), 1.0, false,
                             input.positionWS, _TexWorldScaleEmissive,
                             mappingType, layerTexCoord);

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

 #endif
 
     // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
-    ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, float4(1.0, 0.0, 0.0, 0.0), _UVDetailsMappingMask,
+    ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMask, _UVDetailsMappingMask,
                             _BaseColorMap_ST.xy, _BaseColorMap_ST.zw, _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0, _LinkDetailsWithBase,
                             positionWS, _TexWorldScale,
                             mappingType, layerTexCoord);

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

         [Enum(Flip, 0, Mirror, 1)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
-        [Enum(UV0, 0, Planar, 4, TriPlanar, 5)] _UVBase("UV Set for base", Float) = 0
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase("UV Set for base", Float) = 0
         _TexWorldScale("Scale to apply on world coordinate", Float) = 1.0
         [HideInInspector] _InvTilingScale("Inverse tiling scale = 2 / (abs(_BaseColorMap_ST.x) + abs(_BaseColorMap_ST.y))", Float) = 1
         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScatteringManager.cs

             var desc = hdCamera.renderTextureDesc;
             desc.width = (desc.width + 7) / 8;
             desc.height = (desc.height + 7) / 8;
+            // TODO: This fails allocation with MSAA enabled?
             m_HTile = CoreUtils.CreateRenderTexture(desc, 0, RenderTextureFormat.R8, RenderTextureReadWrite.Linear); // DXGI_FORMAT_R8_UINT is not supported by Unity
             m_HTile.filterMode = FilterMode.Point;
             m_HTile.enableRandomWrite = true;
             if (sssParameters == null || !frameSettings.enableSubsurfaceScattering)
                 return;
 
+            // TODO: For MSAA, at least initially, we can only support Jimenez, because we can't
+            // create MSAA + UAV render targets.
+
             using (new ProfilingSample(cmd, "Subsurface Scattering", CustomSamplerId.SubsurfaceScattering.GetSampler()))
             {
                 // For Jimenez we always need an extra buffer, for Disney it depends on platform
                     cmd.ReleaseTemporaryRT(m_CameraFilteringBuffer);
-                    CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraFilteringBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
+
+                    if (frameSettings.enableMSAA)
+                        CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraFilteringBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear); // no UAV
+                    else
+                        CoreUtils.CreateCmdTemporaryRT(cmd, m_CameraFilteringBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear, 1, true); // Enable UAV
 
                     // Clear the SSS filtering target
                     using (new ProfilingSample(cmd, "Clear SSS filtering target", CustomSamplerId.ClearSSSFilteringTarget.GetSampler()))

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

             aggregate.enableTransparentObjects = srcFrameSettings.enableTransparentObjects;
 
             aggregate.enableMSAA = srcFrameSettings.enableMSAA && renderPipelineSettings.supportMSAA;
+            if (QualitySettings.antiAliasing < 1)
+                aggregate.enableMSAA = false;
+            aggregate.ConfigureMSAADependentSettings();
+        }
+
+        public void ConfigureMSAADependentSettings()
+        {
+            if (enableMSAA)
+            {
+                // Initially, MSAA will only support forward
+                enableForwardRenderingOnly = true;
+
+                // TODO: Should we disable enableFptlForForwardOpaque in here, instead of in InitializeLightLoopSettings?
+                // We'd have to move this method to after InitializeLightLoopSettings if we did.  It would be nice to centralize
+                // all MSAA-dependent settings in this method.
+
+                // Assuming MSAA is being used, TAA, and therefore, motion vectors are not needed
+                enableMotionVectors = false;
+
+                // TODO: The work will be implemented piecemeal to support all passes
+                enableDBuffer = false; // no decals
+                enableDistortion = false; // no gaussian final color
+                enablePostprocess = false;
+                enableRoughRefraction = false; // no gaussian pre-refraction
+                enableSSAO = false;
+                enableSSR = false;
+                enableSubsurfaceScattering = false;
+                enableTransparentObjects = false; // waiting on depth pyramid generation
+            }
         }
 
         static public void RegisterDebug(String menuName, FrameSettings frameSettings)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/AtmosphericScattering/AtmosphericScattering.hlsl

 #include "AtmosphericScattering.cs.hlsl"
 #include "../SkyVariables.hlsl"
 #include "../../ShaderVariables.hlsl"
-#include "../../Lighting/VBuffer.hlsl"
+#include "../../Lighting/Volumetrics/VBuffer.hlsl"
 
 #if (SHADEROPTIONS_VOLUMETRIC_LIGHTING_PRESET != 0)
 TEXTURE3D(_VBufferLighting);

ScriptableRenderPipeline/HDRenderPipeline/package.json

 {
     "name": "com.unity.render-pipelines.high-definition",
     "description": "HD Render Pipeline for Unity.",
-    "version": "0.1.26",
+    "version": "0.1.27",
-        "com.unity.postprocessing": "0.1.7",
-        "com.unity.render-pipelines.core": "0.1.26"
+        "com.unity.postprocessing": "0.1.8",
+        "com.unity.render-pipelines.core": "0.1.27"
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

             }
 
             RenderTextureDescriptor colorRTDesc = new RenderTextureDescriptor(rtWidth, rtHeight, m_ColorFormat, kDepthStencilBufferBits);
+            colorRTDesc.sRGB = true;
             colorRTDesc.msaaSamples = msaaSamples;
             colorRTDesc.enableRandomWrite = false;
 

ScriptableRenderPipeline/LightweightPipeline/package.json

 {
     "name": "com.unity.render-pipelines.lightweight",
     "description": "Lightweight Render Pipeline for Unity.",
-    "version": "0.1.26",
+    "version": "0.1.27",
-        "com.unity.postprocessing": "0.1.7",
-        "com.unity.render-pipelines.core": "0.1.26"
+        "com.unity.postprocessing": "0.1.8",
+        "com.unity.render-pipelines.core": "0.1.27"
     }
 }

ScriptableRenderPipeline/master-package.json

 {
-    "version": "0.1.26",
+    "version": "0.1.27",
-        "com.unity.postprocessing": "0.1.7"
+        "com.unity.postprocessing": "0.1.8"
     },
     "subPackages": [
         "Core",

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/CornelBox/Cornell Box.fbx.meta

     2186277476908879428: ImportLogs
     2186277476908879430: ImportLogs
     2186277476908879432: ImportLogs
+    2186277476908879434: ImportLogs
+    2186277476908879436: ImportLogs
   externalObjects:
   - first:
       type: UnityEngine:Material
       name: Cornell Box_red
     second: {fileID: 2100000, guid: 9e230cd3dd687c74f9fd71088a260bb3, type: 2}
   materials:
-    importMaterials: 1
+    importMaterials: 0
     materialName: 0
     materialSearch: 1
     materialLocation: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/Sphere/Sphere.fbx.meta

   tangentSpace:
     normalSmoothAngle: 60
     normalImportMode: 0
-    tangentImportMode: 0
+    tangentImportMode: 3
     normalCalculationMode: 4
   importAnimation: 1
   copyAvatar: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2103_BakeMixed.unity

   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &126909927
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &398276648
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &569393405
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &573256290
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &585362627
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &591582530
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &658105329
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &752846307
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &886840555
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &976312494
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &1106453251
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &1142614819
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &1252875748
 MeshRenderer:
   m_ObjectHideFlags: 2
   shadowResolution: 512
   shadowDimmer: 1
   shadowFadeDistance: 10000
+  enableContactShadows: 0
+  contactShadowLength: 0
+  contactShadowDistanceScaleFactor: 0.5
+  contactShadowMaxDistance: 50
+  contactShadowFadeDistance: 5
+  contactShadowSampleCount: 8
   shadowCascadeCount: 4
   shadowCascadeRatios:
   - 0.05
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &1546213938
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &1589059864
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &1636907145
 MeshRenderer:
   m_ObjectHideFlags: 2
   blendNormalDistanceNegative: {x: 0, y: 0, z: 0}
   boxSideFadePositive: {x: 1, y: 1, z: 1}
   boxSideFadeNegative: {x: 1, y: 1, z: 1}
+  proxyVolumeComponent: {fileID: 0}
 --- !u!23 &1828705049
 MeshRenderer:
   m_ObjectHideFlags: 2
   m_Modification:
     m_TransformParent: {fileID: 0}
     m_Modifications:
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+    - target: {fileID: 4048380051118816, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
-    - target: {fileID: 100000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
-      propertyPath: m_StaticEditorFlags
-      value: 4294967295
-      objectReference: {fileID: 0}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
-      propertyPath: m_LocalScale.x
-      value: 3
-      objectReference: {fileID: 0}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
-      propertyPath: m_LocalScale.y
-      value: 3
-      objectReference: {fileID: 0}
-    - target: {fileID: 400000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
-      propertyPath: m_LocalScale.z
-      value: 3
-      objectReference: {fileID: 0}
-  m_ParentPrefab: {fileID: 100100000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}
+  m_ParentPrefab: {fileID: 100100000, guid: 9c31666db73c94448ad9133b2aeff0e5, type: 2}
   m_IsPrefabParent: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/CommonAssets/Cornell Box.fbx.meta

     2186277476908879416: ImportLogs
     2186277476908879418: ImportLogs
     2186277476908879420: ImportLogs
+    2186277476908879422: ImportLogs
   externalObjects:
   - first:
       type: UnityEngine:Material
     hasExtraRoot: 0
     skeletonHasParents: 1
   lastHumanDescriptionAvatarSource: {instanceID: 0}
-  animationType: 2
+  animationType: 0
   humanoidOversampling: 1
   additionalBone: 0
   userData: 

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/040_UpgradeScene/Models/Environment/Floor.fbx.meta

     2186277476908879416: ImportLogs
     2186277476908879418: ImportLogs
     2186277476908879420: ImportLogs
+    2186277476908879422: ImportLogs
   externalObjects:
   - first:
       type: UnityEngine:Material
     rootMotionBoneName: 
     rootMotionBoneRotation: {x: 0, y: 0, z: 0, w: 1}
     hasTranslationDoF: 0
-    hasExtraRoot: 0
+    hasExtraRoot: 1
-  animationType: 2
+  animationType: 0
   humanoidOversampling: 1
   additionalBone: 0
   userData: 

Tests/Scripts/Editor/GraphicTests/Framework/TestFramework.cs

                 yield return null;
             }
 
+            // Force rendering of all realtime reflection probes
+            ReflectionProbe[] probes = GameObject.FindObjectsOfType<ReflectionProbe>();
+            int[] renderIDs = new int[probes.Length];
+            for (int i=0; i<probes.Length; ++i)
+            {
+                if (probes[i].mode == UnityEngine.Rendering.ReflectionProbeMode.Realtime)
+                    renderIDs[i] = probes[i].RenderProbe();
+                else
+                    renderIDs[i] = -1;
+            }
+            for (int i=0; i<probes.Length; ++i)
+            {
+                if (renderIDs[i] != -1)
+                {
+                    while (!probes[i].IsFinishedRendering(renderIDs[i])) yield return null;
+                }
+            }
+
             testSetup.thingToDoBeforeTest.Invoke();
 
             // Render the camera
 				var misMatchLocationTemplate = Path.Combine(failedPath, string.Format("{0}.template.{1}", testInfo.name, "png"));
 				var generated = captured.EncodeToPNG();
                 File.WriteAllBytes(misMatchLocationResult, generated);
-                File.Copy(dumpFileLocation, misMatchLocationTemplate);
+                File.Copy(dumpFileLocation, misMatchLocationTemplate, true);
             }
 
 			Assert.IsTrue(areEqual, "Scene from {0}, did not match .template file.", testInfo.relativePath);

ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2203_PlanarProbes.unity.png.meta

+fileFormatVersion: 2
+guid: 004cadb485fd995429668566213dc468
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation.unity.png.meta

+fileFormatVersion: 2
+guid: bbaff8be8ee1a5144a56b398100698e9
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VBuffer.hlsl.meta

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

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/CornelBox/Cornell Box.prefab

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1001 &100100000
+Prefab:
+  m_ObjectHideFlags: 1
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications: []
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 0}
+  m_RootGameObject: {fileID: 1837566155010132}
+  m_IsPrefabParent: 1
+--- !u!1 &1837566155010132
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4048380051118816}
+  - component: {fileID: 33686852384577776}
+  - component: {fileID: 23804808622393114}
+  m_Layer: 0
+  m_Name: Cornell Box
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 4294967295
+  m_IsActive: 1
+--- !u!4 &4048380051118816
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1837566155010132}
+  m_LocalRotation: {x: 0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -0, y: 0, z: 0}
+  m_LocalScale: {x: 3, y: 3, z: 3}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &23804808622393114
+MeshRenderer:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1837566155010132}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 75d48353f7ed9d04683bb9f74b121d21, type: 2}
+  - {fileID: 2100000, guid: ccb6d265c4315eb46bc2af89bda5b225, type: 2}
+  - {fileID: 2100000, guid: 9e230cd3dd687c74f9fd71088a260bb3, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!33 &33686852384577776
+MeshFilter:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1837566155010132}
+  m_Mesh: {fileID: 4300000, guid: ec3442293e1c1fb4cbdc0a199ebb03f0, type: 3}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/CornelBox/Cornell Box.prefab.meta

+fileFormatVersion: 2
+guid: 9c31666db73c94448ad9133b2aeff0e5
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 100100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2203_PlanarProbes.meta

+fileFormatVersion: 2
+guid: 0b115fd7a18dc9043ba2f65456a487a0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2203_PlanarProbes.unity.meta

+fileFormatVersion: 2
+guid: 359ded33a047fd540b5e19a98547f5e2
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation.meta

+fileFormatVersion: 2
+guid: 717ece33ecae1984aae26589c5a24f09
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation.unity.meta

+fileFormatVersion: 2
+guid: 3f6529c22f7d2ca46814b2e7afd04ef9
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/HDRP_Default_Sky_SmallDist.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d7fd9488000d3734a9e00ee676215985, type: 3}
+  m_Name: HDRP_Default_Sky_SmallDist
+  m_EditorClassIdentifier: 
+  components:
+  - {fileID: 114827887035766406}
+  - {fileID: 114408460862325740}
+  - {fileID: 114186374562632170}
+--- !u!114 &114186374562632170
+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: 7ddcec8a8eb2d684d833ac8f5d26aebd, type: 3}
+  m_Name: HDShadowSettings
+  m_EditorClassIdentifier: 
+  active: 1
+  maxShadowDistance:
+    m_OverrideState: 1
+    m_Value: 20
+    min: 0
+--- !u!114 &114408460862325740
+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: 59b6606ef2548734bb6d11b9d160bc7e, type: 3}
+  m_Name: HDRISky
+  m_EditorClassIdentifier: 
+  active: 1
+  rotation:
+    m_OverrideState: 1
+    m_Value: 160
+    min: 0
+    max: 360
+  exposure:
+    m_OverrideState: 1
+    m_Value: 0
+  multiplier:
+    m_OverrideState: 1
+    m_Value: 1
+    min: 0
+  updateMode:
+    m_OverrideState: 1
+    m_Value: 0
+  updatePeriod:
+    m_OverrideState: 1
+    m_Value: 0
+    min: 0
+  skyHDRI:
+    m_OverrideState: 1
+    m_Value: {fileID: 8900000, guid: fb0bf2eac2381484187ba8a68cdca165, type: 3}
+--- !u!114 &114827887035766406
+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: 0d7593b3a9277ac4696b20006c21dde2, type: 3}
+  m_Name: VisualEnvironment
+  m_EditorClassIdentifier: 
+  active: 1
+  skyType:
+    m_OverrideState: 1
+    m_Value: 1
+  fogType:
+    m_OverrideState: 1
+    m_Value: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/HDRP_Default_Sky_SmallDist.asset.meta

+fileFormatVersion: 2
+guid: ccbdad4b791856b43a5c82a269a26316
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/HDRP_ReflectionProbe256.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0cf1dab834d4ec34195b920ea7bbf9ec, type: 3}
+  m_Name: HDRP_ReflectionProbe256
+  m_EditorClassIdentifier: 
+  m_RenderPipelineResources: {fileID: 11400000, guid: 3ce144cff5783da45aa5d4fdc2da14b7,
+    type: 2}
+  m_FrameSettings:
+    enableShadow: 1
+    enableContactShadows: 1
+    enableSSR: 1
+    enableSSAO: 1
+    enableSubsurfaceScattering: 1
+    enableTransmission: 1
+    diffuseGlobalDimmer: 1
+    specularGlobalDimmer: 1
+    enableForwardRenderingOnly: 0
+    enableDepthPrepassWithDeferredRendering: 0
+    enableAlphaTestOnlyInDeferredPrepass: 0
+    enableTransparentPrepass: 1
+    enableMotionVectors: 1
+    enableObjectMotionVectors: 1
+    enableDBuffer: 1
+    enableAtmosphericScattering: 1
+    enableRoughRefraction: 1
+    enableTransparentPostpass: 1
+    enableDistortion: 1
+    enablePostprocess: 1
+    enableStereo: 0
+    enableAsyncCompute: 0
+    enableOpaqueObjects: 1
+    enableTransparentObjects: 1
+    enableMSAA: 0
+    enableShadowMask: 1
+    lightLoopSettings:
+      enableTileAndCluster: 1
+      enableComputeLightEvaluation: 1
+      enableComputeLightVariants: 1
+      enableComputeMaterialVariants: 1
+      enableFptlForForwardOpaque: 1
+      enableBigTilePrepass: 1
+      isFptlEnabled: 1
+  renderPipelineSettings:
+    supportShadowMask: 1
+    supportSSR: 1
+    supportSSAO: 1
+    supportSubsurfaceScattering: 1
+    supportDBuffer: 1
+    supportMSAA: 0
+    lightLoopSettings:
+      spotCookieSize: 128
+      cookieTexArraySize: 16
+      pointCookieSize: 512
+      cubeCookieTexArraySize: 16
+      reflectionProbeCacheSize: 128
+      reflectionCubemapSize: 256
+      reflectionCacheCompressed: 0
+      skyReflectionSize: 256
+      skyLightingOverrideLayerMask:
+        serializedVersion: 2
+        m_Bits: 0
+    shadowInitParams:
+      shadowAtlasWidth: 4096
+      shadowAtlasHeight: 4096
+  diffusionProfileSettings: {fileID: 11400000, guid: 802c802428a2d9640a87e821dfcdd9e8,
+    type: 2}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/HDRP_ReflectionProbe256.asset.meta

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

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/ProbeVisualizer.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: ProbeVisualizer
+  m_Shader: {fileID: 4800000, guid: c4edd00ff2db5b24391a4fcb1762e459, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2000
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  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}
+    - _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}
+    - _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}
+    - _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}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _UnlitColorMap:
+        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
+    - _CoatMask: 1
+    - _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: 1
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableMotionVectorForVertexAnimation: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableWind: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _IOR: 1
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PreRefractionPass: 0
+    - _RefractionMode: 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
+    - _SupportDBuffer: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThicknessMultiplier: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _ZTestMode: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 1, g: 1, b: 1, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {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}
+    - _UnlitColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/ProbeVisualizer.mat.meta

+fileFormatVersion: 2
+guid: cca4727b1173f9e42b876caafe8c25ee
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/ReflectionProbeToTexture.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+[ExecuteInEditMode, RequireComponent(typeof(RawImage))]
+public class ReflectionProbeToTexture : MonoBehaviour
+{
+    [SerializeField] private ReflectionProbe targetProbe;
+    [SerializeField] private bool correctGamma = false;
+    
+    private Material blitMat;
+    private Texture probeTexture;
+    private Texture2D texture;
+
+    private int renderID;
+
+    private void Start()
+    {
+        //Convert();
+    }
+
+    [ContextMenu("Refresh")]
+	public void Convert ()
+    {
+        if (targetProbe != null)
+        {
+            if (texture != null) DestroyImmediate(texture);
+
+            texture = new Texture2D(targetProbe.resolution * 4, targetProbe.resolution * 3) { wrapMode = TextureWrapMode.Clamp };
+
+            if (blitMat != null) DestroyImmediate(blitMat);
+            blitMat = new Material(Shader.Find("Hiddent/HDRP/Tests/TexCubeToTex2D"));
+            blitMat.SetFloat("_CorrectGamma", correctGamma ? 1 : 0);
+
+            RenderTexture dest = new RenderTexture(texture.width, texture.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default);
+
+            while (!targetProbe.IsFinishedRendering(renderID)) { };
+
+            probeTexture = targetProbe.texture;
+
+            Graphics.Blit(probeTexture, dest, blitMat);
+
+            // Readback the rendered texture
+            var oldActive = RenderTexture.active;
+            RenderTexture.active = dest;
+            texture.ReadPixels(new Rect(0, 0, texture.width, texture.height), 0, 0);
+            RenderTexture.active = oldActive;
+            texture.Apply();
+
+            GetComponent<RawImage>().texture = texture;
+        }
+	}
+
+    [ContextMenu("RenderProbe")]
+    public void RenderProbe()
+    {
+        if (targetProbe != null)
+        {
+            renderID =  targetProbe.RenderProbe();
+            StartCoroutine(WaitForRenderRoutine());
+        }
+    }
+
+    IEnumerator WaitForRenderRoutine()
+    {
+        while (!targetProbe.IsFinishedRendering(renderID)) yield return null;
+        Convert();
+    }
+}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/ReflectionProbeToTexture.cs.meta

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

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/Tess_Displace.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: Tess_Displace
+  m_Shader: {fileID: 4800000, guid: 756bac9090102564582875f4c7e30202, type: 3}
+  m_ShaderKeywords: _DISPLACEMENT_LOCK_TILING_SCALE _HEIGHTMAP _MASKMAP _NORMALMAP
+    _NORMALMAP_TANGENT_SPACE _VERTEX_DISPLACEMENT _VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2000
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - TransparentBackfaceDebugDisplay
+  - 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: 2800000, guid: f23830c1beb532d4a8bf9a720ef56e25, type: 3}
+        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}
+    - _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: 2800000, guid: 3923df8ac3ccc9c438171dac7c7cc3b6, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: f23830c1beb532d4a8bf9a720ef56e25, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 2800000, guid: 9afbfdeb6447dc74089f286f49995089, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 2800000, guid: 57fce5aa5865eaa4fbb2111399715db7, type: 3}
+        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}
+    - _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: 1
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 1
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 1
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 1
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 1
+    - _DistortionDepthTest: 1
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableMotionVectorForVertexAnimation: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableWind: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.14999999
+    - _HeightCenter: 0.3
+    - _HeightMapParametrization: 1
+    - _HeightMax: 3
+    - _HeightMin: -3
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 6
+    - _HeightTessAmplitude: 15
+    - _HeightTessCenter: 0.3
+    - _IOR: 1
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 1
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 64
+    - _PPDMinSamples: 6
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PreRefractionPass: 0
+    - _RefractionMode: 0
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 1
+    - _SmoothnessRemapMax: 0.99999994
+    - _SmoothnessRemapMin: 0
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _StencilRefMV: 128
+    - _StencilWriteMask: 7
+    - _StencilWriteMaskMV: 128
+    - _Stiffness: 1
+    - _SubsurfaceMask: 1
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SupportDBuffer: 1
+    - _SurfaceType: 0
+    - _TessellationBackFaceCullEpsilon: -0.675
+    - _TessellationFactor: 3
+    - _TessellationFactorMaxDistance: 100
+    - _TessellationFactorMinDistance: 99
+    - _TessellationFactorTriangleSize: 2
+    - _TessellationMode: 0
+    - _TessellationShapeFactor: 0.5
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThicknessMultiplier: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _ZTestMode: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _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}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {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/2xxx_Lighting/2401_Light_on_Tesselation/Tess_Displace.mat.meta

+fileFormatVersion: 2
+guid: 4fadbc1a681767747b77a6f8964a368e
+timeCreated: 1509023461
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/TexCubeToTex2D.shader

+Shader "Hiddent/HDRP/Tests/TexCubeToTex2D"
+{
+	Properties
+	{
+		_MainTex ("Texture", Cube) = "white" {}
+        _CorrectGamma ("Correct Gamma", float ) = 0
+	}
+	SubShader
+	{
+		Tags { "RenderType"="Opaque" }
+		LOD 100
+
+		Pass
+		{
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+			};
+
+			struct v2f
+			{
+				float2 uv : TEXCOORD0;
+				float4 vertex : SV_POSITION;
+			};
+
+            samplerCUBE _MainTex;
+            bool _CorrectGamma;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+				o.vertex = UnityObjectToClipPos(v.vertex);
+                o.uv = v.uv;
+				return o;
+			}
+			
+			fixed4 frag (v2f i) : SV_Target
+			{
+                float3 coords = float3(0,0,0);
+
+                coords.x = cos( i.uv.x * UNITY_PI * 2 );
+                coords.z = sin( i.uv.x * UNITY_PI * 2 );
+
+                coords.y = sin((i.uv.y * 2 - 1) * UNITY_PI * 0.5);
+
+                coords.xz *= 1 - abs(coords.y);
+
+                fixed4 col = fixed4(1,1,1,1);
+
+                if (i.uv.x < 0.25)
+                {
+                    if (i.uv.y < 0.3333333)
+                        col.a *= 0;
+                    else if (i.uv.y < 0.6666666)
+                    {
+                        coords.x = saturate(i.uv.x * 4) * 2 - 1;
+                        coords.y = clamp((i.uv.y * 2 - 1) * 3, -1, 1);
+                        coords.z = 1;
+                    }
+                    else
+                        col.a *= 0;
+                }
+                else if (i.uv.x < 0.5)
+                {
+                    if (i.uv.y < 0.3333333)
+                    {
+                        coords.x = ((i.uv.y * 3) * 2 - 1);
+                        coords.y = -1;
+                    }
+                    else if (i.uv.y < 0.6666666)
+                    {
+                        coords.x = 1;
+                        coords.y = (i.uv.y * 2 - 1) * 3;
+                    }
+                    else
+                    {
+                        coords.x = -(((i.uv.y-.6666666) * 3) * 2 - 1);
+                        coords.y = 1;
+                    }
+                    coords.z = -(saturate((i.uv.x - 0.25) * 4) * 2 - 1);
+
+                }
+                else if (i.uv.x < 0.75)
+                {
+                    if (i.uv.y < 0.3333333)
+                        col.a *= 0;
+                    else if (i.uv.y < 0.6666666)
+                    {
+                        coords.x = -(saturate((i.uv.x-0.5) * 4) * 2 - 1);
+                        coords.y = (i.uv.y * 2 - 1) * 3;
+                        coords.z = -1;
+                    }
+                    else
+                        col.a *= 0;
+                }
+                else
+                {
+                    if (i.uv.y < 0.3333333)
+                        col.a *= 0;
+                    else if (i.uv.y < 0.6666666)
+                    {
+                        coords.x = -1;
+                        coords.y = (i.uv.y * 2 - 1) * 3;
+                        coords.z = saturate((i.uv.x - 0.75) * 4) * 2 - 1;
+                    }
+                        else
+                            col.a *= 0;
+                }
+
+                coords = normalize(coords);
+
+				col.rgb *= texCUBE(_MainTex, coords).rgb;
+
+                if (_CorrectGamma == 1)
+                    col.rgb = pow(col.rgb, 0.4545454545); // Gamma Correction
+
+                return col;
+			}
+			ENDCG
+		}
+	}
+}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/TexCubeToTex2D.shader.meta

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

SampleScenes/HDTest/PlanarReflectionTests.meta

-fileFormatVersion: 2
-guid: 16f734fc26685a24ea74c071cf024b43
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/VBuffer.hlsl.meta

-fileFormatVersion: 2
-guid: a9a6d43965a406e43b8b3c3851981e2e
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: