fix HDReflectionProbeEditor

7 年前 · 6f192eff
--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Gizmos.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Gizmos.cs
+using UnityEditor.Experimental.Rendering.HDPipeline;
 using UnityEditorInternal;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
        [DrawGizmo(GizmoType.Active)]
        static void RenderGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
        {
-            var e = GetEditorFor(reflectionProbe);
+            HDReflectionProbeEditor e = GetEditorFor(reflectionProbe);
+            var mat = reflectionProbe.transform.localToWorldMatrix;
-                    Gizmos_Influence(reflectionProbe, reflectionData, e, true);
+                    InfluenceVolumeUI.DrawGizmos(e.m_InfluenceVolumeUI, reflectionData.influenceVolume, mat, InfluenceVolumeUI.HandleType.Base, InfluenceVolumeUI.HandleType.All);
-                    Gizmos_InfluenceFade(reflectionProbe, reflectionData, e, InfluenceType.Standard, true);
+                    InfluenceVolumeUI.DrawGizmos(e.m_InfluenceVolumeUI, reflectionData.influenceVolume, mat, InfluenceVolumeUI.HandleType.Influence, InfluenceVolumeUI.HandleType.All);
-                    Gizmos_InfluenceFade(reflectionProbe, reflectionData, e, InfluenceType.Normal, true);
+                    InfluenceVolumeUI.DrawGizmos(e.m_InfluenceVolumeUI, reflectionData.influenceVolume, mat, InfluenceVolumeUI.HandleType.InfluenceNormal, InfluenceVolumeUI.HandleType.All);
                    break;
            }
        }
                return;

            //Gizmos_Influence(reflectionProbe, reflectionData, e, false);
-            Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Standard, false);
-            Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Normal, false);
-
-            DrawVerticalRay(reflectionProbe.transform);
-        }
-
-        static void Gizmos_InfluenceFade(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, InfluenceType type, bool isEdit)
-        {
-            var col = Gizmos.color;
-            var mat = Gizmos.matrix;
-
-            Gizmo6FacesBoxContained box;
-            Vector3 boxCenterOffset;
-            Vector3 boxSizeOffset;
-            float sphereRadiusOffset;
-            Color color;
-            switch (type)
-            {
-                default:
-                case InfluenceType.Standard:
-                    {
-                        box = e != null ? e.m_UIState.alternativeBoxBlendHandle : null;
-                        boxCenterOffset = a.boxBlendCenterOffset;
-                        boxSizeOffset = a.boxBlendSizeOffset;
-                        sphereRadiusOffset = a.sphereBlendRadiusOffset;
-                        color = isEdit ? k_GizmoThemeColorInfluenceBlendFace : k_GizmoThemeColorInfluenceBlend;
-                        break;
-                    }
-                case InfluenceType.Normal:
-                    {
-                        box = e != null ? e.m_UIState.alternativeBoxBlendNormalHandle : null;
-                        boxCenterOffset = a.boxBlendNormalCenterOffset;
-                        boxSizeOffset = a.boxBlendNormalSizeOffset;
-                        sphereRadiusOffset = a.sphereBlendNormalRadiusOffset;
-                        color = isEdit ? k_GizmoThemeColorInfluenceNormalBlendFace : k_GizmoThemeColorInfluenceNormalBlend;
-                        break;
-                    }
-            }
-
-            Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
-            switch (a.influenceShape)
-            {
-                case ShapeType.Box:
-                    {
-                        Gizmos.color = color;
-                        if (e != null) // e == null may occure when editor have still not been created at selection while the tool is not used for this part
-                        {
-                            box.DrawHull(isEdit);
-                        }
-                        else
-                        {
-                            if (isEdit)
-                                Gizmos.DrawCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
-                            else
-                                Gizmos.DrawWireCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
-                        }
-                        break;
-                    }
-                case ShapeType.Sphere:
-                    {
-                        Gizmos.color = color;
-                        if (isEdit)
-                            Gizmos.DrawSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
-                        else
-                            Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
-                        break;
-                    }
-            }
-
-            Gizmos.matrix = mat;
-            Gizmos.color = col;
-        }
-
-        static void Gizmos_Influence(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, bool isEdit)
-        {
-            var col = Gizmos.color;
-            var mat = Gizmos.matrix;
+            //Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Standard, false);
+            //Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Normal, false);
-            Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
-            switch (a.influenceShape)
-            {
-                case ShapeType.Box:
-                    {
-                        Gizmos.color = k_GizmoThemeColorExtentFace;
-                        e.m_UIState.alternativeBoxInfluenceHandle.DrawHull(isEdit);
-                        break;
-                    }
-                case ShapeType.Sphere:
-                    {
-                        Gizmos.color = k_GizmoThemeColorExtentFace;
-                        if (isEdit)
-                            Gizmos.DrawSphere(p.center, a.influenceSphereRadius);
-                        else
-                            Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius);
-                        break;
-                    }
-            }
+            //[TODO:] DrawInfluence here
-            Gizmos.matrix = mat;
-            Gizmos.color = col;
+            DrawVerticalRay(reflectionProbe.transform);
        }

        static void DrawVerticalRay(Transform transform)
--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Handles.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Handles.cs
                    {
                        alternativeBlendBox = s.alternativeBoxBlendHandle;
                        sphereHandle = s.sphereBlendHandle;
-                        probeBlendDistancePositive = sp.targetData.blendDistancePositive;
-                        probeBlendDistanceNegative = sp.targetData.blendDistanceNegative;
+                        probeBlendDistancePositive = sp.targetData.influenceVolume.boxBlendDistancePositive;
+                        probeBlendDistanceNegative = sp.targetData.influenceVolume.boxBlendDistanceNegative;
                        color = k_GizmoThemeColorInfluenceBlend;
                        break;
                    }
                        sphereHandle = s.sphereBlendNormalHandle;
-                        probeBlendDistancePositive = sp.targetData.blendNormalDistancePositive;
-                        probeBlendDistanceNegative = sp.targetData.blendNormalDistanceNegative;
+                        probeBlendDistancePositive = sp.targetData.influenceVolume.boxBlendNormalDistancePositive;
+                        probeBlendDistanceNegative = sp.targetData.influenceVolume.boxBlendNormalDistanceNegative;
                        color = k_GizmoThemeColorInfluenceNormalBlend;
                        break;
                    }
                case Shape.Sphere:
                    {
                        sphereHandle.center = sp.target.center;
-                        sphereHandle.radius = Mathf.Clamp(sp.targetData.influenceSphereRadius - probeBlendDistancePositive.x, 0, sp.targetData.influenceSphereRadius);
+                        sphereHandle.radius = Mathf.Clamp(sp.targetData.influenceVolume.sphereRadius - probeBlendDistancePositive.x, 0, sp.targetData.influenceVolume.sphereRadius);

                        Handles.color = k_GizmoThemeColorExtent;
                        EditorGUI.BeginChangeCheck();
                            Undo.RecordObject(sp.target, "Modified Reflection influence volume");
                            Undo.RecordObject(sp.targetData, "Modified Reflection influence volume");

-                            var influenceRadius = sp.targetData.influenceSphereRadius;
+                            var influenceRadius = sp.targetData.influenceVolume.sphereRadius;
                            var blendRadius = sphereHandle.radius;

                            var blendDistance = Mathf.Clamp(influenceRadius - blendRadius, 0, influenceRadius);
                default:
                case InfluenceType.Standard:
                    {
-                        sp.blendDistancePositive.vector3Value = probeBlendDistancePositive;
-                        sp.blendDistanceNegative.vector3Value = probeBlendDistanceNegative;
+                        sp.influenceVolume.boxBlendDistancePositive.vector3Value = probeBlendDistancePositive;
+                        sp.influenceVolume.boxBlendDistanceNegative.vector3Value = probeBlendDistanceNegative;
-                        if (sp.editorAdvancedModeEnabled.boolValue)
+                        if (sp.influenceVolume.editorAdvancedModeEnabled.boolValue)
-                            sp.editorAdvancedModeBlendDistancePositive.vector3Value = probeBlendDistancePositive;
-                            sp.editorAdvancedModeBlendDistanceNegative.vector3Value = probeBlendDistanceNegative;
+                            sp.influenceVolume.editorAdvancedModeBlendDistancePositive.vector3Value = probeBlendDistancePositive;
+                            sp.influenceVolume.editorAdvancedModeBlendDistanceNegative.vector3Value = probeBlendDistanceNegative;
-                            sp.editorSimplifiedModeBlendDistance.floatValue = probeBlendDistancePositive.x;
+                            sp.influenceVolume.editorSimplifiedModeBlendDistance.floatValue = probeBlendDistancePositive.x;
-                        sp.blendNormalDistancePositive.vector3Value = probeBlendDistancePositive;
-                        sp.blendNormalDistanceNegative.vector3Value = probeBlendDistanceNegative;
+                        sp.influenceVolume.boxBlendNormalDistancePositive.vector3Value = probeBlendDistancePositive;
+                        sp.influenceVolume.boxBlendNormalDistanceNegative.vector3Value = probeBlendDistanceNegative;
-                        if (sp.editorAdvancedModeEnabled.boolValue)
+                        if (sp.influenceVolume.editorAdvancedModeEnabled.boolValue)
-                            sp.editorAdvancedModeBlendNormalDistancePositive.vector3Value = probeBlendDistancePositive;
-                            sp.editorAdvancedModeBlendNormalDistanceNegative.vector3Value = probeBlendDistanceNegative;
+                            sp.influenceVolume.editorAdvancedModeBlendNormalDistancePositive.vector3Value = probeBlendDistancePositive;
+                            sp.influenceVolume.editorAdvancedModeBlendNormalDistanceNegative.vector3Value = probeBlendDistanceNegative;
-                            sp.editorSimplifiedModeBlendNormalDistance.floatValue = probeBlendDistancePositive.x;
+                            sp.influenceVolume.editorSimplifiedModeBlendNormalDistance.floatValue = probeBlendDistancePositive.x;
                        }
                        break;
                    }
                case Shape.Sphere:
                    {
                        s.sphereInfluenceHandle.center = sp.target.center;
-                        s.sphereInfluenceHandle.radius = sp.targetData.influenceSphereRadius;
+                        s.sphereInfluenceHandle.radius = sp.targetData.influenceVolume.sphereRadius;

                        Handles.color = k_GizmoThemeColorExtent;
                        EditorGUI.BeginChangeCheck();
                            HDReflectionProbeEditorUtility.ValidateAABB(sp.target, ref center, ref radius);
                            influenceRadius = radius.x;

-                            sp.targetData.influenceSphereRadius = influenceRadius;
+                            sp.targetData.influenceVolume.sphereRadius = influenceRadius;

                            //ApplyConstraintsOnTargets(s, sp, o);

--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.cs
 using System.Collections.Generic;
+using UnityEditor.Experimental.Rendering.HDPipeline;
 using UnityEditorInternal;
 using UnityEngine;
 using UnityEngine.Assertions;
        SerializedHDReflectionProbe m_SerializedHdReflectionProbe;
        SerializedObject m_AdditionalDataSerializedObject;
        HDReflectionProbeUI m_UIState = new HDReflectionProbeUI();
+        InfluenceVolumeUI m_InfluenceVolumeUI = new InfluenceVolumeUI();

        int m_PositionHash = 0;

            }
        }

-        static void InspectColorsGUI()
-        {
-            EditorGUILayout.LabelField("Color Theme", EditorStyles.largeLabel);
-            k_GizmoThemeColorExtent = EditorGUILayout.ColorField("Extent", k_GizmoThemeColorExtent);
-            k_GizmoThemeColorExtentFace = EditorGUILayout.ColorField("Extent Face", k_GizmoThemeColorExtentFace);
-            k_GizmoThemeColorInfluenceBlend = EditorGUILayout.ColorField("Influence Blend", k_GizmoThemeColorInfluenceBlend);
-            k_GizmoThemeColorInfluenceBlendFace = EditorGUILayout.ColorField("Influence Blend Face", k_GizmoThemeColorInfluenceBlendFace);
-            k_GizmoThemeColorInfluenceNormalBlend = EditorGUILayout.ColorField("Influence Normal Blend", k_GizmoThemeColorInfluenceNormalBlend);
-            k_GizmoThemeColorInfluenceNormalBlendFace = EditorGUILayout.ColorField("Influence Normal Blend Face", k_GizmoThemeColorInfluenceNormalBlendFace);
-            k_GizmoThemeColorProjection = EditorGUILayout.ColorField("Projection", k_GizmoThemeColorProjection);
-            k_GizmoThemeColorProjectionFace = EditorGUILayout.ColorField("Projection Face", k_GizmoThemeColorProjectionFace);
-            k_GizmoThemeColorDisabled = EditorGUILayout.ColorField("Disabled", k_GizmoThemeColorDisabled);
-            k_GizmoThemeColorDisabledFace = EditorGUILayout.ColorField("Disabled Face", k_GizmoThemeColorDisabledFace);
-            EditorGUILayout.Space();
-        }
-
-            switch ((ShapeType)sp.influenceShape.enumValueIndex)
+            switch ((Shape)sp.influenceVolume.shape.enumValueIndex)
-                case ShapeType.Box:
+                case Shape.Box:
-                    var maxBlendDistance = HDReflectionProbeEditorUtility.CalculateBoxMaxBlendDistance(s, sp, o);
-                    sp.targetData.blendDistancePositive = Vector3.Min(sp.targetData.blendDistancePositive, maxBlendDistance);
-                    sp.targetData.blendDistanceNegative = Vector3.Min(sp.targetData.blendDistanceNegative, maxBlendDistance);
-                    sp.targetData.blendNormalDistancePositive = Vector3.Min(sp.targetData.blendNormalDistancePositive, maxBlendDistance);
-                    sp.targetData.blendNormalDistanceNegative = Vector3.Min(sp.targetData.blendNormalDistanceNegative, maxBlendDistance);
+                    var maxBlendDistance = sp.influenceVolume.boxSize.vector3Value;
+                    sp.targetData.influenceVolume.boxBlendDistancePositive = Vector3.Min(sp.targetData.influenceVolume.boxBlendDistancePositive, maxBlendDistance);
+                    sp.targetData.influenceVolume.boxBlendDistanceNegative = Vector3.Min(sp.targetData.influenceVolume.boxBlendDistanceNegative, maxBlendDistance);
+                    sp.targetData.influenceVolume.boxBlendNormalDistancePositive = Vector3.Min(sp.targetData.influenceVolume.boxBlendNormalDistancePositive, maxBlendDistance);
+                    sp.targetData.influenceVolume.boxBlendNormalDistanceNegative = Vector3.Min(sp.targetData.influenceVolume.boxBlendNormalDistanceNegative, maxBlendDistance);
-                case ShapeType.Sphere:
+                case Shape.Sphere:
-                    var maxBlendDistance = Vector3.one * HDReflectionProbeEditorUtility.CalculateSphereMaxBlendDistance(s, sp, o);
-                    sp.targetData.blendDistancePositive = Vector3.Min(sp.targetData.blendDistancePositive, maxBlendDistance);
-                    sp.targetData.blendDistanceNegative = Vector3.Min(sp.targetData.blendDistanceNegative, maxBlendDistance);
-                    sp.targetData.blendNormalDistancePositive = Vector3.Min(sp.targetData.blendNormalDistancePositive, maxBlendDistance);
-                    sp.targetData.blendNormalDistanceNegative = Vector3.Min(sp.targetData.blendNormalDistanceNegative, maxBlendDistance);
+                    var maxBlendDistance = Vector3.one * sp.influenceVolume.sphereRadius.floatValue;
+                    sp.targetData.influenceVolume.boxBlendDistancePositive = Vector3.Min(sp.targetData.influenceVolume.boxBlendDistancePositive, maxBlendDistance);
+                    sp.targetData.influenceVolume.boxBlendDistanceNegative = Vector3.Min(sp.targetData.influenceVolume.boxBlendDistanceNegative, maxBlendDistance);
+                    sp.targetData.influenceVolume.boxBlendNormalDistancePositive = Vector3.Min(sp.targetData.influenceVolume.boxBlendNormalDistancePositive, maxBlendDistance);
+                    sp.targetData.influenceVolume.boxBlendNormalDistanceNegative = Vector3.Min(sp.targetData.influenceVolume.boxBlendNormalDistanceNegative, maxBlendDistance);
                    break;
                }
            }
--- a/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditorUtility.cs
+++ b/com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditorUtility.cs
            size = b.size;
            return true;
        }
-
-        public static float CalculateSphereMaxBlendDistance(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor o)
-        {
-            return p.influenceSphereRadius.floatValue;
-        }
-
-        public static Vector3 CalculateBoxMaxBlendDistance(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor o)
-        {
-            return p.boxSize.vector3Value * 0.5f;
-        }
    }
 }