*移动amplify shader editor到third party目录

1 files changed, 837 insertions, 0 deletions

diff --git a/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateAdditionalDirectivesHelper.cs b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateAdditionalDirectivesHelper.cs
new file mode 100644
index 00000000..31c03b59
--- /dev/null
+++ b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateAdditionalDirectivesHelper.cs
@@ -0,0 +1,837 @@
+// Amplify Shader Editor - Visual Shader Editing Tool
+// Copyright (c) Amplify Creations, Lda <info@amplify.pt>
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEditorInternal;
+
+namespace AmplifyShaderEditor
+{
+	public enum AdditionalLineType
+	{
+		Include,
+		Define,
+		Pragma,
+		Custom
+	}
+
+	public enum AdditionalContainerOrigin
+	{
+		Native,
+		ShaderFunction,
+		Custom
+	}
+
+
+	[Serializable]
+	public class AdditionalDirectiveContainerSaveItem
+	{
+		public AdditionalLineType LineType = AdditionalLineType.Include;
+		public string LineValue = string.Empty;
+		public bool GUIDToggle = false;
+		public string GUIDValue = string.Empty;
+		public AdditionalContainerOrigin Origin = AdditionalContainerOrigin.Custom;
+		public AdditionalDirectiveContainerSaveItem( AdditionalLineType lineType, string lineValue, bool guidToggle, string guidValue, AdditionalContainerOrigin origin )
+		{
+			LineType = lineType;
+			LineValue = lineValue;
+			GUIDToggle = guidToggle;
+			GUIDValue = guidValue;
+			Origin = origin;
+		}
+
+		public AdditionalDirectiveContainerSaveItem( AdditionalDirectiveContainer container )
+		{
+			LineType = container.LineType;
+			LineValue = container.LineValue;
+			GUIDToggle = container.GUIDToggle;
+			GUIDValue = container.GUIDValue;
+			Origin = container.Origin;
+		}
+	}
+
+	[Serializable]
+	public class AdditionalDirectiveContainer : ScriptableObject
+	{
+		public AdditionalLineType LineType = AdditionalLineType.Include;
+		public string LineValue = string.Empty;
+		public bool GUIDToggle = false;
+		public string GUIDValue = string.Empty;
+		public AdditionalContainerOrigin Origin = AdditionalContainerOrigin.Custom;
+		public TextAsset LibObject = null;
+		public string OwnerId = string.Empty;
+
+		public void Init( string ownerId, AdditionalDirectiveContainer item )
+		{
+			 LineType = item.LineType;
+			 LineValue = item.LineValue;
+			 GUIDToggle = item.GUIDToggle;
+			 GUIDValue = item.GUIDValue;
+			 Origin = item.Origin;
+			 LibObject = item.LibObject;
+			 OwnerId = ownerId;
+		}
+
+		public void Init( AdditionalDirectiveContainerSaveItem item )
+		{
+			LineType = item.LineType;
+			LineValue = item.LineValue;
+			GUIDToggle = item.GUIDToggle;
+			GUIDValue = item.GUIDValue;
+			Origin = item.Origin;
+			if( GUIDToggle )
+			{
+				LibObject = AssetDatabase.LoadAssetAtPath<TextAsset>( AssetDatabase.GUIDToAssetPath( GUIDValue ) );
+			}
+		}
+
+		public void OnDestroy()
+		{
+			//Debug.Log( "Destoying directives" );
+			LibObject = null;
+		}
+
+		public string Value
+		{
+			get
+			{
+				switch( LineType )
+				{
+					case AdditionalLineType.Include:
+					{
+						if( GUIDToggle )
+						{
+							string shaderPath = AssetDatabase.GUIDToAssetPath( GUIDValue );
+							if( !string.IsNullOrEmpty( shaderPath ) )
+								return shaderPath;
+						}
+						return LineValue;
+					}
+					case AdditionalLineType.Define: return LineValue;
+					case AdditionalLineType.Pragma: return LineValue;
+				}
+				return LineValue;
+			}
+		}
+
+		public string FormattedValue
+		{
+			get
+			{
+				switch( LineType )
+				{
+					case AdditionalLineType.Include:
+					{
+						if( GUIDToggle )
+						{
+							string shaderPath = AssetDatabase.GUIDToAssetPath( GUIDValue );
+							if( !string.IsNullOrEmpty( shaderPath ) )
+								return string.Format( Constants.IncludeFormat, shaderPath );
+						}
+
+						return string.Format( Constants.IncludeFormat, LineValue );
+					}
+					case AdditionalLineType.Define:
+					return string.Format( Constants.DefineFormat, LineValue );
+					case AdditionalLineType.Pragma:
+					return string.Format( Constants.PragmaFormat, LineValue );
+				}
+				return LineValue;
+			}
+		}
+	}
+
+
+
+	public enum ReordableAction
+	{
+		None,
+		Add,
+		Remove
+	}
+
+	[Serializable]
+	public sealed class TemplateAdditionalDirectivesHelper : TemplateModuleParent
+	{
+		private string NativeFoldoutStr = "Native";
+
+		[SerializeField]
+		private List<AdditionalDirectiveContainer> m_additionalDirectives = new List<AdditionalDirectiveContainer>();
+
+		[SerializeField]
+		private List<AdditionalDirectiveContainer> m_shaderFunctionDirectives = new List<AdditionalDirectiveContainer>();
+
+		[SerializeField]
+		private List<string> m_nativeDirectives = new List<string>();
+
+		[SerializeField]
+		private int m_nativeDirectivesIndex = -1;
+
+		[SerializeField]
+		private bool m_nativeDirectivesFoldout = false;
+
+		//ONLY USED BY SHADER FUNCTIONS
+		// Since AdditionalDirectiveContainer must be a ScriptableObject because of serialization shenanigans it will not serialize the info correctly into the shader function when saving it into a file ( it only saves the id )
+		// For it to properly work, each AdditionalDirectiveContainer should be added to the SF asset, but that would make it to have children ( which are seen on the project inspector )
+		// Must revisit this later on and come up with a proper solution
+		[SerializeField]
+		private List<AdditionalDirectiveContainerSaveItem> m_directivesSaveItems = new List<AdditionalDirectiveContainerSaveItem>();
+
+
+		private ReordableAction m_actionType = ReordableAction.None;
+		private int m_actionIndex = 0;
+		private ReorderableList m_reordableList = null;
+		private GUIStyle m_propertyAdjustment;
+		private UndoParentNode m_currOwner;
+		private Rect m_nativeRect = Rect.zero;
+
+		public TemplateAdditionalDirectivesHelper( string moduleName ) : base( moduleName ) { }
+
+		//public void AddShaderFunctionItem( AdditionalLineType type, string item )
+		//{
+		//	UpdateShaderFunctionDictionary();
+		//	string id = type + item;
+		//	if( !m_shaderFunctionDictionary.ContainsKey( id ) )
+		//	{
+		//		AdditionalDirectiveContainer newItem = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+		//		newItem.LineType = type;
+		//		newItem.LineValue = item;
+		//		newItem.hideFlags = HideFlags.HideAndDontSave;
+		//		m_shaderFunctionDirectives.Add( newItem );
+		//		m_shaderFunctionDictionary.Add( id, newItem );
+		//	}
+		//}
+
+		public void AddShaderFunctionItems( string ownerOutputId, List<AdditionalDirectiveContainer> functionList )
+		{
+			RemoveShaderFunctionItems( ownerOutputId );
+			if( functionList.Count > 0 )
+			{
+				for( int i = 0; i < functionList.Count; i++ )
+				{
+					AdditionalDirectiveContainer item = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+					item.Init( ownerOutputId, functionList[ i ] );
+					m_shaderFunctionDirectives.Add( item );
+				}
+			}
+			//if( functionList.Count > 0 )
+			//{
+
+			//	m_shaderFunctionDirectives.AddRange( functionList );
+			//}
+		}
+
+		public void RemoveShaderFunctionItems( string ownerOutputId/*, List<AdditionalDirectiveContainer> functionList */)
+		{
+			List<AdditionalDirectiveContainer>  list = m_shaderFunctionDirectives.FindAll( ( x ) => x.OwnerId.Equals( ownerOutputId ));
+			for( int i = 0; i < list.Count; i++ )
+			{
+				m_shaderFunctionDirectives.Remove( list[ i ] );
+				ScriptableObject.DestroyImmediate( list[ i ] );
+			}
+			list.Clear();
+			list = null;
+
+			//for( int i = 0; i < functionList.Count; i++ )
+			//{
+			//	m_shaderFunctionDirectives.Remove( functionList[ i ] );
+			//}
+		}
+
+		//public void RemoveShaderFunctionItem( AdditionalLineType type, string item )
+		//{
+		//	m_shaderFunctionDirectives.RemoveAll( x => x.LineType == type && x.LineValue.Equals( item ) );
+		//}
+
+		public void AddItems( AdditionalLineType type, List<string> items )
+		{
+			int count = items.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				AdditionalDirectiveContainer newItem = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+				newItem.LineType = type;
+				newItem.LineValue = items[ i ];
+				newItem.hideFlags = HideFlags.HideAndDontSave;
+				m_additionalDirectives.Add( newItem );
+			}
+			UpdateNativeIndex();
+		}
+
+		public void AddNativeContainer()
+		{
+			if( m_nativeDirectives.Count > 0 )
+			{
+				if( m_additionalDirectives.FindIndex( x => x.Origin.Equals( AdditionalContainerOrigin.Native ) ) == -1 )
+				{
+					AdditionalDirectiveContainer newItem = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+					newItem.Origin = AdditionalContainerOrigin.Native;
+					newItem.hideFlags = HideFlags.HideAndDontSave;
+					//m_additionalDirectives.Add( newItem );
+					//m_nativeDirectivesIndex = m_additionalDirectives.Count - 1;
+					m_additionalDirectives.Insert( 0, newItem );
+					m_nativeDirectivesIndex = 0;
+				}
+			}
+		}
+
+		public void FillNativeItems( List<string> nativeItems )
+		{
+			m_nativeDirectives.Clear();
+			m_nativeDirectives.AddRange( nativeItems );
+			AddNativeContainer();
+		}
+
+		void DrawNativeItems()
+		{
+			EditorGUILayout.Separator();
+			EditorGUI.indentLevel++;
+			int count = m_nativeDirectives.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				EditorGUILayout.LabelField( m_nativeDirectives[ i ] );
+			}
+			EditorGUI.indentLevel--;
+			EditorGUILayout.Separator();
+		}
+
+		void DrawNativeItemsRect()
+		{
+			int count = m_nativeDirectives.Count;
+			m_nativeRect.y += EditorGUIUtility.singleLineHeight;
+			for( int i = 0; i < count; i++ )
+			{
+				EditorGUI.LabelField( m_nativeRect, m_nativeDirectives[ i ] );
+				m_nativeRect.y += EditorGUIUtility.singleLineHeight;
+			}
+		}
+
+		void DrawButtons()
+		{
+			EditorGUILayout.Separator();
+
+			// Add keyword
+			if( GUILayout.Button( string.Empty, UIUtils.PlusStyle, GUILayout.Width( Constants.PlusMinusButtonLayoutWidth ) ) )
+			{
+				AdditionalDirectiveContainer newItem = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+				newItem.hideFlags = HideFlags.HideAndDontSave;
+				m_additionalDirectives.Add( newItem );
+				UpdateNativeIndex();
+				EditorGUI.FocusTextInControl( null );
+				m_isDirty = true;
+			}
+
+			//Remove keyword
+			if( GUILayout.Button( string.Empty, UIUtils.MinusStyle, GUILayout.Width( Constants.PlusMinusButtonLayoutWidth ) ) )
+			{
+				if( m_additionalDirectives.Count > 0 )
+				{
+					AdditionalDirectiveContainer itemToDelete = m_additionalDirectives[ m_additionalDirectives.Count - 1 ];
+					m_additionalDirectives.RemoveAt( m_additionalDirectives.Count - 1 );
+					ScriptableObject.DestroyImmediate( itemToDelete );
+					EditorGUI.FocusTextInControl( null );
+				}
+				m_isDirty = true;
+			}
+		}
+
+		public override void Draw( UndoParentNode currOwner, bool style = true )
+		{
+			m_currOwner = currOwner;
+			if( m_reordableList == null )
+			{
+				m_reordableList = new ReorderableList( m_additionalDirectives, typeof( AdditionalDirectiveContainer ), true, false, false, false )
+				{
+					headerHeight = 0,
+					footerHeight = 0,
+					showDefaultBackground = false,
+					elementHeightCallback = ( index ) =>
+					{
+						if( m_additionalDirectives[ index ].Origin == AdditionalContainerOrigin.Native && m_nativeDirectivesFoldout )
+						{
+							return ( m_nativeDirectives.Count + 1 ) * ( EditorGUIUtility.singleLineHeight ) + 5;
+						}
+
+						return EditorGUIUtility.singleLineHeight + 5;
+					},
+					drawElementCallback = ( Rect rect, int index, bool isActive, bool isFocused ) =>
+					{
+						if( m_additionalDirectives[ index ].Origin == AdditionalContainerOrigin.Native && m_nativeDirectivesFoldout )
+						{
+							rect.height = ( m_nativeDirectives.Count + 1 ) * ( EditorGUIUtility.singleLineHeight ) + 5;
+						}
+
+						if( m_additionalDirectives[ index ] != null )
+						{
+							float labelWidthStyleAdjust = 0;
+							if( style )
+							{
+								rect.xMin -= 10;
+								labelWidthStyleAdjust = 15;
+							}
+							else
+							{
+								rect.xMin -= 1;
+							}
+
+							float popUpWidth = style ? 75 : 60f;
+							float widthAdjust = m_additionalDirectives[ index ].LineType == AdditionalLineType.Include ? -14 : 0;
+							Rect popupPos = new Rect( rect.x, rect.y, popUpWidth, EditorGUIUtility.singleLineHeight );
+							Rect GUIDTogglePos = m_additionalDirectives[ index ].LineType == AdditionalLineType.Include ? new Rect( rect.x + rect.width - 3 * Constants.PlusMinusButtonLayoutWidth, rect.y, Constants.PlusMinusButtonLayoutWidth, Constants.PlusMinusButtonLayoutWidth ) : new Rect();
+							Rect buttonPlusPos = new Rect( rect.x + rect.width - 2 * Constants.PlusMinusButtonLayoutWidth, rect.y - 2, Constants.PlusMinusButtonLayoutWidth, Constants.PlusMinusButtonLayoutWidth );
+							Rect buttonMinusPos = new Rect( rect.x + rect.width - Constants.PlusMinusButtonLayoutWidth, rect.y - 2, Constants.PlusMinusButtonLayoutWidth, Constants.PlusMinusButtonLayoutWidth );
+							float labelWidthBuffer = EditorGUIUtility.labelWidth;
+							Rect labelPos = new Rect( rect.x + popupPos.width - labelWidthStyleAdjust, rect.y, labelWidthStyleAdjust + rect.width - popupPos.width - buttonPlusPos.width - buttonMinusPos.width + widthAdjust, EditorGUIUtility.singleLineHeight );
+
+							if( m_additionalDirectives[ index ].Origin == AdditionalContainerOrigin.Native )
+							{
+								m_nativeRect = rect;
+#if UNITY_2019_3_OR_NEWER
+								m_nativeRect.y -= ( m_nativeRect.height - ( EditorGUIUtility.singleLineHeight + 5 ) ) * 0.5f;
+#endif
+								m_nativeRect.xMin += 2;
+								m_nativeRect.xMax -= 2;
+								m_nativeRect.yMax -= 2;
+
+								NodeUtils.DrawNestedPropertyGroup( ref m_nativeDirectivesFoldout, rect, NativeFoldoutStr, DrawNativeItemsRect, 4 );
+								return;
+							}
+
+							m_additionalDirectives[ index ].LineType = (AdditionalLineType)m_currOwner.EditorGUIEnumPopup( popupPos, m_additionalDirectives[ index ].LineType );
+
+							if( m_additionalDirectives[ index ].LineType == AdditionalLineType.Include )
+							{
+								if( m_additionalDirectives[ index ].GUIDToggle )
+								{
+									//if( m_additionalDirectives[ index ].LibObject == null && !string.IsNullOrEmpty( m_additionalDirectives[ index ].GUIDValue ) )
+									//{
+									//	m_additionalDirectives[ index ].LibObject = AssetDatabase.LoadAssetAtPath<TextAsset>( AssetDatabase.GUIDToAssetPath( m_additionalDirectives[ index ].GUIDValue ) );
+									//}
+
+									EditorGUI.BeginChangeCheck();
+									TextAsset obj = m_currOwner.EditorGUIObjectField( labelPos, m_additionalDirectives[ index ].LibObject, typeof( TextAsset ), false ) as TextAsset;
+									if( EditorGUI.EndChangeCheck() )
+									{
+										string pathName = AssetDatabase.GetAssetPath( obj );
+										string extension = Path.GetExtension( pathName );
+										extension = extension.ToLower();
+										if( extension.Equals( ".cginc" ) || extension.Equals( ".hlsl" ) )
+										{
+											m_additionalDirectives[ index ].LibObject = obj;
+											m_additionalDirectives[ index ].GUIDValue = AssetDatabase.AssetPathToGUID( pathName );
+										}
+									}
+								}
+								else
+								{
+									m_additionalDirectives[ index ].LineValue = m_currOwner.EditorGUITextField( labelPos, string.Empty, m_additionalDirectives[ index ].LineValue );
+								}
+
+								if( GUI.Button( GUIDTogglePos, m_additionalDirectives[ index ].GUIDToggle ? UIUtils.FloatIntIconOFF : UIUtils.FloatIntIconON, UIUtils.FloatIntPickerONOFF ) )
+									m_additionalDirectives[ index ].GUIDToggle = !m_additionalDirectives[ index ].GUIDToggle;
+							}
+							else
+							{
+								m_additionalDirectives[ index ].LineValue = m_currOwner.EditorGUITextField( labelPos, string.Empty, m_additionalDirectives[ index ].LineValue );
+							}
+
+							if( GUI.Button( buttonPlusPos, string.Empty, UIUtils.PlusStyle ) )
+							{
+								m_actionType = ReordableAction.Add;
+								m_actionIndex = index;
+							}
+
+							if( GUI.Button( buttonMinusPos, string.Empty, UIUtils.MinusStyle ) )
+							{
+								m_actionType = ReordableAction.Remove;
+								m_actionIndex = index;
+							}
+						}
+					},
+					onReorderCallback = ( ReorderableList list ) =>
+					{
+						UpdateNativeIndex();
+					}
+				};
+			}
+
+			if( m_actionType != ReordableAction.None )
+			{
+				switch( m_actionType )
+				{
+					case ReordableAction.Add:
+					{
+						AdditionalDirectiveContainer newItem = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+						newItem.hideFlags = HideFlags.HideAndDontSave;
+						m_additionalDirectives.Insert( m_actionIndex + 1, newItem );
+					}
+					break;
+					case ReordableAction.Remove:
+					AdditionalDirectiveContainer itemToDelete = m_additionalDirectives[ m_actionIndex ];
+					m_additionalDirectives.RemoveAt( m_actionIndex );
+					ScriptableObject.DestroyImmediate( itemToDelete );
+					break;
+				}
+				m_isDirty = true;
+				m_actionType = ReordableAction.None;
+				EditorGUI.FocusTextInControl( null );
+			}
+			bool foldoutValue = currOwner.ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedAdditionalDirectives;
+			if( style )
+			{
+				NodeUtils.DrawPropertyGroup( ref foldoutValue, m_moduleName, DrawReordableList, DrawButtons );
+			}
+			else
+			{
+				NodeUtils.DrawNestedPropertyGroup( ref foldoutValue, m_moduleName, DrawReordableList, DrawButtons );
+			}
+			currOwner.ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedAdditionalDirectives = foldoutValue;
+		}
+
+		void DrawReordableList()
+		{
+			if( m_reordableList != null )
+			{
+				if( m_propertyAdjustment == null )
+				{
+					m_propertyAdjustment = new GUIStyle();
+					m_propertyAdjustment.padding.left = 17;
+				}
+				//EditorGUILayout.BeginVertical( m_propertyAdjustment );
+				EditorGUILayout.Space();
+				if( m_nativeDirectives.Count > 0 )
+				{
+					//NodeUtils.DrawNestedPropertyGroup( ref m_nativeDirectivesFoldout, NativeFoldoutStr, DrawNativeItems, 4 );
+				}
+				if( m_additionalDirectives.Count == 0 )
+				{
+					EditorGUILayout.HelpBox( "Your list is Empty!\nUse the plus button to add one.", MessageType.Info );
+				}
+				else
+				{
+					m_reordableList.DoLayoutList();
+				}
+				EditorGUILayout.Space();
+				//EditorGUILayout.EndVertical();
+			}
+		}
+
+		public void AddAllToDataCollector( ref MasterNodeDataCollector dataCollector, TemplateIncludePragmaContainter nativesContainer )
+		{
+			//List<AdditionalDirectiveContainer> list = m_additionalDirectives;
+			//int count = list.FindIndex( x => x.Origin.Equals( AdditionalContainerOrigin.Native ) );
+			//for( int i = 0; i < count; i++ )
+			//{
+			//	switch( list[ i ].LineType )
+			//	{
+			//		case AdditionalLineType.Include:
+			//		{
+			//			string value = list[ i ].Value;
+			//			if( !string.IsNullOrEmpty( value ) &&
+			//			  !nativesContainer.HasInclude( value ) )
+			//			{
+			//				dataCollector.AddToMisc( list[ i ].FormattedValue );
+			//			}
+			//		}
+			//		break;
+			//		case AdditionalLineType.Define:
+			//		{
+			//			if( !string.IsNullOrEmpty( list[ i ].LineValue ) &&
+			//			  !nativesContainer.HasDefine( list[ i ].LineValue ) )
+			//			{
+			//				dataCollector.AddToMisc( list[ i ].FormattedValue );
+			//			}
+			//		}
+			//		break;
+			//		case AdditionalLineType.Pragma:
+			//		{
+			//			if( !string.IsNullOrEmpty( list[ i ].LineValue ) &&
+			//			  !nativesContainer.HasPragma( list[ i ].LineValue ) )
+			//			{
+			//				dataCollector.AddToMisc( list[ i ].FormattedValue );
+			//			}
+			//		}
+			//		break;
+			//		default:
+			//		case AdditionalLineType.Custom:
+			//		dataCollector.AddToMisc( list[ i ].LineValue );
+			//		break;
+			//	}
+			//}
+
+			AddToDataCollector( ref dataCollector, nativesContainer, false );
+			AddToDataCollector( ref dataCollector, nativesContainer, true );
+		}
+
+		public void AddAllToDataCollector( ref MasterNodeDataCollector dataCollector )
+		{
+			AddToDataCollector( ref dataCollector, false );
+			AddToDataCollector( ref dataCollector, true );
+		}
+
+		void AddToDataCollector( ref MasterNodeDataCollector dataCollector, TemplateIncludePragmaContainter nativesContainer, bool fromSF )
+		{
+			List<AdditionalDirectiveContainer> list = fromSF ? m_shaderFunctionDirectives : m_additionalDirectives;
+			int count = list.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				int orderIdx = fromSF ? 1 : ( i > m_nativeDirectivesIndex ? 1 : -1 );
+				switch( list[ i ].LineType )
+				{
+					case AdditionalLineType.Include:
+					{
+						string value = list[ i ].Value;
+						if( !string.IsNullOrEmpty( value ) &&
+						  !nativesContainer.HasInclude( value ) )
+						{
+							dataCollector.AddToDirectives( list[ i ].FormattedValue, orderIdx );
+						}
+					}
+					break;
+					case AdditionalLineType.Define:
+					{
+						if( !string.IsNullOrEmpty( list[ i ].LineValue ) &&
+						  !nativesContainer.HasDefine( list[ i ].LineValue ) )
+						{
+							dataCollector.AddToDirectives( list[ i ].FormattedValue, orderIdx );
+						}
+					}
+					break;
+					case AdditionalLineType.Pragma:
+					{
+						if( !string.IsNullOrEmpty( list[ i ].LineValue ) &&
+						  !nativesContainer.HasPragma( list[ i ].LineValue ) )
+						{
+							dataCollector.AddToDirectives( list[ i ].FormattedValue, orderIdx );
+						}
+					}
+					break;
+					default:
+					case AdditionalLineType.Custom:
+					dataCollector.AddToDirectives( list[ i ].LineValue, orderIdx );
+					break;
+				}
+			}
+		}
+
+		void AddToDataCollector( ref MasterNodeDataCollector dataCollector, bool fromSF )
+		{
+			List<AdditionalDirectiveContainer> list = fromSF ? m_shaderFunctionDirectives : m_additionalDirectives;
+			int orderIdx = 1;
+			int count = list.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				switch( list[ i ].LineType )
+				{
+					case AdditionalLineType.Include:
+					{
+						string value = list[ i ].FormattedValue;
+						if( !string.IsNullOrEmpty( value ) )
+						{
+							dataCollector.AddToDirectives( value, orderIdx );
+						}
+					}
+					break;
+					case AdditionalLineType.Define:
+					{
+						if( !string.IsNullOrEmpty( list[ i ].LineValue ) )
+						{
+							dataCollector.AddToDirectives( list[ i ].FormattedValue, orderIdx );
+						}
+					}
+					break;
+					case AdditionalLineType.Pragma:
+					{
+						if( !string.IsNullOrEmpty( list[ i ].LineValue ) )
+						{
+							dataCollector.AddToDirectives( list[ i ].FormattedValue, orderIdx );
+						}
+					}
+					break;
+					default:
+					case AdditionalLineType.Custom:
+					dataCollector.AddToDirectives( list[ i ].LineValue, orderIdx );
+					break;
+				}
+			}
+		}
+
+		public override void ReadFromString( ref uint index, ref string[] nodeParams )
+		{
+			try
+			{
+				m_nativeDirectivesIndex = -1;
+				int count = Convert.ToInt32( nodeParams[ index++ ] );
+				m_additionalDirectives.Clear();
+				for( int i = 0; i < count; i++ )
+				{
+					AdditionalLineType lineType = (AdditionalLineType)Enum.Parse( typeof( AdditionalLineType ), nodeParams[ index++ ] );
+					string lineValue = nodeParams[ index++ ];
+					AdditionalDirectiveContainer newItem = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+					newItem.hideFlags = HideFlags.HideAndDontSave;
+					newItem.LineType = lineType;
+					newItem.LineValue = lineValue.Replace( Constants.SemiColonSeparator, ';' );
+					if( UIUtils.CurrentShaderVersion() > 15607 )
+					{
+						newItem.GUIDToggle = Convert.ToBoolean( nodeParams[ index++ ] );
+						newItem.GUIDValue = nodeParams[ index++ ];
+						if( newItem.GUIDToggle )
+						{
+							newItem.LibObject = AssetDatabase.LoadAssetAtPath<TextAsset>( AssetDatabase.GUIDToAssetPath( newItem.GUIDValue ) );
+							if( newItem.LibObject == null )
+							{
+								Debug.LogWarning( "Include file not found with GUID " + newItem.GUIDValue );
+							}
+						}
+					}
+					AdditionalContainerOrigin origin = AdditionalContainerOrigin.Custom;
+					if( UIUtils.CurrentShaderVersion() > 16902 )
+					{
+						origin = (AdditionalContainerOrigin)Enum.Parse( typeof( AdditionalContainerOrigin ), nodeParams[ index++ ] );
+						newItem.Origin = origin;
+					}
+
+					m_additionalDirectives.Add( newItem );
+
+					if( origin == AdditionalContainerOrigin.Native )
+					{
+						m_nativeDirectivesIndex = i;
+					}
+				}
+				AddNativeContainer();
+			}
+			catch( Exception e )
+			{
+				Debug.LogException( e );
+			}
+		}
+
+		public override void WriteToString( ref string nodeInfo )
+		{
+			if( m_additionalDirectives.Count == 1 && m_additionalDirectives[ 0 ].Origin == AdditionalContainerOrigin.Native )
+			{
+				IOUtils.AddFieldValueToString( ref nodeInfo, 0 );
+				return;
+			}
+
+			IOUtils.AddFieldValueToString( ref nodeInfo, m_additionalDirectives.Count );
+			for( int i = 0; i < m_additionalDirectives.Count; i++ )
+			{
+				IOUtils.AddFieldValueToString( ref nodeInfo, m_additionalDirectives[ i ].LineType );
+				IOUtils.AddFieldValueToString( ref nodeInfo, m_additionalDirectives[ i ].LineValue.Replace( ';', Constants.SemiColonSeparator ) );
+				IOUtils.AddFieldValueToString( ref nodeInfo, m_additionalDirectives[ i ].GUIDToggle );
+				IOUtils.AddFieldValueToString( ref nodeInfo, m_additionalDirectives[ i ].GUIDValue );
+				IOUtils.AddFieldValueToString( ref nodeInfo, m_additionalDirectives[ i ].Origin );
+			}
+		}
+
+		// read comment on m_directivesSaveItems declaration
+		public void UpdateSaveItemsFromDirectives()
+		{
+			bool foundNull = false;
+			m_directivesSaveItems.Clear();
+			for( int i = 0; i < m_additionalDirectives.Count; i++ )
+			{
+				if( m_additionalDirectives[ i ] != null )
+				{
+					m_directivesSaveItems.Add( new AdditionalDirectiveContainerSaveItem( m_additionalDirectives[ i ] ) );
+				}
+				else
+				{
+					foundNull = true;
+				}
+			}
+
+			if( foundNull )
+			{
+				m_additionalDirectives.RemoveAll( item => item == null );
+			}
+		}
+
+		public void CleanNullDirectives()
+		{
+			m_additionalDirectives.RemoveAll( item => item == null );
+		}
+
+		public void ResetDirectivesOrigin()
+		{
+			for( int i = 0; i < m_directivesSaveItems.Count; i++ )
+			{
+				m_directivesSaveItems[ i ].Origin = AdditionalContainerOrigin.Custom;
+			}
+		}
+
+		// read comment on m_directivesSaveItems declaration
+		public void UpdateDirectivesFromSaveItems()
+		{
+			if( m_directivesSaveItems.Count > 0 )
+			{
+				for( int i = 0; i < m_additionalDirectives.Count; i++ )
+				{
+					if( m_additionalDirectives[ i ] != null )
+						ScriptableObject.DestroyImmediate( m_additionalDirectives[ i ] );
+				}
+
+				m_additionalDirectives.Clear();
+
+				for( int i = 0; i < m_directivesSaveItems.Count; i++ )
+				{
+					AdditionalDirectiveContainer newItem = ScriptableObject.CreateInstance<AdditionalDirectiveContainer>();
+					newItem.hideFlags = HideFlags.HideAndDontSave;
+					newItem.Init( m_directivesSaveItems[ i ] );
+					m_additionalDirectives.Add( newItem );
+				}
+				UpdateNativeIndex();
+				//m_directivesSaveItems.Clear();
+			}
+		}
+
+		void UpdateNativeIndex()
+		{
+			m_nativeDirectivesIndex = -1;
+			int count = m_additionalDirectives.Count;
+			for( int i = 0; i < count; i++ )
+			{
+				if( m_additionalDirectives[ i ].Origin == AdditionalContainerOrigin.Native )
+				{
+					m_nativeDirectivesIndex = i;
+					break;
+				}
+			}
+		}
+
+		public override void Destroy()
+		{
+			base.Destroy();
+
+			m_nativeDirectives.Clear();
+			m_nativeDirectives = null;
+
+			for( int i = 0; i < m_additionalDirectives.Count; i++ )
+			{
+				ScriptableObject.DestroyImmediate( m_additionalDirectives[ i ] );
+			}
+
+			m_additionalDirectives.Clear();
+			m_additionalDirectives = null;
+
+			for( int i = 0; i < m_shaderFunctionDirectives.Count; i++ )
+			{
+				ScriptableObject.DestroyImmediate( m_shaderFunctionDirectives[ i ] );
+			}
+
+			m_shaderFunctionDirectives.Clear();
+			m_shaderFunctionDirectives = null;
+
+
+			m_propertyAdjustment = null;
+			m_reordableList = null;
+		}
+
+
+		public List<AdditionalDirectiveContainer> DirectivesList { get { return m_additionalDirectives; } }
+		public bool IsValid { get { return m_validData; } set { m_validData = value; } }
+	}
+}