Improve Quality Settings UX for Volume Component Inspector

com.unity.render-pipelines.high-definition/Editor/Lighting/AmbientOcclusionEditor.cs

@@ -37,8 +37,6 @@ class AmbientOcclusionEditor : VolumeComponentWithQualityEditor
 
         public override void OnEnable()
         {
-            base.OnEnable();
-
             var o = new PropertyFetcher<AmbientOcclusion>(serializedObject);
 
             m_Intensity = Unpack(o.Find(x => x.intensity));
@@ -61,6 +59,8 @@ public override void OnEnable()
             m_Denoise = Unpack(o.Find(x => x.denoise));
             m_SampleCount = Unpack(o.Find(x => x.sampleCount));
             m_DenoiserRadius = Unpack(o.Find(x => x.denoiserRadius));
+
+            base.OnEnable();
         }
 
         public override void OnInspectorGUI()
@@ -84,61 +84,111 @@ public override void OnInspectorGUI()
             {
                 PropertyField(m_LayerMask, EditorGUIUtility.TrTextContent("Layer Mask", "Layer mask used to include the objects for ambient occlusion."));
                 base.OnInspectorGUI(); // Quality Setting
-                using (new EditorGUI.DisabledScope(!useCustomValue))
+                using (new QualityScope(this))
                 {
-                    EditorGUI.indentLevel++;
-                    PropertyField(m_RayLength, EditorGUIUtility.TrTextContent("Max Ray Length", "Controls the maximal length of ambient occlusion rays. The higher this value is, the more expensive ray traced ambient occlusion is."));
-                    PropertyField(m_SampleCount, EditorGUIUtility.TrTextContent("Sample Count", "Number of samples for ray traced ambient occlusion."));
-                    PropertyField(m_Denoise, EditorGUIUtility.TrTextContent("Denoise", "Enable denoising on the ray traced ambient occlusion."));
+                    using (new HDEditorUtils.IndentScope())
                     {
-                        EditorGUI.indentLevel++;
-                        PropertyField(m_DenoiserRadius, EditorGUIUtility.TrTextContent("Denoiser Radius", "Radius parameter for the denoising."));
-                        EditorGUI.indentLevel--;
+                        PropertyField(m_RayLength, EditorGUIUtility.TrTextContent("Max Ray Length", "Controls the maximal length of ambient occlusion rays. The higher this value is, the more expensive ray traced ambient occlusion is."));
+                        PropertyField(m_SampleCount, EditorGUIUtility.TrTextContent("Sample Count", "Number of samples for ray traced ambient occlusion."));
+                        PropertyField(m_Denoise, EditorGUIUtility.TrTextContent("Denoise", "Enable denoising on the ray traced ambient occlusion."));
+                        {
+                            using (new HDEditorUtils.IndentScope())
+                                PropertyField(m_DenoiserRadius, EditorGUIUtility.TrTextContent("Denoiser Radius", "Radius parameter for the denoising."));
+                        }
                     }
-                    EditorGUI.indentLevel--;
                 }
             }
             else
             {
-
                 PropertyField(m_Radius, EditorGUIUtility.TrTextContent("Radius", "Sampling radius. Bigger the radius, wider AO will be achieved, risking to lose fine details and increasing cost of the effect due to increasing cache misses."));
 
                 base.OnInspectorGUI(); // Quality Setting
-                using (new EditorGUI.DisabledScope(!useCustomValue))
+
+                using (new QualityScope(this))
                 {
                     PropertyField(m_MaximumRadiusInPixels, EditorGUIUtility.TrTextContent("Maximum Radius In Pixels", "This poses a maximum radius in pixels that we consider. It is very important to keep this as tight as possible to preserve good performance. Note that this is the value used for 1080p when *not* running the effect at full resolution, it will be scaled accordingly for other resolutions."));
                     PropertyField(m_FullResolution, EditorGUIUtility.TrTextContent("Full Resolution", "The effect runs at full resolution. This increases quality, but also decreases performance significantly."));
                     PropertyField(m_StepCount, EditorGUIUtility.TrTextContent("Step Count", "Number of steps to take along one signed direction during horizon search (this is the number of steps in positive and negative direction)."));
-                }
 
-                PropertyField(m_TemporalAccumulation, EditorGUIUtility.TrTextContent("Temporal Accumulation", "Whether the results are accumulated over time or not. This can get better results cheaper, but it can lead to temporal artifacts. Requires Motion Vectors to be enabled."));
-                EditorGUI.indentLevel++;
-                if(!m_TemporalAccumulation.value.boolValue)
-                {
-                    using (new EditorGUI.DisabledScope(!useCustomValue))
-                    {
-                        PropertyField(m_DirectionCount, EditorGUIUtility.TrTextContent("Direction Count", "Number of directions searched for occlusion at each each pixel."));
-                    }
-                    if (m_DirectionCount.value.intValue > 3)
-                    {
-                        EditorGUILayout.HelpBox("Performance will be seriously impacted by high direction count.", MessageType.Warning, wide: true);
-                    }
-                    PropertyField(m_BlurSharpness, EditorGUIUtility.TrTextContent("Blur sharpness", "Modify the non-temporal blur to change how sharp features are preserved. Lower values blurrier/softer, higher values sharper but with risk of noise."));
-                }
-                else
-                {
-                    PropertyField(m_SpatialBilateralAggressiveness, EditorGUIUtility.TrTextContent("Bilateral Aggressiveness", "Higher this value, the less lenient with depth differences the spatial filter is. Increase if for example noticing white halos where AO should be."));
-                    PropertyField(m_GhostingAdjustement, EditorGUIUtility.TrTextContent("Ghosting reduction", "Moving this factor closer to 0 will increase the amount of accepted samples during temporal accumulation, increasing the ghosting, but reducing the temporal noise."));
-                    if (isInAdvancedMode && !m_FullResolution.value.boolValue)
+                    PropertyField(m_TemporalAccumulation, EditorGUIUtility.TrTextContent("Temporal Accumulation", "Whether the results are accumulated over time or not. This can get better results cheaper, but it can lead to temporal artifacts. Requires Motion Vectors to be enabled."));
+
+                    using (new HDEditorUtils.IndentScope())
                     {
-                        using (new EditorGUI.DisabledScope(!useCustomValue))
+                        if(!m_TemporalAccumulation.value.boolValue)
                         {
-                            PropertyField(m_BilateralUpsample, EditorGUIUtility.TrTextContent("Bilateral Upsample", "This upsample method preserves sharp edges better, however can result in visible aliasing and it is slightly more expensive."));
+                            PropertyField(m_DirectionCount, EditorGUIUtility.TrTextContent("Direction Count", "Number of directions searched for occlusion at each each pixel."));
+
+                            if (m_DirectionCount.value.intValue > 3)
+                            {
+                                EditorGUILayout.HelpBox("Performance will be seriously impacted by high direction count.", MessageType.Warning, wide: true);
+                            }
+                            PropertyField(m_BlurSharpness, EditorGUIUtility.TrTextContent("Blur sharpness", "Modify the non-temporal blur to change how sharp features are preserved. Lower values blurrier/softer, higher values sharper but with risk of noise."));
+                        }
+                        else
+                        {
+                            PropertyField(m_SpatialBilateralAggressiveness, EditorGUIUtility.TrTextContent("Bilateral Aggressiveness", "Higher this value, the less lenient with depth differences the spatial filter is. Increase if for example noticing white halos where AO should be."));
+                            PropertyField(m_GhostingAdjustement, EditorGUIUtility.TrTextContent("Ghosting reduction", "Moving this factor closer to 0 will increase the amount of accepted samples during temporal accumulation, increasing the ghosting, but reducing the temporal noise."));
+                            if (isInAdvancedMode && !m_FullResolution.value.boolValue)
+                            {
+                                PropertyField(m_BilateralUpsample, EditorGUIUtility.TrTextContent("Bilateral Upsample", "This upsample method preserves sharp edges better, however can result in visible aliasing and it is slightly more expensive."));
+                            }
                         }
                     }
                 }
-                EditorGUI.indentLevel--;
             }
         }
+
+        public override QualitySettingsBlob SaveCustomQualitySettingsAsObject(QualitySettingsBlob settings = null)
+        {
+            if (settings == null)
+                settings = new QualitySettingsBlob();
+
+            // RTAO
+            settings.Save<float>(m_RayLength);
+            settings.Save<int>(m_SampleCount);
+            settings.Save<bool>(m_Denoise);
+            settings.Save<float>(m_DenoiserRadius);
+
+            // SSAO
+            settings.Save<int>(m_MaximumRadiusInPixels);
+            settings.Save<bool>(m_FullResolution);
+            settings.Save<int>(m_StepCount);
+            settings.Save<int>(m_DirectionCount);
+            settings.Save<bool>(m_BilateralUpsample);
+
+            return settings;
+        }
+
+        public override void LoadSettingsFromObject(QualitySettingsBlob settings)
+        {
+            // RTAO
+            settings.TryLoad<float>(ref m_RayLength);
+            settings.TryLoad<int>(ref m_SampleCount);
+            settings.TryLoad<bool>(ref m_Denoise);
+            settings.TryLoad<float>(ref m_DenoiserRadius);
+
+            // SSAO
+            settings.TryLoad<int>(ref m_MaximumRadiusInPixels);
+            settings.TryLoad<bool>(ref m_FullResolution);
+            settings.TryLoad<int>(ref m_StepCount);
+            settings.TryLoad<int>(ref m_DirectionCount);
+            settings.TryLoad<bool>(ref m_BilateralUpsample);
+        }
+
+        public override void LoadSettingsFromQualityPreset(RenderPipelineSettings settings, int level)
+        {
+            // RTAO
+            CopySetting(ref m_RayLength, settings.lightingQualitySettings.RTAORayLength[level]);
+            CopySetting(ref m_SampleCount, settings.lightingQualitySettings.RTAOSampleCount[level]);
+            CopySetting(ref m_Denoise, settings.lightingQualitySettings.RTAODenoise[level]);
+            CopySetting(ref m_DenoiserRadius, settings.lightingQualitySettings.RTAODenoiserRadius[level]);
+
+            // SSAO
+            CopySetting(ref m_MaximumRadiusInPixels, settings.lightingQualitySettings.AOMaximumRadiusPixels[level]);
+            CopySetting(ref m_FullResolution, settings.lightingQualitySettings.AOFullRes[level]);
+            CopySetting(ref m_StepCount, settings.lightingQualitySettings.AOStepCount[level]);
+            CopySetting(ref m_DirectionCount, settings.lightingQualitySettings.AODirectionCount[level]);
+            CopySetting(ref m_BilateralUpsample, settings.lightingQualitySettings.AOBilateralUpsample[level]);
+        }
     }
 }

com.unity.render-pipelines.high-definition/Editor/Lighting/Reflection/HDScreenSpaceReflectionEditor.cs

@@ -39,8 +39,6 @@ class HDScreenSpaceReflectionEditor : VolumeComponentWithQualityEditor
 
         public override void OnEnable()
         {
-            base.OnEnable();
-
             var o = new PropertyFetcher<ScreenSpaceReflection>(serializedObject);
             m_Enable                        = Unpack(o.Find(x => x.enabled));
             m_RayTracing                    = Unpack(o.Find(x => x.rayTracing));
@@ -70,6 +68,8 @@ public override void OnEnable()
             // Quality
             m_SampleCount                   = Unpack(o.Find(x => x.sampleCount));
             m_BounceCount                   = Unpack(o.Find(x => x.bounceCount));
+
+            base.OnEnable();
         }
 
         static public readonly GUIContent k_RayTracingText = EditorGUIUtility.TrTextContent("Ray Tracing (Preview)", "Enable ray traced reflections.");
@@ -100,20 +100,20 @@ void RayTracingQualityModeGUI()
             PropertyField(m_SampleCount, k_SampleCountText);
             PropertyField(m_BounceCount, k_BounceCountText);
             PropertyField(m_Denoise, k_DenoiseText);
+            using (new HDEditorUtils.IndentScope())
             {
-                EditorGUI.indentLevel++;
                 PropertyField(m_DenoiserRadius, k_DenoiseRadiusText);
-                EditorGUI.indentLevel--;
             }
         }
 
 
         void RayTracingPerformanceModeGUI()
         {
             base.OnInspectorGUI();
-            using (new EditorGUI.DisabledScope(!useCustomValue))
+
+            using (new HDEditorUtils.IndentScope())
+            using (new QualityScope(this))
             {
-                EditorGUI.indentLevel++;
                 PropertyField(m_MinSmoothness, k_MinimumSmoothnessText);
                 PropertyField(m_SmoothnessFadeStart, k_SmoothnessFadeStartText);
                 m_SmoothnessFadeStart.value.floatValue  = Mathf.Max(m_MinSmoothness.value.floatValue, m_SmoothnessFadeStart.value.floatValue);
@@ -122,12 +122,10 @@ void RayTracingPerformanceModeGUI()
                 PropertyField(m_UpscaleRadius, k_UpscaleRadiusText);
                 PropertyField(m_FullResolution, k_FullResolutionText);
                 PropertyField(m_Denoise, k_DenoiseText);
+                using (new HDEditorUtils.IndentScope())
                 {
-                    EditorGUI.indentLevel++;
                     PropertyField(m_DenoiserRadius, k_DenoiseRadiusText);
-                    EditorGUI.indentLevel--;
                 }
-                EditorGUI.indentLevel--;
             }
         }
 
@@ -140,21 +138,23 @@ void RayTracedReflectionGUI()
             if (currentAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Both)
             {
                 PropertyField(m_Mode, k_ModeText);
-                EditorGUI.indentLevel++;
-                switch (m_Mode.value.GetEnumValue<RayTracingMode>())
+
+                using (new HDEditorUtils.IndentScope())
                 {
-                    case RayTracingMode.Performance:
-                    {
-                        RayTracingPerformanceModeGUI();
-                    }
-                    break;
-                    case RayTracingMode.Quality:
+                    switch (m_Mode.value.GetEnumValue<RayTracingMode>())
                     {
-                        RayTracingQualityModeGUI();
+                        case RayTracingMode.Performance:
+                        {
+                            RayTracingPerformanceModeGUI();
+                        }
+                            break;
+                        case RayTracingMode.Quality:
+                        {
+                            RayTracingQualityModeGUI();
+                        }
+                            break;
                     }
-                    break;
                 }
-                EditorGUI.indentLevel--;
             }
             else if (currentAsset.currentPlatformRenderPipelineSettings.supportedRayTracingMode == RenderPipelineSettings.SupportedRayTracingMode.Quality)
             {
@@ -202,14 +202,78 @@ public override void OnInspectorGUI()
                 m_DepthBufferThickness.value.floatValue = Mathf.Clamp(m_DepthBufferThickness.value.floatValue, 0.001f, 1.0f);
 
                 base.OnInspectorGUI();
-                using (new EditorGUI.DisabledScope(!useCustomValue))
+
+                using (new HDEditorUtils.IndentScope())
+                using (new QualityScope(this))
                 {
-                    EditorGUI.indentLevel++;
                     PropertyField(m_RayMaxIterations, k_RayMaxIterationsText);
                     m_RayMaxIterations.value.intValue = Mathf.Max(0, m_RayMaxIterations.value.intValue);
-                    EditorGUI.indentLevel--;
                 }
             }
         }
+        public override QualitySettingsBlob SaveCustomQualitySettingsAsObject(QualitySettingsBlob settings = null)
+        {
+            if (settings == null)
+                settings = new QualitySettingsBlob();
+
+            // RTR
+            if (HDRenderPipeline.pipelineSupportsRayTracing && m_RayTracing.overrideState.boolValue &&
+                m_RayTracing.value.boolValue)
+            {
+                settings.Save<float>(m_MinSmoothness);
+                settings.Save<float>(m_SmoothnessFadeStart);
+                settings.Save<float>(m_RayLength);
+                settings.Save<float>(m_ClampValue);
+                settings.Save<int>(m_UpscaleRadius);
+                settings.Save<bool>(m_FullResolution);
+                settings.Save<bool>(m_Denoise);
+                settings.Save<int>(m_DenoiserRadius);
+            }
+            // SSR
+            else
+                settings.Save<int>(m_RayMaxIterations);
+
+            return settings;
+        }
+
+        public override void LoadSettingsFromObject(QualitySettingsBlob settings)
+        {
+            // RTR
+            if (HDRenderPipeline.pipelineSupportsRayTracing && m_RayTracing.overrideState.boolValue &&
+                m_RayTracing.value.boolValue)
+            {
+                settings.TryLoad<float>(ref m_MinSmoothness);
+                settings.TryLoad<float>(ref m_SmoothnessFadeStart);
+                settings.TryLoad<float>(ref m_RayLength);
+                settings.TryLoad<float>(ref m_ClampValue);
+                settings.TryLoad<int>(ref m_UpscaleRadius);
+                settings.TryLoad<bool>(ref m_FullResolution);
+                settings.TryLoad<bool>(ref m_Denoise);
+                settings.TryLoad<int>(ref m_DenoiserRadius);
+            }
+            // SSR
+            else
+                settings.TryLoad<int>(ref m_RayMaxIterations);
+        }
+
+        public override void LoadSettingsFromQualityPreset(RenderPipelineSettings settings, int level)
+        {
+            // RTR
+            if (HDRenderPipeline.pipelineSupportsRayTracing && m_RayTracing.overrideState.boolValue &&
+                m_RayTracing.value.boolValue)
+            {
+                CopySetting(ref m_MinSmoothness, settings.lightingQualitySettings.RTRMinSmoothness[level]);
+                CopySetting(ref m_SmoothnessFadeStart, settings.lightingQualitySettings.RTRSmoothnessFadeStart[level]);
+                CopySetting(ref m_RayLength, settings.lightingQualitySettings.RTRRayLength[level]);
+                CopySetting(ref m_ClampValue, settings.lightingQualitySettings.RTRClampValue[level]);
+                CopySetting(ref m_UpscaleRadius, settings.lightingQualitySettings.RTRUpScaleRadius[level]);
+                CopySetting(ref m_FullResolution, settings.lightingQualitySettings.RTRFullResolution[level]);
+                CopySetting(ref m_Denoise, settings.lightingQualitySettings.RTRDenoise[level]);
+                CopySetting(ref m_DenoiserRadius, settings.lightingQualitySettings.RTRDenoiserRadius[level]);
+            }
+            // SSR
+            else
+                CopySetting(ref m_RayMaxIterations, settings.lightingQualitySettings.SSRMaxRaySteps[level]);
+        }
     }
 }