[Port] [6000.0] Graphics/bugfix/copypass texture array

Author: svc-reach-platform-support

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphUtilsBlit.cs

@@ -20,6 +20,16 @@ public static bool CanAddCopyPassMSAA()
             return Blitter.CanCopyMSAA();
         }
 
+        /// <summary>
+        /// Checks if the shader features required by the MSAA version of the copy pass is supported on current platform.
+        /// </summary>
+        /// <param name="sourceDesc">The texture description of the that will be copied from.</param>
+        /// <returns>Returns true if the shader features required by the copy pass is supported for MSAA, otherwise will it return false.</returns>
+        public static bool CanAddCopyPassMSAA(in TextureDesc sourceDesc)
+        {
+            return Blitter.CanCopyMSAA(sourceDesc);
+        }
+
         class CopyPassData
         {
             public bool isMSAA;
@@ -80,7 +90,7 @@ public static void AddCopyPass(
             //       It would have 1 if the MSAA pass is not able to be used for target and 2 otherwise.
             //       https://docs.unity3d.com/2017.4/Documentation/Manual/SL-ShaderCompileTargets.html
             //       https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-to-get-sample-position
-            if (isMSAA && !Blitter.CanCopyMSAA())
+            if (isMSAA && !Blitter.CanCopyMSAA(sourceDesc))
                 throw new ArgumentException("Target does not support MSAA for AddCopyPass. Please use the blit alternative or use non MSAA textures.");
 
             using (var builder = graph.AddRasterRenderPass<CopyPassData>(passName, out var passData, file, line))

Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blitter.cs

@@ -5,6 +5,7 @@
 using System.Text.RegularExpressions;
 using UnityEngine.Rendering.RenderGraphModule.Util;
 using UnityEngine.Rendering.RenderGraphModule;
+
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
@@ -285,10 +286,9 @@ static internal void DrawQuad(CommandBuffer cmd, Material material, int shaderPa
 
         internal static bool CanCopyMSAA()
         {
-            //Temporary disable most msaa copies as we fix UUM-67324 which is a bit more involved due to the internal work required
-            GraphicsDeviceType deviceType = SystemInfo.graphicsDeviceType;
-            if (deviceType != GraphicsDeviceType.Metal || deviceType != GraphicsDeviceType.Vulkan)
+            if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.PlayStation4)
             {
+                // Will be done later, see: UUM-97281
                 return false;
             }
 
@@ -298,10 +298,34 @@ internal static bool CanCopyMSAA()
             return s_Copy.passCount == 2;
         }
 
+        internal static bool CanCopyMSAA(in TextureDesc sourceDesc)
+        {
+
+            // Real native renderpass platforms
+            // TODO: Expose this through systeminfo
+            bool hasRenderPass =
+                SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal
+                || SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan
+                || SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D12;
+
+            if (SystemInfo.supportsMultisampleAutoResolve &&
+                !hasRenderPass && sourceDesc.bindTextureMS == false)
+            {
+                // If we have autoresolve it means msaa rendertextures render as MSAA but  magically resolve in the driver when accessed as a texture, the MSAA surface is fully hidden inside the GFX device
+                // this is contrary to most platforms where the resolve magic on reading happens in the engine layer (and thus allocates proper multi sampled and resolve surfaces the engine can access)
+                // So in the cases of auto resolving, and a renderpass framebuffer fetch emulation layer we can't correctly access the individual unresolved msaa samples and thus don't allow this case here
+                // Note: In practice the above check mostly triggers on GLES.
+                return false;
+            }
+
+            return CanCopyMSAA();
+        }
+
         /// <summary>
         /// Copy a texture to another texture using framebuffer fetch.
         /// </summary>
         /// <param name="cmd">Command Buffer used for rendering.</param>
+        /// <param name="isMSAA">Use the MSAA variant of the copy shader (otherwise single sample is used).</param>
         /// <param name="force2DForXR">Disable the special handling when XR is active where the source and destination are considered array
         /// textures with a slice for each eye. Setting this to true will consider source and destination as regular 2D textures. When XR is
         /// disabled, textures are always 2D so forcing them to 2D has no impact.</param>

Tests/SRPTests/Projects/UniversalGraphicsTest_Foundation/Assets/Scenes/315_CoreCopyAndBlit/CoreCopyBlitTestFeature.cs

@@ -13,12 +13,15 @@ class CustomRenderPass : ScriptableRenderPass
     {
         Material m_Material;
         Material m_materialTint;
+        Material m_materialDummyTint;
 
         int m_Pass;
-        public void init(Material material, Material materialTint, int pass)
+        public void init(Material material, Material materialTint, Material materialDummyTint, int pass)
         {
             m_Material = material;
             m_materialTint = materialTint;
+            m_materialDummyTint = materialDummyTint;
+
             m_Pass = pass;
         }
 
@@ -33,7 +36,7 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
 
             var mip = 0;
 
-            if (textureDesc.msaaSamples != MSAASamples.None && RenderGraphUtils.CanAddCopyPassMSAA())
+            if (textureDesc.msaaSamples != MSAASamples.None && RenderGraphUtils.CanAddCopyPassMSAA(textureDesc))
             {
                 textureDesc.name = "Temp FBFetchMSAA";
                 TextureHandle fbFetchDestinationMSAA = renderGraph.CreateTexture(textureDesc);
@@ -44,13 +47,29 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
                 // Tint the temp texture, this works through alpha blending on the blit material and thus ensures we're not just sampling
                 // an auto-resolved surface or something but that the copied pixels are good for "framebuffer operations"
                 BlitMaterialParameters param = new BlitMaterialParameters(TextureHandle.nullHandle, fbFetchDestinationMSAA, m_materialTint, 0);
-                renderGraph.AddBlitPass(param);
+                renderGraph.AddBlitPass(param, passName: "Tint Temp Texture Blit");
 
                 // Copy the whole thing back to the main color texture
                 renderGraph.AddCopyPass(fbFetchDestinationMSAA, resourceData.activeColorTexture, 0, 0, mip, mip, "Copy MSAA 2");
+
+                // This blit does nothing, it tints the color buffer by 1,1,1 it just ensures the blit pass below renders correctly
+                // I "assume" it ensures vulkan thinks the color buffer has changed and it will correctly pick up the values in the inverse blit pass below.
+                // Without this dummy pass it actually picks up the untinted values (i.e. the results of the copy pass above are not visible)
+                // My suspicion is that this is because the copy pass goes through the renderpass api and the blit goes through setRT
+                // we've seen similar issues before in other code where mixing renderpasses/setRT confused things.
+                // When looking at this in renderdoc without this dummy pass you will see:
+                // Pass "DrawOpaqueObjects": Resolves to 2d color attachment #x
+                // Pass "Copy MSAA 2": Resolves to 2d color attachment #y
+                // Pass "Blit inverse using Material": Reads from color attachment #x < so it incorrectly picks an old version X istead of Y (note: this is the resolve target specifically the MSAA samples target seems to be correct?)
+                if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan)
+                {
+                    BlitMaterialParameters paramDummy = new BlitMaterialParameters(TextureHandle.nullHandle, resourceData.activeColorTexture, m_materialDummyTint, 0);
+                    renderGraph.AddBlitPass(paramDummy, passName: "Dummy Blit");
+                }
             }
             else
             {
+                // If we can't do MSAA copies that part of the test doesn't apply. But we just tint the buffer here so the ref images are still the same for all cases
                 BlitMaterialParameters param = new BlitMaterialParameters(TextureHandle.nullHandle, resourceData.activeColorTexture, m_materialTint, 0);
                 renderGraph.AddBlitPass(param);
             }
@@ -84,11 +103,16 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
     CustomRenderPass m_ScriptablePass;
     public Material material = null;
     public Material materialTint = null;
+    private Material materialDummy = null;
+
     public int pass = 0;
     /// <inheritdoc/>
     public override void Create()
     {
         m_ScriptablePass = new CustomRenderPass();
+        materialDummy = new Material(materialTint);
+        materialDummy.SetColor("_Color", Color.white);
+        materialDummy.SetColor("_EyeOneColor", Color.white);
 
         // Configures where the render pass should be injected.
         m_ScriptablePass.renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
@@ -99,7 +123,7 @@ public override void Create()
     public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
     {
         if (material == null || materialTint == null) return;
-        m_ScriptablePass.init(material, materialTint, pass);
+        m_ScriptablePass.init(material, materialTint, materialDummy, pass);
         m_ScriptablePass.requiresIntermediateTexture = true;
         renderer.EnqueuePass(m_ScriptablePass);
     }