mirror Internal/6000.5/staging

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

@@ -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/Debugging/DebugWindow.SearchFilter.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/Debugging/DebugWindow.cs

@@ -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/Debugging/DebugWindow.uss

@@ -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.uxml

@@ -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">

Packages/com.unity.render-pipelines.core/Editor/Lighting/LightingSearchSelectors.cs → Packages/com.unity.render-pipelines.core/Editor/Lighting/LightingSearchColumnProviders.cs

@@ -6,7 +6,7 @@
 
 namespace UnityEditor.Lighting
 {
-    static class CoreLightingSearchSelectors
+    static class CoreLightingSearchColumnProviders
     {
         internal const string k_SceneProvider = "scene";
         internal const string k_BakingSetPath = "BakingSets/";
@@ -18,8 +18,7 @@ static class CoreLightingSearchSelectors
         internal const string k_VolumeModePath = k_VolumePath + "Mode";
         internal const string k_VolumeProfilePath = k_VolumePath + "Profile";
 
-        const string k_StyleSheetPath = "StyleSheets/LightingSearchSelectors.uss";
-        const int k_DefaultSearchSelectorPriority = 99;
+        const string k_StyleSheetPath = "StyleSheets/LightingSearchColumnProviders.uss";
         const int k_MinBakingSamples = 1;
         const int k_MaxBakingSamples = 8192;
         static StyleSheet s_StyleSheet;
@@ -33,26 +32,6 @@ static StyleSheet LoadStyleSheet()
             return s_StyleSheet;
         }
 
-        [SearchSelector(k_VolumeModePath, provider: k_SceneProvider, priority: k_DefaultSearchSelectorPriority)]
-        static object VolumeModeSearchSelector(SearchSelectorArgs args)
-        {
-            var go = args.current.ToObject<GameObject>();
-            if (go == null)
-                return null;
-
-            return LightingSearchDataAccessors.GetVolumeMode(go);
-        }
-
-        [SearchSelector(k_VolumeProfilePath, provider: k_SceneProvider, priority: k_DefaultSearchSelectorPriority)]
-        static object VolumeProfileSearchSelector(SearchSelectorArgs args)
-        {
-            var go = args.current.ToObject<GameObject>();
-            if (go == null)
-                return null;
-
-            return LightingSearchDataAccessors.GetVolumeProfile(go);
-        }
-
         [SearchColumnProvider(k_BakingModePath)]
         public static void BakingModeSearchColumnProvider(SearchColumn column)
         {
@@ -396,7 +375,7 @@ internal static void SetLightShape(GameObject go, LightType value)
 
         internal static bool IsLightShapeApplicable(LightType lightType)
         {
-            return IsAreaLight(lightType);
+            return lightType is LightType.Rectangle or LightType.Disc;
         }
 
         static bool IsAreaLight(LightType lightType)
@@ -407,8 +386,7 @@ static bool IsAreaLight(LightType lightType)
         enum AreaLightShape
         {
             Rectangle = LightType.Rectangle,
-            Disc = LightType.Disc,
-            Tube = LightType.Tube
+            Disc = LightType.Disc
         }
 
         class LightShapeField : EnumField
@@ -452,7 +430,9 @@ void UpdateEnumField()
             {
                 if (IsAreaLight(m_Value))
                 {
-                    Init((AreaLightShape)m_Value, false);
+                    // Tube is not offered as an option; display as Rectangle
+                    var displayType = m_Value == LightType.Tube ? LightType.Rectangle : m_Value;
+                    Init((AreaLightShape)displayType, false);
                 }
             }
         }

Packages/com.unity.render-pipelines.core/Editor/PathTracing/LightBakerStrangler.cs

@@ -884,16 +884,18 @@ internal static Result ExecuteLightmapRequests(
             bool debugDispatches = integrationSettings.DebugDispatches;
             bool doDirectionality = AnyLightmapRequestHasOutput(lightmapRequestData.requests, LightmapRequestOutputType.DirectionalityDirect) || AnyLightmapRequestHasOutput(lightmapRequestData.requests, LightmapRequestOutputType.DirectionalityIndirect);
 
-            // Find the max index count in any mesh, so we can pre-allocate various buffers based on it.
+            // Find the max index and vertex count in any mesh, so we can pre-allocate various buffers based on it.
             uint maxIndexCount = 1;
+            uint maxVertexCount = 1;
             for (int meshIdx = 0; meshIdx < world.Meshes.Length; ++meshIdx)
             {
                 maxIndexCount = Math.Max(maxIndexCount, world.Meshes[meshIdx].GetTotalIndexCount());
+                maxVertexCount = Math.Max(maxVertexCount, (uint)world.Meshes[meshIdx].vertexCount);
             }
 
             (int width, int height)[] atlasSizes = lightmapRequestData.atlassing.m_AtlasSizes;
             int initialLightmapResolution = atlasSizes.Length > 0 ? atlasSizes[0].width : 1024;
-            if (!lightmappingContext.Initialize(deviceContext, initialLightmapResolution, initialLightmapResolution, world, maxIndexCount, lightmapResourceLib))
+            if (!lightmappingContext.Initialize(deviceContext, initialLightmapResolution, initialLightmapResolution, world, maxIndexCount, maxVertexCount, lightmapResourceLib))
                 return Result.InitializeFailure;
 
             lightmappingContext.IntegratorContext.Initialize(samplingResources, lightmapResourceLib, !useLegacyBakingBehavior);