Merge pull request #910 from Unity-Technologies/hdrp-rth-fixes

Misc HDRP RTHandle fixes

ScriptableRenderPipeline/Core/CoreRP/RTHandle.cs

         public static int s_MaxWidthMSAAA { get { return s_MaxWidths[(int)RTCategory.MSAA]; } }
         public static int s_MaxHeightMSAA { get { return s_MaxHeights[(int)RTCategory.MSAA]; } }
 
-        private static int GetMaxWith(RTCategory category) { return s_MaxWidths[(int)category]; }
+        private static int GetMaxWidth(RTCategory category) { return s_MaxWidths[(int)category]; }
         private static int GetMaxHeight(RTCategory category) { return s_MaxHeights[(int)category]; }
 
 
         static int[] s_MaxWidths = new int[(int)RTCategory.Count];
         static int[] s_MaxHeights = new int[(int)RTCategory.Count];
 
-        public static int maxWidth { get { return GetMaxWith(s_ScaledRTCurrentCategory); } }
+        public static int maxWidth { get { return GetMaxWidth(s_ScaledRTCurrentCategory); } }
         public static int maxHeight { get { return GetMaxHeight(s_ScaledRTCurrentCategory); } }
 
         static RTHandle()
             height = Mathf.Max(height, 1);
 
             bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
-            if (width > GetMaxWith(category) || height > GetMaxHeight(category) || msaaSamplesChanged)
+            if (width > GetMaxWidth(category) || height > GetMaxHeight(category) || msaaSamplesChanged)
                 Resize(width, height, category, msaaSamples);
         }
 
             height = Mathf.Max(height, 1);
 
             bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
-            if (width != GetMaxWith(category) || height != GetMaxHeight(category) || msaaSamplesChanged)
+            if (width != GetMaxWidth(category) || height != GetMaxHeight(category) || msaaSamplesChanged)
                 Resize(width, height, category, msaaSamples);
         }
 
             bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
             RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
 
-            int width = Mathf.Max(Mathf.RoundToInt(scaleFactor.x * GetMaxWith(category)), 1);
+            int width = Mathf.Max(Mathf.RoundToInt(scaleFactor.x * GetMaxWidth(category)), 1);
             int height = Mathf.Max(Mathf.RoundToInt(scaleFactor.y * GetMaxHeight(category)), 1);
 
             var rth = AllocAutoSizedRenderTexture(width,
             bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
             RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
 
-            var scaleFactor = scaleFunc(new Vector2Int(GetMaxWith(category), GetMaxHeight(category)));
+            var scaleFactor = scaleFunc(new Vector2Int(GetMaxWidth(category), GetMaxHeight(category)));
             int width = Mathf.Max(scaleFactor.x, 1);
             int height = Mathf.Max(scaleFactor.y, 1);
 
             }
 
             // MSAA Does not support random read/write.
-            if (allocForMSAA && enableRandomWrite == true)
+            bool UAV = enableRandomWrite;
+            if (allocForMSAA && (UAV == true))
-                Debug.LogWarning("RTHandle allocated with MSAA can't be enableRandomWrite.");
-                enableRandomWrite = false;
+                Debug.LogWarning("RTHandle that is MSAA-enabled cannot allocate MSAA RT with 'enableRandomWrite = true'.");
+                UAV = false;
-            bool UAV = enableRandomWrite;
             RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
 
             var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
                     anisoLevel = refRT.anisoLevel,
                     mipMapBias = refRT.mipMapBias,
                     antiAliasing = 1, // No MSAA for the regular version of the texture.
-                    bindTextureMS = refRT.bindTextureMS,
+                    bindTextureMS = false, // Somehow, this can be true even if antiAliasing == 1. Leads to Unity-internal binding errors.
                     useDynamicScale = refRT.useDynamicScale,
                     vrUsage = refRT.vrUsage,
                     memorylessMode = refRT.memorylessMode

ScriptableRenderPipeline/Core/CoreRP/Resources/GPUCopy.compute

 
 #include "../ShaderLibrary/Common.hlsl"
 
-SamplerState sampler_LinearClamp;
-
-CBUFFER_START(cb)
-    float4 _Size;
-CBUFFER_END
-
 RWTexture2D<float1> _Result1;
 
 Texture2D<float4> _Source4;

ScriptableRenderPipeline/Core/CoreRP/Resources/GPUCopy.cs

 
         static readonly int _Result1 = Shader.PropertyToID("_Result1");
         static readonly int _Source4 = Shader.PropertyToID("_Source4");
-        static readonly int _Size = Shader.PropertyToID("_Size");
-                var s = new Vector4(size.x, size.y, 1f / size.x, 1f / size.y);
-                cmd.SetComputeVectorParam(m_Shader, _Size, s);
                 cmd.SetComputeTextureParam(m_Shader, k_SampleKernel_xyzw2x, _Source4, source);
                 cmd.SetComputeTextureParam(m_Shader, k_SampleKernel_xyzw2x, _Result1, target);
                 cmd.DispatchCompute(m_Shader, k_SampleKernel_xyzw2x, (int)Mathf.Max((size.x) / 8, 1), (int)Mathf.Max((size.y) / 8, 1), 1);

ScriptableRenderPipeline/Core/CoreRP/Resources/GPUCopyAsset.cs

             csc.AppendLine("        public GPUCopy(ComputeShader shader)");
             csc.AppendLine("        {");
             csc.AppendLine("            m_Shader = shader;");
-            csm.AppendLine("        static readonly int _Size = Shader.PropertyToID(\"_Size\");");
             for (var i = 0; i < operations.Length; i++)
             {
                 var o = operations[i];
                 // CSharp method
                 csm.AppendLine(string.Format(@"        public void SampleCopyChannel_{0}2{1}(CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier target, Vector2 size)", channelName, o.subscript));
                 csm.AppendLine("            {");
-                csm.AppendLine("                var s = new Vector4(size.x, size.y, 1f / size.x, 1f / size.y);");
-                csm.AppendLine("                cmd.SetComputeVectorParam(m_Shader, _Size, s);");
                 csm.AppendLine(string.Format("                cmd.SetComputeTextureParam(m_Shader, {0}, _Source{1}, source);", kernelIndexName, o.sourceChannel.ToString()));
                 csm.AppendLine(string.Format("                cmd.SetComputeTextureParam(m_Shader, {0}, _Result{1}, target);", kernelIndexName, o.targetChannel.ToString()));
                 csm.AppendLine(string.Format("                cmd.DispatchCompute(m_Shader, {0}, (int)Mathf.Max((size.x) / {1}, 1), (int)Mathf.Max((size.y) / {1}, 1), 1);", kernelIndexName, k_KernelSize.ToString()));
             cc.AppendLine(@"// Autogenerated file. Do not edit by hand");
             cc.AppendLine();
             cc.AppendLine(@"#include ""../ShaderLibrary/Common.hlsl""");
-            cc.AppendLine();
-            cc.AppendLine(@"SamplerState sampler_LinearClamp;");
-            cc.AppendLine();
-            cc.AppendLine(@"CBUFFER_START(cb)");
-            cc.AppendLine(@"    float4 _Size;");
-            cc.AppendLine(@"CBUFFER_END");
             cc.AppendLine(ccp.ToString()); // Properties
             cc.AppendLine(cck.ToString()); // Kernels
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

 
             m_ActualWidth = camera.pixelWidth;
             m_ActualHeight = camera.pixelHeight;
+            var screenWidth = m_ActualWidth;
+            var screenHeight = m_ActualHeight;
-                m_ActualWidth = XRSettings.eyeTextureWidth;
-                m_ActualHeight = XRSettings.eyeTextureHeight;
+                screenWidth = XRSettings.eyeTextureWidth;
+                screenHeight = XRSettings.eyeTextureHeight;
+
+                var xrDesc = XRSettings.eyeTextureDesc;
+                m_ActualWidth = xrDesc.width;
+                m_ActualHeight = xrDesc.height;
             }
 
             // Unfortunately sometime (like in the HDCameraEditor) HDUtils.hdrpSettings can be null because of scripts that change the current pipeline...
             m_CameraScaleBias.x = (float)m_ActualWidth / maxWidth;
             m_CameraScaleBias.y = (float)m_ActualHeight / maxHeight;
 
-            screenSize = new Vector4(m_ActualWidth, m_ActualHeight, 1.0f / m_ActualWidth, 1.0f / m_ActualHeight);
+            screenSize = new Vector4(screenWidth, screenHeight, 1.0f / screenWidth, 1.0f / screenHeight);
         }
 
         // Warning: different views can use the same camera!