Add same editor refactor to PlanarReflectionProbe

6 年前 · 0066baad
--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs
            }
        }

-        static void Drawer_AdvancedBlendDistance(SerializedProperty blendDistancePositive, SerializedProperty blendDistanceNegative, Vector3 maxBlendDistance, GUIContent content, AnimatedValues.AnimBool advanced)
+        public static void Drawer_AdvancedBlendDistance(SerializedProperty blendDistancePositive, SerializedProperty blendDistanceNegative, Vector3 maxBlendDistance, GUIContent content, AnimatedValues.AnimBool advanced)
        {
            Vector3 bdp = blendDistancePositive.vector3Value;
            Vector3 bdn = blendDistanceNegative.vector3Value;
--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs
        public static readonly CED.IDrawer Inspector;

        public static readonly CED.IDrawer SectionProbeModeSettings;
+        public static readonly CED.IDrawer ProxyVolumeSettings = CED.FoldoutGroup(
+                "Proxy Volume",
+                (s, d, o) => s.isSectionExpendedProxyVolume,
+                FoldoutOption.Indent,
+                CED.Action(Drawer_SectionProxySettings)
+                );
        public static readonly CED.IDrawer SectionProbeModeBakedSettings = CED.noop;
        public static readonly CED.IDrawer SectionProbeModeCustomSettings = CED.Action(Drawer_SectionProbeModeCustomSettings);
        public static readonly CED.IDrawer SectionProbeModeRealtimeSettings = CED.Action(Drawer_SectionProbeModeRealtimeSettings);
-                "Influence Settings",
+                "Artistic Settings",
+        public static readonly CED.IDrawer SectionFoldoutProxySettings;
        public static readonly CED.IDrawer SectionFoldoutCaptureSettings;

        public static readonly CED.IDrawer SectionCaptureMirrorSettings = CED.Action(Drawer_SectionCaptureMirror);
                    CED.Action(Drawer_SectionCaptureSettings),
                    CED.FadeGroup(
                        (s, d, o, i) =>
-                {
-                    switch (i)
-                    {
-                        default:
-                        case 0: return s.isSectionExpandedCaptureMirrorSettings;
-                        case 1: return s.isSectionExpandedCaptureStaticSettings;
-                    }
-                },
+                        {
+                            switch (i)
+                            {
+                                default:
+                                case 0: return s.isSectionExpandedCaptureMirrorSettings;
+                                case 1: return s.isSectionExpandedCaptureStaticSettings;
+                            }
+                        },
                        FadeOption.None,
                        SectionCaptureMirrorSettings,
                        SectionCaptureStaticSettings)
                    );

            Inspector = CED.Group(
-                    //SectionProbeModeSettings,
-                    CED.space,
-                    CED.Action((s, d, o) => EditorGUILayout.LabelField(_.GetContent("Proxy Volume"), EditorStyles.boldLabel)),
-                    CED.Action(Drawer_FieldProxyVolumeReference),
-                    CED.space,
+                    ProxyVolumeSettings,
                    CED.Select(
                        (s, d, o) => s.influenceVolume,
                        (s, d, o) => d.influenceVolume,
-                    SectionFoldoutInfluenceSettings,
+                    SectionFoldoutInfluenceSettings,
                    CED.Select(
                        (s, d, o) => s.frameSettings,
                        (s, d, o) => d.frameSettings,
            GUI.enabled = true;
        }

+        static void Drawer_SectionProxySettings(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
+        {
+            EditorGUILayout.PropertyField(d.proxyVolumeReference, _.GetContent("Reference"));
+
+            if (d.proxyVolumeReference.objectReferenceValue != null)
+            {
+                var proxy = (ReflectionProxyVolumeComponent)d.proxyVolumeReference.objectReferenceValue;
+                if ((int)proxy.proxyVolume.shapeType != d.influenceVolume.shapeType.enumValueIndex)
+                    EditorGUILayout.HelpBox(
+                        "Proxy volume and influence volume have different shape types, this is not supported.",
+                        MessageType.Error,
+                        true
+                        );
+            }
+            else
+            {
+                EditorGUILayout.HelpBox(
+                        "When no Proxy setted, Influence shape will be used as Proxy shape too.",
+                        MessageType.Info,
+                        true
+                        );
+            }
+        }
+
        static void Drawer_SectionInfluenceSettings(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
        {
            EditorGUILayout.PropertyField(d.weight, _.GetContent("Weight"));
            GUI.enabled = false;
            EditorGUILayout.PropertyField(d.mode, _.GetContent("Type"));
            GUI.enabled = true;
-        }
-
-        static void Drawer_FieldProxyVolumeReference(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
-        {
-            EditorGUILayout.PropertyField(d.proxyVolumeReference, _.GetContent("Reference"));
        }

        static readonly EditMode.SceneViewEditMode[] k_Toolbar_SceneViewEditModes =
--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.cs
 {
    partial class PlanarReflectionProbeUI : BaseUI<SerializedPlanarReflectionProbe>
    {
-        const int k_AnimBoolFields = 4;
+        const int k_AnimBoolFields = 5;
        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 bool showCaptureHandles { get; set; }

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

    partial class InfluenceVolumeUI
    {
-        public static readonly CED.IDrawer SectionShape;
-
        public static readonly CED.IDrawer FieldShape = CED.Action(Drawer_FieldShapeType);
        public static readonly CED.IDrawer SectionShapeBox = CED.Action(Drawer_SectionShapeBox);
        public static readonly CED.IDrawer SectionShapeSphere = CED.Action(Drawer_SectionShapeSphere);
-            SectionShape = CED.Group(
-                    CED.Action(Drawer_FieldShapeType),
-                    CED.FadeGroup(
-                        (s, d, o, i) => s.IsSectionExpanded_Shape((ShapeType)i),
-                        FadeOption.Indent,
-                        SectionShapeBox,
-                        SectionShapeSphere
-                        )
-                    );
-
+                        CED.Action(Drawer_InfluenceAdvancedSwitch),
+                        CED.space,
                        CED.Action(Drawer_FieldShapeType),
                        CED.FadeGroup(
                            (s, d, o, i) => s.IsSectionExpanded_Shape((ShapeType)i),

        static void Drawer_FieldShapeType(InfluenceVolumeUI s, SerializedInfluenceVolume d, Editor o)
        {
+            //EditorGUI.showMixedValue = d.;
+            //EditorGUI.showMixedValue = false;
+
+            //if(s.shapeMissmatch)
+            //{
+            //    EditorGUILayout.HelpBox(
+            //            "Proxy volume and influence volume have different shape types, this is not supported.",
+            //            MessageType.Error,
+            //            true
+            //            );
+            //}
+        }
+
+        static void Drawer_InfluenceAdvancedSwitch(InfluenceVolumeUI s, SerializedInfluenceVolume d, Editor owner)
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+
+                bool advanced = s.isSectionAdvancedInfluenceSettings.value;
+                advanced = !GUILayout.Toggle(!advanced, CoreEditorUtils.GetContent("Normal|Normal parameters mode (only change for box shape)."), EditorStyles.miniButtonLeft, GUILayout.Width(60f), GUILayout.ExpandWidth(false));
+                advanced = GUILayout.Toggle(advanced, CoreEditorUtils.GetContent("Advanced|Advanced parameters mode (only change for box shape)."), EditorStyles.miniButtonRight, GUILayout.Width(60f), GUILayout.ExpandWidth(false));
+                if (s.isSectionAdvancedInfluenceSettings.value ^ advanced)
+                {
+                    s.isSectionAdvancedInfluenceSettings.value = 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;
+                    }
+                }
+            }
        }

        static void Drawer_SectionShapeBox(InfluenceVolumeUI s, SerializedInfluenceVolume d, Editor o)

            EditorGUILayout.Space();

-            _.DrawVector6Slider(
-                _.GetContent("Influence Fade"),
-                d.boxInfluencePositiveFade, d.boxInfluenceNegativeFade,
-                minFadeDistance, maxFadeDistance);
+            EditorGUILayout.BeginHorizontal();
+            HDReflectionProbeUI.Drawer_AdvancedBlendDistance(
+                d.boxInfluencePositiveFade,
+                d.boxInfluenceNegativeFade,
+                maxFadeDistance,
+                CoreEditorUtils.GetContent("Blend Distance|Area around the probe where it is blended with other probes. Only used in deferred probes."),
+                s.isSectionAdvancedInfluenceSettings
+                );
+            //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))))
+            //{
+            //    EditMode.ChangeEditMode(k_Toolbar_SceneViewEditModes[1], GetBoundsGetter(p)(), owner);
+            //}
+            EditorGUILayout.EndHorizontal();
-            _.DrawVector6Slider(
-                _.GetContent("Influence Normal Fade"),
-                d.boxInfluenceNormalPositiveFade, d.boxInfluenceNormalNegativeFade,
-                minFadeDistance, maxFadeDistance);
+            EditorGUILayout.BeginHorizontal();
+            HDReflectionProbeUI.Drawer_AdvancedBlendDistance(
+                d.boxInfluenceNormalPositiveFade,
+                d.boxInfluenceNormalNegativeFade,
+                maxFadeDistance,
+                CoreEditorUtils.GetContent("Blend Normal Distance|Area around the probe where the normals influence the probe. Only used in deferred probes."),
+                s.isSectionAdvancedInfluenceSettings
+                );
+            //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))))
+            //{
+            //    EditMode.ChangeEditMode(k_Toolbar_SceneViewEditModes[2], GetBoundsGetter(p)(), owner);
+            //}
+            EditorGUILayout.EndHorizontal();
-            _.DrawVector6Slider(
-                _.GetContent("Influence Face Fade"),
-                d.boxPositiveFaceFade, d.boxNegativeFaceFade,
-                Vector3.zero, Vector3.one);
+            if (s.isSectionAdvancedInfluenceSettings.value)
+            {
+                CoreEditorUtils.DrawVector6(
+                    CoreEditorUtils.GetContent("Face fade|Fade faces of the cubemap."),
+                    d.boxPositiveFaceFade, d.boxNegativeFaceFade, Vector3.zero, Vector3.one, HDReflectionProbeEditor.k_handlesColor);
+            }
        }

        static void Drawer_SectionShapeSphere(InfluenceVolumeUI s, SerializedInfluenceVolume d, Editor o)
--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.cs
 {
    partial class InfluenceVolumeUI : BaseUI<SerializedInfluenceVolume>
    {
+        const int k_AnimBoolFields = 2;
        internal static Color k_GizmoThemeColorBase = new Color(255f / 255f, 229f / 255f, 148f / 255f, 80f / 255f);
        internal static Color k_GizmoThemeColorBaseFace = new Color(255f / 255f, 229f / 255f, 148f / 255f, 45f / 255f);
        internal static Color k_GizmoThemeColorInfluence = new Color(83f / 255f, 255f / 255f, 95f / 255f, 75f / 255f);
        public SphereBoundsHandle sphereInfluenceNormalHandle = new SphereBoundsHandle();

        public AnimBool isSectionExpandedShape { get { return m_AnimBools[k_ShapeCount]; } }
+        public AnimBool isSectionAdvancedInfluenceSettings  { get { return m_AnimBools[k_ShapeCount + 1]; } }
-            : base(k_ShapeCount + 1)
+            : base(k_ShapeCount + k_AnimBoolFields)
+            isSectionAdvancedInfluenceSettings.value = false;
        }

        public override void Update()