[Material Graph] Sub graph / subgraph input nodes are can be added now, need to work on slots still

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

 
         public static string GeneratePreviewShader(AbstractMaterialNode node, out PreviewMode generatedShaderMode)
         {
+            if (!node.materialOuputSlots.Any())
+            {
+                generatedShaderMode = PreviewMode.Preview2D;
+                return string.Empty;
+            }
+
             // figure out what kind of preview we want!
             var activeNodeList = ListPool<INode>.Get();
             NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, node);

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs.meta

+fileFormatVersion: 2
+guid: 706886b5adec4e3409ceb9a30e04440e
+folderAsset: yes
+timeCreated: 1465559218
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/TitleAttribute.cs

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/TitleAttribute.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph.meta

+fileFormatVersion: 2
+guid: 7e981d45b83422d4aa5407e9fe5c7ab5
+folderAsset: yes
+timeCreated: 1465559218
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/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 override bool RequiresConstantRepaint()
+        {
+            return nodes.OfType<IRequiresTime>().Any();
+        }
+
+        /*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;*/
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/AbstractMaterialGraph.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/IMaterialGraphAsset.cs

+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public interface IMaterialGraphAsset : IGraphAsset
+    {
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/IMaterialGraphAsset.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/MaterialGraph.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class MaterialGraph
+    {
+        [SerializeField]
+        private MaterialOptions m_MaterialOptions = new MaterialOptions();
+
+        [SerializeField]
+        private PixelGraph m_PixelGraph;
+
+        [SerializeField]
+        private string m_Name;
+ 
+        public string name
+        {
+            get { return m_Name; }
+            set { m_Name = value; }
+        }
+
+        public MaterialGraph()
+        {
+            m_PixelGraph = new PixelGraph();
+        }
+
+        public MaterialOptions materialOptions
+        {
+            get { return m_MaterialOptions; }
+        }
+
+        public AbstractMaterialGraph currentGraph
+        {
+            get { return m_PixelGraph; }
+        }
+
+        /*
+        public Material GetMaterial()
+        {
+            if (m_PixelGraph == null)
+                return null;
+
+            return m_PixelGraph.GetMaterial();
+        }
+
+        public void ExportShader(string path)
+        {
+            List<PropertyGenerator.TextureInfo> configuredTextures;
+            var shaderString = ShaderGenerator.GenerateSurfaceShader(this, name, false, out configuredTextures);
+            File.WriteAllText(path, shaderString);
+            AssetDatabase.Refresh(); // Investigate if this is optimal
+
+            var shader = AssetDatabase.LoadAssetAtPath(path, typeof(Shader)) as Shader;
+            if (shader == null)
+                return;
+
+            var shaderImporter = AssetImporter.GetAtPath(path) as ShaderImporter;
+            if (shaderImporter == null)
+                return;
+
+            var textureNames = new List<string>();
+            var textures = new List<Texture>();
+            foreach (var textureInfo in configuredTextures.Where(x => x.modifiable))
+            {
+                var texture = EditorUtility.InstanceIDToObject(textureInfo.textureId) as Texture;
+                if (texture == null)
+                    continue;
+                textureNames.Add(textureInfo.name);
+                textures.Add(texture);
+            }
+            shaderImporter.SetDefaultTextures(textureNames.ToArray(), textures.ToArray());
+
+            textureNames.Clear();
+            textures.Clear();
+            foreach (var textureInfo in configuredTextures.Where(x => !x.modifiable))
+            {
+                var texture = EditorUtility.InstanceIDToObject(textureInfo.textureId) as Texture;
+                if (texture == null)
+                    continue;
+                textureNames.Add(textureInfo.name);
+                textures.Add(texture);
+            }
+            shaderImporter.SetNonModifiableTextures(textureNames.ToArray(), textures.ToArray());
+
+            shaderImporter.SaveAndReimport();
+        }*/
+
+        public void PostCreate()
+        {
+            m_PixelGraph.AddNode(new PixelShaderNode(m_PixelGraph));
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/MaterialGraph.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/MaterialGraphAsset.cs

+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public class MaterialGraphAsset : ScriptableObject, IMaterialGraphAsset
+    {
+        [SerializeField]
+        private MaterialGraph m_MaterialGraph;
+
+        public IGraph graph
+        {
+            get { return m_MaterialGraph.currentGraph; }
+        }
+
+        public bool shouldRepaint 
+        {
+            get { return graph.nodes.OfType<IRequiresTime>().Any(); }
+        }
+
+        public ScriptableObject GetScriptableObject()
+        {
+            return this;
+        }
+
+        public Material GetMaterial()
+        {
+            return null;
+        }
+
+        public void PostCreate()
+        {
+            m_MaterialGraph.PostCreate();
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/MaterialGraphAsset.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/MaterialOptions.cs

+using System;
+using UnityEngine;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class MaterialOptions
+    {
+        public enum BlendMode
+        {
+            One,
+            Zero,
+            SrcColor,
+            SrcAlpha,
+            DstColor,
+            DstAlpha,
+            OneMinusSrcColor,
+            OneMinusSrcAlpha,
+            OneMinusDstColor,
+            OneMinusDstAlpha,
+        }
+
+        public enum CullMode
+        {
+            Back,
+            Front,
+            Off
+        }
+
+        public enum ZTest
+        {
+            Less,
+            Greater,
+            LEqual,
+            GEqual,
+            Equal,
+            NotEqual,
+            Always
+        }
+
+        public enum ZWrite
+        {
+            On,
+            Off
+        }
+
+        public enum RenderQueue
+        {
+            Background,
+            Geometry,
+            Transparent,
+            Overlay,
+        }
+
+        public enum RenderType
+        {
+            Opaque,
+            Transparent,
+            TransparentCutout,
+            Background,
+            Overlay
+        }
+
+        [SerializeField]
+        private BlendMode m_SrcBlend;
+
+        [SerializeField]
+        private BlendMode m_DstBlend;
+
+        [SerializeField]
+        private CullMode m_CullMode;
+
+        [SerializeField]
+        private ZTest m_ZTest;
+
+        [SerializeField]
+        private ZWrite m_ZWrite;
+
+        [SerializeField]
+        private RenderQueue m_RenderQueue;
+
+        [SerializeField]
+        private RenderType m_RenderType;
+
+        [SerializeField]
+        private bool m_ShadowPass;
+
+        [SerializeField]
+        private bool m_FullForwardShadows;
+
+        [SerializeField]
+        private bool m_NoAmbient;
+
+        [SerializeField]
+        private bool m_NoVertexLights;
+
+        [SerializeField]
+        private bool m_NoLightmaps;
+
+        [SerializeField]
+        private bool m_NoDirLightmap;
+
+        [SerializeField]
+        private bool m_NoForwardAdd;
+
+        [SerializeField]
+        private bool m_ApproxView;
+
+        [SerializeField]
+        private bool m_HalfAsView;
+
+        [SerializeField]
+        private bool m_Expanded;
+
+        public void Init()
+        {
+            srcBlend = BlendMode.One;
+            dstBlend = BlendMode.Zero;
+            cullMode = CullMode.Back;
+            zTest = ZTest.LEqual;
+            zWrite = ZWrite.On;
+            renderQueue = RenderQueue.Geometry;
+            renderType = RenderType.Opaque;
+            shadowPass = false;
+            fullForwardShadows = false;
+            noAmbient = false;
+            noVertexLights = false;
+            noLightmaps = false;
+            noDirLightmap = false;
+            noForwardAdd = false;
+            approxView = false;
+            halfAsView = false;
+        }
+
+        public void GetTags(ShaderGenerator visitor)
+        {
+            visitor.AddShaderChunk("Tags {", false);
+            visitor.Indent();
+            visitor.AddShaderChunk("\"RenderType\"=\"" + renderType + "\"", false);
+            visitor.AddShaderChunk("\"Queue\"=\"" + renderQueue + "\"", false);
+            visitor.Deindent();
+            visitor.AddShaderChunk("}", false);
+        }
+
+        public void GetBlend(ShaderGenerator visitor)
+        {
+            visitor.AddShaderChunk("Blend " + srcBlend + " " + dstBlend, false);
+        }
+
+        public void GetCull(ShaderGenerator visitor)
+        {
+            visitor.AddShaderChunk("Cull " + cullMode, false);
+        }
+
+        public void GetDepthWrite(ShaderGenerator visitor)
+        {
+            visitor.AddShaderChunk("ZWrite " + zWrite, false);
+        }
+
+        public void GetDepthTest(ShaderGenerator visitor)
+        {
+            visitor.AddShaderChunk("ZTest " + zTest, false);
+        }
+
+        /*private Vector2 m_ScrollPos;
+        public void DoGUI()
+        {
+            GUILayout.BeginVertical();
+            m_Expanded = MaterialGraphStyles.Header("Options", m_Expanded);
+
+            if (m_Expanded)
+            {
+                srcBlend = (BlendMode) EditorGUILayout.EnumPopup("Src Blend", srcBlend);
+                dstBlend = (BlendMode) EditorGUILayout.EnumPopup("Dst Blend", dstBlend);
+                cullMode = (CullMode) EditorGUILayout.EnumPopup("Cull Mode", cullMode);
+                zTest = (ZTest) EditorGUILayout.EnumPopup("Z Test", zTest);
+                zWrite = (ZWrite) EditorGUILayout.EnumPopup("Z Write", zWrite);
+                renderQueue = (RenderQueue) EditorGUILayout.EnumPopup("Render Queue", renderQueue);
+                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; } }
+        public CullMode cullMode { get { return m_CullMode; } set { m_CullMode = value; } }
+        public ZTest zTest { get { return m_ZTest; } set { m_ZTest = value; } }
+        public ZWrite zWrite { get { return m_ZWrite; } set { m_ZWrite = value; } }
+        public RenderQueue renderQueue { get { return m_RenderQueue; } set { m_RenderQueue = value; } }
+        public RenderType renderType { get { return m_RenderType; } set { m_RenderType = value; } }
+        public bool shadowPass { get { return m_ShadowPass; } set { m_ShadowPass = value; } }
+        public bool fullForwardShadows { get { return m_FullForwardShadows; } set { m_FullForwardShadows = value; } }
+        public bool noAmbient { get { return m_NoAmbient; } set { m_NoAmbient = value; } }
+        public bool noVertexLights { get { return m_NoVertexLights; } set { m_NoVertexLights = value; } }
+        public bool noLightmaps { get { return m_NoLightmaps; } set { m_NoLightmaps = value; } }
+        public bool noDirLightmap { get { return m_NoDirLightmap; } set { m_NoDirLightmap = value; } }
+        public bool noForwardAdd { get { return m_NoForwardAdd; } set { m_NoForwardAdd = value; } }
+        public bool approxView { get { return m_ApproxView; } set { m_ApproxView = value; } }
+        public bool halfAsView { get { return m_HalfAsView; } set { m_HalfAsView = value; } }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/MaterialOptions.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/PixelGraph.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class PixelGraph : AbstractMaterialGraph
+    {
+        [NonSerialized]
+        private PixelShaderNode m_PixelMasterNode;
+
+        public PixelShaderNode pixelMasterNode
+        {
+            get
+            {
+                // find existing node
+                if (m_PixelMasterNode == null)
+                    m_PixelMasterNode = nodes.FirstOrDefault(x => x.GetType() == typeof(PixelShaderNode)) as PixelShaderNode;
+
+                return m_PixelMasterNode;
+            }
+        }
+ 
+        [NonSerialized]
+        private List<INode> m_ActiveNodes = new List<INode>();
+        public IEnumerable<AbstractMaterialNode> activeNodes
+        {
+            get
+            {
+                m_ActiveNodes.Clear();
+                NodeUtils.DepthFirstCollectNodesFromNode(m_ActiveNodes, pixelMasterNode);
+                return m_ActiveNodes.OfType<AbstractMaterialNode>();
+            }
+        }
+
+        public override void OnAfterDeserialize()
+        {
+            base.OnAfterDeserialize();
+            m_PixelMasterNode = null;
+        }
+
+        public override void AddNode(INode node)
+        {
+            if (pixelMasterNode != null && node is PixelShaderNode)
+            {
+                Debug.LogWarning("Attempting to add second PixelShaderNode to PixelGraph. This is not allowed.");
+                return;
+            }
+            base.AddNode(node);
+        }
+        
+        public static void GenerateSurfaceShader(
+            PixelShaderNode pixelNode,
+            ShaderGenerator shaderBody,
+            ShaderGenerator inputStruct,
+            ShaderGenerator lightFunction,
+            ShaderGenerator surfaceOutput,
+            ShaderGenerator nodeFunction,
+            PropertyGenerator shaderProperties,
+            ShaderGenerator propertyUsages,
+            ShaderGenerator vertexShader,
+            bool isPreview)
+        {
+            pixelNode.GenerateLightFunction(lightFunction);
+            pixelNode.GenerateSurfaceOutput(surfaceOutput);
+
+            var genMode = isPreview ? GenerationMode.Preview3D : GenerationMode.SurfaceShader;
+
+            var activeNodes = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodes, pixelNode);
+            var activeMaterialNodes = activeNodes.OfType<AbstractMaterialNode>();
+
+            foreach (var node in activeMaterialNodes)
+            {
+                if (node is IGeneratesFunction) (node as IGeneratesFunction).GenerateNodeFunction(nodeFunction, genMode);
+                if (node is IGeneratesVertexToFragmentBlock) (node as IGeneratesVertexToFragmentBlock).GenerateVertexToFragmentBlock(inputStruct, genMode);
+                if (node is IGeneratesVertexShaderBlock) (node as IGeneratesVertexShaderBlock).GenerateVertexShaderBlock(vertexShader, genMode);
+
+                if (node is IGenerateProperties)
+                {
+                    (node as IGenerateProperties).GeneratePropertyBlock(shaderProperties, genMode);
+                    (node as IGenerateProperties).GeneratePropertyUsages(propertyUsages, genMode, ConcreteSlotValueType.Vector4);
+                }
+            }
+
+            pixelNode.GenerateNodeCode(shaderBody, genMode);
+        }
+        /*
+        public Material GetMaterial()
+        {
+            if (pixelMasterNode == null)
+                return null;
+
+            var material = pixelMasterNode.previewMaterial;
+            AbstractMaterialNode.UpdateMaterialProperties(pixelMasterNode, material);
+            return material;
+        }*/
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Graphs/PixelGraph.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/MaterialSubGraphAsset.cs

+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public class MaterialSubGraphAsset : ScriptableObject, IMaterialGraphAsset
+    {
+        [SerializeField]
+        private SubGraph m_MaterialSubGraph;
+
+        public IGraph graph
+        {
+            get { return m_MaterialSubGraph; }
+        }
+
+        public bool shouldRepaint 
+        {
+            get { return graph.nodes.OfType<IRequiresTime>().Any(); }
+        }
+
+        public ScriptableObject GetScriptableObject()
+        {
+            return this;
+        }
+
+        public void PostCreate()
+        {
+            m_MaterialSubGraph.PostCreate();
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/MaterialSubGraphAsset.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraph.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class SubGraph : AbstractMaterialGraph
+    {
+        [NonSerialized]
+        private SubGraphInputNode m_InputNode;
+        [NonSerialized]
+        private SubGraphOutputNode m_OutputNode;
+
+        public SubGraphInputNode inputNode
+        {
+            get
+            {
+                // find existing node
+                if (m_InputNode == null)
+                    m_InputNode = nodes.OfType<SubGraphInputNode>().FirstOrDefault();
+
+                return m_InputNode;
+            }
+        }
+
+        public SubGraphOutputNode outputNode
+        {
+            get
+            {
+                // find existing node
+                if (m_OutputNode == null)
+                    m_OutputNode = nodes.OfType<SubGraphOutputNode>().FirstOrDefault();
+
+                return m_OutputNode;
+            }
+        }
+ 
+        [NonSerialized]
+        private List<INode> m_ActiveNodes = new List<INode>();
+        public IEnumerable<AbstractMaterialNode> activeNodes
+        {
+            get
+            {
+                m_ActiveNodes.Clear();
+                NodeUtils.DepthFirstCollectNodesFromNode(m_ActiveNodes, outputNode);
+                return m_ActiveNodes.OfType<AbstractMaterialNode>();
+            }
+        }
+
+        public override void OnAfterDeserialize()
+        {
+            base.OnAfterDeserialize();
+            m_InputNode = null;
+            m_OutputNode = null;
+        }
+
+        public override void AddNode(INode node)
+        {
+            if (inputNode != null && node is SubGraphInputNode)
+            {
+                Debug.LogWarning("Attempting to add second SubGraphInputNode to SubGraph. This is not allowed.");
+                return;
+            }
+
+            if (outputNode != null && node is SubGraphOutputNode)
+            {
+                Debug.LogWarning("Attempting to add second SubGraphOutputNode to SubGraph. This is not allowed.");
+                return;
+            }
+            base.AddNode(node);
+        }
+
+        public void PostCreate()
+        {
+            AddNode(new SubGraphInputNode(this));
+            AddNode(new SubGraphOutputNode(this));
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraph.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphIOBaseNode.cs

+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public abstract class SubGraphIOBaseNode : AbstractMaterialNode
+    {
+        protected SubGraphIOBaseNode(IGraph theOwner) : base(theOwner)
+        {}
+
+        /*public void FooterUI(GraphGUI host)
+        {
+            // TODO: make it pretty
+            GUIStyle style = this is SubGraphOutputNode ?
+                Styles.GetNodeStyle("shader in", Styles.Color.Aqua, false) :
+                Styles.GetNodeStyle("shader out", Styles.Color.Aqua, false);
+            var pos = GUILayoutUtility.GetRect(kTempContent, style);
+            int id = GUIUtility.GetControlID(FocusType.Passive);
+
+            Event evt = Event.current;
+            if (evt.type == EventType.Layout || evt.type == EventType.Used)
+                return;
+
+            switch (evt.GetTypeForControl(id))
+            {
+                case EventType.MouseUp:
+                    if (pos.Contains(evt.mousePosition) && evt.button == 0)
+                    {
+                        AddSlot();
+                        evt.Use();
+                    }
+                    break;
+                case EventType.Repaint:
+                    style.Draw(pos, kTempContent, id);
+                    break;
+            }
+        }*/
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphIOBaseNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphInputNode.cs

+using System.Collections.Generic;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public class SubGraphInputNode : SubGraphIOBaseNode, IGenerateProperties
+    {
+        public SubGraphInputNode(IGraph theOwner) : base(theOwner)
+        {
+            name = "SubGraphInputs";
+        }
+/*
+        public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
+        {
+            base.GeneratePropertyBlock(visitor, generationMode);
+
+            if (!generationMode.IsPreview())
+                return;
+
+            foreach (var slot in outputSlots)
+            {
+                if (slot.edges.Count == 0)
+                    continue;
+
+                var defaultValue = GetSlotDefaultValue(slot.name);
+                if (defaultValue != null)
+                    defaultValue.GeneratePropertyBlock(visitor, generationMode);
+            }
+        }
+
+        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode, ConcreteSlotValueType slotValueType)
+        {
+            base.GeneratePropertyUsages(visitor, generationMode, slotValueType);
+
+            if (!generationMode.IsPreview())
+                return;
+
+            foreach (var slot in outputSlots)
+            {
+                if (slot.edges.Count == 0)
+                    continue;
+
+                var defaultValue = GetSlotDefaultValue(slot.name);
+                if (defaultValue != null)
+                    defaultValue.GeneratePropertyUsages(visitor, generationMode, slotValueType);
+            }
+        }
+
+        protected override void CollectPreviewMaterialProperties (List<PreviewProperty> properties)
+        {
+            base.CollectPreviewMaterialProperties(properties);
+            foreach (var slot in outputSlots)
+            {
+                if (slot.edges.Count == 0)
+                    continue;
+
+                var defaultOutput = GetSlotDefaultValue(slot.name);
+                if (defaultOutput == null)
+                    continue;
+
+                var pp = new PreviewProperty
+                {
+                    m_Name = defaultOutput.inputName,
+                    m_PropType = PropertyType.Vector4,
+                    m_Vector4 = defaultOutput.defaultValue
+                };
+                properties.Add (pp);
+            }
+        }*/
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphInputNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphOutputNode.cs

+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    public class SubGraphOutputNode : SubGraphIOBaseNode
+    {
+        public SubGraphOutputNode(IGraph theOwner) : base(theOwner)
+        {
+            name = "SubGraphOutputs";
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SubGraph/SubGraphOutputNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SubGraphIOBaseNode.cs

-/*
-namespace UnityEditor.MaterialGraph
-{
-    public class SubGraphIOBaseNode : BaseMaterialNode
-    {
-        GUIContent kTempContent = new GUIContent("+");
-
-        public virtual void AddSlot()
-        {
-        }
-
-        public void FooterUI(GraphGUI host)
-        {
-            // TODO: make it pretty
-            GUIStyle style = this is SubGraphOutputsNode ?
-                Styles.GetNodeStyle("shader in", Styles.Color.Aqua, false) :
-                Styles.GetNodeStyle("shader out", Styles.Color.Aqua, false);
-            var pos = GUILayoutUtility.GetRect(kTempContent, style);
-            int id = GUIUtility.GetControlID(FocusType.Passive);
-
-            Event evt = Event.current;
-            if (evt.type == EventType.Layout || evt.type == EventType.Used)
-                return;
-
-            switch (evt.GetTypeForControl(id))
-            {
-                case EventType.MouseUp:
-                    if (pos.Contains(evt.mousePosition) && evt.button == 0)
-                    {
-                        AddSlot();
-                        evt.Use();
-                    }
-                    break;
-                case EventType.Repaint:
-                    style.Draw(pos, kTempContent, id);
-                    break;
-            }
-        }
-    }
-}
-*/

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SubGraphIOBaseNode.cs.meta

-fileFormatVersion: 2
-guid: 329dc46f2903e364da6c6d6500b0cfee
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SubGraphInputsNode.cs

-using UnityEngine;
-using System.Collections.Generic;
-/*
-namespace UnityEditor.MaterialGraph
-{
-    public class SubGraphInputsNode : SubGraphIOBaseNode, IGenerateProperties
-    {
-        public override void OnCreate()
-        {
-            name = "SubGraphInputs";
-            title = "Inputs";
-         //   position = new Rect(BaseMaterialGraphGUI.kDefaultNodeWidth * 4, BaseMaterialGraphGUI.kDefaultNodeHeight * 2, Mathf.Max(300, position.width), position.height);
-            base.OnCreate();
-        }
-
-        public override void AddSlot()
-        {
-            //AddSlot(new Slot(SlotType.OutputSlot, GenerateSlotName(SlotType.OutputSlot)));
-        }
-
-        public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {
-            base.GeneratePropertyBlock(visitor, generationMode);
-
-            if (!generationMode.IsPreview())
-                return;
-
-            foreach (var slot in outputSlots)
-            {
-                if (slot.edges.Count == 0)
-                    continue;
-
-                var defaultValue = GetSlotDefaultValue(slot.name);
-                if (defaultValue != null)
-                    defaultValue.GeneratePropertyBlock(visitor, generationMode);
-            }
-        }
-
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode, ConcreteSlotValueType slotValueType)
-        {
-            base.GeneratePropertyUsages(visitor, generationMode, slotValueType);
-
-            if (!generationMode.IsPreview())
-                return;
-
-            foreach (var slot in outputSlots)
-            {
-                if (slot.edges.Count == 0)
-                    continue;
-
-                var defaultValue = GetSlotDefaultValue(slot.name);
-                if (defaultValue != null)
-                    defaultValue.GeneratePropertyUsages(visitor, generationMode, slotValueType);
-            }
-        }
-
-        protected override void CollectPreviewMaterialProperties (List<PreviewProperty> properties)
-        {
-            base.CollectPreviewMaterialProperties(properties);
-            foreach (var slot in outputSlots)
-            {
-                if (slot.edges.Count == 0)
-                    continue;
-
-                var defaultOutput = GetSlotDefaultValue(slot.name);
-                if (defaultOutput == null)
-                    continue;
-
-                var pp = new PreviewProperty
-                {
-                    m_Name = defaultOutput.inputName,
-                    m_PropType = PropertyType.Vector4,
-                    m_Vector4 = defaultOutput.defaultValue
-                };
-                properties.Add (pp);
-            }
-        }
-    }
-}*/

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SubGraphInputsNode.cs.meta

-fileFormatVersion: 2
-guid: af738716871e4a345ac8edc429a3b665
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SubGraphNode.cs.meta

-fileFormatVersion: 2
-guid: 047e0841c1476e041935baac6d7bb652
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SubGraphOutputsNode.cs

-/*using UnityEditor.Graphs;
-using UnityEngine;
-
-namespace UnityEditor.MaterialGraph
-{
-    public class SubGraphOutputsNode : SubGraphIOBaseNode
-    {
-        public override void OnCreate()
-        {
-            base.OnCreate();
-            name = "SubGraphOutputs";
-            title = "Outputs";
-            //position = new Rect(BaseMaterialGraphGUI.kDefaultNodeWidth * 8, BaseMaterialGraphGUI.kDefaultNodeHeight * 2, Mathf.Max(300, position.width), position.height);
-        }
-
-        public override void AddSlot()
-        {
-            //AddSlot(new Slot(SlotType.InputSlot, GenerateSlotName(SlotType.InputSlot)));
-        }
-    }
-}
-*/

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SubGraphOutputsNode.cs.meta

-fileFormatVersion: 2
-guid: 12f42b98cfc8a394ca51a63cdd53d2cb
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: