merge proxyVolume field in HDProbe

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

                 Handles.matrix = m;
             }
 
-            if (d.proxyVolumeReference != null)
-                ReflectionProxyVolumeComponentUI.DrawHandles_EditNone(s.reflectionProxyVolume, d.proxyVolumeReference);
+            if (d.proxyVolume != null)
+                ReflectionProxyVolumeComponentUI.DrawHandles_EditNone(s.reflectionProxyVolume, d.proxyVolume);
         }
 
         [DrawGizmo(GizmoType.Selected)]
                 }
             }
 
-            if (d.proxyVolumeReference != null)
-                ReflectionProxyVolumeComponentUI.DrawGizmos_EditNone(s.reflectionProxyVolume, d.proxyVolumeReference);
+            if (d.proxyVolume != null)
+                ReflectionProxyVolumeComponentUI.DrawGizmos_EditNone(s.reflectionProxyVolume, d.proxyVolume);
 
             var showFrustrum = s.showCaptureHandles
                 || EditMode.editMode == EditCenter;

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

                 Apply();
             }
 
-            proxyVolumeComponent = addso.Find((HDAdditionalReflectionData d) => d.proxyVolumeComponent);
+            proxyVolumeComponent = addso.Find((HDAdditionalReflectionData d) => d.proxyVolume);
         }
 
         public void Update()

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

         {
             this.serializedObject = serializedObject;
 
-            proxyVolumeReference = serializedObject.Find((PlanarReflectionProbe p) => p.proxyVolumeReference);
+            proxyVolumeReference = serializedObject.Find((PlanarReflectionProbe p) => p.proxyVolume);
             influenceVolume = new SerializedInfluenceVolume(serializedObject.Find((PlanarReflectionProbe p) => p.influenceVolume));
 
             captureLocalPosition = serializedObject.Find((PlanarReflectionProbe p) => p.captureLocalPosition);
             var objs = new List<Object>();
             for (var i = 0; i < serializedObject.targetObjects.Length; i++)
             {
-                var p = ((PlanarReflectionProbe)serializedObject.targetObjects[i]).proxyVolumeReference;
+                var p = ((PlanarReflectionProbe)serializedObject.targetObjects[i]).proxyVolume;
                 if (p != null)
                     objs.Add(p);
             }
                 var proxyVolumeTargets = reflectionProxyVolume.serializedObject.targetObjects;
                 for (var i = 0; i < serializedObject.targetObjects.Length; i++)
                 {
-                    if (proxyVolumeTargets[i] != ((PlanarReflectionProbe)serializedObject.targetObjects[i]).proxyVolumeReference)
+                    if (proxyVolumeTargets[i] != ((PlanarReflectionProbe)serializedObject.targetObjects[i]).proxyVolume)
                     {
                         updateProxyVolume = true;
                         break;

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

         [SerializeField] private float editorSimplifiedModeBlendNormalDistance;
         [SerializeField] private bool editorAdvancedModeEnabled;
 
-        public ReflectionProxyVolumeComponent proxyVolumeComponent;
-
         public Vector3 boxBlendCenterOffset { get { return (blendDistanceNegative - blendDistancePositive) * 0.5f; } }
         public Vector3 boxBlendSizeOffset { get { return -(blendDistancePositive + blendDistanceNegative); } }
         public Vector3 boxBlendNormalCenterOffset { get { return (blendNormalDistanceNegative - blendNormalDistancePositive) * 0.5f; } }

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

 using UnityEngine;
+using UnityEngine.Serialization;
+        [SerializeField, FormerlySerializedAs("proxyVolumeComponent"), FormerlySerializedAs("m_ProxyVolumeReference")]
+        ReflectionProxyVolumeComponent m_ProxyVolume = null;
+        public ReflectionProxyVolumeComponent proxyVolume { get { return m_ProxyVolume; } }
     }
 }

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

         }
 
         [SerializeField]
-        ReflectionProxyVolumeComponent m_ProxyVolumeReference = null;
-        [SerializeField]
         InfluenceVolume m_InfluenceVolume = new InfluenceVolume();
         [SerializeField]
         Vector3 m_CaptureLocalPosition;
         public bool overrideFieldOfView { get { return m_OverrideFieldOfView; } }
         public float fieldOfViewOverride { get { return m_FieldOfViewOverride; } }
 
-        public ReflectionProxyVolumeComponent proxyVolumeReference { get { return m_ProxyVolumeReference; } }
         public InfluenceVolume influenceVolume { get { return m_InfluenceVolume; } }
         public BoundingSphere boundingSphere { get { return m_InfluenceVolume.GetBoundingSphereAt(transform); } }
 
         {
             get
             {
-                return m_ProxyVolumeReference != null
-                    ? m_ProxyVolumeReference.transform.localToWorldMatrix
+                return proxyVolume != null
+                    ? proxyVolume.transform.localToWorldMatrix
                     : influenceToWorld;
             }
         }
             {
-                return m_ProxyVolumeReference != null
-                    ? m_ProxyVolumeReference.proxyVolume.shapeType
+                return proxyVolume != null
+                    ? proxyVolume.proxyVolume.shapeType
                     : influenceVolume.shapeType;
             }
         }
             {
-                return m_ProxyVolumeReference != null
-                    ? m_ProxyVolumeReference.proxyVolume.extents
+                return proxyVolume != null
+                    ? proxyVolume.proxyVolume.extents
-        public bool infiniteProjection { get { return m_ProxyVolumeReference != null && m_ProxyVolumeReference.proxyVolume.infiniteProjection; } }
+        public bool infiniteProjection { get { return proxyVolume != null && proxyVolume.proxyVolume.infiniteProjection; } }
 
         public bool useMirrorPlane
         {

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

         {
             get
             {
-                return additional.proxyVolumeComponent != null
-                    ? ConvertShape(additional.proxyVolumeComponent.proxyVolume.shapeType)
+                return additional.proxyVolume != null
+                    ? ConvertShape(additional.proxyVolume.proxyVolume.shapeType)
                     : influenceShapeType;
             }
         }
             {
-                return additional.proxyVolumeComponent != null
-                    ? additional.proxyVolumeComponent.proxyVolume.extents
+                return additional.proxyVolume != null
+                    ? additional.proxyVolume.proxyVolume.extents
                     : influenceExtents;
             }
         }
             get
             {
-                return additional.proxyVolumeComponent != null
-                    ? additional.proxyVolumeComponent.proxyVolume.infiniteProjection
+                return additional.proxyVolume != null
+                    ? additional.proxyVolume.proxyVolume.infiniteProjection
                     : probe.boxProjection == 0;
             }
         }
             get
             {
-                return additional.proxyVolumeComponent != null
-                    ? additional.proxyVolumeComponent.transform.localToWorldMatrix
+                return additional.proxyVolume != null
+                    ? additional.proxyVolume.transform.localToWorldMatrix
                     : influenceToWorld;
             }
         }