Internal/master

Packages/com.unity.render-pipelines.core/CHANGELOG.md

@@ -10,6 +10,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 Version Updated
 The version number for this package has increased due to a version update of a related graphics package.
 
+## [17.4.0] - 2025-10-22
+
+This version is compatible with Unity 6000.4.0a4.
+For the release notes, refer to the [Unity download archive](https://unity.com/releases/editor/archive).
+
 ## [17.3.0] - 2025-08-27
 
 This version is compatible with Unity 6000.3.0b1.

Packages/com.unity.render-pipelines.core/Documentation~/TableOfContents.md

@@ -36,6 +36,7 @@
   * [Customize the UI of a setting](customize-ui-for-a-setting.md)
   * [Get custom graphics settings](get-custom-graphics-settings.md)
   * [Include or exclude a setting in your build](choose-whether-unity-includes-a-graphics-setting-in-your-build.md)
+  * [Advanced Properties](advanced-properties.md)
 * [Shaders](shaders.md)
   * [Use shader methods from the SRP Core shader library](built-in-shader-methods.md)
   * [Synchronizing shader code and C#](generating-shader-includes.md)

Packages/com.unity.render-pipelines.core/Documentation~/advanced-properties.md

@@ -12,29 +12,29 @@ There is a global state per user that stores if Unity displays **advanced proper
 ## Exposing advanced properties within the inspector
 
 Not every component or Volume Override includes advanced properties.
-If one does, it has a contextual menu to the right of each property section header that includes additional properties. To expose advanced properties for that section, open the contextual menu and click **Advanced Properties**.
+If one does, it has a contextual menu to the right of each property section header that includes additional properties. To expose advanced properties for that section, open the contextual menu and click **Show All Advanced Properties**.
 
 For an example, refer to the **Water Surface** component in [High Definition Render Pipeline (HDRP)](https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@latest?subfolder=/manual/settings-and-properties-related-to-the-water-system.html).
 
 By default only standard properties are shown.
 
 ![](Images/Preferences/HDRP_WaterSurface_General.png)
 
-When you select **Advanced Properties**:
+When you select **Show All Advanced Properties**:
 
 ![](Images/Preferences/PopUpAdvanced.png)
 
 **Advanced Properties** become visible:
 
 ![](Images/Preferences/HDRP_WaterSurface_General_Visible.png)
 
-For Volume Overrides, the already existing contextual menu has a **Advanced Properties** toggle as well.
+For Volume Overrides, the already existing contextual menu has a **Show All Advanced Properties** toggle as well.
 
 ## Exposing advanced properties on preferences
 
 You can also access to this global preference by:
 
-1. Open the **Graphics** tab in the **Preferences** window (menu: **Edit > Preferences > Graphics**).
-2. Under **Properties**. Set **Advanced Properties** to **All Visible**.
+1. Open the **Graphics** tab in the **Preferences** window (menu: **Edit > Preferences**, macOS: **Unity > Settings**).
+2. Under **Graphics**, select **Properties**. Set **Advanced Properties** to **All Visible**.
 
 ![](Images/Preferences/AdvancedProperties_Settings.png)

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

@@ -0,0 +1,38 @@
+using System;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.Rendering.Converter
+{
+    // This is the serialized class that stores the state of each item in the list of items to convert
+    [Serializable]
+    class ConverterItemState
+    {
+        public Action<bool> onIsSelectedChanged;
+        private bool m_IsSelected;
+        public bool isSelected
+        {
+            get => m_IsSelected;
+            set
+            {
+                if (m_IsSelected != value)
+                {
+                    m_IsSelected = value;
+                    onIsSelectedChanged?.Invoke(m_IsSelected);
+                }
+            }
+        }
+        public IRenderPipelineConverterItem item;
+        public (Status Status, string Message) conversionResult = (Status.Pending, string.Empty);
+        internal bool hasConverted => conversionResult.Status != Status.Pending;
+
+        public void OnSelectionChanged(ClickEvent _)
+        {
+            isSelected = !isSelected;
+        }
+
+        public void OnClicked(ClickEvent _)
+        {
+            item.OnClicked();
+        }
+    }
+}

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

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace UnityEditor.Rendering.Converter
+{
+    [Flags]
+    internal enum DisplayFilter
+    {
+        None = 0,
+        Pending = (1 << Status.Pending),
+        Warnings = (1 << Status.Warning),
+        Errors = (1 << Status.Error),
+        Success = (1 << Status.Success),
+        All = Pending | Warnings | Errors | Success
+    }
+
+    // Each converter uses the active bool
+    // Each converter has a list of active items/assets
+    // We do this so that we can use the binding system of the UI Elements
+    [Serializable]
+    class ConverterState
+    {
+        public bool isExpanded;
+        public bool isSelected;
+        public bool isLoading; // to name
+        public bool isInitialized;
+        public List<ConverterItemState> items = new List<ConverterItemState>();
+        [SerializeReference]
+        public IRenderPipelineConverter converter;
+
+        public DisplayFilter currentFilter = DisplayFilter.All;
+        public IList<TreeViewItemData<ConverterItemState>> filteredItems = new List<TreeViewItemData<ConverterItemState>>();
+
+        private int CountItemWithFlag(Status status)
+        {
+            int count = 0;
+            foreach (ConverterItemState itemState in items)
+            {
+                if (itemState.conversionResult.Status == status)
+                {
+                    count++;
+                }
+            }
+            return count;
+        }
+        public int pending => CountItemWithFlag(Status.Pending);
+        public int warnings => CountItemWithFlag(Status.Warning);
+        public int errors => CountItemWithFlag(Status.Error);
+        public int success => CountItemWithFlag(Status.Success);
+
+        public override string ToString()
+        {
+            return $"Warnings: {warnings} - Errors: {errors} - Ok: {success} - Total: {items?.Count ?? 0}";
+        }
+
+        public void Clear()
+        {
+            isInitialized = false;
+            items.Clear();
+            filteredItems.Clear();
+        }
+
+        private bool IsVisible(DisplayFilter filter)
+        {
+            return (currentFilter & filter) == filter;
+        }
+
+        internal bool ShouldInclude(ConverterItemState converterItemState)
+        {
+            return converterItemState.conversionResult.Status switch
+            {
+                Status.Pending => IsVisible(DisplayFilter.Pending),
+                Status.Warning => IsVisible(DisplayFilter.Warnings),
+                Status.Error => IsVisible(DisplayFilter.Errors),
+                Status.Success => IsVisible(DisplayFilter.Success),
+                _ => false
+            };
+        }
+
+        internal void AddItem(ConverterItemState converterItemState)
+        {
+            items.Add(converterItemState);
+            if (ShouldInclude(converterItemState))
+            {
+                filteredItems.Add(new TreeViewItemData<ConverterItemState>(filteredItems.Count, converterItemState));
+            }
+        }
+
+        internal void ApplyFilter()
+        {
+            filteredItems.Clear();
+
+            foreach (var item in items)
+            {
+                if (IsVisible((DisplayFilter)(1 << (int)item.conversionResult.Status)))
+                    filteredItems.Add(new TreeViewItemData<ConverterItemState>(filteredItems.Count, item));
+            }
+        }
+
+        public int selectedItemsCount
+        {
+            get
+            {
+                int count = 0;
+                foreach (ConverterItemState itemState in items)
+                {
+                    if (itemState.isSelected)
+                    {
+                        count++;
+                    }
+                }
+                return count;
+            }
+        }
+    }
+}

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

@@ -11,12 +11,12 @@ interface IRenderPipelineConverter
         /// <summary>
         /// Gets a value indicating whether the converter is enabled and can be used.
         /// </summary>
-        bool isEnabled { get; }
+        bool isEnabled => true;
 
         /// <summary>
         /// Gets or sets the reason message shown when the converter item is disabled.
         /// </summary>
-        string isDisabledMessage { get; }
+        string isDisabledMessage => string.Empty;
 
         /// <summary>
         /// Scans for available render pipeline converter items.

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

@@ -1,3 +1,5 @@
+using UnityEngine;
+
 namespace UnityEditor.Rendering.Converter
 {
     /// <summary>
@@ -25,6 +27,8 @@ interface IRenderPipelineConverterItem
         /// </summary>
         string isDisabledMessage { get; set; }
 
+        Texture2D icon => null;
+
         /// <summary>
         /// Invoked when the converter item is clicked or activated.
         /// </summary>

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

@@ -10,12 +10,42 @@ internal class RenderPipelineConverterAssetItem : IRenderPipelineConverterItem
         public string assetPath { get; }
         public string guid { get; }
 
-        public string name => assetPath;
+        public string name
+        {
+            get
+            {
+                var obj = LoadObject();
+                if (obj != null)
+                    return obj.name;
+
+                // Fallback to asset path name
+                return System.IO.Path.GetFileNameWithoutExtension(assetPath);
+            }
+        }
+
+        public string info => assetPath;
 
-        public string info => guid;
+        public bool isEnabled { get; set; } = true;
+        public string isDisabledMessage { get; set; } = string.Empty;
 
-        public bool isEnabled { get; set; }
-        public string isDisabledMessage { get; set; }
+        public Texture2D icon
+        {
+            get
+            {
+                var obj = LoadObject();
+                if (obj == null)
+                    return null;
+
+                // Try the object's thumbnail/icon
+                var icon = AssetPreview.GetMiniThumbnail(obj);
+                if (icon != null) return icon;
+
+                // Fallback to type icon
+                var type = obj.GetType();
+                icon = EditorGUIUtility.ObjectContent(null, type).image as Texture2D;
+                return icon;
+            }
+        }
 
         public RenderPipelineConverterAssetItem(string id)
         {
@@ -79,7 +109,9 @@ public UnityEngine.Object LoadObject()
 
         public void OnClicked()
         {
-            EditorGUIUtility.PingObject(AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath));
+            var obj = LoadObject();
+            if (obj != null)
+                EditorGUIUtility.PingObject(obj);
         }
     }
 }