Post merge fixes

ScriptableRenderPipeline/Core/CoreRP/CoreUtils.cs

             mesh.triangles = triangles;
             return mesh;
         }
-
-		public static void ResizeHTile(ref RenderTexture hTile, ref RenderTargetIdentifier hTileRT, RenderTextureDescriptor desc)
-        {
-            // We must use a RenderTexture and not GetTemporaryRT() as currently Unity only aloow to bind a RenderTexture for a UAV in a pixel shader
-            // We use 8x8 tiles in order to match the native GCN HTile as closely as possible.          
-            desc.width = (desc.width + 7) / 8;
-            desc.height = (desc.height + 7) / 8;
-            // TODO: This fails allocation with MSAA enabled?
-			hTile = CreateRenderTexture(desc, 0, RenderTextureFormat.R8, RenderTextureReadWrite.Linear); // DXGI_FORMAT_R8_UINT is not supported by Unity
-            hTile.filterMode = FilterMode.Point;
-            hTile.enableRandomWrite = true;
-            hTile.Create();
-            hTileRT = new RenderTargetIdentifier(hTile);
-        }
     }
 }

ScriptableRenderPipeline/Core/CoreRP/RTHandle.cs

         private static int GetMaxWith(RTCategory category) { return s_MaxWidths[(int)category]; }
         private static int GetMaxHeight(RTCategory category) { return s_MaxHeights[(int)category]; }
 
+
+        // Parameters for auto-scaled Render Textures
+        static bool             s_ScaledRTSupportsMSAA = false;
+        static MSAASamples      s_ScaledRTCurrentMSAASamples = MSAASamples.None;
-        static RTCategory       s_CurrentCategory = RTCategory.Regular;
+        static RTCategory       s_ScaledRTCurrentCategory = RTCategory.Regular;
-        public static int maxWidth { get { return GetMaxWith(s_CurrentCategory); } }
-        public static int maxHeight { get { return GetMaxHeight(s_CurrentCategory); } }
+        public static int maxWidth { get { return GetMaxWith(s_ScaledRTCurrentCategory); } }
+        public static int maxHeight { get { return GetMaxHeight(s_ScaledRTCurrentCategory); } }
-        {
+{
             s_AutoSizedRTs = new List<RTHandle>();
             for (int i = 0; i < (int)RTCategory.Count; ++i)
             {
         }
 
+        // Call this once to set the initial size and allow msaa targets or not.
+        public static void Initialize(int width, int height, bool scaledRTsupportsMSAA, MSAASamples scaledRTMSAASamples)
+        {
+            Debug.Assert(s_AutoSizedRTs.Count == 0, "RTHandle.Initialize should only be called once before allocating any Render Texture.");
+
+            for (int i = 0; i < (int)RTCategory.Count; ++i)
+            {
+                s_MaxWidths[i] = width;
+                s_MaxHeights[i] = height;
+            }
+
+            s_ScaledRTSupportsMSAA = scaledRTsupportsMSAA;
+            s_ScaledRTCurrentMSAASamples = scaledRTMSAASamples;
+        }
+
         public static void Release(RTHandle rth)
         {
             if(rth != null)
-        public static void SetReferenceSize(int width, int height, bool msaa)
+        public static void SetReferenceSize(int width, int height, bool msaa, MSAASamples msaaSamples)
         {
             // Technically, the enum could be passed as argument directly but let's not pollute public API with unnecessary complexity for now.
             RTCategory category = msaa ? RTCategory.MSAA : RTCategory.Regular;
 
-            if (width > GetMaxWith(category) || height > GetMaxHeight(category))
-                Resize(width, height, category);
+            bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
+            if (width > GetMaxWith(category) || height > GetMaxHeight(category) || msaaSamplesChanged)
+                Resize(width, height, category, msaaSamples);
-        public static void ResetReferenceSize(int width, int height, bool msaa)
+        public static void ResetReferenceSize(int width, int height, bool msaa, MSAASamples msaaSamples)
         {
             // Technically, the enum could be passed as argument directly but let's not pollute public API with unnecessary complexity for now.
             RTCategory category = msaa ? RTCategory.MSAA : RTCategory.Regular;
 
-            if (width != GetMaxWith(category) || height != GetMaxHeight(category))
-                Resize(width, height, category);
+            bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
+            if (width != GetMaxWith(category) || height != GetMaxHeight(category) || msaaSamplesChanged)
+                Resize(width, height, category, msaaSamples);
-        static void Resize(int width, int height, RTCategory category)
+        static void Resize(int width, int height, RTCategory category, MSAASamples msaaSamples)
+            s_ScaledRTCurrentMSAASamples = msaaSamples;
-            s_CurrentCategory = category;
+            s_ScaledRTCurrentCategory = category;
 
             foreach (var rth in s_AutoSizedRTs)
             {
 
                     rt.width = Mathf.Max(scaledSize.x, 1);
                     rt.height = Mathf.Max(scaledSize.y, 1);
+
+                    if (category == RTCategory.MSAA)
+                        rt.antiAliasing = (int)s_ScaledRTCurrentMSAASamples;
-
-                rth.SetCurrentCategory(category);
             }
         }
 
                 RenderTextureMemoryless memoryless = RenderTextureMemoryless.None
             )
         {
-            RTCategory category = msaaSamples != MSAASamples.None ? RTCategory.MSAA : RTCategory.Regular;
+            bool enableMSAA = msaaSamples != MSAASamples.None;
+            if (!enableMSAA && bindTextureMS == true)
+            {
+                Debug.LogWarning("RTHandle allocated without MSAA but with bindMS set to true, forcing bindMS to false.");
+                bindTextureMS = false;
+            }
 
             var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
             {
             };
             rt.Create();
 
-            var newRT = new RTHandle(rt, category);
+            RTCategory category = enableMSAA ? RTCategory.MSAA : RTCategory.Regular;
+            var newRT = new RTHandle();
+            newRT.SetRenderTexture(rt, category);
+            newRT.m_EnableRandomWrite = enableRandomWrite;
+            newRT.m_EnableMSAA = enableMSAA;
             return newRT;
         }
 
                 bool autoGenerateMips = true,
                 int anisoLevel = 1,
                 float mipMapBias = 0f,
-                MSAASamples msaaSamples = MSAASamples.None,
+                bool enableMSAA = false,
                 bool bindTextureMS = false,
                 bool useDynamicScale = false,
                 VRTextureUsage vrUsage = VRTextureUsage.None,
-            RTCategory category = msaaSamples != MSAASamples.None ? RTCategory.MSAA : RTCategory.Regular;
+            bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
+            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
-            var rth = Alloc(width,
+            var rth = AllocAutoSizedRenderTexture(width,
                 height,
                 1,
                 depthBufferBits,
                 autoGenerateMips,
                 anisoLevel,
                 mipMapBias,
-                msaaSamples,
+                enableMSAA,
                 bindTextureMS,
                 useDynamicScale,
                 vrUsage,
             rth.scaleFactor = scaleFactor;
-            rth.useScaling = true;
-            s_AutoSizedRTs.Add(rth);
             return rth;
         }
 
                 bool autoGenerateMips = true,
                 int anisoLevel = 1,
                 float mipMapBias = 0f,
-                MSAASamples msaaSamples = MSAASamples.None,
+                bool enableMSAA = false,
                 bool bindTextureMS = false,
                 bool useDynamicScale = false,
                 VRTextureUsage vrUsage = VRTextureUsage.None,
-            RTCategory category = msaaSamples != MSAASamples.None ? RTCategory.MSAA : RTCategory.Regular;
+            bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
+            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
-            var rth = Alloc(width,
+            var rth = AllocAutoSizedRenderTexture(width,
                 height,
                 1,
                 depthBufferBits,
                 autoGenerateMips,
                 anisoLevel,
                 mipMapBias,
-                msaaSamples,
+                enableMSAA,
                 bindTextureMS,
                 useDynamicScale,
                 vrUsage,
             rth.scaleFunc = scaleFunc;
+            return rth;
+        }
+
+        static RTHandle AllocAutoSizedRenderTexture(
+                int width,
+                int height,
+                int slices,
+                DepthBits depthBufferBits,
+                RenderTextureFormat colorFormat,
+                FilterMode filterMode,
+                TextureWrapMode wrapMode,
+                TextureDimension dimension,
+                bool sRGB,
+                bool enableRandomWrite,
+                bool useMipMap,
+                bool autoGenerateMips,
+                int anisoLevel,
+                float mipMapBias,
+                bool enableMSAA,
+                bool bindTextureMS,
+                bool useDynamicScale,
+                VRTextureUsage vrUsage,
+                RenderTextureMemoryless memoryless
+            )
+        {
+            // Here user made a mistake in setting up msaa/bindMS, hence the warning
+            if (!enableMSAA && bindTextureMS == true)
+            {
+                Debug.LogWarning("RTHandle allocated without MSAA but with bindMS set to true, forcing bindMS to false.");
+                bindTextureMS = false;
+            }
+
+            bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
+            // Here we purposefully disable MSAA so we just force the bindMS param to false.
+            if (!allocForMSAA)
+            {
+                bindTextureMS = false;
+            }
+
+            int msaaSamples = allocForMSAA ? (int)s_ScaledRTCurrentMSAASamples : 1;
+            bool UAV = allocForMSAA ? false : enableRandomWrite; // MSAA Does not support random read/write.
+            RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
+
+            var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
+            {
+                hideFlags = HideFlags.HideAndDontSave,
+                volumeDepth = slices,
+                filterMode = filterMode,
+                wrapMode = wrapMode,
+                dimension = dimension,
+                enableRandomWrite = UAV,
+                useMipMap = useMipMap,
+                autoGenerateMips = autoGenerateMips,
+                anisoLevel = anisoLevel,
+                mipMapBias = mipMapBias,
+                antiAliasing = msaaSamples,
+                bindTextureMS = bindTextureMS,
+                useDynamicScale = useDynamicScale,
+                vrUsage = vrUsage,
+                memorylessMode = memoryless
+            };
+            rt.Create();
+
+            RTHandle rth = new RTHandle();
+            rth.SetRenderTexture(rt, category);
+            rth.m_EnableMSAA = enableMSAA;
+            rth.m_EnableRandomWrite = enableRandomWrite;
             rth.useScaling = true;
             s_AutoSizedRTs.Add(rth);
             return rth;
         }
 
         // Instance data
-        RTCategory m_CurrentCategory = RTCategory.Regular;
-        RenderTexture[] m_RTs = new RenderTexture[2];
-        RenderTargetIdentifier[] m_NameIDs = new RenderTargetIdentifier[2];
+        RenderTexture[]             m_RTs = new RenderTexture[2];
+        RenderTargetIdentifier[]    m_NameIDs = new RenderTargetIdentifier[2];
+        bool                        m_EnableMSAA = false;
+        bool                        m_EnableRandomWrite = false;
 
         Vector2 scaleFactor = Vector2.one;
         ScaleFunc scaleFunc;
         {
             get
             {
-                CreateIfNeeded(m_CurrentCategory);
-                return m_RTs[(int)m_CurrentCategory];
+                if(!useScaling)
+                {
+                    return m_EnableMSAA ? m_RTs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
+                }
+                else
+                {
+                    RTCategory category = (m_EnableMSAA && s_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
+                    CreateIfNeeded(category);
+                    return m_RTs[(int)category];
+                }
             }
         }
 
             {
-                CreateIfNeeded(m_CurrentCategory);
-                return m_NameIDs[(int)m_CurrentCategory];
+                if (!useScaling)
+                {
+                    return m_EnableMSAA ? m_NameIDs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
+                }
+                else
+                {
+                    RTCategory category = (m_EnableMSAA && s_ScaledRTCurrentCategory == RTCategory.MSAA) ? RTCategory.MSAA : RTCategory.Regular;
+                    CreateIfNeeded(category);
+                    return m_NameIDs[(int)category];
+                }
-        RTHandle(RenderTexture rt, RTCategory category)
+        // Keep constructor private
+        RTHandle()
-            this.m_RTs[(int)category] = rt;
-            this.m_NameIDs[(int)category] = new RenderTargetIdentifier(rt);
+        }
-            SetCurrentCategory(category);
+        void SetRenderTexture(RenderTexture rt, RTCategory category)
+        {
+            m_RTs[(int)category] = rt;
+            m_NameIDs[(int)category] = new RenderTargetIdentifier(rt);
         }
 
         void CreateIfNeeded(RTCategory category)
                     filterMode = refRT.filterMode,
                     wrapMode = refRT.wrapMode,
                     dimension = refRT.dimension,
-                    enableRandomWrite = refRT.enableRandomWrite,
+                    enableRandomWrite = m_EnableRandomWrite, // We cannot take the info from the msaa rt since we force it to 1
                     useMipMap = refRT.useMipMap,
                     autoGenerateMips = refRT.autoGenerateMips,
                     anisoLevel = refRT.anisoLevel,
             }
         }
 
-        void SetCurrentCategory(RTCategory category)
-        {
-            m_CurrentCategory = category;
-        }
-
+
             s_AutoSizedRTs.Remove(this);
             for (int i = 0; i < (int)RTCategory.Count; ++i)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

                 m_ActualHeight = XRSettings.eyeTextureHeight;
             }
 
-            RTHandle.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, QualitySettings.antiAliasing);
+            RTHandle.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, HDUtils.hdrpSettings.msaaSampleCount);
+
             int maxWidth = RTHandle.maxWidth;
             int maxHeight = RTHandle.maxHeight;
             m_CameraScaleBias.x = (float)m_ActualWidth / maxWidth;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/RenderPipelineSettingsUI.cs

             EditorGUILayout.PropertyField(d.supportSSR, _.GetContent("Support SSR"));
             EditorGUILayout.PropertyField(d.supportSSAO, _.GetContent("Support SSAO"));
             EditorGUILayout.PropertyField(d.supportDBuffer, _.GetContent("Support Decal Buffer"));
-            EditorGUILayout.PropertyField(d.supportMSAA, _.GetContent("Support MSAA"));
+            EditorGUILayout.PropertyField(d.supportMSAAAntiAliasing, _.GetContent("Support MSAA Anti-Aliasing"));
+            EditorGUILayout.PropertyField(d.MSAASampleCount, _.GetContent("MSAA Sample Count"));
             EditorGUILayout.PropertyField(d.supportSubsurfaceScattering, _.GetContent("Support Subsurface Scattering"));
             EditorGUILayout.PropertyField(d.supportsForwardOnly, _.GetContent("Support Forward Only"));
             EditorGUILayout.PropertyField(d.supportsMotionVectors, _.GetContent("Support Motion Vectors"));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedRenderPipelineSettings.cs

         public SerializedProperty supportSSR;
         public SerializedProperty supportSSAO;
         public SerializedProperty supportDBuffer;
-        public SerializedProperty supportMSAA;
+        public SerializedProperty supportMSAAAntiAliasing;
+        public SerializedProperty MSAASampleCount;
         public SerializedProperty supportSubsurfaceScattering;
         public SerializedProperty supportsForwardOnly;
         public SerializedProperty supportsMotionVectors;
             supportSSR = root.Find((RenderPipelineSettings s) => s.supportSSR);
             supportSSAO = root.Find((RenderPipelineSettings s) => s.supportSSAO);
             supportDBuffer = root.Find((RenderPipelineSettings s) => s.supportDBuffer);
-            supportMSAA = root.Find((RenderPipelineSettings s) => s.supportMSAA);
+            supportMSAAAntiAliasing = root.Find((RenderPipelineSettings s) => s.supportMSAAAntiAliasing);
+            MSAASampleCount = root.Find((RenderPipelineSettings s) => s.msaaSampleCount);
             supportSubsurfaceScattering = root.Find((RenderPipelineSettings s) => s.supportSubsurfaceScattering);
             supportsForwardOnly = root.Find((RenderPipelineSettings s) => s.supportsForwardOnly);
             supportsMotionVectors = root.Find((RenderPipelineSettings s) => s.supportsMotionVectors);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

                 return asset;
             }
         }
+        public RenderPipelineSettings renderPipelineSettings { get { return m_Asset.renderPipelineSettings; } }
 
         public bool IsInternalDiffusionProfile(DiffusionProfileSettings profile)
         {
         // Detect when windows size is changing
         int m_CurrentWidth;
         int m_CurrentHeight;
-        int m_CurrentMSAASampleCount;
 
         // Use to detect frame changes
         int m_FrameCount;
 
         void InitializeRenderTextures()
         {
+            // Initial state of the RTHandle system.
+            // Tells the system that we will require MSAA or not so that we can avoid wasteful render texture allocation.
+            // TODO: Might want to initialize to at least the window resolution to avoid un-necessary re-alloc in the player
+            RTHandle.Initialize(1, 1, m_Asset.renderPipelineSettings.supportMSAAAntiAliasing, m_Asset.renderPipelineSettings.msaaSampleCount);
+
             m_GbufferManager.CreateBuffers();
 
             if(m_Asset.renderPipelineSettings.supportDBuffer)
 
-            m_CameraColorBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB : false, enableRandomWrite: true);
-            m_CameraSssDiffuseLightingBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true);
+            m_CameraColorBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.ARGBHalf, sRGB : false, enableRandomWrite: true, enableMSAA: true);
+            m_CameraSssDiffuseLightingBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true, enableMSAA: true);
-            m_CameraDepthStencilBuffer = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point);
+            m_CameraDepthStencilBuffer = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, bindTextureMS: true, enableMSAA: true);
-                m_CameraDepthBufferCopy = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point);
+                m_CameraDepthBufferCopy = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.Depth24, colorFormat: RenderTextureFormat.Depth, filterMode: FilterMode.Point, bindTextureMS: true, enableMSAA: true);
-            m_CameraStencilBufferCopy = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.None, colorFormat: RenderTextureFormat.R8, sRGB: false, filterMode: FilterMode.Point); // DXGI_FORMAT_R8_UINT is not supported by Unity
+            m_CameraStencilBufferCopy = RTHandle.Alloc(Vector2.one, depthBufferBits: DepthBits.None, colorFormat: RenderTextureFormat.R8, sRGB: false, filterMode: FilterMode.Point, enableMSAA: true); // DXGI_FORMAT_R8_UINT is not supported by Unity
 
             if (m_Asset.renderPipelineSettings.supportSSAO)
             {
             if (m_Asset.renderPipelineSettings.supportsMotionVectors)
             {
-                m_VelocityBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetVelocityBufferFormat(), sRGB: Builtin.GetVelocityBuffer_sRGBFlag());
+                m_VelocityBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetVelocityBufferFormat(), sRGB: Builtin.GetVelocityBuffer_sRGBFlag(), enableMSAA: true);
             }
 
             m_DistortionBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: Builtin.GetDistortionBufferFormat(), sRGB: Builtin.GetDistortionBuffer_sRGBFlag());
 
             RTHandle.Release(m_DebugColorPickerBuffer);
             RTHandle.Release(m_DebugFullScreenTempBuffer);
+
+            foreach (var rth in m_GaussianPyramidColorMips)
+            {
+                RTHandle.Release(rth);
+            }
+
+            foreach (var rth in m_DepthPyramidMips)
+            {
+                RTHandle.Release(rth);
+            }
         }
 
 
             m_VolumetricLightingModule.ResizeVBuffer(hdCamera, hdCamera.actualWidth, hdCamera.actualHeight);
 
             // update recorded window resolution
-            m_CurrentMSAASampleCount = sampleCount;
             m_CurrentWidth = hdCamera.actualWidth;
             m_CurrentHeight = hdCamera.actualHeight;
         }
                 HDUtils.SetRenderTarget(cmd, hdCamera, m_GbufferManager.GetBuffersRTI(), m_CameraDepthStencilBuffer);
                 if (m_FrameSettings.enableDBuffer)
                 {
-                    m_DbufferManager.SetHTile(m_GbufferManager.gbufferCount, cmd);
+                    m_DbufferManager.SetHTile(m_GbufferManager.bufferCount, cmd);
                 }
 
                 // Render opaque objects into GBuffer
 
 				// we need to do a separate clear for normals, because they are cleared to a different color
 				Color clearColorNormal = new Color(0.5f, 0.5f, 0.5f, 1.0f); // for normals 0.5 is neutral
-				m_DbufferManager.ClearNormalTargetAndHTile(clearColorNormal, cmd);
-				m_DbufferManager.ClearNormalTarget(cmd, camera, clearColorNormal);
+				m_DbufferManager.ClearNormalTargetAndHTile(cmd, camera, clearColorNormal);
-                m_DbufferManager.SetHTile(m_DbufferManager.dbufferCount, cmd);
+                m_DbufferManager.SetHTile(m_DbufferManager.bufferCount, cmd);
                 DecalSystem.instance.Render(renderContext, camera, cmd);
                 m_DbufferManager.UnSetHTile(cmd);
             }
 
                 if (settings.IsEnabledAndSupported(null))
                 {
-                    CoreUtils.CreateCmdTemporaryRT(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera.renderTextureDesc, 0, FilterMode.Bilinear, RenderTextureFormat.R8, RenderTextureReadWrite.Linear, msaaSamplesOverride: 1, enableRandomWrite: true);
                     postProcessLayer.BakeMSVOMap(cmd, camera, m_AmbientOcclusionBuffer, GetDepthTexture(), true);
 
                     cmd.SetGlobalTexture(HDShaderIDs._AmbientOcclusionTexture, m_AmbientOcclusionBuffer);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDUtils.cs

         public const RendererConfiguration k_RendererConfigurationBakedLighting = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
         public const RendererConfiguration k_RendererConfigurationBakedLightingWithShadowMask = k_RendererConfigurationBakedLighting | RendererConfiguration.PerObjectOcclusionProbe | RendererConfiguration.PerObjectOcclusionProbeProxyVolume | RendererConfiguration.PerObjectShadowMask;
 
-        static Material GetBlitMaterial()
+        public static Material GetBlitMaterial()
         {
             HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
             if (hdPipeline != null)
 
             return null;
+        }
+
+        public static RenderPipelineSettings hdrpSettings
+        {
+            get
+            {
+                HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+                if (hdPipeline != null)
+                {
+                    return hdPipeline.renderPipelineSettings;
+                }
+                return null;
+            }
         }
 
         static MaterialPropertyBlock s_PropertyBlock = new MaterialPropertyBlock();

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

 
                         cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._MainDepthTexture, depthTexture);
 
-                        // TODO: Should remove this setting but can't remove it else get error: Property (_AmbientOcclusionTexture) at kernel index (32) is not set. Check why
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._AmbientOcclusionTexture, HDShaderIDs._AmbientOcclusionTexture);
-
                         // TODO: Is it possible to setup this outside the loop ? Can figure out how, get this: Property (specularLightingUAV) at kernel index (21) is not set
                         cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.specularLightingUAV, colorBuffers[0]);
                         cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.diffuseLightingUAV,  colorBuffers[1]);

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

 
         public RenderTexture NewRenderTarget(PlanarReflectionProbe probe)
         {
-            var desc = GetRenderHDCamera(probe).renderTextureDesc;
+            RenderTextureDescriptor desc = new RenderTextureDescriptor();
             desc.width = m_Parameters.planarReflectionProbeSize;
             desc.height = m_Parameters.planarReflectionProbeSize;
             desc.colorFormat = RenderTextureFormat.ARGBHalf;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/MRTBufferManager.cs

         protected RTHandle[] m_RTs;
         protected int[] m_TextureShaderIDs;
 
+        public int bufferCount { get { return m_BufferCount; } }
+
         public MRTBufferManager(int maxBufferCount)
         {
             m_BufferCount = maxBufferCount;
             }
         }
 
-        public void DestroyBuffers()
+        virtual public void DestroyBuffers()
         {
             for (int i = 0; i < m_BufferCount; ++i)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DBufferManager.cs

     {
         public int vsibleDecalCount { get; set; }
 
+        RTHandle m_HTile;
+
         public DBufferManager()
             : base(Decal.GetMaterialDBufferCount())
         {
                 m_RTIDs[dbufferIndex] = m_RTs[dbufferIndex].nameID;
                 m_TextureShaderIDs[dbufferIndex] = HDShaderIDs._DBufferTexture[dbufferIndex];
             }
+
+            // We use 8x8 tiles in order to match the native GCN HTile as closely as possible.
+            m_HTile = RTHandle.Alloc(size => new Vector2Int((size.x + 7) / 8, (size.y + 7) / 8), filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.R8, sRGB: false, enableRandomWrite: true); // Enable UAV
-		
-		public void ClearNormalTarget(CommandBuffer cmd, HDCamera camera, Color clearColor)
-		{
-			// index 1 is normals
-			HDUtils.SetRenderTarget(cmd, camera, m_RTs[1], ClearFlag.Color, clearColor);
-		}
+
+        override public void DestroyBuffers()
+        {
+            base.DestroyBuffers();
+            RTHandle.Release(m_HTile);
+        }
+
+        public void ClearNormalTargetAndHTile(CommandBuffer cmd, HDCamera camera, Color clearColor)
+        {
+            // index 1 is normals
+            HDUtils.SetRenderTarget(cmd, camera, m_RTs[1], ClearFlag.Color, clearColor);
+            HDUtils.SetRenderTarget(cmd, camera, m_HTile, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+        }
+
+        public void SetHTile(int bindSlot, CommandBuffer cmd)
+        {
+            cmd.SetRandomWriteTarget(bindSlot, m_HTile);
+        }
+
+        public void UnSetHTile(CommandBuffer cmd)
+        {
+            cmd.ClearRandomWriteTargets();
+        }
 
         public void PushGlobalParams(CommandBuffer cmd)
         {

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

 
         public void InitSSSBuffers(GBufferManager gbufferManager, RenderPipelineSettings settings)
         {
+            // TODO: For MSAA, at least initially, we can only support Jimenez, because we can't create MSAA + UAV render targets.
-        {
-        // In case of full forward we must allocate the render target for forward SSS (or reuse one already existing)
-        // TODO: Provide a way to reuse a render target
+            {
+                // In case of full forward we must allocate the render target for forward SSS (or reuse one already existing)
+                // TODO: Provide a way to reuse a render target
-        {
+            {
                 // In case of deferred, we must be in sync with SubsurfaceScattering.hlsl and lit.hlsl files and setup the correct buffers
                 m_ColorMRTs[0] = gbufferManager.GetBuffer(0); // Note: This buffer must be sRGB (which is the case with Lit.shader)
                 m_ExternalBuffer[0] = true;
             {
                 // Caution: must be same format as m_CameraSssDiffuseLightingBuffer
-                m_CameraFilteringBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true); // Enable UAV
+                m_CameraFilteringBuffer = RTHandle.Alloc(Vector2.one, filterMode: FilterMode.Point, colorFormat: RenderTextureFormat.RGB111110Float, sRGB: false, enableRandomWrite: true, enableMSAA: true); // Enable UAV
             }
 
             // We use 8x8 tiles in order to match the native GCN HTile as closely as possible.
                 if (!m_ExternalBuffer[i])
                 {
                     RTHandle.Release(m_ColorMRTs[i]);
-        }
+                }
             }
 
             RTHandle.Release(m_CameraFilteringBuffer);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

             aggregate.enableOpaqueObjects = srcFrameSettings.enableOpaqueObjects;
             aggregate.enableTransparentObjects = srcFrameSettings.enableTransparentObjects;
 
-            aggregate.enableMSAA = srcFrameSettings.enableMSAA && renderPipelineSettings.supportMSAA;
+            aggregate.enableMSAA = srcFrameSettings.enableMSAA && renderPipelineSettings.supportMSAAAntiAliasing;
             if (QualitySettings.antiAliasing < 1)
                 aggregate.enableMSAA = false;
             aggregate.ConfigureMSAADependentSettings();

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/RenderPipelineSettings.cs

         public bool supportsForwardOnly = false;
 
         // Engine
-        public bool supportDBuffer = false;
-        public bool supportMSAA = false;
-        public bool supportsMotionVectors = true;
-        public bool supportsStereo = false;
+        public bool         supportDBuffer = false;
+        public bool         supportMSAAAntiAliasing = false;
+        public MSAASamples  msaaSampleCount = MSAASamples.None;
+        public bool         supportsMotionVectors = true;
+        public bool         supportsStereo = false;
 
         public GlobalLightLoopSettings  lightLoopSettings = new GlobalLightLoopSettings();
         public ShadowInitParameters     shadowInitParams = new ShadowInitParameters();