Merge master

And fix conflicts

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

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 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 interface IGraph : IOnAssetEnabled
     {

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/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/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/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/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/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/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/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
             var result = base.GetLegacyTypeRemapping();
             var viewNode = new SerializationHelper.TypeSerializationInfo
             {
-                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
 {
     public interface IMaterialSlotHasVaule<T>
     {
 
         [SerializeField]
         private Vector2 m_DefaultValue;
-        
+
         public Vector2MaterialSlot()
         {
         }
 
         [SerializeField]
         private Vector3 m_DefaultValue;
-        
+
         public Vector3MaterialSlot()
         {
         }
             :base(slotId, displayName, shaderOutputName, slotType, shaderStage, hidden)
         {
         }
-        
+
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
             return precision + "2x2 (1,0,0,1)";
 
         protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
         {
-            return precision + "4 (" + value.x + "," + value.y + "," + value.z + "," + value.w + ")"; 
+            return precision + "4 (" + value.x + "," + value.y + "," + value.z + "," + value.w + ")";
         }
     }
 
         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

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

 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
 /*    [Serializable]
     [Title("Master/Lightweight/Fast Blinn")]

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

 using System;
 using System.Collections.Generic;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     [Title("Master/Lightweight/PBR Metallic")]

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

 using System;
 using System.Collections.Generic;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     [Title("Master/Lightweight/PBR Specular")]

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

 using System;
 using System.Collections.Generic;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Serializable]
     [Title("Master/Lightweight/Unlit")]

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

 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     public static class GuidEncoder
     {

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Art/Adjustments/ContrastNode.cs

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Art/Adjustments/HueNode.cs

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Art/Adjustments/LevelsNode.cs

-using UnityEngine.Graphing;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Art/Adjustments/Levels")]
     public class LevelsNode : CodeFunctionNode

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Art/Adjustments/SaturationNode.cs

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Art/Conversion/HSVtoRGBNode.cs

 using System.Reflection;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Art/Conversion/HSVtoRGB")]
     public class HSVtoRGBNode : CodeFunctionNode

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Art/Conversion/LinearToRGBNode.cs

 using System.Reflection;
-using UnityEngine.Graphing;
+using UnityEngine;
+using UnityEditor.Graphing;
-namespace UnityEngine.MaterialGraph
+namespace UnityEditor.ShaderGraph
 {
     [Title("Art/Conversion/LineartoRGB")]
     public class LineartoRGBNode : CodeFunctionNode