Camera stacking support for the 2D Renderer

TestProjects/UniversalGraphicsTest/Assets/Test/Runtime/Renderer2DTests.cs

@@ -0,0 +1,117 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering.Universal;
+using UnityEngine.Rendering.Universal;
+
+[TestFixture]
+class Renderer2DTests
+{
+    GameObject m_BaseObj;
+    GameObject m_OverlayObj;
+    Camera m_BaseCamera;
+    Camera m_OverlayCamera;
+    UniversalAdditionalCameraData m_BaseCameraData;
+    UniversalAdditionalCameraData m_OverlayCameraData;
+
+    [SetUp]
+    public void Setup()
+    {
+        m_BaseObj = new GameObject();
+        m_BaseCamera = m_BaseObj.AddComponent<Camera>();
+        m_BaseCameraData = m_BaseObj.AddComponent<UniversalAdditionalCameraData>();
+
+        m_BaseCamera.allowHDR = false;
+        m_BaseCameraData.SetRenderer(3);    // 2D Renderer. See the list of Renderers in CommonAssets/UniversalRPAsset.
+        m_BaseCameraData.renderType = CameraRenderType.Base;
+        m_BaseCameraData.renderPostProcessing = false;
+
+        m_OverlayObj = new GameObject();
+        m_OverlayCamera = m_OverlayObj.AddComponent<Camera>();
+        m_OverlayCameraData = m_OverlayObj.AddComponent<UniversalAdditionalCameraData>();
+
+        m_OverlayCamera.allowHDR = false;
+        m_OverlayCameraData.SetRenderer(3);    // 2D Renderer. See the list of Renderers in CommonAssets/UniversalRPAsset.
+        m_OverlayCameraData.renderType = CameraRenderType.Overlay;
+        m_OverlayCameraData.renderPostProcessing = false;
+    }
+
+    [TearDown]
+    public void Cleanup()
+    {
+        Object.DestroyImmediate(m_OverlayObj);
+        Object.DestroyImmediate(m_BaseObj);
+    }
+
+    [Test]
+    public void BaseRendererDoesNotCreateRenderTexturesIfStackIsEmpty()
+    {
+        m_BaseCamera.Render();
+
+        Renderer2D baseRenderer = m_BaseCameraData.scriptableRenderer as Renderer2D;
+
+        Assert.IsFalse(baseRenderer.createColorTexture);
+        Assert.AreEqual(RenderTargetHandle.CameraTarget.Identifier(), baseRenderer.cameraColorTarget);
+
+        Assert.IsFalse(baseRenderer.createDepthTexture);
+        Assert.AreEqual(RenderTargetHandle.CameraTarget.Identifier(), baseRenderer.cameraDepth);
+    }
+
+    [Test]
+    public void BaseRendererCreatesRenderTexturesIfStackIsNotEmpty()
+    {
+        m_BaseCameraData.cameraStack.Add(m_OverlayCamera);
+
+        m_BaseCamera.Render();
+
+        Renderer2D baseRenderer = m_BaseCameraData.scriptableRenderer as Renderer2D;
+
+        Assert.IsTrue(baseRenderer.createColorTexture);
+        Assert.AreNotEqual(RenderTargetHandle.CameraTarget.Identifier(), baseRenderer.cameraColorTarget);
+
+        Assert.IsTrue(baseRenderer.createDepthTexture);
+        Assert.AreNotEqual(RenderTargetHandle.CameraTarget.Identifier(), baseRenderer.cameraDepth);
+    }
+
+    [Test]
+    public void BaseRendererUsesDepthAttachmentOfColorTextureIfNoDepthTextureCreated()
+    {
+        m_BaseCameraData.renderPostProcessing = true;   // This will make the renderer create color texture.
+
+        m_BaseCamera.Render();
+
+        Renderer2D baseRenderer = m_BaseCameraData.scriptableRenderer as Renderer2D;
+
+        Assert.IsTrue(baseRenderer.createColorTexture);
+        Assert.AreNotEqual(RenderTargetHandle.CameraTarget.Identifier(), baseRenderer.cameraColorTarget);
+
+        Assert.IsFalse(baseRenderer.createDepthTexture);
+        Assert.AreEqual(baseRenderer.cameraColorTarget, baseRenderer.cameraDepth);
+    }
+
+    [Test]
+    public void OverlayRendererUsesRenderTexturesFromBase()
+    {
+        m_BaseCameraData.cameraStack.Add(m_OverlayCamera);
+
+        m_BaseCamera.Render();
+
+        Renderer2D baseRenderer = m_BaseCameraData.scriptableRenderer as Renderer2D;
+        Renderer2D overlayRenderer = m_OverlayCameraData.scriptableRenderer as Renderer2D;
+
+        Assert.AreEqual(baseRenderer.cameraColorTarget, overlayRenderer.cameraColorTarget);
+        Assert.AreEqual(baseRenderer.cameraDepth, overlayRenderer.cameraDepth);
+    }
+
+    [Test]
+    public void OverlayRendererSetsTheCreateTextureFlags()
+    {
+        m_BaseCameraData.cameraStack.Add(m_OverlayCamera);
+
+        m_BaseCamera.Render();
+
+        Renderer2D overlayRenderer = m_OverlayCameraData.scriptableRenderer as Renderer2D;
+
+        Assert.IsTrue(overlayRenderer.createColorTexture);
+        Assert.IsTrue(overlayRenderer.createDepthTexture);
+    }
+}

com.unity.render-pipelines.universal/CHANGELOG.md

@@ -55,6 +55,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - DepthOnlyPass, CopyDepthPass and CopyColorPass now use OnCameraSetup() instead of Configure() to set up their passes before executing as they only need to get their rendertextures once per camera instead of once per eye.
 - Updated shaders to be compatible with Microsoft's DXC.
 - Mesh GPU Instancing option is now hidden from the particles system renderer as this feature is not supported by URP.
+- The 2D Renderer now supports camera stacking.
 
 ### Fixed
 - Fixed an issue where linear to sRGB conversion occurred twice on certain Android devices.

com.unity.render-pipelines.universal/Editor/2D/PixelPerfectCameraEditor.cs

@@ -1,6 +1,7 @@
 using System;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering.Universal;
+using UnityEngine.Rendering.Universal;
 
 namespace UnityEditor.Experimental.Rendering.Universal
 {
@@ -19,6 +20,7 @@ private class Style
             public GUIContent stretchFill = new GUIContent("Stretch Fill", "If enabled, expands the viewport to fit the screen resolution while maintaining the viewport aspect ratio.");
             public GUIContent currentPixelRatio = new GUIContent("Current Pixel Ratio", "Ratio of the rendered Sprites compared to their original size.");
             public GUIContent runInEditMode = new GUIContent("Run In Edit Mode", "Enable this to preview Camera setting changes in Edit Mode. This will cause constant changes to the Scene while active.");
+            public const string cameraStackingWarning = "Pixel Perfect Camera won't function properly if stacked with another camera.";
 
             public GUIStyle centeredLabel;
 
@@ -45,6 +47,7 @@ public Style()
 
         private Vector2 m_GameViewSize = Vector2.zero;
         private GUIContent m_CurrentPixelRatioValue;
+        bool m_CameraStacking;
 
         private void LazyInit()
         {
@@ -55,6 +58,26 @@ private void LazyInit()
                 m_CurrentPixelRatioValue = new GUIContent();
         }
 
+        void CheckForCameraStacking()
+        {
+            m_CameraStacking = false;
+
+            PixelPerfectCamera obj = target as PixelPerfectCamera;
+            UniversalAdditionalCameraData cameraData = null;
+            obj?.TryGetComponent(out cameraData);
+
+            if (cameraData == null)
+                return;
+
+            if (cameraData.renderType == CameraRenderType.Base)
+            {
+                var cameraStack = cameraData.cameraStack;
+                m_CameraStacking = cameraStack != null ? cameraStack.Count > 0 : false;
+            }
+            else if (cameraData.renderType == CameraRenderType.Overlay)
+                m_CameraStacking = true;
+        }
+
         public void OnEnable()
         {
             m_AssetsPPU = serializedObject.FindProperty("m_AssetsPPU");
@@ -92,6 +115,12 @@ public override void OnInspectorGUI()
 
             serializedObject.Update();
 
+            if (Event.current.type == EventType.Layout)
+                CheckForCameraStacking();
+
+            if (m_CameraStacking)
+                EditorGUILayout.HelpBox(Style.cameraStackingWarning, MessageType.Warning);
+
             EditorGUILayout.PropertyField(m_AssetsPPU, m_Style.assetsPPU);
             if (m_AssetsPPU.intValue <= 0)
                 m_AssetsPPU.intValue = 1;

com.unity.render-pipelines.universal/Runtime/2D/Passes/Render2DLightingPass.cs

@@ -135,7 +135,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
 
                     // Start Rendering
                     if (lightStats.totalNormalMapUsage > 0)
-                        RendererLighting.RenderNormals(context, renderingData.cullResults, normalsDrawSettings, filterSettings);
+                        RendererLighting.RenderNormals(context, renderingData.cullResults, normalsDrawSettings, filterSettings, depthAttachment);
 
                     cmd.Clear();
                     if (lightStats.totalLights > 0)
@@ -147,7 +147,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
                         RendererLighting.ClearDirtyLighting(cmd, lightStats.blendStylesUsed);
                     }
 
-                    CoreUtils.SetRenderTarget(cmd, colorAttachment, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, ClearFlag.None, Color.white);
+                    CoreUtils.SetRenderTarget(cmd, colorAttachment, depthAttachment, ClearFlag.None, Color.white);
                     context.ExecuteCommandBuffer(cmd);
 
                     Profiler.BeginSample("RenderSpritesWithLighting - Draw Transparent Renderers");
@@ -158,7 +158,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
                     {
 
                         cmd.Clear();
-                        RendererLighting.RenderLightVolumes(camera, cmd, layerToRender, colorAttachment, lightStats.blendStylesUsed);
+                        RendererLighting.RenderLightVolumes(camera, cmd, layerToRender, colorAttachment, depthAttachment, lightStats.blendStylesUsed);
                         context.ExecuteCommandBuffer(cmd);
                         cmd.Clear();
                     }
@@ -180,7 +180,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
                 CommandBuffer cmd = CommandBufferPool.Get("Render Unlit");
                 DrawingSettings unlitDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
 
-                CoreUtils.SetRenderTarget(cmd, colorAttachment, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, ClearFlag.None, Color.white);
+                CoreUtils.SetRenderTarget(cmd, colorAttachment, depthAttachment, ClearFlag.None, Color.white);
                 cmd.SetGlobalTexture("_ShapeLightTexture0", Texture2D.blackTexture);
                 cmd.SetGlobalTexture("_ShapeLightTexture1", Texture2D.blackTexture);
                 cmd.SetGlobalTexture("_ShapeLightTexture2", Texture2D.blackTexture);

com.unity.render-pipelines.universal/Runtime/2D/Passes/Utility/RendererLighting.cs

@@ -106,7 +106,7 @@ static public void CreateNormalMapRenderTexture(CommandBuffer cmd)
             descriptor.useMipMap = false;
             descriptor.autoGenerateMips = false;
             descriptor.depthBufferBits = 0;
-            descriptor.msaaSamples = 1;
+            descriptor.msaaSamples = s_RenderingData.cameraData.cameraTargetDescriptor.msaaSamples;
             descriptor.dimension = TextureDimension.Tex2D;
 
             cmd.GetTemporaryRT(s_NormalsTarget.id, descriptor, FilterMode.Bilinear);
@@ -184,7 +184,7 @@ static public void ReleaseRenderTextures(CommandBuffer cmd)
         }
 
 
-        static private void RenderShadows(CommandBuffer cmdBuffer, int layerToRender, Light2D light, float shadowIntensity, RenderTargetIdentifier renderTexture)
+        static private void RenderShadows(CommandBuffer cmdBuffer, int layerToRender, Light2D light, float shadowIntensity, RenderTargetIdentifier renderTexture, RenderTargetIdentifier depthTexture)
         {
             cmdBuffer.SetGlobalFloat("_ShadowIntensity", 1 - light.shadowIntensity);
             cmdBuffer.SetGlobalFloat("_ShadowVolumeIntensity", 1 - light.shadowVolumeIntensity);
@@ -268,7 +268,7 @@ static private void RenderShadows(CommandBuffer cmdBuffer, int layerToRender, Li
                 }
 
                 ReleaseShadowRenderTexture(cmdBuffer);
-                cmdBuffer.SetRenderTarget(renderTexture);
+                cmdBuffer.SetRenderTarget(renderTexture, depthTexture);
             }
         }
 
@@ -287,7 +287,7 @@ static private bool RenderLightSet(Camera camera, int blendStyleIndex, CommandBu
                         Mesh lightMesh = light.GetMesh();
                         if (lightMesh != null)
                         {
-                            RenderShadows(cmdBuffer, layerToRender, light, light.shadowIntensity, renderTexture);
+                            RenderShadows(cmdBuffer, layerToRender, light, light.shadowIntensity, renderTexture, renderTexture);
 
                             renderedAnyLight = true;
 
@@ -322,7 +322,7 @@ static private bool RenderLightSet(Camera camera, int blendStyleIndex, CommandBu
             return renderedAnyLight;
         }
 
-        static private void RenderLightVolumeSet(Camera camera, int blendStyleIndex, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTexture, List<Light2D> lights)
+        static private void RenderLightVolumeSet(Camera camera, int blendStyleIndex, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTexture, RenderTargetIdentifier depthTexture, List<Light2D> lights)
         {
             if (lights.Count > 0)
             {
@@ -341,7 +341,7 @@ static private void RenderLightVolumeSet(Camera camera, int blendStyleIndex, Com
                                 Mesh lightMesh = light.GetMesh();
                                 if (lightMesh != null)
                                 {
-                                    RenderShadows(cmdBuffer, layerToRender, light, light.shadowVolumeIntensity, renderTexture);
+                                    RenderShadows(cmdBuffer, layerToRender, light, light.shadowVolumeIntensity, renderTexture, depthTexture);
 
                                     if (light.lightType == Light2D.LightType.Sprite && light.lightCookieSprite != null && light.lightCookieSprite.texture != null)
                                         cmdBuffer.SetGlobalTexture("_CookieTex", light.lightCookieSprite.texture);
@@ -480,10 +480,10 @@ static public void ClearDirtyLighting(CommandBuffer cmdBuffer, uint blendStylesU
             }
         }
 
-        static public void RenderNormals(ScriptableRenderContext renderContext, CullingResults cullResults, DrawingSettings drawSettings, FilteringSettings filterSettings)
+        static public void RenderNormals(ScriptableRenderContext renderContext, CullingResults cullResults, DrawingSettings drawSettings, FilteringSettings filterSettings, RenderTargetIdentifier depthTarget)
         {
             var cmd = CommandBufferPool.Get("Clear Normals");
-            cmd.SetRenderTarget(s_NormalsTarget.Identifier());
+            cmd.SetRenderTarget(s_NormalsTarget.Identifier(), depthTarget);
             cmd.ClearRenderTarget(true, true, k_NormalClearColor);
             renderContext.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
@@ -529,7 +529,7 @@ static public void RenderLights(Camera camera, CommandBuffer cmdBuffer, int laye
             }
         }
 
-        static public void RenderLightVolumes(Camera camera, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTarget, uint blendStylesUsed)
+        static public void RenderLightVolumes(Camera camera, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTarget, RenderTargetIdentifier depthTarget, uint blendStylesUsed)
         {
             for (int i = 0; i < s_BlendStyles.Length; ++i)
             {
@@ -545,6 +545,7 @@ static public void RenderLightVolumes(Camera camera, CommandBuffer cmdBuffer, in
                     cmdBuffer,
                     layerToRender,
                     renderTarget,
+                    depthTarget,
                     Light2D.GetLightsByBlendStyle(i)                  
                 );