[Material Graph] split into runtime vs editor. Create UI delegation to handle node drawing nicely.

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/DrawableNode.cs

+using System.Collections.Generic;
+using UnityEngine.Graphing;
+using UnityEngine.MaterialGraph;
-    public sealed class DrawableNode : CanvasElement
+    public interface ICustomNodeUi
-        protected int previewWidth
-        {
-            get { return kPreviewWidth; }
-        }
+        int GetNodeUiHeight(int width);
+        GUIModificationType Render(Rect area);
+    }
-        protected int previewHeight
-        {
-            get { return kPreviewHeight; }
-        }
-        public delegate void NeedsRepaint();
-        public NeedsRepaint onNeedsRepaint;
-
-        private const int kPreviewWidth = 64;
-        private const int kPreviewHeight = 64;
-
+    public class DrawableNode : CanvasElement
+    {
-        public INode m_Node;
-        private Rect m_PreviewArea;
-        private Rect m_NodeUIRect;
+        private readonly Rect m_CustomUiRect;
+        public readonly INode m_Node;
+        private readonly ICustomNodeUi m_Ui;
-        public DrawableNode(INode node, float width, GraphDataSource data)
+        public DrawableNode(INode node, ICustomNodeUi ui, GraphDataSource data)
+            const int width = 200;
+            m_Ui = ui;
-            //m_Node.onNeedsRepaint += Invalidate;
 
             const float yStart = 10.0f;
             var vector3 = new Vector3(5.0f, yStart, 0.0f);
 
             pos.y = Mathf.Max(pos.y, inputYMax);
 
-            /*
-            var nodeUIHeight = m_Node.GetNodeUIHeight(width);
-            m_NodeUIRect = new Rect(10, pos.y, width - 20, nodeUIHeight);
-            pos.y += nodeUIHeight;
+            if (ui != null)
+            {
+                var customUiHeight = ui.GetNodeUiHeight(width);
+                m_CustomUiRect = new Rect(10, pos.y, width - 20, customUiHeight);
+                pos.y += customUiHeight;
+            }
+            /*
             if (node.hasPreview && node.drawMode != DrawMode.Collapsed)
             {
                 m_PreviewArea = new Rect(10, pos.y, width - 20, width - 20);
             scale = new Vector3(pos.x, pos.y + 10.0f, 0.0f);
-            //OnWidget += MarkDirtyIfNeedsTime;
+
+            OnWidget += MarkDirtyIfNeedsTime;
-
-        /*
+        
         private bool MarkDirtyIfNeedsTime(CanvasElement element, Event e, Canvas2D parent)
         {
             var childrenNodes = ListPool<INode>.Get();
             ListPool<INode>.Release(childrenNodes);
             return true;
-        }*/
+        }
 
         public override void UpdateModel(UpdateType t)
         {
                 return;
             }
 
-            /*var modificationType = m_Node.NodeUI(m_NodeUIRect);
-            if (modificationType == GUIModificationType.Repaint)
+            if (m_Ui != null)
-                // if we were changed, we need to redraw all the
-                // dependent nodes.
-                RepaintDependentNodes(m_Node);
-            }
-            else if (modificationType == GUIModificationType.ModelChanged)
-            {
-                ParentCanvas().ReloadData();
-                ParentCanvas().Repaint();
-                return;
+                var modificationType = m_Ui.Render(m_CustomUiRect);
+                if (modificationType == GUIModificationType.Repaint)
+                {
+                    // if we were changed, we need to redraw all the
+                    // dependent nodes.
+                    RepaintDependentNodes(m_Node);
+                }
+                else if (modificationType == GUIModificationType.ModelChanged)
+                {
+                    ParentCanvas().ReloadData();
+                    ParentCanvas().Repaint();
+                    return;
+                }
-            if (m_Node.hasPreview
+            /*  if (m_Node.hasPreview
                 && m_Node.drawMode != DrawMode.Collapsed
                 && m_PreviewArea.width > 0
                 && m_PreviewArea.height > 0)
 
             base.Render(parentRect, canvas);
         }
-
-        /*
-        public static void RepaintDependentNodes(AbstractMaterialNode bmn)
+        
+        private void RepaintDependentNodes(INode theNode)
-            NodeUtils.CollectNodesNodeFeedsInto(dependentNodes, bmn);
-            foreach (var node in dependentNodes.OfType<SerializableNode>())
-                node.onNeedsRepaint();
+            NodeUtils.CollectNodesNodeFeedsInto(dependentNodes, theNode);
+            foreach (var node in dependentNodes)
+            {
+                foreach (var drawableNode in m_Data.lastGeneratedNodes.Where(x => x.m_Node == node))
+                    drawableNode.Invalidate();
+            }
+        /*
         public static void OnGUI(List<CanvasElement> selection)
         {
             var drawableMaterialNode = selection.OfType<DrawableMaterialNode>().FirstOrDefault();
                 // dependent nodes.
                 RepaintDependentNodes(drawableMaterialNode.m_Node);
             }
+        }*/
+
+       /* public virtual GUIModificationType NodeUI(Rect drawArea)
+        {
+            return GUIModificationType.None;
+        }
+
+        public virtual bool OnGUI()
+        {
+            GUILayout.Label("MaterialSlot Defaults", EditorStyles.boldLabel);
+            var modified = false;
+            foreach (var slot in inputSlots)
+            {
+                if (!owner.GetEdges(GetSlotReference(slot.name)).Any())
+                    modified |= DoSlotUI(this, slot);
+            }
+
+            return modified;
+        }
+
+        public static bool DoSlotUI(SerializableNode node, ISlot slot)
+        {
+            GUILayout.BeginHorizontal( /*EditorStyles.inspectorBig*);
+            GUILayout.BeginVertical();
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("MaterialSlot " + slot.name, EditorStyles.largeLabel);
+            GUILayout.FlexibleSpace();
+            GUILayout.EndHorizontal();
+            GUILayout.EndVertical();
+            GUILayout.EndHorizontal();
+
+            //TODO: fix this
+            return false;
+            //return slot.OnGUI();
         }*/
     }
 }

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/GraphDataSource.cs

 using UnityEditor.Experimental;
 using UnityEditor.Experimental.Graph;
 using UnityEngine;
+using UnityEngine.Graphing;
 
 namespace UnityEditor.Graphing.Drawing
 {
             foreach (var node in graph.nodes)
             {
                 // add the nodes
-                m_DrawableNodes.Add(new DrawableNode(node, 200.0f, this));
+                m_DrawableNodes.Add(new DrawableNode(node, null, this));
             }
 
             // Add the edges now

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/GraphEditWindow.cs

 using UnityEditor.Experimental;
 using UnityEditor.MaterialGraph;
 using UnityEngine;
+using UnityEngine.Graphing;
+using UnityEngine.MaterialGraph;
 using Object = UnityEngine.Object;
 
 namespace UnityEditor.Graphing.Drawing
             drawstate.position = new Rect(posObj.m_Pos.x, posObj.m_Pos.y, drawstate.position.width, drawstate.position.height);
             node.drawState = drawstate;
             m_LastSelection.graph.AddNode(node);
-
+            EditorUtility.SetDirty(m_LastSelection);
             Rebuild();
             Repaint();
         }

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/NodeAnchor.cs

 using UnityEditor.Experimental;
 using UnityEditor.Experimental.Graph;
 using UnityEngine;
+using UnityEngine.Graphing;
 
 namespace UnityEditor.Graphing.Drawing
 {

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/NullInputProxy.cs

 using UnityEditor.Experimental;
 using UnityEngine;
+using UnityEngine.Graphing;
 
 namespace UnityEditor.Graphing.Drawing
 {

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Tests/SerializedGraphTests.cs

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

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

 using System.IO;
 using UnityEditor.ProjectWindowCallback;
+using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph
 {

UnityProject/Assets/UnityShaderEditor/Editor/Editors/MaterialGraphEditor.cs

 using UnityEditorInternal;
 using UnityEngine;
+using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph
 {

UnityProject/Assets/UnityShaderEditor/Editor/Testing/ShaderGeneration/ShaderGenerationTest.cs

 using System.Linq;
 using NUnit.Framework;
 using UnityEngine;
+using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph.Tests
 {

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

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

UnityProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/MaterialGraphTests.cs

 using System.Linq;
 using NUnit.Framework;
-using UnityEditor.Graphing;
+using UnityEngine.Graphing;
+using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph.Tests
 {
         [Test]
         public void TestCreateMaterialGraph()
         {
-            MaterialGraph graph = new MaterialGraph();
+            UnityEngine.MaterialGraph.MaterialGraph graph = new UnityEngine.MaterialGraph.MaterialGraph();
 
             Assert.IsNotNull(graph.currentGraph);
             Assert.IsNotNull(graph.materialOptions);

UnityProject/ProjectSettings/GraphicsSettings.asset

 --- !u!30 &1
 GraphicsSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 6
+  serializedVersion: 7
   m_Deferred:
     m_Mode: 1
     m_Shader: {fileID: 69, guid: 0000000000000000f000000000000000, type: 0}
   m_LegacyDeferred:
     m_Mode: 1
     m_Shader: {fileID: 63, guid: 0000000000000000f000000000000000, type: 0}
+  m_DepthNormals:
+    m_Mode: 1
+    m_Shader: {fileID: 62, guid: 0000000000000000f000000000000000, type: 0}
+  m_MotionVectors:
+    m_Mode: 1
+    m_Shader: {fileID: 75, guid: 0000000000000000f000000000000000, type: 0}
+  m_LightHalo:
+    m_Mode: 1
+    m_Shader: {fileID: 105, guid: 0000000000000000f000000000000000, type: 0}
+  m_LensFlare:
+    m_Mode: 1
+    m_Shader: {fileID: 102, guid: 0000000000000000f000000000000000, type: 0}
   m_AlwaysIncludedShaders:
   - {fileID: 7, guid: 0000000000000000f000000000000000, type: 0}
   - {fileID: 15104, guid: 0000000000000000f000000000000000, type: 0}
   m_PreloadedShaders: []
   m_ShaderSettings_Tier1:
     useCascadedShadowMaps: 1
+    useSinglePassStereoRendering: 0
+    useSinglePassStereoRendering: 0
-    standardShaderQuality: 2
-    useReflectionProbeBoxProjection: 1
-    useReflectionProbeBlending: 1
-  m_ShaderSettings_Tier4:
-    useCascadedShadowMaps: 1
+    useSinglePassStereoRendering: 0
     standardShaderQuality: 2
     useReflectionProbeBoxProjection: 1
     useReflectionProbeBlending: 1

UnityProject/ProjectSettings/ProjectSettings.asset

   productName: Graphs
   defaultCursor: {fileID: 0}
   cursorHotspot: {x: 0, y: 0}
+  m_SplashScreenStyle: 0
   m_ShowUnitySplashScreen: 1
   m_VirtualRealitySplashScreen: {fileID: 0}
   defaultScreenWidth: 1024
   m_ActiveColorSpace: 1
   m_MTRendering: 1
   m_MobileMTRendering: 0
-  m_Stereoscopic3D: 0
+  m_StackTraceTypes: 010000000100000001000000010000000100000001000000
   iosShowActivityIndicatorOnLoading: -1
   androidShowActivityIndicatorOnLoading: -1
   iosAppInBackgroundBehavior: 0
   resizableWindow: 0
   useMacAppStoreValidation: 0
   gpuSkinning: 0
+  graphicsJobs: 0
   xboxPIXTextureCapture: 0
   xboxEnableAvatar: 0
   xboxEnableKinect: 0
   xboxSpeechDB: 0
   xboxEnableHeadOrientation: 0
   xboxEnableGuest: 0
+  xboxEnablePIXSampling: 0
+  ignoreAlphaClear: 0
   xboxOneResolution: 0
   ps3SplashScreen: {fileID: 0}
   videoMemoryForVertexBuffers: 0
   bundleVersion: 1.0
   preloadedAssets: []
   metroEnableIndependentInputSource: 0
-  metroEnableLowLatencyPresentationAPI: 0
-  virtualRealitySupported: 0
+  singlePassStereoRendering: 0
+  protectGraphicsMemory: 0
   productGUID: 4a61ffcca1e65d342aac47392d65ac32
   AndroidBundleVersionCode: 1
   AndroidMinSdkVersion: 9
     m_Bits: 238
   iPhoneSdkVersion: 988
   iPhoneTargetOSVersion: 22
+  tvOSSdkVersion: 0
+  tvOSTargetOSVersion: 900
   uIPrerenderedIcon: 0
   uIRequiresPersistentWiFi: 0
   uIRequiresFullScreen: 1
   iPadLandscapeSplashScreen: {fileID: 0}
   iPadHighResLandscapeSplashScreen: {fileID: 0}
   appleTVSplashScreen: {fileID: 0}
+  tvOSSmallIconLayers: []
+  tvOSLargeIconLayers: []
+  tvOSTopShelfImageLayers: []
   iOSLaunchScreenType: 0
   iOSLaunchScreenPortrait: {fileID: 0}
   iOSLaunchScreenLandscape: {fileID: 0}
   iOSLaunchScreeniPadSize: 100
   iOSLaunchScreeniPadCustomXibPath: 
   iOSDeviceRequirements: []
+  iOSURLSchemes: []
   AndroidTargetDevice: 0
   AndroidSplashScreenScale: 0
   androidSplashScreen: {fileID: 0}
   ps4DownloadDataSize: 0
   ps4GarlicHeapSize: 2048
   ps4Passcode: eaoEiIgxIX4a2dREbbSqWy6yhKIDCdJO
+  ps4UseDebugIl2cppLibs: 0
   ps4pnSessions: 1
   ps4pnPresence: 1
   ps4pnFriends: 1
   ps4UseAudio3dBackend: 0
+  ps4SocialScreenEnabled: 0
+  ps4attribCpuUsage: 0
   ps4PatchPkgPath: 
   ps4PatchLatestPkgPath: 
   ps4PatchChangeinfoPath: 
   ps4attribShareSupport: 0
+  ps4disableAutoHideSplash: 0
   ps4IncludedModules: []
   monoEnv: 
   psp2Splashimage: {fileID: 0}
   psp2UseLibLocation: 0
   psp2InfoBarOnStartup: 0
   psp2InfoBarColor: 0
+  psp2UseDebugIl2cppLibs: 0
   psmSplashimage: {fileID: 0}
   spritePackerPolicy: 
   scriptingDefineSymbols: {}
   metroFTAFileTypes: []
   metroProtocolName: 
   metroCompilationOverrides: 1
-  blackberryDeviceAddress: 
-  blackberryDevicePassword: 
-  blackberryTokenPath: 
-  blackberryTokenExires: 
-  blackberryTokenAuthor: 
-  blackberryTokenAuthorId: 
-  blackberryCskPassword: 
-  blackberrySaveLogPath: 
-  blackberrySharedPermissions: 0
-  blackberryCameraPermissions: 0
-  blackberryGPSPermissions: 0
-  blackberryDeviceIDPermissions: 0
-  blackberryMicrophonePermissions: 0
-  blackberryGamepadSupport: 0
-  blackberryBuildId: 0
-  blackberryLandscapeSplashScreen: {fileID: 0}
-  blackberryPortraitSplashScreen: {fileID: 0}
-  blackberrySquareSplashScreen: {fileID: 0}
   tizenProductDescription: 
   tizenProductURL: 
   tizenSigningProfileName: 
   - Standalone::ScriptingBackend
   Android::ScriptingBackend: 0
   Standalone::ScriptingBackend: 0
-  boolPropertyNames: []
-  stringPropertyNames: []
+  boolPropertyNames:
+  - Android::VR::enable
+  - Metro::VR::enable
+  - N3DS::VR::enable
+  - PS3::VR::enable
+  - PS4::VR::enable
+  - PSM::VR::enable
+  - PSP2::VR::enable
+  - SamsungTV::VR::enable
+  - Standalone::VR::enable
+  - Tizen::VR::enable
+  - WebGL::VR::enable
+  - WebPlayer::VR::enable
+  - WiiU::VR::enable
+  - Xbox360::VR::enable
+  - XboxOne::VR::enable
+  - iOS::VR::enable
+  - tvOS::VR::enable
+  Android::VR::enable: 0
+  Metro::VR::enable: 0
+  N3DS::VR::enable: 0
+  PS3::VR::enable: 0
+  PS4::VR::enable: 0
+  PSM::VR::enable: 0
+  PSP2::VR::enable: 0
+  SamsungTV::VR::enable: 0
+  Standalone::VR::enable: 0
+  Tizen::VR::enable: 0
+  WebGL::VR::enable: 0
+  WebPlayer::VR::enable: 0
+  WiiU::VR::enable: 0
+  Xbox360::VR::enable: 0
+  XboxOne::VR::enable: 0
+  iOS::VR::enable: 0
+  tvOS::VR::enable: 0
+  stringPropertyNames:
+  - Analytics_ServiceEnabled::Analytics_ServiceEnabled
+  - Build_ServiceEnabled::Build_ServiceEnabled
+  - Collab_ServiceEnabled::Collab_ServiceEnabled
+  - ErrorHub_ServiceEnabled::ErrorHub_ServiceEnabled
+  - Game_Performance_ServiceEnabled::Game_Performance_ServiceEnabled
+  - Hub_ServiceEnabled::Hub_ServiceEnabled
+  - Purchasing_ServiceEnabled::Purchasing_ServiceEnabled
+  - UNet_ServiceEnabled::UNet_ServiceEnabled
+  - Unity_Ads_ServiceEnabled::Unity_Ads_ServiceEnabled
+  Analytics_ServiceEnabled::Analytics_ServiceEnabled: False
+  Build_ServiceEnabled::Build_ServiceEnabled: False
+  Collab_ServiceEnabled::Collab_ServiceEnabled: False
+  ErrorHub_ServiceEnabled::ErrorHub_ServiceEnabled: False
+  Game_Performance_ServiceEnabled::Game_Performance_ServiceEnabled: False
+  Hub_ServiceEnabled::Hub_ServiceEnabled: False
+  Purchasing_ServiceEnabled::Purchasing_ServiceEnabled: False
+  UNet_ServiceEnabled::UNet_ServiceEnabled: False
+  Unity_Ads_ServiceEnabled::Unity_Ads_ServiceEnabled: False
+  vectorPropertyNames:
+  - Android::VR::enabledDevices
+  - Metro::VR::enabledDevices
+  - N3DS::VR::enabledDevices
+  - PS3::VR::enabledDevices
+  - PS4::VR::enabledDevices
+  - PSM::VR::enabledDevices
+  - PSP2::VR::enabledDevices
+  - SamsungTV::VR::enabledDevices
+  - Standalone::VR::enabledDevices
+  - Tizen::VR::enabledDevices
+  - WebGL::VR::enabledDevices
+  - WebPlayer::VR::enabledDevices
+  - WiiU::VR::enabledDevices
+  - Xbox360::VR::enabledDevices
+  - XboxOne::VR::enabledDevices
+  - iOS::VR::enabledDevices
+  - tvOS::VR::enabledDevices
+  Android::VR::enabledDevices:
+  - Oculus
+  Metro::VR::enabledDevices:
+  - HoloLens
+  N3DS::VR::enabledDevices: []
+  PS3::VR::enabledDevices: []
+  PS4::VR::enabledDevices:
+  - PlayStationVR
+  PSM::VR::enabledDevices: []
+  PSP2::VR::enabledDevices: []
+  SamsungTV::VR::enabledDevices: []
+  Standalone::VR::enabledDevices:
+  - Oculus
+  Tizen::VR::enabledDevices: []
+  WebGL::VR::enabledDevices: []
+  WebPlayer::VR::enabledDevices: []
+  WiiU::VR::enabledDevices: []
+  Xbox360::VR::enabledDevices: []
+  XboxOne::VR::enabledDevices: []
+  iOS::VR::enabledDevices: []
+  tvOS::VR::enabledDevices: []
   cloudProjectId: 
   projectName: 
   organizationId: 

UnityProject/ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 5.4.0b3
+m_EditorVersion: 5.4.0b21
 m_StandardAssetsVersion: 0

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Util/ListPool.cs

 using System.Collections.Generic;
 
-namespace UnityEditor.Graphing
+namespace UnityEngine.Graphing
-    internal static class ListPool<T>
+    public static class ListPool<T>
     {
         // Object pool to avoid allocations.
         private static readonly ObjectPool<List<T>> s_ListPool = new ObjectPool<List<T>>(null, l => l.Clear());

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Util/ObjectPool.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Util/SerializationHelper.cs

 using System;
 using System.Collections.Generic;
-using UnityEngine;
-namespace UnityEditor.Graphing
+namespace UnityEngine.Graphing
 {
     public static class SerializationHelper
     {

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Implementation/Edge.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Implementation/NodeUtils.cs

 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine;
-namespace UnityEditor.Graphing
+namespace UnityEngine.Graphing
-    internal class NodeUtils
+    public class NodeUtils
     {
         // GetSlotsThatOutputToNodeRecurse returns a list of output slots on from node that
         // manage to connect to toNode... they may go via some other nodes to reach there.

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Implementation/SerializableGraph.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Implementation/SerializableNode.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine;
-namespace UnityEditor.Graphing
+namespace UnityEngine.Graphing
 {
     [Serializable]
     public class SerializableNode : INode, ISerializationCallbackReceiver
 
         public SerializableNode(IGraph theOwner)
         {
+            m_DrawData.expanded = true;
             owner = theOwner;
             m_Guid = Guid.NewGuid();
         }
         {
             return 0;
         }
-
-        public virtual GUIModificationType NodeUI(Rect drawArea)
-        {
-            return GUIModificationType.None;
-        }
-
-        public virtual bool OnGUI()
-        {
-            GUILayout.Label("MaterialSlot Defaults", EditorStyles.boldLabel);
-            var modified = false;
-            foreach (var slot in inputSlots)
-            {
-                if (!owner.GetEdges(GetSlotReference(slot.name)).Any())
-                    modified |= DoSlotUI(this, slot);
-            }
-
-            return modified;
-        }
-
-        public static bool DoSlotUI(SerializableNode node, ISlot slot)
-        {
-            GUILayout.BeginHorizontal( /*EditorStyles.inspectorBig*/);
-            GUILayout.BeginVertical();
-            GUILayout.BeginHorizontal();
-            GUILayout.Label("MaterialSlot " + slot.name, EditorStyles.largeLabel);
-            GUILayout.FlexibleSpace();
-            GUILayout.EndHorizontal();
-            GUILayout.EndVertical();
-            GUILayout.EndHorizontal();
-
-            //TODO: fix this
-            return false;
-            //return slot.OnGUI();
-        }
-
+        
         public virtual void OnBeforeSerialize()
         {
             m_GuidSerialized = m_Guid.ToString();

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Implementation/SerializableSlot.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Implementation/SlotType.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Interfaces/DrawingData.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Interfaces/IGraph.cs

 using System;
 using System.Collections.Generic;
 
-namespace UnityEditor.Graphing
+namespace UnityEngine.Graphing
 {
     public interface IGraph
     {

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Interfaces/INode.cs

 using System;
 using System.Collections.Generic;
-using UnityEngine;
-namespace UnityEditor.Graphing
+namespace UnityEngine.Graphing
 {
     public interface INode
     {

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Interfaces/ISlot.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Interfaces/SlotReference.cs

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

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Interfaces/IEdge.cs

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

UnityProject/Assets/UnityShaderEditor/Runtime/Util/ShaderGenerator.cs

 using System.IO;
 using System.Linq;
 using System.Text;
-using UnityEditor.Graphing;
-using UnityEngine;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     public enum TextureType
     {

UnityProject/Assets/UnityShaderEditor/Runtime/Interfaces/Interfaces.cs

-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     public interface IRequiresTime
     {

UnityProject/Assets/UnityShaderEditor/Runtime/Light/BaseLightFunction.cs

-using UnityEngine;
-using SlotType = UnityEditor.Graphing.SlotType;
-namespace UnityEditor.MaterialGraph
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
 {
     public abstract class BaseLightFunction
     {

UnityProject/Assets/UnityShaderEditor/Runtime/MaterialGraph.cs

 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using UnityEngine;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [Serializable]
     public class MaterialGraph
             get { return m_PixelGraph; }
         }
 
+        /*
         public Material GetMaterial()
         {
             if (m_PixelGraph == null)
             shaderImporter.SetNonModifiableTextures(textureNames.ToArray(), textures.ToArray());
 
             shaderImporter.SaveAndReimport();
-        }
+        }*/
 
         public void PostCreate()
         {

UnityProject/Assets/UnityShaderEditor/Runtime/MaterialGraphAsset.cs

-using UnityEngine;
-
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     public class MaterialGraphAsset : ScriptableObject
     {

UnityProject/Assets/UnityShaderEditor/Runtime/MaterialOptions.cs

 using System;
 using UnityEngine;
 
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [Serializable]
     public class MaterialOptions
             visitor.AddShaderChunk("ZTest " + zTest, false);
         }
 
-        private Vector2 m_ScrollPos;
+        /*private Vector2 m_ScrollPos;
         public void DoGUI()
         {
             GUILayout.BeginVertical();
                 renderType = (RenderType) EditorGUILayout.EnumPopup("Render Type", renderType);
             }
             GUILayout.EndVertical();
-        }
+        }*/
 
         public BlendMode srcBlend { get { return m_SrcBlend; } set { m_SrcBlend = value; } }
         public BlendMode dstBlend { get { return m_DstBlend; } set { m_DstBlend = value; } }

UnityProject/Assets/UnityShaderEditor/Runtime/PixelGraph.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEditor.Graphing;
-using UnityEngine;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [Serializable]
     public class PixelGraph : AbstractMaterialGraph
 
             pixelMasterNode.GenerateNodeCode(shaderBody, genMode);
         }
-
+        /*
         public Material GetMaterial()
         {
             if (pixelMasterNode == null)
             AbstractMaterialNode.UpdateMaterialProperties(pixelMasterNode, material);
             return material;
-        }
+        }*/
     }
 }

UnityProject/Assets/UnityShaderEditor/Runtime/TitleAttribute.cs

 using System;
 
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Method | AttributeTargets.Class | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
     public class TitleAttribute : Attribute

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/AbstractMaterialNode.cs

 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using UnityEditor.Graphing;
-using UnityEditorInternal;
-using UnityEngine;
-using Object = UnityEngine.Object;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
-        private static readonly Mesh[] s_Meshes = {null, null, null, null};
+        /*private static readonly Mesh[] s_Meshes = {null, null, null, null};
-        protected PreviewMode m_GeneratedShaderMode = PreviewMode.Preview2D;
+        protected PreviewMode m_GeneratedShaderMode = PreviewMode.Preview2D;*/
-        [SerializeField]
+        /*[SerializeField]
         private string m_LastShader; 
 
         [NonSerialized]
-        private Shader m_PreviewShader;
+        private Shader m_PreviewShader;*/
 
         public AbstractMaterialGraph materialGraphOwner
         {
             get { return true; }
         }
 
-        public Material previewMaterial
+/*        public Material previewMaterial
         {
             get
             {
                 return m_PreviewMaterial;
             }
         }
-
+        */
         public bool hasError
         {
             get { return m_HasError; }
             }
         }
 
+        /*
         public virtual bool DrawSlotDefaultInput(Rect rect, MaterialSlot inputSlot)
         {
             var inputSlotType = inputSlot.concreteValueType;
             }
 
             return !ShaderHasError(m_PreviewShader);
-        }
+        }*/
-        /// <summary>
+     /*   /// <summary>
         ///     RenderPreview gets called in OnPreviewGUI. Nodes can override
         ///     RenderPreview and do their own rendering to the render texture
         /// </summary>
                 Graphics.Blit(null, previewMaterial);
             }
             return previewUtil.EndPreview();
-        }
+        }*/
 
         private static void SetPreviewMaterialProperty(PreviewProperty previewProperty, Material mat)
         {
             ListPool<PreviewProperty>.Release(pList);
         }
 
-        public void UpdatePreviewProperties()
+       /* public void UpdatePreviewProperties()
-        }
+        }*/
 
         public virtual string GetOutputVariableNameForSlot(MaterialSlot s, GenerationMode generationMode)
         {

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/AddNode.cs

-using UnityEditor.Graphing;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [Title("Math/Add Node")]
     public class AddNode : Function2Input, IGeneratesFunction
             visitor.AddShaderChunk(outputString.GetShaderString(0), true);
         }
 
+        /*
-        }
+        }*/
     }
 }

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/Function2Input.cs

-using UnityEditor.Graphing;
-using UnityEngine;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     public abstract class Function2Input : AbstractMaterialNode, IGeneratesBodyCode
     {

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/MaterialSlot.cs

 using System;
-using UnityEditor.Graphing;
-using UnityEngine;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [Serializable]
     public class MaterialSlot : SerializableSlot
                     return "error";
             }
         }
-
+        /*
         public override bool OnGUI()
         {
             EditorGUI.BeginChangeCheck();
                     break;
             }
             return EditorGUI.EndChangeCheck();
-        }
+        }*/
     }
 }

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/PixelShaderNode.cs

 using System;
-using UnityEngine;
-using UnityEditor.Graphing;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [Serializable]
     public class PixelShaderNode : AbstractMaterialNode, IGeneratesBodyCode
             return GetOutputVariableNameForNode();
         }
 
-        public override float GetNodeUIHeight(float width)
+   /*     public override float GetNodeUIHeight(float width)
         {
             return EditorGUIUtility.singleLineHeight;
         }
                 return GUIModificationType.ModelChanged;
             }
             return GUIModificationType.None;
-        }
+        }*/
 
         public override IEnumerable<ISlot> GetInputsWithNoConnection()
         {
             get { return true; }
         }
 
+
+        /*
         protected override bool UpdatePreviewShader()
         {
             if (hasError)
             m_GeneratedShaderMode = PreviewMode.Preview3D;
             hasError = !InternalUpdatePreviewShader(resultShader);
             return true;
-        }
+        }*/
     }
 }

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/PropertyNode.cs

 using System.Collections.Generic;
 using System.Linq;
-using UnityEditor.Graphing;
-using UnityEngine;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     public abstract class PropertyNode : AbstractMaterialNode
     {
             return propertyName;
         }
         
-        public override float GetNodeUIHeight(float width)
-        {
-            return 2 * EditorGUIUtility.singleLineHeight;
-        }
-
         protected override void CollectPreviewMaterialProperties (List<PreviewProperty> properties)
         {
             base.CollectPreviewMaterialProperties(properties);
             return false;
         }
 
+        /*
+        public override float GetNodeUIHeight(float width)
+        {
+            return 2 * EditorGUIUtility.singleLineHeight;
+        }
+
         public override bool OnGUI()
         {
             EditorGUI.BeginChangeCheck();
             
             modified |= base.OnGUI();
             return modified;
-        }
+        }*/
     }
 }

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/PropertyType.cs

-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     public enum PropertyType
     {

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/SlotValue.cs

 using System;
-using UnityEditor.Graphs;
-using UnityEngine;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     /*  public static class SlotExtensions
         {

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/Precision.cs

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

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/PreviewMode.cs

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

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/PreviewProperty.cs

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

UnityProject/Assets/UnityShaderEditor/Runtime/Nodes/Vector4Node.cs

-using UnityEditor.Graphing;
-using UnityEngine;
+using UnityEngine.Graphing;
-namespace UnityEditor.MaterialGraph
+namespace UnityEngine.MaterialGraph
 {
     [Title("Input/Vector 4 Node")]
     class Vector4Node : PropertyNode, IGeneratesBodyCode
             visitor.AddShaderChunk(precision + "4 " +  propertyName + " = " + precision + "4 (" + m_Value.x + ", " + m_Value.y + ", " + m_Value.z + ", " + m_Value.w + ");", true);
         }
 
-        public override GUIModificationType NodeUI(Rect drawArea)
-        {
-            base.NodeUI(drawArea);
-
-            EditorGUI.BeginChangeCheck();
-            m_Value = EditorGUI.Vector4Field(new Rect(drawArea.x, drawArea.y, drawArea.width, EditorGUIUtility.singleLineHeight), "Value", m_Value);
-            if (EditorGUI.EndChangeCheck())
-            {
-                //TODO:tidy this shit.
-                //EditorUtility.SetDirty(materialGraphOwner.owner);
-                return GUIModificationType.Repaint;
-            }
-            return GUIModificationType.None;
-        }
-
         public override PreviewProperty GetPreviewProperty()
         {
             return new PreviewProperty
             base.OnAfterDeserialize();
             UpdateSlots(); 
         }
+
+
+        /*
+ public override GUIModificationType NodeUI(Rect drawArea)
+ {
+     base.NodeUI(drawArea);
+
+     EditorGUI.BeginChangeCheck();
+     m_Value = EditorGUI.Vector4Field(new Rect(drawArea.x, drawArea.y, drawArea.width, EditorGUIUtility.singleLineHeight), "Value", m_Value);
+     if (EditorGUI.EndChangeCheck())
+     {
+         //TODO:tidy this shit.
+         //EditorUtility.SetDirty(materialGraphOwner.owner);
+         return GUIModificationType.Repaint;
+     }
+     return GUIModificationType.None;
+ }
+ */
     }
 }

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Util/CreateSerializableGraph.cs

+using System.IO;
+using UnityEditor.ProjectWindowCallback;
+using UnityEngine.Graphing;
+
+namespace UnityEditor.Graphing
+{
+    public class CreateSerializableGraph : EndNameEditAction
+    {
+        [MenuItem("Assets/Create/Serializable Graph", false, 207)]
+        public static void CreateMaterialGraph()
+        {
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance<CreateSerializableGraph>(),
+                "New Shader Graph.ShaderGraph", null, null);
+        }
+
+        public override void Action(int instanceId, string pathName, string resourceFile)
+        {
+            var graph = CreateInstance<SerializableGraphAsset>();
+            graph.name = Path.GetFileName(pathName);
+            AssetDatabase.CreateAsset(graph, pathName);
+        }
+    }
+}

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Util/CreateSerializableGraph.cs.meta

+fileFormatVersion: 2
+guid: 2a64b792c8859f74281b897c2a1d659c
+timeCreated: 1464601236
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime.meta

+fileFormatVersion: 2
+guid: 96b491f66dc38674cb2874ef6c452b3d
+folderAsset: yes
+timeCreated: 1464601235
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Runtime.meta

+fileFormatVersion: 2
+guid: c196fa3d7b5ae4049afeb1cd0400d9b6
+folderAsset: yes
+timeCreated: 1464601235
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Assets.meta

+fileFormatVersion: 2
+guid: 450f53852bcbf1e4097fcf172f93bc15
+folderAsset: yes
+timeCreated: 1464601235
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Assets/SerializableGraphAsset.cs

+namespace UnityEngine.Graphing
+{
+    public class SerializableGraphAsset : ScriptableObject
+    {
+        [SerializeField]
+        private SerializableGraph m_Graph = new SerializableGraph();
+        
+        public SerializableGraph graph
+        {
+            get { return m_Graph; }
+        }
+    }
+}

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Util.meta

+fileFormatVersion: 2
+guid: e0658374597bb894cbc93094fd0b1e46
+folderAsset: yes
+timeCreated: 1464264920
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GraphFramework/SerializableGraph/Runtime/Util/Logging.cs

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

UnityProject/Assets/UnityShaderEditor/Runtime/AbstractMaterialGraph.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public abstract class AbstractMaterialGraph : SerializableGraph
+    {
+        
+        public IEnumerable<AbstractMaterialNode> materialNodes
+        {
+            get { return nodes.OfType<AbstractMaterialNode>(); }
+        }
+
+        public bool requiresRepaint
+        {
+            get { return nodes.Any(x => x is IRequiresTime); }
+        }
+         
+        public override void AddNode(INode node)
+        {
+            if (node is AbstractMaterialNode)
+            {
+                base.AddNode(node);
+            }
+            else
+            {
+                Debug.LogWarningFormat("Trying to add node {0} to Material graph, but it is not a {1}", node, typeof(AbstractMaterialNode));
+            }
+        }
+
+        public AbstractMaterialNode GetMaterialNodeFromGuid(Guid guid)
+        {
+            var node = GetNodeFromGuid(guid);
+            if (node == null)
+            {
+                Debug.LogWarningFormat("Node with guid {0} either can not be found", guid);
+                return null;
+            }
+            if (node is AbstractMaterialNode)
+                return node as AbstractMaterialNode;
+
+            Debug.LogWarningFormat("Node {0} with guid {1} is not a Material node", guid);
+            return null;
+        }
+        
+        public override void ValidateGraph()
+        {
+            base.ValidateGraph();
+
+            foreach (var node in materialNodes)
+                node.ValidateNode();
+        }
+
+        /*public PreviewRenderUtility previewUtility
+        {
+            get
+            {
+                if (m_PreviewUtility == null)
+                {
+                    m_PreviewUtility = new PreviewRenderUtility();
+                    EditorUtility.SetCameraAnimateMaterials(m_PreviewUtility.m_Camera, true);
+                }
+
+                return m_PreviewUtility;
+            }
+        }
+
+        [NonSerialized]
+        private PreviewRenderUtility m_PreviewUtility;*/
+    }
+}

UnityProject/Assets/UnityShaderEditor/Runtime/AbstractMaterialGraph.cs.meta

+fileFormatVersion: 2
+guid: 2b0e8711e6be02b46b0f59cdc792d962
+timeCreated: 1464601236
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Runtime/MaterialGraph.cs.meta

+fileFormatVersion: 2
+guid: fb1baf5d764fd6543ae40a4772ed0299
+timeCreated: 1464601237
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Runtime/MaterialGraphAsset.cs.meta

+fileFormatVersion: 2
+guid: 562bd27a5e73fc64d80a1d9d936ffbd5
+timeCreated: 1464601236
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Runtime/MaterialOptions.cs.meta

+fileFormatVersion: 2
+guid: 8ca34891049f83b43ba622e89782529d
+timeCreated: 1464601236
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Runtime/PixelGraph.cs.meta

+fileFormatVersion: 2
+guid: 2d360593fcc8fe74495305ba643d8770
+timeCreated: 1464601236
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Runtime/TitleAttribute.cs.meta

+fileFormatVersion: 2
+guid: 5c804f35a96ccb9408f04f818773a159
+timeCreated: 1464601236
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

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

UnityProject/Assets/GraphFramework/SerializableGraph/Editor/Assets.meta

-fileFormatVersion: 2
-guid: fbce0c0b81b61ca4cb27684a4abb3fd1
-folderAsset: yes
-timeCreated: 1464265232
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

UnityProject/Assets/UnityShaderEditor/Editor/AbstractMaterialGraph.cs

-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityEditor.Graphing;
-using UnityEngine;
-
-namespace UnityEditor.MaterialGraph
-{
-    [Serializable]
-    public abstract class AbstractMaterialGraph : Graphing.SerializableGraph
-    {
-        [NonSerialized]
-        private PreviewRenderUtility m_PreviewUtility;
-        
-        public IEnumerable<AbstractMaterialNode> materialNodes
-        {
-            get { return nodes.OfType<AbstractMaterialNode>(); }
-        }
-
-        public PreviewRenderUtility previewUtility
-        {
-            get
-            {
-                if (m_PreviewUtility == null)
-                {
-                    m_PreviewUtility = new PreviewRenderUtility();
-                    EditorUtility.SetCameraAnimateMaterials(m_PreviewUtility.m_Camera, true);
-                }
-
-                return m_PreviewUtility;
-            }
-        }
-
-        public bool requiresRepaint
-        {
-            get { return nodes.Any(x => x is IRequiresTime); }
-        }
-         
-        public override void AddNode(INode node)
-        {
-            if (node is AbstractMaterialNode)
-            {
-                base.AddNode(node);
-            }
-            else
-            {
-                Debug.LogWarningFormat("Trying to add node {0} to Material graph, but it is not a {1}", node, typeof(AbstractMaterialNode));
-            }
-        }
-
-        public AbstractMaterialNode GetMaterialNodeFromGuid(Guid guid)
-        {
-            var node = GetNodeFromGuid(guid);
-            if (node == null)
-            {
-                Debug.LogWarningFormat("Node with guid {0} either can not be found", guid);
-                return null;
-            }
-            if (node is AbstractMaterialNode)
-                return node as AbstractMaterialNode;
-
-            Debug.LogWarningFormat("Node {0} with guid {1} is not a Material node", guid);
-            return null;
-        }
-        
-        public override void ValidateGraph()
-        {
-            base.ValidateGraph();
-
-            foreach (var node in materialNodes)
-                node.ValidateNode();
-        }
-    }
-}

UnityProject/Assets/UnityShaderEditor/Editor/AbstractMaterialGraph.cs.meta

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

UnityProject/Assets/UnityShaderEditor/Editor/MaterialGraph.cs.meta

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

UnityProject/Assets/UnityShaderEditor/Editor/MaterialGraphAsset.cs.meta

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

UnityProject/Assets/UnityShaderEditor/Editor/MaterialOptions.cs.meta

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

UnityProject/Assets/UnityShaderEditor/Editor/PixelGraph.cs.meta

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

UnityProject/Assets/UnityShaderEditor/Editor/TitleAttribute.cs.meta

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