Merge master

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Assets/IGraphAsset.cs

-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
 }

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Assets/SerializableGraphAsset.cs

-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
 }

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/Edge.cs

 using System;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     [Serializable]
     public class Edge : IEdge

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/NodeUtils.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine.MaterialGraph;
+using UnityEditor.ShaderGraph;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public class SlotConfigurationException : Exception
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/SerializableGraph.cs

 using System.Reflection;
 using System.Runtime.InteropServices;
 using NUnit.Framework;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     [Serializable]
     public class SerializableGraph : IGraph, ISerializationCallbackReceiver
         [SerializeField]
         List<SerializationHelper.JSONSerializedElement> m_SerializableEdges = new List<SerializationHelper.JSONSerializedElement>();
 
+        [NonSerialized]
+        List<INode> m_AddedNodes = new List<INode>();
+
+        [NonSerialized]
+        List<INode> m_RemovedNodes = new List<INode>();
+
+        [NonSerialized]
+        List<IEdge> m_AddedEdges = new List<IEdge>();
+
+        [NonSerialized]
+        List<IEdge> m_RemovedEdges = new List<IEdge>();
+
+        public IEnumerable<INode> addedNodes
+        {
+            get { return m_AddedNodes; }
+        }
+
+        public IEnumerable<INode> removedNodes
+        {
+            get { return m_RemovedNodes; }
+        }
+
+        public IEnumerable<IEdge> addedEdges
+        {
+            get { return m_AddedEdges; }
+        }
+
+        public IEnumerable<IEdge> removedEdges
+        {
+            get { return m_RemovedEdges; }
+        }
+
+        public IGraphObject owner { get; set; }
+
+        public virtual void ClearChanges()
+        {
+            m_AddedNodes.Clear();
+            m_RemovedNodes.Clear();
+            m_AddedEdges.Clear();
+            m_RemovedEdges.Clear();
+        }
+
         public IEnumerable<T> GetNodes<T>() where T : INode
         {
             return m_Nodes.Values.OfType<T>();
         {
             m_Nodes.Add(node.guid, node);
             node.owner = this;
-            NotifyChange(new NodeAddedGraphChange(node));
+            m_AddedNodes.Add(node);
         }
 
         public virtual void RemoveNode(INode node)
 
             m_Nodes.Remove(node.guid);
-            NotifyChange(new NodeRemovedGraphChange(node));
+            m_RemovedNodes.Add(node);
             ValidateGraph();
         }
 
                 return;
 
             m_Nodes.Remove(node.guid);
-            NotifyChange(new NodeRemovedGraphChange(node));
+            m_RemovedNodes.Add(node);
         }
 
         void AddEdgeToNodeEdges(IEdge edge)
             return new Dictionary<SerializationHelper.TypeSerializationInfo, SerializationHelper.TypeSerializationInfo>();
         }
 
-        public virtual IEdge Connect(SlotReference fromSlotRef, SlotReference toSlotRef)
+        IEdge ConnectNoValidate(SlotReference fromSlotRef, SlotReference toSlotRef)
         {
             if (fromSlotRef == null || toSlotRef == null)
                 return null;
 
             var newEdge = new Edge(outputSlot, inputSlot);
             m_Edges.Add(newEdge);
-            NotifyChange(new EdgeAddedGraphChange(newEdge));
+            m_AddedEdges.Add(newEdge);
+            return newEdge;
+        }
+
+        public virtual IEdge Connect(SlotReference fromSlotRef, SlotReference toSlotRef)
+        {
+            var newEdge = ConnectNoValidate(fromSlotRef, toSlotRef);
             ValidateGraph();
             return newEdge;
         }
             if (m_NodeEdges.TryGetValue(e.outputSlot.nodeGuid, out outputNodeEdges))
                 outputNodeEdges.Remove(e);
 
-            NotifyChange(new EdgeRemovedGraphChange(e));
+            m_RemovedEdges.Add(e);
         }
 
         public INode GetNodeFromGuid(Guid guid)
                 AddEdgeToNodeEdges(edge);
 
             OnEnable();
-            ValidateGraph(); 
+            ValidateGraph();
         }
 
         public virtual void ValidateGraph()
             //manually modifies serialized data
             //of if they delete a node in the inspector
-            //debug view. 
-            foreach (var edge in edges.ToArray()) 
+            //debug view.
+            foreach (var edge in edges.ToArray())
             {
                 var outputNode = GetNodeFromGuid(edge.outputSlot.nodeGuid);
                 var inputNode = GetNodeFromGuid(edge.inputSlot.nodeGuid);
                         removedNodeEdges.Add(edge);
                 }
                 foreach (var edge in removedNodeEdges)
-                    RemoveEdge(edge);
+                    RemoveEdgeNoValidate(edge);
             }
 
             // Remove all nodes and re-add them.
                 foreach (var node in m_Nodes.Values)
                     removedNodeGuids.Add(node.guid);
                 foreach (var nodeGuid in removedNodeGuids)
-                    RemoveNode(m_Nodes[nodeGuid]);
+                    RemoveNodeNoValidate(m_Nodes[nodeGuid]);
+
+            ValidateGraph();
-                    AddNode(node);
+                    AddNodeNoValidate(node);
             }
 
             // Add edges from other graph which don't exist in this one.
-                    Connect(edge.outputSlot, edge.inputSlot);
+                    ConnectNoValidate(edge.outputSlot, edge.inputSlot);
+
+            ValidateGraph();
         }
 
         public void OnEnable()
                 node.OnEnable();
             }
-        }
-
-        public OnGraphChange onChange { get; set; }
-
-        public IGraphObject owner { get; set; }
-
-        protected void NotifyChange(GraphChange change)
-        {
-            if (onChange != null)
-                onChange(change);
         }
     }
 }

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/SerializableGraphObject.cs

 using System;
 using UnityEditor;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public class SerializableGraphObject : ScriptableObject, IGraphObject, ISerializationCallbackReceiver
     {

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

 using System;
 using System.Collections.Generic;
 using System.Linq;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     [Serializable]
     public class SerializableNode : INode, ISerializationCallbackReceiver

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/SerializableSlot.cs

 using System;
 using System.Linq;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     [Serializable]
     public class SerializableSlot : ISlot

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Implementation/SlotType.cs

-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public enum SlotType
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/DrawState.cs

 using System;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     [Serializable]
     public struct DrawState

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/GraphChange.cs

 using System;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public abstract class GraphChange {}
 

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/GraphDrawingData.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     [Serializable]
     public class GraphDrawingData : ISerializationCallbackReceiver

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/IEdge.cs

 using System;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public interface IEdge : IEquatable<IEdge>
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/IGraph.cs

 using System;
 using System.Collections.Generic;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
-    public delegate void OnGraphChange(GraphChange change);
-
     public interface IGraph : IOnAssetEnabled
     {
         IEnumerable<T> GetNodes<T>() where T : INode;
         IEnumerable<IEdge> GetEdges(SlotReference s);
         void ValidateGraph();
         void ReplaceWith(IGraph other);
-        OnGraphChange onChange { get; set; }
+        IEnumerable<INode> addedNodes { get; }
+        IEnumerable<INode> removedNodes { get; }
+        IEnumerable<IEdge> addedEdges { get; }
+        IEnumerable<IEdge> removedEdges { get; }
+        void ClearChanges();
     }
 }

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/IGraphObject.cs

-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public interface IGraphObject
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/INode.cs

 using System;
 using System.Collections.Generic;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public enum ModificationScope
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/IOnAssetEnabled.cs

-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public interface IOnAssetEnabled
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/ISlot.cs

 using System;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public interface ISlot : IEquatable<ISlot>
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Interfaces/SlotReference.cs

 using System;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     [Serializable]
     public class SlotReference : ISerializationCallbackReceiver, IEquatable<SlotReference>

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Testing/IntegrationTests/SerializationTests.cs

 using System.Collections.Generic;
 using NUnit.Framework;
 using UnityEngine;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
 
 namespace UnityEditor.Graphing.IntegrationTests
 {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Testing/UnitTests/SerializedGraphTests.cs

 using System.Linq;
 using NUnit.Framework;
 using UnityEngine;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
 
 namespace UnityEditor.Graphing.UnitTests
 {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/DictionaryPool.cs

 using System.Collections.Generic;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public static class DictionaryPool<TKey, TValue>
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/ListPool.cs

 using System.Collections.Generic;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public static class ListPool<T>
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/Logging.cs

 using System;
+using UnityEngine;
+using Object = System.Object;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
-        public void LogFormat(LogType logType, Object context, string format, params object[] args)
+        public void LogFormat(LogType logType, UnityEngine.Object context, string format, params object[] args)
-        public void LogException(Exception exception, Object context)
+        public void LogException(Exception exception, UnityEngine.Object context)
         {
             Console.WriteLine("{0} - {1}", context, exception);
         }

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/ObjectPool.cs

 using System;
 using System.Collections.Generic;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     class ObjectPool<T> where T : new()
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/PooledObject.cs

 using System;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public class PooledObject<T> : IDisposable where T : new()
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/QueuePool.cs

 using System.Collections.Generic;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public static class QueuePool<T>
     {

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/SerializationHelper.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public static class SerializationHelper
     {
             [SerializeField]
             public string fullName;
-
-            [SerializeField]
-            public string assemblyName;
-                return !string.IsNullOrEmpty(fullName) && !string.IsNullOrEmpty(assemblyName);
-            }
-
-            public string SearchString()
-            {
-                if (!IsValid())
-                    return string.Empty;
-
-                return string.Format("{0}, {1}", fullName, assemblyName);
-            }
-
-            public string SearchStringTestable()
-            {
-                if (!IsValid())
-                    return string.Empty;
-
-                return string.Format("{0}, {1}-testable", fullName, assemblyName);
+                return !string.IsNullOrEmpty(fullName);
             }
         }
 
         {
             return new TypeSerializationInfo
             {
-                fullName = type.FullName,
-                assemblyName = type.Assembly.GetName().Name
+                fullName = type.FullName
-        private static Type GetTypeFromSerializedString(TypeSerializationInfo typeInfo)
+        static Type GetTypeFromSerializedString(TypeSerializationInfo typeInfo)
-            var res =  Type.GetType(typeInfo.SearchString());
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+            foreach (var assembly in assemblies)
+            {
+                var type = assembly.GetType(typeInfo.fullName);
+                if (type != null)
+                    return type;
+            }
-            // if we are using a 'testable' dll.
-            if (res == null)
-                res = Type.GetType(typeInfo.SearchStringTestable());
-
-            return res;
+            return null;
         }
 
         public static JSONSerializedElement Serialize<T>(T item)
             };
         }
 
-        private static TypeSerializationInfo DoTypeRemap(TypeSerializationInfo info, Dictionary<TypeSerializationInfo, TypeSerializationInfo> remapper)
+        static TypeSerializationInfo DoTypeRemap(TypeSerializationInfo info, Dictionary<TypeSerializationInfo, TypeSerializationInfo> remapper)
         {
             TypeSerializationInfo foundInfo;
             if (remapper.TryGetValue(info, out foundInfo))
                 throw new ArgumentException(string.Format("Can not deserialize {0}, it is invalid", item));
 
             TypeSerializationInfo info = item.typeInfo;
+            info.fullName = info.fullName.Replace("UnityEngine.MaterialGraph", "UnityEditor.ShaderGraph");
+            info.fullName = info.fullName.Replace("UnityEngine.Graphing", "UnityEditor.Graphing");
-            info.assemblyName = "Assembly-CSharp-Editor";
-                throw new ArgumentException(string.Format("Can not deserialize ({0}, {1}), type is invalid", info.assemblyName, info.fullName));
+                throw new ArgumentException(string.Format("Can not deserialize ({0}), type is invalid", info.fullName));
 
             T instance;
             try

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Util/StackPool.cs

 using System.Collections.Generic;
 
-namespace UnityEngine.Graphing
+namespace UnityEditor.Graphing
 {
     public static class StackPool<T>
     {

MaterialGraphProject/Assets/NewNodes/Editor/ChannelBlendNode.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     /*  [Title("Art/ChannelBlend")]
       public class ChannelBlend : FunctionNInNOut, IGeneratesFunction

MaterialGraphProject/Assets/NewNodes/Editor/CommonMatrixType.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public enum CommonMatrixType
     {

MaterialGraphProject/Assets/NewNodes/Editor/ConstantType.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public enum ConstantType
     {

MaterialGraphProject/Assets/NewNodes/Editor/FractalNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Procedural/Fractal")]
     public class FractalNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/FunctionNAddNode.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     /*  [Title("Math/Advanced/Adder")]
       public class AddManyNode : FunctionNInNOut, IGeneratesFunction

MaterialGraphProject/Assets/NewNodes/Editor/FunctionNInNOut.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     /* public abstract class FunctionNInNOut : AbstractMaterialNode, IGeneratesBodyCode
      {

MaterialGraphProject/Assets/NewNodes/Editor/Keep/BlendModeNode.cs

 using System.Reflection;
-using UnityEditor.MaterialGraph.Drawing.Controls;
-using UnityEngine.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Art/BlendMode")]
     public class BlendModeNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/BlendModesEnum.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public enum BlendModesEnum
     {

MaterialGraphProject/Assets/NewNodes/Editor/Keep/ColorBalanceNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Art/Adjustments/ColorBalance")]
     public class ColorBalanceNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/ConstantsNode.cs

 using System.Collections.Generic;
-using UnityEditor.MaterialGraph.Drawing.Controls;
-using UnityEngine.MaterialGraph;
-using UnityEngine.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.ShaderGraph;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Math/Constants")]
     public class ConstantsNode : AbstractMaterialNode, IGeneratesBodyCode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/GradientNode.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEditor.MaterialGraph.Drawing.Controls;
-using UnityEngine.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Gradient")]
     public class GradientNode : AbstractMaterialNode, IGeneratesBodyCode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/HeightToNormalNode.cs

 using System.Linq;
 using System.Reflection;
 using JetBrains.Annotations;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Utility/Heightmap To Normalmap")]
     public class HeightToNormalNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireMeshUV

MaterialGraphProject/Assets/NewNodes/Editor/Keep/LightProbeNode.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using UnityEngine;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Scene Data/Light Probe")]
     public class LightProbeNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/ParallaxNode.cs

-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
 
     [Title("UV/Parallax")]

MaterialGraphProject/Assets/NewNodes/Editor/Keep/RadialShearNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("UV/RadialShearNode")]
     public class RadialShearNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/RandomRangeNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Math/Range/RandomRange")]
     public class RandomRangeNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/ReciprocalSqrtNode.cs

 using System.Reflection;
 
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Math/Advanced/Reciprocal Square Root")]
     public class ReciprocalSqrtNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/ReflectionProbeNode.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using UnityEngine;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Scene Data/Reflection Probe")]
     public class ReflectionProbeNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/SamplerStateNode.cs

 using System;
-using UnityEditor.MaterialGraph.Drawing.Controls;
-using UnityEngine.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Texture/Sampler State")]
     public class SamplerStateNode : AbstractMaterialNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/ScaleOffsetNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("UV/ScaleOffset")]
     public class ScaleOffsetNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/TangentToWorldNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Math/Vector/TangentToWorld")]
     public class TangentToWorldNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Keep/TextureSamplerNode.cs

 using System.Linq;
 using System.Reflection;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Texture/Sample 2D")]
     public class Sample2DTexture : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireMeshUV

MaterialGraphProject/Assets/NewNodes/Editor/Keep/TransformNode.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-using UnityEditor.MaterialGraph.Drawing.Controls;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Math/Vector/Transform")]
     public class TransformNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireTangent, IMayRequireBitangent, IMayRequireNormal

MaterialGraphProject/Assets/NewNodes/Editor/Keep/UVTriPlanar.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     /* [Title("UV/Tri-Planar Mapping")]
      public class UVTriPlanar : FunctionNInNOut, IGeneratesFunction, IMayRequireNormal, IMayRequireWorldPosition

MaterialGraphProject/Assets/NewNodes/Editor/Kill/AACheckerBoard3dNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Procedural/AACheckerboard3d")]
     public class AACheckerboard3dNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Kill/AACheckerBoardNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Procedural/AACheckerboard")]
     public class AACheckerboardNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Kill/MultiLayerParallaxNode.cs

-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("UV/MultiLayerParallax")]
     public class MultiLayerParallaxNode : AbstractMaterialNode, IGeneratesBodyCode, IGeneratesFunction, IMayRequireMeshUV, IMayRequireViewDirection

MaterialGraphProject/Assets/NewNodes/Editor/Kill/POMNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("UV/ParallaxOcclusionMapping")]
     public class ParallaxOcclusionMappingNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Kill/ScatterNode.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     /*  [Title("Procedural/Scatter")]
       public class ScatterNode : FunctionNInNOut, IGeneratesFunction

MaterialGraphProject/Assets/NewNodes/Editor/Kill/SphereWarpNode.cs

 using System.Reflection;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("UV/SphereWarpNode")]
     public class SphereWarpNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Kill/SphericalIndentationNode.cs

 using System.Reflection;
-
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("UV/SphericalIndentation")]
     public class SphericalIndentationNode : CodeFunctionNode

MaterialGraphProject/Assets/NewNodes/Editor/Kill/ToggleNode.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
    /* [Title("Input/Toggle")]
     public class ToggleNode : PropertyNode, IGeneratesBodyCode

MaterialGraphProject/Assets/NewNodes/Editor/Kill/VertexNormalNode.cs

-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Input/Geometry/Vertex Normal")]
     public class VertexNormalNode : AbstractMaterialNode

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateLayeredShaderGraph.cs

 using System.IO;
 using UnityEditor.ProjectWindowCallback;
-using UnityEngine.MaterialGraph;
+using UnityEditor.ShaderGraph;
-namespace UnityEditor.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public class CreateLayeredShaderGraph : EndNameEditAction
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateRemapGraph.cs

 using System.IO;
 using UnityEditor.ProjectWindowCallback;
-using UnityEngine.MaterialGraph;
+using UnityEditor.ShaderGraph;
-namespace UnityEditor.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public class CreateRemapGraph : EndNameEditAction
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateShaderGraph.cs

 using System.IO;
 using UnityEditor.ProjectWindowCallback;
-using UnityEngine.MaterialGraph;
+using UnityEditor.ShaderGraph;
-namespace UnityEditor.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public class CreateShaderGraph : EndNameEditAction
     {
 
         public override void Action(int instanceId, string pathName, string resourceFile)
         {
-            var graph = new UnityEngine.MaterialGraph.MaterialGraph();
+            var graph = new ShaderGraph.MaterialGraph();
             graph.AddNode(new LightweightMetallicMasterNode());
             File.WriteAllText(pathName, EditorJsonUtility.ToJson(graph));
             AssetDatabase.Refresh();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/AssetCallbacks/CreateShaderSubGraph.cs

 using System.IO;
 using UnityEditor.ProjectWindowCallback;
-using UnityEngine.MaterialGraph;
+using UnityEditor.ShaderGraph;
-namespace UnityEditor.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public class CreateShaderSubGraph : EndNameEditAction
     {

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

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public abstract class AbstractMaterialGraph : SerializableGraph, IGenerateProperties
 
         [SerializeField]
         List<SerializationHelper.JSONSerializedElement> m_SerializedProperties = new List<SerializationHelper.JSONSerializedElement>();
+
+        [NonSerialized]
+        List<IShaderProperty> m_AddedProperties = new List<IShaderProperty>();
+
+        [NonSerialized]
+        List<Guid> m_RemovedProperties = new List<Guid>();
 
         public IEnumerable<IShaderProperty> properties
         {
+        public IEnumerable<IShaderProperty> addedProperties
+        {
+            get { return m_AddedProperties; }
+        }
+
+        public IEnumerable<Guid> removedProperties
+        {
+            get { return m_RemovedProperties; }
+        }
+
+        public override void ClearChanges()
+        {
+            base.ClearChanges();
+            m_AddedProperties.Clear();
+            m_RemovedProperties.Clear();
+        }
+
         public override void AddNode(INode node)
         {
             if (node is AbstractMaterialNode)
                 return;
 
             m_Properties.Add(property);
-            NotifyChange(new ShaderPropertyAdded(property));
+            m_AddedProperties.Add(property);
-                NotifyChange(new ShaderPropertyRemoved(guid));
+                m_RemovedProperties.Add(guid);
         }
 
         public override Dictionary<SerializationHelper.TypeSerializationInfo, SerializationHelper.TypeSerializationInfo> GetLegacyTypeRemapping()
             {
-                fullName = "UnityEngine.MaterialGraph.ViewDirectionNode",
-                assemblyName = "Assembly-CSharp"
+                fullName = "UnityEngine.MaterialGraph.ViewDirectionNode"
-                fullName = "UnityEngine.MaterialGraph.NormalNode",
-                assemblyName = "Assembly-CSharp"
+                fullName = "UnityEngine.MaterialGraph.NormalNode"
-                fullName = "UnityEngine.MaterialGraph.WorldPosNode",
-                assemblyName = "Assembly-CSharp"
+                fullName = "UnityEngine.MaterialGraph.WorldPosNode"
             };
             result[worldPosNode] = SerializationHelper.GetTypeSerializableAsString(typeof(PositionNode));
 

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

 using System.Linq;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
 }

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

 using System;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public abstract class AbstractShaderProperty<T> : IShaderProperty

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

 using System;
 using System.Text;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class ColorShaderProperty : AbstractShaderProperty<Color>

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

 using System;
 using System.Text;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class FloatShaderProperty : AbstractShaderProperty<float>

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

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
 }

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

 using System.Collections.Generic;
 
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IShaderGraph
     {

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

 using System;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IShaderProperty
     {

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

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class MaterialGraph : AbstractMaterialGraph, IShaderGraph

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

+
+using UnityEngine;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public class MaterialGraphAsset
     {

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

 using System;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public abstract class MaterialSlot : SerializableSlot
         ShaderStage m_ShaderStage;
 
         private bool m_HasError;
-        
+
         protected MaterialSlot() { }
 
         protected MaterialSlot(int slotId, string displayName, string shaderOutputName, SlotType slotType, ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
 
         public string RawDisplayName()
         {
-            return displayName;
+            return base.displayName;
-        
+
         public static MaterialSlot CreateMaterialSlot(SlotValueType type, int slotId, string displayName, string shaderOutputName, SlotType slotType, Vector4 defaultValue, ShaderStage shaderStage = ShaderStage.Dynamic, bool hidden = false)
         {
             switch (type)

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

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public enum Precision
     {

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

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public enum PreviewMode
     {

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

-namespace UnityEngine.MaterialGraph
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
 {
     public class PreviewProperty
     {

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

 using System;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     class SamplerStateShaderProperty : AbstractShaderProperty<TextureSamplerState>
     {

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

 using System;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class SerializableGuid : ISerializationCallbackReceiver

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

 using System;
 using UnityEditor;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class SerializableTexture

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

 using System.Collections.Generic;
 
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public struct ShaderGraphRequirements
     {

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

-namespace UnityEngine.MaterialGraph
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
 {
     public class TextureSamplerState
     {

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

 using System;
 using System.Text;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class TextureShaderProperty : AbstractShaderProperty<SerializableTexture>

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

 using System;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class Vector2ShaderProperty : VectorShaderProperty

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

 using System;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class Vector3ShaderProperty : VectorShaderProperty

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

 using System;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public class Vector4ShaderProperty : VectorShaderProperty

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

 using System;
 using System.Text;
+using UnityEngine;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public abstract class VectorShaderProperty : AbstractShaderProperty<Vector4>

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/GenerationMode.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public enum GenerationMode
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IGenerateProperties.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IGenerateProperties
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IGeneratesBodyCode.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IGeneratesBodyCode
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IGeneratesFunction.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IGeneratesFunction
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IMayRequireNormal.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IMayRequireNormal
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/IMayRequireTime.cs

-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public interface IMayRequireTime
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/MaterialGraphChange.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public class ShaderPropertyAdded : GraphChange
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Interfaces/NeededCoordinateSpace.cs

 using System;
 
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Flags]
     public enum NeededCoordinateSpace

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/AbstractLightweightMasterNode.cs

 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public abstract class AbstractLightweightMasterNode : MasterNode
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/AbstractLightweightPBRMasterNode.cs

 using System;
 using System.Linq;
 
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     public abstract class AbstractLightweightPBRMasterNode : AbstractLightweightMasterNode