tidy up new nodes for upgrading.

MaterialGraphProject/Assets/SphereDent.ShaderGraph.meta

 fileFormatVersion: 2
 guid: b63da350811f7ba48914e852a299204c
-timeCreated: 1500715026
+timeCreated: 1500770532
 licenseType: Pro
 ShaderImporter:
   defaultTextures: []

MaterialGraphProject/Assets/UnityShaderEditor/Editor.meta

 folderAsset: yes
 DefaultImporter:
   userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/GeneratedShader.shader

+Shader "Hidden/PreviewShader/Sin_5540BA00_result" {
+	Properties {
+
+	}	
+	
+	SubShader {
+		// inside SubShader
+		Tags
+		{
+			"Queue"="Geometry"
+			"RenderType"="Opaque"
+			"IgnoreProjector"="True"
+		}
+
+		// inside Pass
+		ZWrite On
+
+		Blend One Zero
+		
+		Pass {
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#include "UnityCG.cginc"
+
+
+
+
+			struct v2f 
+			{
+				float4 pos : SV_POSITION;
+				float4 color : COLOR;
+
+			};
+
+
+			void Unity_Sin_float(float argument, out float result)
+			{
+			    result = sin(argument);
+			}
+
+
+			v2f vert (appdata_full v) 
+			{
+				v2f o = (v2f)0;
+				o.pos = UnityObjectToClipPos(v.vertex);;
+				float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
+				float3 viewDir = UnityWorldSpaceViewDir(worldPos);
+				float4 screenPos = ComputeScreenPos(UnityObjectToClipPos(v.vertex));
+				float3 worldNormal = UnityObjectToWorldNormal(v.normal);
+
+				return o;
+			}
+
+			half4 frag (v2f IN) : COLOR
+			{
+				float Sin_5540BA00_result;
+				Unity_Sin_float(_Time.y, Sin_5540BA00_result);
+				return half4(Sin_5540BA00_result, Sin_5540BA00_result, Sin_5540BA00_result, 1.0);
+
+			}
+			ENDCG
+		}
+	}
+	Fallback Off
+}

MaterialGraphProject/Assets/GeneratedShader.shader.meta

+fileFormatVersion: 2
+guid: 4afc3341bed83d34cb1aebb7e98d8751
+timeCreated: 1500713419
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/AbstractGraphEditWindow.cs.orig

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using RMGUI.GraphView;
+using UnityEngine;
+using UnityEngine.Graphing;
+using UnityEngine.Experimental.UIElements;
+using UnityEngine.MaterialGraph;
+using Object = UnityEngine.Object;
+
+namespace UnityEditor.Graphing.Drawing
+{
+    public abstract class AbstractGraphEditWindow : EditorWindow, ISerializationCallbackReceiver
+    {
+        public abstract IGraphAsset inMemoryAsset { get; set; }
+        public abstract Object selected { get; set; }
+
+		public static bool allowAlwaysRepaint = true;
+
+        private bool shouldRepaint
+        {
+            get
+            {
+				return allowAlwaysRepaint && inMemoryAsset != null && inMemoryAsset.shouldRepaint;
+            }
+        }
+
+        protected GraphView graphView
+        {
+            get { return m_GraphEditorDrawer.graphView; }
+        }
+
+        private GraphEditorDrawer m_GraphEditorDrawer;
+
+        public virtual AbstractGraphPresenter CreateDataSource()
+        {
+            return CreateInstance<SerializedGraphPresenter>();
+        }
+
+        public virtual GraphView CreateGraphView()
+        {
+            return new SerializableGraphView();
+        }
+
+        void OnEnable()
+        {
+            m_GraphEditorDrawer = new GraphEditorDrawer(CreateGraphView());
+            rootVisualContainer.AddChild(m_GraphEditorDrawer);
+            var source = CreateDataSource();
+            source.Initialize(inMemoryAsset, this);
+            m_GraphEditorDrawer.presenter = source;
+        }
+
+        void OnDisable()
+        {
+            rootVisualContainer.ClearChildren();
+        }
+
+        void Update()
+        {
+            if (shouldRepaint)
+                Repaint();
+        }
+
+		public void PingAsset()
+		{
+			if (selected != null)
+				EditorGUIUtility.PingObject(selected);
+		}
+
+        public void UpdateAsset()
+        {
+            if (selected != null && inMemoryAsset != null)
+            {
+                var path = AssetDatabase.GetAssetPath(selected);
+                if (string.IsNullOrEmpty(path) || inMemoryAsset == null)
+                {
+                    return;
+                }
+
+                var masterNode = ((MaterialGraphAsset)inMemoryAsset).materialGraph.masterNode;
+                if (masterNode == null)
+                    return;
+
+                List<PropertyGenerator.TextureInfo> configuredTextures;
+<<<<<<< HEAD
+                masterNode.GetFullShader(GenerationMode.ForReals, "NotNeeded", out configuredTextures);
+=======
+                masterNode.GetFullShader(GenerationMode.ForReals, out configuredTextures);
+>>>>>>> hackweek2017
+
+                var shaderImporter = AssetImporter.GetAtPath(path) as ShaderImporter;
+                if (shaderImporter == null)
+                    return;
+
+                var textureNames = new List<string>();
+                var textures = new List<Texture>();
+                foreach (var textureInfo in configuredTextures.Where(
+                    x => x.modifiable == TexturePropertyChunk.ModifiableState.Modifiable))
+                {
+                    var texture = EditorUtility.InstanceIDToObject(textureInfo.textureId) as Texture;
+                    if (texture == null)
+                        continue;
+                    textureNames.Add(textureInfo.name);
+                    textures.Add(texture);
+                }
+                shaderImporter.SetDefaultTextures(textureNames.ToArray(), textures.ToArray());
+
+                textureNames.Clear();
+                textures.Clear();
+                foreach (var textureInfo in configuredTextures.Where(
+                    x => x.modifiable == TexturePropertyChunk.ModifiableState.NonModifiable))
+                {
+                    var texture = EditorUtility.InstanceIDToObject(textureInfo.textureId) as Texture;
+                    if (texture == null)
+                        continue;
+                    textureNames.Add(textureInfo.name);
+                    textures.Add(texture);
+                }
+                shaderImporter.SetNonModifiableTextures(textureNames.ToArray(), textures.ToArray());
+                File.WriteAllText(path, EditorJsonUtility.ToJson(inMemoryAsset.graph));
+                shaderImporter.SaveAndReimport();
+                AssetDatabase.ImportAsset(path);
+
+            }
+        }
+
+        public virtual void ToggleRequiresTime()
+		{
+			allowAlwaysRepaint = !allowAlwaysRepaint;
+		}
+
+		public void ChangeSelction(Object newSelection)
+		{
+			if (!EditorUtility.IsPersistent (newSelection))
+				return;
+
+			if (selected == newSelection)
+				return;
+
+			if (selected != null)
+            {
+				if (EditorUtility.DisplayDialog ("Save Old Graph?", "Save Old Graph?", "yes!", "no")) {
+					UpdateAsset ();
+				}
+			}
+
+			selected = newSelection;
+
+		    var mGraph = CreateInstance<MaterialGraphAsset>();
+		    var path = AssetDatabase.GetAssetPath(newSelection);
+            var textGraph = File.ReadAllText(path, Encoding.UTF8);
+		    mGraph.materialGraph = JsonUtility.FromJson<UnityEngine.MaterialGraph.MaterialGraph>(textGraph);
+
+		    inMemoryAsset = mGraph;
+            var graph = inMemoryAsset.graph;
+			graph.OnEnable ();
+			graph.ValidateGraph ();
+
+			var source = CreateDataSource ();
+			source.Initialize (inMemoryAsset, this) ;
+			m_GraphEditorDrawer.presenter = source;
+<<<<<<< HEAD
+			//m_GraphView.StretchToParentSize();
+			Repaint ();
+			if (refocus)
+			{
+				focused = false;
+				m_GraphEditorDrawer.graphView.Schedule (Focus).StartingIn (1).Until (() => focused);
+			}
+		}
+=======
+            Repaint();
+        }
+>>>>>>> hackweek2017
+
+		public void OnBeforeSerialize()
+		{
+			//m_ToLoad = m_Selected as ScriptableObject;
+		}
+
+		public void OnAfterDeserialize()
+		{}
+
+        /*
+        private void ConvertSelectionToSubGraph()
+        {
+            if (m_Canvas.presenter == null)
+                return;
+
+            var presenter = m_Canvas.presenter as GraphDataSource;
+            if (presenter == null)
+                return;
+
+            var asset = presenter.graphAsset;
+            if (asset == null)
+                return;
+
+            var targetGraph = asset.graph;
+            if (targetGraph == null)
+                return;
+
+            if (!m_Canvas.selection.Any())
+                return;
+
+            var serialzied = CopySelected.SerializeSelectedElements(m_Canvas);
+            var deserialized = CopySelected.DeserializeSelectedElements(serialzied);
+            if (deserialized == null)
+                return;
+
+            string path = EditorUtility.SaveFilePanelInProject("Save subgraph", "New SubGraph", "ShaderSubGraph", "");
+            path = path.Replace(Application.dataPath, "Assets");
+            if (path.Length == 0)
+                return;
+
+            var graphAsset = CreateInstance<MaterialSubGraphAsset>();
+            graphAsset.name = Path.GetFileName(path);
+            graphAsset.PostCreate();
+
+            var graph = graphAsset.subGraph;
+            if (graphAsset.graph == null)
+                return;
+
+            var nodeGuidMap = new Dictionary<Guid, Guid>();
+            foreach (var node in deserialized.GetNodes<INode>())
+            {
+                var oldGuid = node.guid;
+                var newGuid = node.RewriteGuid();
+                nodeGuidMap[oldGuid] = newGuid;
+                graph.AddNode(node);
+            }
+
+            // remap outputs to the subgraph
+            var inputEdgeNeedsRemap = new List<IEdge>();
+            var outputEdgeNeedsRemap = new List<IEdge>();
+            foreach (var edge in deserialized.edges)
+            {
+                var outputSlot = edge.outputSlot;
+                var inputSlot = edge.inputSlot;
+
+                Guid remappedOutputNodeGuid;
+                Guid remappedInputNodeGuid;
+                var outputRemapExists = nodeGuidMap.TryGetValue(outputSlot.nodeGuid, out remappedOutputNodeGuid);
+                var inputRemapExists = nodeGuidMap.TryGetValue(inputSlot.nodeGuid, out remappedInputNodeGuid);
+
+                // pasting nice internal links!
+                if (outputRemapExists && inputRemapExists)
+                {
+                    var outputSlotRef = new SlotReference(remappedOutputNodeGuid, outputSlot.slotId);
+                    var inputSlotRef = new SlotReference(remappedInputNodeGuid, inputSlot.slotId);
+                    graph.Connect(outputSlotRef, inputSlotRef);
+                }
+                // one edge needs to go to outside world
+                else if (outputRemapExists)
+                {
+                    inputEdgeNeedsRemap.Add(edge);
+                }
+                else if (inputRemapExists)
+                {
+                    outputEdgeNeedsRemap.Add(edge);
+                }
+            }
+
+            // we do a grouping here as the same output can
+            // point to multiple inputs
+            var uniqueOutputs = outputEdgeNeedsRemap.GroupBy(edge => edge.outputSlot);
+            var inputsNeedingConnection = new List<KeyValuePair<IEdge, IEdge>>();
+            foreach (var group in uniqueOutputs)
+            {
+                var inputNode = graph.inputNode;
+                var slotId = inputNode.AddSlot();
+
+                var outputSlotRef = new SlotReference(inputNode.guid, slotId);
+
+                foreach (var edge in group)
+                {
+                    var newEdge = graph.Connect(outputSlotRef, new SlotReference(nodeGuidMap[edge.inputSlot.nodeGuid], edge.inputSlot.slotId));
+                    inputsNeedingConnection.Add(new KeyValuePair<IEdge, IEdge>(edge, newEdge));
+                }
+            }
+
+            var uniqueInputs = inputEdgeNeedsRemap.GroupBy(edge => edge.inputSlot);
+            var outputsNeedingConnection = new List<KeyValuePair<IEdge, IEdge>>();
+            foreach (var group in uniqueInputs)
+            {
+                var outputNode = graph.outputNode;
+                var slotId = outputNode.AddSlot();
+
+                var inputSlotRef = new SlotReference(outputNode.guid, slotId);
+
+                foreach (var edge in group)
+                {
+                    var newEdge = graph.Connect(new SlotReference(nodeGuidMap[edge.outputSlot.nodeGuid], edge.outputSlot.slotId), inputSlotRef);
+                    outputsNeedingConnection.Add(new KeyValuePair<IEdge, IEdge>(edge, newEdge));
+                }
+            }
+            AssetDatabase.CreateAsset(graphAsset, path);
+
+            var subGraphNode = new SubGraphNode();
+            targetGraph.AddNode(subGraphNode);
+            subGraphNode.subGraphAsset = graphAsset;
+
+            foreach (var edgeMap in inputsNeedingConnection)
+            {
+                targetGraph.Connect(edgeMap.Key.outputSlot, new SlotReference(subGraphNode.guid, edgeMap.Value.outputSlot.slotId));
+            }
+            foreach (var edgeMap in outputsNeedingConnection)
+            {
+                targetGraph.Connect(new SlotReference(subGraphNode.guid, edgeMap.Value.inputSlot.slotId), edgeMap.Key.inputSlot);
+            }
+
+            var toDelete = m_Canvas.selection.Where(x => x is DrawableNode).ToList();
+            presenter.DeleteElements(toDelete);
+
+            targetGraph.ValidateGraph();
+            m_Canvas.ReloadData();
+            m_Canvas.Invalidate();
+            m_Canvas.selection.Clear();
+
+            var toSelect = m_Canvas.elements.OfType<DrawableNode>().FirstOrDefault(x => x.m_Node == subGraphNode);
+            if (toSelect != null)
+            {
+                toSelect.selected = true;
+                m_Canvas.selection.Add(toSelect);
+            }
+            m_Canvas.Repaint();
+        }*/
+
+
+    }
+}

MaterialGraphProject/Assets/NewNodes/Keep.meta

+fileFormatVersion: 2
+guid: 46cda65b157b245ba8f0fe2271912a9c
+folderAsset: yes
+timeCreated: 1500793639
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/NewNodes/Kill.meta

+fileFormatVersion: 2
+guid: fb228c8240a06467bbf24021de179428
+folderAsset: yes
+timeCreated: 1500793644
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/NewNodes/WIP.meta

-fileFormatVersion: 2
-guid: 1035abaf40f232e4585818283e199b96
-folderAsset: yes
-timeCreated: 1495558038
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/HelperShader.shader

-Shader "UnityEngine.MaterialGraph.ExportTextureMasterNode71166862-083a-4792-8c3a-4111b9dd9d37" 
-{
-	Properties 
-	{
-				Texture_339414d4_3f08_4a60_b7de_60b5078454cd_Uniform("Texture", 2D) = "white" {}
-
-	}	
-	
-	SubShader 
-	{
-		Tags { "Queue"="Geometry" "IgnoreProjector"="True" "RenderType"="Opaque" }
-
-		ZWrite Off
-		Blend One Zero
-		
-		Pass 
-		{
-			CGPROGRAM
-			#include "UnityCustomRenderTexture.cginc"
-		 	#pragma vertex CustomRenderTextureVertexShader
-			#pragma fragment frag
-			#pragma target 4.0
-			
-			v2f_customrendertexture CustomRenderTextureVertexShader_Preview(appdata_base IN)
-			{
-				v2f_customrendertexture OUT;
-				OUT.vertex = UnityObjectToClipPos(IN.vertex);
-				OUT.primitiveID = 0;//TODO
-				OUT.localTexcoord = IN.texcoord;
-				OUT.globalTexcoord = IN.texcoord;
-				OUT.direction = CustomRenderTextureComputeCubeDirection(OUT.globalTexcoord.xy);
-				return OUT;
-			}
-
-			sampler2D Texture_339414d4_3f08_4a60_b7de_60b5078454cd_Uniform;
-
-
-			inline float3 unity_rgbtohsv_float (float3 arg1)
-			{
-				float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-				float4 P = lerp(float4(arg1.bg, K.wz), float4(arg1.gb, K.xy), step(arg1.b, arg1.g));
-				float4 Q = lerp(float4(P.xyw, arg1.r), float4(arg1.r, P.yzx), step(P.x, arg1.r));
-				float D = Q.x - min(Q.w, Q.y);
-				float E = 1e-10;
-				return float3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);
-			}
-			inline float3 unity_hsvtorgb_float (float3 arg1)
-			{
-				float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-				float3 P = abs(frac(arg1.xxx + K.xyz) * 6.0 - K.www);
-				return arg1.z * lerp(K.xxx, saturate(P - K.xxx), arg1.y);
-			}
-
-
-			float4 frag(v2f_customrendertexture IN) : COLOR
-			{
-				half4 uv0 = float4(IN.localTexcoord.xyz,1.0);
-				float4 Split_81de5761_6b38_4350_8ede_9db8ac1d98d0 = float4(_SinTime);
-				float4 Texture_339414d4_3f08_4a60_b7de_60b5078454cd = tex2D (Texture_339414d4_3f08_4a60_b7de_60b5078454cd_Uniform, uv0.xy);
-				float3 RGBtoHSV_6b42522c_e2df_4b64_8142_be2f5cf24530_Output = unity_rgbtohsv_float (Texture_339414d4_3f08_4a60_b7de_60b5078454cd);
-				float4 Split_42661a92_b299_44b2_a9ad_e7a76a22817c = float4(RGBtoHSV_6b42522c_e2df_4b64_8142_be2f5cf24530_Output, 1.0);
-				float4 Combine_8b3bcdf1_2eeb_4f31_a5ca_a4796ceb5066_Output = float4(Split_81de5761_6b38_4350_8ede_9db8ac1d98d0.r,Split_42661a92_b299_44b2_a9ad_e7a76a22817c.g,Split_42661a92_b299_44b2_a9ad_e7a76a22817c.b,0.0);
-				float3 HSVtoRGB_e30c457c_26fb_4e7c_847e_fb4e9cb55bb6_Output = unity_hsvtorgb_float (Combine_8b3bcdf1_2eeb_4f31_a5ca_a4796ceb5066_Output);
-				float Vector1_a551547a_ba15_43fe_8319_a5f8dc3c4362_Uniform = 1;
-				float4 Combine_97922ab7_d2fa_4422_aae7_10b1f82228da_Output = float4(HSVtoRGB_e30c457c_26fb_4e7c_847e_fb4e9cb55bb6_Output,Vector1_a551547a_ba15_43fe_8319_a5f8dc3c4362_Uniform);
-				return Combine_97922ab7_d2fa_4422_aae7_10b1f82228da_Output;
-
-			}
-			ENDCG
-		}
-	}
-	Fallback Off
-}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/HelperShader.shader.meta

-fileFormatVersion: 2
-guid: 9ab5e16c2083a4fe689209a8c1ae425e
-timeCreated: 1495755323
-licenseType: Pro
-ShaderImporter:
-  defaultTextures:
-  - Texture_339414d4_3f08_4a60_b7de_60b5078454cd_Uniform: {fileID: 2800000, guid: 5485e2f56028a3c4cb54f5caa167377e,
-      type: 3}
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: