[shadergraph]Make export button that works.

UnityProject/Assets/UnityShaderEditor/Editor/Source/Drawing/MaterialGraphDataSource.cs

-using System.Collections.Generic;
-using System.Linq;
-using UnityEditor.Experimental;
-using UnityEditor.Experimental.Graph;
-using UnityEngine;
-
-namespace UnityEditor.MaterialGraph
-{
-    public class MaterialGraphDataSource : ICanvasDataSource
-    {
-        readonly List<DrawableMaterialNode> m_DrawableNodes = new List<DrawableMaterialNode>();
-        
-        public MaterialGraph graph { get; set; }
-
-        public ICollection<DrawableMaterialNode> lastGeneratedNodes
-        {
-            get { return m_DrawableNodes; }
-        }
-
-        public CanvasElement[] FetchElements()
-        {
-            m_DrawableNodes.Clear();
-            Debug.Log("trying to convert");
-            var pixelGraph = graph.currentGraph;
-            foreach (var node in pixelGraph.nodes)
-            {
-                // add the nodes
-                var bmn = node as BaseMaterialNode;
-                m_DrawableNodes.Add(new DrawableMaterialNode(bmn, (bmn is PixelShaderNode) ? 600.0f : 200.0f, typeof(Vector4), this));
-            }
-
-            // Add the edges now
-            var drawableEdges = new List<Edge<NodeAnchor>>();
-            foreach (var drawableMaterialNode in m_DrawableNodes)
-            {
-                var baseNode = drawableMaterialNode.m_Node;
-                foreach (var slot in baseNode.outputSlots)
-                {
-                    var sourceAnchor =  (NodeAnchor)drawableMaterialNode.Children().FirstOrDefault(x => x is NodeAnchor && ((NodeAnchor) x).m_Slot == slot);
-
-                    foreach (var edge in slot.edges)
-                    {
-                        var targetNode = m_DrawableNodes.FirstOrDefault(x => x.m_Node == edge.toSlot.node);
-                        var targetAnchor = (NodeAnchor)targetNode.Children().FirstOrDefault(x => x is NodeAnchor && ((NodeAnchor) x).m_Slot == edge.toSlot);
-                        drawableEdges.Add(new Edge<NodeAnchor>(this, sourceAnchor, targetAnchor));
-                    }
-                }
-            }
-            
-            var toReturn = new List<CanvasElement>();
-            toReturn.AddRange(m_DrawableNodes.Select(x => (CanvasElement)x));
-            toReturn.AddRange(drawableEdges.Select(x => (CanvasElement)x));
-            
-            Debug.LogFormat("REturning {0} nodes", toReturn.Count);
-            return toReturn.ToArray();
-        }
-
-        public void DeleteElement(CanvasElement e)
-        {
-            Debug.Log("Trying to delete " + e);
-  
-            if (e is Edge<NodeAnchor>)
-            {
-                //find the edge
-                var localEdge = (Edge<NodeAnchor>) e;
-                var edge = graph.currentGraph.edges.FirstOrDefault(x => x.fromSlot == localEdge.Left.m_Slot && x.toSlot == localEdge.Right.m_Slot);
-                
-                Debug.Log("Deleting edge " + edge);
-                graph.currentGraph.RemoveEdge(edge);
-            }
-            else if (e is DrawableMaterialNode)
-            {
-                Debug.Log("Deleting node " + e + " " + ((DrawableMaterialNode) e).m_Node);
-                graph.currentGraph.RemoveNode(((DrawableMaterialNode) e).m_Node);
-            }
-
-            e.ParentCanvas().ReloadData();
-            e.ParentCanvas().Repaint();
-        }
-
-        public void Connect(NodeAnchor a, NodeAnchor b)
-        {
-            var pixelGraph = graph.currentGraph;
-            pixelGraph.Connect(a.m_Slot, b.m_Slot);
-        }
-    }
-}
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor.Experimental;
+using UnityEditor.Experimental.Graph;
+using UnityEngine;
+
+namespace UnityEditor.MaterialGraph
+{
+    public class MaterialGraphDataSource : ICanvasDataSource
+    {
+        readonly List<DrawableMaterialNode> m_DrawableNodes = new List<DrawableMaterialNode>();
+        
+        public MaterialGraph graph { get; set; }
+
+        public ICollection<DrawableMaterialNode> lastGeneratedNodes
+        {
+            get { return m_DrawableNodes; }
+        }
+
+        public CanvasElement[] FetchElements()
+        {
+            m_DrawableNodes.Clear();
+            Debug.Log("trying to convert");
+            var pixelGraph = graph.currentGraph;
+            foreach (var node in pixelGraph.nodes)
+            {
+                // add the nodes
+                var bmn = node as BaseMaterialNode;
+                m_DrawableNodes.Add(new DrawableMaterialNode(bmn, (bmn is PixelShaderNode) ? 600.0f : 200.0f, typeof(Vector4), this));
+            }
+
+            // Add the edges now
+            var drawableEdges = new List<Edge<NodeAnchor>>();
+            foreach (var drawableMaterialNode in m_DrawableNodes)
+            {
+                var baseNode = drawableMaterialNode.m_Node;
+                foreach (var slot in baseNode.outputSlots)
+                {
+                    var sourceAnchor =  (NodeAnchor)drawableMaterialNode.Children().FirstOrDefault(x => x is NodeAnchor && ((NodeAnchor) x).m_Slot == slot);
+
+                    foreach (var edge in slot.edges)
+                    {
+                        var targetNode = m_DrawableNodes.FirstOrDefault(x => x.m_Node == edge.toSlot.node);
+                        var targetAnchor = (NodeAnchor)targetNode.Children().FirstOrDefault(x => x is NodeAnchor && ((NodeAnchor) x).m_Slot == edge.toSlot);
+                        drawableEdges.Add(new Edge<NodeAnchor>(this, sourceAnchor, targetAnchor));
+                    }
+                }
+            }
+            
+            var toReturn = new List<CanvasElement>();
+            toReturn.AddRange(m_DrawableNodes.Select(x => (CanvasElement)x));
+            toReturn.AddRange(drawableEdges.Select(x => (CanvasElement)x));
+            
+            Debug.LogFormat("REturning {0} nodes", toReturn.Count);
+            return toReturn.ToArray();
+        }
+
+        public void DeleteElement(CanvasElement e)
+        {
+            Debug.Log("Trying to delete " + e);
+  
+            if (e is Edge<NodeAnchor>)
+            {
+                //find the edge
+                var localEdge = (Edge<NodeAnchor>) e;
+                var edge = graph.currentGraph.edges.FirstOrDefault(x => x.fromSlot == localEdge.Left.m_Slot && x.toSlot == localEdge.Right.m_Slot);
+                
+                Debug.Log("Deleting edge " + edge);
+                graph.currentGraph.RemoveEdge(edge);
+            }
+            else if (e is DrawableMaterialNode)
+            {
+                Debug.Log("Deleting node " + e + " " + ((DrawableMaterialNode) e).m_Node);
+                graph.currentGraph.RemoveNode(((DrawableMaterialNode) e).m_Node);
+            }
+
+            e.ParentCanvas().ReloadData();
+            e.ParentCanvas().Repaint();
+        }
+
+        public void Connect(NodeAnchor a, NodeAnchor b)
+        {
+            var pixelGraph = graph.currentGraph;
+            pixelGraph.Connect(a.m_Slot, b.m_Slot);
+        }
+
+        private string m_LastPath;
+        public void Export(bool quickExport)
+        {
+            var path = quickExport ? m_LastPath : EditorUtility.SaveFilePanelInProject("Export shader to file...", "shader.shader", "shader", "Enter file name");
+            m_LastPath = path; // For quick exporting
+            if (!string.IsNullOrEmpty(path))
+                graph.ExportShader(path);
+            else
+                EditorUtility.DisplayDialog("Export Shader Error", "Cannot export shader", "Ok");
+        }
+    }
+}

UnityProject/Assets/UnityShaderEditor/Editor/Source/Drawing/MaterialWindow.cs

             EditorGUILayout.BeginHorizontal();
             GUILayout.FlexibleSpace();
 
+            EditorGUILayout.BeginVertical();
             m_ScrollPos = GUILayout.BeginScrollView(m_ScrollPos, EditorStyles.textArea, GUILayout.Width(250), GUILayout.ExpandHeight(true));
             graph.materialOptions.DoGUI();
             EditorGUILayout.Separator();
             if (m_NodeExpanded)
                 DrawableMaterialNode.OnGUI(m_Canvas.Selection);
-
+      
+            if (GUILayout.Button("Export"))
+                m_DataSource.Export(false);
+
+            GUILayout.EndVertical();
             EditorGUILayout.EndHorizontal();
         }
 

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

 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using UnityEngine;
 
             AssetDatabase.AddObjectToAsset(m_MaterialOptions, this);
             AssetDatabase.AddObjectToAsset(m_PixelGraph, this);
         }
-
-
+        
         private Material m_Material;
         public Material GetMaterial()
         {
             return m_PixelGraph.GetMaterial();
+        }
+
+        public void ExportShader(string path)
+        {
+            Dictionary<string, int> defaultTextures;
+            var shaderString = ShaderGenerator.GenerateSurfaceShader(this, name, false, out defaultTextures);
+            File.WriteAllText(path, shaderString);
+            AssetDatabase.Refresh(); // Investigate if this is optimal
+
+            var shader = AssetDatabase.LoadAssetAtPath(path, typeof(Shader)) as Shader;
+            if (shader == null)
+                return;
+
+            var shaderImporter = AssetImporter.GetAtPath(path) as ShaderImporter;
+            if (shaderImporter == null)
+                return;
+
+            var textureNames = new List<string>();
+            var textures = new List<Texture>();
+            foreach (var textureInfo in defaultTextures)
+            {
+                var texture = EditorUtility.InstanceIDToObject(textureInfo.Value) as Texture;
+                if (texture == null)
+                    continue;
+                textureNames.Add(textureInfo.Key);
+                textures.Add(texture);
+            }
+            shaderImporter.SetDefaultTextures(textureNames.ToArray(), textures.ToArray());
+            shaderImporter.SaveAndReimport();
         }
     }
 }

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/PixelShaderNode.cs

                 return false;
 
             var shaderName = "Hidden/PreviewShader/" + name + "_" + Math.Abs(GetInstanceID());
-            Dictionary<string, Texture> defaultTextures;
+            Dictionary<string, int> defaultTextures;
             var resultShader = ShaderGenerator.GenerateSurfaceShader(pixelGraph.owner, shaderName, true, out defaultTextures);
             m_GeneratedShaderMode = PreviewMode.Preview3D;
             InternalUpdatePreviewShader(resultShader);

UnityProject/Assets/UnityShaderEditor/Editor/Source/Nodes/TextureNode.cs

 
         // Properties
         public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
-        {}
+        {
+            if (HasBoundProperty())
+                return;
+
+            visitor.AddShaderProperty(new TexturePropertyChunk(GetPropertyName(), GetPropertyName(), m_DefaultTexture, m_TextureType, true));
+        }
 
         public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode, ConcreteSlotValueType slotValueType)
         {

UnityProject/Assets/UnityShaderEditor/Editor/Source/Prop/TextureProperty.cs

 
         public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
         {
-            visitor.AddShaderProperty(new TexturePropertyChunk(name, m_PropertyDescription, m_DefaultTexture,
-                    m_DefaultTextureType, false));
+            visitor.AddShaderProperty(new TexturePropertyChunk(name, m_PropertyDescription, m_DefaultTexture, m_DefaultTextureType, false));
         }
 
         public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode, ConcreteSlotValueType slotValueType)

UnityProject/Assets/UnityShaderEditor/Editor/Source/Util/ShaderGenerator.cs

             return result.ToString();
         }
 
-        public Texture defaultTexture { get { return m_DefaultTexture; } }
+        public Texture defaultTexture
+        {
+            get
+            {
+                int i = 0;
+                ++i;
+                return m_DefaultTexture;
+            }
+        }
     }
 
     public class ColorPropertyChunk : PropertyChunk
             return sb.ToString();
         }
 
-        public Dictionary<string, Texture> GetDefaultTexutres()
+        public Dictionary<string, int> GetDefaultTexutres()
-            var result = new Dictionary<string, Texture>();
+            var result = new Dictionary<string, int>();
-                    result.Add(prop.propertyName, prop.defaultTexture);
+                {
+                    var tex = prop.defaultTexture.GetInstanceID();
+
+                    result.Add(prop.propertyName, tex);
+                }
             }
             return result;
         }
             return template;
         }
 
-        public static string GenerateSurfaceShader(MaterialGraph graph, string shaderName, bool isPreview, out Dictionary<string, Texture> defaultTextures)
+        public static string GenerateSurfaceShader(MaterialGraph graph, string shaderName, bool isPreview, out Dictionary<string, int> defaultTextures)
-                defaultTextures = new Dictionary<string, Texture>();
+                defaultTextures = new Dictionary<string, int>();
                 return string.Empty;
             }
 

UnityProject/UnityProject.sln.DotSettings

 	<s:String x:Key="/Default/CodeStyle/Naming/VBNaming/PredefinedNamingRules/=StaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="s_" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/VBNaming/PredefinedNamingRules/=TypeParameters/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="T" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/VBNaming/PredefinedNamingRules/=TypesAndNamespaces/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

UnityProject/Assets/UnityShaderEditor/Editor/Source/Drawing/MaterialGraphStyles.cs

+using UnityEngine;
+
+namespace UnityEditor.MaterialGraph
+{
+    public class MaterialGraphStyles
+    {
+        private static MaterialGraphStyles s_Styles;
+
+        private const float kHeadingSpace = 22.0f;
+        private readonly GUIStyle m_Header = "ShurikenModuleTitle";
+        
+        private MaterialGraphStyles()
+        {
+            m_Header.font = (new GUIStyle("Label")).font;
+            m_Header.border = new RectOffset(15, 7, 4, 4);
+            m_Header.fixedHeight = kHeadingSpace;
+            m_Header.contentOffset = new Vector2(20f, -2f);
+        }
+
+        private static MaterialGraphStyles styles
+        {
+            get { return s_Styles ?? (s_Styles = new MaterialGraphStyles()); }
+        }
+        
+        public static bool DoDrawDefaultInspector(SerializedObject obj)
+        {
+            EditorGUI.BeginChangeCheck();
+            obj.Update();
+
+            // Loop through properties and create one field (including children) for each top level property.
+            SerializedProperty property = obj.GetIterator();
+            bool expanded = true;
+            while (property.NextVisible(expanded))
+            {
+                EditorGUI.BeginDisabledGroup("m_Script" == property.propertyPath);
+                EditorGUILayout.PropertyField(property, true);
+                EditorGUI.EndDisabledGroup();
+                expanded = false;
+            }
+
+            obj.ApplyModifiedProperties();
+            return EditorGUI.EndChangeCheck();
+        }
+
+        public static bool Header(string title, bool display)
+        {
+            GUILayout.Box(title, styles.m_Header);
+
+            var rect = GUILayoutUtility.GetLastRect();
+
+            Rect toggleRect = new Rect(rect.x + 4f, rect.y + 2f, 13f, 13f);
+            if (Event.current.type == EventType.Repaint)
+                EditorStyles.foldout.Draw(toggleRect, false, false, display, false);
+
+            Event e = Event.current;
+            if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
+            {
+                display = !display;
+                e.Use();
+            }
+            return display;
+        }
+    }
+}

UnityProject/Assets/UnityShaderEditor/Editor/Source/Drawing/MaterialGraphStyles.cs.meta

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

UnityProject/Assets/StandaredAssetJazz/ImageEffects.meta

-fileFormatVersion: 2
-guid: 0d6ddd252915e0644ace6732c35612a9
-folderAsset: yes
-DefaultImporter:
-  userData: 
-  assetBundleName: