Fix serialization for PlanarReflectionProbe

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs

         public static readonly CED.IDrawer SectionProbeModeRealtimeSettings = CED.Action(Drawer_SectionProbeModeRealtimeSettings);
         public static readonly CED.IDrawer SectionBakeButton = CED.Action(Drawer_SectionBakeButton);
 
-        public static readonly CED.IDrawer SectionFoldoutInfluenceSettings = CED.FoldoutGroup(
+        public static readonly CED.IDrawer SectionFoldoutAdditionalSettings = CED.FoldoutGroup(
-                (s, d, o) => s.isSectionExpandedInfluenceSettings,
+                (s, d, o) => s.isSectionExpendedAdditionalSettings,
                 FoldoutOption.Indent,
                 CED.Action(Drawer_SectionInfluenceSettings)
                 );
                         ),
                     CED.Action(Drawer_DifferentShapeError),
                     SectionFoldoutCaptureSettings,
-                    SectionFoldoutInfluenceSettings,
+                    SectionFoldoutAdditionalSettings,
                     CED.Select(
                         (s, d, o) => s.frameSettings,
                         (s, d, o) => d.frameSettings,

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

 {
     partial class PlanarReflectionProbeUI : BaseUI<SerializedPlanarReflectionProbe>
     {
-        const int k_AnimBoolFields = 5;
+        const int k_AnimBoolFields = 6;
         static readonly int k_ReflectionProbeModeModeCount = Enum.GetValues(typeof(ReflectionProbeMode)).Length;
         static readonly int k_AnimBoolTotal = k_AnimBoolFields + k_ReflectionProbeModeModeCount;
 
         public AnimBool isSectionExpandedCaptureMirrorSettings { get { return m_AnimBools[k_ReflectionProbeModeModeCount + 2]; } }
         public AnimBool isSectionExpandedCaptureStaticSettings { get { return m_AnimBools[k_ReflectionProbeModeModeCount + 3]; } }
         public AnimBool isSectionExpendedProxyVolume { get { return m_AnimBools[k_ReflectionProbeModeModeCount + 4]; } }
+        public AnimBool isSectionExpendedAdditionalSettings { get { return m_AnimBools[k_ReflectionProbeModeModeCount + 5]; } }
 
         public bool showCaptureHandles { get; set; }
 
+            isSectionExpandedInfluenceSettings.value = true;
+            isSectionExpandedCaptureSettings.value = true;
+            isSectionExpendedProxyVolume.value = true;
+            isSectionExpendedAdditionalSettings.value = false;
         }
 
         public AnimBool IsSectionExpandedReflectionProbeMode(ReflectionProbeMode mode)

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.Drawers.cs

             {
                 GUILayout.FlexibleSpace();
 
-                bool advanced = s.isSectionAdvancedInfluenceSettings.value;
+                bool advanced = d.editorAdvancedModeEnabled.boolValue;
-                if (s.isSectionAdvancedInfluenceSettings.value ^ advanced)
+                s.boxInfluenceHandle.allHandleControledByOne = s.boxInfluenceNormalHandle.allHandleControledByOne = !advanced;
+                if (d.editorAdvancedModeEnabled.boolValue ^ advanced)
-                    s.isSectionAdvancedInfluenceSettings.value = advanced;
-                    if (!advanced)
+                    d.editorAdvancedModeEnabled.boolValue = advanced;
+                    if (advanced)
-                        d.boxInfluenceNegativeFade.vector3Value = d.boxInfluencePositiveFade.vector3Value = Vector3.one * d.boxInfluencePositiveFade.vector3Value.x;
-                        d.boxInfluenceNormalNegativeFade.vector3Value = d.boxInfluenceNormalPositiveFade.vector3Value = Vector3.one * d.boxInfluenceNormalPositiveFade.vector3Value.x;
+                        d.boxInfluencePositiveFade.vector3Value = d.editorAdvancedModeBlendDistancePositive.vector3Value;
+                        d.boxInfluenceNegativeFade.vector3Value = d.editorAdvancedModeBlendDistanceNegative.vector3Value;
+                        d.boxInfluenceNormalPositiveFade.vector3Value = d.editorAdvancedModeBlendNormalDistancePositive.vector3Value;
+                        d.boxInfluenceNormalNegativeFade.vector3Value = d.editorAdvancedModeBlendNormalDistanceNegative.vector3Value;
+                    else
+                    {
+                        d.boxInfluenceNegativeFade.vector3Value = d.boxInfluencePositiveFade.vector3Value = Vector3.one * d.editorSimplifiedModeBlendDistance.floatValue;
+                        d.boxInfluenceNormalNegativeFade.vector3Value = d.boxInfluenceNormalPositiveFade.vector3Value = Vector3.one * d.editorSimplifiedModeBlendNormalDistance.floatValue;
+                    }
+                    d.Apply();
                 }
             }
         }
+            bool advanced = d.editorAdvancedModeEnabled.boolValue;
             var maxFadeDistance = d.boxBaseSize.vector3Value * 0.5f;
             var minFadeDistance = Vector3.zero;
 
                 d,
                 false,
                 maxFadeDistance,
-                CoreEditorUtils.GetContent("Blend Distance|Area around the probe where it is blended with other probes. Only used in deferred probes."),
-                s.isSectionAdvancedInfluenceSettings
+                CoreEditorUtils.GetContent("Blend Distance|Area around the probe where it is blended with other probes. Only used in deferred probes.")
-            PlanarReflectionProbeUI.Drawer_ToolBarButton(1, o, GUILayout.ExpandHeight(true), GUILayout.Width(28f), GUILayout.MinHeight(22f), GUILayout.MaxHeight((s.isSectionAdvancedInfluenceSettings.value ? 3 : 1) * (EditorGUIUtility.singleLineHeight + 3)));
+            PlanarReflectionProbeUI.Drawer_ToolBarButton(1, o, GUILayout.ExpandHeight(true), GUILayout.Width(28f), GUILayout.MinHeight(22f), GUILayout.MaxHeight((advanced ? 3 : 1) * (EditorGUIUtility.singleLineHeight + 3)));
             EditorGUILayout.EndHorizontal();
 
             EditorGUILayout.BeginHorizontal();
                 maxFadeDistance,
-                CoreEditorUtils.GetContent("Blend Normal Distance|Area around the probe where the normals influence the probe. Only used in deferred probes."),
-                s.isSectionAdvancedInfluenceSettings
+                CoreEditorUtils.GetContent("Blend Normal Distance|Area around the probe where the normals influence the probe. Only used in deferred probes.")
-            PlanarReflectionProbeUI.Drawer_ToolBarButton(2, o, GUILayout.ExpandHeight(true), GUILayout.Width(28f), GUILayout.MinHeight(22f), GUILayout.MaxHeight((s.isSectionAdvancedInfluenceSettings.value ? 3 : 1) * (EditorGUIUtility.singleLineHeight + 3)));
+            PlanarReflectionProbeUI.Drawer_ToolBarButton(2, o, GUILayout.ExpandHeight(true), GUILayout.Width(28f), GUILayout.MinHeight(22f), GUILayout.MaxHeight((advanced ? 3 : 1) * (EditorGUIUtility.singleLineHeight + 3)));
-            if (s.isSectionAdvancedInfluenceSettings.value)
+            if (advanced)
             {
                 CoreEditorUtils.DrawVector6(
                     CoreEditorUtils.GetContent("Face fade|Fade faces of the cubemap."),
 
-        static void Drawer_AdvancedBlendDistance(SerializedInfluenceVolume d, bool isNormal, Vector3 maxBlendDistance, GUIContent content, AnimatedValues.AnimBool advanced)
+        static void Drawer_AdvancedBlendDistance(SerializedInfluenceVolume d, bool isNormal, Vector3 maxBlendDistance, GUIContent content)
         {
             SerializedProperty blendDistancePositive = isNormal ? d.boxInfluenceNormalPositiveFade : d.boxInfluencePositiveFade;
             SerializedProperty blendDistanceNegative = isNormal ? d.boxInfluenceNormalNegativeFade : d.boxInfluenceNegativeFade;
 
             EditorGUILayout.BeginVertical();
 
-            if (advanced.value)
+            if (d.editorAdvancedModeEnabled.boolValue)
             {
                 EditorGUI.BeginChangeCheck();
                 blendDistancePositive.vector3Value = editorAdvancedModeBlendDistancePositive.vector3Value;

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.Handles.cs

             switch (d.shapeType)
             {
                 case ShapeType.Box:
-                {
-                    var center = d.boxBaseOffset;
-                    var size = d.boxBaseSize;
-                    DrawBoxHandle(
-                        s, d, o, sourceAsset,
-                        s1 => s1.boxBaseHandle,
-                        ref center,
-                        ref size);
-                    d.boxBaseOffset = center;
-                    d.boxBaseSize = size;
-                    break;
-                }
+                    {
+                        var center = d.boxBaseOffset;
+                        var size = d.boxBaseSize;
+                        DrawBoxHandle(
+                            s, d, o, sourceAsset,
+                            s1 => s1.boxBaseHandle,
+                            ref center,
+                            ref size);
+                        d.boxBaseOffset = center;
+                        d.boxBaseSize = size;
+                        break;
+                    }
-                {
-                    var center = d.sphereBaseOffset;
-                    var radius = d.sphereBaseRadius;
-                    DrawSphereHandle(
-                        s, d, o, sourceAsset,
-                        s1 => s1.sphereBaseHandle,
-                        ref center,
-                        ref radius);
-                    d.sphereBaseOffset = center;
-                    d.sphereBaseRadius = radius;
-                    break;
-                }
+                    {
+                        var center = d.sphereBaseOffset;
+                        var radius = d.sphereBaseRadius;
+                        DrawSphereHandle(
+                            s, d, o, sourceAsset,
+                            s1 => s1.sphereBaseHandle,
+                            ref center,
+                            ref radius);
+                        d.sphereBaseOffset = center;
+                        d.sphereBaseRadius = radius;
+                        break;
+                    }
             }
             Handles.matrix = mat;
             Handles.color = c;
             switch (d.shapeType)
             {
                 case ShapeType.Box:
-                {
-                    var positive = d.boxInfluencePositiveFade;
-                    var negative = d.boxInfluenceNegativeFade;
-                    DrawBoxFadeHandle(
-                        s, d, o, sourceAsset,
-                        s1 => s1.boxInfluenceHandle,
-                        d.boxBaseOffset, d.boxBaseSize,
-                        ref positive,
-                        ref negative);
-                    d.boxInfluencePositiveFade = positive;
-                    d.boxInfluenceNegativeFade = negative;
-                    break;
-                }
+                    {
+                        var positive = d.boxInfluencePositiveFade;
+                        var negative = d.boxInfluenceNegativeFade;
+                        DrawBoxFadeHandle(
+                            s, d, o, sourceAsset,
+                            s1 => s1.boxInfluenceHandle,
+                            d.boxBaseOffset, d.boxBaseSize,
+                            ref positive,
+                            ref negative);
+                        s.data.boxInfluencePositiveFade.vector3Value = positive;
+                        s.data.boxInfluenceNegativeFade.vector3Value = negative;
+
+                        //save advanced/simplified saved data
+                        if (s.data.editorAdvancedModeEnabled.boolValue)
+                        {
+                            s.data.editorAdvancedModeBlendDistancePositive.vector3Value = positive;
+                            s.data.editorAdvancedModeBlendDistanceNegative.vector3Value = negative;
+                        }
+                        else
+                        {
+                            s.data.editorSimplifiedModeBlendDistance.floatValue = positive.x;
+                        }
+                        s.data.Apply();
+                        break;
+                    }
-                {
-                    var fade = d.sphereInfluenceFade;
-                    DrawSphereFadeHandle(
-                        s, d, o, sourceAsset,
-                        s1 => s1.sphereInfluenceHandle,
-                        d.sphereBaseOffset, d.sphereBaseRadius,
-                        ref fade);
-                    d.sphereInfluenceFade = fade;
-                    break;
-                }
+                    {
+                        var fade = d.sphereInfluenceFade;
+                        DrawSphereFadeHandle(
+                            s, d, o, sourceAsset,
+                            s1 => s1.sphereInfluenceHandle,
+                            d.sphereBaseOffset, d.sphereBaseRadius,
+                            ref fade);
+                        d.sphereInfluenceFade = fade;
+                        break;
+                    }
             }
             Handles.matrix = mat;
             Handles.color = c;
             switch (d.shapeType)
             {
                 case ShapeType.Box:
-                {
-                    var positive = d.boxInfluenceNormalPositiveFade;
-                    var negative = d.boxInfluenceNormalNegativeFade;
-                    DrawBoxFadeHandle(
-                        s, d, o, sourceAsset,
-                        s1 => s1.boxInfluenceNormalHandle,
-                        d.boxBaseOffset, d.boxBaseSize,
-                        ref positive,
-                        ref negative);
-                    d.boxInfluenceNormalPositiveFade = positive;
-                    d.boxInfluenceNormalNegativeFade = negative;
-                    break;
-                }
+                    {
+
+                        Vector3 positive = d.boxInfluenceNormalPositiveFade;
+                        Vector3 negative = d.boxInfluenceNormalNegativeFade;
+                        DrawBoxFadeHandle(
+                            s, d, o, sourceAsset,
+                            s1 => s1.boxInfluenceNormalHandle,
+                            d.boxBaseOffset, d.boxBaseSize,
+                            ref positive,
+                            ref negative);
+                        s.data.boxInfluenceNormalPositiveFade.vector3Value = positive;
+                        s.data.boxInfluenceNormalNegativeFade.vector3Value = negative;
+
+                        //save advanced/simplified saved data
+                        if (s.data.editorAdvancedModeEnabled.boolValue)
+                        {
+                            s.data.editorAdvancedModeBlendNormalDistancePositive.vector3Value = positive;
+                            s.data.editorAdvancedModeBlendNormalDistanceNegative.vector3Value = negative;
+                        }
+                        else
+                        {
+                            s.data.editorSimplifiedModeBlendNormalDistance.floatValue = positive.x;
+                        }
+                        s.data.Apply();
+                        break;
+                    }
-                {
-                    var fade = d.sphereInfluenceNormalFade;
-                    DrawSphereFadeHandle(
-                        s, d, o, sourceAsset,
-                        s1 => s1.sphereInfluenceNormalHandle,
-                        d.sphereBaseOffset, d.sphereBaseRadius,
-                        ref fade);
-                    d.sphereInfluenceNormalFade = fade;
-                    break;
-                }
+                    {
+                        var fade = d.sphereInfluenceNormalFade;
+                        DrawSphereFadeHandle(
+                            s, d, o, sourceAsset,
+                            s1 => s1.sphereInfluenceNormalHandle,
+                            d.sphereBaseOffset, d.sphereBaseRadius,
+                            ref fade);
+                        d.sphereInfluenceNormalFade = fade;
+                        break;
+                    }
             }
             Handles.matrix = mat;
             Handles.color = c;
 
             b.center = baseOffset - (positive - negative) * 0.5f;
             b.size = baseSize - positive - negative;
+            b.allHandleControledByOne = !s.data.editorAdvancedModeEnabled.boolValue;
 
             EditorGUI.BeginChangeCheck();
             b.DrawHandle();

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.cs

         public SphereBoundsHandle sphereInfluenceNormalHandle = new SphereBoundsHandle();
 
         public AnimBool isSectionExpandedShape { get { return m_AnimBools[k_ShapeCount]; } }
-        public AnimBool isSectionAdvancedInfluenceSettings  { get { return m_AnimBools[k_ShapeCount + 1]; } }
-            isSectionAdvancedInfluenceSettings.value = false;
+            isSectionExpandedShape.value = true;
 
             boxBaseHandle = new Gizmo6FacesBox(monochromeFace:true, monochromeSelectedFace:true);
             boxInfluenceHandle = new Gizmo6FacesBoxContained(boxBaseHandle, monochromeFace:true, monochromeSelectedFace:true);

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/SerializedInfluenceVolume.cs

                 editorAdvancedModeEnabled.boolValue = true;
             }
         }
+
+        public void Apply()
+        {
+            root.serializedObject.ApplyModifiedProperties();
+        }
     }
 }