#35 Unify {Graph,Material}NodePresenter

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/MaterialGraphView.cs

                 return EventPropagation.Stop;
 
             nodalViewData.RemoveElements(
-                selection.OfType<MaterialNodeDrawer>().Select(x => x.GetPresenter<GraphNodePresenter>()),
+                selection.OfType<MaterialNodeDrawer>().Select(x => x.GetPresenter<MaterialNodePresenter>()),
                 selection.OfType<Edge>().Select(x => x.GetPresenter<GraphEdgePresenter>())
                 );
 
                 return;
 
             var graphAsset = graphDataSource.graphAsset;
-            if (graphAsset == null || graphAsset.drawingData.selection.SequenceEqual(selection.OfType<MaterialNodeDrawer>().Select(d => ((GraphNodePresenter) d.presenter).node.guid))) return;
+            if (graphAsset == null || graphAsset.drawingData.selection.SequenceEqual(selection.OfType<MaterialNodeDrawer>().Select(d => ((MaterialNodePresenter) d.presenter).node.guid))) return;
-                            .FirstOrDefault(drawer => ((GraphNodePresenter) drawer.presenter).node.guid == guid))
+                            .FirstOrDefault(drawer => ((MaterialNodePresenter) drawer.presenter).node.guid == guid))
                 .ToList();
 
             ClearSelection();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MaterialGraphPresenter.cs

 
         protected MaterialGraphPresenter()
         {
-            typeMapper = new GraphTypeMapper(typeof(GraphNodePresenter));
+            typeMapper = new GraphTypeMapper(typeof(MaterialNodePresenter));
             typeMapper[typeof(AbstractMaterialNode)] = typeof(MaterialNodePresenter);
             typeMapper[typeof(ColorNode)] = typeof(ColorNodePresenter);
             typeMapper[typeof(GradientNode)] = typeof(GradientNodePresenter);
             NodeUtils.CollectNodesNodeFeedsInto(dependentNodes, inNode);
             foreach (var node in dependentNodes)
             {
-                var theElements = m_Elements.OfType<GraphNodePresenter>().ToList();
+                var theElements = m_Elements.OfType<MaterialNodePresenter>().ToList();
                 var found = theElements.Where(x => x.node.guid == node.guid).ToList();
                 foreach (var drawableNodeData in found)
                     drawableNodeData.OnModified(scope);
         {
             // Find all nodes currently being drawn which are no longer in the graph (i.e. deleted)
             var deletedElements = m_Elements
-                .OfType<GraphNodePresenter>()
+                .OfType<MaterialNodePresenter>()
                 .Where(nd => !graphAsset.graph.GetNodes<INode>().Contains(nd.node))
                 .OfType<GraphElementPresenter>()
                 .ToList();
                 edgeData.input.Disconnect(edgeData);
 
                 var toNodeGuid = edgeData.edge.inputSlot.nodeGuid;
-                var toNode = m_Elements.OfType<GraphNodePresenter>().FirstOrDefault(nd => nd.node.guid == toNodeGuid);
+                var toNode = m_Elements.OfType<MaterialNodePresenter>().FirstOrDefault(nd => nd.node.guid == toNodeGuid);
                 if (toNode != null)
                 {
                     // Make the input node (i.e. right side of the connection) re-render
                 m_Elements.Remove(deletedElement);
             }
 
-            var addedNodes = new List<GraphNodePresenter>();
+            var addedNodes = new List<MaterialNodePresenter>();
-                if (m_Elements.OfType<GraphNodePresenter>().Any(e => e.node == node))
+                if (m_Elements.OfType<MaterialNodePresenter>().Any(e => e.node == node))
-                var nodeData = (GraphNodePresenter)typeMapper.Create(node);
+                var nodeData = (MaterialNodePresenter)typeMapper.Create(node);
 
                 node.onModified += OnNodeChanged;
 
                 {
                     var fromNode = graphAsset.graph.GetNodeFromGuid(edge.outputSlot.nodeGuid);
                     var fromSlot = fromNode.FindOutputSlot<ISlot>(edge.outputSlot.slotId);
-                    var sourceNode = m_Elements.OfType<GraphNodePresenter>().FirstOrDefault(x => x.node == fromNode);
+                    var sourceNode = m_Elements.OfType<MaterialNodePresenter>().FirstOrDefault(x => x.node == fromNode);
-                    var targetNode = m_Elements.OfType<GraphNodePresenter>().FirstOrDefault(x => x.node == toNode);
+                    var targetNode = m_Elements.OfType<MaterialNodePresenter>().FirstOrDefault(x => x.node == toNode);
                     var targetAnchors = targetNode.elements.OfType<GraphAnchorPresenter>();
                     var targetAnchor = targetAnchors.FirstOrDefault(x => x.slot == toSlot);
 
             UpdateData();
         }
 
-        public void RemoveElements(IEnumerable<GraphNodePresenter> nodes, IEnumerable<GraphEdgePresenter> edges)
+        public void RemoveElements(IEnumerable<MaterialNodePresenter> nodes, IEnumerable<GraphEdgePresenter> edges)
         {
             graphAsset.graph.RemoveElements(nodes.Select(x => x.node), edges.Select(x => x.edge));
             graphAsset.graph.ValidateGraph();
             var graph = new CopyPasteGraph();
             foreach (var presenter in selection)
             {
-                var nodePresenter = presenter as GraphNodePresenter;
+                var nodePresenter = presenter as MaterialNodePresenter;
                 if (nodePresenter != null)
                 {
                     graph.AddNode(nodePresenter.node);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MaterialNodePresenter.cs

 namespace UnityEditor.MaterialGraph.Drawing
 {
     [Serializable]
-    public class MaterialNodePresenter : GraphNodePresenter
+    public class MaterialNodePresenter : NodePresenter
+        public INode node { get; private set; }
+
+        [SerializeField]
+        protected List<GraphElementPresenter> m_Controls = new List<GraphElementPresenter>();
+
         [SerializeField]
         NodePreviewPresenter m_NodePreviewPresenter;
 
             get { return node is IRequiresTime; }
         }
 
-        public override IEnumerable<GraphElementPresenter> elements
+        public IEnumerable<GraphElementPresenter> elements
-                foreach (var element in base.elements)
+                return inputAnchors.Concat(outputAnchors).Cast<GraphElementPresenter>().Concat(m_Controls).Concat(new [] {m_NodePreviewPresenter});
+            }
+        }
+
+        public override bool expanded
+        {
+            get { return base.expanded; }
+            set
+            {
+                if (base.expanded != value)
-                    yield return element;
+                    base.expanded = value;
+                    DrawState ds = node.drawState;
+                    ds.expanded = value;
+                    node.drawState = ds;
-                yield return m_NodePreviewPresenter;
             }
         }
 
             return towatch.ToArray();
         }
 
-        public override void OnModified(ModificationScope scope)
+        public virtual void OnModified(ModificationScope scope)
-            base.OnModified(scope);
+
+            expanded = node.drawState.expanded;
+
+            if (scope == ModificationScope.Topological)
+            {
+                var slots = node.GetSlots<ISlot>().ToList();
+
+                inputAnchors.RemoveAll(data => !slots.Contains(((GraphAnchorPresenter)data).slot));
+                outputAnchors.RemoveAll(data => !slots.Contains(((GraphAnchorPresenter)data).slot));
+
+                AddSlots(slots.Except(inputAnchors.Concat(outputAnchors).Select(data => ((GraphAnchorPresenter)data).slot)));
+
+                inputAnchors.Sort((x, y) => slots.IndexOf(((GraphAnchorPresenter)x).slot) - slots.IndexOf(((GraphAnchorPresenter)y).slot));
+                outputAnchors.Sort((x, y) => slots.IndexOf(((GraphAnchorPresenter)x).slot) - slots.IndexOf(((GraphAnchorPresenter)y).slot));
+            }
+
+        public override void CommitChanges()
+        {
+            var drawState = node.drawState;
+            drawState.position = position;
+            node.drawState = drawState;
+        }
+
+        protected virtual IEnumerable<GraphElementPresenter> GetControlData()
+        {
+            return Enumerable.Empty<GraphElementPresenter>();
+        }
+
+        protected void AddSlots(IEnumerable<ISlot> slots)
+        {
+            foreach (var slot in slots)
+            {
+                if (slot.hidden)
+                    continue;
+
+                var data = CreateInstance<GraphAnchorPresenter>();
+                data.capabilities &= ~Capabilities.Movable;
+                data.Initialize(slot);
+
+                if (slot.isOutputSlot)
+                {
+                    outputAnchors.Add(data);
+                }
+                else
+                {
+                    inputAnchors.Add(data);
+                }
+            }
+        }
+
-        public override void Initialize(INode inNode)
+        public virtual void Initialize(INode inNode)
-            base.Initialize(inNode);
+            node = inNode;
+
+            if (node == null)
+                return;
+
+            title = inNode.name;
+            expanded = node.drawState.expanded;
+
+            AddSlots(node.GetSlots<ISlot>());
+
+            var controlData = GetControlData();
+            m_Controls.AddRange(controlData);
+
+            position = new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0);
+
             m_Version = 0;
             AddPreview(inNode);
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/GraphNodePresenter.cs

-using System.Collections.Generic;
-using System.Linq;
-using UnityEditor.Experimental.UIElements.GraphView;
-using UnityEngine;
-using UnityEngine.Graphing;
-using UnityEditor.Experimental.UIElements.GraphView;
-
-namespace UnityEditor.MaterialGraph.Drawing
-{
-    public class GraphNodePresenter : NodePresenter
-    {
-        protected GraphNodePresenter()
-        {}
-
-        public INode node { get; private set; }
-
-        [SerializeField]
-        protected List<GraphElementPresenter> m_Controls = new List<GraphElementPresenter>();
-
-        public virtual IEnumerable<GraphElementPresenter> elements
-        {
-            get { return inputAnchors.Concat(outputAnchors).Cast<GraphElementPresenter>().Concat(m_Controls); }
-        }
-
-        public override bool expanded
-        {
-            get { return base.expanded; }
-            set
-            {
-                if (base.expanded != value)
-                {
-                    base.expanded = value;
-                    DrawState ds = node.drawState;
-                    ds.expanded = value;
-                    node.drawState = ds;
-                }
-            }
-        }
-
-        public virtual void OnModified(ModificationScope scope)
-        {
-            expanded = node.drawState.expanded;
-
-            if (scope == ModificationScope.Topological)
-            {
-                var slots = node.GetSlots<ISlot>().ToList();
-
-                inputAnchors.RemoveAll(data => !slots.Contains(((GraphAnchorPresenter)data).slot));
-                outputAnchors.RemoveAll(data => !slots.Contains(((GraphAnchorPresenter)data).slot));
-
-                AddSlots(slots.Except(inputAnchors.Concat(outputAnchors).Select(data => ((GraphAnchorPresenter)data).slot)));
-
-                inputAnchors.Sort((x, y) => slots.IndexOf(((GraphAnchorPresenter)x).slot) - slots.IndexOf(((GraphAnchorPresenter)y).slot));
-                outputAnchors.Sort((x, y) => slots.IndexOf(((GraphAnchorPresenter)x).slot) - slots.IndexOf(((GraphAnchorPresenter)y).slot));
-            }
-        }
-
-        public override void CommitChanges()
-        {
-            var drawState = node.drawState;
-            drawState.position = position;
-            node.drawState = drawState;
-        }
-
-        protected virtual IEnumerable<GraphElementPresenter> GetControlData()
-        {
-            return Enumerable.Empty<GraphElementPresenter>();
-        }
-
-        protected void AddSlots(IEnumerable<ISlot> slots)
-        {
-            foreach (var slot in slots)
-            {
-                if (slot.hidden)
-                    continue;
-
-                var data = CreateInstance<GraphAnchorPresenter>();
-                data.capabilities &= ~Capabilities.Movable;
-                data.Initialize(slot);
-
-                if (slot.isOutputSlot)
-                {
-                    outputAnchors.Add(data);
-                }
-                else
-                {
-                    inputAnchors.Add(data);
-                }
-            }
-        }
-
-        // TODO JOCE: Move to OnEnable??
-        public virtual void Initialize(INode inNode)
-        {
-            node = inNode;
-
-            if (node == null)
-                return;
-
-            title = inNode.name;
-            expanded = node.drawState.expanded;
-
-            AddSlots(node.GetSlots<ISlot>());
-
-            var controlData = GetControlData();
-            m_Controls.AddRange(controlData);
-
-            position = new Rect(node.drawState.position.x, node.drawState.position.y, 0, 0);
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/GraphNodePresenter.cs.meta

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