*移动amplify shader editor到third party目录

1 files changed, 3996 insertions, 0 deletions

diff --git a/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Graphs/ParentGraph.cs b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Graphs/ParentGraph.cs
new file mode 100644
index 00000000..32889936
--- /dev/null
+++ b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Graphs/ParentGraph.cs
@@ -0,0 +1,3996 @@
+// Amplify Shader Editor - Visual Shader Editing Tool
+// Copyright (c) Amplify Creations, Lda <info@amplify.pt>
+
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+
+namespace AmplifyShaderEditor
+{
+	[Serializable]
+	public class ParentGraph : ScriptableObject, ISerializationCallbackReceiver
+	{
+		private const int MasterNodeLODIncrement = 100;
+		private const int MaxLodAmount = 9;
+
+		public enum NodeLOD
+		{
+			LOD0,
+			LOD1,
+			LOD2,
+			LOD3,
+			LOD4,
+			LOD5
+		}
+
+		private static bool m_samplingThroughMacros = false;
+
+		private NodeLOD m_lodLevel = NodeLOD.LOD0;
+		private GUIStyle nodeStyleOff;
+		private GUIStyle nodeStyleOn;
+		private GUIStyle nodeTitle;
+		private GUIStyle commentaryBackground;
+
+		public delegate void LODMasterNodesAdded( int lod );
+		public event LODMasterNodesAdded OnLODMasterNodesAddedEvent;
+
+		public delegate void EmptyGraphDetected( ParentGraph graph );
+		public event EmptyGraphDetected OnEmptyGraphDetectedEvt;
+
+		public delegate void NodeEvent( ParentNode node );
+		public event NodeEvent OnNodeEvent = null;
+		public event NodeEvent OnNodeRemovedEvent;
+
+		public delegate void DuplicateEvent();
+		public event DuplicateEvent OnDuplicateEvent;
+
+		public event MasterNode.OnMaterialUpdated OnMaterialUpdatedEvent;
+		public event MasterNode.OnMaterialUpdated OnShaderUpdatedEvent;
+
+		private bool m_afterDeserializeFlag = true;
+		private bool m_lateOptionsRefresh = false;
+		private bool m_foundDuplicates = false;
+
+		//[SerializeField]
+		private AmplifyShaderEditorWindow m_parentWindow = null;
+
+		[SerializeField]
+		private int m_validNodeId;
+
+		[SerializeField]
+		private List<ParentNode> m_nodes = new List<ParentNode>();
+
+		// Sampler Nodes registry
+		[SerializeField]
+		private UsageListSamplerNodes m_samplerNodes = new UsageListSamplerNodes();
+
+		[SerializeField]
+		private UsageListFloatIntNodes m_floatNodes = new UsageListFloatIntNodes();
+
+		[SerializeField]
+		private UsageListTexturePropertyNodes m_texturePropertyNodes = new UsageListTexturePropertyNodes();
+
+		[SerializeField]
+		private UsageListTextureArrayNodes m_textureArrayNodes = new UsageListTextureArrayNodes();
+
+		[SerializeField]
+		private UsageListPropertyNodes m_propertyNodes = new UsageListPropertyNodes();
+
+		[SerializeField]
+		private UsageListPropertyNodes m_rawPropertyNodes = new UsageListPropertyNodes();
+
+		[SerializeField]
+		private UsageListScreenColorNodes m_screenColorNodes = new UsageListScreenColorNodes();
+
+		[SerializeField]
+		private UsageListRegisterLocalVarNodes m_localVarNodes = new UsageListRegisterLocalVarNodes();
+
+		[SerializeField]
+		private UsageListGlobalArrayNodes m_globalArrayNodes = new UsageListGlobalArrayNodes();
+
+		[SerializeField]
+		private UsageListFunctionInputNodes m_functionInputNodes = new UsageListFunctionInputNodes();
+
+		[SerializeField]
+		private UsageListFunctionNodes m_functionNodes = new UsageListFunctionNodes();
+
+		[SerializeField]
+		private UsageListFunctionOutputNodes m_functionOutputNodes = new UsageListFunctionOutputNodes();
+
+		[SerializeField]
+		private UsageListFunctionSwitchNodes m_functionSwitchNodes = new UsageListFunctionSwitchNodes();
+
+		[SerializeField]
+		private UsageListFunctionSwitchCopyNodes m_functionSwitchCopyNodes = new UsageListFunctionSwitchCopyNodes();
+
+		[SerializeField]
+		private UsageListTemplateMultiPassMasterNodes m_multiPassMasterNodes = new UsageListTemplateMultiPassMasterNodes();
+
+		[SerializeField]
+		private List<UsageListTemplateMultiPassMasterNodes> m_lodMultiPassMasterNodes;
+
+		[SerializeField]
+		private UsageListCustomExpressionsOnFunctionMode m_customExpressionsOnFunctionMode = new UsageListCustomExpressionsOnFunctionMode();
+
+		[SerializeField]
+		private UsageListStaticSwitchNodes m_staticSwitchNodes = new UsageListStaticSwitchNodes();
+
+		[SerializeField]
+		private int m_masterNodeId = Constants.INVALID_NODE_ID;
+
+		[SerializeField]
+		private bool m_isDirty;
+
+		[SerializeField]
+		private bool m_saveIsDirty = false;
+
+		[SerializeField]
+		private int m_nodeClicked;
+
+		[SerializeField]
+		private int m_loadedShaderVersion;
+
+		[SerializeField]
+		private int m_instancePropertyCount = 0;
+
+		[SerializeField]
+		private int m_virtualTextureCount = 0;
+
+		[SerializeField]
+		private int m_graphId = 0;
+
+		[SerializeField]
+		private PrecisionType m_currentPrecision = PrecisionType.Float;
+
+		[SerializeField]
+		private NodeAvailability m_currentCanvasMode = NodeAvailability.SurfaceShader;
+
+		[SerializeField]
+		private TemplateSRPType m_currentSRPType = TemplateSRPType.BuiltIn;
+
+		//private List<ParentNode> m_visibleNodes = new List<ParentNode>();
+
+		private List<ParentNode> m_nodePreviewList = new List<ParentNode>();
+
+		private Dictionary<int, ParentNode> m_nodesDict = new Dictionary<int, ParentNode>();
+
+		[NonSerialized]
+		private List<ParentNode> m_selectedNodes = new List<ParentNode>();
+
+		[NonSerialized]
+		private List<ParentNode> m_markedForDeletion = new List<ParentNode>();
+
+		[SerializeField]
+		private List<WireReference> m_highlightedWires = new List<WireReference>();
+		private System.Type m_masterNodeDefaultType;
+
+		[SerializeField]
+		private List<PropertyNode> m_internalTemplateNodesList = new List<PropertyNode>();
+		private Dictionary<int, PropertyNode> m_internalTemplateNodesDict = new Dictionary<int, PropertyNode>();
+
+		private NodeGrid m_nodeGrid;
+
+		private bool m_markedToDeSelect = false;
+		private int m_markToSelect = -1;
+		private bool m_markToReOrder = false;
+
+		private bool m_hasUnConnectedNodes = false;
+
+		private bool m_checkSelectedWireHighlights = false;
+
+		// Bezier info
+		[SerializeField]
+		private List<WireBezierReference> m_bezierReferences;
+		private const int MaxBezierReferences = 50;
+		private int m_wireBezierCount = 0;
+
+		protected int m_normalDependentCount = 0;
+		private bool m_forceCategoryRefresh = false;
+
+		[SerializeField]
+		private bool m_forceRepositionCheck = false;
+
+		private bool m_isLoading = false;
+		private bool m_isDuplicating = false;
+
+		private bool m_changedLightingModel = false;
+
+		public void ResetEvents()
+		{
+			OnNodeEvent = null;
+			OnMaterialUpdatedEvent = null;
+			OnShaderUpdatedEvent = null;
+			OnEmptyGraphDetectedEvt = null;
+			OnNodeRemovedEvent = null;
+		}
+
+		public void Init()
+		{
+			Undo.undoRedoPerformed += OnUndoRedoCallback;
+			m_normalDependentCount = 0;
+			m_nodes = new List<ParentNode>();
+			m_samplerNodes = new UsageListSamplerNodes();
+			m_samplerNodes.ContainerGraph = this;
+			m_samplerNodes.ReorderOnChange = true;
+			m_floatNodes = new UsageListFloatIntNodes();
+			m_floatNodes.ContainerGraph = this;
+			m_texturePropertyNodes = new UsageListTexturePropertyNodes();
+			m_texturePropertyNodes.ContainerGraph = this;
+			m_textureArrayNodes = new UsageListTextureArrayNodes();
+			m_textureArrayNodes.ContainerGraph = this;
+			m_textureArrayNodes.ReorderOnChange = true;
+			m_propertyNodes = new UsageListPropertyNodes();
+			m_propertyNodes.ContainerGraph = this;
+			m_rawPropertyNodes = new UsageListPropertyNodes();
+			m_rawPropertyNodes.ContainerGraph = this;
+			m_customExpressionsOnFunctionMode = new UsageListCustomExpressionsOnFunctionMode();
+			m_customExpressionsOnFunctionMode.ContainerGraph = this;
+			m_staticSwitchNodes = new UsageListStaticSwitchNodes();
+			m_staticSwitchNodes.ContainerGraph = this;
+			m_staticSwitchNodes.ReorderOnChange = true;
+			m_screenColorNodes = new UsageListScreenColorNodes();
+			m_screenColorNodes.ContainerGraph = this;
+			m_screenColorNodes.ReorderOnChange = true;
+			m_localVarNodes = new UsageListRegisterLocalVarNodes();
+			m_localVarNodes.ContainerGraph = this;
+			m_localVarNodes.ReorderOnChange = true;
+			m_globalArrayNodes = new UsageListGlobalArrayNodes();
+			m_globalArrayNodes.ContainerGraph = this;
+			m_functionInputNodes = new UsageListFunctionInputNodes();
+			m_functionInputNodes.ContainerGraph = this;
+			m_functionNodes = new UsageListFunctionNodes();
+			m_functionNodes.ContainerGraph = this;
+			m_functionOutputNodes = new UsageListFunctionOutputNodes();
+			m_functionOutputNodes.ContainerGraph = this;
+			m_functionSwitchNodes = new UsageListFunctionSwitchNodes();
+			m_functionSwitchNodes.ContainerGraph = this;
+			m_functionSwitchCopyNodes = new UsageListFunctionSwitchCopyNodes();
+			m_functionSwitchCopyNodes.ContainerGraph = this;
+			m_multiPassMasterNodes = new UsageListTemplateMultiPassMasterNodes();
+			m_multiPassMasterNodes.ContainerGraph = this;
+			m_lodMultiPassMasterNodes = new List<UsageListTemplateMultiPassMasterNodes>( MaxLodAmount );
+			for( int i = 0; i < MaxLodAmount; i++ )
+			{
+				m_lodMultiPassMasterNodes.Add( new UsageListTemplateMultiPassMasterNodes() );
+			}
+			m_selectedNodes = new List<ParentNode>();
+			m_markedForDeletion = new List<ParentNode>();
+			m_highlightedWires = new List<WireReference>();
+			m_validNodeId = 0;
+			IsDirty = false;
+			SaveIsDirty = false;
+			m_masterNodeDefaultType = typeof( StandardSurfaceOutputNode );
+
+			m_bezierReferences = new List<WireBezierReference>( MaxBezierReferences );
+			for( int i = 0; i < MaxBezierReferences; i++ )
+			{
+				m_bezierReferences.Add( new WireBezierReference() );
+			}
+
+			m_samplingThroughMacros = Preferences.GlobalUseMacros;
+		}
+
+		private void OnUndoRedoCallback()
+		{
+			DeSelectAll();
+		}
+
+		private void OnEnable()
+		{
+			hideFlags = HideFlags.HideAndDontSave;
+			m_nodeGrid = new NodeGrid();
+			m_internalTemplateNodesDict = new Dictionary<int, PropertyNode>();
+			m_nodesDict = new Dictionary<int, ParentNode>();
+			nodeStyleOff = UIUtils.GetCustomStyle( CustomStyle.NodeWindowOff );
+			nodeStyleOn = UIUtils.GetCustomStyle( CustomStyle.NodeWindowOn );
+			nodeTitle = UIUtils.GetCustomStyle( CustomStyle.NodeHeader );
+			commentaryBackground = UIUtils.GetCustomStyle( CustomStyle.CommentaryBackground );
+		}
+
+		public void UpdateRegisters()
+		{
+			m_samplerNodes.UpdateNodeArr();
+			m_propertyNodes.UpdateNodeArr();
+			m_rawPropertyNodes.UpdateNodeArr();
+			m_customExpressionsOnFunctionMode.UpdateNodeArr();
+			m_staticSwitchNodes.UpdateNodeArr();
+			m_functionInputNodes.UpdateNodeArr();
+			m_functionNodes.UpdateNodeArr();
+			m_functionOutputNodes.UpdateNodeArr();
+			m_functionSwitchNodes.UpdateNodeArr();
+			m_functionSwitchCopyNodes.UpdateNodeArr();
+			m_multiPassMasterNodes.UpdateNodeArr();
+			for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+			{
+				m_lodMultiPassMasterNodes[ i ].UpdateNodeArr();
+			}
+			m_texturePropertyNodes.UpdateNodeArr();
+			m_textureArrayNodes.UpdateNodeArr();
+			m_screenColorNodes.UpdateNodeArr();
+			m_localVarNodes.UpdateNodeArr();
+			m_globalArrayNodes.UpdateNodeArr();
+		}
+
+		public int GetValidId()
+		{
+			return m_validNodeId++;
+		}
+
+		void UpdateIdFromNode( ParentNode node )
+		{
+			if( node.UniqueId >= m_validNodeId )
+			{
+				m_validNodeId = node.UniqueId + 1;
+			}
+		}
+
+		public void ResetNodeConnStatus()
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				if( m_nodes[ i ].ConnStatus == NodeConnectionStatus.Connected )
+				{
+					m_nodes[ i ].ConnStatus = NodeConnectionStatus.Not_Connected;
+				}
+			}
+		}
+
+		public void CleanUnusedNodes()
+		{
+			List<ParentNode> unusedNodes = new List<ParentNode>();
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				if( m_nodes[ i ].ConnStatus == NodeConnectionStatus.Not_Connected )
+				{
+					unusedNodes.Add( m_nodes[ i ] );
+				}
+			}
+
+			for( int i = 0; i < unusedNodes.Count; i++ )
+			{
+				DestroyNode( unusedNodes[ i ] );
+			}
+			unusedNodes.Clear();
+			unusedNodes = null;
+
+			IsDirty = true;
+		}
+
+		// Destroy all nodes excluding Master Node
+		public void ClearGraph()
+		{
+			List<ParentNode> list = new List<ParentNode>();
+			int count = m_nodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( m_nodes[ i ].UniqueId != m_masterNodeId )
+				{
+					list.Add( m_nodes[ i ] );
+				}
+			}
+
+			while( list.Count > 0 )
+			{
+				DestroyNode( list[ 0 ] );
+				list.RemoveAt( 0 );
+			}
+		}
+
+		public void CleanNodes()
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				if( m_nodes[ i ] != null )
+				{
+					Undo.ClearUndo( m_nodes[ i ] );
+					m_nodes[ i ].Destroy();
+					GameObject.DestroyImmediate( m_nodes[ i ] );
+				}
+			}
+			ClearInternalTemplateNodes();
+
+			m_masterNodeId = Constants.INVALID_NODE_ID;
+			m_validNodeId = 0;
+			m_instancePropertyCount = 0;
+			m_virtualTextureCount = 0;
+
+			m_nodesDict.Clear();
+			m_nodes.Clear();
+			m_samplerNodes.Clear();
+			m_propertyNodes.Clear();
+			m_rawPropertyNodes.Clear();
+			m_customExpressionsOnFunctionMode.Clear();
+			m_staticSwitchNodes.Clear();
+			m_functionInputNodes.Clear();
+			m_functionNodes.Clear();
+			m_functionOutputNodes.Clear();
+			m_functionSwitchNodes.Clear();
+			m_functionSwitchCopyNodes.Clear();
+			m_multiPassMasterNodes.Clear();
+			for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+			{
+				m_lodMultiPassMasterNodes[ i ].Clear();
+			}
+			
+			m_texturePropertyNodes.Clear();
+			m_textureArrayNodes.Clear();
+			m_screenColorNodes.Clear();
+			m_localVarNodes.Clear();
+			m_globalArrayNodes.Clear();
+			m_selectedNodes.Clear();
+			m_markedForDeletion.Clear();
+		}
+
+		public void ResetHighlightedWires()
+		{
+			for( int i = 0; i < m_highlightedWires.Count; i++ )
+			{
+				m_highlightedWires[ i ].WireStatus = WireStatus.Default;
+			}
+			m_highlightedWires.Clear();
+		}
+
+		public void HighlightWiresStartingNode( ParentNode node )
+		{
+			for( int outputIdx = 0; outputIdx < node.OutputPorts.Count; outputIdx++ )
+			{
+				for( int extIdx = 0; extIdx < node.OutputPorts[ outputIdx ].ExternalReferences.Count; extIdx++ )
+				{
+					WireReference wireRef = node.OutputPorts[ outputIdx ].ExternalReferences[ extIdx ];
+					ParentNode nextNode = GetNode( wireRef.NodeId );
+					if( nextNode && nextNode.ConnStatus == NodeConnectionStatus.Connected )
+					{
+						InputPort port = nextNode.GetInputPortByUniqueId( wireRef.PortId );
+						if( port.ExternalReferences.Count == 0 || port.ExternalReferences[ 0 ].WireStatus == WireStatus.Highlighted )
+						{
+							// if even one wire is already highlighted then this tells us that this node was already been analysed
+							return;
+						}
+
+						port.ExternalReferences[ 0 ].WireStatus = WireStatus.Highlighted;
+						m_highlightedWires.Add( port.ExternalReferences[ 0 ] );
+						HighlightWiresStartingNode( nextNode );
+					}
+				}
+			}
+
+			RegisterLocalVarNode regNode = node as RegisterLocalVarNode;
+			if( (object)regNode != null )
+			{
+				int count = regNode.NodeReferences.Count;
+				for( int i = 0; i < count; i++ )
+				{
+					HighlightWiresStartingNode( regNode.NodeReferences[ i ] );
+				}
+			}
+		}
+
+		void PropagateHighlightDeselection( ParentNode node, int portId = -1 )
+		{
+			if( portId > -1 )
+			{
+				InputPort port = node.GetInputPortByUniqueId( portId );
+				port.ExternalReferences[ 0 ].WireStatus = WireStatus.Default;
+			}
+
+			if( node.Selected )
+				return;
+
+			for( int i = 0; i < node.InputPorts.Count; i++ )
+			{
+				if( node.InputPorts[ i ].ExternalReferences.Count > 0 && node.InputPorts[ i ].ExternalReferences[ 0 ].WireStatus == WireStatus.Highlighted )
+				{
+					// even though node is deselected, it receives wire highlight from a previous one 
+					return;
+				}
+			}
+
+			for( int outputIdx = 0; outputIdx < node.OutputPorts.Count; outputIdx++ )
+			{
+				for( int extIdx = 0; extIdx < node.OutputPorts[ outputIdx ].ExternalReferences.Count; extIdx++ )
+				{
+					WireReference wireRef = node.OutputPorts[ outputIdx ].ExternalReferences[ extIdx ];
+					ParentNode nextNode = GetNode( wireRef.NodeId );
+					PropagateHighlightDeselection( nextNode, wireRef.PortId );
+				}
+			}
+
+			RegisterLocalVarNode regNode = node as RegisterLocalVarNode;
+			if( (object)regNode != null )
+			{
+				int count = regNode.NodeReferences.Count;
+				for( int i = 0; i < count; i++ )
+				{
+					PropagateHighlightDeselection( regNode.NodeReferences[ i ], -1 );
+				}
+			}
+		}
+
+
+		public void ResetNodesData()
+		{
+			int count = m_nodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				m_nodes[ i ].ResetNodeData();
+			}
+		}
+
+		public void FullCleanUndoStack()
+		{
+			Undo.ClearUndo( this );
+			int count = m_nodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( m_nodes[ i ] != null )
+				{
+					Undo.ClearUndo( m_nodes[ i ] );
+				}
+			}
+		}
+
+		public void FullRegisterOnUndoStack()
+		{
+			Undo.RegisterCompleteObjectUndo( this, Constants.UndoRegisterFullGrapId );
+			int count = m_nodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( m_nodes[ i ] != null )
+				{
+					Undo.RegisterCompleteObjectUndo( m_nodes[ i ], Constants.UndoRegisterFullGrapId );
+				}
+			}
+		}
+
+		public void CheckPropertiesAutoRegister( ref MasterNodeDataCollector dataCollector )
+		{
+			List<PropertyNode> propertyNodesList = m_rawPropertyNodes.NodesList;
+			int propertyCount = propertyNodesList.Count;
+			for( int i = 0; i < propertyCount; i++ )
+			{
+				propertyNodesList[ i ].CheckIfAutoRegister( ref dataCollector );
+			}
+			propertyNodesList = null;
+
+			List<GlobalArrayNode> globalArrayNodeList = m_globalArrayNodes.NodesList;
+			int globalArrayCount = globalArrayNodeList.Count;
+			for( int i = 0; i < globalArrayCount; i++ )
+			{
+				globalArrayNodeList[ i ].CheckIfAutoRegister( ref dataCollector );
+			}
+			globalArrayNodeList = null;
+
+			//List<PropertyNode> propertyNodesList = m_propertyNodes.NodesList;
+			//int propertyCount = propertyNodesList.Count;
+			//for( int i = 0; i < propertyCount; i++ )
+			//{
+			//	propertyNodesList[ i ].CheckIfAutoRegister( ref dataCollector );
+			//}
+			//propertyNodesList = null;
+
+			//List<ScreenColorNode> screenColorNodes = m_screenColorNodes.NodesList;
+			//int screenColorNodesCount = screenColorNodes.Count;
+			//for( int i = 0; i < screenColorNodesCount; i++ )
+			//{
+			//	screenColorNodes[ i ].CheckIfAutoRegister( ref dataCollector );
+			//}
+			//screenColorNodes = null;
+		}
+
+		public void SoftDestroy()
+		{
+			OnNodeRemovedEvent = null;
+
+			m_masterNodeId = Constants.INVALID_NODE_ID;
+			m_validNodeId = 0;
+			
+			m_nodeGrid.Destroy();
+			//m_nodeGrid = null;
+
+			ClearInternalTemplateNodes();
+
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				if( m_nodes[ i ] != null )
+				{
+					m_nodes[ i ].Destroy();
+					GameObject.DestroyImmediate( m_nodes[ i ] );
+				}
+			}
+
+			m_instancePropertyCount = 0;
+
+			m_nodes.Clear();
+			//m_nodes = null;
+
+			m_nodesDict.Clear();
+			//m_nodesDict = null;
+
+			m_samplerNodes.Clear();
+			//m_samplerNodes = null;
+
+			m_propertyNodes.Clear();
+			m_rawPropertyNodes.Clear();
+			//m_propertyNodes = null;
+
+			m_customExpressionsOnFunctionMode.Clear();
+
+			m_staticSwitchNodes.Clear();
+
+			m_functionInputNodes.Clear();
+			//m_functionInputNodes = null;
+
+			m_functionNodes.Clear();
+			//m_functionNodes = null;
+
+			m_functionOutputNodes.Clear();
+			//m_functionOutputNodes = null;
+
+			m_functionSwitchNodes.Clear();
+			//m_functionSwitchNodes = null;
+
+			m_functionSwitchCopyNodes.Clear();
+			//m_functionSwitchCopyNodes = null;
+
+			m_texturePropertyNodes.Clear();
+			//m_texturePropertyNodes = null;
+
+			m_textureArrayNodes.Clear();
+			//m_textureArrayNodes = null;
+
+			m_screenColorNodes.Clear();
+			//m_screenColorNodes = null;
+
+			m_localVarNodes.Clear();
+			//m_localVarNodes = null;
+
+			m_globalArrayNodes.Clear();
+
+			m_selectedNodes.Clear();
+			//m_selectedNodes = null;
+
+			m_markedForDeletion.Clear();
+			//m_markedForDeletion = null;
+
+			m_nodePreviewList.Clear();
+			//m_nodePreviewList = null;
+
+			IsDirty = true;
+
+			OnNodeEvent = null;
+			OnDuplicateEvent = null;
+			//m_currentShaderFunction = null;
+
+			OnMaterialUpdatedEvent = null;
+			OnShaderUpdatedEvent = null;
+			OnEmptyGraphDetectedEvt = null;
+
+			nodeStyleOff = null;
+			nodeStyleOn = null;
+			nodeTitle = null;
+			commentaryBackground = null;
+			OnLODMasterNodesAddedEvent = null;
+		}
+
+
+
+
+		public void Destroy()
+		{
+			Undo.undoRedoPerformed -= OnUndoRedoCallback;
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				if( m_nodes[ i ] != null )
+				{
+					Undo.ClearUndo( m_nodes[ i ] );
+					m_nodes[ i ].Destroy();
+					GameObject.DestroyImmediate( m_nodes[ i ] );
+				}
+			}
+
+			//Must be before m_propertyNodes.Destroy();
+			ClearInternalTemplateNodes();
+			m_internalTemplateNodesDict = null;
+			m_internalTemplateNodesList = null;
+
+			OnNodeRemovedEvent = null;
+
+			m_masterNodeId = Constants.INVALID_NODE_ID;
+			m_validNodeId = 0;
+			m_instancePropertyCount = 0;
+
+			m_nodeGrid.Destroy();
+			m_nodeGrid = null;
+
+			m_nodes.Clear();
+			m_nodes = null;
+
+			m_samplerNodes.Destroy();
+			m_samplerNodes = null;
+
+			m_propertyNodes.Destroy();
+			m_propertyNodes = null;
+
+			m_rawPropertyNodes.Destroy();
+			m_rawPropertyNodes = null;
+
+			m_customExpressionsOnFunctionMode.Destroy();
+			m_customExpressionsOnFunctionMode = null;
+
+			m_staticSwitchNodes.Destroy();
+			m_staticSwitchNodes = null;
+
+			m_functionInputNodes.Destroy();
+			m_functionInputNodes = null;
+
+			m_functionNodes.Destroy();
+			m_functionNodes = null;
+
+			m_functionOutputNodes.Destroy();
+			m_functionOutputNodes = null;
+
+			m_functionSwitchNodes.Destroy();
+			m_functionSwitchNodes = null;
+
+			m_functionSwitchCopyNodes.Destroy();
+			m_functionSwitchCopyNodes = null;
+
+			m_multiPassMasterNodes.Destroy();
+			m_multiPassMasterNodes = null;
+
+			for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+			{
+				m_lodMultiPassMasterNodes[ i ].Destroy();
+				m_lodMultiPassMasterNodes[ i ] = null;
+			}
+			m_lodMultiPassMasterNodes.Clear();
+			m_lodMultiPassMasterNodes = null;
+
+			m_texturePropertyNodes.Destroy();
+			m_texturePropertyNodes = null;
+
+			m_textureArrayNodes.Destroy();
+			m_textureArrayNodes = null;
+
+			m_screenColorNodes.Destroy();
+			m_screenColorNodes = null;
+
+			m_localVarNodes.Destroy();
+			m_localVarNodes = null;
+
+			m_globalArrayNodes.Destroy();
+			m_globalArrayNodes = null;
+
+			m_selectedNodes.Clear();
+			m_selectedNodes = null;
+
+			m_markedForDeletion.Clear();
+			m_markedForDeletion = null;
+
+
+			m_nodesDict.Clear();
+			m_nodesDict = null;
+
+			m_nodePreviewList.Clear();
+			m_nodePreviewList = null;
+
+			IsDirty = true;
+
+			OnNodeEvent = null;
+			OnDuplicateEvent = null;
+			//m_currentShaderFunction = null;
+
+			OnMaterialUpdatedEvent = null;
+			OnShaderUpdatedEvent = null;
+			OnEmptyGraphDetectedEvt = null;
+
+			nodeStyleOff = null;
+			nodeStyleOn = null;
+			nodeTitle = null;
+			commentaryBackground = null;
+
+			OnLODMasterNodesAddedEvent = null;
+		}
+
+		void OnNodeChangeSizeEvent( ParentNode node )
+		{
+			m_nodeGrid.RemoveNodeFromGrid( node, true );
+			m_nodeGrid.AddNodeToGrid( node );
+		}
+
+		public void OnNodeFinishMoving( ParentNode node, bool testOnlySelected, InteractionMode interactionMode )
+		{
+			if( OnNodeEvent != null )
+			{
+				OnNodeEvent( node );
+				SaveIsDirty = true;
+			}
+
+			m_nodeGrid.RemoveNodeFromGrid( node, true );
+			m_nodeGrid.AddNodeToGrid( node );
+
+			//if( testOnlySelected )
+			//{
+			//	for( int i = m_visibleNodes.Count - 1; i > -1; i-- )
+			//	{
+			//		if( node.UniqueId != m_visibleNodes[ i ].UniqueId )
+			//		{
+			//			switch( interactionMode )
+			//			{
+			//				case InteractionMode.Target:
+			//				{
+			//					node.OnNodeInteraction( m_visibleNodes[ i ] );
+			//				}
+			//				break;
+			//				case InteractionMode.Other:
+			//				{
+			//					m_visibleNodes[ i ].OnNodeInteraction( node );
+			//				}
+			//				break;
+			//				case InteractionMode.Both:
+			//				{
+			//					node.OnNodeInteraction( m_visibleNodes[ i ] );
+			//					m_visibleNodes[ i ].OnNodeInteraction( node );
+			//				}
+			//				break;
+			//			}
+			//		}
+			//	}
+			//}
+			//else
+			{
+				for( int i = m_nodes.Count - 1; i > -1; i-- )
+				{
+					if( node.UniqueId != m_nodes[ i ].UniqueId )
+					{
+						switch( interactionMode )
+						{
+							case InteractionMode.Target:
+							{
+								node.OnNodeInteraction( m_nodes[ i ] );
+							}
+							break;
+							case InteractionMode.Other:
+							{
+								m_nodes[ i ].OnNodeInteraction( node );
+							}
+							break;
+							case InteractionMode.Both:
+							{
+								node.OnNodeInteraction( m_nodes[ i ] );
+								m_nodes[ i ].OnNodeInteraction( node );
+							}
+							break;
+						}
+					}
+				}
+			}
+		}
+
+
+		public void OnNodeReOrderEvent( ParentNode node, int index )
+		{
+			if( node.Depth < index )
+			{
+				Debug.LogWarning( "Reorder canceled: This is a specific method for when reordering needs to be done and a its original index is higher than the new one" );
+			}
+			else
+			{
+				m_nodes.Remove( node );
+				m_nodes.Insert( index, node );
+				m_markToReOrder = true;
+			}
+		}
+
+		public void AddNode( ParentNode node, bool updateId = false, bool addLast = true, bool registerUndo = true, bool fetchMaterialValues = true )
+		{
+			if( registerUndo )
+			{
+				UIUtils.MarkUndoAction();
+				Undo.RegisterCompleteObjectUndo( ParentWindow, Constants.UndoCreateNodeId );
+				Undo.RegisterCompleteObjectUndo( this, Constants.UndoCreateNodeId );
+				Undo.RegisterCreatedObjectUndo( node, Constants.UndoCreateNodeId );
+			}
+
+			if( OnNodeEvent != null )
+			{
+				OnNodeEvent( node );
+			}
+			if( updateId )
+			{
+				node.UniqueId = GetValidId();
+			}
+			else
+			{
+				UpdateIdFromNode( node );
+			}
+
+
+
+			if( addLast )
+			{
+				m_nodes.Add( node );
+				node.Depth = m_nodes.Count;
+			}
+			else
+			{
+				m_nodes.Insert( 0, node );
+				node.Depth = 0;
+			}
+
+			if( m_nodesDict.ContainsKey( node.UniqueId ) )
+			{
+				//m_nodesDict[ node.UniqueId ] = node;
+				m_foundDuplicates = true;
+			}
+			else
+			{
+				m_nodesDict.Add( node.UniqueId, node );
+				node.SetMaterialMode( CurrentMaterial, fetchMaterialValues );
+			}
+
+			m_nodeGrid.AddNodeToGrid( node );
+			node.OnNodeChangeSizeEvent += OnNodeChangeSizeEvent;
+			node.OnNodeReOrderEvent += OnNodeReOrderEvent;
+			IsDirty = true;
+		}
+
+		public void CheckForDuplicates()
+		{
+			if( m_foundDuplicates )
+			{
+				Debug.LogWarning( "Found duplicates:" );
+				m_foundDuplicates = false;
+				m_nodesDict.Clear();
+				int count = m_nodes.Count;
+				for( int i = 0; i < count; i++ )
+				{
+					if( m_nodesDict.ContainsKey( m_nodes[ i ].UniqueId ) )
+					{
+						m_nodes[ i ].UniqueId = GetValidId();
+						m_nodesDict.Add( m_nodes[ i ].UniqueId, m_nodes[ i ] );
+						Debug.LogWarning( "Assigning new ID to " + m_nodes[ i ].TypeName );
+					}
+					else
+					{
+						m_nodesDict.Add( m_nodes[ i ].UniqueId, m_nodes[ i ] );
+					}
+				}
+			}
+		}
+
+		public ParentNode GetClickedNode()
+		{
+			if( m_nodeClicked < 0 )
+				return null;
+			return GetNode( m_nodeClicked );
+		}
+
+		public PropertyNode GetInternalTemplateNode( int nodeId )
+		{
+			if( m_internalTemplateNodesDict.Count != m_internalTemplateNodesList.Count )
+			{
+				m_internalTemplateNodesDict.Clear();
+				int count = m_internalTemplateNodesList.Count;
+				for( int i = 0; i < m_internalTemplateNodesList.Count; i++ )
+				{
+					if( m_internalTemplateNodesList[ i ] != null )
+						m_internalTemplateNodesDict.Add( m_internalTemplateNodesList[ i ].UniqueId, m_internalTemplateNodesList[ i ] );
+				}
+			}
+
+			if( m_internalTemplateNodesDict.ContainsKey( nodeId ) )
+				return m_internalTemplateNodesDict[ nodeId ];
+
+			return null;
+		}
+
+		public PropertyNode GetInternalTemplateNode( string propertyName )
+		{
+			return m_internalTemplateNodesList.Find( ( x ) => x.PropertyName.Equals( propertyName ) );
+		}
+
+		public void AddInternalTemplateNode( TemplateShaderPropertyData data )
+		{
+			PropertyNode propertyNode = null;
+			switch( data.PropertyDataType )
+			{
+				case WirePortDataType.FLOAT:
+				propertyNode = CreateInstance<RangedFloatNode>(); break;
+				case WirePortDataType.FLOAT4:
+				propertyNode = CreateInstance<Vector4Node>();
+				break;
+				case WirePortDataType.COLOR:
+				propertyNode = CreateInstance<ColorNode>();
+				break;
+				case WirePortDataType.INT:
+				propertyNode = CreateInstance<IntNode>(); break;
+				case WirePortDataType.SAMPLER1D:
+				case WirePortDataType.SAMPLER2D:
+				case WirePortDataType.SAMPLER3D:
+				case WirePortDataType.SAMPLERCUBE:
+				propertyNode = CreateInstance<SamplerNode>();
+				break;
+				default: return;
+			}
+
+			propertyNode.PropertyNameFromTemplate( data );
+
+			// Create a negative unique Id to separate it from 
+			// the regular ids on the main nodes list 
+			// Its begins at -2 since -1 is used to detect invalid values
+			int uniqueId = -( m_internalTemplateNodesList.Count + 2 );
+			propertyNode.SetBaseUniqueId( uniqueId );
+
+			//Register into Float/Int Nodes list to be available inline
+			// Unique Id must be already set at this point to properly 
+			// create array
+			if( data.PropertyDataType == WirePortDataType.FLOAT ||
+				data.PropertyDataType == WirePortDataType.INT )
+				m_floatNodes.AddNode( propertyNode );
+
+			m_internalTemplateNodesList.Add( propertyNode );
+			m_internalTemplateNodesDict.Add( uniqueId, propertyNode );
+		}
+
+		public void ClearInternalTemplateNodes()
+		{
+			if( m_internalTemplateNodesList != null )
+			{
+				int count = m_internalTemplateNodesList.Count;
+				for( int i = 0; i < count; i++ )
+				{
+					m_internalTemplateNodesList[ i ].Destroy();
+					GameObject.DestroyImmediate( m_internalTemplateNodesList[ i ] );
+				}
+
+				m_internalTemplateNodesList.Clear();
+				m_internalTemplateNodesDict.Clear();
+			}
+		}
+
+		public ParentNode GetNode( int nodeId )
+		{
+			if( m_nodesDict.Count != m_nodes.Count )
+			{
+				m_nodesDict.Clear();
+				int count = m_nodes.Count;
+				for( int i = 0; i < count; i++ )
+				{
+					if( m_nodes[ i ] != null && !m_nodesDict.ContainsKey( m_nodes[ i ].UniqueId ) )
+						m_nodesDict.Add( m_nodes[ i ].UniqueId, m_nodes[ i ] );
+				}
+			}
+
+			if( m_nodesDict.ContainsKey( nodeId ) )
+				return m_nodesDict[ nodeId ];
+
+			return null;
+		}
+
+		public void ForceReOrder()
+		{
+			m_nodes.Sort( ( x, y ) => x.Depth.CompareTo( y.Depth ) );
+		}
+
+		public bool Draw( DrawInfo drawInfo )
+		{
+			MasterNode masterNode = GetNode( m_masterNodeId ) as MasterNode;
+			if( m_forceCategoryRefresh && masterNode != null )
+			{
+				masterNode.RefreshAvailableCategories();
+				m_forceCategoryRefresh = false;
+			}
+
+			SaveIsDirty = false;
+			if( m_afterDeserializeFlag )
+			{
+				// this is now done after logic update... templates needs it this way
+				//m_afterDeserializeFlag = false;
+
+				CleanCorruptedNodes();
+				if( m_nodes.Count == 0 )
+				{
+					//TODO: remove this temp from here
+					NodeAvailability cachedCanvas = CurrentCanvasMode;
+					ParentWindow.CreateNewGraph( "Empty" );
+					CurrentCanvasMode = cachedCanvas;
+					if( OnEmptyGraphDetectedEvt != null )
+					{
+						OnEmptyGraphDetectedEvt( this );
+						SaveIsDirty = false;
+					}
+					else
+					{
+						SaveIsDirty = true;
+					}
+				}
+
+				//for( int i = 0; i < m_nodes.Count; i++ )
+				//{
+				//	m_nodes[ i ].SetContainerGraph( this );
+				//}
+			}
+
+			if( drawInfo.CurrentEventType == EventType.Repaint )
+			{
+				if( m_markedToDeSelect )
+					DeSelectAll();
+
+				if( m_markToSelect > -1 )
+				{
+					AddToSelectedNodes( GetNode( m_markToSelect ) );
+					m_markToSelect = -1;
+				}
+
+				if( m_markToReOrder )
+				{
+					m_markToReOrder = false;
+					int nodesCount = m_nodes.Count;
+					for( int i = 0; i < nodesCount; i++ )
+					{
+						m_nodes[ i ].Depth = i;
+					}
+				}
+			}
+
+			if( drawInfo.CurrentEventType == EventType.Repaint )
+			{
+				// Resizing Nods per LOD level
+				NodeLOD newLevel = NodeLOD.LOD0;
+				float referenceValue;
+				if( drawInfo.InvertedZoom > 0.5f )
+				{
+					newLevel = NodeLOD.LOD0;
+					referenceValue = 4;
+				}
+				else if( drawInfo.InvertedZoom > 0.25f )
+				{
+					newLevel = NodeLOD.LOD1;
+					referenceValue = 2;
+				}
+				else if( drawInfo.InvertedZoom > 0.15f )
+				{
+					newLevel = NodeLOD.LOD2;
+					referenceValue = 1;
+				}
+				else if( drawInfo.InvertedZoom > 0.1f )
+				{
+					newLevel = NodeLOD.LOD3;
+					referenceValue = 0;
+				}
+				else if( drawInfo.InvertedZoom > 0.07f )
+				{
+					newLevel = NodeLOD.LOD4;
+					referenceValue = 0;
+				}
+				else
+				{
+					newLevel = NodeLOD.LOD5;
+					referenceValue = 0;
+				}
+
+				// Just a sanity check
+				nodeStyleOff = UIUtils.GetCustomStyle( CustomStyle.NodeWindowOff );
+				nodeStyleOn = UIUtils.GetCustomStyle( CustomStyle.NodeWindowOn );//= UIUtils.GetCustomStyle( CustomStyle.NodeWindowOn );
+				nodeTitle = UIUtils.GetCustomStyle( CustomStyle.NodeHeader );
+				commentaryBackground = UIUtils.GetCustomStyle( CustomStyle.CommentaryBackground );
+
+				if( newLevel != m_lodLevel || ( UIUtils.MainSkin != null && UIUtils.MainSkin.textField.border.left != referenceValue ) )
+				{
+					m_lodLevel = newLevel;
+					switch( m_lodLevel )
+					{
+						default:
+						case NodeLOD.LOD0:
+						{
+							UIUtils.MainSkin.textField.border = UIUtils.RectOffsetFour;
+							nodeStyleOff.border = UIUtils.RectOffsetSix;
+							UIUtils.NodeWindowOffSquare.border = UIUtils.RectOffsetFour;
+
+							nodeStyleOn.border = UIUtils.RectOffsetSix;
+							UIUtils.NodeWindowOnSquare.border = UIUtils.RectOffsetSix;
+
+							nodeTitle.border.left = 6;
+							nodeTitle.border.right = 6;
+							nodeTitle.border.top = 6;
+							nodeTitle.border.bottom = 4;
+
+							UIUtils.NodeHeaderSquare.border = UIUtils.RectOffsetFour;
+							commentaryBackground.border = UIUtils.RectOffsetSix;
+						}
+						break;
+						case NodeLOD.LOD1:
+						{
+							UIUtils.MainSkin.textField.border = UIUtils.RectOffsetTwo;
+							nodeStyleOff.border = UIUtils.RectOffsetFive;
+							UIUtils.NodeWindowOffSquare.border = UIUtils.RectOffsetFive;
+
+							nodeStyleOn.border = UIUtils.RectOffsetFive;
+							UIUtils.NodeWindowOnSquare.border = UIUtils.RectOffsetFour;
+
+							nodeTitle.border.left = 5;
+							nodeTitle.border.right = 5;
+							nodeTitle.border.top = 5;
+							nodeTitle.border.bottom = 2;
+
+							UIUtils.NodeHeaderSquare.border = UIUtils.RectOffsetThree;
+							commentaryBackground.border = UIUtils.RectOffsetFive;
+						}
+						break;
+						case NodeLOD.LOD2:
+						{
+							UIUtils.MainSkin.textField.border = UIUtils.RectOffsetOne;
+
+							nodeStyleOff.border.left = 2;
+							nodeStyleOff.border.right = 2;
+							nodeStyleOff.border.top = 2;
+							nodeStyleOff.border.bottom = 3;
+
+							UIUtils.NodeWindowOffSquare.border = UIUtils.RectOffsetThree;
+
+							nodeStyleOn.border.left = 4;
+							nodeStyleOn.border.right = 4;
+							nodeStyleOn.border.top = 4;
+							nodeStyleOn.border.bottom = 3;
+
+							UIUtils.NodeWindowOnSquare.border = UIUtils.RectOffsetThree;
+
+							nodeTitle.border = UIUtils.RectOffsetTwo;
+							UIUtils.NodeHeaderSquare.border = UIUtils.RectOffsetTwo;
+
+							commentaryBackground.border.left = 2;
+							commentaryBackground.border.right = 2;
+							commentaryBackground.border.top = 2;
+							commentaryBackground.border.bottom = 3;
+						}
+						break;
+						case NodeLOD.LOD3:
+						case NodeLOD.LOD4:
+						case NodeLOD.LOD5:
+						{
+							UIUtils.MainSkin.textField.border = UIUtils.RectOffsetZero;
+
+							nodeStyleOff.border.left = 1;
+							nodeStyleOff.border.right = 1;
+							nodeStyleOff.border.top = 1;
+							nodeStyleOff.border.bottom = 2;
+
+							UIUtils.NodeWindowOffSquare.border = UIUtils.RectOffsetTwo;
+
+							nodeStyleOn.border = UIUtils.RectOffsetTwo;
+							UIUtils.NodeWindowOnSquare.border = UIUtils.RectOffsetTwo;
+
+							nodeTitle.border = UIUtils.RectOffsetOne;
+							UIUtils.NodeHeaderSquare.border = UIUtils.RectOffsetOne;
+
+							commentaryBackground.border.left = 1;
+							commentaryBackground.border.right = 1;
+							commentaryBackground.border.top = 1;
+							commentaryBackground.border.bottom = 2;
+						}
+						break;
+					}
+				}
+			}
+
+			//m_visibleNodes.Clear();
+			//int nullCount = 0;
+			m_hasUnConnectedNodes = false;
+			bool repaint = false;
+			Material currentMaterial = masterNode != null ? masterNode.CurrentMaterial : null;
+			EditorGUI.BeginChangeCheck();
+			bool repaintMaterialInspector = false;
+
+			int nodeCount = m_nodes.Count;
+			for( int i = 0; i < nodeCount; i++ )
+			{
+				m_nodes[ i ].OnNodeLogicUpdate( drawInfo );
+			}
+
+			if( m_afterDeserializeFlag || m_lateOptionsRefresh )
+			{
+				m_afterDeserializeFlag = false;
+				m_lateOptionsRefresh = false;
+				if( CurrentCanvasMode == NodeAvailability.TemplateShader )
+				{
+					RefreshLinkedMasterNodes( true );
+					OnRefreshLinkedPortsComplete();
+					//If clipboard has cached nodes then a master node replacement will take place
+					//We need to re-cache master nodes to ensure applied options are correctly cached
+					//As first cache happens before that
+					if( m_parentWindow.ClipboardInstance.HasCachedMasterNodes )
+					{
+						m_parentWindow.ClipboardInstance.AddMultiPassNodesToClipboard( MultiPassMasterNodes.NodesList );
+					}
+					//RepositionTemplateNodes( CurrentMasterNode );
+				}
+			}
+
+			if( m_forceRepositionCheck )
+			{
+				RepositionTemplateNodes( CurrentMasterNode );
+			}
+
+			//for( int i = 0; i < m_functionNodes.NodesList.Count; i++ )
+			//{
+			//	m_functionNodes.NodesList[ i ].LogicGraph();
+			//}
+
+			//for( int i = 0; i < UIUtils.FunctionSwitchCopyList().Count; i++ )
+			//{
+			//	UIUtils.FunctionSwitchCopyList()[ i ].CheckReference();
+			//}
+
+
+
+			// Dont use nodeCount variable because node count can change in this loop???
+			nodeCount = m_nodes.Count;
+			ParentNode node = null;
+			for( int i = 0; i < nodeCount; i++ )
+			{
+				node = m_nodes[ i ];
+				if( !node.IsOnGrid )
+				{
+					m_nodeGrid.AddNodeToGrid( node );
+				}
+
+				node.MovingInFrame = false;
+
+				if( drawInfo.CurrentEventType == EventType.Repaint )
+					node.OnNodeLayout( drawInfo );
+
+				m_hasUnConnectedNodes = m_hasUnConnectedNodes ||
+										( node.ConnStatus != NodeConnectionStatus.Connected && node.ConnStatus != NodeConnectionStatus.Island );
+
+				if( node.RequireMaterialUpdate && currentMaterial != null )
+				{
+					node.UpdateMaterial( currentMaterial );
+					repaintMaterialInspector = true;
+				}
+
+				//if( node.IsVisible )
+				//	m_visibleNodes.Add( node );
+
+				IsDirty = ( m_isDirty || node.IsDirty );
+				SaveIsDirty = ( m_saveIsDirty || node.SaveIsDirty );
+			}
+
+			// Handles GUI controls
+			nodeCount = m_nodes.Count;
+			for( int i = nodeCount - 1; i >= 0; i-- )
+			//for ( int i = 0; i < nodeCount; i++ )
+			{
+				node = m_nodes[ i ];
+				bool restoreMouse = false;
+				if( drawInfo.CurrentEventType == EventType.MouseDown && m_nodeClicked > -1 && node.UniqueId != m_nodeClicked )
+				{
+					restoreMouse = true;
+					drawInfo.CurrentEventType = EventType.Ignore;
+				}
+
+				node.DrawGUIControls( drawInfo );
+
+				if( restoreMouse )
+				{
+					drawInfo.CurrentEventType = EventType.MouseDown;
+				}
+			}
+
+			// Draw connection wires
+			if( drawInfo.CurrentEventType == EventType.Repaint )
+				DrawWires( ParentWindow.WireTexture, drawInfo, ParentWindow.WindowContextPallete.IsActive, ParentWindow.WindowContextPallete.CurrentPosition );
+
+			// Master Draw
+			nodeCount = m_nodes.Count;
+			for( int i = 0; i < nodeCount; i++ )
+			{
+				node = m_nodes[ i ];
+				bool restoreMouse = false;
+				if( drawInfo.CurrentEventType == EventType.MouseDown && m_nodeClicked > -1 && node.UniqueId != m_nodeClicked )
+				{
+					restoreMouse = true;
+					drawInfo.CurrentEventType = EventType.Ignore;
+				}
+
+				node.Draw( drawInfo );
+
+				if( restoreMouse )
+				{
+					drawInfo.CurrentEventType = EventType.MouseDown;
+				}
+			}
+
+			// Draw Tooltip
+			if( drawInfo.CurrentEventType == EventType.Repaint || drawInfo.CurrentEventType == EventType.MouseDown )
+			{
+				nodeCount = m_nodes.Count;
+				for( int i = nodeCount - 1; i >= 0; i-- )
+				{
+					node = m_nodes[ i ];
+					if( node.IsVisible && !node.IsMoving )
+					{
+						bool showing = node.ShowTooltip( drawInfo );
+						if( showing )
+							break;
+					}
+				}
+			}
+
+			if( repaintMaterialInspector )
+			{
+				if( ASEMaterialInspector.Instance != null )
+				{
+					ASEMaterialInspector.Instance.Repaint();
+				}
+			}
+
+			if( m_checkSelectedWireHighlights )
+			{
+				m_checkSelectedWireHighlights = false;
+				ResetHighlightedWires();
+				for( int i = 0; i < m_selectedNodes.Count; i++ )
+				{
+					HighlightWiresStartingNode( m_selectedNodes[ i ] );
+				}
+			}
+
+			if( EditorGUI.EndChangeCheck() )
+			{
+				SaveIsDirty = true;
+				repaint = true;
+			}
+
+			if( drawInfo.CurrentEventType == EventType.Repaint )
+			{
+				// Revert LOD changes to LOD0 (only if it's different)
+				if( UIUtils.MainSkin.textField.border.left != 4 )
+				{
+					UIUtils.MainSkin.textField.border = UIUtils.RectOffsetFour;
+					nodeStyleOff.border = UIUtils.RectOffsetSix;
+					UIUtils.NodeWindowOffSquare.border = UIUtils.RectOffsetFour;
+
+					nodeStyleOn.border = UIUtils.RectOffsetSix;
+					UIUtils.NodeWindowOnSquare.border = UIUtils.RectOffsetSix;
+
+					nodeTitle.border.left = 6;
+					nodeTitle.border.right = 6;
+					nodeTitle.border.top = 6;
+					nodeTitle.border.bottom = 4;
+
+					UIUtils.NodeHeaderSquare.border = UIUtils.RectOffsetFour;
+					commentaryBackground.border = UIUtils.RectOffsetSix;
+				}
+			}
+
+			//if ( nullCount == m_nodes.Count )
+			//	m_nodes.Clear();
+
+			ChangedLightingModel = false;
+
+			return repaint;
+		}
+
+		public bool UpdateMarkForDeletion()
+		{
+			if( m_markedForDeletion.Count != 0 )
+			{
+				DeleteMarkedForDeletionNodes();
+				return true;
+			}
+			return false;
+		}
+
+		public void DrawWires( Texture2D wireTex, DrawInfo drawInfo, bool contextPaletteActive, Vector3 contextPalettePos )
+		{
+			//Handles.BeginGUI();
+			//Debug.Log(GUI.depth);
+			// Draw connected node wires
+			m_wireBezierCount = 0;
+			for( int nodeIdx = 0; nodeIdx < m_nodes.Count; nodeIdx++ )
+			{
+				ParentNode node = m_nodes[ nodeIdx ];
+				if( (object)node == null )
+					return;
+
+				for( int inputPortIdx = 0; inputPortIdx < node.InputPorts.Count; inputPortIdx++ )
+				{
+					InputPort inputPort = node.InputPorts[ inputPortIdx ];
+					if(  inputPort.ExternalReferences.Count > 0 && inputPort.Visible )
+					{
+						bool cleanInvalidConnections = false;
+						for( int wireIdx = 0; wireIdx < inputPort.ExternalReferences.Count; wireIdx++ )
+						{
+							WireReference reference = inputPort.ExternalReferences[ wireIdx ];
+							if( reference.NodeId != -1 && reference.PortId != -1 )
+							{
+								ParentNode outputNode = GetNode( reference.NodeId );
+								if( outputNode != null )
+								{
+									OutputPort outputPort = outputNode.GetOutputPortByUniqueId( reference.PortId );
+									Vector3 endPos = new Vector3( inputPort.Position.x, inputPort.Position.y );
+									Vector3 startPos = new Vector3( outputPort.Position.x, outputPort.Position.y );
+									float x = ( startPos.x < endPos.x ) ? startPos.x : endPos.x;
+									float y = ( startPos.y < endPos.y ) ? startPos.y : endPos.y;
+									float width = Mathf.Abs( startPos.x - endPos.x ) + outputPort.Position.width;
+									float height = Mathf.Abs( startPos.y - endPos.y ) + outputPort.Position.height;
+									Rect portsBoundingBox = new Rect( x, y, width, height );
+
+									bool isVisible = node.IsVisible || outputNode.IsVisible;
+									if( !isVisible )
+									{
+										isVisible = drawInfo.TransformedCameraArea.Overlaps( portsBoundingBox );
+									}
+
+									if( isVisible )
+									{
+
+										Rect bezierBB = DrawBezier( drawInfo.InvertedZoom, startPos, endPos, inputPort.DataType, outputPort.DataType, node.GetInputPortVisualDataTypeByArrayIdx( inputPortIdx ), outputNode.GetOutputPortVisualDataTypeById( reference.PortId ), reference.WireStatus, wireTex, node, outputNode );
+										bezierBB.x -= Constants.OUTSIDE_WIRE_MARGIN;
+										bezierBB.y -= Constants.OUTSIDE_WIRE_MARGIN;
+
+										bezierBB.width += Constants.OUTSIDE_WIRE_MARGIN * 2;
+										bezierBB.height += Constants.OUTSIDE_WIRE_MARGIN * 2;
+
+										if( m_wireBezierCount < m_bezierReferences.Count )
+										{
+											m_bezierReferences[ m_wireBezierCount ].UpdateInfo( ref bezierBB, inputPort.NodeId, inputPort.PortId, outputPort.NodeId, outputPort.PortId );
+										}
+										else
+										{
+											m_bezierReferences.Add( new WireBezierReference( ref bezierBB, inputPort.NodeId, inputPort.PortId, outputPort.NodeId, outputPort.PortId ) );
+										}
+										m_wireBezierCount++;
+
+									}
+								}
+								else
+								{
+									if( DebugConsoleWindow.DeveloperMode )
+										UIUtils.ShowMessage( "Detected Invalid connection from node " + node.UniqueId + " port " + inputPortIdx + " to Node " + reference.NodeId + " port " + reference.PortId, MessageSeverity.Error );
+									cleanInvalidConnections = true;
+									inputPort.ExternalReferences[ wireIdx ].Invalidate();
+								}
+							}
+						}
+
+						if( cleanInvalidConnections )
+						{
+							inputPort.RemoveInvalidConnections();
+						}
+					}
+				}
+			}
+
+			//Draw selected wire
+			if( m_parentWindow.WireReferenceUtils.ValidReferences() )
+			{
+				if( m_parentWindow.WireReferenceUtils.InputPortReference.IsValid )
+				{
+					InputPort inputPort = GetNode( m_parentWindow.WireReferenceUtils.InputPortReference.NodeId ).GetInputPortByUniqueId( m_parentWindow.WireReferenceUtils.InputPortReference.PortId );
+					Vector3 endPos = Vector3.zero;
+					if( m_parentWindow.WireReferenceUtils.SnapEnabled )
+					{
+						Vector2 pos = ( m_parentWindow.WireReferenceUtils.SnapPosition + drawInfo.CameraOffset ) * drawInfo.InvertedZoom;
+						endPos = new Vector3( pos.x, pos.y ) + UIUtils.ScaledPortsDelta;
+					}
+					else
+					{
+						endPos = contextPaletteActive ? contextPalettePos : new Vector3( Event.current.mousePosition.x, Event.current.mousePosition.y );
+					}
+
+					Vector3 startPos = new Vector3( inputPort.Position.x, inputPort.Position.y );
+					DrawBezier( drawInfo.InvertedZoom, endPos, startPos, inputPort.DataType, inputPort.DataType, inputPort.DataType, inputPort.DataType, WireStatus.Default, wireTex );
+				}
+
+				if( m_parentWindow.WireReferenceUtils.OutputPortReference.IsValid )
+				{
+					OutputPort outputPort = GetNode( m_parentWindow.WireReferenceUtils.OutputPortReference.NodeId ).GetOutputPortByUniqueId( m_parentWindow.WireReferenceUtils.OutputPortReference.PortId );
+					Vector3 endPos = Vector3.zero;
+					if( m_parentWindow.WireReferenceUtils.SnapEnabled )
+					{
+						Vector2 pos = ( m_parentWindow.WireReferenceUtils.SnapPosition + drawInfo.CameraOffset ) * drawInfo.InvertedZoom;
+						endPos = new Vector3( pos.x, pos.y ) + UIUtils.ScaledPortsDelta;
+					}
+					else
+					{
+						endPos = contextPaletteActive ? contextPalettePos : new Vector3( Event.current.mousePosition.x, Event.current.mousePosition.y );
+					}
+					Vector3 startPos = new Vector3( outputPort.Position.x, outputPort.Position.y );
+					DrawBezier( drawInfo.InvertedZoom, startPos, endPos, outputPort.DataType, outputPort.DataType, outputPort.DataType, outputPort.DataType, WireStatus.Default, wireTex );
+				}
+			}
+			//Handles.EndGUI();
+		}
+
+		Rect DrawBezier( float invertedZoom, Vector3 startPos, Vector3 endPos, WirePortDataType inputDataType, WirePortDataType outputDataType, WirePortDataType inputVisualDataType, WirePortDataType outputVisualDataType, WireStatus wireStatus, Texture2D wireTex, ParentNode inputNode = null, ParentNode outputNode = null )
+		{
+			startPos += UIUtils.ScaledPortsDelta;
+			endPos += UIUtils.ScaledPortsDelta;
+
+			// Calculate the 4 points for bezier taking into account wire nodes and their automatic tangents
+			float mag = ( endPos - startPos ).magnitude;
+			float resizedMag = Mathf.Min( mag * 0.66f, Constants.HORIZONTAL_TANGENT_SIZE * invertedZoom );
+
+			Vector3 startTangent = new Vector3( startPos.x + resizedMag, startPos.y );
+			Vector3 endTangent = new Vector3( endPos.x - resizedMag, endPos.y );
+
+			if( (object)inputNode != null && inputNode.GetType() == typeof( WireNode ) )
+				endTangent = endPos + ( ( inputNode as WireNode ).TangentDirection ) * mag * 0.33f;
+
+			if( (object)outputNode != null && outputNode.GetType() == typeof( WireNode ) )
+				startTangent = startPos - ( ( outputNode as WireNode ).TangentDirection ) * mag * 0.33f;
+
+			///////////////Draw tangents
+			//Rect box1 = new Rect( new Vector2( startTangent.x, startTangent.y ), new Vector2( 10, 10 ) );
+			//box1.x -= box1.width * 0.5f;
+			//box1.y -= box1.height * 0.5f;
+			//GUI.Label( box1, string.Empty, UIUtils.Box );
+
+			//Rect box2 = new Rect( new Vector2( endTangent.x, endTangent.y ), new Vector2( 10, 10 ) );
+			//box2.x -= box2.width * 0.5f;
+			//box2.y -= box2.height * 0.5f;
+			//GUI.Label( box2, string.Empty, UIUtils.Box );
+
+			//m_auxRect.Set( 0, 0, UIUtils.CurrentWindow.position.width, UIUtils.CurrentWindow.position.height );
+			//GLDraw.BeginGroup( m_auxRect );
+
+			int ty = 1;
+			float wireThickness = 0;
+
+
+			if( ParentWindow.Options.MultiLinePorts )
+			{
+				GLDraw.MultiLine = true;
+				Shader.SetGlobalFloat( "_InvertedZoom", invertedZoom );
+
+				WirePortDataType smallest = ( (int)outputDataType < (int)inputDataType ? outputDataType : inputDataType );
+				smallest = ( (int)smallest < (int)outputVisualDataType ? smallest : outputVisualDataType );
+				smallest = ( (int)smallest < (int)inputVisualDataType ? smallest : inputVisualDataType );
+
+				switch( smallest )
+				{
+					case WirePortDataType.FLOAT2: ty = 2; break;
+					case WirePortDataType.FLOAT3: ty = 3; break;
+					case WirePortDataType.FLOAT4:
+					case WirePortDataType.COLOR:
+					{
+						ty = 4;
+					}
+					break;
+					default: ty = 1; break;
+				}
+				wireThickness = Mathf.Lerp( Constants.WIRE_WIDTH * ( ty * invertedZoom * -0.05f + 0.15f ), Constants.WIRE_WIDTH * ( ty * invertedZoom * 0.175f + 0.3f ), invertedZoom + 0.4f );
+			}
+			else
+			{
+				GLDraw.MultiLine = false;
+				wireThickness = Mathf.Lerp( Constants.WIRE_WIDTH * ( invertedZoom * -0.05f + 0.15f ), Constants.WIRE_WIDTH * ( invertedZoom * 0.175f + 0.3f ), invertedZoom + 0.4f );
+			}
+
+			Rect boundBox = new Rect();
+			int segments = 11;
+			if( LodLevel <= ParentGraph.NodeLOD.LOD4 )
+				segments = Mathf.Clamp( Mathf.FloorToInt( mag * 0.2f * invertedZoom ), 11, 35 );
+			else
+				segments = (int)( invertedZoom * 14.28f * 11 );
+
+			if( ParentWindow.Options.ColoredPorts && wireStatus != WireStatus.Highlighted )
+				boundBox = GLDraw.DrawBezier( startPos, startTangent, endPos, endTangent, UIUtils.GetColorForDataType( outputVisualDataType, false, false ), UIUtils.GetColorForDataType( inputVisualDataType, false, false ), wireThickness, segments, ty );
+			else
+				boundBox = GLDraw.DrawBezier( startPos, startTangent, endPos, endTangent, UIUtils.GetColorFromWireStatus( wireStatus ), wireThickness, segments, ty );
+			//GLDraw.EndGroup();
+
+			//GUI.Box( m_auxRect, string.Empty, UIUtils.CurrentWindow.CustomStylesInstance.Box );
+			//GUI.Box( boundBox, string.Empty, UIUtils.CurrentWindow.CustomStylesInstance.Box );
+			//if ( UIUtils.CurrentWindow.Options.ColoredPorts && wireStatus != WireStatus.Highlighted )
+			//	Handles.DrawBezier( startPos, endPos, startTangent, endTangent, UIUtils.GetColorForDataType( outputDataType, false, false ), wireTex, wiresTickness );
+			//else
+			//	Handles.DrawBezier( startPos, endPos, startTangent, endTangent, UIUtils.GetColorFromWireStatus( wireStatus ), wireTex, wiresTickness );
+
+			//Handles.DrawLine( startPos, startTangent );
+			//Handles.DrawLine( endPos, endTangent );
+
+			float extraBound = 30 * invertedZoom;
+			boundBox.xMin -= extraBound;
+			boundBox.xMax += extraBound;
+			boundBox.yMin -= extraBound;
+			boundBox.yMax += extraBound;
+
+			return boundBox;
+		}
+
+		public void DrawBezierBoundingBox()
+		{
+			for( int i = 0; i < m_wireBezierCount; i++ )
+			{
+				m_bezierReferences[ i ].DebugDraw();
+			}
+		}
+
+		public WireBezierReference GetWireBezierInPos( Vector2 position )
+		{
+			for( int i = 0; i < m_wireBezierCount; i++ )
+			{
+				if( m_bezierReferences[ i ].Contains( position ) )
+					return m_bezierReferences[ i ];
+			}
+			return null;
+		}
+
+
+		public List<WireBezierReference> GetWireBezierListInPos( Vector2 position )
+		{
+			List<WireBezierReference> list = new List<WireBezierReference>();
+			for( int i = 0; i < m_wireBezierCount; i++ )
+			{
+				if( m_bezierReferences[ i ].Contains( position ) )
+					list.Add( m_bezierReferences[ i ] );
+			}
+
+			return list;
+		}
+
+
+		public void MoveSelectedNodes( Vector2 delta, bool snap = false )
+		{
+			//bool validMovement = delta.magnitude > 0.001f;
+			//if ( validMovement )
+			//{
+			//	Undo.RegisterCompleteObjectUndo( ParentWindow, Constants.UndoMoveNodesId );
+			//	for ( int i = 0; i < m_selectedNodes.Count; i++ )
+			//	{
+			//		if ( !m_selectedNodes[ i ].MovingInFrame )
+			//		{
+			//			Undo.RecordObject( m_selectedNodes[ i ], Constants.UndoMoveNodesId );
+			//			m_selectedNodes[ i ].Move( delta, snap );
+			//		}
+			//	}
+			//	IsDirty = true;
+			//}
+
+			bool performUndo = delta.magnitude > 0.01f;
+			if( performUndo )
+			{
+				Undo.RegisterCompleteObjectUndo( ParentWindow, Constants.UndoMoveNodesId );
+				Undo.RegisterCompleteObjectUndo( this, Constants.UndoMoveNodesId );
+			}
+
+			for( int i = 0; i < m_selectedNodes.Count; i++ )
+			{
+				if( !m_selectedNodes[ i ].MovingInFrame )
+				{
+					if( performUndo )
+						m_selectedNodes[ i ].RecordObject( Constants.UndoMoveNodesId );
+					m_selectedNodes[ i ].Move( delta, snap );
+				}
+			}
+
+			IsDirty = true;
+		}
+
+		public void SetConnection( int InNodeId, int InPortId, int OutNodeId, int OutPortId )
+		{
+			ParentNode inNode = GetNode( InNodeId );
+			ParentNode outNode = GetNode( OutNodeId );
+			InputPort inputPort = null;
+			OutputPort outputPort = null;
+			if( inNode != null && outNode != null )
+			{
+				inputPort = inNode.GetInputPortByUniqueId( InPortId );
+				outputPort = outNode.GetOutputPortByUniqueId( OutPortId );
+				if( inputPort != null && outputPort != null )
+				{
+					if( inputPort.IsConnectedTo( OutNodeId, OutPortId ) || outputPort.IsConnectedTo( InNodeId, InPortId ) )
+					{
+						if( DebugConsoleWindow.DeveloperMode )
+							UIUtils.ShowMessage( "Node/Port already connected " + InNodeId, MessageSeverity.Error );
+						return;
+					}
+
+					if( !inputPort.CheckValidType( outputPort.DataType ) )
+					{
+						if( DebugConsoleWindow.DeveloperMode )
+							UIUtils.ShowIncompatiblePortMessage( true, inNode, inputPort, outNode, outputPort );
+						return;
+					}
+
+					if( !outputPort.CheckValidType( inputPort.DataType ) )
+					{
+
+						if( DebugConsoleWindow.DeveloperMode )
+							UIUtils.ShowIncompatiblePortMessage( false, outNode, outputPort, inNode, inputPort );
+						return;
+					}
+					if( !inputPort.Available || !outputPort.Available )
+					{
+						if( DebugConsoleWindow.DeveloperMode )
+							UIUtils.ShowMessage( "Ports not available to connection", MessageSeverity.Warning );
+
+						return;
+					}
+
+					if( inputPort.ConnectTo( OutNodeId, OutPortId, outputPort.DataType, false ) )
+					{
+						inNode.OnInputPortConnected( InPortId, OutNodeId, OutPortId );
+					}
+
+
+					if( outputPort.ConnectTo( InNodeId, InPortId, inputPort.DataType, inputPort.TypeLocked ) )
+					{
+						outNode.OnOutputPortConnected( OutPortId, InNodeId, InPortId );
+					}
+				}
+				else if( (object)inputPort == null )
+				{
+					if( DebugConsoleWindow.DeveloperMode )
+						UIUtils.ShowMessage( "Input Port " + InPortId + " doesn't exist on node " + InNodeId, MessageSeverity.Error );
+				}
+				else
+				{
+					if( DebugConsoleWindow.DeveloperMode )
+						UIUtils.ShowMessage( "Output Port " + OutPortId + " doesn't exist on node " + OutNodeId, MessageSeverity.Error );
+				}
+			}
+			else if( (object)inNode == null )
+			{
+				if( DebugConsoleWindow.DeveloperMode )
+					UIUtils.ShowMessage( "Input node " + InNodeId + " doesn't exist", MessageSeverity.Error );
+			}
+			else
+			{
+				if( DebugConsoleWindow.DeveloperMode )
+					UIUtils.ShowMessage( "Output node " + OutNodeId + " doesn't exist", MessageSeverity.Error );
+			}
+		}
+
+		public void CreateConnection( int inNodeId, int inPortId, int outNodeId, int outPortId, bool registerUndo = true )
+		{
+			ParentNode outputNode = GetNode( outNodeId );
+			if( outputNode != null )
+			{
+				OutputPort outputPort = outputNode.GetOutputPortByUniqueId( outPortId );
+				if( outputPort != null )
+				{
+					ParentNode inputNode = GetNode( inNodeId );
+					InputPort inputPort = inputNode.GetInputPortByUniqueId( inPortId );
+
+					if( !inputPort.CheckValidType( outputPort.DataType ) )
+					{
+						UIUtils.ShowIncompatiblePortMessage( true, inputNode, inputPort, outputNode, outputPort );
+						return;
+					}
+
+					if( !outputPort.CheckValidType( inputPort.DataType ) )
+					{
+						UIUtils.ShowIncompatiblePortMessage( false, outputNode, outputPort, inputNode, inputPort );
+						return;
+					}
+
+					inputPort.DummyAdd( outputPort.NodeId, outputPort.PortId );
+					outputPort.DummyAdd( inNodeId, inPortId );
+
+					if( UIUtils.DetectNodeLoopsFrom( inputNode, new Dictionary<int, int>() ) )
+					{
+						inputPort.DummyRemove();
+						outputPort.DummyRemove();
+						m_parentWindow.WireReferenceUtils.InvalidateReferences();
+						UIUtils.ShowMessage( "Infinite Loop detected" );
+						Event.current.Use();
+						return;
+					}
+
+					inputPort.DummyRemove();
+					outputPort.DummyRemove();
+
+					if( inputPort.IsConnected )
+					{
+						DeleteConnection( true, inNodeId, inPortId, true, false, registerUndo );
+					}
+
+					//link output to input
+					if( outputPort.ConnectTo( inNodeId, inPortId, inputPort.DataType, inputPort.TypeLocked ) )
+						outputNode.OnOutputPortConnected( outputPort.PortId, inNodeId, inPortId );
+
+					//link input to output
+					if( inputPort.ConnectTo( outputPort.NodeId, outputPort.PortId, outputPort.DataType, inputPort.TypeLocked ) )
+						inputNode.OnInputPortConnected( inPortId, outputNode.UniqueId, outputPort.PortId );
+
+					MarkWireHighlights();
+				}
+				SaveIsDirty = true;
+				//ParentWindow.ShaderIsModified = true;
+			}
+		}
+
+		public void DeleteInvalidConnections()
+		{
+			int count = m_nodes.Count;
+			for( int nodeIdx = 0; nodeIdx < count; nodeIdx++ )
+			{
+				{
+					int inputCount = m_nodes[ nodeIdx ].InputPorts.Count;
+					for( int inputIdx = 0; inputIdx < inputCount; inputIdx++ )
+					{
+						if( !m_nodes[ nodeIdx ].InputPorts[ inputIdx ].Visible &&
+							m_nodes[ nodeIdx ].InputPorts[ inputIdx ].IsConnected &&
+							!m_nodes[ nodeIdx ].InputPorts[ inputIdx ].IsDummy )
+						{
+							DeleteConnection( true, m_nodes[ nodeIdx ].UniqueId, m_nodes[ nodeIdx ].InputPorts[ inputIdx ].PortId, true, true );
+						}
+					}
+				}
+				{
+					int outputCount = m_nodes[ nodeIdx ].OutputPorts.Count;
+					for( int outputIdx = 0; outputIdx < outputCount; outputIdx++ )
+					{
+						if( !m_nodes[ nodeIdx ].OutputPorts[ outputIdx ].Visible && m_nodes[ nodeIdx ].OutputPorts[ outputIdx ].IsConnected )
+						{
+							DeleteConnection( false, m_nodes[ nodeIdx ].UniqueId, m_nodes[ nodeIdx ].OutputPorts[ outputIdx ].PortId, true, true );
+						}
+					}
+				}
+			}
+		}
+
+		public void DeleteAllConnectionFromNode( int nodeId, bool registerOnLog, bool propagateCallback, bool registerUndo )
+		{
+			ParentNode node = GetNode( nodeId );
+			if( (object)node == null )
+				return;
+			DeleteAllConnectionFromNode( node, registerOnLog, propagateCallback, registerUndo );
+		}
+
+		public void DeleteAllConnectionFromNode( ParentNode node, bool registerOnLog, bool propagateCallback, bool registerUndo )
+		{
+
+			for( int i = 0; i < node.InputPorts.Count; i++ )
+			{
+				if( node.InputPorts[ i ].IsConnected )
+					DeleteConnection( true, node.UniqueId, node.InputPorts[ i ].PortId, registerOnLog, propagateCallback, registerUndo );
+			}
+
+			for( int i = 0; i < node.OutputPorts.Count; i++ )
+			{
+				if( node.OutputPorts[ i ].IsConnected )
+					DeleteConnection( false, node.UniqueId, node.OutputPorts[ i ].PortId, registerOnLog, propagateCallback, registerUndo );
+			}
+		}
+
+		public void DeleteConnection( bool isInput, int nodeId, int portId, bool registerOnLog, bool propagateCallback, bool registerUndo = true )
+		{
+			ParentNode node = GetNode( nodeId );
+			if( (object)node == null )
+				return;
+
+			if( registerUndo )
+			{
+				UIUtils.MarkUndoAction();
+				Undo.RegisterCompleteObjectUndo( ParentWindow, Constants.UndoDeleteConnectionId );
+				Undo.RegisterCompleteObjectUndo( this, Constants.UndoDeleteConnectionId );
+				node.RecordObject( Constants.UndoDeleteConnectionId );
+			}
+
+			if( isInput )
+			{
+				InputPort inputPort = node.GetInputPortByUniqueId( portId );
+				if( inputPort != null && inputPort.IsConnected )
+				{
+
+					if( node.ConnStatus == NodeConnectionStatus.Connected )
+					{
+						node.DeactivateInputPortNode( portId, false );
+						//inputPort.GetOutputNode().DeactivateNode( portId, false );
+						m_checkSelectedWireHighlights = true;
+					}
+
+					for( int i = 0; i < inputPort.ExternalReferences.Count; i++ )
+					{
+						WireReference inputReference = inputPort.ExternalReferences[ i ];
+						ParentNode outputNode = GetNode( inputReference.NodeId );
+						if( registerUndo )
+							outputNode.RecordObject( Constants.UndoDeleteConnectionId );
+						outputNode.GetOutputPortByUniqueId( inputReference.PortId ).InvalidateConnection( inputPort.NodeId, inputPort.PortId );
+						if( propagateCallback )
+							outputNode.OnOutputPortDisconnected( inputReference.PortId );
+					}
+					inputPort.InvalidateAllConnections();
+					if( propagateCallback )
+						node.OnInputPortDisconnected( portId );
+				}
+			}
+			else
+			{
+				OutputPort outputPort = node.GetOutputPortByUniqueId( portId );
+				if( outputPort != null && outputPort.IsConnected )
+				{
+					if( propagateCallback )
+						node.OnOutputPortDisconnected( portId );
+
+					for( int i = 0; i < outputPort.ExternalReferences.Count; i++ )
+					{
+						WireReference outputReference = outputPort.ExternalReferences[ i ];
+						ParentNode inputNode = GetNode( outputReference.NodeId );
+						if( registerUndo )
+							inputNode.RecordObject( Constants.UndoDeleteConnectionId );
+						if( inputNode.ConnStatus == NodeConnectionStatus.Connected )
+						{
+							node.DeactivateNode( portId, false );
+							m_checkSelectedWireHighlights = true;
+						}
+						inputNode.GetInputPortByUniqueId( outputReference.PortId ).InvalidateConnection( outputPort.NodeId, outputPort.PortId );
+						if( propagateCallback )
+						{
+							// Removing WireNodes fires this after the rewiring ( and the OnInputPortConnected callback ) which causes incorrect behaviors
+							// If is connected is true then we're on that case so we don't fire the OnInputPortDisconnected
+							if( !inputNode.GetInputPortByUniqueId( outputReference.PortId ).IsConnected )
+								inputNode.OnInputPortDisconnected( outputReference.PortId );
+						}
+					}
+					outputPort.InvalidateAllConnections();
+				}
+			}
+			IsDirty = true;
+			SaveIsDirty = true;
+		}
+
+		//public void DeleteSelectedNodes()
+		//{
+		//	bool invalidateMasterNode = false;
+		//	int count = m_selectedNodes.Count;
+		//	for( int nodeIdx = 0; nodeIdx < count; nodeIdx++ )
+		//	{
+		//		ParentNode node = m_selectedNodes[ nodeIdx ];
+		//		if( node.UniqueId == m_masterNodeId )
+		//		{
+		//			invalidateMasterNode = true;
+		//		}
+		//		else
+		//		{
+		//			DestroyNode( node );
+		//		}
+		//	}
+
+		//	if( invalidateMasterNode )
+		//	{
+		//		CurrentOutputNode.Selected = false;
+		//	}
+		//	//Clear all references
+		//	m_selectedNodes.Clear();
+		//	IsDirty = true;
+		//}
+
+		public void DeleteNodesOnArray( ref ParentNode[] nodeArray )
+		{
+			bool invalidateMasterNode = false;
+			for( int nodeIdx = 0; nodeIdx < nodeArray.Length; nodeIdx++ )
+			{
+				ParentNode node = nodeArray[ nodeIdx ];
+				if( node.UniqueId == m_masterNodeId )
+				{
+					FunctionOutput fout = node as FunctionOutput;
+					if( fout != null )
+					{
+						for( int i = 0; i < m_nodes.Count; i++ )
+						{
+							FunctionOutput secondfout = m_nodes[ i ] as FunctionOutput;
+							if( secondfout != null && secondfout != fout )
+							{
+								secondfout.Function = fout.Function;
+								AssignMasterNode( secondfout, false );
+
+								DeselectNode( fout );
+								DestroyNode( fout );
+								break;
+							}
+						}
+					}
+					invalidateMasterNode = true;
+				}
+				else
+				{
+					DeselectNode( node );
+					DestroyNode( node );
+				}
+				nodeArray[ nodeIdx ] = null;
+			}
+
+			if( invalidateMasterNode && CurrentMasterNode != null )
+			{
+				CurrentMasterNode.Selected = false;
+			}
+
+			//Clear all references
+			nodeArray = null;
+			IsDirty = true;
+		}
+
+		public void MarkWireNodeSequence( WireNode node, bool isInput )
+		{
+			if( node == null )
+			{
+				return;
+			}
+
+			if( m_markedForDeletion.Contains( node ) )
+				return;
+
+			m_markedForDeletion.Add( node );
+
+			if( isInput && node.InputPorts[ 0 ].IsConnected )
+			{
+				MarkWireNodeSequence( GetNode( node.InputPorts[ 0 ].ExternalReferences[ 0 ].NodeId ) as WireNode, isInput );
+			}
+			else if( !isInput && node.OutputPorts[ 0 ].IsConnected )
+			{
+				MarkWireNodeSequence( GetNode( node.OutputPorts[ 0 ].ExternalReferences[ 0 ].NodeId ) as WireNode, isInput );
+			}
+		}
+
+		public void UndoableDeleteSelectedNodes( List<ParentNode> nodeList )
+		{
+			if( nodeList.Count == 0 )
+				return;
+
+			List<ParentNode> validNode = new List<ParentNode>();
+
+			for( int i = 0; i < nodeList.Count; i++ )
+			{
+				if( nodeList[ i ] != null && nodeList[ i ].UniqueId != m_masterNodeId )
+				{
+					validNode.Add( nodeList[ i ] );
+				}
+			}
+			UIUtils.ClearUndoHelper();
+			ParentNode[] selectedNodes = new ParentNode[ validNode.Count ];
+			for( int i = 0; i < selectedNodes.Length; i++ )
+			{
+				if( validNode[ i ] != null )
+				{
+					selectedNodes[ i ] = validNode[ i ];
+					UIUtils.CheckUndoNode( selectedNodes[ i ] );
+				}
+			}
+
+			//Check nodes connected to deleted nodes to preserve connections on undo
+			List<ParentNode> extraNodes = new List<ParentNode>();
+			for( int selectedNodeIdx = 0; selectedNodeIdx < selectedNodes.Length; selectedNodeIdx++ )
+			{
+				// Check inputs
+				if( selectedNodes[ selectedNodeIdx ] != null )
+				{
+					int inputIdxCount = selectedNodes[ selectedNodeIdx ].InputPorts.Count;
+					if( inputIdxCount > 0 )
+					{
+						for( int inputIdx = 0; inputIdx < inputIdxCount; inputIdx++ )
+						{
+							if( selectedNodes[ selectedNodeIdx ].InputPorts[ inputIdx ].IsConnected )
+							{
+								int nodeIdx = selectedNodes[ selectedNodeIdx ].InputPorts[ inputIdx ].ExternalReferences[ 0 ].NodeId;
+								if( nodeIdx > -1 )
+								{
+									ParentNode node = GetNode( nodeIdx );
+									if( node != null && UIUtils.CheckUndoNode( node ) )
+									{
+										extraNodes.Add( node );
+									}
+								}
+							}
+						}
+					}
+				}
+
+				// Check outputs
+				if( selectedNodes[ selectedNodeIdx ] != null )
+				{
+					int outputIdxCount = selectedNodes[ selectedNodeIdx ].OutputPorts.Count;
+					if( outputIdxCount > 0 )
+					{
+						for( int outputIdx = 0; outputIdx < outputIdxCount; outputIdx++ )
+						{
+							int inputIdxCount = selectedNodes[ selectedNodeIdx ].OutputPorts[ outputIdx ].ExternalReferences.Count;
+							if( inputIdxCount > 0 )
+							{
+								for( int inputIdx = 0; inputIdx < inputIdxCount; inputIdx++ )
+								{
+									int nodeIdx = selectedNodes[ selectedNodeIdx ].OutputPorts[ outputIdx ].ExternalReferences[ inputIdx ].NodeId;
+									if( nodeIdx > -1 )
+									{
+										ParentNode node = GetNode( nodeIdx );
+										if( UIUtils.CheckUndoNode( node ) )
+										{
+											extraNodes.Add( node );
+										}
+									}
+								}
+							}
+						}
+					}
+
+				}
+			}
+
+			UIUtils.ClearUndoHelper();
+			//Record deleted nodes
+			UIUtils.MarkUndoAction();
+			Undo.RegisterCompleteObjectUndo( ParentWindow, Constants.UndoDeleteNodeId );
+			Undo.RegisterCompleteObjectUndo( this, Constants.UndoDeleteNodeId );
+			Undo.RecordObjects( selectedNodes, Constants.UndoDeleteNodeId );
+			Undo.RecordObjects( extraNodes.ToArray(), Constants.UndoDeleteNodeId );
+
+			//Record deleting connections
+			for( int i = 0; i < selectedNodes.Length; i++ )
+			{
+				CurrentOutputNode.Selected = false;
+				selectedNodes[ i ].Alive = false;
+				DeleteAllConnectionFromNode( selectedNodes[ i ], false, true, true );
+			}
+			//Delete
+			DeleteNodesOnArray( ref selectedNodes );
+
+			extraNodes.Clear();
+			extraNodes = null;
+
+			EditorUtility.SetDirty( ParentWindow );
+
+			ParentWindow.ForceRepaint();
+		}
+
+		public void DeleteMarkedForDeletionNodes()
+		{
+			UndoableDeleteSelectedNodes( m_markedForDeletion );
+			m_markedForDeletion.Clear();
+			IsDirty = true;
+
+			//bool invalidateMasterNode = false;
+			//int count = m_markedForDeletion.Count;
+			//for ( int nodeIdx = 0; nodeIdx < count; nodeIdx++ )
+			//{
+			//	ParentNode node = m_markedForDeletion[ nodeIdx ];
+			//	if ( node.UniqueId == m_masterNodeId )
+			//	{
+			//		invalidateMasterNode = true;
+			//	}
+			//	else
+			//	{
+			//		if ( node.Selected )
+			//		{
+			//			m_selectedNodes.Remove( node );
+			//			node.Selected = false;
+			//		}
+			//		DestroyNode( node );
+			//	}
+			//}
+
+			//if ( invalidateMasterNode )
+			//{
+			//	CurrentMasterNode.Selected = false;
+			//}
+			////Clear all references
+			//m_markedForDeletion.Clear();
+			//IsDirty = true;
+		}
+
+		public void DestroyNode( int nodeId )
+		{
+			ParentNode node = GetNode( nodeId );
+			DestroyNode( node );
+		}
+
+		public void DestroyNode( ParentNode node, bool registerUndo = true, bool destroyMasterNode = false )
+		{
+			if( node == null )
+			{
+				UIUtils.ShowMessage( "Attempting to destroying a inexistant node ", MessageSeverity.Warning );
+				return;
+			}
+
+			if( node.ConnStatus == NodeConnectionStatus.Connected && !m_checkSelectedWireHighlights )
+			{
+				ResetHighlightedWires();
+				m_checkSelectedWireHighlights = true;
+			}
+
+			//TODO: check better placement of this code (reconnects wires from wire nodes)
+			//if ( node.GetType() == typeof( WireNode ) )
+			//{
+			//	if ( node.InputPorts[ 0 ].ExternalReferences != null && node.InputPorts[ 0 ].ExternalReferences.Count > 0 )
+			//	{
+			//		WireReference backPort = node.InputPorts[ 0 ].ExternalReferences[ 0 ];
+			//		for ( int i = 0; i < node.OutputPorts[ 0 ].ExternalReferences.Count; i++ )
+			//		{
+			//			UIUtils.CurrentWindow.ConnectInputToOutput( node.OutputPorts[ 0 ].ExternalReferences[ i ].NodeId, node.OutputPorts[ 0 ].ExternalReferences[ i ].PortId, backPort.NodeId, backPort.PortId );
+			//		}
+			//	}
+			//}
+			if( destroyMasterNode || ( node.UniqueId != m_masterNodeId && !( node is TemplateMultiPassMasterNode )/*!m_multiPassMasterNodes.HasNode( node.UniqueId )*/ ) )
+			{
+				m_nodeGrid.RemoveNodeFromGrid( node, false );
+				//Send Deactivation signal if active
+				if( node.ConnStatus == NodeConnectionStatus.Connected )
+				{
+					node.DeactivateNode( -1, true );
+				}
+
+				//Invalidate references
+				//Invalidate input references
+				for( int inputPortIdx = 0; inputPortIdx < node.InputPorts.Count; inputPortIdx++ )
+				{
+					InputPort inputPort = node.InputPorts[ inputPortIdx ];
+					if( inputPort.IsConnected )
+					{
+						for( int wireIdx = 0; wireIdx < inputPort.ExternalReferences.Count; wireIdx++ )
+						{
+							WireReference inputReference = inputPort.ExternalReferences[ wireIdx ];
+							ParentNode outputNode = GetNode( inputReference.NodeId );
+							outputNode.GetOutputPortByUniqueId( inputReference.PortId ).InvalidateConnection( inputPort.NodeId, inputPort.PortId );
+							outputNode.OnOutputPortDisconnected( inputReference.PortId );
+						}
+						inputPort.InvalidateAllConnections();
+					}
+				}
+
+				//Invalidate output reference
+				for( int outputPortIdx = 0; outputPortIdx < node.OutputPorts.Count; outputPortIdx++ )
+				{
+					OutputPort outputPort = node.OutputPorts[ outputPortIdx ];
+					if( outputPort.IsConnected )
+					{
+						for( int wireIdx = 0; wireIdx < outputPort.ExternalReferences.Count; wireIdx++ )
+						{
+							WireReference outputReference = outputPort.ExternalReferences[ wireIdx ];
+							ParentNode outnode = GetNode( outputReference.NodeId );
+							if( outnode != null )
+							{
+								outnode.GetInputPortByUniqueId( outputReference.PortId ).InvalidateConnection( outputPort.NodeId, outputPort.PortId );
+								outnode.OnInputPortDisconnected( outputReference.PortId );
+							}
+						}
+						outputPort.InvalidateAllConnections();
+					}
+				}
+
+				//Remove node from main list
+				//Undo.RecordObject( node, "Destroying node " + ( node.Attributes != null? node.Attributes.Name: node.GetType().ToString() ) );
+				if( registerUndo )
+				{
+					UIUtils.MarkUndoAction();
+					Undo.RegisterCompleteObjectUndo( ParentWindow, Constants.UndoDeleteNodeId );
+					Undo.RegisterCompleteObjectUndo( this, Constants.UndoDeleteNodeId );
+					node.RecordObjectOnDestroy( Constants.UndoDeleteNodeId );
+				}
+
+				if( OnNodeRemovedEvent != null )
+					OnNodeRemovedEvent( node );
+
+				m_nodes.Remove( node );
+				m_nodesDict.Remove( node.UniqueId );
+				node.Destroy();
+				if( registerUndo )
+					Undo.DestroyObjectImmediate( node );
+				else
+					DestroyImmediate( node );
+				IsDirty = true;
+				m_markToReOrder = true;
+			}
+			//else if( node.UniqueId == m_masterNodeId && node.GetType() == typeof(FunctionOutput) )
+			//{
+			//	Debug.Log( "Attempting to destroy a output node" );
+			//	DeselectNode( node );
+			//	UIUtils.ShowMessage( "Attempting to destroy a output node" );
+			//}
+			else
+			{
+				TemplateMultiPassMasterNode templateMasterNode = node as TemplateMultiPassMasterNode;
+				if( templateMasterNode != null && templateMasterNode.InvalidNode )
+				{
+					DestroyNode( node, false, true );
+					return;
+				}
+
+				DeselectNode( node );
+				UIUtils.ShowMessage( "Attempting to destroy a master node" );
+			}
+		}
+
+		void AddToSelectedNodes( ParentNode node )
+		{
+			node.Selected = true;
+			m_selectedNodes.Add( node );
+			node.OnNodeStoppedMovingEvent += OnNodeFinishMoving;
+			if( node.ConnStatus == NodeConnectionStatus.Connected )
+			{
+				HighlightWiresStartingNode( node );
+			}
+		}
+
+		void RemoveFromSelectedNodes( ParentNode node )
+		{
+			node.Selected = false;
+			m_selectedNodes.Remove( node );
+			node.OnNodeStoppedMovingEvent -= OnNodeFinishMoving;
+		}
+
+		public void SelectNode( ParentNode node, bool append, bool reorder )
+		{
+			if( node == null )
+				return;
+
+			if( append )
+			{
+				if( !m_selectedNodes.Contains( node ) )
+				{
+					AddToSelectedNodes( node );
+				}
+			}
+			else
+			{
+				DeSelectAll();
+				AddToSelectedNodes( node );
+			}
+			if( reorder && !node.ReorderLocked )
+			{
+				m_nodes.Remove( node );
+				m_nodes.Add( node );
+				m_markToReOrder = true;
+			}
+		}
+
+		public void MultipleSelection( Rect selectionArea, bool appendSelection = true )
+		{
+			if( !appendSelection )
+			{
+				for( int i = 0; i < m_nodes.Count; i++ )
+				{
+					if( selectionArea.Overlaps( m_nodes[ i ].Position, true ) )
+					{
+						RemoveFromSelectedNodes( m_nodes[ i ] );
+					}
+				}
+
+				m_markedToDeSelect = false;
+				ResetHighlightedWires();
+			}
+			else
+			{
+				for( int i = 0; i < m_nodes.Count; i++ )
+				{
+					if( !m_nodes[ i ].Selected && selectionArea.Overlaps( m_nodes[ i ].Position, true ) )
+					{
+						AddToSelectedNodes( m_nodes[ i ] );
+					}
+				}
+			}
+
+			// reorder nodes and highlight them
+			for( int i = 0; i < m_selectedNodes.Count; i++ )
+			{
+				if( !m_selectedNodes[ i ].ReorderLocked )
+				{
+					m_nodes.Remove( m_selectedNodes[ i ] );
+					m_nodes.Add( m_selectedNodes[ i ] );
+					m_markToReOrder = true;
+					if( m_selectedNodes[ i ].ConnStatus == NodeConnectionStatus.Connected )
+					{
+						HighlightWiresStartingNode( m_selectedNodes[ i ] );
+					}
+				}
+			}
+		}
+
+		public void SelectAll()
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				if( !m_nodes[ i ].Selected )
+					AddToSelectedNodes( m_nodes[ i ] );
+			}
+		}
+
+		public void SelectMasterNode()
+		{
+			if( m_masterNodeId != Constants.INVALID_NODE_ID )
+			{
+				SelectNode( CurrentMasterNode, false, false );
+			}
+		}
+
+		public void SelectOutputNode()
+		{
+			if( m_masterNodeId != Constants.INVALID_NODE_ID )
+			{
+				SelectNode( CurrentOutputNode, false, false );
+			}
+		}
+
+		public void DeselectNode( int nodeId )
+		{
+			ParentNode node = GetNode( nodeId );
+			if( node )
+			{
+				m_selectedNodes.Remove( node );
+				node.Selected = false;
+			}
+		}
+
+		public void DeselectNode( ParentNode node )
+		{
+			m_selectedNodes.Remove( node );
+			node.Selected = false;
+			PropagateHighlightDeselection( node );
+		}
+
+
+
+		public void DeSelectAll()
+		{
+			m_markedToDeSelect = false;
+			for( int i = 0; i < m_selectedNodes.Count; i++ )
+			{
+				m_selectedNodes[ i ].Selected = false;
+				m_selectedNodes[ i ].OnNodeStoppedMovingEvent -= OnNodeFinishMoving;
+			}
+			m_selectedNodes.Clear();
+			ResetHighlightedWires();
+		}
+
+		public void AssignMasterNode()
+		{
+			if( m_selectedNodes.Count == 1 )
+			{
+				OutputNode newOutputNode = m_selectedNodes[ 0 ] as OutputNode;
+				MasterNode newMasterNode = newOutputNode as MasterNode;
+				if( newOutputNode != null )
+				{
+					if( m_masterNodeId != Constants.INVALID_NODE_ID && m_masterNodeId != newOutputNode.UniqueId )
+					{
+						OutputNode oldOutputNode = GetNode( m_masterNodeId ) as OutputNode;
+						MasterNode oldMasterNode = oldOutputNode as MasterNode;
+						if( oldOutputNode != null )
+						{
+							oldOutputNode.IsMainOutputNode = false;
+							if( oldMasterNode != null )
+							{
+								oldMasterNode.ClearUpdateEvents();
+							}
+						}
+					}
+					m_masterNodeId = newOutputNode.UniqueId;
+					newOutputNode.IsMainOutputNode = true;
+					if( newMasterNode != null )
+					{
+						newMasterNode.OnMaterialUpdatedEvent += OnMaterialUpdatedEvent;
+						newMasterNode.OnShaderUpdatedEvent += OnShaderUpdatedEvent;
+					}
+				}
+			}
+
+			IsDirty = true;
+		}
+
+		public void AssignMasterNode( OutputNode node, bool onlyUpdateGraphId )
+		{
+			AssignMasterNode( node.UniqueId, onlyUpdateGraphId );
+			MasterNode masterNode = node as MasterNode;
+			if( masterNode != null )
+			{
+				masterNode.OnMaterialUpdatedEvent += OnMaterialUpdatedEvent;
+				masterNode.OnShaderUpdatedEvent += OnShaderUpdatedEvent;
+			}
+		}
+
+		public void AssignMasterNode( int nodeId, bool onlyUpdateGraphId )
+		{
+			if( nodeId < 0 || m_masterNodeId == nodeId )
+				return;
+
+			if( m_masterNodeId > Constants.INVALID_NODE_ID )
+			{
+				OutputNode oldOutputNode = ( GetNode( nodeId ) as OutputNode );
+				MasterNode oldMasterNode = oldOutputNode as MasterNode;
+				if( oldOutputNode != null )
+				{
+					oldOutputNode.IsMainOutputNode = false;
+					if( oldMasterNode != null )
+					{
+						oldMasterNode.ClearUpdateEvents();
+					}
+				}
+			}
+
+			if( onlyUpdateGraphId )
+			{
+				m_masterNodeId = nodeId;
+			}
+			else
+			{
+				OutputNode outputNode = ( GetNode( nodeId ) as OutputNode );
+				if( outputNode != null )
+				{
+					outputNode.IsMainOutputNode = true;
+					m_masterNodeId = nodeId;
+				}
+			}
+
+			IsDirty = true;
+		}
+
+		public void RefreshOnUndo()
+		{
+			if( m_nodes != null )
+			{
+				int count = m_nodes.Count;
+				for( int i = 0; i < count; i++ )
+				{
+					if( m_nodes[ i ] != null )
+					{
+						m_nodes[ i ].RefreshOnUndo();
+					}
+				}
+			}
+		}
+
+		public void DrawGrid( DrawInfo drawInfo )
+		{
+			m_nodeGrid.DrawGrid( drawInfo );
+		}
+
+		public float MaxNodeDist
+		{
+			get { return m_nodeGrid.MaxNodeDist; }
+		}
+
+		public List<ParentNode> GetNodesInGrid( Vector2 transformedMousePos )
+		{
+			return m_nodeGrid.GetNodesOn( transformedMousePos );
+		}
+
+		public void FireMasterNode( Shader selectedShader )
+		{
+			( GetNode( m_masterNodeId ) as MasterNode ).Execute( selectedShader );
+		}
+
+		public Shader FireMasterNode( string pathname, bool isFullPath )
+		{
+			return ( GetNode( m_masterNodeId ) as MasterNode ).Execute( pathname, isFullPath );
+		}
+
+		private void ForceSignalPropagationOnMasterNodeInternal( UsageListTemplateMultiPassMasterNodes masterNodes )
+		{
+			int mpCount = masterNodes.Count;
+			for( int i = 0; i < mpCount; i++ )
+			{
+				masterNodes.NodesList[ i ].GenerateSignalPropagation();
+			}
+		}
+
+		public void ForceSignalPropagationOnMasterNode()
+		{
+			if( m_multiPassMasterNodes.Count > 0 )
+			{
+				ForceSignalPropagationOnMasterNodeInternal( m_multiPassMasterNodes );
+				for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+				{
+					ForceSignalPropagationOnMasterNodeInternal( m_lodMultiPassMasterNodes[ i ] );
+				}
+			}
+			else if( CurrentOutputNode != null )
+				CurrentOutputNode.GenerateSignalPropagation();
+
+			List<FunctionOutput> allOutputs = m_functionOutputNodes.NodesList;
+			for( int i = 0; i < allOutputs.Count; i++ )
+			{
+				allOutputs[ i ].GenerateSignalPropagation();
+			}
+
+			//List<RegisterLocalVarNode> localVarNodes = m_localVarNodes.NodesList;
+			//int count = localVarNodes.Count;
+			//for( int i = 0; i < count; i++ )
+			//{
+			//	localVarNodes[ i ].GenerateSignalPropagation();
+			//}
+		}
+
+		public void UpdateShaderOnMasterNode( Shader newShader )
+		{
+			MasterNode mainMasterNode = ( GetNode( m_masterNodeId ) as MasterNode );
+			if( mainMasterNode == null )
+			{
+				Debug.LogError( "No Master Node was detected. Aborting update!" );
+				return;
+			}
+			mainMasterNode.UpdateFromShader( newShader );
+
+			if( HasLODs )
+			{
+				int passIdx = ( (TemplateMultiPassMasterNode)mainMasterNode ).PassIdx;
+				for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+				{
+					if( m_lodMultiPassMasterNodes.Count != 0 && m_lodMultiPassMasterNodes[ i ].NodesList.Count > 0 )
+					{
+						if( m_lodMultiPassMasterNodes[ i ].NodesList[ passIdx ] != null )
+						{
+							m_lodMultiPassMasterNodes[ i ].NodesList[ passIdx ].UpdateFromShader( newShader );
+						}
+						else
+						{
+							Debug.LogError( "Null master node detected. Aborting update!" );
+							return;
+						}
+					}
+					else break;
+				}
+			}
+		}
+
+		public void CopyValuesFromMaterial( Material material )
+		{
+			Material currMaterial = CurrentMaterial;
+			if( currMaterial == material )
+			{
+				for( int i = 0; i < m_nodes.Count; i++ )
+				{
+					m_nodes[ i ].ForceUpdateFromMaterial( material );
+				}
+			}
+		}
+
+		public void UpdateMaterialOnMasterNode( Material material )
+		{
+			MasterNode mainMasterNode = ( GetNode( m_masterNodeId ) as MasterNode );
+			mainMasterNode.UpdateMasterNodeMaterial( material );
+			if( HasLODs )
+			{
+				int passIdx = ( (TemplateMultiPassMasterNode)mainMasterNode ).PassIdx;
+				for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+				{
+					if( m_lodMultiPassMasterNodes.Count != 0 && m_lodMultiPassMasterNodes[ i ].NodesList.Count > 0 )
+					{
+						m_lodMultiPassMasterNodes[ i ].NodesList[ passIdx ].UpdateMasterNodeMaterial( material );
+					}
+					else break;
+				}
+			}
+		}
+
+		public void UpdateMaterialOnPropertyNodes( Material material )
+		{
+			int propertyCount = m_propertyNodes.Count;
+			for(int i = 0;i< propertyCount;i++ )
+			{
+				m_propertyNodes.NodesList[i].UpdateMaterial( material );
+			}
+		}
+
+		public void SetMaterialModeOnGraph( Material mat, bool fetchMaterialValues = true )
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				m_nodes[ i ].SetMaterialMode( mat, fetchMaterialValues );
+			}
+		}
+
+		public ParentNode CheckNodeAt( Vector3 pos, bool checkForRMBIgnore = false )
+		{
+			ParentNode selectedNode = null;
+
+			// this is checked on the inverse order to give priority to nodes that are drawn on top  ( last on the list )
+			for( int i = m_nodes.Count - 1; i > -1; i-- )
+			{
+				if( m_nodes[ i ].Contains( pos ) )
+				{
+					if( checkForRMBIgnore )
+					{
+						if( !m_nodes[ i ].RMBIgnore )
+						{
+							selectedNode = m_nodes[ i ];
+							break;
+						}
+					}
+					else
+					{
+						selectedNode = m_nodes[ i ];
+						break;
+					}
+				}
+			}
+			return selectedNode;
+		}
+
+		public void ResetNodesLocalVariables()
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				m_nodes[ i ].Reset();
+				m_nodes[ i ].ResetOutputLocals();
+
+				FunctionNode fnode = m_nodes[ i ] as FunctionNode;
+				if( fnode != null )
+				{
+					if( fnode.Function != null )
+						fnode.FunctionGraph.ResetNodesLocalVariables();
+				}
+			}
+		}
+
+		public void ResetNodesLocalVariablesIfNot( MasterNodePortCategory category )
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				m_nodes[ i ].Reset();
+				m_nodes[ i ].ResetOutputLocalsIfNot( category );
+
+				FunctionNode fnode = m_nodes[ i ] as FunctionNode;
+				if( fnode != null )
+				{
+					if( fnode.Function != null )
+						fnode.FunctionGraph.ResetNodesLocalVariablesIfNot( category );
+				}
+			}
+		}
+
+		public void ResetNodesLocalVariables( ParentNode node )
+		{
+			if( node is GetLocalVarNode )
+			{
+				GetLocalVarNode localVarNode = node as GetLocalVarNode;
+				if( localVarNode.CurrentSelected != null )
+				{
+					node = localVarNode.CurrentSelected;
+				}
+			}
+
+			node.Reset();
+			node.ResetOutputLocals();
+			int count = node.InputPorts.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( node.InputPorts[ i ].IsConnected )
+				{
+					ResetNodesLocalVariables( m_nodesDict[ node.InputPorts[ i ].GetConnection().NodeId ] );
+				}
+			}
+		}
+
+		public void ResetNodesLocalVariablesIfNot( ParentNode node, MasterNodePortCategory category )
+		{
+			if( node is GetLocalVarNode )
+			{
+				GetLocalVarNode localVarNode = node as GetLocalVarNode;
+				if( localVarNode.CurrentSelected != null )
+				{
+					node = localVarNode.CurrentSelected;
+				}
+			}
+
+			node.Reset();
+			node.ResetOutputLocalsIfNot( category );
+			int count = node.InputPorts.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( node.InputPorts[ i ].IsConnected )
+				{
+					ResetNodesLocalVariablesIfNot( m_nodesDict[ node.InputPorts[ i ].GetConnection().NodeId ], category );
+				}
+			}
+		}
+
+
+		public override string ToString()
+		{
+			string dump = ( "Parent Graph \n" );
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				dump += ( m_nodes[ i ] + "\n" );
+			}
+			return dump;
+		}
+
+		public void OrderNodesByGraphDepth()
+		{
+			if( CurrentMasterNode != null )
+			{
+				//CurrentMasterNode.SetupNodeCategories();
+				int count = m_nodes.Count;
+				for( int i = 0; i < count; i++ )
+				{
+					if( m_nodes[ i ].ConnStatus == NodeConnectionStatus.Island )
+					{
+						m_nodes[ i ].CalculateCustomGraphDepth();
+					}
+				}
+			}
+			else
+			{
+				//TODO: remove this dynamic list
+				List<OutputNode> allOutputs = new List<OutputNode>();
+				for( int i = 0; i < AllNodes.Count; i++ )
+				{
+					OutputNode temp = AllNodes[ i ] as OutputNode;
+					if( temp != null )
+						allOutputs.Add( temp );
+				}
+
+				for( int j = 0; j < allOutputs.Count; j++ )
+				{
+					allOutputs[ j ].SetupNodeCategories();
+					int count = m_nodes.Count;
+					for( int i = 0; i < count; i++ )
+					{
+						if( m_nodes[ i ].ConnStatus == NodeConnectionStatus.Island )
+						{
+							m_nodes[ i ].CalculateCustomGraphDepth();
+						}
+					}
+				}
+			}
+
+			m_nodes.Sort( ( x, y ) => { return y.GraphDepth.CompareTo( x.GraphDepth ); } );
+		}
+
+		public void WriteToString( ref string nodesInfo, ref string connectionsInfo )
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				m_nodes[ i ].FullWriteToString( ref nodesInfo, ref connectionsInfo );
+				IOUtils.AddLineTerminator( ref nodesInfo );
+			}
+		}
+
+		public void Reset()
+		{
+			SaveIsDirty = false;
+			IsDirty = false;
+		}
+
+		public void OnBeforeSerialize()
+		{
+			//DeSelectAll();
+		}
+
+		public void OnAfterDeserialize()
+		{
+			m_afterDeserializeFlag = true;
+		}
+
+		public void CleanCorruptedNodes()
+		{
+			for( int i = 0; i < m_nodes.Count; i++ )
+			{
+				if( (object)m_nodes[ i ] == null )
+				{
+					m_nodes.RemoveAt( i );
+					CleanCorruptedNodes();
+				}
+			}
+		}
+
+		public void OnDuplicateEventWrapper()
+		{
+			if( OnDuplicateEvent != null )
+			{
+				AmplifyShaderEditorWindow temp = UIUtils.CurrentWindow;
+				UIUtils.CurrentWindow = ParentWindow;
+				OnDuplicateEvent();
+				UIUtils.CurrentWindow = temp;
+			}
+		}
+
+		public ParentNode CreateNode( AmplifyShaderFunction shaderFunction, bool registerUndo, int nodeId = -1, bool addLast = true )
+		{
+			FunctionNode newNode = ScriptableObject.CreateInstance<FunctionNode>();
+			if( newNode )
+			{
+				newNode.ContainerGraph = this;
+				newNode.CommonInit( shaderFunction, nodeId );
+				newNode.UniqueId = nodeId;
+				AddNode( newNode, nodeId < 0, addLast, registerUndo );
+			}
+			return newNode;
+		}
+
+		public ParentNode CreateNode( AmplifyShaderFunction shaderFunction, bool registerUndo, Vector2 pos, int nodeId = -1, bool addLast = true )
+		{
+			ParentNode newNode = CreateNode( shaderFunction, registerUndo, nodeId, addLast );
+			if( newNode )
+			{
+				newNode.Vec2Position = pos;
+			}
+			return newNode;
+		}
+
+		public ParentNode CreateNode( System.Type type, bool registerUndo, int nodeId = -1, bool addLast = true )
+		{
+			ParentNode newNode = ScriptableObject.CreateInstance( type ) as ParentNode;
+			if( newNode )
+			{
+				newNode.ContainerGraph = this;
+				newNode.UniqueId = nodeId;
+				AddNode( newNode, nodeId < 0, addLast, registerUndo );
+			}
+			return newNode;
+		}
+
+		public ParentNode CreateNode( System.Type type, bool registerUndo, Vector2 pos, int nodeId = -1, bool addLast = true )
+		{
+			ParentNode newNode = CreateNode( type, registerUndo, nodeId, addLast );
+			if( newNode )
+			{
+				newNode.Vec2Position = pos;
+			}
+			return newNode;
+		}
+
+		public void FireMasterNodeReplacedEvent()
+		{
+			MasterNode masterNode = CurrentMasterNode;
+			int count = m_nodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( m_nodes[ i ].UniqueId != m_masterNodeId )
+				{
+					m_nodes[ i ].OnMasterNodeReplaced( masterNode );
+				}
+			}
+		}
+
+		//Used over shader functions to propagate signal into their graphs
+		public void FireMasterNodeReplacedEvent( MasterNode masterNode )
+		{
+			int count = m_nodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( m_nodes[ i ].UniqueId != masterNode.UniqueId )
+				{
+					m_nodes[ i ].OnMasterNodeReplaced( masterNode );
+				}
+			}
+		}
+
+
+		public void CrossCheckTemplateNodes( TemplateDataParent templateData )
+		{
+			/*Paulo*/
+			DeSelectAll();
+			TemplateMultiPassMasterNode newMasterNode = null;
+			Dictionary<string, TemplateReplaceHelper> nodesDict = new Dictionary<string, TemplateReplaceHelper>();
+			int mpNodeCount = m_multiPassMasterNodes.NodesList.Count;
+			for( int i = 0; i < mpNodeCount; i++ )
+			{
+				nodesDict.Add( m_multiPassMasterNodes.NodesList[ i ].OriginalPassName, new TemplateReplaceHelper( m_multiPassMasterNodes.NodesList[ i ] ) );
+			}
+
+			TemplateMultiPassMasterNode currMasterNode = GetNode( m_masterNodeId ) as TemplateMultiPassMasterNode;
+
+			TemplateMultiPass multipassData = templateData as TemplateMultiPass;
+			m_currentSRPType = multipassData.SubShaders[ 0 ].Modules.SRPType;
+
+			bool sortTemplatesNodes = false;
+			Vector2 currentPosition = currMasterNode.Vec2Position;
+			for( int subShaderIdx = 0; subShaderIdx < multipassData.SubShaders.Count; subShaderIdx++ )
+			{
+				for( int passIdx = 0; passIdx < multipassData.SubShaders[ subShaderIdx ].Passes.Count; passIdx++ )
+				{
+					string currPassName = multipassData.SubShaders[ subShaderIdx ].Passes[ passIdx ].PassNameContainer.Data;
+					if( nodesDict.ContainsKey( currPassName ) )
+					{
+						bool wasMainNode = nodesDict[ currPassName ].MasterNode.IsMainOutputNode;
+
+						currentPosition.y += nodesDict[ currPassName ].MasterNode.Position.height + 10;
+						nodesDict[ currPassName ].Used = true;
+						nodesDict[ currPassName ].MasterNode.SetTemplate( multipassData, false, false, subShaderIdx, passIdx, SetTemplateSource.NewShader );
+						if( wasMainNode && !nodesDict[ currPassName ].MasterNode.IsMainOutputNode )
+						{
+							nodesDict[ currPassName ].MasterNode.ReleaseResources();
+						}
+						else if( !wasMainNode && nodesDict[ currPassName ].MasterNode.IsMainOutputNode )
+						{
+							newMasterNode = nodesDict[ currPassName ].MasterNode;
+						}
+					}
+					else
+					{
+						sortTemplatesNodes = true;
+						TemplateMultiPassMasterNode masterNode = CreateNode( typeof( TemplateMultiPassMasterNode ), false ) as TemplateMultiPassMasterNode;
+						if( multipassData.SubShaders[ subShaderIdx ].Passes[ passIdx ].IsMainPass )
+						{
+							newMasterNode = masterNode;
+							currMasterNode.ReleaseResources();
+						}
+						masterNode.Vec2Position = currentPosition;
+						masterNode.SetTemplate( multipassData, true, true, subShaderIdx, passIdx, SetTemplateSource.NewShader );
+						//currentPosition.y += masterNode.HeightEstimate + 10;
+					}
+				}
+			}
+
+			foreach( KeyValuePair<string, TemplateReplaceHelper> kvp in nodesDict )
+			{
+				if( !kvp.Value.Used )
+					DestroyNode( kvp.Value.MasterNode, false, true );
+			}
+			nodesDict.Clear();
+
+			if( newMasterNode != null )
+			{
+				m_masterNodeId = newMasterNode.UniqueId;
+				newMasterNode.OnMaterialUpdatedEvent += OnMaterialUpdatedEvent;
+				newMasterNode.OnShaderUpdatedEvent += OnShaderUpdatedEvent;
+				newMasterNode.IsMainOutputNode = true;
+			}
+
+			if( sortTemplatesNodes )
+			{
+				m_multiPassMasterNodes.NodesList.Sort( ( x, y ) => ( x.PassIdx.CompareTo( y.PassIdx ) ) );
+			}
+		}
+
+		public void OnRefreshLinkedPortsComplete()
+		{
+			OnRefreshLinkedPortsCompleteInternal( m_multiPassMasterNodes );
+			for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+			{
+				OnRefreshLinkedPortsCompleteInternal( m_lodMultiPassMasterNodes[ i ] );
+			}
+		}
+
+		private void OnRefreshLinkedPortsCompleteInternal( UsageListTemplateMultiPassMasterNodes masterNodes )
+		{
+			int mpCount = masterNodes.Count;
+			for( int i = 0; i < mpCount; i++ )
+			{
+				masterNodes.NodesList[ i ].OnRefreshLinkedPortsComplete();
+			}
+		}
+
+		public void RefreshLinkedMasterNodes( bool optionsUpdate = false )
+		{
+			if( DebugConsoleWindow.DeveloperMode )
+				Debug.Log( "Refresh linked master nodes" );
+
+			RefreshLinkedMasterNodesInternal( m_multiPassMasterNodes, optionsUpdate );
+			for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+			{
+				RefreshLinkedMasterNodesInternal( m_lodMultiPassMasterNodes[i], optionsUpdate );
+			}
+		}
+
+		private void RefreshLinkedMasterNodesInternal( UsageListTemplateMultiPassMasterNodes masterNodes, bool optionsUpdate )
+		{
+			int mpCount = masterNodes.Count;
+			if( mpCount > 1 )
+			{
+				Dictionary<string, List<InputPort>> registeredLinks = new Dictionary<string, List<InputPort>>();
+				for( int i = 0; i < mpCount; i++ )
+				{
+					CheckLinkedPorts( ref registeredLinks, masterNodes.NodesList[ mpCount - 1 - i ] );
+				}
+
+				foreach( KeyValuePair<string, List<InputPort>> kvp in registeredLinks )
+				{
+					int linkCount = kvp.Value.Count;
+					if( linkCount == 1 )
+					{
+						kvp.Value[ 0 ].Visible = true;
+					}
+					else
+					{
+						kvp.Value[ 0 ].Visible = true;
+						for( int i = 1; i < linkCount; i++ )
+						{
+							kvp.Value[ i ].SetExternalLink( kvp.Value[ 0 ].NodeId, kvp.Value[ 0 ].PortId );
+							kvp.Value[ i ].Visible = false;
+						}
+					}
+					kvp.Value.Clear();
+				}
+				registeredLinks.Clear();
+				registeredLinks = null;
+			}
+
+			masterNodes.NodesList.Sort( ( x, y ) => ( x.SubShaderIdx * 1000 + x.PassIdx ).CompareTo( y.SubShaderIdx * 1000 + y.PassIdx ) );
+			masterNodes.UpdateNodeArr();
+
+			m_parentWindow.TemplatesManagerInstance.ResetOptionsSetupData();
+			for( int i = 0; i < mpCount; i++ )
+			{
+				int visiblePorts = 0;
+				for( int j = 0; j < masterNodes.NodesList[ i ].InputPorts.Count; j++ )
+				{
+					if( masterNodes.NodesList[ i ].InputPorts[ j ].Visible )
+					{
+						visiblePorts++;
+					}
+				}
+
+				if( masterNodes.NodesList[ i ].VisiblePorts != visiblePorts )
+				{
+					masterNodes.NodesList[ i ].VisiblePorts = visiblePorts;
+					ForceRepositionCheck = true;
+				}
+
+				masterNodes.NodesList[ i ].Docking = visiblePorts <= 0;
+				if( optionsUpdate )
+				{
+					masterNodes.NodesList[ i ].ForceOptionsRefresh();
+				}
+			}
+		}
+
+		void CheckLinkedPorts( ref Dictionary<string, List<InputPort>> registeredLinks, TemplateMultiPassMasterNode masterNode )
+		{
+			if( masterNode.HasLinkPorts )
+			{
+				int inputCount = masterNode.InputPorts.Count;
+				for( int i = 0; i < inputCount; i++ )
+				{
+					if( !string.IsNullOrEmpty( masterNode.InputPorts[ i ].ExternalLinkId ) )
+					{
+						string linkId = masterNode.InputPorts[ i ].ExternalLinkId;
+						if( !registeredLinks.ContainsKey( masterNode.InputPorts[ i ].ExternalLinkId ) )
+						{
+							registeredLinks.Add( linkId, new List<InputPort>() );
+						}
+
+						if( masterNode.IsMainOutputNode )
+						{
+							registeredLinks[ linkId ].Insert( 0, masterNode.InputPorts[ i ] );
+						}
+						else
+						{
+							registeredLinks[ linkId ].Add( masterNode.InputPorts[ i ] );
+						}
+					}
+					else
+					{
+						masterNode.InputPorts[ i ].Visible = true;
+					}
+				}
+			}
+			else
+			{
+				int inputCount = masterNode.InputPorts.Count;
+				for( int i = 0; i < inputCount; i++ )
+				{
+					masterNode.InputPorts[ i ].Visible = true;
+				}
+			}
+			
+		}
+
+		public MasterNode ReplaceMasterNode( AvailableShaderTypes newType, bool writeDefaultData = false, TemplateDataParent templateData = null )
+		{
+			DeSelectAll();
+			ResetNodeConnStatus();
+			MasterNode newMasterNode = null;
+			List<TemplateMultiPassMasterNode> nodesToDelete = null;
+			int mpNodeCount = m_multiPassMasterNodes.NodesList.Count;
+			if( mpNodeCount > 0 )
+			{
+				nodesToDelete = new List<TemplateMultiPassMasterNode>();
+				for( int i = 0; i < mpNodeCount; i++ )
+				{
+					if( m_multiPassMasterNodes.NodesList[ i ].UniqueId != m_masterNodeId )
+					{
+						nodesToDelete.Add( m_multiPassMasterNodes.NodesList[ i ] );
+					}
+				}
+
+				for( int lod = 0; lod < m_lodMultiPassMasterNodes.Count; lod++ )
+				{
+					int lodNodeCount = m_lodMultiPassMasterNodes[ lod ].Count;
+					for( int i = 0; i < lodNodeCount; i++ )
+					{
+						nodesToDelete.Add( m_lodMultiPassMasterNodes[ lod ].NodesList[ i ] );
+					}
+				}
+			}
+
+			MasterNode currMasterNode = GetNode( m_masterNodeId ) as MasterNode;
+			if( currMasterNode != null )
+			{
+				currMasterNode.ReleaseResources();
+			}
+
+			bool refreshLinkedMasterNodes = false;
+			switch( newType )
+			{
+				default:
+				case AvailableShaderTypes.SurfaceShader:
+				{
+					CurrentCanvasMode = NodeAvailability.SurfaceShader;
+					m_currentSRPType = TemplateSRPType.BuiltIn;
+					newMasterNode = CreateNode( typeof( StandardSurfaceOutputNode ), false ) as MasterNode;
+				}
+				break;
+				case AvailableShaderTypes.Template:
+				{
+					CurrentCanvasMode = NodeAvailability.TemplateShader;
+					if( templateData.TemplateType == TemplateDataType.LegacySinglePass )
+					{
+						newMasterNode = CreateNode( typeof( TemplateMasterNode ), false ) as MasterNode;
+						( newMasterNode as TemplateMasterNode ).SetTemplate( templateData as TemplateData, writeDefaultData, false );
+						m_currentSRPType = TemplateSRPType.BuiltIn;
+					}
+					else
+					{
+						/*Paulo*/
+						TemplateMultiPass multipassData = templateData as TemplateMultiPass;
+						m_currentSRPType = multipassData.SubShaders[ 0 ].Modules.SRPType;
+
+						Vector2 currentPosition = currMasterNode.Vec2Position;
+
+						for( int subShaderIdx = 0; subShaderIdx < multipassData.SubShaders.Count; subShaderIdx++ )
+						{
+							for( int passIdx = 0; passIdx < multipassData.SubShaders[ subShaderIdx ].Passes.Count; passIdx++ )
+							{
+								TemplateMultiPassMasterNode masterNode = CreateNode( typeof( TemplateMultiPassMasterNode ), false ) as TemplateMultiPassMasterNode;
+								if( multipassData.SubShaders[ subShaderIdx ].Passes[ passIdx ].IsMainPass )
+								{
+									newMasterNode = masterNode;
+									ParentWindow.IsShaderFunctionWindow = false;
+									CurrentCanvasMode = NodeAvailability.TemplateShader;
+								}
+								masterNode.Vec2Position = currentPosition;
+								masterNode.SetTemplate( multipassData, true, true, subShaderIdx, passIdx, SetTemplateSource.NewShader );
+								//currentPosition.y += masterNode.HeightEstimate + 10;
+							}
+						}
+						refreshLinkedMasterNodes = true;
+						//RefreshLinkedMasterNodes();
+					}
+				}
+				break;
+			}
+
+			if( currMasterNode != null )
+			{
+				newMasterNode.CopyFrom( currMasterNode );
+				m_masterNodeId = -1;
+				DestroyNode( currMasterNode, false, true );
+			}
+
+			if( nodesToDelete != null )
+			{
+				for( int i = 0; i < nodesToDelete.Count; i++ )
+				{
+					DestroyNode( nodesToDelete[ i ], false, true );
+				}
+				nodesToDelete.Clear();
+			}
+
+			if( refreshLinkedMasterNodes )
+				RefreshLinkedMasterNodes( true );
+
+			m_masterNodeId = newMasterNode.UniqueId;
+			newMasterNode.OnMaterialUpdatedEvent += OnMaterialUpdatedEvent;
+			newMasterNode.OnShaderUpdatedEvent += OnShaderUpdatedEvent;
+			newMasterNode.IsMainOutputNode = true;
+			OnRefreshLinkedPortsComplete();
+			FullCleanUndoStack();
+			return newMasterNode;
+		}
+
+		private void RepositionTemplateNodes( MasterNode newMasterNode )
+		{
+			m_forceRepositionCheck = false;
+
+			int dockedElementsBefore = 0;
+			int dockedElementsAfter = 0;
+			int masterIndex = 0;
+			bool foundMaster = false;
+			for( int i = 0; i < MultiPassMasterNodes.Count; i++ )
+			{
+				if( MultiPassMasterNodes.NodesList[ i ].UniqueId == m_masterNodeId )
+				{
+					foundMaster = true;
+					masterIndex = i;
+				}
+
+				if( !MultiPassMasterNodes.NodesList[ i ].IsInvisible && MultiPassMasterNodes.NodesList[ i ].Docking )
+				{
+					if( foundMaster )
+						dockedElementsAfter++;
+					else
+						dockedElementsBefore++;
+				}
+			}
+
+			if( dockedElementsBefore > 0 )
+			{
+				newMasterNode.UseSquareNodeTitle = true;
+			}
+
+			for( int i = masterIndex - 1; i >= 0; i-- )
+			{
+				float forwardTracking = 0;
+				for( int j = i + 1; j <= masterIndex; j++ )
+				{
+					if( !MultiPassMasterNodes.NodesList[ i ].IsInvisible && !MultiPassMasterNodes.NodesList[ j ].Docking )
+					{
+						forwardTracking += MultiPassMasterNodes.NodesList[ j ].HeightEstimate + 10;
+					}
+				}
+				MasterNode node = MultiPassMasterNodes.NodesList[ i ];
+				node.Vec2Position = new Vector2( node.Vec2Position.x, newMasterNode.Position.y - forwardTracking - 33 * ( dockedElementsBefore ) );
+			}
+
+			for( int i = masterIndex + 1; i < MultiPassMasterNodes.Count; i++ )
+			{
+				if( MultiPassMasterNodes.NodesList[ i ].UniqueId == newMasterNode.UniqueId || MultiPassMasterNodes.NodesList[ i ].Docking )
+					continue;
+
+				float backTracking = 0;
+				for( int j = i - 1; j >= masterIndex; j-- )
+				{
+					if( !MultiPassMasterNodes.NodesList[ i ].IsInvisible && !MultiPassMasterNodes.NodesList[ j ].Docking )
+					{
+						backTracking += MultiPassMasterNodes.NodesList[ j ].HeightEstimate + 10;
+					}
+				}
+				MasterNode node = MultiPassMasterNodes.NodesList[ i ];
+				node.Vec2Position = new Vector2( node.Vec2Position.x, newMasterNode.Position.y + backTracking + 33 * ( dockedElementsAfter ) );
+			}
+		}
+
+		public void CreateNewEmpty( string name )
+		{
+			CleanNodes();
+			if( m_masterNodeDefaultType == null )
+				m_masterNodeDefaultType = typeof( StandardSurfaceOutputNode );
+
+			MasterNode newMasterNode = CreateNode( m_masterNodeDefaultType, false ) as MasterNode;
+			newMasterNode.SetName( name );
+			m_masterNodeId = newMasterNode.UniqueId;
+
+			ParentWindow.IsShaderFunctionWindow = false;
+			CurrentCanvasMode = NodeAvailability.SurfaceShader;
+
+			newMasterNode.OnMaterialUpdatedEvent += OnMaterialUpdatedEvent;
+			newMasterNode.OnShaderUpdatedEvent += OnShaderUpdatedEvent;
+			newMasterNode.IsMainOutputNode = true;
+			LoadedShaderVersion = VersionInfo.FullNumber;
+		}
+
+		public void CreateNewEmptyTemplate( string templateGUID )
+		{
+			CleanNodes();
+			TemplateDataParent templateData = m_parentWindow.TemplatesManagerInstance.GetTemplate( templateGUID );
+			if( templateData.TemplateType == TemplateDataType.LegacySinglePass )
+			{
+				TemplateMasterNode newMasterNode = CreateNode( typeof( TemplateMasterNode ), false ) as TemplateMasterNode;
+				m_masterNodeId = newMasterNode.UniqueId;
+
+				ParentWindow.IsShaderFunctionWindow = false;
+				CurrentCanvasMode = NodeAvailability.TemplateShader;
+				m_currentSRPType = TemplateSRPType.BuiltIn;
+				newMasterNode.OnMaterialUpdatedEvent += OnMaterialUpdatedEvent;
+				newMasterNode.OnShaderUpdatedEvent += OnShaderUpdatedEvent;
+				newMasterNode.IsMainOutputNode = true;
+
+				newMasterNode.SetTemplate( templateData as TemplateData, true, true );
+			}
+			else
+			{
+				/*Paulo*/
+				TemplateMultiPass multipassData = templateData as TemplateMultiPass;
+				m_currentSRPType = multipassData.SubShaders[ 0 ].Modules.SRPType;
+
+				Vector2 currentPosition = Vector2.zero;
+				for( int subShaderIdx = 0; subShaderIdx < multipassData.SubShaders.Count; subShaderIdx++ )
+				{
+					for( int passIdx = 0; passIdx < multipassData.SubShaders[ subShaderIdx ].Passes.Count; passIdx++ )
+					{
+						TemplateMultiPassMasterNode newMasterNode = CreateNode( typeof( TemplateMultiPassMasterNode ), false ) as TemplateMultiPassMasterNode;
+						if( multipassData.SubShaders[ subShaderIdx ].Passes[ passIdx ].IsMainPass )
+						{
+							m_masterNodeId = newMasterNode.UniqueId;
+
+							ParentWindow.IsShaderFunctionWindow = false;
+							CurrentCanvasMode = NodeAvailability.TemplateShader;
+
+							newMasterNode.OnMaterialUpdatedEvent += OnMaterialUpdatedEvent;
+							newMasterNode.OnShaderUpdatedEvent += OnShaderUpdatedEvent;
+							newMasterNode.IsMainOutputNode = true;
+						}
+						newMasterNode.Vec2Position = currentPosition;
+						newMasterNode.SetTemplate( multipassData, true, true, subShaderIdx, passIdx, SetTemplateSource.NewShader );
+
+						//currentPosition.y += newMasterNode.HeightEstimate + 10;
+					}
+				}
+				
+				RefreshLinkedMasterNodes( false );
+				OnRefreshLinkedPortsComplete();
+			}
+
+			LoadedShaderVersion = VersionInfo.FullNumber;
+		}
+
+		public void CreateNewEmptyFunction( AmplifyShaderFunction shaderFunction )
+		{
+			CleanNodes();
+			FunctionOutput newOutputNode = CreateNode( typeof( FunctionOutput ), false ) as FunctionOutput;
+			m_masterNodeId = newOutputNode.UniqueId;
+
+			ParentWindow.IsShaderFunctionWindow = true;
+			CurrentCanvasMode = NodeAvailability.ShaderFunction;
+
+			newOutputNode.IsMainOutputNode = true;
+		}
+
+		public void ForceCategoryRefresh() { m_forceCategoryRefresh = true; }
+		public void RefreshExternalReferences()
+		{
+			int count = m_nodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				m_nodes[ i ].RefreshExternalReferences();
+			}
+		}
+
+		public Vector2 SelectedNodesCentroid
+		{
+			get
+			{
+				if( m_selectedNodes.Count == 0 )
+					return Vector2.zero;
+				Vector2 pos = new Vector2( 0, 0 );
+				for( int i = 0; i < m_selectedNodes.Count; i++ )
+				{
+					pos += m_selectedNodes[ i ].Vec2Position;
+				}
+
+				pos /= m_selectedNodes.Count;
+				return pos;
+			}
+		}
+
+		public void AddVirtualTextureCount()
+		{
+			m_virtualTextureCount += 1;
+		}
+
+		public void RemoveVirtualTextureCount()
+		{
+			m_virtualTextureCount -= 1;
+			if( m_virtualTextureCount < 0 )
+			{
+				Debug.LogWarning( "Invalid virtual texture count" );
+			}
+		}
+
+		public bool HasVirtualTexture { get { return m_virtualTextureCount > 0; } }
+
+		public void AddInstancePropertyCount()
+		{
+			m_instancePropertyCount += 1;
+//			Debug.Log( "AddInstancePropertyCount "+this.GetInstanceID() + " " + m_instancePropertyCount );
+		}
+
+		public void RemoveInstancePropertyCount()
+		{
+			m_instancePropertyCount -= 1;
+	//		Debug.Log( "RemoveInstancePropertyCount " + this.GetInstanceID() + " " + m_instancePropertyCount );
+
+			if( m_instancePropertyCount < 0 )
+			{
+				Debug.LogWarning( "Invalid property instance count" );
+			}
+		}
+
+		public int InstancePropertyCount { get { return m_instancePropertyCount; } set { m_instancePropertyCount = value; } }
+
+		public bool IsInstancedShader { get { return m_instancePropertyCount > 0; } }
+
+		public void AddNormalDependentCount() { m_normalDependentCount += 1; }
+
+		public void RemoveNormalDependentCount()
+		{
+			m_normalDependentCount -= 1;
+			if( m_normalDependentCount < 0 )
+			{
+				Debug.LogWarning( "Invalid normal dependentCount count" );
+			}
+		}
+
+		public void SetModeFromMasterNode()
+		{
+			MasterNode masterNode = CurrentMasterNode;
+			if( masterNode != null )
+			{
+				switch( masterNode.CurrentMasterNodeCategory )
+				{
+					default:
+					case AvailableShaderTypes.SurfaceShader:
+					{
+						if( masterNode is StandardSurfaceOutputNode )
+							CurrentCanvasMode = ParentWindow.CurrentNodeAvailability;
+						else
+							CurrentCanvasMode = NodeAvailability.SurfaceShader;
+					}
+					break;
+					case AvailableShaderTypes.Template:
+					{
+						CurrentCanvasMode = NodeAvailability.TemplateShader;
+					}
+					break;
+				}
+			}
+			else
+			{
+
+				CurrentCanvasMode = NodeAvailability.SurfaceShader;
+			}
+		}
+
+		public void MarkToDelete( ParentNode node )
+		{
+			m_markedForDeletion.Add( node );
+		}
+		public bool IsMasterNode( ParentNode node )
+		{
+			return ( node.UniqueId == m_masterNodeId ) ||
+					m_multiPassMasterNodes.HasNode( node.UniqueId );
+		}
+
+		public TemplateMultiPassMasterNode GetMainMasterNodeOfLOD( int lod )
+		{
+			if( lod == -1 )
+				return CurrentMasterNode as TemplateMultiPassMasterNode;
+
+			return m_lodMultiPassMasterNodes[ lod ].NodesList.Find( x => x.IsMainOutputNode );
+		}
+
+		public TemplateMultiPassMasterNode GetMasterNodeOfPass( string passName, int lod )
+		{
+			if( lod == -1 )
+				return m_multiPassMasterNodes.NodesList.Find( x => x.PassName.Equals( passName ) );
+
+			return  m_lodMultiPassMasterNodes[lod].NodesList.Find( x => x.PassName.Equals( passName ) );
+		}
+
+		public void ForceMultiPassMasterNodesRefresh()
+		{
+			int mainOutputId = 0;
+			int count = m_multiPassMasterNodes.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				m_multiPassMasterNodes.NodesList[ i ].ForceTemplateRefresh();
+				if( m_multiPassMasterNodes.NodesList[ i ].IsMainOutputNode )
+					mainOutputId = i;
+			}
+
+			int lodCount = m_lodMultiPassMasterNodes.Count;
+			for( int i = 0; i < lodCount; i++ )
+			{
+				if( m_lodMultiPassMasterNodes[ i ] != null )
+				{
+					count = m_lodMultiPassMasterNodes[ i ].Count;
+					for( int j = 0; j < count; j++ )
+					{
+						m_lodMultiPassMasterNodes[ i ].NodesList[ j ].ForceTemplateRefresh();
+					}
+				}
+			}
+
+			m_multiPassMasterNodes.NodesList[ mainOutputId ].CheckTemplateChanges();
+		}
+
+		public void SetLateOptionsRefresh()
+		{
+			m_lateOptionsRefresh = true;
+		}
+
+		public void CreateLodMasterNodes( TemplateMultiPass templateMultiPass,int index, Vector2 initialPosition )
+		{
+			for( int lod = 0; lod < m_lodMultiPassMasterNodes.Count; lod++ )
+			{
+				if( m_lodMultiPassMasterNodes[ lod ].Count == 0 )
+				{
+					TemplateMultiPassMasterNode reference = CurrentMasterNode as TemplateMultiPassMasterNode;
+
+					int shaderLod = -1;
+					if( lod == 0 )
+					{
+						shaderLod = reference.ShaderLOD - MasterNodeLODIncrement;
+					}
+					else
+					{
+						//index == -2 is when user clicks on +/- buttons over the foldout UI
+						if( index == -2 )
+						{
+							shaderLod = m_lodMultiPassMasterNodes[ lod - 1 ].NodesList[ reference.PassIdx ].ShaderLOD - MasterNodeLODIncrement;
+						}
+						//index == -1 is when user clicks on + button over the main lod master node
+						else if( index == -1 )
+						{
+							int mainShaderLOD = m_lodMultiPassMasterNodes[ 0 ].NodesList[ reference.PassIdx ].ShaderLOD;
+							shaderLod = ( reference.ShaderLOD + mainShaderLOD )/2;
+						}
+						else
+						{
+							if( m_lodMultiPassMasterNodes[ index ].Count > 0 )
+							{
+								if( m_lodMultiPassMasterNodes[ index + 1 ].Count > 0 )
+								{
+									shaderLod = (m_lodMultiPassMasterNodes[ index ].NodesList[ reference.PassIdx ].ShaderLOD +
+												m_lodMultiPassMasterNodes[ index + 1 ].NodesList[ reference.PassIdx ].ShaderLOD )/2;
+								}
+								else
+								{
+									shaderLod = m_lodMultiPassMasterNodes[ index ].NodesList[ reference.PassIdx ].ShaderLOD - MasterNodeLODIncrement;
+								}
+							}
+						}
+					}
+
+					int nodeId = 0;
+					TemplateMultiPassMasterNode mainMasterNode = null;
+					for( int subShaderIdx = 0; subShaderIdx < templateMultiPass.SubShaders.Count; subShaderIdx++ )
+					{
+						for( int passIdx = 0; passIdx < templateMultiPass.SubShaders[ subShaderIdx ].Passes.Count; passIdx++ )
+						{
+							TemplateMultiPassMasterNode masterNode = ScriptableObject.CreateInstance( typeof( TemplateMultiPassMasterNode ) ) as TemplateMultiPassMasterNode;
+							masterNode.LODIndex = lod;
+							masterNode.ContainerGraph = this;
+							masterNode.Vec2Position = initialPosition;
+							AddNode( masterNode, true );
+							masterNode.SetTemplate( templateMultiPass, true, true, subShaderIdx, passIdx, SetTemplateSource.NewShader );
+							masterNode.CopyOptionsFrom( m_multiPassMasterNodes.NodesList[ nodeId++ ] );
+							if( masterNode.IsMainOutputNode || ( subShaderIdx == 0 && passIdx == 0 ) )
+							{
+								masterNode.SetShaderLODValueAndLabel( shaderLod );
+								mainMasterNode = masterNode;
+							}
+						}
+					}
+
+					mainMasterNode.ForceOptionsRefresh();
+					SortLODMasterNodes();
+					if( OnLODMasterNodesAddedEvent != null )
+					{
+						OnLODMasterNodesAddedEvent( lod );
+					}
+
+					TemplateMultiPassMasterNode lodMainMasterNode = CurrentMasterNode as TemplateMultiPassMasterNode;
+					lodMainMasterNode.SetShaderLODValueAndLabel( lodMainMasterNode.ShaderLOD );
+					return;
+				}
+			}
+		}
+
+		public void DestroyLodMasterNodes( int index )
+		{
+			if( index < 0 )
+			{
+				for( int lod = m_lodMultiPassMasterNodes.Count - 1; lod >= 0; lod-- )
+				{
+					if( m_lodMultiPassMasterNodes[ lod ].Count > 0 )
+					{
+						while( m_lodMultiPassMasterNodes[ lod ].Count > 0 )
+						{
+							DestroyNode( m_lodMultiPassMasterNodes[ lod ].NodesList[ 0 ], false, true );
+						}
+						break;
+					}
+				}
+			}
+			else
+			{
+				while( m_lodMultiPassMasterNodes[ index ].Count > 0 )
+				{
+					DestroyNode( m_lodMultiPassMasterNodes[ index ].NodesList[ 0 ], false, true );
+				}
+			}
+			SortLODMasterNodes();
+			TemplateMultiPassMasterNode lodMainMasterNode = CurrentMasterNode as TemplateMultiPassMasterNode;
+			lodMainMasterNode.SetShaderLODValueAndLabel( lodMainMasterNode.ShaderLOD );
+		}
+
+		public void SortLODMasterNodes()
+		{
+			int idx = (CurrentMasterNode as TemplateMultiPassMasterNode).PassIdx;
+			m_lodMultiPassMasterNodes.Sort( ( x, y ) =>
+			{
+				if( x.Count > 0 )
+				{
+					if( y.Count > 0 )
+					{
+						return -x.NodesList[ idx ].ShaderLOD.CompareTo( y.NodesList[ idx ].ShaderLOD );
+					}
+					else
+					{
+						return -1;
+					}
+				}
+				else
+				{
+					if( y.Count > 0 )
+					{
+						return 1;
+					}
+				}
+				return 0;
+			});
+			
+			for( int lodIdx = 0; lodIdx < m_lodMultiPassMasterNodes.Count; lodIdx++ )
+			{
+				for( int nodeIdx = 0; nodeIdx < m_lodMultiPassMasterNodes[ lodIdx ].Count; nodeIdx++ )
+				{
+					m_lodMultiPassMasterNodes[ lodIdx ].NodesList[ nodeIdx ].LODIndex = lodIdx;
+				}	
+			}
+		}
+
+		public List<TemplateMultiPassMasterNode> GetMultiPassMasterNodes( int lod )
+		{
+			if( lod == -1 )
+				return m_multiPassMasterNodes.NodesList;
+
+			return m_lodMultiPassMasterNodes[ lod ].NodesList;
+		}
+
+		public bool IsNormalDependent { get { return m_normalDependentCount > 0; } }
+
+		public void MarkToDeselect() { m_markedToDeSelect = true; }
+		public void MarkToSelect( int nodeId ) { m_markToSelect = nodeId; }
+		public void MarkWireHighlights() { m_checkSelectedWireHighlights = true; }
+		public List<ParentNode> SelectedNodes { get { return m_selectedNodes; } }
+		public List<ParentNode> MarkedForDeletionNodes { get { return m_markedForDeletion; } }
+		public int CurrentMasterNodeId { get { return m_masterNodeId; } set { m_masterNodeId = value; } }
+
+		public Shader CurrentShader
+		{
+			get
+			{
+				MasterNode masterNode = GetNode( m_masterNodeId ) as MasterNode;
+				if( masterNode != null )
+					return masterNode.CurrentShader;
+				return null;
+			}
+		}
+
+		public Material CurrentMaterial
+		{
+			get
+			{
+				MasterNode masterNode = GetNode( m_masterNodeId ) as MasterNode;
+				if( masterNode != null )
+					return masterNode.CurrentMaterial;
+				return null;
+			}
+		}
+		
+
+
+		public NodeAvailability CurrentCanvasMode { get { return m_currentCanvasMode; } set { m_currentCanvasMode = value; ParentWindow.LateRefreshAvailableNodes(); } }
+		public OutputNode CurrentOutputNode { get { return GetNode( m_masterNodeId ) as OutputNode; } }
+		public FunctionOutput CurrentFunctionOutput { get { return GetNode( m_masterNodeId ) as FunctionOutput; } }
+		public MasterNode CurrentMasterNode { get { return GetNode( m_masterNodeId ) as MasterNode; } }
+		public StandardSurfaceOutputNode CurrentStandardSurface { get { return GetNode( m_masterNodeId ) as StandardSurfaceOutputNode; } }
+		public List<ParentNode> AllNodes { get { return m_nodes; } }
+		public int NodeCount { get { return m_nodes.Count; } }
+		//public List<ParentNode> VisibleNodes { get { return m_visibleNodes; } }
+
+		public int NodeClicked
+		{
+			set { m_nodeClicked = value; }
+			get { return m_nodeClicked; }
+		}
+
+		public bool IsDirty
+		{
+			set { m_isDirty = value && UIUtils.DirtyMask; }
+			get
+			{
+				bool value = m_isDirty;
+				m_isDirty = false;
+				return value;
+			}
+		}
+
+		public bool SaveIsDirty
+		{
+			set { m_saveIsDirty = value && UIUtils.DirtyMask; }
+			get { return m_saveIsDirty; }
+		}
+		public int LoadedShaderVersion
+		{
+			get { return m_loadedShaderVersion; }
+			set { m_loadedShaderVersion = value; }
+		}
+
+		public AmplifyShaderFunction CurrentShaderFunction
+		{
+			get { if( CurrentFunctionOutput != null ) return CurrentFunctionOutput.Function; else return null; }
+			set { if( CurrentFunctionOutput != null ) CurrentFunctionOutput.Function = value; }
+		}
+
+		public bool HasUnConnectedNodes { get { return m_hasUnConnectedNodes; } }
+		public UsageListSamplerNodes SamplerNodes { get { return m_samplerNodes; } }
+		public UsageListFloatIntNodes FloatIntNodes { get { return m_floatNodes; } }
+		public UsageListTexturePropertyNodes TexturePropertyNodes { get { return m_texturePropertyNodes; } }
+		public UsageListTextureArrayNodes TextureArrayNodes { get { return m_textureArrayNodes; } }
+		public UsageListPropertyNodes PropertyNodes { get { return m_propertyNodes; } }
+		public UsageListPropertyNodes RawPropertyNodes { get { return m_rawPropertyNodes; } }
+		public UsageListCustomExpressionsOnFunctionMode CustomExpressionOnFunctionMode { get { return m_customExpressionsOnFunctionMode; } }
+		public UsageListStaticSwitchNodes StaticSwitchNodes { get { return m_staticSwitchNodes; } }
+		public UsageListScreenColorNodes ScreenColorNodes { get { return m_screenColorNodes; } }
+		public UsageListRegisterLocalVarNodes LocalVarNodes { get { return m_localVarNodes; } }
+		public UsageListGlobalArrayNodes GlobalArrayNodes { get { return m_globalArrayNodes; } }
+		public UsageListFunctionInputNodes FunctionInputNodes { get { return m_functionInputNodes; } }
+		public UsageListFunctionNodes FunctionNodes { get { return m_functionNodes; } }
+		public UsageListFunctionOutputNodes FunctionOutputNodes { get { return m_functionOutputNodes; } }
+		public UsageListFunctionSwitchNodes FunctionSwitchNodes { get { return m_functionSwitchNodes; } }
+		public UsageListFunctionSwitchCopyNodes FunctionSwitchCopyNodes { get { return m_functionSwitchCopyNodes; } }
+		public UsageListTemplateMultiPassMasterNodes MultiPassMasterNodes { get { return m_multiPassMasterNodes; } set { m_multiPassMasterNodes = value; } }
+		public List<UsageListTemplateMultiPassMasterNodes> LodMultiPassMasternodes { get { return m_lodMultiPassMasterNodes; } }
+
+
+		public PrecisionType CurrentPrecision
+		{
+			get { return m_currentPrecision; }
+			set { m_currentPrecision = value; }
+		}
+
+		public NodeLOD LodLevel
+		{
+			get { return m_lodLevel; }
+		}
+
+		public List<ParentNode> NodePreviewList { get { return m_nodePreviewList; } set { m_nodePreviewList = value; } }
+
+		public void SetGraphId( int id )
+		{
+			m_graphId = id;
+		}
+
+		public int GraphId
+		{
+			get { return m_graphId; }
+		}
+
+		public AmplifyShaderEditorWindow ParentWindow
+		{
+			get { return m_parentWindow; }
+			set { m_parentWindow = value; }
+		}
+
+
+		public bool ChangedLightingModel
+		{
+			get { return m_changedLightingModel; }
+			set { m_changedLightingModel = value; }
+		}
+
+		public bool ForceRepositionCheck
+		{
+			get { return m_forceRepositionCheck; }
+			set { m_forceRepositionCheck = value; }
+		}
+
+		public bool IsLoading { get { return m_isLoading; } set { m_isLoading = value; } }
+		public bool IsDuplicating { get { return m_isDuplicating; } set { m_isDuplicating = value; } }
+		public TemplateSRPType CurrentSRPType { get { return m_currentSRPType; }set { m_currentSRPType = value; } }
+		public bool IsSRP { get { return m_currentSRPType == TemplateSRPType.Lightweight || m_currentSRPType == TemplateSRPType.HD; } }
+		public bool IsHDRP { get { return m_currentSRPType == TemplateSRPType.HD; } }
+		public bool IsLWRP { get { return m_currentSRPType == TemplateSRPType.Lightweight; } }
+		public bool IsStandardSurface { get { return GetNode( m_masterNodeId ) is StandardSurfaceOutputNode; } }
+		public bool SamplingThroughMacros { get { return m_samplingThroughMacros && IsSRP; } set { m_samplingThroughMacros = value; } }
+		public bool HasLODs { get { return m_lodMultiPassMasterNodes[ 0 ].Count > 0; } }
+		//public bool HasLodMultiPassNodes
+		//{
+		//	get
+		//	{
+		//		for( int i = 0; i < m_lodMultiPassMasterNodes.Count; i++ )
+		//		{
+		//			if( m_lodMultiPassMasterNodes[ i ].Count > 0 )
+		//				return true;
+		//		}
+		//		return false;
+		//	}
+		//}
+	}
+}