[Port] [6000.5] Improve UI/UX of Renderer Features with the Tile-Only Mode and bugfixes

Author: svc-reach-platform-support

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

@@ -1130,7 +1130,7 @@ void PropagateTextureUVOrigin()
                                 var firstStoreAttachmentName = graph.m_ResourcesForDebugOnly.GetRenderGraphResourceName(firstStoreNativePassAttachment.handle);
                                 var name = graph.m_ResourcesForDebugOnly.GetRenderGraphResourceName(nativePassAttachment.handle);
 
-                                throw new InvalidOperationException($"From pass '{contextData.passNames[nativePassData.firstGraphPass]}' to pass '{contextData.passNames[nativePassData.lastGraphPass]}' when trying to store resource '{name}' of type {nativePassAttachment.handle.type} at index {nativePassAttachment.handle.index} - "
+                                throw new InvalidOperationException($"From pass '{contextData.GetPassName(nativePassData.firstGraphPass)}' to pass '{contextData.GetPassName(nativePassData.lastGraphPass)}' when trying to store resource '{name}' of type {nativePassAttachment.handle.type} at index {nativePassAttachment.handle.index} - "
                                                                     + RenderGraph.RenderGraphExceptionMessages.IncompatibleTextureUVOriginStore(firstStoreAttachmentName, storeUVOrigin, name, resData.textureUVOrigin));
                             }
 

Packages/com.unity.render-pipelines.universal/Editor/RendererFeatures/FullScreenPassRendererFeatureEditor.cs

@@ -2,8 +2,8 @@
 using UnityEditor.RenderPipelines.Core;
 using UnityEditor.ShaderGraph;
 using UnityEngine;
+using UnityEngine.Rendering;
 using UnityEngine.Rendering.Universal;
-using static UnityEditor.Rendering.InspectorCurveEditor;
 
 namespace UnityEditor.Rendering.Universal
 {
@@ -13,7 +13,7 @@ namespace UnityEditor.Rendering.Universal
     /// </summary>
     [UnityEngine.Scripting.APIUpdating.MovedFrom("")]
     [CustomEditor(typeof(FullScreenPassRendererFeature))]
-    public class FullScreenPassRendererFeatureEditor : Editor
+    public class FullScreenPassRendererFeatureEditor : Editor, IOwningRendererDataConsumer
     {
         private SerializedProperty m_InjectionPointProperty;
         private SerializedProperty m_RequirementsProperty;
@@ -22,13 +22,26 @@ public class FullScreenPassRendererFeatureEditor : Editor
         private SerializedProperty m_PassMaterialProperty;
         private SerializedProperty m_PassIndexProperty;
         private bool m_ShowDuplicateColorCopyWarning;
+        private bool m_ShowFetchColorBufferTileOnlyError;
+        private bool m_ShowRequirementsColorTileOnlyError;
+        private bool m_ShowRequirementsDepthWithoutNormalTileOnlyError;
+        private bool m_ShowRequirementsMotionWithoutNormalTileOnlyError;
 
         private static readonly GUIContent k_InjectionPointGuiContent = new GUIContent("Injection Point", "Specifies where in the frame this pass will be injected.");
         private static readonly GUIContent k_RequirementsGuiContent = new GUIContent("Requirements", "A mask of URP internal textures that will need to be generated and bound for sampling.\n\nNote that 'Color' here corresponds to '_CameraOpaqueTexture' so most of the time you will want to use the 'Fetch Color Buffer' option instead.");
         private static readonly GUIContent k_FetchColorBufferGuiContent = new GUIContent("Fetch Color Buffer", "Enable this if the assigned material will need to sample the active color target. The active color will be bound to the '_BlitTexture' shader property for sampling. Note that this will introduce an internal color copy pass.");
         private static readonly GUIContent k_BindDepthStencilAttachmentGuiContent = new GUIContent("Bind Depth-Stencil", "Enable this to bind the active camera's depth-stencil attachment to the framebuffer (only use this if depth-stencil ops are used by the assigned material as this could have a performance impact).");
         private static readonly GUIContent k_PassMaterialGuiContent = new GUIContent("Pass Material", "The material used to render the full screen pass.");
         private static readonly GUIContent k_PassGuiContent = new GUIContent("Pass", "The name of the shader pass to use from the assigned material.");
+        private static readonly string k_FetchColorBufferIncompatibleWithTileOnlyMode = L10n.Tr("Fetch Color Buffer is incompatible with the enabled 'Tile-Only Mode'. Disable this setting.");
+        private static readonly string k_RequirementsColorIncompatibleWithTileOnlyMode = L10n.Tr("Color is incompatible with the enabled 'Tile-Only Mode'. Clear Color from Requirements.");
+        private static readonly string k_RequirementsDepthWithoutNormalIncompatibleWithTileOnlyMode = L10n.Tr("Depth without Normal is incompatible with the enabled 'Tile-Only Mode'. Add Normal to Requirements or clear Depth.");
+        private static readonly string k_RequirementsMotionWithoutNormalIncompatibleWithTileOnlyMode = L10n.Tr("Motion without Normal is incompatible with the enabled 'Tile-Only Mode'. Add Normal to Requirements or clear Motion.");
+
+        /// <summary>
+        /// The renderer data that owns the feature when the inspector is drawn.
+        /// </summary>
+        public ScriptableRendererData owningRendererData { get; set; }
 
         static readonly GUIContent k_NewFullscreenMaterialButtonText = EditorGUIUtility.TrTextContent("New", "Creates a new Fullscreen material.");
         static readonly string k_NewBlitShaderText = "SRP Blit Shader";
@@ -58,19 +71,38 @@ public override void OnInspectorGUI()
                 currentFeature.passIndex = 0;
 
             EditorGUILayout.PropertyField(m_InjectionPointProperty, k_InjectionPointGuiContent);
-            EditorGUILayout.PropertyField(m_RequirementsProperty, k_RequirementsGuiContent);
+            EditorGUILayout.PropertyField(m_RequirementsProperty, k_RequirementsGuiContent);            
+
+            var requirements = m_RequirementsProperty.GetEnumValue<ScriptableRenderPassInput>();
+            var rendererData = (this as IOwningRendererDataConsumer).owningRendererData as UniversalRendererData;
+
+            if (Event.current.type == EventType.Layout)
+            {
+                bool tileOnlyMode = rendererData != null && rendererData.tileOnlyMode;
+                m_ShowFetchColorBufferTileOnlyError = tileOnlyMode && m_FetchColorBufferProperty.boolValue;
+                m_ShowRequirementsColorTileOnlyError = tileOnlyMode && (requirements & ScriptableRenderPassInput.Color) != ScriptableRenderPassInput.None;
+                // Depth without Normal triggers a depth copy; with Normal, URP does a prepass instead (see comment on k_RequirementsDepthWithoutNormalIncompatibleWithTileOnlyMode).
+                m_ShowRequirementsDepthWithoutNormalTileOnlyError = tileOnlyMode && (requirements & ScriptableRenderPassInput.Depth) != ScriptableRenderPassInput.None && (requirements & ScriptableRenderPassInput.Normal) == ScriptableRenderPassInput.None;
+                m_ShowRequirementsMotionWithoutNormalTileOnlyError = tileOnlyMode && (requirements & ScriptableRenderPassInput.Motion) != ScriptableRenderPassInput.None && (requirements & ScriptableRenderPassInput.Normal) == ScriptableRenderPassInput.None;
+            }
+            if (m_ShowFetchColorBufferTileOnlyError)
+                EditorGUILayout.HelpBox(k_FetchColorBufferIncompatibleWithTileOnlyMode, MessageType.Error, true);
+            if (m_ShowRequirementsColorTileOnlyError)
+                EditorGUILayout.HelpBox(k_RequirementsColorIncompatibleWithTileOnlyMode, MessageType.Error, true);
+            if (m_ShowRequirementsDepthWithoutNormalTileOnlyError)
+                EditorGUILayout.HelpBox(k_RequirementsDepthWithoutNormalIncompatibleWithTileOnlyMode, MessageType.Error, true);
+            if (m_ShowRequirementsMotionWithoutNormalTileOnlyError)
+                EditorGUILayout.HelpBox(k_RequirementsMotionWithoutNormalIncompatibleWithTileOnlyMode, MessageType.Error, true);
+
             EditorGUILayout.PropertyField(m_FetchColorBufferProperty, k_FetchColorBufferGuiContent);
 
             if (Event.current.type == EventType.Layout)
             {
-                bool requestedColor = (m_RequirementsProperty.GetEnumValue<ScriptableRenderPassInput>() & ScriptableRenderPassInput.Color) != ScriptableRenderPassInput.None;
-                m_ShowDuplicateColorCopyWarning = requestedColor && m_FetchColorBufferProperty.boolValue;
+                m_ShowDuplicateColorCopyWarning = (requirements & ScriptableRenderPassInput.Color) != ScriptableRenderPassInput.None && m_FetchColorBufferProperty.boolValue;
             }
 
             if (m_ShowDuplicateColorCopyWarning)
-            {
                 EditorGUILayout.HelpBox("You request two different color textures: the opaque color texture via \"Requirements: Color\", and the current camera attachment via \"Fetch Color Buffer\". While this is allowed, we recommend disabling one of these two options for optimal performance.", MessageType.Warning, true);
-            }
 
             EditorGUILayout.PropertyField(m_BindDepthStencilAttachmentProperty, k_BindDepthStencilAttachmentGuiContent);
 

Packages/com.unity.render-pipelines.universal/Editor/RendererFeatures/OnTilePostProcessFeatureEditor.cs

@@ -1,25 +1,34 @@
+using UnityEngine.Rendering.Universal;
+
 namespace UnityEditor.Rendering.Universal
 {
     [CustomEditor(typeof(OnTilePostProcessFeature))]
-    internal class OnTilePostProcessFeatureEditor : Editor
+    internal class OnTilePostProcessFeatureEditor : Editor, IOwningRendererDataConsumer
     {
         #region Serialized Properties
         private SerializedProperty m_UseFallbackProperty;
         #endregion
 
         static class Styles
         {
-            public static readonly string k_NoSettingsHelpBox = L10n.Tr("This feature performs post-processing operation in tile memory. There are currently no available settings, they might be added later.");
-            public static readonly string k_NeedsTileOnlyMode = L10n.Tr("On Tile PostProcessing feature needs 'Tile-Only Mode' set on the Renderer. Otherwise, this render feature will fallback to texture sampling mode (slow off-tile rendering)");
+            public static readonly string k_NoSettingsHelpBox = L10n.Tr("Only pixel local post-processing effects are supported. For example color adjustments, vignette or film grain. There are currently no available settings.");
+            public static readonly string k_TileOnlyModeOffWarning = L10n.Tr("Tile-Only Mode is not enabled on this Renderer. This feature will fallback to texture sampling mode. This uses more GPU bandwidth and can reduce performance.");
         }
 
         private void OnEnable()
         {
         }
 
+        /// <summary>
+        /// The renderer data that owns the feature when the inspector is drawn.
+        /// </summary>
+        public ScriptableRendererData owningRendererData { get; set; }
+
         public override void OnInspectorGUI()
         {
-            EditorGUILayout.HelpBox(Styles.k_NeedsTileOnlyMode, MessageType.Info);
+            var rendererData = (this as IOwningRendererDataConsumer).owningRendererData as UniversalRendererData;
+            if (rendererData == null || !rendererData.tileOnlyMode)
+                EditorGUILayout.HelpBox(Styles.k_TileOnlyModeOffWarning, MessageType.Warning);
             EditorGUILayout.HelpBox(Styles.k_NoSettingsHelpBox, MessageType.Info);
         }
     }

Packages/com.unity.render-pipelines.universal/Editor/RendererFeatures/ScreenSpaceAmbientOcclusionEditor.cs

@@ -5,7 +5,7 @@
 namespace UnityEditor.Rendering.Universal
 {
     [CustomEditor(typeof(ScreenSpaceAmbientOcclusion))]
-    internal class ScreenSpaceAmbientOcclusionEditor : Editor
+    internal class ScreenSpaceAmbientOcclusionEditor : Editor, IOwningRendererDataConsumer
     {
         #region Serialized Properties
         private SerializedProperty m_AOMethod;
@@ -23,6 +23,14 @@ internal class ScreenSpaceAmbientOcclusionEditor : Editor
 
         private bool m_IsInitialized = false;
         private HeaderBool m_ShowQualitySettings;
+        private bool m_ShowAfterOpaqueTileOnlyError;
+
+        private static readonly string k_AfterOpaqueIncompatibleWithTileOnlyMode = L10n.Tr("'After Opaque' is incompatible with the enabled 'Tile-Only Mode'. Disable After Opaque.");
+
+        /// <summary>
+        /// The renderer data that owns the feature when the inspector is drawn.
+        /// </summary>
+        public ScriptableRendererData owningRendererData { get; set; }
 
         class HeaderBool
         {
@@ -123,6 +131,17 @@ public override void OnInspectorGUI()
 
                 EditorGUILayout.PropertyField(m_Downsample, Styles.Downsample);
                 EditorGUILayout.PropertyField(m_AfterOpaque, Styles.AfterOpaque);
+
+                if (Event.current.type == EventType.Layout)
+                {
+                    var rendererData = (this as IOwningRendererDataConsumer).owningRendererData as UniversalRendererData;
+                    bool tileOnlyMode = rendererData != null && rendererData.tileOnlyMode;
+                    bool afterOpaque = m_AfterOpaque.boolValue;
+                    m_ShowAfterOpaqueTileOnlyError = tileOnlyMode && afterOpaque;
+                }
+                if (m_ShowAfterOpaqueTileOnlyError)
+                    EditorGUILayout.HelpBox(k_AfterOpaqueIncompatibleWithTileOnlyMode, MessageType.Error, true);
+
                 EditorGUILayout.PropertyField(m_BlurQuality, Styles.BlurQuality);
                 EditorGUILayout.PropertyField(m_Samples, Styles.Samples);
 

Packages/com.unity.render-pipelines.universal/Editor/ScriptableRendererDataEditor.cs

@@ -194,7 +194,13 @@ private void DrawRendererFeature(int index, ref SerializedProperty renderFeature
                     }
 
                     EditorGUI.BeginChangeCheck();
+                    if (rendererFeatureEditor is IOwningRendererDataConsumer consumer)
+                    {
+                        consumer.owningRendererData = target as ScriptableRendererData;                        
+                    }
+                   
                     rendererFeatureEditor.OnInspectorGUI();
+                    
                     hasChangedProperties |= EditorGUI.EndChangeCheck();
 
                     EditorGUILayout.Space(EditorGUIUtility.singleLineHeight);
@@ -361,4 +367,13 @@ private void ForceSave()
             EditorUtility.SetDirty(target);
         }
     }
+
+    /// <summary>
+    /// Implement this interface on a custom Editor for a ScriptableRendererFeature to receive the renderer data that owns the feature when the inspector is drawn.
+    /// </summary>
+    internal interface IOwningRendererDataConsumer
+    {
+        /// <summary>The renderer data that contains this feature. Set by the drawer before OnInspectorGUI, cleared after.</summary>
+        public ScriptableRendererData owningRendererData { get; set; }
+    }
 }

Packages/com.unity.render-pipelines.universal/Runtime/Passes/ScreenSpaceAmbientOcclusionPass.cs

@@ -127,39 +127,12 @@ internal ScreenSpaceAmbientOcclusionPass()
             m_CurrentSettings = new ScreenSpaceAmbientOcclusionSettings();
         }
 
-        internal bool Setup(ScreenSpaceAmbientOcclusionSettings featureSettings, ScriptableRenderer renderer, Material material, Texture2D[] blueNoiseTextures)
+        internal bool Setup(ScreenSpaceAmbientOcclusionSettings featureSettings, ScreenSpaceAmbientOcclusionSettings.DepthSource depthSource, Material material, Texture2D[] blueNoiseTextures)
         {
             m_BlueNoiseTextures = blueNoiseTextures;
             m_Material = material;
             m_CurrentSettings = featureSettings;
-
-            // RenderPass Event + Source Settings (Depth / Depth&Normals
-            if (renderer is UniversalRenderer { usesDeferredLighting: true })
-            {
-                renderPassEvent = m_CurrentSettings.AfterOpaque ? RenderPassEvent.AfterRenderingOpaques : RenderPassEvent.AfterRenderingPrePasses;
-
-                m_CurrentSettings.Source = ScreenSpaceAmbientOcclusionSettings.DepthSource.DepthNormals;
-            }
-            else
-            {
-                // Rendering after PrePasses is usually correct except when depth priming is in play:
-                // then we rely on a depth resolve taking place after the PrePasses in order to have it ready for SSAO.
-                // Hence we set the event to RenderPassEvent.AfterRenderingPrePasses + 1 at the earliest.
-                renderPassEvent = m_CurrentSettings.AfterOpaque ? RenderPassEvent.BeforeRenderingTransparents : RenderPassEvent.AfterRenderingPrePasses + 1;
-            }
-
-            // Ask for a Depth or Depth + Normals textures
-            switch (m_CurrentSettings.Source)
-            {
-                case ScreenSpaceAmbientOcclusionSettings.DepthSource.Depth:
-                    ConfigureInput(ScriptableRenderPassInput.Depth);
-                    break;
-                case ScreenSpaceAmbientOcclusionSettings.DepthSource.DepthNormals:
-                    ConfigureInput(ScriptableRenderPassInput.Depth | ScriptableRenderPassInput.Normal); // need depthNormal prepass for forward-only geometry
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
+            m_CurrentSettings.Source = depthSource;
 
             // Blur settings
             switch (m_CurrentSettings.BlurQuality)
@@ -277,7 +250,6 @@ private class SSAOPassData
             internal MaterialPropertyBlock materialPropertyBlock;
             internal Material material;
             internal float directLightingStrength;
-            internal TextureHandle cameraColor;
             internal TextureHandle AOTexture;
             internal TextureHandle finalTexture;
             internal TextureHandle blurTexture;
@@ -399,7 +371,6 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
 
                 // Fill in the Pass data...
                 InitSSAOPassData(passData);
-                passData.cameraColor = resourceData.cameraColor;
                 passData.AOTexture = aoTexture;
                 passData.finalTexture = finalTexture;
                 passData.blurTexture = blurTexture;
@@ -409,13 +380,6 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
                 // Declare input textures
                 builder.SetRenderAttachment(passData.AOTexture, 0, AccessFlags.WriteAll);
 
-                // TODO: Refactor to eliminate the need for 'UseTexture'.
-                // Currently required only because 'PostProcessUtils.SetSourceSize' allocates an RTHandle,
-                // which expects a valid graphicsResource. Without this call, 'cameraColor.graphicsResource'
-                // may be null if it wasn't initialized in an earlier pass (e.g., DrawOpaque).
-                if (passData.cameraColor.IsValid())
-                    builder.UseTexture(passData.cameraColor, AccessFlags.Read);
-
                 if (cameraDepthTexture.IsValid())
                     builder.UseTexture(cameraDepthTexture, AccessFlags.Read);
 
@@ -427,8 +391,8 @@ public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer
 
                 builder.SetRenderFunc(static (SSAOPassData data, RasterGraphContext ctx) =>
                 {
-                    // Setup
-                    PostProcessUtils.SetGlobalShaderSourceSize(ctx.cmd, data.cameraData.cameraTargetDescriptor.width, data.cameraData.cameraTargetDescriptor.height, data.cameraColor);
+                    var desc = data.cameraData.cameraTargetDescriptor;
+                    PostProcessUtils.SetGlobalShaderSourceSize(ctx.cmd, desc.width, desc.height, desc.useDynamicScale);
 
                     if (data.cameraNormalsTexture.IsValid())
                         data.materialPropertyBlock.SetTexture(s_CameraNormalsTextureID, data.cameraNormalsTexture);