[Port] [6000.4] Initialise VolumeManager BaseComponentTypes from DefaultProfile to avoid reflection and reduce startup overhead

Author: svc-reach-platform-support

Packages/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentEditor.cs

@@ -196,7 +196,6 @@ internal void SetVolumeProfile(VolumeProfile p)
 
         static Dictionary<Type, VolumeParameterDrawer> s_ParameterDrawers;
         SupportedOnRenderPipelineAttribute m_SupportedOnRenderPipelineAttribute;
-        Type[] m_LegacyPipelineTypes;
 
         static VolumeComponentEditor()
         {
@@ -274,11 +273,6 @@ internal void Init()
 
             var volumeComponentType = volumeComponent.GetType();
             m_SupportedOnRenderPipelineAttribute = volumeComponentType.GetCustomAttribute<SupportedOnRenderPipelineAttribute>();
-
-#pragma warning disable CS0618
-            var supportedOn = volumeComponentType.GetCustomAttribute<VolumeComponentMenuForRenderPipeline>();
-            m_LegacyPipelineTypes = supportedOn != null ? supportedOn.pipelineTypes : Array.Empty<Type>();
-#pragma warning restore CS0618
         }
 
         internal void DetermineVisibility(Type renderPipelineAssetType, Type renderPipelineType)
@@ -295,12 +289,6 @@ internal void DetermineVisibility(Type renderPipelineAssetType, Type renderPipel
                 return;
             }
 
-            if (renderPipelineType != null && m_LegacyPipelineTypes.Length > 0)
-            {
-                visible = m_LegacyPipelineTypes.Contains(renderPipelineType);
-                return;
-            }
-
             visible = true;
         }
 

Packages/com.unity.render-pipelines.core/Editor/Volume/VolumeProfileUtils.cs

@@ -140,19 +140,19 @@ static VolumeComponent GetVolumeComponentOfTypeOrDefault(this VolumeProfile prof
         static List<Type> GetTypesMissingFromDefaultProfile(VolumeProfile profile)
         {
             List<Type> missingTypes = new List<Type>();
-            var volumeComponentTypes = VolumeManager.instance.baseComponentTypeArray;
+
+            var volumeComponentTypes = VolumeManager.instance.isInitialized ?
+                VolumeManager.instance.baseComponentTypeArray : VolumeManager.instance.LoadBaseTypesByReflection(GraphicsSettings.currentRenderPipelineAssetType);
             foreach (var type in volumeComponentTypes)
             {
                 if (profile.components.Find(c => c.GetType() == type) == null)
                 {
-                    if (type.IsDefined(typeof(ObsoleteAttribute), false) ||
-                        type.IsDefined(typeof(HideInInspector), false))
+                    if (type.IsDefined(typeof(ObsoleteAttribute), false))
                         continue;
 
                     missingTypes.Add(type);
                 }
             }
-
             return missingTypes;
         }
 
@@ -163,13 +163,14 @@ static List<Type> GetTypesMissingFromDefaultProfile(VolumeProfile profile)
         /// <param name="profile">VolumeProfile to use.</param>
         /// <param name="defaultValueSource">An optional VolumeProfile asset containing default values to use for
         /// any components that are added to <see cref="profile"/>.</param>
-        public static void EnsureAllOverridesForDefaultProfile(VolumeProfile profile, VolumeProfile defaultValueSource = null)
+        public static void EnsureAllOverridesForDefaultProfile(VolumeProfile profile, VolumeProfile defaultValueSource = null) => TryEnsureAllOverridesForDefaultProfile(profile, defaultValueSource);
+        internal static bool TryEnsureAllOverridesForDefaultProfile(VolumeProfile profile, VolumeProfile defaultValueSource = null)
         {
             // It's possible that the volume profile is assigned to the default asset inside the HDRP package. In
             // this case it cannot be modified. User is expected to use HDRP Wizard "Fix" to create a local profile.
             var path = AssetDatabase.GetAssetPath(profile);
             if (CoreEditorUtils.IsAssetInReadOnlyPackage(path))
-                return;
+                return false;
 
             bool changed = false;
             int numComponentsBefore = profile.components.Count;
@@ -241,6 +242,8 @@ public static void EnsureAllOverridesForDefaultProfile(VolumeProfile profile, Vo
                 VolumeManager.instance.OnVolumeProfileChanged(profile);
                 EditorUtility.SetDirty(profile);
             }
+
+            return changed;
         }
 
         /// <summary>

Packages/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.cs

@@ -45,7 +45,7 @@ public VolumeComponentMenu(string menu)
     /// This attribute allows you to add commands to the <b>Add Override</b> popup menu on Volumes,
     /// while also specifying the render pipeline(s) for which the command will be supported.
     /// </summary>
-    [Obsolete(@"VolumeComponentMenuForRenderPipelineAttribute is deprecated. Use VolumeComponentMenu with SupportedOnRenderPipeline instead. #from(2023.1)")]
+    [Obsolete(@"VolumeComponentMenuForRenderPipelineAttribute is deprecated. Use VolumeComponentMenu with SupportedOnRenderPipeline instead. #from(2023.1)", true)]
     public class VolumeComponentMenuForRenderPipeline : VolumeComponentMenu
     {
         /// <summary>
@@ -126,7 +126,7 @@ public sealed class VolumeComponentDeprecated : Attribute
     /// <para>
     /// In the example above, the custom component `ExampleComponent` extends `VolumeComponent` and defines a parameter
     /// (`intensity`) that can be manipulated within the volume framework. The `ClampedFloatParameter` is a type of
-    /// <see cref="VolumeParameter{T}"/> that ensures the value remains within a specified range. 
+    /// <see cref="VolumeParameter{T}"/> that ensures the value remains within a specified range.
     /// </para>
     /// </example>
     [Serializable]
@@ -164,7 +164,7 @@ public Indent(int relativeAmount = 1)
         /// The backing storage of <see cref="parameters"/>. Use this for performance-critical work.
         /// </summary>
         internal VolumeParameter[] parameterList;
-        
+
         ReadOnlyCollection<VolumeParameter> m_ParameterReadOnlyCollection;
 
         /// <summary>
@@ -355,7 +355,7 @@ public bool AnyPropertiesIsOverridden()
         {
             for (int i = 0; i < parameterList.Length; ++i)
             {
-                if (parameterList[i].overrideState) 
+                if (parameterList[i].overrideState)
                     return true;
             }
             return false;

Packages/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.cs

@@ -41,6 +41,8 @@ namespace UnityEngine.Rendering
     /// <seealso cref="GraphicsSettings"/>
     public sealed partial class VolumeManager
     {
+        static readonly ProfilerMarker k_ProfilerMarkerInitialize = new ("VolumeManager.Initialize");
+        static readonly ProfilerMarker k_ProfilerMarkerInitializeBaseTypesArray = new ("VolumeManager.InitializeBaseTypesArray");
         static readonly ProfilerMarker k_ProfilerMarkerUpdate = new ("VolumeManager.Update");
         static readonly ProfilerMarker k_ProfilerMarkerReplaceData = new ("VolumeManager.ReplaceData");
         static readonly ProfilerMarker k_ProfilerMarkerEvaluateVolumeDefaultState = new ("VolumeManager.EvaluateVolumeDefaultState");
@@ -78,7 +80,7 @@ public sealed partial class VolumeManager
                 return supportedVolumeComponents;
 
             if (baseComponentTypeArray == null)
-                LoadBaseTypes(currentPipelineAssetType);
+                InitializeBaseTypesArray();
 
             supportedVolumeComponents = BuildVolumeComponentDisplayList(baseComponentTypeArray);
             s_SupportedVolumeComponentsForRenderPipeline[currentPipelineAssetType] = supportedVolumeComponents;
@@ -133,18 +135,17 @@ public sealed partial class VolumeManager
                 volumes.Add((path, t));
             }
 
-            return volumes
-                .OrderBy(i => i.Item1)
-                .ToList();
+            volumes.Sort((a, b) => string.Compare(a.Item1, b.Item1));
+            return volumes;
         }
-        
+
         Type[] m_BaseComponentTypeArray;
 
         /// <summary>
         /// The current list of all available types that derive from <see cref="VolumeComponent"/>.
         /// </summary>
-        public Type[] baseComponentTypeArray 
-        { 
+        public Type[] baseComponentTypeArray
+        {
             get
             {
                 if (isInitialized)
@@ -153,7 +154,7 @@ public Type[] baseComponentTypeArray
                 throw new InvalidOperationException($"{nameof(VolumeManager)}.{nameof(instance)}.{nameof(baseComponentTypeArray)} cannot be called before the {nameof(VolumeManager)} is initialized. (See {nameof(VolumeManager)}.{nameof(instance)}.{nameof(isInitialized)} and {nameof(RenderPipelineManager)} for creation callback).");
             }
             internal set => m_BaseComponentTypeArray = value; // internal only for tests
-        } 
+        }
 
         /// <summary>
         /// Global default profile that provides default values for volume components. VolumeManager applies
@@ -247,13 +248,30 @@ internal VolumeManager()
         /// <param name="qualityDefaultVolumeProfile">Quality default volume profile.</param>
         public void Initialize(VolumeProfile globalDefaultVolumeProfile = null, VolumeProfile qualityDefaultVolumeProfile = null)
         {
+            using var profilerScope = k_ProfilerMarkerInitialize.Auto();
             Debug.Assert(!isInitialized);
             Debug.Assert(m_CreatedVolumeStacks.Count == 0);
 
-            LoadBaseTypes(GraphicsSettings.currentRenderPipelineAssetType);
+            InitializeBaseTypesArray(globalDefaultVolumeProfile);
+
             InitializeInternal(globalDefaultVolumeProfile, qualityDefaultVolumeProfile);
         }
 
+        void InitializeBaseTypesArray(VolumeProfile globalDefaultVolumeProfile = null)
+        {
+            using var profilerScope = k_ProfilerMarkerInitializeBaseTypesArray.Auto();
+#if UNITY_EDITOR
+            LoadBaseTypesByReflection(GraphicsSettings.currentRenderPipelineAssetType);
+#else
+            if (globalDefaultVolumeProfile == null)
+            {
+                var defaultVolumeProfileSettings = GraphicsSettings.GetRenderPipelineSettings<IDefaultVolumeProfileAsset>();
+                globalDefaultVolumeProfile = defaultVolumeProfileSettings?.defaultVolumeProfile;
+            }
+            LoadBaseTypes(globalDefaultVolumeProfile);
+#endif
+        }
+
         //This is called by test where the basetypes are tuned for the purpose of the test.
         internal void InitializeInternal(VolumeProfile globalDefaultVolumeProfile = null, VolumeProfile qualityDefaultVolumeProfile = null)
         {
@@ -293,6 +311,7 @@ public void Deinitialize()
         /// <param name="profile">The VolumeProfile to use as the global default profile.</param>
         public void SetGlobalDefaultProfile(VolumeProfile profile)
         {
+            LoadBaseTypes(profile);
             globalDefaultProfile = profile;
             EvaluateVolumeDefaultState();
         }
@@ -315,6 +334,10 @@ public void SetCustomDefaultProfiles(List<VolumeProfile> profiles)
         {
             var validProfiles = profiles ?? new List<VolumeProfile>();
             validProfiles.RemoveAll(x => x == null);
+
+            if (globalDefaultProfile == null && validProfiles.Count > 0)
+                globalDefaultProfile = validProfiles[0];
+
             customDefaultProfiles = new ReadOnlyCollection<VolumeProfile>(validProfiles);
             EvaluateVolumeDefaultState();
         }
@@ -396,38 +419,44 @@ public void DestroyStack(VolumeStack stack)
             stack.Dispose();
         }
 
-        // For now, if a user is having a VolumeComponent with the old attribute for filtering support.
-        // We are adding it to the supported volume components, but we are showing a warning.
-        bool IsSupportedByObsoleteVolumeComponentMenuForRenderPipeline(Type t, Type pipelineAssetType)
+        /// <summary>
+        /// LoadBaseTypes is responsible for loading the list of VolumeComponent types that will be used to build the default state of the VolumeStack. It uses the provided global default profile to determine which component types are relevant for the current render pipeline.
+        /// This will be called only once at runtime on app boot
+        /// </summary>
+        /// <param name="globalDefaultVolumeProfile">The global default volume profile to use to build the base component type array.</param>
+        internal void LoadBaseTypes(VolumeProfile globalDefaultVolumeProfile)
         {
-            var legacySupported = false;
-
-#pragma warning disable CS0618
-            var legacyPipelineAttribute = t.GetCustomAttribute<VolumeComponentMenuForRenderPipeline>();
-            if (legacyPipelineAttribute != null)
+            if (globalDefaultVolumeProfile == null)
             {
-                Debug.LogWarning($"{nameof(VolumeComponentMenuForRenderPipeline)} is deprecated, use {nameof(SupportedOnRenderPipelineAttribute)} and {nameof(VolumeComponentMenu)} with {t} instead. #from(2023.1)");
-#if UNITY_EDITOR
-                var renderPipelineTypeFromAsset = RenderPipelineEditorUtility.GetPipelineTypeFromPipelineAssetType(pipelineAssetType);
+                m_BaseComponentTypeArray = Array.Empty<Type>();
+                return;
+            }
 
-                for (int i = 0; i < legacyPipelineAttribute.pipelineTypes.Length; ++i)
+            using (ListPool<Type>.Get(out var list))
+            {
+                var pipelineAssetType = GraphicsSettings.currentRenderPipelineAssetType;
+                foreach (var comp in globalDefaultVolumeProfile.components)
                 {
-                    if (legacyPipelineAttribute.pipelineTypes[i] == renderPipelineTypeFromAsset)
-                    {
-                        legacySupported = true;
-                        break;
-                    }
+                    if (comp == null) continue;
+
+                    var componentType = comp.GetType();
+                    if (!SupportedOnRenderPipelineAttribute.IsTypeSupportedOnRenderPipeline(componentType, pipelineAssetType))
+                        continue;
+
+                    list.Add(componentType);
                 }
-#endif
-            }
-#pragma warning restore CS0618
 
-            return legacySupported;
+                m_BaseComponentTypeArray = list.ToArray();
+            }
         }
 
-        // This will be called only once at runtime and on domain reload / pipeline switch in the editor
-        // as we need to keep track of any compatible component in the project
-        internal void LoadBaseTypes(Type pipelineAssetType)
+#if UNITY_EDITOR
+        /// <summary>
+        /// This should only be called when we need to load base types without being able to trust default profiles are up to date. This is slow and uses Reflection!
+        /// Will be called only once at runtime and on domain reload / pipeline switch in the editor as we need to keep track of any compatible component in the project
+        /// </summary>
+        /// <param name="pipelineAssetType">The Pipeline Type used to check if each VolumeComponent is supported.</param>
+        internal Type[] LoadBaseTypesByReflection(Type pipelineAssetType)
         {
             // Grab all the component types we can find that are compatible with current pipeline
             using (ListPool<Type>.Get(out var list))
@@ -437,23 +466,25 @@ internal void LoadBaseTypes(Type pipelineAssetType)
                     if (t.IsAbstract)
                         continue;
 
-                    var isSupported = SupportedOnRenderPipelineAttribute.IsTypeSupportedOnRenderPipeline(t, pipelineAssetType) ||
-                                      IsSupportedByObsoleteVolumeComponentMenuForRenderPipeline(t, pipelineAssetType);
+                    if (!SupportedOnRenderPipelineAttribute.IsTypeSupportedOnRenderPipeline(t, pipelineAssetType))
+                        continue;
 
-                    if (isSupported)
-                        list.Add(t);
+                    list.Add(t);
                 }
 
                 m_BaseComponentTypeArray = list.ToArray();
             }
+
+            return m_BaseComponentTypeArray;
         }
+#endif
 
         internal void InitializeVolumeComponents()
         {
             if (m_BaseComponentTypeArray == null || m_BaseComponentTypeArray.Length == 0)
                 return;
 
-            // Call custom static Init method if present
+            // Call deprecated static Init method if present
             var flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
             foreach (var type in m_BaseComponentTypeArray)
             {
@@ -469,7 +500,11 @@ internal void InitializeVolumeComponents()
         void EvaluateVolumeDefaultState()
         {
             if (m_BaseComponentTypeArray == null || m_BaseComponentTypeArray.Length == 0)
+            {
+                m_ComponentsDefaultState = Array.Empty<VolumeComponent>();
+                m_ParametersDefaultState = Array.Empty<VolumeParameter>();
                 return;
+            }
 
             using var profilerScope = k_ProfilerMarkerEvaluateVolumeDefaultState.Auto();
 
@@ -478,7 +513,7 @@ void EvaluateVolumeDefaultState()
             // Initialize() and the default state can be updated a lot quicker.
 
             // First, default-construct all VolumeComponents
-            List<VolumeComponent> componentsDefaultStateList = new();
+            using var _ = ListPool<VolumeComponent>.Get(out var componentsDefaultStateList);
             foreach (var type in m_BaseComponentTypeArray)
             {
                 componentsDefaultStateList.Add((VolumeComponent) ScriptableObject.CreateInstance(type));

Packages/com.unity.render-pipelines.high-definition/Editor/BuildProcessors/HDRPPreprocessBuild.cs

@@ -41,6 +41,21 @@ public void OnPreprocessBuild(BuildReport report)
 
                 ConfigureMinimumMaxLoDValueForAllQualitySettings();
 
+                if (HDRenderPipelineGlobalSettings.instance.TryInitializeDefaultVolumeProfile(out var defaultVolumeProfileSettings))
+                {
+                    Debug.Log("Default Volume Profile has been created or Diffusion Profiles have been updated to ensure all components are present. This is required to avoid missing overrides at runtime which can lead to unexpected rendering issues. Please save these changes to avoid this message in the future.");
+                }
+
+                if (defaultVolumeProfileSettings == null)
+                {
+                    throw new BuildFailedException("Failed to initialize the Default Volume Profile. A Default Volume Profile is required for HDRP to function properly.");
+                }
+
+                if (VolumeProfileUtils.TryEnsureAllOverridesForDefaultProfile(defaultVolumeProfileSettings.volumeProfile))
+                {
+                    Debug.Log("Default Volume Profile has been modified to ensure all components are present. This is required to avoid missing overrides at runtime which can lead to unexpected rendering issues. Please save these changes to avoid this message in the future.");
+                }
+
                 LogIncludedAssets(m_BuildData.renderPipelineAssets);
 
                 GatherShaderFeatures();