[Forward Port] [trunk] [HDRP] Migrated performance warning platform check from HDRP package code to engine-side.

Author: EmreDoganUnity

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

@@ -146,6 +146,13 @@ public override void OnInspectorGUI()
             }
             m_SerializedProperties.Update();
 
+            if (EditorGraphicsSettings.ShouldValidateGraphicsForActiveBuildTarget())
+            {
+                var validationSettings = HDProjectSettings.validationSettings;
+                if (!validationSettings.k_GraphicsCompositor_Recommended && m_compositionManager.enableInternal)
+                    HDEditorUtils.ShowFeatureOptimisationWarning("Graphics Compositor");
+            }
+
             m_EnablePreview = EditorGUILayout.Toggle(Styles.k_EnablePreview, m_compositionManager.enableOutput);
             {
                 m_compositionManager.enableOutput = m_EnablePreview;

Packages/com.unity.render-pipelines.high-definition/Editor/Compositor/CompositionManagerEditor.cs

@@ -519,9 +519,35 @@ public override void OnInspectorGUI()
             }
             using var disableScope = new EditorGUI.DisabledScope(notSupported);
 
+            if (EditorGraphicsSettings.ShouldValidateGraphicsForActiveBuildTarget())
+            {
+                var validationSettings = HDProjectSettings.validationSettings;
+                VolumetricClouds defaultClouds = HDEditorUtils.GetVolumeComponentDefaultState<VolumetricClouds>();
+
+                // Get effective quality value (use local if overridden, otherwise use default)
+                bool useDefaultEnabled = !m_Enable.overrideState.boolValue;
+                bool effectiveEnabled = useDefaultEnabled
+                    ? (defaultClouds?.enable.value ?? false)
+                    : m_Enable.value.boolValue;
+
+                if (effectiveEnabled && !validationSettings.k_VolumetricClouds_Recommended)
+                {
+                    if (useDefaultEnabled && HDEditorUtils.TryGetVolumeParameterSource<VolumetricClouds>(
+                      clouds => clouds.enable.overrideState && clouds.enable.value == effectiveEnabled,
+                      out var sourceProfile,
+                      out var sourceName))
+                    {
+                        HDEditorUtils.ShowFeatureOptimisationWarning(HDRenderPipelineUI.Styles.volumetricCloudsSubTitle.text, sourceName, () => Selection.activeObject = sourceProfile);
+                    }
+                    else
+                    {
+                        HDEditorUtils.ShowFeatureOptimisationWarning(HDRenderPipelineUI.Styles.volumetricCloudsSubTitle.text);
+                    }
+                }
+            }
+
             EditorGUILayout.LabelField("General", EditorStyles.miniLabel);
             PropertyField(m_Enable, EditorGUIUtility.TrTextContent("State"));
-
             if (m_Enable.value.boolValue && !notSupported)
                 HDEditorUtils.EnsureFrameSetting(FrameSettingsField.VolumetricClouds);
 

Packages/com.unity.render-pipelines.high-definition/Editor/Lighting/VolumetricClouds/VolumetricCloudsEditor.cs

@@ -25,8 +25,36 @@ public override void OnInspectorGUI()
         {
             HDEditorUtils.EnsureFrameSetting(FrameSettingsField.FilmGrain);
 
-            if (m_Intensity.value.floatValue > 0)
-                HDEditorUtils.ShowPlatformPerformanceWarning(BuildTarget.Switch2, "Film Grain");
+            if (EditorGraphicsSettings.ShouldValidateGraphicsForActiveBuildTarget())
+            {
+                var defaultFilmGrain = HDEditorUtils.GetVolumeComponentDefaultState<FilmGrain>();
+
+                // Get effective intensity value (use local if overridden, otherwise use default)
+                bool useDefaultIntensity = !m_Intensity.overrideState.boolValue;
+                float effectiveIntensity = useDefaultIntensity
+                    ? (defaultFilmGrain?.intensity.value ?? 0.0f)
+                    : m_Intensity.value.floatValue;
+
+                var validationSettings = HDProjectSettings.validationSettings;
+                if (effectiveIntensity > 0.0f && !validationSettings.k_FilmGrain_Recommended)
+                {
+                    using (new IndentLevelScope())
+                    {
+                        if (useDefaultIntensity && HDEditorUtils.TryGetVolumeParameterSource<FilmGrain>(
+                              filmGrain => filmGrain.intensity.overrideState && filmGrain.intensity.value > 0.0f,
+                              out var sourceProfile,
+                              out var sourceName))
+                        {
+                            HDEditorUtils.ShowFeatureOptimisationWarning("Film Grain", sourceName, () => Selection.activeObject = sourceProfile);
+                        }
+                        else
+                        {
+                            HDEditorUtils.ShowFeatureOptimisationWarning("Film Grain");
+                        }
+                    }
+
+                }
+            }
 
             PropertyField(m_Type);
 

Packages/com.unity.render-pipelines.high-definition/Editor/PostProcessing/FilmGrainEditor.cs

@@ -437,32 +437,167 @@ internal static bool EnsureVolume<T>(Func<T, string> volumeValidator) where T :
             return true;
         }
 
+        /// <summary>
+        /// Gets the resolved default state for a volume component, which combines global and quality default profiles.
+        /// Use this to determine what values will be used for non-overridden parameters.
+        /// </summary>
+        /// <typeparam name="T">The type of volume component to retrieve</typeparam>
+        /// <returns>The volume component with resolved default state, or null if not initialized</returns>
+        internal static T GetVolumeComponentDefaultState<T>() where T : VolumeComponent
+        {
+            if (!VolumeManager.instance.isInitialized)
+                return null;
+
+            return VolumeManager.instance.GetVolumeComponentDefaultState(typeof(T)) as T;
+        }
+
+        /// <summary>
+        /// Gets the effective value of a volume parameter, considering override state and default fallback.
+        /// If the parameter is overridden, returns the local value. Otherwise, returns the value from
+        /// the default parameter (or the fallback if default is null).
+        /// </summary>
+        /// <typeparam name="T">The type of the parameter value</typeparam>
+        /// <param name="parameter">The volume parameter to get the value from</param>
+        /// <param name="defaultParameter">The default parameter to use when parameter is not overridden</param>
+        /// <param name="fallbackValue">Fallback value if default parameter is null</param>
+        /// <returns>The effective value considering override state and defaults</returns>
+        internal static T GetEffectiveParameterValue<T>(
+            VolumeParameter<T> parameter,
+            VolumeParameter<T> defaultParameter,
+            T fallbackValue)
+        {
+            if (parameter.overrideState)
+                return parameter.value;
+
+            return defaultParameter != null ? defaultParameter.value : fallbackValue;
+        }
+
+        /// <summary>
+        /// Finds which default volume profile (global or quality) is setting a parameter value.
+        /// Checks in precedence order: Quality profile overrides Global profile.
+        /// </summary>
+        /// <typeparam name="T">The type of volume component</typeparam>
+        /// <param name="parameterPredicate">Predicate which specifies the target</param>
+        /// <param name="sourceProfile">The volume profile that is setting the value, or null if not found</param>
+        /// <param name="sourceDescription">Human-readable description of the source (e.g., "Quality Profile in HDRenderPipelineAsset")</param>
+        /// <returns>True if a profile with the target parameter was found</returns>
+        internal static bool TryGetVolumeParameterSource<T>(
+            System.Func<T, bool> parameterPredicate,
+            out VolumeProfile sourceProfile,
+            out string sourceDescription) where T : VolumeComponent
+        {
+            sourceProfile = null;
+            sourceDescription = null;
+
+            if (!VolumeManager.instance.isInitialized)
+                return false;
+
+            // Check quality profile first (higher precedence)
+            if (VolumeManager.instance.qualityDefaultProfile != null &&
+                VolumeManager.instance.qualityDefaultProfile.TryGet<T>(out var qualityComponent) &&
+                qualityComponent.active && parameterPredicate(qualityComponent))
+            {
+                sourceProfile = VolumeManager.instance.qualityDefaultProfile;
+                var assetName = HDRenderPipeline.currentAsset != null ? HDRenderPipeline.currentAsset.name : "HDRP Asset";
+                sourceDescription = $"Quality Profile ({assetName})";
+                return true;
+            }
+
+            // Check global default profile (lower precedence)
+            if (VolumeManager.instance.globalDefaultProfile != null &&
+                VolumeManager.instance.globalDefaultProfile.TryGet<T>(out var globalComponent) &&
+                globalComponent.active && parameterPredicate(globalComponent))
+            {
+                sourceProfile = VolumeManager.instance.globalDefaultProfile;
+                sourceDescription = "Global Profile (Graphics Settings)";
+                return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Shows a platform-specific performance warning help box for a given feature.
         /// </summary>
-        /// <param name="targetPlatform">The build target platform to check and display</param>
         /// <param name="featureName">The name of the feature (e.g., "Ray Tracing", "Film Grain")</param>
         /// <param name="recommendation">Optional recommendation text. If null, uses default "is not recommended for this platform"</param>
-        internal static void ShowPlatformPerformanceWarning(BuildTarget targetPlatform, string featureName, string recommendation = null)
+        internal static void ShowFeatureOptimisationWarning(string featureName, string recommendation = null)
         {
-            if (EditorUserBuildSettings.activeBuildTarget != targetPlatform)
-                return;
+            string message = $"{featureName} is enabled for the active platform.\n";
+
+            if (!string.IsNullOrEmpty(recommendation))
+            {
+                message += recommendation;
+            }
+            else
+            {
+                message += HDRenderPipelineUI.Styles.featureNotRecommendedWarning;
+            }
 
-            var activeBuildTargetGroup = BuildPipeline.GetBuildTargetGroup(targetPlatform);
-            var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(activeBuildTargetGroup);
+            EditorGUILayout.HelpBox(message, MessageType.Warning, wide: true);
+        }
 
-            string message = $"{featureName} is enabled for {namedBuildTarget.TargetName}. ";
+        /// <summary>
+        /// Shows a platform-specific performance warning help box for a given feature.
+        /// </summary>
+        /// <param name="featureName">The name of the feature (e.g., "Ray Tracing", "Film Grain")</param>
+        /// <param name="recommendation">Optional recommendation text. If null, uses default "is not recommended for this platform"</param>
+        internal static void ShowFeatureOptimisationWarning(string featureName, string sourceAssetName, Action onButtonClicked, string recommendation = null)
+        {
+            string message = $"{featureName} is enabled in {sourceAssetName} for the active platform.\n";
 
             if (!string.IsNullOrEmpty(recommendation))
             {
                 message += recommendation;
             }
             else
             {
-                message += "This may significantly impact performance and is not recommended for this platform.";
+                message += HDRenderPipelineUI.Styles.featureNotRecommendedWarning;
             }
 
-            EditorGUILayout.HelpBox(message, MessageType.Warning, wide: true);
+            CoreEditorUtils.DrawFixMeBox(
+                message,
+                MessageType.Warning,
+                "Open",
+                onButtonClicked);
+        }
+
+        internal static void ShowFeatureParameterOptimisationWarning(string settingName, string settingValue, string recommendation = null)
+        {
+            EditorGUILayout.HelpBox(CreateParameterWarningMessage(settingName, settingValue, null, recommendation), MessageType.Warning, wide: true);
+        }
+
+        internal static void ShowFeatureParameterOptimisationWarning(string settingName, string settingValue, string sourceAssetName, Action onButtonClicked, string recommendation = null)
+        {
+            CoreEditorUtils.DrawFixMeBox(
+                CreateParameterWarningMessage(settingName, settingValue, sourceAssetName, recommendation),
+                MessageType.Warning,
+                "Open",
+                onButtonClicked);
+        }
+
+        internal static string CreateParameterWarningMessage(string settingName, string settingValue, string sourceAssetName = null, string recommendation = null)
+        {
+            string message = $"{settingName}: {settingValue} ";
+            if (sourceAssetName != null)
+            {
+                message += $"is set in {sourceAssetName}.";
+            }
+            else
+            {
+                message += $"is used for the active platform.";
+            }
+
+            if (!string.IsNullOrEmpty(recommendation))
+            {
+                message += '\n' + recommendation;
+            }
+            else
+            {
+                message += $"\nThis may impact performance and is not recommended for this platform.";
+            }
+
+            return message;
         }
 
         internal static bool IsInTestSuiteOrBatchMode()

Packages/com.unity.render-pipelines.high-definition/Editor/RenderPipeline/HDEditorUtils.cs

@@ -422,6 +422,10 @@ int CountBits(uint bitMask) // System.Numerics.BitOperations not available
             public static GUIContent staticBatchingInfoMessage =
                 EditorGUIUtility.TrTextContent("Static Batching is not recommended when using GPU draw submission modes, performance may improve if Static Batching is disabled in Player Settings.");
 
+            public static readonly string featureNotRecommendedWarning = L10n.Tr("This feature is not optimized for this platform, enabling it may affect performance.");
+            public static readonly string maxFogBudgetWarning = L10n.Tr("The maximum recommended fog budget for this platform is {0}. Lower the tier to stay under this for optimal performance.");
+            public static readonly string minFogBudgetForDensityCutoffWarning = L10n.Tr("It is recommended to use Density cutoff when the fog budget is > {0} for this platform.");
+
             public const string memoryDrawback = "Adds GPU memory";
             public const string shaderVariantDrawback = "Adds Shader Variants";
             public const string lotShaderVariantDrawback = "Adds multiple Shader Variants";

Packages/com.unity.render-pipelines.high-definition/Editor/RenderPipeline/HDRenderPipelineUI.Skin.cs

@@ -230,6 +230,13 @@ static void Drawer_Volumetric(SerializedHDRenderPipelineAsset serialized, Editor
             }
 
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportVolumetricClouds, Styles.supportVolumetricCloudsContent);
+
+            if (EditorGraphicsSettings.ShouldValidateGraphicsForActiveBuildTarget())
+            {
+                var validationSettings = HDProjectSettings.validationSettings;
+                if (serialized.renderPipelineSettings.supportVolumetricClouds.boolValue && !validationSettings.k_VolumetricClouds_Recommended)
+                    HDEditorUtils.ShowFeatureOptimisationWarning(Styles.volumetricCloudsSubTitle.text);
+            }
         }
 
         static void Drawer_SectionProbeVolume(SerializedHDRenderPipelineAsset serialized, Editor owner)
@@ -1231,6 +1238,13 @@ static void Drawer_SectionHighQualityLineRenderingSettings(SerializedHDRenderPip
         {
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportHighQualityLineRendering, Styles.supportHighQualityLineRenderingContent);
 
+            if (EditorGraphicsSettings.ShouldValidateGraphicsForActiveBuildTarget())
+            {
+                var validationSettings = HDProjectSettings.validationSettings;
+                if (serialized.renderPipelineSettings.supportHighQualityLineRendering.boolValue && !validationSettings.k_HighQualityLineRendering_Recommended)
+                    HDEditorUtils.ShowFeatureOptimisationWarning(Styles.highQualityLineRenderingSubTitle.text);
+            }
+
             ++EditorGUI.indentLevel;
             using (new EditorGUI.DisabledScope(!serialized.renderPipelineSettings.supportHighQualityLineRendering.boolValue))
             {
@@ -1448,7 +1462,7 @@ static void DrawSSGIQualitySetting(SerializedHDRenderPipelineAsset serialized, i
         internal static void DisplayRayTracingSupportBox()
         {
             var currentBuildTarget = EditorUserBuildSettings.activeBuildTarget;
-            if (HDRenderPipeline.PlatformHasRaytracingIssues(currentBuildTarget, out var warning))
+            if (HDRenderPipeline.CheckPlatformRaytracingCompatability(currentBuildTarget, out var warning))
             {
                 EditorGUILayout.HelpBox(warning, MessageType.Warning);
             }
@@ -1604,8 +1618,13 @@ static void Drawer_SectionMaterialUnsorted(SerializedHDRenderPipelineAsset seria
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportDistortion, Styles.supportDistortion);
 
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportSubsurfaceScattering, Styles.supportedSSSContent);
-            if (serialized.renderPipelineSettings.supportSubsurfaceScattering.boolValue)
-                HDEditorUtils.ShowPlatformPerformanceWarning(BuildTarget.Switch2, "Subsurface Scattering");
+
+            if (EditorGraphicsSettings.ShouldValidateGraphicsForActiveBuildTarget())
+            {
+                var validationSettings = HDProjectSettings.validationSettings;
+                if (serialized.renderPipelineSettings.supportSubsurfaceScattering.boolValue && !validationSettings.k_SubsurfaceScattering_Recommended)
+                    HDEditorUtils.ShowFeatureOptimisationWarning(Styles.supportedSSSContent.text);
+            }
 
             using (new EditorGUI.DisabledScope(serialized.renderPipelineSettings.supportSubsurfaceScattering.hasMultipleDifferentValues
                 || !serialized.renderPipelineSettings.supportSubsurfaceScattering.boolValue))

Packages/com.unity.render-pipelines.high-definition/Editor/RenderPipeline/HDRenderPipelineUI.cs

@@ -43,6 +43,36 @@ public override void OnInspectorGUI()
             }
             using var disableScope = new EditorGUI.DisabledScope(notSupported);
 
+            if (!notSupported && EditorGraphicsSettings.ShouldValidateGraphicsForActiveBuildTarget())
+            {
+                var validationSettings = HDProjectSettings.validationSettings;
+                var defaultHQLines = HDEditorUtils.GetVolumeComponentDefaultState<HighQualityLineRenderingVolumeComponent>();
+
+                // Get effective enable value (use local if overridden, otherwise use default)
+                bool useDefaultEnable = !m_Enable.overrideState.boolValue;
+                bool effectiveEnable = useDefaultEnable
+                    ? (defaultHQLines?.enable.value ?? false)
+                    : m_Enable.value.boolValue;
+
+                if (effectiveEnable && !validationSettings.k_HighQualityLineRendering_Recommended)
+                {
+                    using (new IndentLevelScope())
+                    {
+                        if (useDefaultEnable && HDEditorUtils.TryGetVolumeParameterSource<HighQualityLineRenderingVolumeComponent>(
+                              hqLines => hqLines.enable.overrideState && hqLines.enable.value == effectiveEnable,
+                              out var sourceProfile,
+                              out var sourceName))
+                        {
+                            HDEditorUtils.ShowFeatureOptimisationWarning(HDRenderPipelineUI.Styles.highQualityLineRenderingSubTitle.text, sourceName, () => Selection.activeObject = sourceProfile);
+                        }
+                        else
+                        {
+                            HDEditorUtils.ShowFeatureOptimisationWarning(HDRenderPipelineUI.Styles.highQualityLineRenderingSubTitle.text);
+                        }
+                    }
+                }
+            }
+
             EditorGUILayout.LabelField("General", EditorStyles.miniLabel);
             PropertyField(m_Enable);
             PropertyField(m_CompositionMode);