*移动amplify shader editor到third party目录

1 files changed, 2374 insertions, 0 deletions

diff --git a/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateHelperFunctions.cs b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateHelperFunctions.cs
new file mode 100644
index 00000000..d5fc6583
--- /dev/null
+++ b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateHelperFunctions.cs
@@ -0,0 +1,2374 @@
+// Amplify Shader Editor - Visual Shader Editing Tool
+// Copyright (c) Amplify Creations, Lda <info@amplify.pt>
+
+using System;
+using System.Text.RegularExpressions;
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace AmplifyShaderEditor
+{
+	public enum CustomTemplatePropertyUIEnum
+	{
+		None,
+		HDPBR
+	}
+
+	public enum TemplateSemantics
+	{
+		NONE,
+		POSITION,
+		SV_POSITION,
+		COLOR,
+		COLOR0,
+		COLOR1,
+		TEXCOORD0,
+		TEXCOORD1,
+		TEXCOORD2,
+		TEXCOORD3,
+		TEXCOORD4,
+		TEXCOORD5,
+		TEXCOORD6,
+		TEXCOORD7,
+		TEXCOORD8,
+		TEXCOORD9,
+		TEXCOORD10,
+		TEXCOORD11,
+		TEXCOORD12,
+		TEXCOORD13,
+		TEXCOORD14,
+		TEXCOORD15,
+		NORMAL,
+		TANGENT,
+		VFACE,
+		SV_VertexID,
+		SV_PrimitiveID,
+		SV_InstanceID,
+		INTERNALTESSPOS
+	}
+
+	public enum TemplateInfoOnSematics
+	{
+		NONE,
+		POSITION,
+		CLIP_POS,
+		SCREEN_POSITION,
+		SCREEN_POSITION_NORMALIZED,
+		COLOR,
+		TEXTURE_COORDINATES0,
+		TEXTURE_COORDINATES1,
+		TEXTURE_COORDINATES2,
+		TEXTURE_COORDINATES3,
+		TEXTURE_COORDINATES4,
+		TEXTURE_COORDINATES5,
+		TEXTURE_COORDINATES6,
+		TEXTURE_COORDINATES7,
+		NORMAL,
+		TANGENT,
+		WORLD_NORMAL,
+		WORLD_TANGENT,
+		WORLD_BITANGENT,
+		WORLD_VIEW_DIR,
+		WORLD_POSITION,
+		RELATIVE_WORLD_POS,
+		INSTANCE_ID,
+		OTHER,
+		VFACE,
+		SHADOWCOORDS,
+		VERTEXID
+	}
+
+	public enum TemplateShaderPropertiesIdx
+	{
+		Identation = 1,
+		Name = 3,
+		InspectorName,
+		Type
+	}
+
+	public enum TemplateShaderGlobalsIdx
+	{
+		Type = 1,
+		Name = 2
+	}
+	public enum TemplateDataCheck
+	{
+		Valid,
+		Invalid
+	}
+
+	public enum InvisibleOptionsEnum
+	{
+		SyncProperties = 1 << 0
+	}
+
+	public enum TemplateSpecialTags
+	{
+		RenderType,
+		Queue,
+		None
+	}
+
+	public class TemplateReplaceHelper
+	{
+		public TemplateMultiPassMasterNode MasterNode = null;
+		public bool Used = false;
+		public TemplateReplaceHelper( TemplateMultiPassMasterNode masterNode ) { MasterNode = masterNode; }
+	}
+
+	[Serializable]
+	public class TemplatesTagData
+	{
+		public string Name;
+		public string Value;
+		public TemplatesTagData( string name, string value )
+		{
+			Name = name;
+			Value = value;
+		}
+	}
+
+	[Serializable]
+	public class TemplateModuleData
+	{
+		public bool IndependentModule = true;
+		public TemplateDataCheck DataCheck = TemplateDataCheck.Invalid;
+		public string InlineData = string.Empty;
+		public int StartIdx;
+		public bool IsValid { get { return DataCheck == TemplateDataCheck.Valid; } }
+		public virtual void SetAllModulesDefault() { IndependentModule = false; DataCheck = TemplateDataCheck.Valid; }
+	}
+
+	[Serializable]
+	public sealed class TemplateTagsModuleData : TemplateModuleData
+	{
+		public string TagsId;
+		public List<TemplatesTagData> Tags = new List<TemplatesTagData>();
+		public void Destroy()
+		{
+			Tags.Clear();
+			Tags = null;
+		}
+
+		public void Reset()
+		{
+			Tags.Clear();
+		}
+
+		public void Dump()
+		{
+			string dump = string.Empty;
+			for( int i = 0; i < Tags.Count; i++ )
+			{
+				dump += string.Format( "[{0}] Name: {1} Value: {2}\n", i, Tags[ i ].Name, Tags[ i ].Value );
+			}
+			Debug.Log( dump );
+		}
+	}
+
+	[Serializable]
+	public class TemplateShaderModelData : TemplateModuleData
+	{
+		public string Id = string.Empty;
+		public string Value = "2.5";
+		public int InterpolatorAmount = 8;
+		public bool Encapsulate = false;
+		public override void SetAllModulesDefault()
+		{
+			base.SetAllModulesDefault();
+			Id = string.Empty;
+			Value = "3.0";
+			InterpolatorAmount = 10;
+			Encapsulate = true;
+		}
+	}
+
+	[Serializable]
+	public sealed class TemplateDepthData : TemplateModuleData
+	{
+		public bool ValidZWrite;
+		public string ZWriteModeId;
+		public ZWriteMode ZWriteModeValue;
+		public int ZWriteStartIndex;
+		public string ZWriteInlineValue;
+
+
+		public bool ValidZTest;
+		public string ZTestModeId;
+		public ZTestMode ZTestModeValue;
+		public int ZTestStartIndex;
+		public string ZTestInlineValue;
+
+		public bool ValidOffset;
+		public string OffsetId;
+		public float OffsetFactor;
+		public float OffsetUnits;
+		public int OffsetStartIndex;
+		public string OffsetFactorInlineValue;
+		public string OffsetUnitsInlineValue;
+
+		public override void SetAllModulesDefault()
+		{
+			base.SetAllModulesDefault();
+			ValidZWrite = true;
+			ZWriteModeId = string.Empty;
+			ZWriteModeValue = ZWriteMode.On;
+			ZWriteStartIndex = -1;
+			ZWriteInlineValue = string.Empty;
+
+
+			ValidZTest = true;
+			ZTestModeId = string.Empty;
+			ZTestModeValue = ZTestMode.LEqual;
+			ZTestStartIndex = -1;
+			ZTestInlineValue = string.Empty;
+
+			ValidOffset = true;
+			OffsetId = string.Empty;
+			OffsetFactor = 0;
+			OffsetUnits = 0;
+			OffsetStartIndex = -1;
+			OffsetFactorInlineValue = string.Empty;
+			OffsetUnitsInlineValue = string.Empty;
+		}
+
+		public void SetDataCheck()
+		{
+			DataCheck = ( ValidZWrite || ValidZTest || ValidOffset )?TemplateDataCheck.Valid:TemplateDataCheck.Invalid;
+		}
+	}
+
+	[Serializable]
+	public sealed class TemplateStencilData : TemplateModuleData
+	{
+		public string StencilBufferId;
+		public bool Active = true;
+
+		public int Reference;
+		public string ReferenceInline;
+
+		public int ReadMask = 255;
+		public string ReadMaskInline;
+
+		public int WriteMask = 255;
+		public string WriteMaskInline;
+
+		public string ComparisonFront;
+		public string ComparisonFrontInline;
+
+		public string PassFront;
+		public string PassFrontInline;
+
+		public string FailFront;
+		public string FailFrontInline;
+
+		public string ZFailFront;
+		public string ZFailFrontInline;
+
+		public string ComparisonBack;
+		public string ComparisonBackInline;
+
+		public string PassBack;
+		public string PassBackInline;
+
+		public string FailBack;
+		public string FailBackInline;
+
+		public string ZFailBack;
+		public string ZFailBackInline;
+
+		public void SetDefaultValues()
+		{
+			Active = false;
+
+			StencilBufferId = string.Empty;
+
+			Reference = 255;
+			ReferenceInline = string.Empty;
+
+			ReadMask = 255;
+			ReadMaskInline = string.Empty;
+
+			WriteMask = 255;
+			WriteMaskInline = string.Empty;
+
+			ComparisonFront = "always";
+			ComparisonFrontInline = string.Empty;
+
+			PassFront = "keep";
+			PassFrontInline = string.Empty;
+
+			FailFront = "keep";
+			FailFrontInline = string.Empty;
+
+			ZFailFront = "keep";
+			ZFailFrontInline = string.Empty;
+
+
+			ComparisonBack = "always";
+			ComparisonBackInline = string.Empty;
+
+			PassBack = "keep";
+			PassBackInline = string.Empty;
+
+			FailBack = "keep";
+			FailBackInline = string.Empty;
+
+			ZFailBack = "keep";
+			ZFailBackInline = string.Empty;
+		}
+
+		public void SetIndependentDefault()
+		{
+			IndependentModule = true;
+			DataCheck = TemplateDataCheck.Valid;
+			SetDefaultValues();
+		}
+
+		public override void SetAllModulesDefault()
+		{
+			base.SetAllModulesDefault();
+			SetDefaultValues();
+		}
+	}
+
+	[Serializable]
+	public sealed class TemplateBlendData : TemplateModuleData
+	{
+		public bool ValidBlendMode = false;
+		public bool BlendModeOff = true;
+
+		public string BlendModeId;
+		public bool SeparateBlendFactors = false;
+		public AvailableBlendFactor SourceFactorRGB = AvailableBlendFactor.One;
+		public string SourceFactorRGBInline;
+		public AvailableBlendFactor DestFactorRGB = AvailableBlendFactor.Zero;
+		public string DestFactorRGBInline;
+		public int BlendModeStartIndex;
+
+		public AvailableBlendFactor SourceFactorAlpha = AvailableBlendFactor.One;
+		public string SourceFactorAlphaInline;
+		public AvailableBlendFactor DestFactorAlpha = AvailableBlendFactor.Zero;
+		public string DestFactorAlphaInline;
+
+		public bool ValidBlendOp = false;
+		public string BlendOpId;
+		public bool SeparateBlendOps = false;
+		public AvailableBlendOps BlendOpRGB = AvailableBlendOps.OFF;
+		public string BlendOpRGBInline;
+		public AvailableBlendOps BlendOpAlpha = AvailableBlendOps.OFF;
+		public string BlendOpAlphaInline;
+		public int BlendOpStartIndex;
+
+		public bool IndependentAlphaToMask = false;
+		public bool ValidAlphaToMask = false;
+		public bool AlphaToMaskValue = false;
+		public string AlphaToMaskId;
+
+		public override void SetAllModulesDefault()
+		{
+			base.SetAllModulesDefault();
+
+			if( !ValidAlphaToMask )
+			{
+				ValidAlphaToMask = true;
+				AlphaToMaskValue = false;
+				AlphaToMaskId = string.Empty;
+			}
+
+			if( !ValidBlendMode )
+			{
+				ValidBlendMode = true;
+				BlendModeOff = true;
+				BlendModeId = string.Empty;
+				SeparateBlendFactors = false;
+				SourceFactorRGB = AvailableBlendFactor.One;
+				SourceFactorRGBInline = string.Empty;
+				DestFactorRGB = AvailableBlendFactor.Zero;
+				DestFactorRGBInline = string.Empty;
+				BlendModeStartIndex = -1;
+				SourceFactorAlpha = AvailableBlendFactor.One;
+				SourceFactorAlphaInline = string.Empty;
+				DestFactorAlpha = AvailableBlendFactor.Zero;
+				DestFactorAlphaInline = string.Empty;
+			}
+
+			if( !ValidBlendOp )
+			{
+				ValidBlendOp = true;
+				BlendOpId = string.Empty;
+				SeparateBlendOps = false;
+				BlendOpRGB = AvailableBlendOps.OFF;
+				BlendOpRGBInline = string.Empty;
+				BlendOpAlpha = AvailableBlendOps.OFF;
+				BlendOpAlphaInline = string.Empty;
+				BlendOpStartIndex = -1;
+			}
+
+			DataCheck = TemplateDataCheck.Valid;
+		}
+
+	}
+
+	[Serializable]
+	public sealed class TemplateCullModeData : TemplateModuleData
+	{
+		public string CullModeId;
+		public CullMode CullModeData = CullMode.Back;
+		public override void SetAllModulesDefault()
+		{
+			base.SetAllModulesDefault();
+			CullModeId = string.Empty;
+			CullModeData = CullMode.Back;
+		}
+	}
+
+	[Serializable]
+	public sealed class TemplateColorMaskData : TemplateModuleData
+	{
+		public string ColorMaskId;
+		public bool[] ColorMaskData = { true, true, true, true };
+		public override void SetAllModulesDefault()
+		{
+			base.SetAllModulesDefault();
+			ColorMaskId = string.Empty;
+			for( int i = 0; i < ColorMaskData.Length; i++ )
+			{
+				ColorMaskData[ i ] = true;
+			}
+		}
+	}
+
+	public static class TemplateHelperFunctions
+	{
+		/*
+		struct DirectionalLightData
+		{
+			uint lightLayers;
+			float3 positionRWS;
+			float3 color;
+			int cookieIndex;
+			float volumetricDimmer;
+			float3 right;
+			float3 up;
+			float3 forward;
+			int tileCookie;
+			int shadowIndex;
+			int contactShadowIndex;
+			float4 shadowMaskSelector;
+			int nonLightmappedOnly;
+			float diffuseScale;
+			float specularScale;
+		}; 
+		*/
+		public static string HDLightInfoFormat = "_DirectionalLightDatas[{0}].{1}";
+
+		public static string[] VectorSwizzle = { "x", "y", "z", "w" };
+		public static string[] ColorSwizzle = { "r", "g", "b", "a" };
+
+		public static readonly Dictionary<string, CustomTemplatePropertyUIEnum> CustomTemplatePropertyUI = new Dictionary<string, CustomTemplatePropertyUIEnum>
+		{
+			{ "None", CustomTemplatePropertyUIEnum.None},
+			{ "HDPBR", CustomTemplatePropertyUIEnum.HDPBR}
+		};
+
+		public static readonly Dictionary<string, InvisibleOptionsEnum> InvisibleOptions = new Dictionary<string, InvisibleOptionsEnum>()
+		{
+			{ "SyncP", InvisibleOptionsEnum.SyncProperties }
+		};
+
+		public static readonly Dictionary<string, TemplateSpecialTags> StringToReservedTags = new Dictionary<string, TemplateSpecialTags>()
+		{
+			{ TemplateSpecialTags.RenderType.ToString(), TemplateSpecialTags.RenderType},
+			{ TemplateSpecialTags.Queue.ToString(), TemplateSpecialTags.Queue},
+		};
+
+		public static readonly Dictionary<string, RenderType> StringToRenderType = new Dictionary<string, RenderType>
+		{
+			{"Opaque",RenderType.Opaque},
+			{"Transparent",RenderType.Transparent},
+			{"TransparentCutout",RenderType.TransparentCutout},
+			{"Background",RenderType.Background},
+			{"Overlay",RenderType.Overlay},
+			{"TreeOpaque",RenderType.TreeOpaque},
+			{"TreeTransparentCutout",RenderType.TreeTransparentCutout},
+			{"TreeBillboard",RenderType.TreeBillboard},
+			{"Grass",RenderType.Grass},
+			{"GrassBillboard",RenderType.GrassBillboard}
+		};
+
+		public static readonly Dictionary<string, RenderQueue> StringToRenderQueue = new Dictionary<string, RenderQueue>
+		{
+			{"Background",RenderQueue.Background },
+			{"Geometry",RenderQueue.Geometry },
+			{"AlphaTest",RenderQueue.AlphaTest },
+			{"Transparent",RenderQueue.Transparent },
+			{"Overlay",RenderQueue.Overlay }
+		};
+
+		public static readonly Dictionary<string, WirePortDataType> PropertyToWireType = new Dictionary<string, WirePortDataType>
+		{
+			{"Float",WirePortDataType.FLOAT},
+			{"Range",WirePortDataType.FLOAT},
+			{"Int",WirePortDataType.INT},
+			{"Color",WirePortDataType.COLOR},
+			{"Vector",WirePortDataType.FLOAT4},
+			{"2D",WirePortDataType.SAMPLER2D},
+			{"3D",WirePortDataType.SAMPLER3D},
+			{"Cube",WirePortDataType.SAMPLERCUBE}
+		};
+
+		public static readonly Dictionary<WirePortDataType, int> DataTypeChannelUsage = new Dictionary<WirePortDataType, int>
+		{
+			{WirePortDataType.OBJECT,0 },
+			{WirePortDataType.FLOAT,1 },
+			{WirePortDataType.FLOAT2,2 },
+			{WirePortDataType.FLOAT3,3 },
+			{WirePortDataType.FLOAT4,4 },
+			{WirePortDataType.FLOAT3x3,0 },
+			{WirePortDataType.FLOAT4x4,0 },
+			{WirePortDataType.COLOR,4 },
+			{WirePortDataType.INT,1 },
+			{WirePortDataType.UINT,1 },
+			{WirePortDataType.SAMPLER1D,0 },
+			{WirePortDataType.SAMPLER2D,0 },
+			{WirePortDataType.SAMPLER3D,0 },
+			{WirePortDataType.SAMPLERCUBE,0 }
+		};
+
+		public static readonly Dictionary<int, WirePortDataType> ChannelToDataType = new Dictionary<int, WirePortDataType>
+		{
+			{1,WirePortDataType.FLOAT},
+			{2,WirePortDataType.FLOAT2},
+			{3,WirePortDataType.FLOAT3},
+			{4,WirePortDataType.FLOAT4}
+		};
+
+		public static readonly Dictionary<TemplateSemantics, string> SemanticsDefaultName = new Dictionary<TemplateSemantics, string>
+		{
+			{TemplateSemantics.COLOR			,"ase_color"},
+			{TemplateSemantics.NORMAL			,"ase_normal"},
+			{TemplateSemantics.POSITION			,"ase_position"},
+			{TemplateSemantics.SV_POSITION		,"ase_sv_position"},
+			{TemplateSemantics.TANGENT			,"ase_tangent"},
+			{TemplateSemantics.VFACE			,"ase_vface"},
+			{TemplateSemantics.SV_VertexID		,"ase_vertexId"},
+			{TemplateSemantics.SV_PrimitiveID   ,"ase_primitiveId"},
+			{TemplateSemantics.INTERNALTESSPOS  ,"ase_internalTessPos"},
+			{TemplateSemantics.TEXCOORD0		,"ase_tex_coord0"},
+			{TemplateSemantics.TEXCOORD1		,"ase_tex_coord1"},
+			{TemplateSemantics.TEXCOORD2		,"ase_tex_coord2"},
+			{TemplateSemantics.TEXCOORD3		,"ase_tex_coord3"},
+			{TemplateSemantics.TEXCOORD4		,"ase_tex_coord4"},
+			{TemplateSemantics.TEXCOORD5		,"ase_tex_coord5"},
+			{TemplateSemantics.TEXCOORD6		,"ase_tex_coord6"},
+			{TemplateSemantics.TEXCOORD7		,"ase_tex_coord7"},
+			{TemplateSemantics.TEXCOORD8		,"ase_tex_coord8"},
+			{TemplateSemantics.TEXCOORD9		,"ase_tex_coord9"},
+			{TemplateSemantics.TEXCOORD10		,"ase_tex_coord10"},
+			{TemplateSemantics.TEXCOORD11		,"ase_tex_coord11"},
+			{TemplateSemantics.TEXCOORD12		,"ase_tex_coord12"},
+			{TemplateSemantics.TEXCOORD13		,"ase_tex_coord13"},
+			{TemplateSemantics.TEXCOORD14		,"ase_tex_coord14"},
+			{TemplateSemantics.TEXCOORD15		,"ase_tex_coord15"},
+		};
+
+		public static readonly Dictionary<int, TemplateInfoOnSematics> IntToInfo = new Dictionary<int, TemplateInfoOnSematics>
+		{
+			{0,TemplateInfoOnSematics.TEXTURE_COORDINATES0 },
+			{1,TemplateInfoOnSematics.TEXTURE_COORDINATES1 },
+			{2,TemplateInfoOnSematics.TEXTURE_COORDINATES2 },
+			{3,TemplateInfoOnSematics.TEXTURE_COORDINATES3 },
+			{4,TemplateInfoOnSematics.TEXTURE_COORDINATES4 },
+			{5,TemplateInfoOnSematics.TEXTURE_COORDINATES5 },
+			{6,TemplateInfoOnSematics.TEXTURE_COORDINATES6 },
+			{7,TemplateInfoOnSematics.TEXTURE_COORDINATES7 },
+		};
+
+		public static readonly Dictionary<string, TemplateInfoOnSematics> ShortcutToInfo = new Dictionary<string, TemplateInfoOnSematics>
+		{
+			{"p"    ,TemplateInfoOnSematics.POSITION },
+			{"sp"   ,TemplateInfoOnSematics.CLIP_POS },
+			{"spu"  ,TemplateInfoOnSematics.SCREEN_POSITION },
+			{"spn"  ,TemplateInfoOnSematics.SCREEN_POSITION_NORMALIZED },
+			{"c"    ,TemplateInfoOnSematics.COLOR },
+			{"uv0"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES0 },
+			{"uv1"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES1 },
+			{"uv2"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES2 },
+			{"uv3"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES3 },
+			{"uv4"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES4 },
+			{"uv5"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES5 },
+			{"uv6"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES6 },
+			{"uv7"  ,TemplateInfoOnSematics.TEXTURE_COORDINATES7 },
+			{"n"    ,TemplateInfoOnSematics.NORMAL },
+			{"t"    ,TemplateInfoOnSematics.TANGENT },
+			{"wn"   ,TemplateInfoOnSematics.WORLD_NORMAL},
+			{"wt"   ,TemplateInfoOnSematics.WORLD_TANGENT},
+			{"wbt"  ,TemplateInfoOnSematics.WORLD_BITANGENT},
+			{"wvd"  ,TemplateInfoOnSematics.WORLD_VIEW_DIR},
+			{"wp"   ,TemplateInfoOnSematics.WORLD_POSITION},
+			{"rwp"  ,TemplateInfoOnSematics.RELATIVE_WORLD_POS},
+			{"vf"   ,TemplateInfoOnSematics.VFACE},
+			{"sc"   ,TemplateInfoOnSematics.SHADOWCOORDS}
+		};
+
+		public static readonly Dictionary<TemplateInfoOnSematics, string> InfoToDefineFrag = new Dictionary<TemplateInfoOnSematics, string>
+		{
+			{TemplateInfoOnSematics.POSITION ,"ASE_NEEDS_FRAG_POSITION"},
+			{TemplateInfoOnSematics.CLIP_POS ,"ASE_NEEDS_FRAG_CLIP_POS"},
+			{TemplateInfoOnSematics.SCREEN_POSITION,"ASE_NEEDS_FRAG_SCREEN_POSITION" },
+			{TemplateInfoOnSematics.SCREEN_POSITION_NORMALIZED,"ASE_NEEDS_FRAG_SCREEN_POSITION_NORMALIZED" },
+			{TemplateInfoOnSematics.COLOR, "ASE_NEEDS_FRAG_COLOR"},
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES0,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES0" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES1,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES1" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES2,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES2" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES3,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES3" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES4,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES4" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES5,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES5" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES6,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES6" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES7,"ASE_NEEDS_FRAG_TEXTURE_COORDINATES7" },
+			{TemplateInfoOnSematics.NORMAL,"ASE_NEEDS_FRAG_NORMAL" },
+			{TemplateInfoOnSematics.TANGENT ,"ASE_NEEDS_FRAG_TANGENT"},
+			{TemplateInfoOnSematics.WORLD_NORMAL,"ASE_NEEDS_FRAG_WORLD_NORMAL"},
+			{TemplateInfoOnSematics.WORLD_TANGENT,"ASE_NEEDS_FRAG_WORLD_TANGENT"},
+			{TemplateInfoOnSematics.WORLD_BITANGENT,"ASE_NEEDS_FRAG_WORLD_BITANGENT"},
+			{TemplateInfoOnSematics.WORLD_VIEW_DIR,"ASE_NEEDS_FRAG_WORLD_VIEW_DIR"},
+			{TemplateInfoOnSematics.WORLD_POSITION,"ASE_NEEDS_FRAG_WORLD_POSITION"},
+			{TemplateInfoOnSematics.RELATIVE_WORLD_POS,"ASE_NEEDS_FRAG_RELATIVE_WORLD_POS"},
+			{TemplateInfoOnSematics.VFACE,"ASE_NEEDS_FRAG_VFACE"},
+			{TemplateInfoOnSematics.SHADOWCOORDS,"ASE_NEEDS_FRAG_SHADOWCOORDS"}
+		};
+
+		public static readonly Dictionary<TemplateInfoOnSematics, string> InfoToDefineVertex = new Dictionary<TemplateInfoOnSematics, string>
+		{
+			{TemplateInfoOnSematics.POSITION ,"ASE_NEEDS_VERT_POSITION"},
+			{TemplateInfoOnSematics.CLIP_POS ,"ASE_NEEDS_VERT_CLIP_POS"},
+			{TemplateInfoOnSematics.SCREEN_POSITION,"ASE_NEEDS_VERT_SCREEN_POSITION" },
+			{TemplateInfoOnSematics.SCREEN_POSITION_NORMALIZED,"ASE_NEEDS_VERT_SCREEN_POSITION_NORMALIZED" },
+			{TemplateInfoOnSematics.COLOR, "ASE_NEEDS_VERT_COLOR"},
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES0,"ASE_NEEDS_VERT_TEXTURE_COORDINATES0" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES1,"ASE_NEEDS_VERT_TEXTURE_COORDINATES1" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES2,"ASE_NEEDS_VERT_TEXTURE_COORDINATES2" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES3,"ASE_NEEDS_VERT_TEXTURE_COORDINATES3" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES4,"ASE_NEEDS_VERT_TEXTURE_COORDINATES4" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES5,"ASE_NEEDS_VERT_TEXTURE_COORDINATES5" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES6,"ASE_NEEDS_VERT_TEXTURE_COORDINATES6" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES7,"ASE_NEEDS_VERT_TEXTURE_COORDINATES7" },
+			{TemplateInfoOnSematics.NORMAL,"ASE_NEEDS_VERT_NORMAL" },
+			{TemplateInfoOnSematics.TANGENT ,"ASE_NEEDS_VERT_TANGENT"},
+			{TemplateInfoOnSematics.WORLD_NORMAL,"ASE_NEEDS_VERT_WORLD_NORMAL"},
+			{TemplateInfoOnSematics.WORLD_TANGENT,"ASE_NEEDS_VERT_WORLD_TANGENT"},
+			{TemplateInfoOnSematics.WORLD_BITANGENT,"ASE_NEEDS_VERT_WORLD_BITANGENT"},
+			{TemplateInfoOnSematics.WORLD_VIEW_DIR,"ASE_NEEDS_VERT_WORLD_VIEW_DIR"},
+			{TemplateInfoOnSematics.WORLD_POSITION,"ASE_NEEDS_VERT_WORLD_POSITION"},
+			{TemplateInfoOnSematics.RELATIVE_WORLD_POS,"ASE_NEEDS_VERT_RELATIVE_WORLD_POS"},
+			{TemplateInfoOnSematics.VFACE,"ASE_NEEDS_VERT_VFACE"},
+			{TemplateInfoOnSematics.SHADOWCOORDS,"ASE_NEEDS_VERT_SHADOWCOORDS"}
+		};
+
+		public static readonly Dictionary<TemplateInfoOnSematics, string> InfoToLocalVar = new Dictionary<TemplateInfoOnSematics, string>
+		{
+			{TemplateInfoOnSematics.POSITION,GeneratorUtils.VertexPosition4Str },
+			{TemplateInfoOnSematics.CLIP_POS,GeneratorUtils.ClipPositionStr },
+			{TemplateInfoOnSematics.SCREEN_POSITION,GeneratorUtils.ScreenPositionStr },
+			{TemplateInfoOnSematics.SCREEN_POSITION_NORMALIZED,GeneratorUtils.ScreenPositionNormalizedStr },
+			{TemplateInfoOnSematics.COLOR, "ase_color" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES0, "ase_uv0" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES1, "ase_uv1" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES2, "ase_uv2" },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES3, "ase_uv3" },
+			{TemplateInfoOnSematics.NORMAL, GeneratorUtils.VertexNormalStr },
+			{TemplateInfoOnSematics.TANGENT, GeneratorUtils.VertexTangentStr },
+			{TemplateInfoOnSematics.WORLD_NORMAL, GeneratorUtils.WorldNormalStr},
+			{TemplateInfoOnSematics.WORLD_TANGENT, GeneratorUtils.WorldTangentStr},
+			{TemplateInfoOnSematics.WORLD_BITANGENT, GeneratorUtils.WorldBitangentStr},
+			{TemplateInfoOnSematics.WORLD_VIEW_DIR, GeneratorUtils.WorldViewDirectionStr},
+			{TemplateInfoOnSematics.WORLD_POSITION, GeneratorUtils.WorldPositionStr},
+			{TemplateInfoOnSematics.RELATIVE_WORLD_POS, GeneratorUtils.RelativeWorldPositionStr},
+			{TemplateInfoOnSematics.VFACE, GeneratorUtils.VFaceStr},
+			{TemplateInfoOnSematics.SHADOWCOORDS, GeneratorUtils.ShadowCoordsStr}
+		};
+
+
+		public static readonly Dictionary<TemplateInfoOnSematics, WirePortDataType> InfoToWirePortType = new Dictionary<TemplateInfoOnSematics, WirePortDataType>
+		{
+			{TemplateInfoOnSematics.POSITION,WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.CLIP_POS,WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.SCREEN_POSITION,WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.SCREEN_POSITION_NORMALIZED,WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.COLOR, WirePortDataType.COLOR },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES0, WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES1, WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES2, WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.TEXTURE_COORDINATES3, WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.NORMAL, WirePortDataType.FLOAT3 },
+			{TemplateInfoOnSematics.TANGENT, WirePortDataType.FLOAT4 },
+			{TemplateInfoOnSematics.WORLD_NORMAL, WirePortDataType.FLOAT3},
+			{TemplateInfoOnSematics.WORLD_TANGENT, WirePortDataType.FLOAT3},
+			{TemplateInfoOnSematics.WORLD_BITANGENT, WirePortDataType.FLOAT3},
+			{TemplateInfoOnSematics.WORLD_VIEW_DIR, WirePortDataType.FLOAT3},
+			{TemplateInfoOnSematics.WORLD_POSITION, WirePortDataType.FLOAT3},
+			{TemplateInfoOnSematics.RELATIVE_WORLD_POS, WirePortDataType.FLOAT3},
+			{TemplateInfoOnSematics.VFACE, WirePortDataType.FLOAT},
+			{TemplateInfoOnSematics.SHADOWCOORDS, WirePortDataType.FLOAT4},
+		};
+		public static readonly Dictionary<int, TemplateInfoOnSematics> IntToUVChannelInfo = new Dictionary<int, TemplateInfoOnSematics>
+		{
+			{0,TemplateInfoOnSematics.TEXTURE_COORDINATES0 },
+			{1,TemplateInfoOnSematics.TEXTURE_COORDINATES1 },
+			{2,TemplateInfoOnSematics.TEXTURE_COORDINATES2 },
+			{3,TemplateInfoOnSematics.TEXTURE_COORDINATES3 },
+			{4,TemplateInfoOnSematics.TEXTURE_COORDINATES4 },
+			{5,TemplateInfoOnSematics.TEXTURE_COORDINATES5 },
+			{6,TemplateInfoOnSematics.TEXTURE_COORDINATES6 },
+			{7,TemplateInfoOnSematics.TEXTURE_COORDINATES7 }
+		};
+
+		public static readonly Dictionary<int, TemplateSemantics> IntToSemantic = new Dictionary<int, TemplateSemantics>
+		{
+			{ 0,TemplateSemantics.TEXCOORD0 },
+			{ 1,TemplateSemantics.TEXCOORD1 },
+			{ 2,TemplateSemantics.TEXCOORD2 },
+			{ 3,TemplateSemantics.TEXCOORD3 },
+			{ 4,TemplateSemantics.TEXCOORD4 },
+			{ 5,TemplateSemantics.TEXCOORD5 },
+			{ 6,TemplateSemantics.TEXCOORD6 },
+			{ 7,TemplateSemantics.TEXCOORD7 },
+			{ 8,TemplateSemantics.TEXCOORD8 },
+			{ 9,TemplateSemantics.TEXCOORD9 },
+			{ 10,TemplateSemantics.TEXCOORD10 },
+			{ 11,TemplateSemantics.TEXCOORD11 },
+			{ 12,TemplateSemantics.TEXCOORD12 },
+			{ 13,TemplateSemantics.TEXCOORD13 },
+			{ 14,TemplateSemantics.TEXCOORD14 },
+			{ 15,TemplateSemantics.TEXCOORD15 }
+		};
+
+		public static readonly Dictionary<TemplateSemantics, int> SemanticToInt = new Dictionary<TemplateSemantics, int>
+		{
+			{ TemplateSemantics.TEXCOORD0,0 },
+			{ TemplateSemantics.TEXCOORD1,1 },
+			{ TemplateSemantics.TEXCOORD2,2 },
+			{ TemplateSemantics.TEXCOORD3,3 },
+			{ TemplateSemantics.TEXCOORD4,4 },
+			{ TemplateSemantics.TEXCOORD5,5 },
+			{ TemplateSemantics.TEXCOORD6,6 },
+			{ TemplateSemantics.TEXCOORD7,7 },
+			{ TemplateSemantics.TEXCOORD8,8 },
+			{ TemplateSemantics.TEXCOORD9,9 },
+			{ TemplateSemantics.TEXCOORD10,10 },
+			{ TemplateSemantics.TEXCOORD11,11 },
+			{ TemplateSemantics.TEXCOORD12,12 },
+			{ TemplateSemantics.TEXCOORD13,13 },
+			{ TemplateSemantics.TEXCOORD14,14 },
+			{ TemplateSemantics.TEXCOORD15,15 },
+		};
+
+		public static readonly Dictionary<string, TemplateSemantics> ShortcutToSemantic = new Dictionary<string, TemplateSemantics>
+		{
+			{ "p"   ,TemplateSemantics.POSITION },
+			{ "sp"  ,TemplateSemantics.SV_POSITION },
+			{ "c"   ,TemplateSemantics.COLOR },
+			{ "n"   ,TemplateSemantics.NORMAL },
+			{ "t"   ,TemplateSemantics.TANGENT },
+			{ "tc0" ,TemplateSemantics.TEXCOORD0 },
+			{ "tc1" ,TemplateSemantics.TEXCOORD1 },
+			{ "tc2" ,TemplateSemantics.TEXCOORD2 },
+			{ "tc3" ,TemplateSemantics.TEXCOORD3 },
+			{ "tc4" ,TemplateSemantics.TEXCOORD4 },
+			{ "tc5" ,TemplateSemantics.TEXCOORD5 },
+			{ "tc6" ,TemplateSemantics.TEXCOORD6 },
+			{ "tc7" ,TemplateSemantics.TEXCOORD7 },
+			{ "tc8" ,TemplateSemantics.TEXCOORD8 },
+			{ "tc9" ,TemplateSemantics.TEXCOORD9 },
+			{ "tc10" ,TemplateSemantics.TEXCOORD10 },
+			{ "tc11" ,TemplateSemantics.TEXCOORD11 },
+			{ "tc12" ,TemplateSemantics.TEXCOORD12 },
+			{ "tc13" ,TemplateSemantics.TEXCOORD13 },
+			{ "tc14" ,TemplateSemantics.TEXCOORD14 },
+			{ "tc15" ,TemplateSemantics.TEXCOORD15 }
+		};
+
+		public static readonly Dictionary<string, WirePortDataType> CgToWirePortType = new Dictionary<string, WirePortDataType>()
+		{
+			{"float"            ,WirePortDataType.FLOAT},
+			{"float2"           ,WirePortDataType.FLOAT2},
+			{"float3"           ,WirePortDataType.FLOAT3},
+			{"float4"           ,WirePortDataType.FLOAT4},
+			{"float3x3"         ,WirePortDataType.FLOAT3x3},
+			{"float4x4"         ,WirePortDataType.FLOAT4x4},
+			{"half"             ,WirePortDataType.FLOAT},
+			{"half2"            ,WirePortDataType.FLOAT2},
+			{"half3"            ,WirePortDataType.FLOAT3},
+			{"half4"            ,WirePortDataType.FLOAT4},
+			{"half3x3"          ,WirePortDataType.FLOAT3x3},
+			{"half4x4"          ,WirePortDataType.FLOAT4x4},
+			{"fixed"            ,WirePortDataType.FLOAT},
+			{"fixed2"           ,WirePortDataType.FLOAT2},
+			{"fixed3"           ,WirePortDataType.FLOAT3},
+			{"fixed4"           ,WirePortDataType.FLOAT4},
+			{"fixed3x3"         ,WirePortDataType.FLOAT3x3},
+			{"fixed4x4"         ,WirePortDataType.FLOAT4x4},
+			{"int"              ,WirePortDataType.INT},
+			{"uint"              ,WirePortDataType.INT},
+			{"sampler1D"        ,WirePortDataType.SAMPLER1D},
+			{"sampler2D"        ,WirePortDataType.SAMPLER2D},
+			{"sampler2D_float"  ,WirePortDataType.SAMPLER2D},
+			{"sampler3D"        ,WirePortDataType.SAMPLER3D},
+			{"samplerCUBE"      ,WirePortDataType.SAMPLERCUBE}
+		};
+
+		public static readonly Dictionary<string, int> AvailableInterpolators = new Dictionary<string, int>()
+		{
+			{"2.0",8 },
+			{"2.5",8 },
+			{"3.0",10},
+			{"3.5",10},
+			{"4.0",16},
+			{"4.5",16},
+			{"4.6",16},
+			{"5.0",16}
+		};
+
+		public static readonly string[] AvailableShaderModels =
+		{ "2.0", "2.5", "3.0", "3.5", "4.0", "4.5", "4.6", "5.0" };
+
+		public static readonly Dictionary<string, int> ShaderModelToArrayIdx = new Dictionary<string, int>()
+		{
+			{"2.0",0},
+			{"2.5",1},
+			{"3.0",2},
+			{"3.5",3},
+			{"4.0",4},
+			{"4.5",5},
+			{"4.6",6},
+			{"5.0",7}
+		};
+
+		public static readonly string HDPBRTag = "UNITY_MATERIAL_LIT";
+		public static readonly Dictionary<string, TemplateSRPType> TagToRenderPipeline = new Dictionary<string, TemplateSRPType>()
+		{
+			{ "UniversalPipeline",TemplateSRPType.Lightweight },
+			{ "LightweightPipeline",TemplateSRPType.Lightweight },
+			{ "HDRenderPipeline",TemplateSRPType.HD }
+		};
+#if UNITY_2018_3_OR_NEWER
+		public static string CoreColorLib = "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl";
+		public static string CoreCommonLib = "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl";
+#else
+		public static string CoreCommonLib = "CoreRP/ShaderLibrary/Common.hlsl";
+		public static string CoreColorLib = "CoreRP/ShaderLibrary/Color.hlsl";
+#endif
+
+		public static string FetchSubShaderBody = @"(SubShader.*)\/\*ase_lod\*\/";
+		public static string TemplateCustomUI = @"\/\*CustomNodeUI:(\w*)\*\/";
+		public static string HidePassPattern = @"\/\*ase_hide_pass[:]*([a-zA-Z:]*)\*\/";
+		public static string ASEPassPattern = @"\/\*ase_pass[:]*([a-zA-Z:]*)\*\/";
+		public static string BlendWholeWordPattern = @"\bBlend\b";
+		public static string BlendOpWholeWordPattern = @"\bBlendOp\b";
+		public static string AlphaToMaskPattern = @"\bAlphaToMask (\w*)";
+		public static string CullWholeWordPattern = @"\bCull\b";
+		public static string ColorMaskWholeWordPattern = @"\bColorMask\b";
+		public static string StencilWholeWordPattern = @"\bStencil\b";
+		public static string ZWriteWholeWordPattern = @"\bZWrite\b";
+		public static string ZTestWholeWordPattern = @"\bZTest\b";
+		public static string ZOffsetWholeWordPattern = @"\bOffset\b";
+		public static string TagsWholeWordPattern = @"\bTags\b";
+
+
+		public static string CustomInspectorPattern = "^\\s*CustomEditor\\s+\\\"([\\w\\.]*)\\\"";
+		public static string FallbackPattern = "^\\s*Fallback\\s+\\\"([\\w\\/\\\\]*)\\\"";
+		public static string DefinesPattern = @"^\s*#define\s+([\w .]*)";
+		public static string PragmasPattern = @"^\s*#pragma\s+([\w .]*)";
+		public static string IncludesPattern = "^\\s*#include\\s+\"([\\w.\\/]*)\"";
+		public static string GlobalDirectivesPattern = "[#]+(define|pragma|include)\\s+([\\w .\\/\\\"]*)";
+		public static string BeforePragmaPattern = @"(?:CGPROGRAM|HLSLPROGRAM|GLSLPROGRAM).*?\n(\s*)(.)";
+		public static string GlobalTOPDirectivesPattern = @"(CGPROGRAM|CGINCLUDE|HLSLPROGRAM|HLSLINCLUDE).*?\n\s*(.)";
+
+		public static string VertexPragmaPattern = @"#pragma vertex\s+(\w+)";
+		public static string FragmentPragmaPattern = @"#pragma fragment\s+(\w+)";
+		public static string FunctionBodyStartPattern = @"\s+{0}\s*\(";
+
+		public static string ShaderModelPattern = @"#pragma\s+target\s+([0-9]*[.]*[0-9]*)";
+
+		public static readonly string LocalVarPattern = @"\/\*ase_local_var[:]*(\w*)\*\/\s*(\w*)\s+(\w*)";
+
+		public static readonly string InlinePattern = @"\/\*ase_inline_begin\*\/(.*?)\/\*ase_inline_end\*\/";
+
+		public static readonly string SubShaderLODPattern = @"\sLOD\s+(\d+)";
+
+		public static readonly string PassNamePattern = "Name\\s+\\\"([\\w\\+\\-\\*\\/\\(\\) ]*)\\\"";
+
+		public static readonly string TagsPattern = "\"(\\w+)\"\\s*=\\s*\"(\\w+\\+*\\w*)\"";
+		public static readonly string ZTestPattern = @"^\s*ZTest\s+(\[*\w+\]*)";
+		public static readonly string ZWritePattern = @"^\s*ZWrite\s+(\[*\w+\]*)";
+		//public static readonly string ZOffsetPattern = @"\s*Offset\s+([-+]?[0-9]*\.?[0-9]+)\s*,\s*([-+]?[0-9]*\.?[0-9]+)";
+		public static readonly string ZOffsetPattern = @"^\s*Offset\s+([-+]?[0-9]*\.?[0-9]+|\[*\w+\]*)\s*,\s*([-+]?[0-9]*\.?[0-9]+|\[*\w+\]*)\s*";
+		public static readonly string VertexDataPattern = @"(\w+)\s*(\w+)\s*:\s*([A-Z0-9_]+);";
+		public static readonly string InterpRangePattern = @"ase_interp\((\d\.{0,1}\w{0,4}),(\d*)\)";
+		//public static readonly string PropertiesPatternB = "(\\w*)\\s*\\(\\s*\"([\\w ]*)\"\\s*\\,\\s*(\\w*)\\s*.*\\)";
+		//public static readonly string PropertiesPatternC = "^\\s*(\\w*)\\s*\\(\\s*\"([\\w\\(\\)\\+\\-\\\\* ]*)\"\\s*\\,\\s*(\\w*)\\s*.*\\)";
+		//public static readonly string PropertiesPatternD = "(\\/\\/\\s*)*(\\w*)\\s*\\(\\s*\"([\\w\\(\\)\\+\\-\\\\* ]*)\"\\s*\\,\\s*(\\w*)\\s*.*\\)";
+		//public static readonly string PropertiesPatternE = "(\\/\\/\\s*)*(\\w*)\\s*\\(\\s*\"([\\w\\(\\)\\+\\-\\\\* ]*)\"\\s*\\,\\s*(\\w*)\\s*.*\\)\\s*=\\s*[\\w,()\" {}]*";
+		//public static readonly string PropertiesPatternF = "^(\\/\\/)*\\s*(\\[[\\[\\]\\w\\s\\(\\)\\_\\,]*\\])*\\s*(\\w*)\\s*\\(\\s*\"([\\w\\(\\)\\+\\-\\\\* ]*)\"\\s*\\,\\s*(\\w*)\\s*.*\\)\\s*=\\s*[\\w,()\" {}]*";
+		//public static readonly string PropertiesPatternG = "^(\\s*)(\\[[\\[\\]\\w\\s\\(\\)\\_\\,]*\\])*\\s*(\\w*)\\s*\\(\\s*\"([\\w\\(\\)\\+\\-\\\\* ]*)\"\\s*\\,\\s*(\\w*)\\s*.*\\)\\s*=\\s*[\\w,()\" {}]*";
+		public static readonly string PropertiesPatternG = "^(\\s*)(\\[[\\[\\]\\w\\s\\(\\)_,\\.]*\\])*\\s*(\\w*)\\s*\\(\\s*\"([\\w\\(\\)\\+\\-\\\\* ]*)\"\\s*\\,\\s*(\\w*)\\s*.*\\)\\s*=\\s*[\\w,()\" {}\\.]*";
+		public static readonly string CullModePattern = @"^\s*Cull\s+(\[*\w+\]*)";
+		public static readonly string ColorMaskPattern = @"^\s*ColorMask\s+([\d\w\[\]]+)(\s*\d)*";
+		//public static readonly string BlendModePattern = @"\s*Blend\s+(\w+)\s+(\w+)(?:[\s,]+(\w+)\s+(\w+)|)";
+		//public static readonly string BlendModePattern = @"\s*Blend\s+(\[*\w+\]*)\s+(\[*\w+\]*)(?:[\s,]+(\[*\w+\]*)\s+(\[*\w+\]*)|)";
+		public static readonly string BlendModePattern = @"^\s*Blend\s+(?:(?=\d)|(\[*\w+\]*)\s+(\[*\w+\]*)(?:[\s,]+(\[*\w+\]*)\s+(\[*\w+\]*)|))";
+		//public static readonly string BlendOpPattern = @"\s*BlendOp\s+(\w+)[\s,]*(?:(\w+)|)";
+		//public static readonly string BlendOpPattern = @"\s*BlendOp\s+(\[*\w+\]*)[\s,]*(?:(\[*\w+\]*)|)";
+		public static readonly string BlendOpPattern = @"^\s*BlendOp\s+(?:(?=\d)|(\[*\w+\]*)[\s,]*(?:(\[*\w+\]*)|))";
+
+		public static readonly string StencilOpGlobalPattern = @"Stencil\s*{([\w\W\s]*)}";
+		public static readonly string StencilOpLinePattern = @"(\w+)\s*(\[*\w+\]*)";
+
+		public static readonly string ShaderGlobalsOverallPattern = "(?:\\/\\*ase_pragma\\*\\/|[\\}\\#])[\\w\\s\\;\\/\\*\\.\\\"]*\\/\\*ase_globals\\*\\/";
+		public static readonly string ShaderGlobalsMultilinePattern = @"^\s*(?:uniform\s*)*(\w*)\s*(\w*);$";
+
+		public static readonly string TexSemantic = "float4 {0} : TEXCOORD{1};";
+		public static readonly string TexFullSemantic = "float4 {0} : {1};";
+		public static readonly string InterpFullSemantic = "{0} {1} : {2};";
+		public static readonly string BaseInterpolatorName = "ase_texcoord";
+		public static readonly string TexUVFullSemantic = "float4 ase_texcoord{0} : TEXCOORD{0};";
+		public static readonly string InterpMacro = "{0}({1})";
+
+		public static readonly string InterpolatorDecl = Constants.VertexShaderOutputStr + ".{0} = " + Constants.VertexShaderInputStr + ".{0};";
+		public static readonly string TemplateVariableDecl = "{0} = {1};";
+		public static readonly string TemplateVarFormat = "{0}.{1}";
+
+		//public static readonly string StructsRemoval = @"struct\s+\w+\s+{[\s\w;\/\*]+};";
+		public static readonly string StructsRemoval = @"struct\s+\w+\s+{[\s\w\(\).;:=,\/\*]+};";
+
+		public static readonly string SRPBatcherFindTag = @"CBUFFER_START\s*\(\s*UnityPerMaterial\s*\)\s*\n(\s*)";
+
+		public static string ReplaceAt( this string body, string oldStr, string newStr, int startIndex )
+		{
+			return body.Remove( startIndex, oldStr.Length ).Insert( startIndex, newStr );
+		}
+
+		public static bool GetPassUniqueId( TemplateTagData tagData, TemplatePropertyContainer propertyContainer, TemplateIdManager idManager, string uniquePrefix, int offsetIdx, string subBody, ref string  passUniqueID )
+		{
+			Match match = Regex.Match( subBody, ASEPassPattern );
+			if( match.Success && match.Groups.Count > 1 && match.Groups[1].Length > 0  )
+			{
+				passUniqueID = match.Groups[ 1 ].Value;
+
+				tagData.StartIdx = offsetIdx + match.Index;
+				tagData.Id = match.Value;
+
+				idManager.RegisterId( tagData.StartIdx, uniquePrefix + tagData.Id, tagData.Id );
+				propertyContainer.AddId( subBody, tagData.Id, tagData.SearchIndentation );
+				return true;
+			}
+			return false;
+		}
+
+		public static CustomTemplatePropertyUIEnum FetchCustomUI( string data )
+		{
+			Match match = Regex.Match( data, TemplateCustomUI );
+			if( match.Success && CustomTemplatePropertyUI.ContainsKey( match.Groups[ 1 ].Value ) )
+			{
+				return CustomTemplatePropertyUI[ match.Groups[ 1 ].Value ];
+			}
+			return CustomTemplatePropertyUIEnum.None;
+		}
+
+		public static bool FetchInvisibleInfo( string input, ref int optionsArr, ref string id, ref int idIndex )
+		{
+			Match match = Regex.Match( input, HidePassPattern );
+			if( match.Success )
+			{
+				id = match.Value;
+				idIndex = match.Index;
+				if( match.Groups.Count > 1 )
+				{
+					string[] properties = match.Groups[ 1 ].Value.Split( ':' );
+					for( int i = 0; i < properties.Length; i++ )
+					{
+						if( InvisibleOptions.ContainsKey( properties[ i ] ) )
+						{
+							optionsArr |= (int)InvisibleOptions[ properties[ i ] ];
+						}
+					}
+				}
+			}
+			return match.Success;
+		}
+
+		static public string GenerateTextureSemantic( ref MasterNodeDataCollector dataCollector, int uv )
+		{
+			string texCoordName = BaseInterpolatorName;
+			if( uv > 0 )
+			{
+				texCoordName += uv.ToString();
+			}
+
+			string texCoordData = string.Format( TexSemantic, texCoordName, uv );
+			dataCollector.AddToVertexInput( texCoordData );
+			dataCollector.AddToInterpolators( texCoordData );
+			dataCollector.AddToVertexInterpolatorsDecl( string.Format( InterpolatorDecl, texCoordName ) );
+			return texCoordName;
+		}
+
+		public static void CreatePragmaIncludeList( string data, TemplateIncludePragmaContainter includePragmaContainer )
+		{
+			// this finds the topmost position for including directives
+			int topIndex = -1;
+			foreach( Match match in Regex.Matches( data, GlobalTOPDirectivesPattern, RegexOptions.Singleline ) )
+			{
+				if( match.Groups.Count == 3 )
+				{
+					topIndex = match.Groups[ 2 ].Index;
+				}
+			}
+
+			foreach( Match match in Regex.Matches( data, GlobalDirectivesPattern, RegexOptions.Multiline ) )
+			{
+				if( match.Success )
+				{
+					includePragmaContainer.AddNativeDirective( match.Groups[ 0 ].Value, topIndex );
+				}
+			}
+
+			foreach( Match match in Regex.Matches( data, PragmasPattern, RegexOptions.Multiline ) )
+			{
+				if( match.Groups.Count == 2 )
+				{
+					includePragmaContainer.AddPragma( match.Groups[ 1 ].Value );
+				}
+			}
+
+			foreach( Match match in Regex.Matches( data, DefinesPattern, RegexOptions.Multiline ) )
+			{
+				if( match.Groups.Count == 2 )
+				{
+					includePragmaContainer.AddDefine( match.Groups[ 1 ].Value );
+				}
+			}
+
+			foreach( Match match in Regex.Matches( data, IncludesPattern, RegexOptions.Multiline ) )
+			{
+				if( match.Groups.Count == 2 )
+				{
+					includePragmaContainer.AddInclude( match.Groups[ 1 ].Value );
+				}
+			}
+		}
+
+		public static void CreateShaderPropertiesList( string propertyData, ref List<TemplateShaderPropertyData> propertiesList, ref Dictionary<string, TemplateShaderPropertyData> duplicatesHelper )
+		{
+			int identationIdx = (int)TemplateShaderPropertiesIdx.Identation;
+			int nameIdx = (int)TemplateShaderPropertiesIdx.Name;
+			int typeIdx = (int)TemplateShaderPropertiesIdx.Type;
+			int inspectorNameIdx = (int)TemplateShaderPropertiesIdx.InspectorName;
+
+			foreach( Match match in Regex.Matches( propertyData, PropertiesPatternG,RegexOptions.Multiline ) )
+			{
+				if( match.Groups.Count > 1 )
+				{
+					if( !duplicatesHelper.ContainsKey( match.Groups[ nameIdx ].Value ) && PropertyToWireType.ContainsKey( match.Groups[ typeIdx ].Value ) )
+					{
+						TemplateShaderPropertyData newData = new TemplateShaderPropertyData(	match.Index,
+																								match.Value,
+																								match.Groups[ identationIdx ].Value,
+																								match.Groups[ inspectorNameIdx ].Value,
+																								match.Groups[ nameIdx ].Value,
+																								PropertyToWireType[ match.Groups[ typeIdx ].Value ],
+																								PropertyType.Property );
+						propertiesList.Add( newData );
+						duplicatesHelper.Add( newData.PropertyName, newData );
+					}	
+				}
+			}
+		}
+
+		public static void CreateShaderGlobalsList( string propertyData, ref List<TemplateShaderPropertyData> propertiesList, ref Dictionary<string, TemplateShaderPropertyData> duplicatesHelper )
+		{
+			int typeIdx = (int)TemplateShaderGlobalsIdx.Type;
+			int nameIdx = (int)TemplateShaderGlobalsIdx.Name;
+			
+			// removes structs
+			propertyData = Regex.Replace( propertyData, StructsRemoval, "" );
+			MatchCollection matchCollection = Regex.Matches( propertyData, ShaderGlobalsOverallPattern );
+			string value = ( matchCollection.Count > 0 ) ? matchCollection[ 0 ].Groups[ 0 ].Value : propertyData;
+			foreach( Match lineMatch in Regex.Matches( value, ShaderGlobalsMultilinePattern, RegexOptions.Multiline ) )
+			{
+				if( lineMatch.Groups.Count > 1 )
+				{
+					if( !duplicatesHelper.ContainsKey( lineMatch.Groups[ nameIdx ].Value ) && CgToWirePortType.ContainsKey( lineMatch.Groups[ typeIdx ].Value ) )
+					{
+						TemplateShaderPropertyData newData = new TemplateShaderPropertyData( -1,
+																								string.Empty,
+																								string.Empty,
+																								string.Empty,
+																								lineMatch.Groups[ nameIdx ].Value,
+																								CgToWirePortType[ lineMatch.Groups[ typeIdx ].Value ],
+																								PropertyType.Global );
+						duplicatesHelper.Add( newData.PropertyName, newData );
+						propertiesList.Add( newData );
+					}
+				}
+			}
+		}
+
+		public static void CreateStencilOps( string stencilData, ref TemplateStencilData stencilDataObj )
+		{
+			stencilDataObj.DataCheck = TemplateDataCheck.Invalid;
+			MatchCollection overallGlobalMatch = Regex.Matches( stencilData, StencilOpGlobalPattern );
+			if( overallGlobalMatch.Count == 1 && overallGlobalMatch[ 0 ].Groups.Count == 2 )
+			{
+				string property = string.Empty;
+				string value = overallGlobalMatch[ 0 ].Groups[ 1 ].Value;
+				foreach( Match match in Regex.Matches( value, StencilOpLinePattern ) )
+				{
+					stencilDataObj.DataCheck = TemplateDataCheck.Valid;
+					if( match.Groups.Count == 3 )
+					{
+						switch( match.Groups[ 1 ].Value )
+						{
+							default:
+								{
+									stencilDataObj.DataCheck = TemplateDataCheck.Invalid;
+									return;
+								}
+							case "Ref":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.ReferenceInline = property;
+									}
+									else
+									{
+										try
+										{
+											stencilDataObj.Reference = Convert.ToInt32( match.Groups[ 2 ].Value );
+										}
+										catch( Exception e )
+										{
+											Debug.LogException( e );
+											stencilDataObj.DataCheck = TemplateDataCheck.Invalid;
+											return;
+										}
+									}
+								}
+								break;
+							case "ReadMask":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.ReadMaskInline = property;
+									}
+									else
+									{
+										try
+										{
+											stencilDataObj.ReadMask = Convert.ToInt32( match.Groups[ 2 ].Value );
+										}
+										catch( Exception e )
+										{
+											Debug.LogException( e );
+											stencilDataObj.DataCheck = TemplateDataCheck.Invalid;
+											return;
+										}
+									}
+								}
+								break;
+							case "WriteMask":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.WriteMaskInline = property;
+									}
+									else
+									{
+										try
+										{
+											stencilDataObj.WriteMask = Convert.ToInt32( match.Groups[ 2 ].Value );
+										}
+										catch( Exception e )
+										{
+											Debug.LogException( e );
+											stencilDataObj.DataCheck = TemplateDataCheck.Invalid;
+											return;
+										}
+									}
+								}
+								break;
+							case "CompFront":
+							case "Comp":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.ComparisonFrontInline = property;
+									}
+									else
+									{
+										stencilDataObj.ComparisonFront = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+							case "PassFront":
+							case "Pass":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.PassFrontInline = property;
+									}
+									else
+									{
+										stencilDataObj.PassFront = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+							case "FailFront":
+							case "Fail":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.FailFrontInline = property;
+									}
+									else
+									{
+										stencilDataObj.FailFront = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+							case "ZFail":
+							case "ZFailFront":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.ZFailFrontInline = property;
+									}
+									else
+									{
+										stencilDataObj.ZFailFront = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+							case "CompBack":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.ComparisonBackInline = property;
+									}
+									else
+									{
+										stencilDataObj.ComparisonBack = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+							case "PassBack":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.PassBackInline = property;
+									}
+									else
+									{
+										stencilDataObj.PassBack = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+							case "FailBack":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.FailBackInline = property;
+									}
+									else
+									{
+										stencilDataObj.FailBack = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+							case "ZFailBack":
+								{
+									if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+									{
+										stencilDataObj.ZFailBackInline = property;
+									}
+									else
+									{
+										stencilDataObj.ZFailBack = match.Groups[ 2 ].Value;
+									}
+								}
+								break;
+						}
+					}
+				}
+			}
+		}
+
+		public static void CreateColorMask( string colorMaskData, ref TemplateColorMaskData colorMaskObj )
+		{
+			colorMaskObj.DataCheck = TemplateDataCheck.Invalid;
+			Match match = Regex.Match( colorMaskData, ColorMaskPattern );
+			if( match.Groups.Count == 3 && !match.Groups[ 2 ].Success ) // second group is the colormask MRT which isn't implemented yet
+			{
+				string property = string.Empty;
+				if( match.Groups[ 1 ].Success && IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+				{
+					colorMaskObj.InlineData = property;
+					colorMaskObj.DataCheck = TemplateDataCheck.Valid;
+				}
+				else
+				{
+					for( int i = 0; i < 4; i++ )
+					{
+						colorMaskObj.ColorMaskData[ i ] = false;
+					}
+
+					colorMaskObj.DataCheck = TemplateDataCheck.Valid;
+					try
+					{
+						for( int i = 0; i < match.Groups[ 1 ].Value.Length; i++ )
+						{
+							switch( Char.ToLower( match.Groups[ 1 ].Value[ i ] ) )
+							{
+								case 'r': colorMaskObj.ColorMaskData[ 0 ] = true; break;
+								case 'g': colorMaskObj.ColorMaskData[ 1 ] = true; break;
+								case 'b': colorMaskObj.ColorMaskData[ 2 ] = true; break;
+								case 'a': colorMaskObj.ColorMaskData[ 3 ] = true; break;
+								case '0':
+									{
+										for( int j = 0; j < 4; j++ )
+										{
+											colorMaskObj.ColorMaskData[ j ] = false;
+										}
+										return;
+									}
+								default:
+									{
+										colorMaskObj.DataCheck = TemplateDataCheck.Invalid;
+										return;
+									}
+							}
+						}
+					}
+					catch( Exception e )
+					{
+						Debug.LogException( e );
+						colorMaskObj.DataCheck = TemplateDataCheck.Invalid;
+						return;
+					}
+				}
+			}
+		}
+
+		public static void CreateCullMode( string cullModeData, ref TemplateCullModeData cullDataObj )
+		{
+			cullDataObj.DataCheck = TemplateDataCheck.Invalid;
+			Match match = Regex.Match( cullModeData, CullModePattern );
+			if( match.Groups.Count == 2 )
+			{
+				string property = string.Empty;
+				if( match.Groups[ 1 ].Success && IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+				{
+					cullDataObj.InlineData = property;
+					cullDataObj.DataCheck = TemplateDataCheck.Valid;
+				}
+				else
+				{
+					try
+					{
+						cullDataObj.CullModeData = (CullMode)Enum.Parse( typeof( CullMode ), match.Groups[ 1 ].Value );
+						cullDataObj.DataCheck = TemplateDataCheck.Valid;
+					}
+					catch( Exception e )
+					{
+						cullDataObj.DataCheck = TemplateDataCheck.Invalid;
+						Debug.LogException( e );
+						return;
+					}
+				}
+			}
+		}
+
+		public static void CreateBlendMode( string blendModeData, ref TemplateBlendData blendDataObj )
+		{
+			blendDataObj.ValidBlendMode = true;
+			string property = string.Empty;
+			bool noMatches = true;
+			// TODO: OPTIMIZE REGEX EXPRESSIONS TO NOT CATCH EMPTY GROUPS 
+			foreach( Match match in Regex.Matches( blendModeData, BlendModePattern ) )
+			{
+
+				if( match.Groups.Count == 3 )
+				{
+					if( match.Groups[ 0 ].Success &&
+						match.Groups[ 1 ].Success )
+					{
+
+						try
+						{
+							if( IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+							{
+								blendDataObj.SourceFactorRGBInline = property;
+							}
+							else
+							{
+								AvailableBlendFactor sourceAll = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), match.Groups[ 1 ].Value );
+								blendDataObj.SourceFactorRGB = sourceAll;
+							}
+							if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+							{
+								blendDataObj.DestFactorRGBInline = property;
+							}
+							else
+							{
+								AvailableBlendFactor destAll = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), match.Groups[ 2 ].Value );
+								blendDataObj.DestFactorRGB = destAll;
+							}
+
+							blendDataObj.SeparateBlendFactors = false;
+							blendDataObj.BlendModeOff = false;
+							noMatches = false;
+						}
+						catch( Exception e )
+						{
+							Debug.LogException( e );
+							blendDataObj.DataCheck = TemplateDataCheck.Invalid;
+							blendDataObj.ValidBlendMode = false;
+							return;
+						}
+						break;
+					}
+				}
+				else if( match.Groups.Count == 5 )
+				{
+					if( match.Groups[ 0 ].Success &&
+						match.Groups[ 1 ].Success )
+					{
+						try
+						{
+							if( IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+							{
+								blendDataObj.SourceFactorRGBInline = property;
+							}
+							else
+							{
+								AvailableBlendFactor sourceRGB = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), match.Groups[ 1 ].Value );
+								blendDataObj.SourceFactorRGB = sourceRGB;
+							}
+
+							if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+							{
+								blendDataObj.DestFactorRGBInline = property;
+							}
+							else
+							{
+								AvailableBlendFactor destRGB = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), match.Groups[ 2 ].Value );
+								blendDataObj.DestFactorRGB = destRGB;
+							}
+
+							if( match.Groups[ 3 ].Success && match.Groups[ 4 ].Success )
+							{
+								if( IsInlineProperty( match.Groups[ 3 ].Value, ref property ) )
+								{
+									blendDataObj.SourceFactorAlphaInline = property;
+								}
+								else
+								{
+									AvailableBlendFactor sourceA = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), match.Groups[ 3 ].Value );
+									blendDataObj.SourceFactorAlpha = sourceA;
+								}
+
+								if( IsInlineProperty( match.Groups[ 4 ].Value, ref property ) )
+								{
+									blendDataObj.DestFactorAlphaInline = property;
+								}
+								else
+								{
+									AvailableBlendFactor destA = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), match.Groups[ 4 ].Value );
+									blendDataObj.DestFactorAlpha = destA;
+								}
+
+								blendDataObj.SeparateBlendFactors = true;
+							}
+							else
+							{
+								blendDataObj.SeparateBlendFactors = false;
+							}
+							blendDataObj.BlendModeOff = false;
+							noMatches = false;
+						}
+						catch( Exception e )
+						{
+							Debug.LogException( e );
+							blendDataObj.DataCheck = TemplateDataCheck.Invalid;
+							blendDataObj.ValidBlendMode = false;
+							return;
+						}
+						break;
+					}
+				}
+			}
+
+			if( noMatches )
+				blendDataObj.ValidBlendMode = false;
+		}
+
+		public static void CreateBlendOp( string blendOpData, ref TemplateBlendData blendDataObj )
+		{
+			bool noMatches = true;
+			blendDataObj.ValidBlendOp = true;
+			string property = string.Empty;
+			// TODO: OPTIMIZE REGEX EXPRESSIONS TO NOT CATCH EMPTY GROUPS 
+			foreach( Match match in Regex.Matches( blendOpData, BlendOpPattern, RegexOptions.None ) )
+			{
+				if( match.Groups.Count == 2 )
+				{
+					if( match.Groups[ 0 ].Success &&
+						match.Groups[ 1 ].Success )
+					{
+
+						try
+						{
+							if( IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+							{
+								blendDataObj.BlendOpRGBInline = property;
+							}
+							else
+							{
+								AvailableBlendOps blendOpsAll = (AvailableBlendOps)Enum.Parse( typeof( AvailableBlendOps ), match.Groups[ 1 ].Value );
+								blendDataObj.BlendOpRGB = blendOpsAll;
+							}
+							blendDataObj.SeparateBlendOps = false;
+							noMatches = false;
+						}
+						catch( Exception e )
+						{
+							Debug.LogException( e );
+							blendDataObj.DataCheck = TemplateDataCheck.Invalid;
+							blendDataObj.ValidBlendOp = false;
+							return;
+						}
+						break;
+					}
+				}
+				else if( match.Groups.Count == 3 )
+				{
+					if( match.Groups[ 0 ].Success &&
+						match.Groups[ 1 ].Success )
+					{
+						try
+						{
+							if( IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+							{
+								blendDataObj.BlendOpRGBInline = property;
+							}
+							else
+							{
+								AvailableBlendOps blendOpsRGB = (AvailableBlendOps)Enum.Parse( typeof( AvailableBlendOps ), match.Groups[ 1 ].Value );
+								blendDataObj.BlendOpRGB = blendOpsRGB;
+							}
+
+							if( match.Groups[ 2 ].Success )
+							{
+								if( IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+								{
+									blendDataObj.BlendOpAlphaInline = property;
+								}
+								else
+								{
+									AvailableBlendOps blendOpsA = (AvailableBlendOps)Enum.Parse( typeof( AvailableBlendOps ), match.Groups[ 2 ].Value );
+									blendDataObj.BlendOpAlpha = blendOpsA;
+								}
+								blendDataObj.SeparateBlendOps = true;
+							}
+							else
+							{
+								blendDataObj.SeparateBlendOps = false;
+							}
+							noMatches = false;
+						}
+						catch( Exception e )
+						{
+							Debug.LogException( e );
+							blendDataObj.DataCheck = TemplateDataCheck.Invalid;
+							blendDataObj.ValidBlendOp = false;
+							return;
+						}
+						break;
+					}
+				}
+			}
+
+			if( noMatches )
+				blendDataObj.ValidBlendOp = false;
+		}
+
+		public static void FetchLocalVars( string body, ref List<TemplateLocalVarData> localVarList, TemplateFunctionData vertexFunction, TemplateFunctionData fragFunction )
+		{
+			foreach( Match match in Regex.Matches( body, LocalVarPattern ) )
+			{
+				if( match.Groups.Count == 4 )
+				{
+					if( CgToWirePortType.ContainsKey( match.Groups[ 2 ].Value ) )
+					{
+						MasterNodePortCategory category;
+						if( fragFunction.MainBodyLocalIdx > vertexFunction.MainBodyLocalIdx )
+						{
+							if( match.Index < fragFunction.MainBodyLocalIdx )
+							{
+								category = MasterNodePortCategory.Vertex;
+							}
+							else
+							{
+								category = MasterNodePortCategory.Fragment;
+							}
+						}
+						else
+						{
+							if( match.Index < vertexFunction.MainBodyLocalIdx )
+							{
+								category = MasterNodePortCategory.Fragment;
+							}
+							else
+							{
+								category = MasterNodePortCategory.Vertex;
+							}
+						}
+
+						if( !string.IsNullOrEmpty( match.Groups[ 1 ].Value ) && ShortcutToInfo.ContainsKey( match.Groups[ 1 ].Value ) )
+						{
+							string id = match.Groups[ 0 ].Value.Substring( 0, match.Groups[ 0 ].Value.IndexOf( "*/" ) + 2 );
+							TemplateLocalVarData data = new TemplateLocalVarData( ShortcutToInfo[ match.Groups[ 1 ].Value ], id, CgToWirePortType[ match.Groups[ 2 ].Value ], category, match.Groups[ 3 ].Value, match.Index );
+							localVarList.Add( data );
+						}
+						else
+						{
+							TemplateLocalVarData data = new TemplateLocalVarData( CgToWirePortType[ match.Groups[ 2 ].Value ], category, match.Groups[ 3 ].Value, match.Index );
+							localVarList.Add( data );
+						}
+
+					}
+				}
+			}
+		}
+
+		public static void FetchInlineVars( string body, ref TemplateIdManager idManager )
+		{
+			foreach( Match match in Regex.Matches( body, InlinePattern ) )
+			{
+				if( match.Success && match.Groups.Count == 2 )
+				{
+					string id = match.Groups[ 0 ].Value;
+					string prop = match.Groups[ 1 ].Value;
+					idManager.RegisterTag( id, prop );
+				}
+			}
+		}
+
+		public static TemplateSRPType CreateTags( ref TemplateTagsModuleData tagsObj, bool isSubShader )
+		{
+			TemplateSRPType srpType = TemplateSRPType.BuiltIn;
+			MatchCollection matchColl = Regex.Matches( tagsObj.TagsId, TagsPattern, RegexOptions.IgnorePatternWhitespace );
+			int count = matchColl.Count;
+			if( count > 0 )
+			{
+				for( int i = 0; i < count; i++ )
+				{
+					if( matchColl[ i ].Groups.Count == 3 )
+					{
+						if( isSubShader && matchColl[ i ].Groups[ 1 ].Value.Equals( "RenderPipeline" ) )
+						{
+							if( TagToRenderPipeline.ContainsKey( matchColl[ i ].Groups[ 2 ].Value ) )
+								srpType = TagToRenderPipeline[ matchColl[ i ].Groups[ 2 ].Value ];
+						}
+						tagsObj.Tags.Add( new TemplatesTagData( matchColl[ i ].Groups[ 1 ].Value, matchColl[ i ].Groups[ 2 ].Value ) );
+					}
+				}
+			}
+			return srpType;
+		}
+
+		public static void CreateZWriteMode( string zWriteData, ref TemplateDepthData depthDataObj )
+		{
+			depthDataObj.DataCheck = TemplateDataCheck.Invalid;
+			Match match = Regex.Match( zWriteData, ZWritePattern );
+			if( match.Groups.Count == 2 )
+			{
+				string property = string.Empty;
+				if( match.Groups[ 1 ].Success && IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+				{
+					depthDataObj.ZWriteInlineValue = property;
+					depthDataObj.DataCheck = TemplateDataCheck.Valid;
+					depthDataObj.ValidZWrite = true;
+				}
+				else
+				{
+					try
+					{
+						depthDataObj.ZWriteModeValue = (ZWriteMode)Enum.Parse( typeof( ZWriteMode ), match.Groups[ 1 ].Value );
+						depthDataObj.DataCheck = TemplateDataCheck.Valid;
+						depthDataObj.ValidZWrite = true;
+					}
+					catch
+					{
+						depthDataObj.DataCheck = TemplateDataCheck.Invalid;
+					}
+				}
+			}
+		}
+
+		public static void CreateZTestMode( string zTestData, ref TemplateDepthData depthDataObj )
+		{
+			depthDataObj.DataCheck = TemplateDataCheck.Invalid;
+			Match match = Regex.Match( zTestData, ZTestPattern );
+			if( match.Groups.Count == 2 )
+			{
+				string property = string.Empty;
+				if( match.Groups[ 1 ].Success && IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+				{
+					depthDataObj.ZTestInlineValue = property;
+					depthDataObj.DataCheck = TemplateDataCheck.Valid;
+					depthDataObj.ValidZTest = true;
+				}
+				else
+				{
+					try
+					{
+						depthDataObj.ZTestModeValue = (ZTestMode)Enum.Parse( typeof( ZTestMode ), match.Groups[ 1 ].Value );
+						depthDataObj.DataCheck = TemplateDataCheck.Valid;
+						depthDataObj.ValidZTest = true;
+					}
+					catch
+					{
+						depthDataObj.DataCheck = TemplateDataCheck.Invalid;
+					}
+				}
+			}
+		}
+
+		public static void CreateZOffsetMode( string zOffsetData, ref TemplateDepthData depthDataObj )
+		{
+			depthDataObj.DataCheck = TemplateDataCheck.Invalid;
+			Match match = Regex.Match( zOffsetData, ZOffsetPattern );
+			if( match.Groups.Count == 3 )
+			{
+				try
+				{
+					string property = string.Empty;
+
+					if( match.Groups[ 1 ].Success && IsInlineProperty( match.Groups[ 1 ].Value, ref property ) )
+					{
+						depthDataObj.OffsetFactorInlineValue = property;
+					}
+					else
+					{
+						depthDataObj.OffsetFactor = Convert.ToSingle( match.Groups[ 1 ].Value );
+					}
+
+					if( match.Groups[ 2 ].Success && IsInlineProperty( match.Groups[ 2 ].Value, ref property ) )
+					{
+						depthDataObj.OffsetUnitsInlineValue = property;
+					}
+					else
+					{
+						depthDataObj.OffsetUnits = Convert.ToSingle( match.Groups[ 2 ].Value );
+					}
+
+					depthDataObj.ValidOffset = true;
+					depthDataObj.DataCheck = TemplateDataCheck.Valid;
+				}
+				catch
+				{
+					depthDataObj.DataCheck = TemplateDataCheck.Invalid;
+				}
+			}
+		}
+
+		public static List<TemplateVertexData> CreateVertexDataList( string vertexData, string parametersBody )
+		{
+			List<TemplateVertexData> vertexDataList = null;
+			Dictionary<TemplateSemantics, TemplateVertexData> vertexDataDict = null;
+
+			foreach( Match match in Regex.Matches( vertexData, VertexDataPattern ) )
+			{
+				if( match.Groups.Count > 1 )
+				{
+					if( vertexDataList == null )
+					{
+						vertexDataList = new List<TemplateVertexData>();
+						vertexDataDict = new Dictionary<TemplateSemantics, TemplateVertexData>();
+					}
+
+					WirePortDataType dataType = CgToWirePortType[ match.Groups[ 1 ].Value ];
+					string varName = match.Groups[ 2 ].Value;
+					TemplateSemantics semantics = (TemplateSemantics)Enum.Parse( typeof( TemplateSemantics ), match.Groups[ 3 ].Value );
+					TemplateVertexData templateVertexData = new TemplateVertexData( semantics, dataType, varName );
+					vertexDataList.Add( templateVertexData );
+					vertexDataDict.Add( semantics, templateVertexData );
+				}
+			}
+
+			if( vertexData.Contains( Constants.InstanceIdMacro ) )
+			{
+				TemplateVertexData templateVertexData = new TemplateVertexData( TemplateSemantics.SV_InstanceID, WirePortDataType.UINT, Constants.InstanceIdVariable );
+				templateVertexData.DataInfo = TemplateInfoOnSematics.INSTANCE_ID;
+				templateVertexData.Available = true;
+				templateVertexData.ExcludeStructPrefix = true;
+
+				vertexDataList.Add( templateVertexData );
+				vertexDataDict.Add( TemplateSemantics.SV_InstanceID, templateVertexData );
+			}
+
+			if( !string.IsNullOrEmpty( parametersBody ) )
+			{
+				string[] paramsArray = parametersBody.Split( IOUtils.FIELD_SEPARATOR );
+				if( paramsArray.Length > 0 )
+				{
+					for( int i = 0; i < paramsArray.Length; i++ )
+					{
+						string[] paramDataArr = paramsArray[ i ].Split( IOUtils.VALUE_SEPARATOR );
+						if( paramDataArr.Length == 2 )
+						{
+							string[] swizzleInfoArr = paramDataArr[ 1 ].Split( IOUtils.FLOAT_SEPARATOR );
+							TemplateSemantics semantic = ShortcutToSemantic[ swizzleInfoArr[ 0 ] ];
+							if( vertexDataDict.ContainsKey( semantic ) )
+							{
+								TemplateVertexData templateVertexData = vertexDataDict[ semantic ];
+								if( templateVertexData != null )
+								{
+									if( swizzleInfoArr.Length > 1 )
+									{
+										templateVertexData.DataSwizzle = "." + swizzleInfoArr[ 1 ];
+									}
+									templateVertexData.DataInfo = ShortcutToInfo[ paramDataArr[ 0 ] ];
+									templateVertexData.Available = true;
+								}
+							}
+						}
+					}
+				}
+			}
+
+			if( vertexDataDict != null )
+			{
+				vertexDataDict.Clear();
+				vertexDataDict = null;
+			}
+
+			return vertexDataList;
+		}
+
+		public static TemplateInterpData CreateInterpDataList( string interpData, string fullLine, int maxInterpolators )
+		{
+			TemplateInterpData interpDataObj = null;
+			List<TemplateVertexData> interpDataList = null;
+			Dictionary<TemplateSemantics, TemplateVertexData> interpDataDict = null;
+			Match rangeMatch = Regex.Match( fullLine, InterpRangePattern );
+			if( rangeMatch.Groups.Count > 0 )
+			{
+				interpDataObj = new TemplateInterpData();
+				// Get range of available interpolators
+				int minVal = 0;
+				int maxVal = 0;
+				try
+				{
+					string[] minValArgs = rangeMatch.Groups[ 1 ].Value.Split( IOUtils.FLOAT_SEPARATOR );
+					minVal = Convert.ToInt32( minValArgs[ 0 ] );
+					if( string.IsNullOrEmpty( rangeMatch.Groups[ 2 ].Value ) )
+					{
+						maxVal = maxInterpolators - 1;
+						interpDataObj.DynamicMax = true;
+					}
+					else
+					{
+						maxVal = Convert.ToInt32( rangeMatch.Groups[ 2 ].Value );
+					}
+					if( minVal > maxVal )
+					{
+						//int aux = minVal;
+						//minVal = maxVal;
+						//maxVal = aux;
+						maxVal = minVal;
+					}
+
+					for( int i = minVal; i <= maxVal; i++ )
+					{
+						interpDataObj.AvailableInterpolators.Add( new TemplateInterpElement( IntToSemantic[ i ] ) );
+					}
+					if( minValArgs.Length > 1 )
+					{
+						interpDataObj.AvailableInterpolators[ 0 ].SetAvailableChannelsFromString( minValArgs[ 1 ] );
+					}
+				}
+				catch( Exception e )
+				{
+					Debug.LogException( e );
+				}
+
+				interpDataList = new List<TemplateVertexData>();
+				interpDataDict = new Dictionary<TemplateSemantics, TemplateVertexData>();
+
+				//Get Current interpolators
+				int parametersBeginIdx = fullLine.IndexOf( ":" ) + 1;
+				int parametersEnd = fullLine.IndexOf( TemplatesManager.TemplateEndOfLine );
+				string parametersBody = fullLine.Substring( parametersBeginIdx, parametersEnd - parametersBeginIdx );
+
+				foreach( Match match in Regex.Matches( interpData, VertexDataPattern ) )
+				{
+					if( match.Groups.Count > 1 )
+					{
+						WirePortDataType dataType = CgToWirePortType[ match.Groups[ 1 ].Value ];
+						string varName = match.Groups[ 2 ].Value;
+						TemplateSemantics semantics = (TemplateSemantics)Enum.Parse( typeof( TemplateSemantics ), match.Groups[ 3 ].Value );
+						TemplateVertexData templateVertexData = new TemplateVertexData( semantics, dataType, varName );
+						//interpDataList.Add( templateVertexData );
+						interpDataDict.Add( semantics, templateVertexData );
+						interpDataObj.RawInterpolators.Add( templateVertexData );
+						//Check if they are also on the free channels list and update their names
+						interpDataObj.ReplaceNameOnInterpolator( semantics, varName );
+					}
+				}
+
+				if( interpData.Contains( Constants.InstanceIdMacro ) )
+				{
+					TemplateVertexData templateInterpData = new TemplateVertexData( TemplateSemantics.SV_InstanceID, WirePortDataType.UINT, Constants.InstanceIdVariable );
+					templateInterpData.DataInfo = TemplateInfoOnSematics.INSTANCE_ID;
+					templateInterpData.Available = true;
+					templateInterpData.ExcludeStructPrefix = true;
+					interpDataList.Add( templateInterpData );
+					interpDataDict.Add( TemplateSemantics.SV_InstanceID, templateInterpData );
+				}
+
+				Dictionary<string, TemplateVertexData> auxDict = new Dictionary<string, TemplateVertexData>();
+				// Get info for available interpolators
+				string[] paramsArray = parametersBody.Split( IOUtils.FIELD_SEPARATOR );
+				if( paramsArray.Length > 0 )
+				{
+					for( int i = 0; i < paramsArray.Length; i++ )
+					{
+						string[] paramDataArr = paramsArray[ i ].Split( IOUtils.VALUE_SEPARATOR );
+						if( paramDataArr.Length == 2 )
+						{
+							string[] swizzleInfoArr = paramDataArr[ 1 ].Split( IOUtils.FLOAT_SEPARATOR );
+							TemplateSemantics semantic = ShortcutToSemantic[ swizzleInfoArr[ 0 ] ];
+							if( interpDataDict.ContainsKey( semantic ) )
+							{
+								if( interpDataDict[ semantic ] != null )
+								{
+									string[] multiComponent = paramDataArr[ 0 ].Split( IOUtils.FLOAT_SEPARATOR );
+
+									if( multiComponent.Length > 1 )
+									{
+										TemplateVertexData templateInterpData = null;
+										if( auxDict.ContainsKey( multiComponent[ 0 ] ) )
+										{
+											templateInterpData = auxDict[ multiComponent[ 0 ] ];
+										}
+										else
+										{
+											templateInterpData = new TemplateVertexData( interpDataDict[ semantic ] );
+											//if( swizzleInfoArr.Length > 1 )
+											//{
+											//	templateInterpData.DataSwizzle = "." + swizzleInfoArr[ 1 ];
+											//}
+											templateInterpData.DataInfo = ShortcutToInfo[ multiComponent[ 0 ] ];
+											templateInterpData.Available = true;
+											interpDataList.Add( templateInterpData );
+											auxDict.Add( multiComponent[ 0 ], templateInterpData );
+										}
+
+										if( swizzleInfoArr[ 1 ].Length == multiComponent[ 1 ].Length )
+										{
+											for( int channelIdx = 0; channelIdx < swizzleInfoArr[ 1 ].Length; channelIdx++ )
+											{
+												templateInterpData.RegisterComponent( multiComponent[ 1 ][ channelIdx ], interpDataDict[ semantic ].VarName + "." + swizzleInfoArr[ 1 ][ channelIdx ] );
+											}
+										}
+									}
+									else
+									{
+										TemplateVertexData templateInterpData = new TemplateVertexData( interpDataDict[ semantic ] );
+										if( swizzleInfoArr.Length > 1 )
+										{
+											templateInterpData.DataSwizzle = "." + swizzleInfoArr[ 1 ];
+										}
+										templateInterpData.DataInfo = ShortcutToInfo[ paramDataArr[ 0 ] ];
+										templateInterpData.Available = true;
+										interpDataList.Add( templateInterpData );
+									}
+								}
+							}
+						}
+					}
+				}
+
+				/*TODO: 
+				1) Remove interpDataList.Add( templateVertexData ); from initial foreach 
+				2) When looping though each foreach array element, create a new TemplateVertexData
+				from the one containted on the interpDataDict and add it to interpDataList
+				*/
+				for( int i = 0; i < interpDataList.Count; i++ )
+				{
+					interpDataList[ i ].BuildVar();
+				}
+
+				auxDict.Clear();
+				auxDict = null;
+
+				interpDataObj.Interpolators = interpDataList;
+				interpDataDict.Clear();
+				interpDataDict = null;
+			}
+			return interpDataObj;
+		}
+
+		public static void FetchDependencies( TemplateInfoContainer dependencies, ref string body )
+		{
+			int index = body.IndexOf( TemplatesManager.TemplateDependenciesListTag );
+			if( index > 0 )
+			{
+				dependencies.Index = index;
+				dependencies.Id = TemplatesManager.TemplateDependenciesListTag;
+				dependencies.Data = TemplatesManager.TemplateDependenciesListTag;
+			}
+			else
+			{
+				int lastIndex = body.LastIndexOf( '}' );
+				if( lastIndex > 0 )
+				{
+					body = body.Insert( lastIndex, "\t" + TemplatesManager.TemplateDependenciesListTag + "\n" );
+					FetchDependencies( dependencies, ref body );
+				}
+			}
+		}
+
+		public static void FetchCustomInspector( TemplateInfoContainer inspectorContainer, ref string body )
+		{
+			Match match = Regex.Match( body, CustomInspectorPattern, RegexOptions.Multiline );
+			if( match != null && match.Groups.Count > 1 )
+			{
+				inspectorContainer.Index = match.Index;
+				inspectorContainer.Id = match.Groups[ 0 ].Value;
+				inspectorContainer.Data = match.Groups[ 1 ].Value;
+
+#if UNITY_2019_3_OR_NEWER
+				if( ASEPackageManagerHelper.CurrentHDVersion > ASESRPVersions.ASE_SRP_6_9_1 )
+				{
+					if( inspectorContainer.Data.Equals( "UnityEditor.Experimental.Rendering.HDPipeline.HDLitGUI" ) )
+						inspectorContainer.Data = "UnityEditor.Rendering.HighDefinition.HDLitGUI";
+				}
+#endif
+			}
+			else
+			{
+				int index = body.LastIndexOf( '}' );
+				if( index > 0 )
+				{
+					body = body.Insert( index, string.Format( "\tCustomEditor \"{0}\"\n", Constants.DefaultCustomInspector ) );
+					FetchCustomInspector( inspectorContainer, ref body );
+				}
+			}
+		}
+
+		public static void FetchFallback( TemplateInfoContainer fallbackContainer, ref string body )
+		{
+			Match match = Regex.Match( body, FallbackPattern, RegexOptions.Multiline | RegexOptions.IgnoreCase );
+			if( match != null && match.Groups.Count > 1 )
+			{
+				fallbackContainer.Index = match.Index;
+				fallbackContainer.Id = match.Groups[ 0 ].Value;
+				fallbackContainer.Data = match.Groups[ 1 ].Value;
+			}
+			else
+			{
+				int index = body.LastIndexOf( '}' );
+				if( index > 0 )
+				{
+					body = body.Insert( index, "\tFallback \"\"\n" );
+					FetchFallback( fallbackContainer, ref body );
+				}
+			}
+		}
+
+		public static string AutoSwizzleData( string dataVar, WirePortDataType from, WirePortDataType to, bool isPosition )
+		{
+			switch( from )
+			{
+				case WirePortDataType.COLOR:
+				case WirePortDataType.FLOAT4:
+					{
+						switch( to )
+						{
+							case WirePortDataType.FLOAT3: dataVar += ".xyz"; break;
+							case WirePortDataType.FLOAT2: dataVar += ".xy"; break;
+							case WirePortDataType.INT:
+							case WirePortDataType.FLOAT: dataVar += ".x"; break;
+						}
+					}
+					break;
+				case WirePortDataType.FLOAT3:
+					{
+						switch( to )
+						{
+							case WirePortDataType.FLOAT4: dataVar = string.Format( "float4({0},{1})", dataVar,(isPosition?1:0) ); break;
+							case WirePortDataType.FLOAT2: dataVar += ".xy"; break;
+							case WirePortDataType.INT:
+							case WirePortDataType.FLOAT: dataVar += ".x"; break;
+						}
+					}
+					break;
+				case WirePortDataType.FLOAT2:
+					{
+						switch( to )
+						{
+							case WirePortDataType.FLOAT4: dataVar = string.Format( "float4({0},0,{1})", dataVar , (isPosition ? 1 : 0) ); break;
+							case WirePortDataType.FLOAT3: dataVar = string.Format( "float3({0},0)", dataVar ); break;
+							case WirePortDataType.INT:
+							case WirePortDataType.FLOAT: dataVar += ".x"; break;
+						}
+					}
+					break;
+				case WirePortDataType.FLOAT:
+					{
+						switch( to )
+						{
+							case WirePortDataType.FLOAT4: dataVar = string.Format( "float4({0},0,0,{1})", dataVar, ( isPosition ? 1 : 0 ) ); break;
+							case WirePortDataType.FLOAT3: dataVar = string.Format( "float3({0},0,0)", dataVar ); break;
+							case WirePortDataType.FLOAT2: dataVar = string.Format( "float2({0},0)", dataVar ); break;
+						}
+					}
+					break;
+			}
+			return dataVar;
+		}
+
+		public static bool CheckIfTemplate( string assetPath )
+		{
+			Type type = AssetDatabase.GetMainAssetTypeAtPath( assetPath );
+			if( type == typeof( Shader ) )
+			{
+				Shader shader = AssetDatabase.LoadAssetAtPath<Shader>( assetPath );
+				if( shader != null )
+				{
+					string body = IOUtils.LoadTextFileFromDisk( assetPath );
+					return ( body.IndexOf( TemplatesManager.TemplateShaderNameBeginTag ) > -1 );
+				}
+			}
+			return false;
+		}
+
+		public static bool CheckIfCompatibles( WirePortDataType first, WirePortDataType second )
+		{
+			switch( first )
+			{
+				case WirePortDataType.OBJECT:
+				return true;
+				case WirePortDataType.FLOAT:
+				case WirePortDataType.FLOAT2:
+				case WirePortDataType.FLOAT3:
+				case WirePortDataType.FLOAT4:
+				case WirePortDataType.COLOR:
+				case WirePortDataType.INT:
+					{
+						switch( second )
+						{
+							case WirePortDataType.FLOAT3x3:
+							case WirePortDataType.FLOAT4x4:
+							case WirePortDataType.SAMPLER1D:
+							case WirePortDataType.SAMPLER2D:
+							case WirePortDataType.SAMPLER3D:
+							case WirePortDataType.SAMPLERCUBE:
+							return false;
+						}
+					}
+					break;
+				case WirePortDataType.FLOAT3x3:
+				case WirePortDataType.FLOAT4x4:
+					{
+						switch( second )
+						{
+							case WirePortDataType.FLOAT:
+							case WirePortDataType.FLOAT2:
+							case WirePortDataType.FLOAT3:
+							case WirePortDataType.FLOAT4:
+							case WirePortDataType.COLOR:
+							case WirePortDataType.INT:
+							case WirePortDataType.SAMPLER1D:
+							case WirePortDataType.SAMPLER2D:
+							case WirePortDataType.SAMPLER3D:
+							case WirePortDataType.SAMPLERCUBE:
+							return false;
+						}
+					}
+					break;
+				case WirePortDataType.SAMPLER1D:
+				case WirePortDataType.SAMPLER2D:
+				case WirePortDataType.SAMPLER3D:
+				case WirePortDataType.SAMPLERCUBE:
+					{
+						switch( second )
+						{
+							case WirePortDataType.FLOAT:
+							case WirePortDataType.FLOAT2:
+							case WirePortDataType.FLOAT3:
+							case WirePortDataType.FLOAT4:
+							case WirePortDataType.FLOAT3x3:
+							case WirePortDataType.FLOAT4x4:
+							case WirePortDataType.COLOR:
+							case WirePortDataType.INT:
+							return false;
+						}
+					}
+					break;
+			}
+			return true;
+		}
+		// Lightweight <-> Default functions
+		public static string WorldSpaceViewDir( MasterNodeDataCollector dataCollector, string worldPosVec3, bool normalize )
+		{
+			string value = string.Empty;
+			if( dataCollector.IsTemplate && dataCollector.IsSRP )
+			{
+				value = string.Format( "_WorldSpaceCameraPos.xyz - {0}", worldPosVec3 );
+			}
+			else
+			{
+				value = string.Format( "UnityWorldSpaceViewDir( {0} )", worldPosVec3 );
+			}
+
+			if( normalize )
+			{
+				value = SafeNormalize( dataCollector, value );
+			}
+
+			return value;
+		}
+
+		public static string SafeNormalize( MasterNodeDataCollector dataCollector, string value )
+		{
+			if( dataCollector.IsTemplate && dataCollector.IsSRP )
+			{
+				value = string.Format( "SafeNormalize( {0} )", value );
+			}
+			else
+			{
+				dataCollector.AddToIncludes( -1, Constants.UnityBRDFLib );
+				value = string.Format( "Unity_SafeNormalize( {0} )", value );
+			}
+			return value;
+		}
+
+
+		public static string CreateUnpackNormalStr( MasterNodeDataCollector dataCollector, bool applyScale, string scale )
+		{
+			string funcName;
+			if( dataCollector.IsTemplate && dataCollector.IsSRP )
+			{
+				if( dataCollector.TemplateDataCollectorInstance.IsHDRP )
+				{
+					funcName = "UnpackNormalmapRGorAG( {0}, " + scale + " )";
+				}
+				else
+				{
+					funcName = "UnpackNormalScale( {0}, " + scale + " )";
+				}
+			}
+			else
+			{
+				funcName = applyScale ? "UnpackScaleNormal( {0}, " + scale + " )" : "UnpackNormal( {0} )";
+			}
+			return funcName;
+		}
+
+		public static bool IsInlineProperty( string data, ref string property )
+		{
+			if( data.Length > 0 && data[ 0 ] == '[' && data[ data.Length - 1 ] == ']' )
+			{
+				property = data.Substring( 1, data.Length - 2 );
+				return true;
+			}
+			return false;
+		}
+
+	//	public static readonly string FetchDefaultDepthFormat = "UNITY_SAMPLE_DEPTH(tex2Dproj(_CameraDepthTexture,UNITY_PROJ_COORD( {0} )))";
+		public static readonly string FetchDefaultDepthFormat = "SAMPLE_DEPTH_TEXTURE( _CameraDepthTexture, {0}.xy )";
+		public static readonly string FetchDefaultDepthFormatVertex = "SAMPLE_DEPTH_TEXTURE_LOD( _CameraDepthTexture, float4( {0}.xy, 0, 0 ) )";
+
+		public static readonly string FetchLWDepthFormat = "SHADERGRAPH_SAMPLE_SCENE_DEPTH( {0}.xy )";
+		public static readonly string FetchLWDepthFormatVertex = "SHADERGRAPH_SAMPLE_SCENE_DEPTH_LOD( {0}.xy )";
+#if UNITY_2018_3_OR_NEWER
+		public static readonly string FetchHDDepthFormat = "SampleCameraDepth( {0}.xy )";
+#else
+		public static readonly string FetchHDDepthFormat = "SAMPLE_TEXTURE2D( _CameraDepthTexture, s_point_clamp_sampler, {0}.xy ).r";
+#endif
+		public static string CreateDepthFetch( MasterNodeDataCollector dataCollector, string screenPos )
+		{
+			string screenDepthInstruction = string.Empty;
+			if( dataCollector.IsTemplate && dataCollector.IsSRP )
+			{
+				if( dataCollector.TemplateDataCollectorInstance.CurrentSRPType == TemplateSRPType.Lightweight )
+				{
+					if( dataCollector.PortCategory == MasterNodePortCategory.Vertex )
+					{
+						string m_functionBody = string.Empty;
+						GenerateLW( ref m_functionBody );
+						dataCollector.AddFunctions( FetchLWDepthFormatVertex, m_functionBody, "0" );
+						screenDepthInstruction = string.Format( FetchLWDepthFormatVertex, screenPos );
+					}
+					else
+						screenDepthInstruction = string.Format( FetchLWDepthFormat, screenPos );
+				}
+				else if( dataCollector.TemplateDataCollectorInstance.CurrentSRPType == TemplateSRPType.HD )
+					screenDepthInstruction = string.Format( FetchHDDepthFormat, screenPos );
+			}
+			else
+			{
+				if( dataCollector.PortCategory == MasterNodePortCategory.Vertex )
+					screenDepthInstruction = string.Format( FetchDefaultDepthFormatVertex, screenPos );
+				else
+					screenDepthInstruction = string.Format( FetchDefaultDepthFormat, screenPos );
+			}
+			return screenDepthInstruction;
+		}
+
+		public static void GenerateLW( ref string body )
+		{
+			body = string.Empty;
+			IOUtils.AddFunctionHeader( ref body, "float SHADERGRAPH_SAMPLE_SCENE_DEPTH_LOD(float2 uv)" );
+			IOUtils.AddFunctionLine( ref body, "#if defined(REQUIRE_DEPTH_TEXTURE)" );
+			IOUtils.AddFunctionLine( ref body, "#if defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)" );
+			IOUtils.AddFunctionLine( ref body, " \tfloat rawDepth = SAMPLE_TEXTURE2D_ARRAY_LOD(_CameraDepthTexture, sampler_CameraDepthTexture, uv, unity_StereoEyeIndex, 0).r;" );
+			IOUtils.AddFunctionLine( ref body, "#else" );
+			IOUtils.AddFunctionLine( ref body, " \tfloat rawDepth = SAMPLE_DEPTH_TEXTURE_LOD(_CameraDepthTexture, sampler_CameraDepthTexture, uv, 0);" );
+			IOUtils.AddFunctionLine( ref body, "#endif" );
+			IOUtils.AddFunctionLine( ref body, "return rawDepth;" );
+			IOUtils.AddFunctionLine( ref body, "#endif // REQUIRE_DEPTH_TEXTURE" );
+			IOUtils.AddFunctionLine( ref body, "return 0;" );
+			IOUtils.CloseFunctionBody( ref body );
+		}
+
+		public static bool GetShaderModelForInterpolatorAmount( int interpAmount, ref string shaderModel )
+		{
+			for( int i = 0; i < AvailableShaderModels.Length; i++ )
+			{
+				if( AvailableInterpolators[ AvailableShaderModels[ i ] ] >= interpAmount )
+				{
+					shaderModel = AvailableShaderModels[ i ];
+					return true;
+				}
+			}
+			return false;
+		}
+
+		public static string GetSubShaderFrom( string shaderBody )
+		{
+			Match match = Regex.Match( shaderBody, FetchSubShaderBody, RegexOptions.Singleline );
+			if( match.Success && match.Groups.Count > 1 )
+			{
+				return match.Groups[ 1 ].Value;
+			}
+
+			return string.Empty;
+		}
+	}
+}