Fix opening "Project Settings > Graphics" caused RG Viewer to become empty

Fix https://jira.unity3d.com/browse/UUM-66952

Graphics Settings UI on URP needs to recreate the render pipeline whenever user changes the "Compatibility mode" checkbox in graphics settings. This change was being detected incorrectly, causing render pipeline to be recreated every time the tab is selected on URP, which in turn triggers RG Viewer to be refreshed. Fixed the issue and added a unit test for it.

Also did a minor adjustment of empty state texts based on QA & UX feedback.

Author: arttu-peltonen

Packages/com.unity.render-pipelines.core/Editor/RenderGraph/RenderGraphViewer.cs

@@ -127,6 +127,7 @@ static partial class Classes
         enum EmptyStateReason
         {
             None = 0,
+            NoGraphRegistered,
             NoExecutionRegistered,
             NoDataAvailable,
             WaitingForCameraRender,
@@ -137,7 +138,8 @@ enum EmptyStateReason
         static readonly string[] kEmptyStateMessages =
         {
             "",
-            L10n.Tr("The selected camera is not active. Activate the selected camera to display data in the Render Graph viewer."),
+            L10n.Tr("No Render Graph has been registered. The Render Graph Viewer is only functional when Render Graph API is in use."),
+            L10n.Tr("The selected camera has not rendered anything yet. Interact with the selected camera to display data in the Render Graph Viewer."),
             L10n.Tr("No data to display. Click refresh to capture data."),
             L10n.Tr("Waiting for the selected camera to render. Depending on the camera, you may need to trigger rendering by selecting the Scene or Game view."),
             L10n.Tr("No passes to display. Select a different Pass Filter to display contents."),
@@ -1399,6 +1401,12 @@ void RebuildGraphViewerUI()
             ClearGraphViewerUI();
             ClearEmptyStateMessage();
 
+            if (m_RegisteredGraphs.Count == 0)
+            {
+                SetEmptyStateMessage(EmptyStateReason.NoGraphRegistered);
+                return;
+            }
+
             if (!CaptureEnabled())
             {
                 SetEmptyStateMessage(EmptyStateReason.NoExecutionRegistered);

Packages/com.unity.render-pipelines.universal/Editor/Settings/PropertyDrawers/URPRenderGraphPropertyDrawer.cs

@@ -14,27 +14,29 @@ class RenderGraphPropertyDrawer : PropertyDrawer
         private const string k_EnableRenderCompatibilityModeLabel = "Compatibility Mode (Render Graph Disabled)";
         private const string k_EnableRenderCompatibilityModeHelpBoxLabel = "Unity no longer develops or improves the rendering path that does not use Render Graph API. Use the Render Graph API when developing new graphics features.";
 
+        bool m_EnableCompatibilityModeValue;
+
         /// <inheritdoc/>
         public override VisualElement CreatePropertyGUI(SerializedProperty property)
         {
             m_Root = new VisualElement();
             var enableCompatilityModeProp = property.FindPropertyRelative(k_EnableRenderCompatibilityPropertyName);
             var enableCompatibilityMode = new PropertyField(enableCompatilityModeProp, k_EnableRenderCompatibilityModeLabel);
 
-            // UITK raises ValueChangeCallback at bind time, so we need to ignore the first event
-            bool firstTime = true;
+            // UITK raises ValueChangeCallback at various times, so we need to track the actual value
+            m_EnableCompatibilityModeValue = enableCompatilityModeProp.boolValue;
 
             m_Root.Add(enableCompatibilityMode);
             enableCompatibilityMode.RegisterValueChangeCallback((onchanged) =>
             {
                 m_Root.Q<HelpBox>("HelpBoxWarning").style.display = (onchanged.changedProperty.boolValue) ? DisplayStyle.Flex : DisplayStyle.None;
-                if (firstTime)
+
+                bool newValue = onchanged.changedProperty.boolValue;
+                if (m_EnableCompatibilityModeValue != newValue)
                 {
-                    firstTime = false;
-                    return;
+                    m_EnableCompatibilityModeValue = newValue;
+                    GraphicsSettings.GetRenderPipelineSettings<RenderGraphSettings>()?.NotifyValueChanged(onchanged.changedProperty.name);
                 }
-
-                GraphicsSettings.GetRenderPipelineSettings<RenderGraphSettings>()?.NotifyValueChanged(onchanged.changedProperty.name);
             });
 
             m_Root.Add(new HelpBox(k_EnableRenderCompatibilityModeHelpBoxLabel, HelpBoxMessageType.Warning)

Tests/SRPTests/Projects/MultipleSRP_Tests/Assets/Common/Runtime/RenderPipelineScope.cs

@@ -71,7 +71,7 @@ public RenderPipelineScope(Type renderPipelineType, bool forceInitialization = f
             }
         }
 
-        static void ForceInitialization()
+        public static void ForceInitialization()
         {
             if (Camera.main != null)
                 Camera.main.Render();

Tests/SRPTests/Projects/MultipleSRP_Tests/Assets/Tests/EditMode/GraphicsSettingsTests.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections;
+using Common;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Rendering.HighDefinition;
+using UnityEngine.Rendering.Universal;
+using UnityEngine.TestTools;
+
+namespace MultipleSRP.EditMode
+{
+    public class GraphicsSettingsTests
+    {
+        RenderPipelineAsset m_GraphicsSettingsRPAsset;
+        RenderPipelineAsset m_QualitySettingsRPAsset;
+
+        [SetUp]
+        public void SetUp()
+        {
+            m_GraphicsSettingsRPAsset = GraphicsSettings.defaultRenderPipeline;
+            m_QualitySettingsRPAsset = QualitySettings.renderPipeline;
+            GraphicsSettings.defaultRenderPipeline = null;
+            QualitySettings.renderPipeline = null;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            RenderPipelineManager.activeRenderPipelineDisposed -= PipelineDisposedCallback;
+            GraphicsSettings.defaultRenderPipeline = m_GraphicsSettingsRPAsset;
+            QualitySettings.renderPipeline = m_QualitySettingsRPAsset;
+        }
+
+        void CloseOpenProjectSettingsWindows()
+        {
+            var projectSettingsWindows = Resources.FindObjectsOfTypeAll(typeof(ProjectSettingsWindow));
+            if (projectSettingsWindows != null && projectSettingsWindows.Length > 0)
+            {
+                foreach (var window in projectSettingsWindows)
+                    (window as EditorWindow).Close();
+            }
+        }
+
+        void PipelineDisposedCallback()
+        {
+            Assert.Fail("Render Pipeline was disposed as a side effect of opening Project Settings > Graphics");
+        }
+
+        [UnityTest]
+        public IEnumerator RenderPipelineNotRecreatedWhenActivatingGraphicsSettingsTab(
+            [Values(typeof(UniversalRenderPipelineAsset), typeof(HDRenderPipelineAsset))]
+            Type rpType)
+        {
+            CloseOpenProjectSettingsWindows();
+
+            const string graphicsSettingsPath = "Project/Graphics";
+            const string playerSettingsPath = "Project/Player";
+
+            IEnumerator WaitAFewFrames()
+            {
+                for (int i = 0; i < 10; i++)
+                    yield return null;
+            }
+
+            using (new RenderPipelineScope(rpType, forceInitialization: true))
+            {
+                yield return WaitAFewFrames();
+
+                // Open Project Settings > Graphics (may trigger RP recreate on not-up-to-date projects)
+                SettingsService.OpenProjectSettings(graphicsSettingsPath);
+                yield return WaitAFewFrames();
+
+                // Switch to Player Settings tab
+                SettingsService.OpenProjectSettings(playerSettingsPath);
+                yield return WaitAFewFrames();
+
+                // Ensure the RP is actually initialized so that disposal is possible, subscribe to disposed event
+                RenderPipelineScope.ForceInitialization();
+                RenderPipelineManager.activeRenderPipelineDisposed += PipelineDisposedCallback;
+
+                // Switch back to Graphics Settings tab, wait in case RP recreate is triggered
+                var window = SettingsService.OpenProjectSettings(graphicsSettingsPath);
+                yield return WaitAFewFrames();
+
+                // All good if we reached here, cleanup
+                RenderPipelineManager.activeRenderPipelineDisposed -= PipelineDisposedCallback;
+                window.Close();
+            }
+        }
+    }
+}