[WIP] Serializing editor only parameters for advance/simplified mode of influence settings box

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

                 default:
                 case InfluenceType.Standard:
                     {
-                        sp.targetData.blendDistancePositive = probeBlendDistancePositive;
-                        sp.targetData.blendDistanceNegative = probeBlendDistanceNegative;
+                        sp.blendDistancePositive.vector3Value = probeBlendDistancePositive;
+                        sp.blendDistanceNegative.vector3Value = probeBlendDistanceNegative;
+
+                        if(sp.editorAdvancedModeEnabled.boolValue)
+                        {
+                            //save advanced/simplified saved data
+                            sp.editorAdvancedModeBlendDistancePositive.vector3Value = probeBlendDistancePositive;
+                            sp.editorAdvancedModeBlendDistanceNegative.vector3Value = probeBlendDistanceNegative;
+                        }
+                        else
+                        {
+                            sp.editorSimplifiedModeBlendDistance.floatValue = probeBlendDistancePositive.x;
+                        }
-                        sp.targetData.blendNormalDistancePositive = probeBlendDistancePositive;
-                        sp.targetData.blendNormalDistanceNegative = probeBlendDistanceNegative;
+                        sp.blendNormalDistancePositive.vector3Value = probeBlendDistancePositive;
+                        sp.blendNormalDistanceNegative.vector3Value = probeBlendDistanceNegative;
+
+                        if(sp.editorAdvancedModeEnabled.boolValue)
+                        {
+                            //save advanced/simplified saved data
+                            sp.editorAdvancedModeBlendNormalDistancePositive.vector3Value = probeBlendDistancePositive;
+                            sp.editorAdvancedModeBlendNormalDistanceNegative.vector3Value = probeBlendDistanceNegative;
+                        }
+                        else
+                        {
+                            sp.editorSimplifiedModeBlendNormalDistance.floatValue = probeBlendDistancePositive.x;
+                        }
+            sp.Apply();
         }
 
         static void Handle_InfluenceEditing(HDReflectionProbeUI s, SerializedHDReflectionProbe sp, Editor o)

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

 
         static void Drawer_InfluenceBoxSettings(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor owner)
         {
+            bool advanced = p.editorAdvancedModeEnabled.boolValue;
-                p.blendDistancePositive,
-                p.blendDistanceNegative,
+                p,
+                false,
-                s.isSectionAdvancedInfluenceSettings
+                advanced
-            if (GUILayout.Button(toolbar_Contents[1], GUILayout.ExpandHeight(true), GUILayout.Width(28f), GUILayout.MinHeight(22f), GUILayout.MaxHeight((s.isSectionAdvancedInfluenceSettings.value ? 3 : 1) * (EditorGUIUtility.singleLineHeight + 3))))
+            if (GUILayout.Button(toolbar_Contents[1], GUILayout.ExpandHeight(true), GUILayout.Width(28f), GUILayout.MinHeight(22f), GUILayout.MaxHeight((advanced ? 3 : 1) * (EditorGUIUtility.singleLineHeight + 3))))
             {
                 EditMode.ChangeEditMode(k_Toolbar_SceneViewEditModes[1], GetBoundsGetter(p)(), owner);
             }
             Drawer_AdvancedBlendDistance(
-                p.blendNormalDistancePositive,
-                p.blendNormalDistanceNegative,
+                p,
+                true,
-                s.isSectionAdvancedInfluenceSettings
+                advanced
-            if (GUILayout.Button(toolbar_Contents[2], GUILayout.ExpandHeight(true), GUILayout.Width(28f), GUILayout.MinHeight(22f), GUILayout.MaxHeight((s.isSectionAdvancedInfluenceSettings.value ? 3 : 1) * (EditorGUIUtility.singleLineHeight + 3))))
+            if (GUILayout.Button(toolbar_Contents[2], 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."),
 
-        public static void Drawer_AdvancedBlendDistance(SerializedProperty blendDistancePositive, SerializedProperty blendDistanceNegative, Vector3 maxBlendDistance, GUIContent content, AnimatedValues.AnimBool advanced)
+        static void Drawer_AdvancedBlendDistance(SerializedHDReflectionProbe p, bool isNormal, Vector3 maxBlendDistance, GUIContent content, bool advanced)
+            SerializedProperty blendDistancePositive = isNormal ? p.blendNormalDistancePositive : p.blendDistancePositive;
+            SerializedProperty blendDistanceNegative = isNormal ? p.blendNormalDistanceNegative : p.blendDistanceNegative;
+            SerializedProperty editorAdvancedModeBlendDistancePositive = isNormal ? p.editorAdvancedModeBlendNormalDistancePositive : p.editorAdvancedModeBlendDistancePositive;
+            SerializedProperty editorAdvancedModeBlendDistanceNegative = isNormal ? p.editorAdvancedModeBlendNormalDistanceNegative : p.editorAdvancedModeBlendDistanceNegative;
+            SerializedProperty editorSimplifiedModeBlendDistance = isNormal ? p.editorSimplifiedModeBlendNormalDistance : p.editorSimplifiedModeBlendDistance;
-            if (advanced.value)
+            if (advanced)
+                EditorGUI.BeginChangeCheck();
+                Debug.Log(editorAdvancedModeBlendDistancePositive.vector3Value + " " + editorAdvancedModeBlendDistanceNegative.vector3Value);
-                    blendDistancePositive, blendDistanceNegative, Vector3.zero, maxBlendDistance, HDReflectionProbeEditor.k_handlesColor);
+                    editorAdvancedModeBlendDistancePositive, editorAdvancedModeBlendDistanceNegative, Vector3.zero, maxBlendDistance, HDReflectionProbeEditor.k_handlesColor);
+                if(EditorGUI.EndChangeCheck())
+                {
+                    blendDistancePositive.vector3Value = editorAdvancedModeBlendDistancePositive.vector3Value;
+                    blendDistanceNegative.vector3Value = editorAdvancedModeBlendDistanceNegative.vector3Value;
+                    p.Apply();
+                }
-                float distance = bdp.x;
+                float distance = editorSimplifiedModeBlendDistance.floatValue;
                 EditorGUI.BeginChangeCheck();
                 distance = EditorGUILayout.FloatField(content, distance);
                 if (EditorGUI.EndChangeCheck())
                     bdn.z = Mathf.Clamp(decal.z, 0f, maxBlendDistance.z);
                     blendDistancePositive.vector3Value = bdp;
                     blendDistanceNegative.vector3Value = bdn;
+                    editorSimplifiedModeBlendDistance.floatValue = distance;
+                    p.Apply();
                 }
             }
 
             {
                 GUILayout.FlexibleSpace();
 
-                bool advanced = s.isSectionAdvancedInfluenceSettings.value;
+                bool advanced = p.editorAdvancedModeEnabled.boolValue;
-                if (s.isSectionAdvancedInfluenceSettings.value ^ advanced)
+                if (p.editorAdvancedModeEnabled.boolValue ^ advanced)
-                    s.isSectionAdvancedInfluenceSettings.value = advanced;
-                    if (!advanced)
+                    p.editorAdvancedModeEnabled.boolValue = advanced;
+                    if (advanced)
+                    {
+                        p.blendDistancePositive.vector3Value = p.editorAdvancedModeBlendDistancePositive.vector3Value;
+                        p.blendDistanceNegative.vector3Value = p.editorAdvancedModeBlendDistanceNegative.vector3Value;
+                        p.blendNormalDistancePositive.vector3Value = p.editorAdvancedModeBlendNormalDistancePositive.vector3Value;
+                        p.blendNormalDistanceNegative.vector3Value = p.editorAdvancedModeBlendNormalDistanceNegative.vector3Value;
+                    }
+                    else
-                        p.blendDistanceNegative.vector3Value = p.blendDistancePositive.vector3Value = Vector3.one *  p.blendDistancePositive.vector3Value.x;
-                        p.blendNormalDistanceNegative.vector3Value = p.blendNormalDistancePositive.vector3Value = Vector3.one *  p.blendNormalDistancePositive.vector3Value.x;
+                        p.blendDistanceNegative.vector3Value = p.blendDistancePositive.vector3Value = Vector3.one * p.editorSimplifiedModeBlendDistance.floatValue;
+                        p.blendNormalDistanceNegative.vector3Value = p.blendNormalDistancePositive.vector3Value = Vector3.one * p.editorSimplifiedModeBlendNormalDistance.floatValue;
+                    s.alternativeBoxBlendHandle.allHandleControledByOne = s.alternativeBoxBlendNormalHandle.allHandleControledByOne = !advanced;
+                    p.Apply();
                 }
             }
         }

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

 {
     public partial class HDReflectionProbeUI : BaseUI<SerializedHDReflectionProbe>
     {
-        const int k_AnimBoolSingleFieldCount = 5;
+        const int k_AnimBoolSingleFieldCount = 4;
         static readonly int k_ReflectionProbeModeCount = Enum.GetValues(typeof(ReflectionProbeMode)).Length;
         static readonly int k_ReflectionInfluenceShapeCount = Enum.GetValues(typeof(ShapeType)).Length;
         static readonly int k_AnimBoolsCount = k_ReflectionProbeModeCount + k_ReflectionInfluenceShapeCount + k_AnimBoolSingleFieldCount;
         public AnimBool isSectionExpandedInfluenceVolume { get { return m_AnimBools[1]; } }
         public AnimBool isSectionExpandedCaptureSettings { get { return m_AnimBools[2]; } }
         public AnimBool isSectionExpandedAdditional { get { return m_AnimBools[3]; } }
-        public AnimBool isSectionAdvancedInfluenceSettings { get { return m_AnimBools[4]; } }
 
         public bool HasAndClearOperation(Operation op)
         {
             isSectionExpandedCaptureSettings.value = true;
             isSectionExpandedInfluenceVolume.value = true;
             isSectionExpandedAdditional.value = false;
-            isSectionAdvancedInfluenceSettings.value = false;
 
             alternativeBoxInfluenceHandle = new Gizmo6FacesBox(monochromeFace:true, monochromeSelectedFace:true);
             alternativeBoxBlendHandle = new Gizmo6FacesBoxContained(alternativeBoxInfluenceHandle, monochromeFace:true, monochromeSelectedFace:true);

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

         internal SerializedProperty weight;
         internal SerializedProperty multiplier;
 
+        internal SerializedProperty editorAdvancedModeBlendDistancePositive;
+        internal SerializedProperty editorAdvancedModeBlendDistanceNegative;
+        internal SerializedProperty editorSimplifiedModeBlendDistance;
+        internal SerializedProperty editorAdvancedModeBlendNormalDistancePositive;
+        internal SerializedProperty editorAdvancedModeBlendNormalDistanceNegative;
+        internal SerializedProperty editorSimplifiedModeBlendNormalDistance;
+        internal SerializedProperty editorAdvancedModeEnabled;
+
         internal SerializedProperty proxyVolumeComponent;
 
         public SerializedHDReflectionProbe(SerializedObject so, SerializedObject addso)
             blendNormalDistanceNegative = addso.Find((HDAdditionalReflectionData d) => d.blendNormalDistanceNegative);
             boxSideFadePositive = addso.Find((HDAdditionalReflectionData d) => d.boxSideFadePositive);
             boxSideFadeNegative = addso.Find((HDAdditionalReflectionData d) => d.boxSideFadeNegative);
+
+            editorAdvancedModeBlendDistancePositive = addso.FindProperty("editorAdvancedModeBlendDistancePositive");
+            editorAdvancedModeBlendDistanceNegative = addso.FindProperty("editorAdvancedModeBlendDistanceNegative");
+            editorSimplifiedModeBlendDistance = addso.FindProperty("editorSimplifiedModeBlendDistance");
+            editorAdvancedModeBlendNormalDistancePositive = addso.FindProperty("editorAdvancedModeBlendNormalDistancePositive");
+            editorAdvancedModeBlendNormalDistanceNegative = addso.FindProperty("editorAdvancedModeBlendNormalDistanceNegative");
+            editorSimplifiedModeBlendNormalDistance = addso.FindProperty("editorSimplifiedModeBlendNormalDistance");
+            editorAdvancedModeEnabled = addso.FindProperty("editorAdvancedModeEnabled");
+            //handle data migration from before editor value were saved
+            if(editorAdvancedModeBlendDistancePositive.vector3Value == Vector3.zero
+                && editorAdvancedModeBlendDistanceNegative.vector3Value == Vector3.zero
+                && editorSimplifiedModeBlendDistance.floatValue == 0f
+                && editorAdvancedModeBlendNormalDistancePositive.vector3Value == Vector3.zero
+                && editorAdvancedModeBlendNormalDistanceNegative.vector3Value == Vector3.zero
+                && editorSimplifiedModeBlendNormalDistance.floatValue == 0f)
+            {
+                Vector3 positive = blendDistancePositive.vector3Value;
+                Vector3 negative = blendDistanceNegative.vector3Value;
+                //exact advanced
+                editorAdvancedModeBlendDistancePositive.vector3Value = positive;
+                editorAdvancedModeBlendDistanceNegative.vector3Value = negative;
+                //aproximated simplified
+                editorSimplifiedModeBlendDistance.floatValue = Mathf.Max(positive.x, positive.y, positive.z, negative.x, negative.y, negative.z);
+
+                positive = blendNormalDistancePositive.vector3Value;
+                negative = blendNormalDistanceNegative.vector3Value;
+                //exact advanced
+                editorAdvancedModeBlendNormalDistancePositive.vector3Value = positive;
+                editorAdvancedModeBlendNormalDistanceNegative.vector3Value = negative;
+                //aproximated simplified
+                editorSimplifiedModeBlendNormalDistance.floatValue = Mathf.Max(positive.x, positive.y, positive.z, negative.x, negative.y, negative.z);
+
+                //display old data
+                editorAdvancedModeEnabled.boolValue = true;
+            }
 
             proxyVolumeComponent = addso.Find((HDAdditionalReflectionData d) => d.proxyVolumeComponent);
         }

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

             //EditorGUILayout.PropertyField(d.boxBaseOffset, _.GetContent("Box Offset"));
 
             EditorGUILayout.BeginHorizontal();
-            HDReflectionProbeUI.Drawer_AdvancedBlendDistance(
-                d.boxInfluencePositiveFade,
-                d.boxInfluenceNegativeFade,
+            Drawer_AdvancedBlendDistance(
+                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
 
             EditorGUILayout.BeginHorizontal();
-            HDReflectionProbeUI.Drawer_AdvancedBlendDistance(
-                d.boxInfluenceNormalPositiveFade,
-                d.boxInfluenceNormalNegativeFade,
+            Drawer_AdvancedBlendDistance(
+                d,
+                true,
                 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("Face fade|Fade faces of the cubemap."),
                     d.boxPositiveFaceFade, d.boxNegativeFaceFade, Vector3.zero, Vector3.one, HDReflectionProbeEditor.k_handlesColor);
             }
+        }
+
+        static void Drawer_AdvancedBlendDistance(SerializedInfluenceVolume d, bool isNormal, Vector3 maxBlendDistance, GUIContent content, AnimatedValues.AnimBool advanced)
+        {
+            SerializedProperty blendDistancePositive = isNormal ? d.boxInfluenceNormalPositiveFade : d.boxInfluencePositiveFade;
+            SerializedProperty blendDistanceNegative = isNormal ? d.boxInfluenceNormalNegativeFade : d.boxInfluenceNegativeFade;
+            SerializedProperty editorAdvancedModeBlendDistancePositive = isNormal ? d.editorAdvancedModeBlendNormalDistancePositive : d.editorAdvancedModeBlendDistancePositive;
+            SerializedProperty editorAdvancedModeBlendDistanceNegative = isNormal ? d.editorAdvancedModeBlendNormalDistanceNegative : d.editorAdvancedModeBlendDistanceNegative;
+            SerializedProperty editorSimplifiedModeBlendDistance = isNormal ? d.editorSimplifiedModeBlendNormalDistance : d.editorSimplifiedModeBlendDistance;
+            Vector3 bdp = blendDistancePositive.vector3Value;
+            Vector3 bdn = blendDistanceNegative.vector3Value;
+
+            EditorGUILayout.BeginVertical();
+
+            if (advanced.value)
+            {
+                EditorGUI.BeginChangeCheck();
+                blendDistancePositive.vector3Value = editorAdvancedModeBlendDistancePositive.vector3Value;
+                blendDistanceNegative.vector3Value = editorAdvancedModeBlendDistanceNegative.vector3Value;
+                CoreEditorUtils.DrawVector6(
+                    content,
+                    blendDistancePositive, blendDistanceNegative, Vector3.zero, maxBlendDistance, HDReflectionProbeEditor.k_handlesColor);
+                if(EditorGUI.EndChangeCheck())
+                {
+                    editorAdvancedModeBlendDistancePositive.vector3Value = blendDistancePositive.vector3Value;
+                    editorAdvancedModeBlendDistanceNegative.vector3Value = blendDistanceNegative.vector3Value;
+                }
+            }
+            else
+            {
+                float distance = editorSimplifiedModeBlendDistance.floatValue;
+                EditorGUI.BeginChangeCheck();
+                distance = EditorGUILayout.FloatField(content, distance);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    Vector3 decal = Vector3.one * distance;
+                    bdp.x = Mathf.Clamp(decal.x, 0f, maxBlendDistance.x);
+                    bdp.y = Mathf.Clamp(decal.y, 0f, maxBlendDistance.y);
+                    bdp.z = Mathf.Clamp(decal.z, 0f, maxBlendDistance.z);
+                    bdn.x = Mathf.Clamp(decal.x, 0f, maxBlendDistance.x);
+                    bdn.y = Mathf.Clamp(decal.y, 0f, maxBlendDistance.y);
+                    bdn.z = Mathf.Clamp(decal.z, 0f, maxBlendDistance.z);
+                    blendDistancePositive.vector3Value = bdp;
+                    blendDistanceNegative.vector3Value = bdn;
+                    editorSimplifiedModeBlendDistance.floatValue = distance;
+                }
+            }
+
+            GUILayout.EndVertical();
         }
 
         static void Drawer_SectionShapeSphere(InfluenceVolumeUI s, SerializedInfluenceVolume d, Editor o)

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

+using UnityEngine;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
         public SerializedProperty sphereInfluenceFade;
         public SerializedProperty sphereInfluenceNormalFade;
 
+        internal SerializedProperty editorAdvancedModeBlendDistancePositive;
+        internal SerializedProperty editorAdvancedModeBlendDistanceNegative;
+        internal SerializedProperty editorSimplifiedModeBlendDistance;
+        internal SerializedProperty editorAdvancedModeBlendNormalDistancePositive;
+        internal SerializedProperty editorAdvancedModeBlendNormalDistanceNegative;
+        internal SerializedProperty editorSimplifiedModeBlendNormalDistance;
+        internal SerializedProperty editorAdvancedModeEnabled;
+
         public SerializedInfluenceVolume(SerializedProperty root)
         {
             this.root = root;
             sphereBaseOffset = root.Find((InfluenceVolume i) => i.sphereBaseOffset);
             sphereInfluenceFade = root.Find((InfluenceVolume i) => i.sphereInfluenceFade);
             sphereInfluenceNormalFade = root.Find((InfluenceVolume i) => i.sphereInfluenceNormalFade);
+
+            editorAdvancedModeBlendDistancePositive = root.FindPropertyRelative("editorAdvancedModeBlendDistancePositive");
+            editorAdvancedModeBlendDistanceNegative = root.FindPropertyRelative("editorAdvancedModeBlendDistanceNegative");
+            editorSimplifiedModeBlendDistance = root.FindPropertyRelative("editorSimplifiedModeBlendDistance");
+            editorAdvancedModeBlendNormalDistancePositive = root.FindPropertyRelative("editorAdvancedModeBlendNormalDistancePositive");
+            editorAdvancedModeBlendNormalDistanceNegative = root.FindPropertyRelative("editorAdvancedModeBlendNormalDistanceNegative");
+            editorSimplifiedModeBlendNormalDistance = root.FindPropertyRelative("editorSimplifiedModeBlendNormalDistance");
+            editorAdvancedModeEnabled = root.FindPropertyRelative("editorAdvancedModeEnabled");
+            //handle data migration from before editor value were saved
+            if(editorAdvancedModeBlendDistancePositive.vector3Value == Vector3.zero
+                && editorAdvancedModeBlendDistanceNegative.vector3Value == Vector3.zero
+                && editorSimplifiedModeBlendDistance.floatValue == 0f
+                && editorAdvancedModeBlendNormalDistancePositive.vector3Value == Vector3.zero
+                && editorAdvancedModeBlendNormalDistanceNegative.vector3Value == Vector3.zero
+                && editorSimplifiedModeBlendNormalDistance.floatValue == 0f)
+            {
+                Vector3 positive = boxInfluencePositiveFade.vector3Value;
+                Vector3 negative = boxInfluenceNegativeFade.vector3Value;
+                //exact advanced
+                editorAdvancedModeBlendDistancePositive.vector3Value = positive;
+                editorAdvancedModeBlendDistanceNegative.vector3Value = negative;
+                //aproximated simplified
+                editorSimplifiedModeBlendDistance.floatValue = Mathf.Max(positive.x, positive.y, positive.z, negative.x, negative.y, negative.z);
+
+                positive = boxInfluenceNormalPositiveFade.vector3Value;
+                negative = boxInfluenceNormalNegativeFade.vector3Value;
+                //exact advanced
+                editorAdvancedModeBlendNormalDistancePositive.vector3Value = positive;
+                editorAdvancedModeBlendNormalDistanceNegative.vector3Value = negative;
+                //aproximated simplified
+                editorSimplifiedModeBlendNormalDistance.floatValue = Mathf.Max(positive.x, positive.y, positive.z, negative.x, negative.y, negative.z);
+
+                //display old data
+                editorAdvancedModeEnabled.boolValue = true;
+            }
         }
     }
 }

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

         public Vector3 boxSideFadePositive = Vector3.one;
         public Vector3 boxSideFadeNegative = Vector3.one;
 
+        //editor value that need to be saved for easy passing from simplified to advanced and vice et versa
+        // /!\ must not be used outside editor code
+        [SerializeField] private Vector3 editorAdvancedModeBlendDistancePositive;
+        [SerializeField] private Vector3 editorAdvancedModeBlendDistanceNegative;
+        [SerializeField] private float editorSimplifiedModeBlendDistance;
+        [SerializeField] private Vector3 editorAdvancedModeBlendNormalDistancePositive;
+        [SerializeField] private Vector3 editorAdvancedModeBlendNormalDistanceNegative;
+        [SerializeField] private float editorSimplifiedModeBlendNormalDistance;
+        [SerializeField] private bool editorAdvancedModeEnabled;
+
         public ReflectionProxyVolumeComponent proxyVolumeComponent;
 
         public Vector3 boxBlendCenterOffset { get { return (blendDistanceNegative - blendDistancePositive) * 0.5f; } }

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/Volumes/InfluenceVolume.cs

         [SerializeField]
         Vector3 m_BoxNegativeFaceFade = Vector3.one;
 
+        //editor value that need to be saved for easy passing from simplified to advanced and vice et versa
+        // /!\ must not be used outside editor code
+        [SerializeField] private Vector3 editorAdvancedModeBlendDistancePositive;
+        [SerializeField] private Vector3 editorAdvancedModeBlendDistanceNegative;
+        [SerializeField] private float editorSimplifiedModeBlendDistance;
+        [SerializeField] private Vector3 editorAdvancedModeBlendNormalDistancePositive;
+        [SerializeField] private Vector3 editorAdvancedModeBlendNormalDistanceNegative;
+        [SerializeField] private float editorSimplifiedModeBlendNormalDistance;
+        [SerializeField] private bool editorAdvancedModeEnabled;
+
         // Sphere
         [SerializeField]
         float m_SphereBaseRadius = 1;