Color control refactor

- Add mode enum to ControlView
- Remove HDR Color node
- Switch Color node value to struct
- Update USS

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Graphs/ColorShaderProperty.cs

 
         public override INode ToConcreteNode()
         {
-            if(colorMode == ColorMode.HDR)
-                return new HDRColorNode { color = value };
-            return new ColorNode { color = value };
+            return new ColorNode { color = new ColorNode.Color(value, colorMode) };
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/ColorNode.cs

+using System;
 using System.Collections.Generic;
 using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
     [Title("Input", "Basic", "Color")]
     public class ColorNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
     {
-        [SerializeField]
-        private Color m_Color;
-
         public const int OutputSlotId = 0;
         private const string kOutputSlotName = "Out";
 
             UpdateNodeAfterDeserialization();
         }
 
-        public sealed override void UpdateNodeAfterDeserialization()
+        [SerializeField]
+        Color m_Color = new Color(UnityEngine.Color.clear, ColorMode.Default);
+
+        [Serializable]
+        public struct Color
-            AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
-            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+            public UnityEngine.Color color;
+            public ColorMode mode;
+
+            public Color(UnityEngine.Color color, ColorMode mode)
+            {
+                this.color = color;
+                this.mode = mode;
+            }
         }
 
         [ColorControl("")]
             set
             {
-                if (m_Color == value)
+                if ((value.color == m_Color.color) && (value.mode == m_Color.mode))
-
-                Dirty(ModificationScope.Node);
+                Dirty(ModificationScope.Graph);
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new Vector4MaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
 
         public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
         {
             {
                 overrideReferenceName = GetVariableNameForNode(),
                 generatePropertyBlock = false,
-                value = color,
-                colorMode = ColorMode.Default
+                value = color.color,
+                colorMode = color.mode
             });
         }
 
                 @"{0}4 {1} = IsGammaSpace() ? {0}4({2}, {3}, {4}, {5}) : {0}4(SRGBToLinear({0}3({2}, {3}, {4})), {5});"
                 , precision
                 , GetVariableNameForNode()
-                , color.r
-                , color.g
-                , color.b
-                , color.a), true);
+                , color.color.r
+                , color.color.g
+                , color.color.b
+                , color.color.a), true);
         }
 
         public override string GetVariableNameForSlot(int slotId)
             properties.Add(new PreviewProperty(PropertyType.Color)
             {
                 name = GetVariableNameForNode(),
-                colorValue = color
+                colorValue = color.color
-            return new ColorShaderProperty { value = color };
+            return new ColorShaderProperty { value = color.color, colorMode = color.mode };
         }
 
         public int outputSlotId { get { return OutputSlotId; } }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/ColorControl.cs

 using UnityEngine.Experimental.UIElements;
 using UnityEngine.Experimental.UIElements.StyleSheets;
 using UnityEditor.ShaderGraph;
+using Color = UnityEditor.ShaderGraph.ColorNode.Color;
 
 namespace UnityEditor.ShaderGraph.Drawing.Controls
 {
         AbstractMaterialNode m_Node;
         PropertyInfo m_PropertyInfo;
 
+        Color m_Color;
+        ColorField m_ColorField;
+
         public ColorControlView(string label, ColorMode colorMode, AbstractMaterialNode node, PropertyInfo propertyInfo)
         {
             m_Node = node;
             label = label ?? ObjectNames.NicifyVariableName(propertyInfo.Name);
 
+            m_Color = (Color)m_PropertyInfo.GetValue(m_Node, null);
+
-            ColorField colorField;
-            switch(colorMode)
-            {
-                case ColorMode.HDR:
-                    colorField = new ColorField { value = (Color)m_PropertyInfo.GetValue(m_Node, null), hdr = true, showEyeDropper = false };
-                    break;
-                default:
-                    colorField = new ColorField { value = (Color)m_PropertyInfo.GetValue(m_Node, null), showEyeDropper = false };
-                    break;
-            }
-            colorField.OnValueChanged(OnChange);
-            Add(colorField);
+            m_ColorField = new ColorField { value = m_Color.color, hdr = m_Color.mode == ColorMode.HDR, showEyeDropper = false };
+            m_ColorField.OnValueChanged(OnChange);
+            Add(m_ColorField);
+
+            VisualElement enumPanel = new VisualElement { name = "enumPanel" };
+            enumPanel.Add(new Label("Mode"));
+            var enumField = new EnumField(m_Color.mode);
+            enumField.OnValueChanged(OnModeChanged);
+            enumPanel.Add(enumField);
+            Add(enumPanel);
-        void OnChange(ChangeEvent<Color> evt)
+        void OnChange(ChangeEvent<UnityEngine.Color> evt)
-            m_PropertyInfo.SetValue(m_Node, evt.newValue, null);
+            m_Color.color = evt.newValue;
+            m_PropertyInfo.SetValue(m_Node, m_Color, null);
+        }
+
+        void OnModeChanged(ChangeEvent<Enum> evt)
+        {
+            if (!evt.newValue.Equals(m_Color.mode))
+            {
+                m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
+                m_Color.mode = (ColorMode)evt.newValue;
+                m_ColorField.hdr = m_Color.mode == ColorMode.HDR;
+                m_PropertyInfo.SetValue(m_Node, m_Color, null);
+            }
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Styles/MaterialGraph.uss

     padding-bottom: 2;
 }
 
-ColorControlView {
+ColorControlView > ColorField {
+    flex-direction: row;
+}
+
+ColorControlView > #enumPanel {
+}
+
+ColorControlView > #enumPanel > EnumField {
+    flex: 1;
+    margin-left: 0;
+    margin-right: 8;
+    margin-top: 4;
+    margin-bottom: 4;
+}
+
+ColorControlView > #enumPanel > Label {
+    padding-left: 0;
+    padding-right: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+    margin-left: 8;
+    margin-right: 8;
+    margin-top: 4;
+    margin-bottom: 4;
 }
 
 MultiFloatControlView {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/HDRColorNode.cs.meta

-fileFormatVersion: 2
-guid: 948ed387e8c19c14c82965be937d7284
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Basic/HDRColorNode.cs

-using System.Collections.Generic;
-using UnityEditor.ShaderGraph.Drawing.Controls;
-using UnityEngine;
-using UnityEditor.Graphing;
-
-namespace UnityEditor.ShaderGraph
-{
-    [Title("Input", "Basic", "HDR Color")]
-    public class HDRColorNode : AbstractMaterialNode, IGeneratesBodyCode, IPropertyFromNode
-    {
-        [SerializeField]
-        private Color m_Color;
-
-        public const int OutputSlotId = 0;
-        private const string kOutputSlotName = "Out";
-
-        public HDRColorNode()
-        {
-            name = "HDR Color";
-            UpdateNodeAfterDeserialization();
-        }
-
-        public sealed override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new ColorRGBAMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, Vector4.zero));
-            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
-        }
-
-        [ColorControl("", ColorMode.HDR)]
-        public Color color
-        {
-            get { return m_Color; }
-            set
-            {
-                if (m_Color == value)
-                    return;
-
-                m_Color = value;
-                Dirty(ModificationScope.Node);
-            }
-        }
-
-
-        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-        {
-            if (!generationMode.IsPreview())
-                return;
-
-            properties.AddShaderProperty(new ColorShaderProperty()
-            {
-                overrideReferenceName = GetVariableNameForNode(),
-                generatePropertyBlock = false,
-                value = color,
-                colorMode = ColorMode.HDR
-            });
-        }
-
-        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            if (generationMode.IsPreview())
-                return;
-
-            visitor.AddShaderChunk(string.Format(
-                @"{0}4 {1} = IsGammaSpace() ? {0}4({2}, {3}, {4}, {5}) : {0}4(SRGBToLinear({0}3({2}, {3}, {4})), {5});"
-                , precision
-                , GetVariableNameForNode()
-                , color.r
-                , color.g
-                , color.b
-                , color.a), true);
-        }
-
-        public override string GetVariableNameForSlot(int slotId)
-        {
-            return GetVariableNameForNode();
-        }
-
-        public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
-        {
-            properties.Add(new PreviewProperty(PropertyType.Color)
-            {
-                name = GetVariableNameForNode(),
-                colorValue = color
-            });
-        }
-
-        public IShaderProperty AsShaderProperty()
-        {
-            return new ColorShaderProperty { value = color, colorMode = ColorMode.HDR };
-        }
-
-        public int outputSlotId { get { return OutputSlotId; } }
-    }
-}