Squash `SerializableNode` into `AbstractMaterialNode`

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/AbstractMaterialNode.cs

     }
 
     [Serializable]
-    public abstract class AbstractMaterialNode : SerializableNode, IGenerateProperties
+    public abstract class AbstractMaterialNode : INode, ISerializationCallbackReceiver, IGenerateProperties
     {
         protected static List<MaterialSlot> s_TempSlots = new List<MaterialSlot>();
         protected static List<IEdge> s_TempEdges = new List<IEdge>();
         }
 
         [NonSerialized]
+        private Guid m_Guid;
+
+        [SerializeField]
+        private string m_GuidSerialized;
+
+        [SerializeField]
+        private string m_Name;
+
+        [SerializeField]
+        private DrawState m_DrawState;
+
+        [NonSerialized]
+        private List<ISlot> m_Slots = new List<ISlot>();
+
+        [SerializeField]
+        List<SerializationHelper.JSONSerializedElement> m_SerializableSlots = new List<SerializationHelper.JSONSerializedElement>();
+
+        [NonSerialized]
+        public IGraph owner { get; set; }
+
+        public OnNodeModified onModified { get; set; }
+
+        public Guid guid
+        {
+            get { return m_Guid; }
+        }
+
+        public string name
+        {
+            get { return m_Name; }
+            set { m_Name = value; }
+        }
+
+        public virtual bool canDeleteNode
+        {
+            get { return true; }
+        }
+
+        public DrawState drawState
+        {
+            get { return m_DrawState; }
+            set
+            {
+                m_DrawState = value;
+                if (onModified != null)
+                    onModified(this, ModificationScope.Node);
+            }
+        }
+
+        private OutputPrecision m_OutputPrecision = OutputPrecision.@float;
+
-
-        //[SerializeField]
-        private OutputPrecision m_OutputPrecision = OutputPrecision.@float;
 
         [SerializeField]
         bool m_PreviewExpanded = true;
             get { return true; }
         }
 
-        public override bool hasError
+        public virtual bool hasError
         {
             get { return m_HasError; }
             protected set { m_HasError = value; }
 
         protected AbstractMaterialNode()
         {
+            m_DrawState.expanded = true;
+            m_Guid = Guid.NewGuid();
+        public Guid RewriteGuid()
+        {
+            m_Guid = Guid.NewGuid();
+            return m_Guid;
+        }
+
+        public void GetInputSlots<T>(List<T> foundSlots) where T : ISlot
+        {
+            foreach (var slot in m_Slots)
+            {
+                if (slot.isInputSlot && slot is T)
+                    foundSlots.Add((T)slot);
+            }
+        }
+
+        public void GetOutputSlots<T>(List<T> foundSlots) where T : ISlot
+        {
+            foreach (var slot in m_Slots)
+            {
+                if (slot.isOutputSlot && slot is T)
+                    foundSlots.Add((T)slot);
+            }
+        }
+
+        public void GetSlots<T>(List<T> foundSlots) where T : ISlot
+        {
+            foreach (var slot in m_Slots)
+            {
+                if (slot is T)
+                    foundSlots.Add((T)slot);
+            }
+        }
+
         public virtual void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
         {
             foreach (var inputSlot in this.GetInputSlots<MaterialSlot>())
             return ConcreteSlotValueType.Vector1;
         }
 
-        public override void ValidateNode()
+        public virtual void ValidateNode()
         {
             var isInError = false;
 
             return new string(arr);
         }
 
-        public sealed override void AddSlot(ISlot slot)
+        public void AddSlot(ISlot slot)
         {
             if (!(slot is MaterialSlot))
                 throw new ArgumentException(string.Format("Trying to add slot {0} to Material node {1}, but it is not a {2}", slot, this, typeof(MaterialSlot)));
 
             // this will remove the old slot and add a new one
             // if an old one was found. This allows updating values
-            base.AddSlot(slot);
+            m_Slots.RemoveAll(x => x.id == slot.id);
+            m_Slots.Add(slot);
+            slot.owner = this;
+
+            if (onModified != null)
+            {
+                onModified(this, ModificationScope.Topological);
+            }
 
             if (foundSlot == null)
                 return;
+
+        public void RemoveSlot(int slotId)
+        {
+            // Remove edges that use this slot
+            // no owner can happen after creation
+            // but before added to graph
+            if (owner != null)
+            {
+                var edges = owner.GetEdges(GetSlotReference(slotId));
+
+                foreach (var edge in edges.ToArray())
+                    owner.RemoveEdge(edge);
+            }
+
+            //remove slots
+            m_Slots.RemoveAll(x => x.id == slotId);
+
+            if (onModified != null)
+            {
+                onModified(this, ModificationScope.Topological);
+            }
+        }
+
+        public void RemoveSlotsNameNotMatching(IEnumerable<int> slotIds, bool supressWarnings = false)
+        {
+            var invalidSlots = m_Slots.Select(x => x.id).Except(slotIds);
+
+            foreach (var invalidSlot in invalidSlots.ToArray())
+            {
+                if (!supressWarnings)
+                    Debug.LogWarningFormat("Removing Invalid MaterialSlot: {0}", invalidSlot);
+                RemoveSlot(invalidSlot);
+            }
+        }
+
+        public SlotReference GetSlotReference(int slotId)
+        {
+            var slot = FindSlot<ISlot>(slotId);
+            if (slot == null)
+                throw new ArgumentException("Slot could not be found", "slotId");
+            return new SlotReference(guid, slotId);
+        }
+
+        public T FindSlot<T>(int slotId) where T : ISlot
+        {
+            foreach (var slot in m_Slots)
+            {
+                if (slot.id == slotId && slot is T)
+                    return (T)slot;
+            }
+            return default(T);
+        }
+
+        public T FindInputSlot<T>(int slotId) where T : ISlot
+        {
+            foreach (var slot in m_Slots)
+            {
+                if (slot.isInputSlot && slot.id == slotId && slot is T)
+                    return (T)slot;
+            }
+            return default(T);
+        }
+
+        public T FindOutputSlot<T>(int slotId) where T : ISlot
+        {
+            foreach (var slot in m_Slots)
+            {
+                if (slot.isOutputSlot && slot.id == slotId && slot is T)
+                    return (T)slot;
+            }
+            return default(T);
+        }
+
+        public virtual IEnumerable<ISlot> GetInputsWithNoConnection()
+        {
+            return this.GetInputSlots<ISlot>().Where(x => !owner.GetEdges(GetSlotReference(x.id)).Any());
+        }
+
+        public virtual void OnBeforeSerialize()
+        {
+            m_GuidSerialized = m_Guid.ToString();
+            m_SerializableSlots = SerializationHelper.Serialize<ISlot>(m_Slots);
+        }
+
+        public virtual void OnAfterDeserialize()
+        {
+            if (!string.IsNullOrEmpty(m_GuidSerialized))
+                m_Guid = new Guid(m_GuidSerialized);
+            else
+                m_Guid = Guid.NewGuid();
+
+            m_Slots = SerializationHelper.Deserialize<ISlot>(m_SerializableSlots, null);
+            m_SerializableSlots = null;
+            foreach (var s in m_Slots)
+                s.owner = this;
+            UpdateNodeAfterDeserialization();
+        }
+
+        public virtual void UpdateNodeAfterDeserialization()
+        {}
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/AbstractMaterialGraphTests.cs

         }
 
         [Test]
-        public void TestCanNotAddSerializableNodeToMaterialGraph()
+        public void TestCanNotAddTestNodeToMaterialGraph()
-            var node = new SerializableNode();
+            var node = new TestNode();
             graph.AddNode(node);
             Assert.AreEqual(0, graph.edges.Count());
             Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/SerializedGraphTests.cs

         public void TestCanAddNodeToBaseMaterialGraph()
         {
             var graph = new TestMaterialGraph();
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.name = "Test Node";
             graph.AddNode(node);
 
         public void TestCanRemoveNodeFromBaseMaterialGraph()
         {
             var graph = new TestMaterialGraph();
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.name = "Test Node";
             graph.AddNode(node);
             Assert.AreEqual(1, graph.GetNodes<INode>().Count());
         [Test]
         public void TestCanModifyNodeDrawState()
         {
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.name = "Test Node";
 
             var drawState = node.drawState;
             Assert.IsFalse(node.drawState.expanded);
         }
 
-        private class SetErrorNode : SerializableNode
+        private class SetErrorNode : TestNode
         {
             public void SetError()
             {
         [Test]
         public void TestNodeGUIDCanBeRewritten()
         {
-            var node = new SerializableNode();
+            var node = new TestNode();
-        public class TestableNode : SerializableNode
+        public class TestableNode : TestNode
         {
             public const int Input0 = 0;
             public const int Input1 = 1;
             Assert.AreEqual(inputNode, graph.GetNodes<INode>().FirstOrDefault());
         }
 
-        private class NoDeleteNode : SerializableNode
+        private class NoDeleteNode : TestNode
         {
             public override bool canDeleteNode { get { return false; } }
         }
             Assert.AreEqual(1, graph.GetNodes<INode>().Count());
         }
 
-        private class OnEnableNode : SerializableNode, IOnAssetEnabled
+        private class OnEnableNode : TestNode, IOnAssetEnabled
         {
             public bool called = false;
             public void OnEnable()
         public void TestCanFindNodeInBaseMaterialGraph()
         {
             var graph = new TestMaterialGraph();
-            var node = new SerializableNode();
+            var node = new TestNode();
             graph.AddNode(node);
 
             Assert.AreEqual(1, graph.GetNodes<INode>().Count());
 
         [Test]
-        public void TestCanAddSlotToSerializableNode()
+        public void TestCanAddSlotToTestNode()
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output));
             node.AddSlot(new SerializableSlot(1, "input", SlotType.Input));
             node.name = "Test Node";
         }
 
         [Test]
-        public void TestCanNotAddNullSlotToSerializableNode()
+        public void TestCanNotAddNullSlotToTestNode()
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(null);
             node.name = "Test Node";
             Assert.AreEqual(0, node.GetOutputSlots<ISlot>().Count());
-        public void TestCanRemoveSlotFromSerializableNode()
+        public void TestCanRemoveSlotFromTestNode()
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output));
             node.AddSlot(new SerializableSlot(1, "input", SlotType.Input));
             graph.AddNode(node);
         }
 
         [Test]
-        public void TestCanRemoveSlotsWithNonMathingNameFromSerializableNode()
+        public void TestCanRemoveSlotsWithNonMathingNameFromTestNode()
         {
             var graph = new TestMaterialGraph();
             var node = new TestableNode();
         }
 
         [Test]
-        public void TestCanNotAddDuplicateSlotToSerializableNode()
+        public void TestCanNotAddDuplicateSlotToTestNode()
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output));
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output));
             node.name = "Test Node";
         }
 
         [Test]
-        public void TestCanUpdateDisplaynameByReaddingSlotToSerializableNode()
+        public void TestCanUpdateDisplaynameByReaddingSlotToTestNode()
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output));
             node.AddSlot(new SerializableSlot(0, "output_updated", SlotType.Output));
             node.name = "Test Node";
         public void TestCanUpdateSlotPriority()
         {
             var graph = new TestMaterialGraph();
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output, 0));
             node.name = "Test Node";
             graph.AddNode(node);
         }
 
         [Test]
-        public void TestCanUpdateSlotPriorityByReaddingSlotToSerializableNode()
+        public void TestCanUpdateSlotPriorityByReaddingSlotToTestNode()
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output, 0));
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output, 5));
             node.name = "Test Node";
         [Test]
         public void TestCanUpdateSlotDisplayName()
         {
-            var node = new SerializableNode();
+            var node = new TestNode();
             node.AddSlot(new SerializableSlot(0, "output", SlotType.Output));
             node.name = "Test Node";
 
         }
 
         [Test]
-        public void TestCanFindSlotOnSerializableNode()
+        public void TestCanFindSlotOnTestNode()
         {
             var node = new TestableNode();
 
         }
 
         [Test]
-        public void TestCanFindSlotReferenceOnSerializableNode()
+        public void TestCanFindSlotReferenceOnTestNode()
         {
             var node = new TestableNode();
 
             var outputNode = new TestableNode();
             graph.AddNode(outputNode);
 
-            var inputNode = new SerializableNode();
+            var inputNode = new TestNode();
             graph.AddNode(inputNode);
 
             Assert.AreEqual(2, graph.GetNodes<INode>().Count());

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/TestNode.cs

+namespace UnityEditor.ShaderGraph
+{
+    public class TestNode : AbstractMaterialNode
+    {
+
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/TestNode.cs.meta

+fileFormatVersion: 2
+guid: 5b3ff0f8519f4c0aa38ae4251a329e34
+timeCreated: 1513341923

MaterialGraphProject/Assets/UnityShaderEditor/Editor/SerializableGraph/Implementation/SerializableNode.cs.meta

-fileFormatVersion: 2
-guid: bd99903e0e5626448a8518284feeb047
-timeCreated: 1464264925
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/SerializableGraph/Implementation/SerializableNode.cs

-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityEngine;
-
-namespace UnityEditor.Graphing
-{
-    [Serializable]
-    public class SerializableNode : INode, ISerializationCallbackReceiver
-    {
-        [NonSerialized]
-        private Guid m_Guid;
-
-        [SerializeField]
-        private string m_GuidSerialized;
-
-        [SerializeField]
-        private string m_Name;
-
-        [SerializeField]
-        private DrawState m_DrawState;
-
-        [NonSerialized]
-        private List<ISlot> m_Slots = new List<ISlot>();
-
-        [SerializeField]
-        List<SerializationHelper.JSONSerializedElement> m_SerializableSlots = new List<SerializationHelper.JSONSerializedElement>();
-
-        public IGraph owner { get; set; }
-
-        public Guid guid
-        {
-            get { return m_Guid; }
-        }
-
-        public string name
-        {
-            get { return m_Name; }
-            set { m_Name = value; }
-        }
-
-        public virtual bool canDeleteNode
-        {
-            get { return true; }
-        }
-
-        public DrawState drawState
-        {
-            get { return m_DrawState; }
-            set
-            {
-                m_DrawState = value;
-                if (onModified != null)
-                    onModified(this, ModificationScope.Node);
-            }
-        }
-
-        public virtual bool hasError { get; protected set; }
-
-        public SerializableNode()
-        {
-            m_DrawState.expanded = true;
-            m_Guid = Guid.NewGuid();
-        }
-
-        public Guid RewriteGuid()
-        {
-            m_Guid = Guid.NewGuid();
-            return m_Guid;
-        }
-
-        public virtual void ValidateNode()
-        {}
-
-        public OnNodeModified onModified { get; set; }
-
-        public void GetInputSlots<T>(List<T> foundSlots) where T : ISlot
-        {
-            foreach (var slot in m_Slots)
-            {
-                if (slot.isInputSlot && slot is T)
-                    foundSlots.Add((T)slot);
-            }
-        }
-
-        public void GetOutputSlots<T>(List<T> foundSlots) where T : ISlot
-        {
-            foreach (var slot in m_Slots)
-            {
-                if (slot.isOutputSlot && slot is T)
-                    foundSlots.Add((T)slot);
-            }
-        }
-
-        public void GetSlots<T>(List<T> foundSlots) where T : ISlot
-        {
-            foreach (var slot in m_Slots)
-            {
-                if (slot is T)
-                    foundSlots.Add((T)slot);
-            }
-        }
-
-        public virtual void AddSlot(ISlot slot)
-        {
-            if (slot == null)
-                return;
-
-            m_Slots.RemoveAll(x => x.id == slot.id);
-            m_Slots.Add(slot);
-            slot.owner = this;
-
-            if (onModified != null)
-            {
-                onModified(this, ModificationScope.Topological);
-            }
-        }
-
-        public void RemoveSlot(int slotId)
-        {
-            // Remove edges that use this slot
-            // no owner can happen after creation
-            // but before added to graph
-            if (owner != null)
-            {
-                var edges = owner.GetEdges(GetSlotReference(slotId));
-
-                foreach (var edge in edges.ToArray())
-                    owner.RemoveEdge(edge);
-            }
-
-            //remove slots
-            m_Slots.RemoveAll(x => x.id == slotId);
-
-            if (onModified != null)
-            {
-                onModified(this, ModificationScope.Topological);
-            }
-        }
-
-        public void RemoveSlotsNameNotMatching(IEnumerable<int> slotIds, bool supressWarnings = false)
-        {
-            var invalidSlots = m_Slots.Select(x => x.id).Except(slotIds);
-
-            foreach (var invalidSlot in invalidSlots.ToArray())
-            {
-                if (!supressWarnings)
-                    Debug.LogWarningFormat("Removing Invalid MaterialSlot: {0}", invalidSlot);
-                RemoveSlot(invalidSlot);
-            }
-        }
-
-        public SlotReference GetSlotReference(int slotId)
-        {
-            var slot = FindSlot<ISlot>(slotId);
-            if (slot == null)
-                throw new ArgumentException("Slot could not be found", "slotId");
-            return new SlotReference(guid, slotId);
-        }
-
-        public T FindSlot<T>(int slotId) where T : ISlot
-        {
-            foreach (var slot in m_Slots)
-            {
-                if (slot.id == slotId && slot is T)
-                    return (T)slot;
-            }
-            return default(T);
-        }
-
-        public T FindInputSlot<T>(int slotId) where T : ISlot
-        {
-            foreach (var slot in m_Slots)
-            {
-                if (slot.isInputSlot && slot.id == slotId && slot is T)
-                    return (T)slot;
-            }
-            return default(T);
-        }
-
-        public T FindOutputSlot<T>(int slotId) where T : ISlot
-        {
-            foreach (var slot in m_Slots)
-            {
-                if (slot.isOutputSlot && slot.id == slotId && slot is T)
-                    return (T)slot;
-            }
-            return default(T);
-        }
-
-        public virtual IEnumerable<ISlot> GetInputsWithNoConnection()
-        {
-            return this.GetInputSlots<ISlot>().Where(x => !owner.GetEdges(GetSlotReference(x.id)).Any());
-        }
-
-        public virtual void OnBeforeSerialize()
-        {
-            m_GuidSerialized = m_Guid.ToString();
-            m_SerializableSlots = SerializationHelper.Serialize<ISlot>(m_Slots);
-        }
-
-        public virtual void OnAfterDeserialize()
-        {
-            if (!string.IsNullOrEmpty(m_GuidSerialized))
-                m_Guid = new Guid(m_GuidSerialized);
-            else
-                m_Guid = Guid.NewGuid();
-
-            m_Slots = SerializationHelper.Deserialize<ISlot>(m_SerializableSlots, null);
-            m_SerializableSlots = null;
-            foreach (var s in m_Slots)
-                s.owner = this;
-            UpdateNodeAfterDeserialization();
-        }
-
-        public virtual void UpdateNodeAfterDeserialization()
-        {}
-    }
-}