[HDRP]Make sure we show warnings on the inspector and when building when some features are not available or have performance impact.

Author: alex-vazquez-unity3d

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

@@ -43,10 +43,72 @@ public void OnPreprocessBuild(BuildReport report)
 
                 LogIncludedAssets(m_BuildData.renderPipelineAssets);
 
+                if (!IsConfigurationValid())
+                {
+                    if(!ProceedWithBuild())
+                        throw new BuildFailedException("Build canceled by user due to HDRP configuration issues.");
+                }
+                    
+
                 GatherShaderFeatures();
             }
         }
 
+        private static bool IsConfigurationValid()
+        {
+            // Validate the configuration of the HDRP assets for the current build target. We want to make sure that users are aware of potential performance issues or unsupported features before building.
+            // We still want to build the player even if the configuration is not optimal, but we log warnings to inform users about potential issues.
+            // Note that we validate the configuration of all HDRP assets included in the build, not just the one assigned in Graphics Settings.
+            // This is because users can have multiple HDRP assets in their project and switch between them at runtime, so we want to make sure that all of them are correctly configured for the target platform.
+
+            // We must log all the warnings, and avoid doing validConfiguration &= ValidationXXX, that will avoid logging all the warnings, and only log the first one that fails.
+            // This way users will have a complete overview of all the potential issues with their configuration, and can fix them all at once, instead of having to go through multiple build iterations to fix each issue one by one.
+            // So be carefull when you edit this code, and make sure to log all the warnings, even if one of the validation fails.
+            bool validConfiguration = true;
+
+            {
+                bool config = ValidateRayTracingConfiguration(m_BuildData.renderPipelineAssets);
+                validConfiguration &= config;
+            }
+
+            {
+                bool config = ValidateSubsurfaceScatteringConfiguration(m_BuildData.renderPipelineAssets);
+                validConfiguration &= config;
+            }
+
+            {
+                bool config = ValidateFilmGrainConfiguration(m_BuildData.renderPipelineAssets);
+                validConfiguration &= config;
+            }
+
+            return validConfiguration;
+        }
+
+        internal static string k_DialogKey = $"{nameof(UnityEditor)}.{nameof(Rendering)}.{nameof(HighDefinition)}.{nameof(HDRPPreprocessBuild)}.{nameof(ProceedWithBuild)}";
+
+        private bool ProceedWithBuild()
+        {
+            if(HDEditorUtils.IsInTestSuiteOrBatchMode())
+                return true;
+
+            var title = "Build Configuration Issues Detected";
+            var body = new StringBuilder();
+
+            body.AppendLine("HDRP identified settings that may impact performance or enable unsupported features for the current build target.");
+            body.AppendLine("Review the Console for details (look for messages tagged 'HDRP Build Validation').");
+            body.AppendLine();
+            body.Append("Do you want to continue building?");
+
+            return EditorUtility.DisplayDialog(
+                title,
+                body.ToString(),
+                "Proceed",
+                "Cancel",
+                DialogOptOutDecisionType.ForThisMachine,
+                k_DialogKey
+            );
+        }
+
         internal static void LogIncludedAssets(List<HDRenderPipelineAsset> assetsList)
         {
             using (GenericPool<StringBuilder>.Get(out var assetsIncluded))
@@ -64,6 +126,104 @@ internal static void LogIncludedAssets(List<HDRenderPipelineAsset> assetsList)
             }
         }
 
+        internal static bool ValidateRayTracingConfiguration(List<HDRenderPipelineAsset> assetsList)
+        {
+            // Check if any asset has ray tracing enabled
+            bool anyAssetHasRayTracingEnabled = false;
+            foreach (var hdrpAsset in assetsList)
+            {
+                if (hdrpAsset != null && hdrpAsset.currentPlatformRenderPipelineSettings.supportRayTracing)
+                {
+                    anyAssetHasRayTracingEnabled = true;
+                    break;
+                }
+            }
+
+            if (!anyAssetHasRayTracingEnabled)
+                return true; // No ray tracing enabled, skip validation
+
+            var currentBuildTarget = EditorUserBuildSettings.activeBuildTarget;
+            if (HDRenderPipeline.PlatformHasRaytracingIssues(currentBuildTarget, out var warning))
+            {
+                Debug.LogWarning($"HDRP Build Validation - Ray Tracing:{warning}");
+                return false;
+            }
+
+            return true;
+        }
+
+        internal static bool ValidateSubsurfaceScatteringConfiguration(List<HDRenderPipelineAsset> assetsList)
+        {
+            var currentBuildTarget = EditorUserBuildSettings.activeBuildTarget;
+
+            // Only validate for Switch 2
+            if (currentBuildTarget != BuildTarget.Switch2)
+                return true;
+
+            // Check if any asset has Subsurface Scattering enabled
+            bool anyAssetHasSSSEnabled = false;
+            foreach (var hdrpAsset in assetsList)
+            {
+                if (hdrpAsset != null && hdrpAsset.currentPlatformRenderPipelineSettings.supportSubsurfaceScattering)
+                {
+                    anyAssetHasSSSEnabled = true;
+                    break;
+                }
+            }
+
+            if (!anyAssetHasSSSEnabled)
+                return true; // No SSS enabled, skip validation
+
+            var activeBuildTargetGroup = BuildPipeline.GetBuildTargetGroup(BuildTarget.Switch2);
+            var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(activeBuildTargetGroup);
+            Debug.LogWarning($"HDRP Build Validation - Subsurface Scattering: Subsurface Scattering is enabled for {namedBuildTarget.TargetName}. For optimal performance, set the Downsample Level to the maximum value (2) for this platform.");
+            return false;
+        }
+
+        internal static bool ValidateFilmGrainConfiguration(List<HDRenderPipelineAsset> assetsList)
+        {
+            var currentBuildTarget = EditorUserBuildSettings.activeBuildTarget;
+
+            // Only validate for Switch 2
+            if (currentBuildTarget != BuildTarget.Switch2)
+                return true;
+
+            // Check default volume profile from HDRP Global Settings
+            bool foundFilmGrain = false;
+            var defaultVolumeProfileSettings = GraphicsSettings.GetRenderPipelineSettings<HDRPDefaultVolumeProfileSettings>();
+            if (defaultVolumeProfileSettings?.volumeProfile != null)
+            {
+                if (defaultVolumeProfileSettings.volumeProfile.TryGet<FilmGrain>(out var filmGrain) && filmGrain.intensity.value > 0)
+                {
+                    foundFilmGrain = true;
+                }
+            }
+
+            // Check volume profiles in each HDRP asset
+            if (!foundFilmGrain)
+            {
+                foreach (var hdrpAsset in assetsList)
+                {
+                    if (hdrpAsset != null && hdrpAsset.volumeProfile != null)
+                    {
+                        if (hdrpAsset.volumeProfile.TryGet<FilmGrain>(out var filmGrain) && filmGrain.intensity.value > 0)
+                        {
+                            foundFilmGrain = true;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (!foundFilmGrain)
+                return true; // No Film Grain with intensity > 0, skip validation
+
+            var activeBuildTargetGroup = BuildPipeline.GetBuildTargetGroup(BuildTarget.Switch2);
+            var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(activeBuildTargetGroup);
+            Debug.LogWarning($"HDRP Build Validation - Film Grain: Film Grain is enabled for {namedBuildTarget.TargetName}. This may significantly impact performance and should be disabled for this platform.");
+            return false;
+        }
+
         internal static void ConfigureMinimumMaxLoDValueForAllQualitySettings()
         {
             int GetMinimumMaxLoDValue(HDRenderPipelineAsset asset)

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

@@ -1,4 +1,3 @@
-using UnityEditor.Rendering;
 using UnityEngine;
 using UnityEngine.Rendering.HighDefinition;
 
@@ -26,6 +25,9 @@ public override void OnInspectorGUI()
         {
             HDEditorUtils.EnsureFrameSetting(FrameSettingsField.FilmGrain);
 
+            if (m_Intensity.value.floatValue > 0)
+                HDEditorUtils.ShowPlatformPerformanceWarning(BuildTarget.Switch2, "Film Grain");
+
             PropertyField(m_Type);
 
             if (m_Type.value.intValue == (int)FilmGrainLookup.Custom)

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

@@ -2,12 +2,12 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using UnityEditor.Build;
 using UnityEditor.Inspector.GraphicsSettingsInspectors;
 using UnityEngine;
+using UnityEngine.Rendering;
 using UnityEngine.Rendering.HighDefinition;
 using UnityEngine.UIElements;
-using RenderingLayerMask = UnityEngine.RenderingLayerMask;
-using UnityEngine.Rendering;
 
 namespace UnityEditor.Rendering.HighDefinition
 {
@@ -436,6 +436,41 @@ internal static bool EnsureVolume<T>(Func<T, string> volumeValidator) where T :
 
             return true;
         }
+
+        /// <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)
+        {
+            if (EditorUserBuildSettings.activeBuildTarget != targetPlatform)
+                return;
+
+            var activeBuildTargetGroup = BuildPipeline.GetBuildTargetGroup(targetPlatform);
+            var namedBuildTarget = NamedBuildTarget.FromBuildTargetGroup(activeBuildTargetGroup);
+
+            string message = $"{featureName} is enabled for {namedBuildTarget.TargetName}. ";
+
+            if (!string.IsNullOrEmpty(recommendation))
+            {
+                message += recommendation;
+            }
+            else
+            {
+                message += "This may significantly impact performance and is not recommended for this platform.";
+            }
+
+            EditorGUILayout.HelpBox(message, MessageType.Warning, wide: true);
+        }
+
+        internal static bool IsInTestSuiteOrBatchMode()
+        {
+            string commandLineOptions = System.Environment.CommandLine;
+            bool inTestSuite = commandLineOptions.Contains("-testResults");
+            return inTestSuite || Application.isBatchMode;
+        }
     }
 
     // Due to a UI bug/limitation, we have to do it this way to support bold labels

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

@@ -185,7 +185,8 @@ public class Styles
             public static readonly GUIContent supportRaytracing = EditorGUIUtility.TrTextContent("Realtime Raytracing");
             public static readonly GUIContent supportedRayTracingMode = EditorGUIUtility.TrTextContent("Supported Ray Tracing Mode");
             public static readonly GUIContent supportVFXRayTracing = EditorGUIUtility.TrTextContent("Visual Effects Ray Tracing", "When enabled, Visual Effects Outputs which have Enable Ray Tracing on will be accounted for in Ray-traced effects.");
-            public static readonly GUIContent rayTracingRestrictionOnlyWarning = EditorGUIUtility.TrTextContent("Ray tracing is currently only supported on DX12, Playstation 5 and Xbox Series X.", null, CoreEditorStyles.iconWarn);
+            public static readonly GUIContent rayTracingRestrictionOnlyWarning = EditorGUIUtility.TrTextContent("Ray tracing requires DX12 on Windows. Disable Auto Graphics API and set Direct3D 12 as the first Graphics API in Player Settings. You can use the HDRP Wizard to configure these settings.", null, CoreEditorStyles.iconWarn);
+            public static string rayTracingNotSupportedBuildTarget = L10n.Tr("The {0} does not support Ray tracing. Consider disabling it or switch to a platform that supports it.");
             public static readonly GUIContent rayTracingMSAAUnsupported = EditorGUIUtility.TrTextContent("When Ray tracing is enabled in asset, MSAA is not supported. Please refer to the documentation.");
             public static readonly GUIContent waterMSAAUnsupported = EditorGUIUtility.TrTextContent("When Water is enabled in asset, MSAA is not supported. Please refer to the documentation.");
             public static readonly GUIContent maximumLODLevel = EditorGUIUtility.TrTextContent("Maximum LOD Level");

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

@@ -1,12 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using UnityEngine;
 using Unity.Mathematics;
+using UnityEditorInternal;
+using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.HighDefinition;
-using UnityEditorInternal;
 using static UnityEngine.Rendering.HighDefinition.RenderPipelineSettings;
 
 namespace UnityEditor.Rendering.HighDefinition
@@ -1442,12 +1442,11 @@ static void DrawSSGIQualitySetting(SerializedHDRenderPipelineAsset serialized, i
 
         internal static void DisplayRayTracingSupportBox()
         {
-            CoreEditorUtils.DrawFixMeBox(Styles.rayTracingRestrictionOnlyWarning, "Open", () =>
+            var currentBuildTarget = EditorUserBuildSettings.activeBuildTarget;
+            if (HDRenderPipeline.PlatformHasRaytracingIssues(currentBuildTarget, out var warning))
             {
-                HDUserSettings.SetOpen(InclusiveMode.DXROptional, true); // Make sure DXR is open
-                HDWizard.OpenWindow();
-            });
-
+                EditorGUILayout.HelpBox(warning, MessageType.Warning);
+            }
         }
 
         static void Drawer_SectionRenderingUnsorted(SerializedHDRenderPipelineAsset serialized, Editor owner)
@@ -1509,19 +1508,18 @@ static void Drawer_SectionRenderingUnsorted(SerializedHDRenderPipelineAsset seri
 
             EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportRayTracing, Styles.supportRaytracing);
 
+            // If ray tracing is enabled by the asset but the current system does not support it display a warning
+            if (serialized.renderPipelineSettings.supportRayTracing.boolValue)
+            {
+                DisplayRayTracingSupportBox();
+            }
+
             using (new EditorGUI.DisabledScope(!serialized.renderPipelineSettings.supportRayTracing.boolValue))
             {
                 ++EditorGUI.indentLevel;
                 EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportedRayTracingMode, Styles.supportedRayTracingMode);
                 EditorGUILayout.PropertyField(serialized.renderPipelineSettings.supportVFXRayTracing,
                     Styles.supportVFXRayTracing);
-
-                // If ray tracing is enabled by the asset but the current system does not support it display a warning
-                if (!HDRenderPipeline.currentSystemSupportsRayTracing)
-                {
-                    if (serialized.renderPipelineSettings.supportRayTracing.boolValue)
-                        DisplayRayTracingSupportBox();
-                }
                 --EditorGUI.indentLevel;
             }
 
@@ -1601,6 +1599,9 @@ 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");
+
             using (new EditorGUI.DisabledScope(serialized.renderPipelineSettings.supportSubsurfaceScattering.hasMultipleDifferentValues
                 || !serialized.renderPipelineSettings.supportSubsurfaceScattering.boolValue))
             {

Packages/com.unity.render-pipelines.high-definition/Editor/Wizard/HDWizard.Configuration.cs

@@ -204,7 +204,7 @@ Entry[] BuildEntryList()
             });
 
             var currentBuildTarget = CalculateSelectedBuildTarget();
-            if ((currentBuildTarget == BuildTarget.PS5) || (currentBuildTarget == BuildTarget.GameCoreXboxSeries))
+            if ((currentBuildTarget == BuildTarget.PS5) || (currentBuildTarget == BuildTarget.GameCoreXboxSeries) || (currentBuildTarget == BuildTarget.Switch2))
             {
                 entryList.AddRange(new[]
                 {