Merge pull request #8277 from Unity-Technologies/internal/6000.5/staging

mirror Internal/6000.5/staging

Author: KEngelstoft

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/Editors.meta

@@ -82,7 +82,16 @@ public static void ShowWindow()
         [MenuItem("Window/Rendering/Render Pipeline Converter", true, 50)]
         public static bool CanShowWindow()
         {
-            return !EditorApplication.isPlaying;
+            if (EditorApplication.isPlaying)
+                return false;
+
+            foreach (var converterType in TypeCache.GetTypesDerivedFrom<IRenderPipelineConverter>())
+            {
+                if (!converterType.IsAbstract && !converterType.IsInterface)
+                    return true;
+            }
+
+            return false;
         }
 
         internal static void DontSaveToLayout(EditorWindow wnd)

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/Editors/HaloEditor.cs

@@ -0,0 +1,148 @@
+#if ENABLE_UIELEMENTS_MODULE && (UNITY_EDITOR || DEVELOPMENT_BUILD)
+#define ENABLE_RENDERING_DEBUGGER_UI
+#endif
+
+using System;
+using System.Collections.Generic;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.Rendering
+{
+    internal class WidgetSearchData
+    {
+        public List<TextElement> textElements;
+        public string aggregatedAdditionalSearchText;
+
+        public WidgetSearchData(List<TextElement> textElements, string aggregatedAdditionalSearchText)
+        {
+            this.textElements = textElements;
+            this.aggregatedAdditionalSearchText = aggregatedAdditionalSearchText;
+        }
+    }
+
+    sealed partial class DebugWindow
+    {
+#if ENABLE_RENDERING_DEBUGGER_UI
+        readonly Dictionary<DebugUI.Widget, WidgetSearchData> m_WidgetSearchElementCache = new();
+        readonly List<TextElement> m_PanelHeaderTextElements = new();
+        UIElementSearchFilter m_SearchFilter;
+
+        void BuildSearchCache()
+        {
+            m_WidgetSearchElementCache.Clear();
+            m_PanelHeaderTextElements.Clear();
+
+            foreach (var panelElement in m_RightPaneElement.Children())
+            {
+                var headerLabel = panelElement.Q<Label>(className: "debug-window-search-filter-target");
+                if (headerLabel != null)
+                    m_PanelHeaderTextElements.Add(headerLabel);
+            }
+
+            DebugManager.instance.ForEachWidget(widget =>
+            {
+                if (widget.m_VisualElement == null)
+                    return;
+
+                List<TextElement> textElements = widget.m_VisualElement.Query()
+                        .Descendents<TextElement>(classname: "debug-window-search-filter-target")
+                        .ToList();
+
+                string aggregatedText = CollectAggregatedAdditionalSearchText(widget);
+                m_WidgetSearchElementCache[widget] = new WidgetSearchData(textElements, aggregatedText);
+            });
+        }
+
+        void InitializeSearchField()
+        {
+            m_SearchFilter = new UIElementSearchFilter(
+                rootVisualElement,
+                searchString =>
+                {
+                    var visiblePanels = PerformSearch(m_WidgetSearchElementCache, searchString, hideRootElementIfNoMatch: true);
+
+                    foreach (var headerLabel in m_PanelHeaderTextElements)
+                        UIElementSearchFilter.ApplySearchAndHighlight(headerLabel, searchString, out _);
+
+                    foreach (var panel in DebugManager.instance.panels)
+                    {
+                        var tab = m_LeftPaneElement.Q<VisualElement>(name: panel.displayName + "_Tab");
+                        if (tab != null)
+                        {
+                            bool shouldShow = string.IsNullOrEmpty(searchString) || visiblePanels.Contains(panel.displayName);
+                            tab.style.display = shouldShow ? DisplayStyle.Flex : DisplayStyle.None;
+                        }
+                    }
+                }
+            );
+            m_SearchFilter.InitializeSearchField("search-field");
+        }
+
+        internal static string CollectAggregatedAdditionalSearchText(DebugUI.Widget widget)
+        {
+            var parts = new List<string>();
+
+            if (!string.IsNullOrEmpty(widget.m_AdditionalSearchText))
+                parts.Add(widget.m_AdditionalSearchText);
+
+            if (widget is DebugUI.Container container)
+            {
+                foreach (var child in container.children)
+                {
+                    string childAggregated = CollectAggregatedAdditionalSearchText(child);
+                    if (!string.IsNullOrEmpty(childAggregated))
+                        parts.Add(childAggregated);
+                }
+            }
+
+            return parts.Count > 0 ? string.Join(",", parts) : string.Empty;
+        }
+
+        internal static HashSet<string> PerformSearch(Dictionary<DebugUI.Widget, WidgetSearchData> elementCache, string searchString, bool hideRootElementIfNoMatch = false)
+        {
+            var panelsWithVisibleWidgets = new HashSet<string>();
+
+            foreach (var (widget, searchData) in elementCache)
+            {
+                bool anyDescendantMatchesSearch = false;
+                foreach (var elem in searchData.textElements)
+                {
+                    UIElementSearchFilter.ApplySearchAndHighlight(elem, searchString, out bool matched);
+                    if (matched)
+                        anyDescendantMatchesSearch = true;
+                }
+
+                if (!string.IsNullOrEmpty(searchData.aggregatedAdditionalSearchText))
+                {
+                    if (searchData.aggregatedAdditionalSearchText.Contains(searchString, StringComparison.CurrentCultureIgnoreCase))
+                        anyDescendantMatchesSearch = true;
+                }
+
+                if (hideRootElementIfNoMatch)
+                {
+                    if (searchString == string.Empty && searchData.textElements.Count == 0)
+                    {
+                        widget.m_IsHiddenBySearchFilter = false;
+                    }
+                    else
+                    {
+                        widget.m_IsHiddenBySearchFilter = !anyDescendantMatchesSearch;
+                    }
+                }
+                else
+                {
+                    widget.m_IsHiddenBySearchFilter = false;
+                }
+
+                if (!widget.m_IsHiddenBySearchFilter && widget.panel != null)
+                    panelsWithVisibleWidgets.Add(widget.panel.displayName);
+            }
+
+            return panelsWithVisibleWidgets;
+        }
+#endif
+    }
+}

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/Editors/HaloEditor.cs.meta

@@ -163,11 +163,15 @@ static void SendWidgetValueChangedAnalytic<T>(string queryPath, T previousValue,
         // Note: this won't get called if the window is opened when the editor itself is closed
         void OnDestroy()
         {
-            // Note: In the case where the window is maximized/unmaximized, OnEnable for the new window gets called *before* OnDestroy.
-            //       Therefore you need to be careful with statics/globals. In this case, we only mark displayEditorUI as false if we are
-            //       closing the only/last DebugWindow instance.
-            if (Resources.FindObjectsOfTypeAll(typeof(DebugWindow)).Length == 0)
-                DebugManager.instance.displayEditorUI = false;
+            EditorApplication.delayCall += () =>
+            {
+                // Note: In the case where the window is maximized/unmaximized, OnEnable for the new window gets called *before* OnDestroy.
+                //       Therefore you need to be careful with statics/globals. In this case, we only mark displayEditorUI as false if we are
+                //       closing the only/last DebugWindow instance. The check is delayed because inside OnDestroy, the current window still exists.
+                var debugWindows = Resources.FindObjectsOfTypeAll(typeof(DebugWindow));
+                if (debugWindows.Length == 0)
+                    DebugManager.instance.displayEditorUI = false;
+            };
 
             DebugManager.instance.onSetDirty -= MarkDirty;
 
@@ -286,6 +290,9 @@ private void RecreateGUI()
                 // The schedulers themselves are created in AttachToPanelEvent so we need to delay to ensure this has happened.
                 EditorApplication.delayCall += () => SetSelectedPanel(m_SelectedPanelName);
             });
+
+            BuildSearchCache();
+            InitializeSearchField();
         }
 
         void ResetClicked()

Packages/com.unity.render-pipelines.core/Editor-PrivateShared/Tools/Converter/Window/RenderPipelineConvertersEditor.cs

@@ -1,7 +1,9 @@
 :root {
 }
 
-/* Lateral Tab Panel */
+.top-toolbar {
+    height: 22px;
+}
 
 #debug-window-tab-panel {
     align-items: stretch;

Packages/com.unity.render-pipelines.core/Editor/Debugging/DebugWindow.SearchFilter.cs

@@ -2,6 +2,7 @@
     engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
     <uie:Toolbar class="top-toolbar">
         <uie:ToolbarSpacer style="flex-grow: 1" />
+        <uie:ToolbarSearchField name="search-field"/>
         <uie:ToolbarButton text="Reset" name="btn-reset" focusable="false" />
     </uie:Toolbar>
     <ui:TwoPaneSplitView fixed-pane-index="0" fixed-pane-initial-dimension="225" view-data-key="debug-window-split-view">