More refactoring.

MaterialGraphProject/Assets/NewNodes/Keep/HeightToNormalNode.cs

 }
 ";
         }
-
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            base.GeneratePropertyUsages(visitor, generationMode);
-
-            visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
-            visitor.AddShaderChunk("SamplerState my_linear_repeat_sampler;", false);
-            visitor.AddShaderChunk("#endif", false);
-        }
     }
 }

MaterialGraphProject/Assets/NewNodes/Keep/SamplerStateNode.cs

-using System.Collections.Generic;
-using UnityEngine.MaterialGraph;
+using System;
 using UnityEngine.Graphing;
 
 namespace UnityEngine.MaterialGraph
     {
-        public enum FilterMode
-        {
-            Linear,
-            Point
-        }
-
-        public enum WrapMode
-        {
-            Repeat,
-            Clamp
-        }
-
-        static Dictionary<FilterMode, string> filterMode = new Dictionary<FilterMode, string>
-        {
-            {FilterMode.Linear, "_linear"},
-            {FilterMode.Point, "_point"},
-        };
-
-        static Dictionary<WrapMode, string> wrapMode = new Dictionary<WrapMode, string>
-        {
-            {WrapMode.Repeat, "_repeat"},
-            {WrapMode.Clamp, "_clamp"},
-        };
-
-
-        private FilterMode m_filter = FilterMode.Linear;
+        private TextureSamplerState.FilterMode m_filter = TextureSamplerState.FilterMode.Linear;
-        public FilterMode filter
+        public TextureSamplerState.FilterMode filter
         {
             get { return m_filter; }
             set
         }
 
         [SerializeField]
-        private WrapMode m_wrap = WrapMode.Repeat;
+        private TextureSamplerState.WrapMode m_wrap = TextureSamplerState.WrapMode.Repeat;
-        public WrapMode wrap
+        public TextureSamplerState.WrapMode wrap
         {
             get { return m_wrap; }
             set
             return GetVariableNameForNode();
         }
 
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-            var decl = string.Format(@"
-#ifdef UNITY_COMPILER_HLSL
-SamplerState {0};
-#endif", GetVariableNameForNode());
-            visitor.AddShaderChunk(decl, true);
+            properties.AddShaderProperty(new SamplerStateShaderProperty()
+            {
+                name = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = new TextureSamplerState()
+                {
+                    filter = m_filter,
+                    wrap =  m_wrap
+                }
+            });
-            return base.GetVariableNameForNode() + filterMode[filter] + wrapMode[wrap] + "_sampler";
+            string ss = name + "_"
+                        + Enum.GetName(typeof(TextureSamplerState.FilterMode), filter) + "_"
+                        + Enum.GetName(typeof(TextureSamplerState.WrapMode), wrap) + "_sampler;";
+            return ss;
         }
     }
 }

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

         public override void Action(int instanceId, string pathName, string resourceFile)
         {
             var graph = new UnityEngine.MaterialGraph.MaterialGraph();
-            graph.AddNode(new MetallicMasterNode());
+//            graph.AddNode(new MetallicMasterNode());
             File.WriteAllText(pathName, EditorJsonUtility.ToJson(graph));
             AssetDatabase.Refresh();
         }

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

 
         void Show();
         void Focus();
-        Object selected { get; }
+        Object selected { get; set; }
+    }
+
+    public abstract class HelperMaterialGraphEditWindow : EditorWindow, IMaterialGraphEditWindow
+    {
+        public abstract AbstractMaterialGraph GetMaterialGraph();
+        public abstract void PingAsset();
+        public abstract void UpdateAsset();
+        public abstract void ToggleRequiresTime();
+        public abstract void ToSubGraph();
+        public abstract Object selected { get; set; }
+        public abstract void ChangeSelection(Object newSelection);
-    {}
+    {
+        public override AbstractMaterialGraph GetMaterialGraph()
+        {
+            return inMemoryAsset;
+        }
+    }
+
-    {}
+    {
+        public override AbstractMaterialGraph GetMaterialGraph()
+        {
+            return inMemoryAsset;
+        }
+    }
-    public abstract class AbstractMaterialGraphEditWindow<TGraphType> : EditorWindow, IMaterialGraphEditWindow where TGraphType : AbstractMaterialGraph
+    public abstract class AbstractMaterialGraphEditWindow<TGraphType> : HelperMaterialGraphEditWindow where TGraphType : AbstractMaterialGraph
     {
         public static bool allowAlwaysRepaint = true;
 
 
         GraphEditorView m_GraphEditorView;
 
-        public TGraphType inMemoryAsset
+        protected TGraphType inMemoryAsset
-        public Object selected
+        public override Object selected
         {
             get { return m_Selected; }
             set { m_Selected = value; }
             }
         }
 
-        public void PingAsset()
+        public override void PingAsset()
-        public void UpdateAsset()
+        public override void UpdateAsset()
         {
             if (selected != null && inMemoryAsset != null)
             {
             }
         }
 
-        public void ToSubGraph()
+        public override void ToSubGraph()
         {
             string path = EditorUtility.SaveFilePanelInProject("Save subgraph", "New SubGraph", "ShaderSubGraph", "");
             path = path.Replace(Application.dataPath, "Assets");
 
         private void UpdateShaderGraphOnDisk(string path)
         {
-            var graph = inMemoryAsset as UnityEngine.MaterialGraph.MaterialGraph;
+    /*        var graph = inMemoryAsset as UnityEngine.MaterialGraph.MaterialGraph;
             if (graph == null)
                 return;
 
 
-            List<PropertyGenerator.TextureInfo> configuredTextures;
+            List<PropertyCollector.TextureInfo> configuredTextures;
             masterNode.GetFullShader(GenerationMode.ForReals, Path.GetFileNameWithoutExtension(path), out configuredTextures);
 
             var shaderImporter = AssetImporter.GetAtPath(path) as ShaderImporter;
             shaderImporter.SetNonModifiableTextures(textureNames.ToArray(), textures.ToArray());
             File.WriteAllText(path, EditorJsonUtility.ToJson(inMemoryAsset, true));
             shaderImporter.SaveAndReimport();
-            AssetDatabase.ImportAsset(path);
+            AssetDatabase.ImportAsset(path);*/
-        public virtual void ToggleRequiresTime()
+        public override void ToggleRequiresTime()
-        public void ChangeSelection(Object newSelection)
+        public override void ChangeSelection(Object newSelection)
         {
             if (!EditorUtility.IsPersistent(newSelection))
                 return;

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/Presenters/GraphInspectorPresenter.cs

         int m_SelectionCount;
 
         TypeMapper m_TypeMapper;
-       
+
-        public AbstractMaterialGraph graph { get; private set; }
+        [SerializeField]
+        private HelperMaterialGraphEditWindow m_Owner;
+
+        public AbstractMaterialGraph graph
+        {
+            get { return m_Owner.GetMaterialGraph(); }
+        }
 
         public AbstractNodeEditorPresenter editor
         {
             get { return m_SelectionCount; }
             set { m_SelectionCount = value; }
         }
-        
+
-
-         public void Initialize(AbstractMaterialGraph igraph, string graphName)
+        public void Initialize(HelperMaterialGraphEditWindow igraph, string graphName)
-            graph = igraph;
+            m_Owner = igraph;
-                {typeof(AbstractSurfaceMasterNode), typeof(SurfaceMasterNodeEditorPresenter)}
+//                {typeof(AbstractSurfaceMasterNode), typeof(SurfaceMasterNodeEditorPresenter)}
             };
             // Nodes missing custom editors:
             // - PropertyNode

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/Presenters/SurfaceMasterNodeEditorPresenter.cs

 
 namespace UnityEditor.MaterialGraph.Drawing.Inspector
 {
-    public class SurfaceMasterNodeEditorPresenter : AbstractNodeEditorPresenter
+   /* public class SurfaceMasterNodeEditorPresenter : AbstractNodeEditorPresenter
     {
         [SerializeField]
         AbstractSurfaceMasterNode m_Node;
         {
             get { return m_Node; }
         }
-    }
+    }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/Views/GraphInspectorView.cs

 using System;
+using System.Linq;
+using UnityEngine.Experimental.UIElements.StyleEnums;
+using UnityEngine.Experimental.UIElements.StyleSheets;
+using UnityEngine.Graphing;
+using UnityEngine.MaterialGraph;
 using Object = UnityEngine.Object;
 
 namespace UnityEditor.MaterialGraph.Drawing.Inspector
                 headerContainer.Add(m_Title);
             }
             Add(headerContainer);
-            
-             m_PropertiesContainer = new VisualElement()
-            {
-                new IMGUIContainer(OnGuiHandler)
-            };
-            m_PropertiesContainer.style.flexDirection = StyleValue<FlexDirection>.Create(FlexDirection.Column);
-            Add(m_PropertiesContainer);
+
+            ReaddProps();
 
             m_ContentContainer = new VisualElement { name = "contentContainer" };
             Add(m_ContentContainer);
                 { typeof(StandardNodeEditorPresenter), typeof(StandardNodeEditorView) },
-                { typeof(SurfaceMasterNodeEditorPresenter), typeof(SurfaceMasterNodeEditorView) }
+//                { typeof(SurfaceMasterNodeEditorPresenter), typeof(SurfaceMasterNodeEditorView) }
-private void OnGuiHandler()
+        private void ReaddProps()
+        {
+            if (m_PropertiesContainer != null)
+                Remove(m_PropertiesContainer);
+
+            m_PropertiesContainer = new VisualElement()
+            {
+                new IMGUIContainer(OnGuiHandler)
+            };
+
+            m_PropertiesContainer.style.flexDirection = StyleValue<FlexDirection>.Create(FlexDirection.Column);
+            Add(m_PropertiesContainer);
+        }
+
+        private void OnGuiHandler()
         {
             if (m_Presenter == null)
                 return;
                 gm.AddItem(new GUIContent("Float"), false, () =>
                 {
                     m_Presenter.graph.AddShaderProperty(new FloatShaderProperty());
-                    m_Presenter.Dirty();
+                    ReaddProps();
+
-                    presenter.Dirty();
+                    ReaddProps();
+
-                    m_Presenter.Dirty();
+                    ReaddProps();
+
-                    m_Presenter.Dirty();
+                    ReaddProps();
+
-                    m_Presenter.Dirty();
+                    ReaddProps();
+
-                    m_Presenter.Dirty();
+                    ReaddProps();
+
                 });
                 gm.ShowAsContext();
             }
                 }
                 EditorGUILayout.Separator();
             }
-            if(EditorGUI.EndChangeCheck())
-                m_Presenter.Dirty();
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var node in m_Presenter.graph.GetNodes<PropertyNode>())
+                    node.onModified(node, ModificationScope.Node);
+            }
-        
+
         public override void OnDataChanged()
         {
             if (presenter == null)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Inspector/Views/SurfaceMasterNodeEditorView.cs

 
 namespace UnityEditor.MaterialGraph.Drawing.Inspector
 {
-    public class SurfaceMasterNodeEditorView : AbstractNodeEditorView
+   /* public class SurfaceMasterNodeEditorView : AbstractNodeEditorView
     {
         NodeEditorHeaderView m_HeaderView;
 
 
             m_HeaderView.title = presenter.node.name;
         }
-    }
+    }*/
 }

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

         public Texture DoRenderPreview(Material mat, PreviewMode mode, Rect size, float time)
         {
             if (mat == null || mat.shader == null)
-                return Texture2D.blackTexture;
+                return Texture2D.blackTexture; 
 
             int rtWidth = (int)(size.width);
             int rtHeight = (int)(size.height);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/NodeInspectors/SurfaceMasterNodeInspector.cs

 {
     public class SurfaceMasterNodeInspector : BasicNodeInspector
     {
-        public override void OnInspectorGUI()
+ /*       public override void OnInspectorGUI()
         {
             base.OnInspectorGUI();
 
 
             if (EditorGUI.EndChangeCheck())
                 node.onModified(node, ModificationScope.Node);
-        }
+        }*/
     }
 }

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

-using UnityEditor.MaterialGraph.Drawing.Inspector;
+using System;
+using UnityEditor.MaterialGraph.Drawing.Inspector;
 using UnityEngine;
 using UnityEngine.Graphing;
 using UnityEngine.MaterialGraph;
             set { m_GraphInspectorPresenter = value; }
         }
 
-        public void Initialize(AbstractMaterialGraph graph, IMaterialGraphEditWindow container, string graphName)
+        public void Initialize(AbstractMaterialGraph graph, HelperMaterialGraphEditWindow container, string graphName)
-            m_GraphInspectorPresenter.Initialize(graph, graphName);
+            m_GraphInspectorPresenter.Initialize(container, graphName);
 
             m_GraphPresenter = CreateInstance<MaterialGraphPresenter>();
             m_GraphPresenter.Initialize(graph, container);

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

             //   typeMapper[typeof(RemapMasterNode)] = typeof(RemapMasterNodePresenter);
             // typeMapper[typeof(MasterRemapInputNode)] = typeof(RemapInputNodePresenter);
             typeMapper[typeof(AbstractSubGraphIONode)] = typeof(SubgraphIONodePresenter);
-            typeMapper[typeof(AbstractSurfaceMasterNode)] = typeof(SurfaceMasterNodePresenter);
+//            typeMapper[typeof(AbstractSurfaceMasterNode)] = typeof(SurfaceMasterNodePresenter);
             typeMapper[typeof(LevelsNode)] = typeof(LevelsNodePresenter);
             typeMapper[typeof(ConstantsNode)] = typeof(ConstantsNodePresenter);
 

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

             {
                 if (m_PreviewGenerator == null)
                 {
-                    m_PreviewGenerator = new MaterialGraphPreviewGenerator(m_Node is AbstractMasterNode);
+                    m_PreviewGenerator = new MaterialGraphPreviewGenerator(m_Node is MasterNode);
                 }
                 return m_PreviewGenerator;
             }
                 if (scope >= ModificationScope.Graph)
                 {
                     var stage = NodeUtils.FindEffectiveShaderStage(m_Node, true);
-                    if (!(m_Node is AbstractSurfaceMasterNode) && stage == ShaderStage.Vertex)
+/*                    if (!(m_Node is AbstractSurfaceMasterNode) && stage == ShaderStage.Vertex)
-                    }
+                    }*/
                     // TODO: Handle shader regeneration error
                     var status = UpdatePreviewShader();
                 }
         protected virtual string GetPreviewShaderString()
         {
             // TODO: this is a workaround right now.
-            if (m_Node is IMasterNode)
+   /*         if (m_Node is IMasterNode)
-                List<PropertyGenerator.TextureInfo> defaultTextures;
+                List<PropertyCollector.TextureInfo> defaultTextures;
                 var resultShader =  ((IMasterNode)m_Node).GetFullShader(GenerationMode.Preview, m_Node.guid + "_preview", out defaultTextures);
 
                 if (((IMasterNode)m_Node).has3DPreview())
 
                 return resultShader;
-            }
+            }*/
             return ShaderGenerator.GeneratePreviewShader(m_Node, out m_GeneratedShaderMode);
         }
 
                     continue;
 
                 node.CollectPreviewMaterialProperties(pList);
+            }
+
+            var graph = target.owner as AbstractMaterialGraph;
+            foreach (var prop in graph.properties)
+            {
+                SetPreviewMaterialProperty(prop.GetPreviewMaterialProperty(), material);
             }
 
             foreach (var prop in pList)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/MasterNodePresenter.cs

 
 namespace UnityEditor.MaterialGraph.Drawing
 {
-    class MasterNodeControlPresenter : GraphControlPresenter
-    {
-        public override void OnGUIHandler()
-        {
-            base.OnGUIHandler();
-            var masterNode = node as AbstractMasterNode;
-            if (masterNode == null || !masterNode.canBeActiveMaster)
-                return;
-
-            using (new EditorGUI.DisabledScope(masterNode.isActiveMaster))
-                masterNode.isActiveMaster |= GUILayout.Button("Set active");
-        }
-
-        public override float GetHeight()
-        {
-            var masterNode = node as AbstractMasterNode;
-            if (masterNode == null || !masterNode.canBeActiveMaster)
-                return 0f;
-            return EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
-        }
-    }
-
-    [Serializable]
-    public class MasterNodePresenter : MaterialNodePresenter
-    {
-        protected override IEnumerable<GraphControlPresenter> GetControlData()
-        {
-            var instance = CreateInstance<MasterNodeControlPresenter>();
-            instance.Initialize(node);
-            return new List<GraphControlPresenter> { instance };
-        }
-    }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/SamplerStateNodePresenter.cs

             get
             {
                 if (samplerFilterMode == null)
-                    samplerFilterMode = Enum.GetNames(typeof(SamplerStateNode.FilterMode));
+                    samplerFilterMode = Enum.GetNames(typeof(TextureSamplerState.FilterMode));
                 return samplerFilterMode;
             }
         }
             get
             {
                 if (samplerWrapMode == null)
-                    samplerWrapMode = Enum.GetNames(typeof(SamplerStateNode.WrapMode));
+                    samplerWrapMode = Enum.GetNames(typeof(TextureSamplerState.WrapMode));
                 return samplerWrapMode;
             }
         }
             base.OnGUIHandler();
 
-            var cNode = node as UnityEngine.MaterialGraph.SamplerStateNode;
+            var cNode = node as SamplerStateNode;
-            cNode.filter = (SamplerStateNode.FilterMode)EditorGUILayout.Popup((int)cNode.filter, _samplerFilterMode, EditorStyles.popup);
-            cNode.wrap = (SamplerStateNode.WrapMode)EditorGUILayout.Popup((int)cNode.wrap, _samplerWrapMode, EditorStyles.popup);
+            cNode.filter = (TextureSamplerState.FilterMode)EditorGUILayout.Popup((int)cNode.filter, _samplerFilterMode, EditorStyles.popup);
+            cNode.wrap = (TextureSamplerState.WrapMode)EditorGUILayout.Popup((int)cNode.wrap, _samplerWrapMode, EditorStyles.popup);
         }
 
         public override float GetHeight()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/SurfaceMasterNodePresenter.cs

 
 namespace UnityEditor.MaterialGraph.Drawing
 {
-    [Serializable]
-    class SurfaceMasterContolPresenter : GraphControlPresenter
-    {
-        public override void OnGUIHandler()
-        {
-            base.OnGUIHandler();
-            var cNode = node as AbstractSurfaceMasterNode;
-            if (cNode == null)
-                return;
-
-            cNode.options.lod = EditorGUILayout.IntField("LOD", cNode.options.lod);
-        }
-
-        public override float GetHeight()
-        {
-            return EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
-        }
-    }
-
-    [Serializable]
-    public class SurfaceMasterNodePresenter : MasterNodePresenter
-    {
-        protected override IEnumerable<GraphControlPresenter> GetControlData()
-        {
-            var instance = CreateInstance<SurfaceMasterContolPresenter>();
-            instance.Initialize(node);
-            var controls = new List<GraphControlPresenter>(base.GetControlData());
-            controls.Add(instance);
-            return controls;
-        }
-    }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/Nodes/Vector1NodePresenter.cs

             if (tNode == null)
                 return;
 
+
+            tNode.value = EditorGUILayout.FloatField("Value:", tNode.value);
+            /*
             tNode.floatType = (FloatPropertyChunk.FloatType)EditorGUILayout.EnumPopup("Float", tNode.floatType);
 
 
                     toggleState = EditorGUILayout.Toggle(toggleState);
                     tNode.value = toggleState == true ? 1f : 0f;
                     break;
-            }
+            }*/
         }
 
         public override float GetHeight()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Importers/ShaderGraphImporter.cs

             var textGraph = File.ReadAllText(path, Encoding.UTF8);
             var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
 
-            IMasterNode masterNode = graph.masterNode;
-            if (masterNode == null)
-                return null;
-
-            List<PropertyGenerator.TextureInfo> configuredTextures;
-            var shaderString = masterNode.GetFullShader(GenerationMode.ForReals, string.Format("graphs/{0}", name), out configuredTextures);
+            List<PropertyCollector.TextureInfo> configuredTextures;
+            var shaderString = graph.GetFullShader(GenerationMode.ForReals, string.Format("graphs/{0}", name), out configuredTextures);
             return shaderString;
         }
         catch (Exception)

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/IntegrationTests/ShaderGenerationTest.cs

             //Assert.IsNotNull(materialGraph);
 
             // Generate the shader
-            List<PropertyGenerator.TextureInfo> configuredTextures;
-            var shaderString =
-                graph.masterNode.GetFullShader(GenerationMode.ForReals, Path.GetFileNameWithoutExtension(filePath), out configuredTextures);
+            List<PropertyCollector.TextureInfo> configuredTextures = new List<PropertyCollector.TextureInfo>();
+            var shaderString = String.Empty;
+                //graph.masterNode.GetFullShader(GenerationMode.ForReals, Path.GetFileNameWithoutExtension(filePath), out configuredTextures);
 
             var rootPath = Directory.GetParent(Directory.GetParent(Application.dataPath).ToString());
             var shaderTemplatePath = Path.Combine(rootPath.ToString(), "ShaderTemplates");

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

             Assert.AreEqual(node, graph.GetNodeFromGuid<TestableMNode>(node.guid));
         }
 
-        [Test]
+   /*     [Test]
         public void TestCreatePixelShaderGraphWorks()
         {
             var graph = new UnityEngine.MaterialGraph.MaterialGraph();
             graph.AddNode(psn2);
             Assert.AreEqual(0, graph.edges.Count());
             Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
-        }
+        }*/
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/MaterialNodeTests.cs

             Assert.AreEqual(expected, result);
         }
 
-        [Test]
+ />an class="p">*       [Test]
         public void NodeGenerateCorrectPreviewPropertyUsages()
         {
             string expected = string.Format("{0} {1};{2}", AbstractMaterialNode.OutputPrecision.@fixed, m_NodeA.GetVariableNameForSlot(TestNode.V1In), Environment.NewLine);
             m_NodeA.precision = AbstractMaterialNode.OutputPrecision.half;
             m_NodeA.GeneratePropertyUsages(visitor, GenerationMode.Preview);
             Assert.AreEqual(expected, visitor.GetShaderString(0));
-        }
+        }*/
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/MaterialSlotTests.cs

             Assert.AreEqual(SlotValueType.Vector3, slot.valueType);
         }
 
-        [Test]
+   /*     [Test]
         public void MaterialSlotCanGeneratePropertyUsagesForPreview()
         {
             string expected = string.Format("{0} {1};{2}", m_NodeA.precision, m_NodeA.GetVariableNameForSlot(TestNode.V1In), Environment.NewLine);
             slot.GeneratePropertyUsages(visitor, GenerationMode.Preview);
             Assert.AreEqual(expected, visitor.GetShaderString(0));
-        }
+        }*/
 
         [Test]
         public void MaterialSlotReturnsValidDefaultValue()
             Assert.AreEqual("half4 (6,6,6,1)", result);
         }
 
-        [Test]
+       /* [Test]
-        }
+        }*/
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/PixelShaderNodeTests.cs

     [TestFixture]
     public class PixelShaderNodeTests
     {
-        private UnityEngine.MaterialGraph.MaterialGraph m_Graph;
+      /*  private UnityEngine.MaterialGraph.MaterialGraph m_Graph;
         private Vector1Node m_InputOne;
         private AbsoluteNode m_Abs;
         private MetallicMasterNode m_PixelNode;
             //m_Graph.Connect(m_Abs.GetSlotReference(Function1Input.OutputSlotId), m_PixelNode.GetSlotReference(AbstractSurfaceMasterNode.AlbedoSlotId));
         }
 
-        /*  [Test]
+         [Test]
           public void TestNodeGeneratesCorrectNodeCode()
           {
               string expected = string.Format("half {0} = 0.2;" + Environment.NewLine

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/PropertyChunkTests.cs

 
 namespace UnityEditor.MaterialGraph.UnitTests
 {
-    [TestFixture]
+ />an class="p">*   [TestFixture]
     public class PropertyChunkTests
     {
         class TestPropertyChunch : PropertyChunk
             Assert.AreEqual(TexturePropertyChunk.ModifiableState.NonModifiable, chunk.modifiableState);
             Assert.AreEqual(PropertyChunk.HideState.Hidden, chunk.hideState);
         }
-    }
+    }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/UnitTests/PropertyGeneratorTests.cs

         private const string kPropertyName = "ThePropertyName";
         private const string kPropertyDescription = "ThePropertyDescription";
 
-        [Test]
+ />an class="p">*       [Test]
-            var generator = new PropertyGenerator();
+            var generator = new PropertyCollector();
-            Assert.AreNotEqual(string.Empty, generator.GetShaderString(0));
+            Assert.AreNotEqual(string.Empty, generator.GetPropertiesBlock(0));
         }
 
         [Test]
-            var generator = new PropertyGenerator();
+            var generator = new PropertyCollector();
-            Assert.AreEqual(0, generator.GetShaderString(0).Count(x => x == '\t'));
-            Assert.AreEqual(1, generator.GetShaderString(1).Count(x => x == '\t'));
-            Assert.AreEqual(2, generator.GetShaderString(2).Count(x => x == '\t'));
+            Assert.AreEqual(0, generator.GetPropertiesBlock(0).Count(x => x == '\t'));
+            Assert.AreEqual(1, generator.GetPropertiesBlock(1).Count(x => x == '\t'));
+            Assert.AreEqual(2, generator.GetPropertiesBlock(2).Count(x => x == '\t'));
         }
 
         [Test]
-            var generator = new PropertyGenerator();
+            var generator = new PropertyCollector();
             generator.AddShaderProperty(chunk);
 
             var infos = generator.GetConfiguredTexutres();
             Assert.AreEqual(TexturePropertyChunk.ModifiableState.Modifiable, infos[0].modifiable);
-        }
+        }*/
     }
 }

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

 using System;
 using System.Collections.Generic;
-using UnityEditor;
+using UnityEngine.XR.WSA.WebCam;
-    public interface IAbstractShaderProperty
-    {
-        string name { get; set; }
-        string description { get; set; }
-        string propertyName { get; }
-        PropertyType propertyType { get; }
-        Guid guid { get; }
-    }
-
-    public abstract class AbstractShaderProperty<T> : ISerializationCallbackReceiver, IAbstractShaderProperty
+    public abstract class AbstractMaterialGraph : SerializableGraph, IGenerateProperties
-        [SerializeField]
-        private T m_Value;
-
-        [SerializeField]
-        private string m_Description;
-
-        [SerializeField]
-        private string m_Name;
-
-        private Guid m_Guid;
-
-        [SerializeField]
-        private string m_GuidSerialized;
-
-        protected AbstractShaderProperty()
-        {
-            m_Guid = Guid.NewGuid();
-        }
-
-        public T value
-        {
-            get { return m_Value; }
-            set { m_Value = value; }
-        }
-
-        public string name
-        {
-            get
-            {
-                if (string.IsNullOrEmpty(m_Name))
-                    return m_Guid.ToString();
-                return m_Name;
-            }
-            set { m_Name = value; }
-        }
-
-        public string description
-        {
-            get
-            {
-                return string.IsNullOrEmpty(m_Description) ? name : m_Description;
-            }
-            set { m_Description = value; }
-        }
-
-        public string propertyName
-        {
-            get
-            {
-                return string.Format("{0}_Uniform", name);
-            }
-        }
-
-        public abstract PropertyType propertyType { get; }
-
-        public Guid guid
-        {
-            get { return m_Guid; }
-        }
-
-        public virtual void OnBeforeSerialize()
-        {
-            m_GuidSerialized = m_Guid.ToString();
-        }
-
-        public virtual void OnAfterDeserialize()
-        {
-            if (!string.IsNullOrEmpty(m_GuidSerialized))
-                m_Guid = new Guid(m_GuidSerialized);
-            else
-                m_Guid = Guid.NewGuid();
-        }
-    }
-
-    [Serializable]
-    public class FloatShaderProperty : AbstractShaderProperty<float>
-    {
-        public override PropertyType propertyType
-        {
-            get { return PropertyType.Float; }
-        }
-    }
-
-    [Serializable]
-    public class Vector2ShaderProperty : AbstractShaderProperty<Vector2>
-    {
-        public override PropertyType propertyType
-        {
-            get { return PropertyType.Vector2; }
-        }
-    }
-
-    [Serializable]
-    public class Vector3ShaderProperty : AbstractShaderProperty<Vector3>
-    {
-        public override PropertyType propertyType
-        {
-            get { return PropertyType.Vector2; }
-        }
-    }
-
-    [Serializable]
-    public class Vector4ShaderProperty : AbstractShaderProperty<Vector4>
-    {
-        public override PropertyType propertyType
-        {
-            get { return PropertyType.Vector4; }
-        }
-    }
-
-    [Serializable]
-    public class ColorShaderProperty : AbstractShaderProperty<Color>
-    {
-        [SerializeField]
-        private bool m_HDR;
-
-        public bool HDR
-        {
-            get { return m_HDR; }
-            set
-            {
-                if (m_HDR == value)
-                    return;
-
-                m_HDR = value;
-            }
-        }
-
-        public override PropertyType propertyType
-        {
-            get { return PropertyType.Color; }
-        }
-
-        public void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderProperty(new ColorPropertyChunk(propertyName, description, value, m_HDR ? ColorPropertyChunk.ColorType.HDR : ColorPropertyChunk.ColorType.Default , PropertyChunk.HideState.Visible));
-        }
-
-        public void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderChunk("float4 " + propertyName + ";", true);
-        }
-
-        public PreviewProperty GetPreviewProperty()
-        {
-            return new PreviewProperty
-            {
-                m_Name = propertyName,
-                m_PropType = PropertyType.Color,
-                m_Color = value
-            };
-        }
-    }
-
-    [Serializable]
-    public class SerializableTexture
-    {
-        [SerializeField] private string m_SerializedTexture;
-
-        [Serializable]
-        private class TextureHelper
-        {
-            public Texture texture;
-        }
-
-#if UNITY_EDITOR
-        public Texture texture
-        {
-            get
-            {
-                if (string.IsNullOrEmpty(m_SerializedTexture))
-                    return null;
-
-                var tex = new TextureHelper();
-                EditorJsonUtility.FromJsonOverwrite(m_SerializedTexture, tex);
-                return tex.texture;
-            }
-            set
-            {
-                if (texture == value)
-                    return;
-
-                var tex = new TextureHelper();
-                tex.texture = value;
-                m_SerializedTexture = EditorJsonUtility.ToJson(tex, true);
-            }
-        }
-#else
-        public Texture defaultTexture {get; set; }
-#endif
-
-    }
-
-    [Serializable]
-    public class TextureShaderProperty : AbstractShaderProperty<SerializableTexture>
-    {
-        [SerializeField]
-        private bool m_Modifiable;
-
-        public TextureShaderProperty()
-        {
-            value = new SerializableTexture();
-        }
-
-        public override PropertyType propertyType
-        {
-            get { return PropertyType.Texture; }
-        }
-
-        // Properties
-        public void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderProperty(
-                new TexturePropertyChunk(
-                    propertyName,
-                    description,
-                    value.texture, TextureType.Black,
-                    PropertyChunk.HideState.Visible,
-                    m_Modifiable ?
-                        TexturePropertyChunk.ModifiableState.Modifiable
-                        : TexturePropertyChunk.ModifiableState.NonModifiable));
-        }
-
-        public void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderChunk("UNITY_DECLARE_TEX2D(" + propertyName + ");", true);
-        }
-
-        public PreviewProperty GetPreviewProperty()
-        {
-            return new PreviewProperty
-            {
-                m_Name = propertyName,
-                m_PropType = PropertyType.Texture,
-                m_Texture = value.texture
-            };
-        }
-    }
-
-    [Serializable]
-    public abstract class AbstractMaterialGraph : SerializableGraph
-    {
-        [NonSerialized]
-        private List<IAbstractShaderProperty> m_Properties = new List<IAbstractShaderProperty>();
+        private List<IShaderProperty> m_Properties = new List<IShaderProperty>();
-        public IEnumerable<IAbstractShaderProperty> properties
+        public IEnumerable<IShaderProperty> properties
         {
             get { return m_Properties; }
         }
             }
         }
 
-        public void AddShaderProperty(IAbstractShaderProperty property)
+        public void CollectShaderProperties(PropertyCollector collector, GenerationMode generationMode)
+        {
+            foreach(var prop in properties)
+                collector.AddShaderProperty(prop);
+        }
+
+        public void AddShaderProperty(IShaderProperty property)
         {
             if (property == null)
                 return;
         public override void OnBeforeSerialize()
         {
             base.OnBeforeSerialize();
-            m_SerializedProperties = SerializationHelper.Serialize<IAbstractShaderProperty>(m_Properties);
+            m_SerializedProperties = SerializationHelper.Serialize<IShaderProperty>(m_Properties);
+            // have to deserialize 'globals' before nodes
+            m_Properties = SerializationHelper.Deserialize<IShaderProperty>(m_SerializedProperties, null);
-            m_Properties = SerializationHelper.Deserialize<IAbstractShaderProperty>(m_SerializedProperties, null);
         }
     }
 }

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

 using System;
+using System.Collections.Generic;
 using System.Linq;
 using UnityEngine.Graphing;
 
     public class MaterialGraph : AbstractMaterialGraph
     {
-        [NonSerialized]
-        private Guid m_ActiveMasterNodeGUID;
-
-        [SerializeField]
-        private string m_ActiveMasterNodeGUIDSerialized;
-
-        public MaterialGraph()
+        public MasterNode masterNode
-            m_ActiveMasterNodeGUID = Guid.NewGuid();
+            get { return GetNodes<MasterNode>().FirstOrDefault(); }
-        public IMasterNode masterNode
+        public string GetFullShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures)
-            get
-            {
-                var found = GetNodeFromGuid(m_ActiveMasterNodeGUID) as IMasterNode;
-                if (found != null)
-                    return found;
+            // Lets collect all the properties
+            var generatedProperties = new PropertyCollector();
+            var shaderFunctions = new ShaderGenerator();
+            var shaderBody = new ShaderGenerator();
-                return GetNodes<IMasterNode>().FirstOrDefault();
-            }
-            set
+            foreach (var prop in properties)
+                generatedProperties.AddShaderProperty(prop);
+
+            // start by collecting all the active nodes!
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode);
+
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
-                var previousMaster = masterNode;
+                if (node is IGeneratesFunction)
+                    (node as IGeneratesFunction).GenerateNodeFunction(shaderFunctions, mode);
-                if (value == null)
-                    m_ActiveMasterNodeGUID = Guid.NewGuid();
-                else
-                    m_ActiveMasterNodeGUID = value.guid;
+                if (node is IGeneratesBodyCode)
+                    (node as IGeneratesBodyCode).GenerateNodeCode(shaderBody, mode);
-                masterNode.onModified(masterNode, ModificationScope.Node);
-                previousMaster.onModified(previousMaster, ModificationScope.Node);
+                node.CollectShaderProperties(generatedProperties, mode);
-        }
-        public override void OnBeforeSerialize()
-        {
-            base.OnBeforeSerialize();
-
-            m_ActiveMasterNodeGUIDSerialized = m_ActiveMasterNodeGUID.ToString();
-        }
-
-        public override void OnAfterDeserialize()
-        {
-            base.OnAfterDeserialize();
-
-            if (!string.IsNullOrEmpty(m_ActiveMasterNodeGUIDSerialized))
-                m_ActiveMasterNodeGUID = new Guid(m_ActiveMasterNodeGUIDSerialized);
-            else
-                m_ActiveMasterNodeGUID = Guid.NewGuid();
+            configuredTextures = generatedProperties.GetConfiguredTexutres();
+            return string.Empty;
         }
     }
 }

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

 using System;
+using System.Collections.Generic;
 using UnityEngine.Graphing;
 
 namespace UnityEngine.MaterialGraph
             set { m_ShaderStage = value; }
         }
 
-        public void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            if (!generationMode.IsPreview())
-                return;
-
-            if (concreteValueType == ConcreteSlotValueType.SamplerState ||
-                concreteValueType == ConcreteSlotValueType.Texture2D)
-                return;
-
-            var matOwner = owner as AbstractMaterialNode;
-            if (matOwner == null)
-                throw new Exception(string.Format("Slot {0} either has no owner, or the owner is not a {1}", this, typeof(AbstractMaterialNode)));
-
-            visitor.AddShaderChunk(AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(matOwner.precision, concreteValueType) + " " + matOwner.GetVariableNameForSlot(id) + ";", true);
-        }
-
         public bool IsCompatibleWithInputSlotType(SlotValueType inputType)
         {
             switch (valueType)
                 default:
                     return "error";
             }
+        }
+
+        public void AddProperty(PropertyCollector properties, GenerationMode generationMode)
+        {
+            if (!generationMode.IsPreview())
+                return;
+
+            if (concreteValueType == ConcreteSlotValueType.SamplerState ||
+                concreteValueType == ConcreteSlotValueType.Texture2D)
+                return;
+
+            var matOwner = owner as AbstractMaterialNode;
+            if (matOwner == null)
+                throw new Exception(string.Format("Slot {0} either has no owner, or the owner is not a {1}", this, typeof(AbstractMaterialNode)));
+
+            IShaderProperty property;
+            switch (concreteValueType)
+            {
+                case ConcreteSlotValueType.Vector4:
+                    property = new Vector4ShaderProperty();
+                    break;
+                case ConcreteSlotValueType.Vector3:
+                    property = new Vector3ShaderProperty();
+                    break;
+                case ConcreteSlotValueType.Vector2:
+                    property = new Vector2ShaderProperty();
+                    break;
+                case ConcreteSlotValueType.Vector1:
+                    property = new FloatShaderProperty();
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            property.name = matOwner.GetVariableNameForSlot(id);
+            property.generatePropertyBlock = false;
+
+            properties.AddShaderProperty(property);
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Interfaces/IGenerateProperties.cs

+using System.Collections.Generic;
+
-        void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode);
-        void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode);
+        void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode);
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Interfaces/IMasterNode.cs

 
 namespace UnityEngine.MaterialGraph
 {
-    public interface IMasterNode : INode
+   /* public interface IMasterNode : INode
     {
         string GetFullShader(GenerationMode mode, string name, out List<PropertyGenerator.TextureInfo> configuredTextures);
 
 
         bool has3DPreview();
-    }
+    }*/
 }

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

             version = 0;
         }
 
-        public virtual void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {}
-
-        public virtual void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        public virtual void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
         {
             if (!generateDefaultInputs)
                 return;
                 if (edges.Any())
                     continue;
 
-                inputSlot.GeneratePropertyUsages(visitor, generationMode);
+                inputSlot.AddProperty(properties, generationMode);
             }
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/ColorNode.cs

             }
         }
 
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-            visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + ";", true);
+            properties.AddShaderProperty(new ColorShaderProperty()
+            {
+                name = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = color,
+                HDR = HDR
+            });
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/Matrix/Matrix2Node.cs

             //if (exposedState == ExposedState.Exposed || generationMode.IsPreview())
             //    return;
 
-            visitor.AddShaderChunk(precision + "2 " +  propertyName + " = " + precision + "2x2 (" + m_Value[0].x + ", " + m_Value[0].y + ", " + m_Value[1].x + ", " + m_Value[1].y + ");", true);
+            visitor.AddShaderChunk(precision + "2 " +  name + " = " + precision + "2x2 (" + m_Value[0].x + ", " + m_Value[0].y + ", " + m_Value[1].x + ", " + m_Value[1].y + ");", true);
         }
 
         [SerializeField]

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/Vector/Vector1Node.cs

         [SerializeField]
         private float m_Value;
 
-        [SerializeField]
-        private FloatPropertyChunk.FloatType m_floatType;
+        /*[SerializeField]
+        private FloatPropertyChunk.FloatType m_floatType;*/
-        [SerializeField]
-        private Vector3 m_rangeValues = new Vector3(0f, 1f, 2f);
+       // [SerializeField]
+        //private Vector3 m_rangeValues = new Vector3(0f, 1f, 2f);
 
         public const int OutputSlotId = 0;
         private const string kOutputSlotName = "Value";
             }
         }
 
-        public FloatPropertyChunk.FloatType floatType
+       /* public FloatPropertyChunk.FloatType floatType
         {
             get { return m_floatType; }
             set
                 if (onModified != null)
                     onModified(this, ModificationScope.Node);
             }
-        }
+        }*/
-        public Vector3 rangeValues
+      /*  public Vector3 rangeValues
         {
             get { return m_rangeValues; }
             set
                     onModified(this, ModificationScope.Node);
             }
         }
-
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+*/
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-            visitor.AddShaderChunk(precision + " " + GetVariableNameForNode() + ";", true);
+            properties.AddShaderProperty(new FloatShaderProperty()
+            {
+                name = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value
+            });
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/Vector/Vector2Node.cs

             }
         }
 
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-            visitor.AddShaderChunk(precision + "2 " + GetVariableNameForNode() + ";", true);
+            properties.AddShaderProperty(new Vector2ShaderProperty()
+            {
+                name = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value
+            });
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/Vector/Vector3Node.cs

+using System;
 using System.Collections.Generic;
 using UnityEngine.Graphing;
 
             }
         }
 
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-            visitor.AddShaderChunk(precision + "3 " + GetVariableNameForNode() + ";", true);
+            properties.AddShaderProperty(new Vector3ShaderProperty()
+            {
+                name = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value
+            });
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Input/Vector/Vector4Node.cs

             }
         }
 
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-            visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + ";", true);
+            properties.AddShaderProperty(new Vector4ShaderProperty()
+            {
+                name = GetVariableNameForNode(),
+                generatePropertyBlock = false,
+                value = value
+            });
         }
 
         public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)

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

         public override string GetVariableNameForSlot(int slotId)
         {
             var graph = owner as AbstractMaterialGraph;
-            var property = graph.properties.FirstOrDefault(x => x.guid == guid);
+            var property = graph.properties.FirstOrDefault(x => x.guid == propertyGuid);
             return property.name;
         }
 
 
-            if (!graph.properties.Any(x => x.guid == guid))
+            if (!graph.properties.Any(x => x.guid == propertyGuid))
                 return true;
 
             return false;

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

             }
         }
 
-        public void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
+        public void CollectShaderProperties(PropertyCollector visitor, GenerationMode generationMode)
-                    (node as IGenerateProperties).GeneratePropertyBlock(visitor, generationMode);
-            }
-        }
-
-        public void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            foreach (var node in usedNodes)
-            {
-                if (node is IGenerateProperties)
-                    (node as IGenerateProperties).GeneratePropertyUsages(visitor, generationMode);
+                    (node as IGenerateProperties).CollectShaderProperties(visitor, generationMode);
             }
         }
 

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

+using System;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine.Graphing;
             RemoveSlot(-lastSlotId);
         }
 
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        public override void CollectShaderProperties(PropertyCollector properties, GenerationMode generationMode)
-            if (generationMode == GenerationMode.ForReals)
+            if (!generationMode.IsPreview())
-                var outDimension = ConvertConcreteSlotValueTypeToString(slot.concreteValueType);
-                visitor.AddShaderChunk("float" + outDimension + " " + GetVariableNameForSlot(slot.id) + ";", true);
+                IShaderProperty property;
+                switch (slot.concreteValueType)
+                {
+                    case ConcreteSlotValueType.Vector4:
+                        property = new Vector4ShaderProperty();
+                        break;
+                    case ConcreteSlotValueType.Vector3:
+                        property = new Vector3ShaderProperty();
+                        break;
+                    case ConcreteSlotValueType.Vector2:
+                        property = new Vector2ShaderProperty();
+                        break;
+                    case ConcreteSlotValueType.Vector1:
+                        property = new FloatShaderProperty();
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+                property.generatePropertyBlock = false;
+                properties.AddShaderProperty(property);
             }
         }
 
                 properties.Add
                 (
                     new PreviewProperty
-                {
-                    m_Name = GetVariableNameForSlot(s.id),
-                    m_PropType = ConvertConcreteSlotValueTypeToPropertyType(s.concreteValueType),
-                    m_Vector4 = s.currentValue,
-                    m_Float = s.currentValue.x,
-                    m_Color = s.currentValue
-                }
+                    {
+                        m_Name = GetVariableNameForSlot(s.id),
+                        m_PropType = ConvertConcreteSlotValueTypeToPropertyType(s.concreteValueType),
+                        m_Vector4 = s.currentValue,
+                        m_Float = s.currentValue.x,
+                        m_Color = s.currentValue
+                    }
                 );
             }
         }

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

             shaderBodyVisitor.AddShaderChunk(outputString.GetShaderString(0), true);
         }
 
-        public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {
-            base.GeneratePropertyBlock(visitor, generationMode);
-
-            if (subGraph == null)
-                return;
-
-            subGraph.GeneratePropertyBlock(visitor, GenerationMode.ForReals);
-        }
-
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        public override void CollectShaderProperties(PropertyCollector visitor, GenerationMode generationMode)
-            base.GeneratePropertyUsages(visitor, generationMode);
+            base.CollectShaderProperties(visitor, generationMode);
-            subGraph.GeneratePropertyUsages(visitor, GenerationMode.ForReals);
+            subGraph.CollectShaderProperties(visitor, GenerationMode.ForReals);
         }
 
         public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/AbstractSurfaceMasterNode.cs

 
 namespace UnityEngine.MaterialGraph
 {
-    [Serializable]
-    public abstract class AbstractSurfaceMasterNode : AbstractMasterNode
+ />an class="p">*   [Serializable]
+    public abstract class AbstractSurfaceMasterNode : MasterNode
     {
         public const string AlbedoSlotName = "Albedo";
         public const string NormalSlotName = "Normal";
             }
         }
 
-        public override string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
+/        public override string GetSubShader(GenerationMode mode, PropertyCollector shaderPropertiesVisitor)
         {
             var templateLocation = ShaderGenerator.GetTemplatePath("subshader.template");
 
             return resultShader;
         }
 
-        public override string GetFullShader(GenerationMode mode, string name, out List<PropertyGenerator.TextureInfo> configuredTextures)
+        public override string GetFullShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures)
-                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                configuredTextures = new List<PropertyCollector.TextureInfo>();
-            var shaderPropertiesVisitor = new PropertyGenerator();
+            var shaderPropertiesVisitor = new PropertyCollector();
-            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetPropertiesBlock(2));
             configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
             return Regex.Replace(resultShader, @"\r\n|\n\r|\n|\r", Environment.NewLine);
         }
                 }
             }
         }
-    }
+    }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/ExportTextureMasterNode.cs

 
 namespace UnityEngine.MaterialGraph
 {
-    [Serializable]
+ />an class="p">*   [Serializable]
-    public class ExportTextureMasterNode : AbstractMasterNode
+    public class ExportTextureMasterNode : MasterNode
     {
         public const string ColorSlotName = "Color";
         public const int ColorSlotId = 0;
             }
         }
 
-        public override string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
+        public override string GetSubShader(GenerationMode mode, PropertyCollector shaderPropertiesVisitor)
         {
             return "";
         }
             return false;
         }
 
-        public override string GetFullShader(GenerationMode generationMode, string name, out List<PropertyGenerator.TextureInfo> configuredTextures)
+        public override string GetFullShader(GenerationMode generationMode, string name, out List<PropertyCollector.TextureInfo> configuredTextures)
         {
             // figure out what kind of preview we want!
             var activeNodeList = ListPool<INode>.Get();
             if (!File.Exists(templateLocation))
             {
-                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                configuredTextures = new List<PropertyCollector.TextureInfo>();
                 return string.Empty;
             }
 
             var shaderFunctionVisitor = new ShaderGenerator();
-            var shaderPropertiesVisitor = new PropertyGenerator();
+            var shaderPropertiesVisitor = new PropertyCollector();
             var shaderPropertyUsagesVisitor = new ShaderGenerator();
             var shaderInputVisitor = new ShaderGenerator();
 
             ListPool<INode>.Release(activeNodeList);
 
             template = template.Replace("${ShaderName}", name);
-            template = template.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
+            template = template.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetPropertiesBlock(2));
             template = template.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(3));
             template = template.Replace("${ShaderFunctions}", shaderFunctionVisitor.GetShaderString(3));
             template = template.Replace("${PixelShaderBody}", shaderBodyVisitor.GetShaderString(4));
             configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
             return Regex.Replace(template, @"\r\n|\n\r|\n|\r", Environment.NewLine);
         }
-    }
+    }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/MetallicMasterNode.cs

 
 namespace UnityEngine.MaterialGraph
 {
-    [Serializable]
+  /*  [Serializable]
     [Title("Master/Metallic")]
     public class MetallicMasterNode : AbstractSurfaceMasterNode
     {
         {
             return LightFunctionName;
         }
-    }
+    }*/
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/SpecularMasterNode.cs

 
 namespace UnityEngine.MaterialGraph
 {
-    [Serializable]
+/*    [Serializable]
     [Title("Master/Specular")]
     public class SpecularMasterNode : AbstractSurfaceMasterNode
     {
         {
             return LightFunctionName;
         }
-    }
+    }*/
 }

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

 
 namespace UnityEngine.MaterialGraph
 {
-    public class CubemapPropertyChunk : PropertyChunk
+/*    public class CubemapPropertyChunk : PropertyChunk
     {
         public enum ModifiableState
         {
                 return m_Modifiable;
             }
         }
-    }
+    }*/
 }

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

 
             var shaderBodyVisitor = new ShaderGenerator();
             var shaderFunctionVisitor = new ShaderGenerator();
-            var shaderPropertiesVisitor = new PropertyGenerator();
-            var shaderPropertyUsagesVisitor = new ShaderGenerator();
+            var shaderPropertiesVisitor = new PropertyCollector();
+            var owner = node.owner as AbstractMaterialGraph;
+            if (owner != null)
+                owner.CollectShaderProperties(shaderPropertiesVisitor, GenerationMode.Preview);
 
             var shaderInputVisitor = new ShaderGenerator();
             var vertexShaderBlock = new ShaderGenerator();
                 if (activeNode is IGeneratesBodyCode)
                     (activeNode as IGeneratesBodyCode).GenerateNodeCode(shaderBodyVisitor, generationMode);
 
-                activeNode.GeneratePropertyBlock(shaderPropertiesVisitor, generationMode);
-                activeNode.GeneratePropertyUsages(shaderPropertyUsagesVisitor, generationMode);
+                activeNode.CollectShaderProperties(shaderPropertiesVisitor, generationMode);
+
 
             shaderBodyVisitor.AddShaderChunk("return " + AdaptNodeOutputForPreview(node, node.GetOutputSlots<MaterialSlot>().First().id) + ";", true);
 
-            template = template.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
-            template = template.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(3));
+            template = template.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetPropertiesBlock(2));
+            template = template.Replace("${ShaderPropertyUsages}", shaderPropertiesVisitor.GetPropertiesDeclaration(3));
             template = template.Replace("${ShaderInputs}", shaderInputVisitor.GetShaderString(4));
             template = template.Replace("${ShaderFunctions}", shaderFunctionVisitor.GetShaderString(3));
             template = template.Replace("${VertexShaderBody}", vertexShaderBlock.GetShaderString(4));

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

+using System;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public abstract class AbstractShaderProperty<T> : ISerializationCallbackReceiver, IShaderProperty
+    {
+        [SerializeField]
+        private T m_Value;
+
+        [SerializeField]
+        private string m_Description;
+
+        [SerializeField]
+        private string m_Name;
+
+        [NonSerialized]
+        private Guid m_Guid;
+
+        [SerializeField]
+        private string m_GuidSerialized;
+
+        [SerializeField]
+        private bool m_GeneratePropertyBlock = true;
+
+        protected AbstractShaderProperty()
+        {
+            m_Guid = Guid.NewGuid();
+        }
+
+        public T value
+        {
+            get { return m_Value; }
+            set { m_Value = value; }
+        }
+
+        public string name
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(m_Name))
+                    return m_Guid.ToString();
+                return m_Name;
+            }
+            set { m_Name = value; }
+        }
+
+        public string description
+        {
+            get
+            {
+                return string.IsNullOrEmpty(m_Description) ? name : m_Description;
+            }
+            set { m_Description = value; }
+        }
+
+        public abstract PropertyType propertyType { get; }
+
+        public Guid guid
+        {
+            get { return m_Guid; }
+        }
+
+        public bool generatePropertyBlock
+        {
+            get { return m_GeneratePropertyBlock; }
+            set { m_GeneratePropertyBlock = value; }
+        }
+
+        public abstract string GetPropertyBlockString();
+        public abstract string GetPropertyDeclarationString();
+        public abstract PreviewProperty GetPreviewMaterialProperty();
+
+        public virtual void OnBeforeSerialize()
+        {
+            m_GuidSerialized = m_Guid.ToString();
+        }
+
+        public virtual void OnAfterDeserialize()
+        {
+            if (!string.IsNullOrEmpty(m_GuidSerialized))
+                m_Guid = new Guid(m_GuidSerialized);
+            else
+                m_Guid = Guid.NewGuid();
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: b1411039ed1342fa8efff6fa8a4c179d
+timeCreated: 1505346915

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

+using System;
+using System.Text;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class ColorShaderProperty : AbstractShaderProperty<Color>
+    {
+        [SerializeField]
+        private bool m_HDR;
+
+        public bool HDR
+        {
+            get { return m_HDR; }
+            set
+            {
+                if (m_HDR == value)
+                    return;
+
+                m_HDR = value;
+            }
+        }
+
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Color; }
+        }
+
+        public override string GetPropertyBlockString()
+        {
+            if (!generatePropertyBlock)
+                return string.Empty;
+
+            var result = new StringBuilder();
+            if (HDR)
+                result.Append("[HDR]");
+            result.Append(name);
+            result.Append("(\"");
+            result.Append(description);
+            result.Append("\", Color) = (");
+            result.Append(value.r);
+            result.Append(",");
+            result.Append(value.g);
+            result.Append(",");
+            result.Append(value.b);
+            result.Append(",");
+            result.Append(value.a);
+            result.Append(")");
+            return result.ToString();
+        }
+
+        public override string GetPropertyDeclarationString()
+        {
+            return "float4 " + name + ";";
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty
+            {
+                m_Name = name,
+                m_PropType = PropertyType.Color,
+                m_Color = value
+            };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 47cf9e64b21b48b09320f42eb82ac3c3
+timeCreated: 1505346940

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

+using System;
+using System.Text;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class FloatShaderProperty : AbstractShaderProperty<float>
+    {
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Float; }
+        }
+
+        public override string GetPropertyBlockString()
+        {
+            var result = new StringBuilder();
+          //  if (m_FloatType == FloatPropertyChunk.FloatType.Toggle)
+           //     result.Append("[Toggle]");
+          //  else if (m_FloatType == FloatPropertyChunk.FloatType.PowerSlider)
+          //      result.Append("[PowerSlider(" + m_rangeValues.z + ")]");
+            result.Append(name);
+            result.Append("(\"");
+            result.Append(description);
+
+            //if (m_FloatType == FloatPropertyChunk.FloatType.Float || m_FloatType == FloatPropertyChunk.FloatType.Toggle)
+            //{
+                result.Append("\", Float) = ");
+           /* }
+            else if (m_FloatType == FloatPropertyChunk.FloatType.Range || m_FloatType == FloatPropertyChunk.FloatType.PowerSlider)
+            {
+                result.Append("\", Range(");
+                result.Append(m_rangeValues.x + ", " + m_rangeValues.y);
+                result.Append(")) = ");
+            }*/
+            result.Append(value);
+            return result.ToString();
+        }
+
+        public override string GetPropertyDeclarationString()
+        {
+            return "float " + name + ";";
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty()
+            {
+                m_Name = name,
+                m_PropType = PropertyType.Float,
+                m_Float = value
+            };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 572cce24ed76430db4c21dfe82d01252
+timeCreated: 1505346922

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

+using System;
+
+namespace UnityEngine.MaterialGraph
+{
+    public interface IShaderProperty
+    {
+        string name { get; set; }
+        string description { get; set; }
+        PropertyType propertyType { get; }
+        Guid guid { get; }
+        bool generatePropertyBlock { get; set; }
+
+        string GetPropertyBlockString();
+        string GetPropertyDeclarationString();
+        PreviewProperty GetPreviewMaterialProperty();
+    }
+}

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

+fileFormatVersion: 2
+guid: 7594463b49eb4d70a1b938f328f0c0b0
+timeCreated: 1505346909

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

+using System;
+
+namespace UnityEngine.MaterialGraph
+{
+    class SamplerStateShaderProperty : AbstractShaderProperty<TextureSamplerState>
+    {
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.SamplerState; }
+        }
+
+        public override string GetPropertyBlockString()
+        {
+            return string.Empty;
+        }
+
+        public override string GetPropertyDeclarationString()
+        {
+            string ss = name + "_"
+                        + Enum.GetName(typeof(TextureSamplerState.FilterMode), value.filter) + "_"
+                        + Enum.GetName(typeof(TextureSamplerState.WrapMode), value.wrap) + "_sampler;";
+
+            return string.Format(@"
+#ifdef UNITY_COMPILER_HLSL
+SamplerState {0};
+#endif", ss);
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return null;
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: b48a2e97e3e24303833a0062f90f4f13
+timeCreated: 1505436387

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

+using System;
+using UnityEditor;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class SerializableTexture
+    {
+        [SerializeField] private string m_SerializedTexture;
+
+        [Serializable]
+        private class TextureHelper
+        {
+            public Texture texture;
+        }
+
+#if UNITY_EDITOR
+        public Texture texture
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(m_SerializedTexture))
+                    return null;
+
+                var tex = new TextureHelper();
+                EditorJsonUtility.FromJsonOverwrite(m_SerializedTexture, tex);
+                return tex.texture;
+            }
+            set
+            {
+                if (texture == value)
+                    return;
+
+                var tex = new TextureHelper();
+                tex.texture = value;
+                m_SerializedTexture = EditorJsonUtility.ToJson(tex, true);
+            }
+        }
+#else
+        public Texture defaultTexture {get; set; }
+#endif
+
+    }
+}

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

+fileFormatVersion: 2
+guid: a4a4ff926ce74b059400bb049aefcba2
+timeCreated: 1505346945

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

+namespace UnityEngine.MaterialGraph
+{
+    public class TextureSamplerState
+    {
+        public enum FilterMode
+        {
+            Linear,
+            Point
+        }
+
+        public enum WrapMode
+        {
+            Repeat,
+            Clamp
+        }
+
+        [SerializeField] private FilterMode m_filter = FilterMode.Linear;
+
+        public FilterMode filter
+        {
+            get { return m_filter; }
+            set
+            {
+                if (m_filter == value)
+                    return;
+
+                m_filter = value;
+            }
+        }
+
+        [SerializeField] private WrapMode m_wrap = WrapMode.Repeat;
+
+        public WrapMode wrap
+        {
+            get { return m_wrap; }
+            set
+            {
+                if (m_wrap == value)
+                    return;
+
+                m_wrap = value;
+            }
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: a0238123ffe44c05bc05acf347c4d52d
+timeCreated: 1505436371

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

+using System;
+using System.Text;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class TextureShaderProperty : AbstractShaderProperty<SerializableTexture>
+    {
+        [SerializeField]
+        private bool m_Modifiable;
+
+        public TextureShaderProperty()
+        {
+            value = new SerializableTexture();
+        }
+
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Texture; }
+        }
+
+        public bool modifiable
+        {
+            get { return m_Modifiable; }
+            set { m_Modifiable = value; }
+        }
+
+        public override string GetPropertyBlockString()
+        {
+            var result = new StringBuilder();
+            if (!m_Modifiable)
+            {
+                result.Append("[HideInInspector] ");
+                result.Append("[NonModifiableTextureData] ");
+            }
+            result.Append("[NoScaleOffset] ");
+
+            result.Append(name);
+            result.Append("(\"");
+            result.Append(description);
+            result.Append("\", 2D) = \"");
+            result.Append(Enum.GetName(typeof(TextureType), value.texture).ToLower());
+            result.Append("\" {}");
+            return result.ToString();
+        }
+
+        public override string GetPropertyDeclarationString()
+        {
+            return "UNITY_DECLARE_TEX2D(" + name + ");";
+        }
+
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty()
+            {
+                m_Name = name,
+                m_PropType = PropertyType.Texture,
+                m_Texture = value.texture
+            };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 08e62564fb95471d9580619b660c6531
+timeCreated: 1505346949

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

+using System;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class Vector2ShaderProperty : VectorShaderProperty
+    {
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Vector2; }
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty()
+            {
+                m_Name = name,
+                m_PropType = PropertyType.Vector2,
+                m_Vector4 = value
+            };
+        }
+
+    }
+}

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

+fileFormatVersion: 2
+guid: dbd5691737554a15ab0b098fca999382
+timeCreated: 1505346926

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

+using System;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class Vector3ShaderProperty : VectorShaderProperty
+    {
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Vector3; }
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty()
+            {
+                m_Name = name,
+                m_PropType = PropertyType.Vector3,
+                m_Vector4 = value
+            };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 34a68571f5ae4ebe8221824597dc0675
+timeCreated: 1505346931

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

+using System;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class Vector4ShaderProperty : VectorShaderProperty
+    {
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.Vector4; }
+        }
+
+        public override PreviewProperty GetPreviewMaterialProperty()
+        {
+            return new PreviewProperty()
+            {
+                m_Name = name,
+                m_PropType = PropertyType.Vector4,
+                m_Vector4 = value
+            };
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 3989871719194dbdba09613ac74761b3
+timeCreated: 1505346935

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

+using System;
+using System.Text;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public abstract class VectorShaderProperty : AbstractShaderProperty<Vector4>
+    {
+        public override string GetPropertyBlockString()
+        {
+            var result = new StringBuilder();
+            result.Append(name);
+            result.Append("(\"");
+            result.Append(description);
+            result.Append("\", Vector) = (");
+            result.Append(value.x);
+            result.Append(",");
+            result.Append(value.y);
+            result.Append(",");
+            result.Append(value.z);
+            result.Append(",");
+            result.Append(value.w);
+            result.Append(")");
+            return result.ToString();
+        }
+
+        public override string GetPropertyDeclarationString()
+        {
+            return "float4 " + name + ";";
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 4f83ebb04c5c4df184601ef18aa7d89d
+timeCreated: 1505408377

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

+using System;
+using System.Collections.Generic;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public class MasterNode : AbstractMaterialNode
+    {
+        protected override bool generateDefaultInputs { get { return false; } }
+
+        public override IEnumerable<ISlot> GetInputsWithNoConnection()
+        {
+            return new List<ISlot>();
+        }
+
+        public override bool hasPreview
+        {
+            get { return true; }
+        }
+
+        public override bool allowedInSubGraph
+        {
+            get { return false; }
+        }
+
+        public virtual bool has3DPreview()
+        {
+            return true;
+        }
+    }
+}

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

+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace UnityEngine.MaterialGraph
+{
+    public class PropertyCollector
+    {
+        public struct TextureInfo
+        {
+            public string name;
+            public int textureId;
+            public bool modifiable;
+        }
+
+        private readonly List<IShaderProperty> m_Properties = new List<IShaderProperty>();
+
+        public void AddShaderProperty(IShaderProperty chunk)
+        {
+            if (m_Properties.Any(x => x.name == chunk.name))
+                return;
+            m_Properties.Add(chunk);
+        }
+
+        public string GetPropertiesBlock(int baseIndentLevel)
+        {
+            var sb = new StringBuilder();
+            foreach (var prop in m_Properties)
+            {
+                for (var i = 0; i < baseIndentLevel; i++)
+                    sb.Append("\t");
+                sb.AppendLine(prop.GetPropertyBlockString());
+            }
+            return sb.ToString();
+        }
+
+        public string GetPropertiesDeclaration(int baseIndentLevel)
+        {
+            var sb = new StringBuilder();
+            foreach (var prop in m_Properties)
+            {
+                for (var i = 0; i < baseIndentLevel; i++)
+                    sb.Append("\t");
+                sb.AppendLine(prop.GetPropertyDeclarationString());
+            }
+            return sb.ToString();
+        }
+
+        public List<TextureInfo> GetConfiguredTexutres()
+        {
+            var result = new List<TextureInfo>();
+
+            foreach (var prop in m_Properties.OfType<TextureShaderProperty>())
+            {
+                if (prop.name != null)
+                {
+                    var textureInfo = new TextureInfo
+                    {
+                        name = prop.name,
+                        textureId = prop.value.texture != null ? prop.value.texture.GetInstanceID() : 0,
+                        modifiable = prop.modifiable
+                    };
+                    result.Add(textureInfo);
+                }
+            }
+            return result;
+        }
+    }
+}

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

-using System;
-using System.Collections.Generic;
-using UnityEngine.Graphing;
-
-namespace UnityEngine.MaterialGraph
-{
-    [Serializable]
-    public abstract class AbstractMasterNode : AbstractMaterialNode, IMasterNode
-    {
-        protected override bool generateDefaultInputs { get { return false; } }
-
-        public override IEnumerable<ISlot> GetInputsWithNoConnection()
-        {
-            return new List<ISlot>();
-        }
-
-        public override bool hasPreview
-        {
-            get { return true; }
-        }
-
-        public override bool allowedInSubGraph
-        {
-            get { return false; }
-        }
-
-        public bool isActiveMaster
-        {
-            get
-            {
-                var graph = owner as MaterialGraph;
-                return graph != null && graph.masterNode == this;
-            }
-            set
-            {
-                var graph = owner as MaterialGraph;
-                if (graph == null || value == isActiveMaster)
-                    return;
-                graph.masterNode = value ? this : null;
-            }
-        }
-
-        public bool canBeActiveMaster
-        {
-            get { return owner is MaterialGraph; }
-        }
-
-        public abstract string GetFullShader(GenerationMode mode, string name, out List<PropertyGenerator.TextureInfo> configuredTextures);
-        public abstract string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor);
-
-        public virtual bool has3DPreview()
-        {
-            return true;
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Util/ColorPropertyChunk.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Util/FloatPropertyChunk.cs.meta

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

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

-namespace UnityEngine.MaterialGraph
-{
-    public abstract class PropertyChunk
-    {
-        public enum HideState
-        {
-            Hidden,
-            Visible
-        }
-
-        private readonly string m_PropertyName;
-        private readonly string m_PropertyDescription;
-        private readonly HideState m_HideState;
-
-        protected PropertyChunk(string propertyName, string propertyDescription, HideState hideState)
-        {
-            m_PropertyName = propertyName;
-            m_PropertyDescription = propertyDescription;
-            m_HideState = hideState;
-        }
-
-        public abstract string GetPropertyString();
-        public string propertyName { get { return m_PropertyName; } }
-        public string propertyDescription { get { return m_PropertyDescription; } }
-        public HideState hideState { get { return m_HideState; } }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Util/PropertyChunk.cs.meta

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

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

-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace UnityEngine.MaterialGraph
-{
-    public class PropertyGenerator
-    {
-        public struct TextureInfo
-        {
-            public string name;
-            public int textureId;
-            public TexturePropertyChunk.ModifiableState modifiable;
-        }
-
-        private readonly List<PropertyChunk> m_Properties = new List<PropertyChunk>();
-
-        public void AddShaderProperty(PropertyChunk chunk)
-        {
-            if (m_Properties.Any(x => x.propertyName == chunk.propertyName))
-                return;
-            m_Properties.Add(chunk);
-        }
-
-        public string GetShaderString(int baseIndentLevel)
-        {
-            var sb = new StringBuilder();
-            foreach (var prop in m_Properties)
-            {
-                for (var i = 0; i < baseIndentLevel; i++)
-                    sb.Append("\t");
-                sb.AppendLine(prop.GetPropertyString());
-            }
-            return sb.ToString();
-        }
-
-        public List<TextureInfo> GetConfiguredTexutres()
-        {
-            var result = new List<TextureInfo>();
-
-            foreach (var prop in m_Properties.OfType<TexturePropertyChunk>())
-            {
-                if (prop.propertyName != null)
-                {
-                    var textureInfo = new TextureInfo
-                    {
-                        name = prop.propertyName,
-                        textureId = prop.defaultTexture != null ? prop.defaultTexture.GetInstanceID() : 0,
-                        modifiable = prop.modifiableState
-                    };
-                    result.Add(textureInfo);
-                }
-            }
-            return result;
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Util/TexturePropertyChunk.cs.meta

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

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

-using System.Text;
-
-namespace UnityEngine.MaterialGraph
-{
-    public class VectorPropertyChunk : PropertyChunk
-    {
-        private readonly Vector4 m_DefaultVector;
-
-        public VectorPropertyChunk(string propertyName, string propertyDescription, Vector4 defaultVector, HideState hideState)
-            : base(propertyName, propertyDescription, hideState)
-        {
-            m_DefaultVector = defaultVector;
-        }
-
-        public Vector4 defaultValue
-        {
-            get { return m_DefaultVector; }
-        }
-
-        public override string GetPropertyString()
-        {
-            var result = new StringBuilder();
-            result.Append(propertyName);
-            result.Append("(\"");
-            result.Append(propertyDescription);
-            result.Append("\", Vector) = (");
-            result.Append(defaultValue.x);
-            result.Append(",");
-            result.Append(defaultValue.y);
-            result.Append(",");
-            result.Append(defaultValue.z);
-            result.Append(",");
-            result.Append(defaultValue.w);
-            result.Append(")");
-            return result.ToString();
-        }
-    }
-}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Util/VectorPropertyChunk.cs.meta

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

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

-using System.Text;
-
-namespace UnityEngine.MaterialGraph
-{
-    public class ColorPropertyChunk : PropertyChunk
-    {
-        public enum ColorType
-        {
-            Default,
-            HDR
-        }
-
-        private Color m_DefaultColor;
-        private ColorType m_colorType;
-
-        public ColorPropertyChunk(string propertyName, string propertyDescription, Color defaultColor, ColorType colorType, HideState hideState)
-            : base(propertyName, propertyDescription, hideState)
-        {
-            m_colorType = colorType;
-            m_DefaultColor = defaultColor;
-        }
-
-        public Color defaultColor
-        {
-            get { return m_DefaultColor; }
-        }
-
-        public override string GetPropertyString()
-        {
-            var result = new StringBuilder();
-            if (m_colorType == ColorType.HDR)
-                result.Append("[HDR]");
-            result.Append(propertyName);
-            result.Append("(\"");
-            result.Append(propertyDescription);
-            result.Append("\", Color) = (");
-            result.Append(defaultColor.r);
-            result.Append(",");
-            result.Append(defaultColor.g);
-            result.Append(",");
-            result.Append(defaultColor.b);
-            result.Append(",");
-            result.Append(defaultColor.a);
-            result.Append(")");
-            return result.ToString();
-        }
-    }
-}

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

-using System.Text;
-
-namespace UnityEngine.MaterialGraph
-{
-    public class FloatPropertyChunk : PropertyChunk
-    {
-        public enum FloatType
-        {
-            Float,
-            Toggle,
-            Range,
-            PowerSlider
-        }
-
-        private readonly float m_DefaultValue;
-        private readonly FloatType m_FloatType;
-        private readonly Vector3 m_rangeValues;
-
-        public FloatPropertyChunk(string propertyName, string propertyDescription, float defaultValue, HideState hideState)
-            : base(propertyName, propertyDescription, hideState)
-        {
-            m_DefaultValue = defaultValue;
-        }
-
-        public FloatPropertyChunk(string propertyName, string propertyDescription, float defaultValue, FloatType floatType, HideState hideState)
-            : base(propertyName, propertyDescription, hideState)
-        {
-            m_FloatType = floatType;
-            m_DefaultValue = defaultValue;
-        }
-
-        public FloatPropertyChunk(string propertyName, string propertyDescription, float defaultValue, FloatType floatType, Vector3 rangeValues, HideState hideState)
-            : base(propertyName, propertyDescription, hideState)
-        {
-            m_FloatType = floatType;
-            m_rangeValues = rangeValues;
-            m_DefaultValue = defaultValue;
-        }
-
-        public float defaultValue
-        {
-            get { return m_DefaultValue; }
-        }
-
-        public override string GetPropertyString()
-        {
-            var result = new StringBuilder();
-            if (m_FloatType == FloatType.Toggle)
-                result.Append("[Toggle]");
-            else if (m_FloatType == FloatType.PowerSlider)
-                result.Append("[PowerSlider(" + m_rangeValues.z + ")]");
-            result.Append(propertyName);
-            result.Append("(\"");
-            result.Append(propertyDescription);
-
-            if (m_FloatType == FloatType.Float || m_FloatType == FloatType.Toggle)
-            {
-                result.Append("\", Float) = ");
-            }
-            else if (m_FloatType == FloatType.Range || m_FloatType == FloatType.PowerSlider)
-            {
-                result.Append("\", Range(");
-                result.Append(m_rangeValues.x + ", " + m_rangeValues.y);
-                result.Append(")) = ");
-            }
-            result.Append(defaultValue);
-            return result.ToString();
-        }
-    }
-}

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

-using System;
-using System.Text;
-
-namespace UnityEngine.MaterialGraph
-{
-    public class TexturePropertyChunk : PropertyChunk
-    {
-        public enum ModifiableState
-        {
-            Modifiable,
-            NonModifiable
-        }
-
-        private readonly Texture m_DefaultTexture;
-        private readonly TextureType m_DefaultTextureType;
-        private readonly ModifiableState m_Modifiable;
-
-        public TexturePropertyChunk(string propertyName, string propertyDescription, Texture defaultTexture, TextureType defaultTextureType, HideState hidden, ModifiableState modifiableState)
-            : base(propertyName, propertyDescription, hidden)
-        {
-            m_DefaultTexture = defaultTexture;
-            m_DefaultTextureType = defaultTextureType;
-            m_Modifiable = modifiableState;
-        }
-
-        public override string GetPropertyString()
-        {
-            var result = new StringBuilder();
-            if (hideState == HideState.Hidden)
-                result.Append("[HideInInspector] ");
-            if (m_Modifiable == ModifiableState.NonModifiable)
-                result.Append("[NonModifiableTextureData] ");
-            result.Append("[NoScaleOffset] ");
-
-            result.Append(propertyName);
-            result.Append("(\"");
-            result.Append(propertyDescription);
-            result.Append("\", 2D) = \"");
-            result.Append(Enum.GetName(typeof(TextureType), m_DefaultTextureType).ToLower());
-            result.Append("\" {}");
-            return result.ToString();
-        }
-
-        public Texture defaultTexture
-        {
-            get
-            {
-                return m_DefaultTexture;
-            }
-        }
-        public ModifiableState modifiableState
-        {
-            get
-            {
-                return m_Modifiable;
-            }
-        }
-    }
-}