summaryrefslogtreecommitdiff
path: root/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateData.cs
diff options
context:
space:
mode:
Diffstat (limited to 'Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateData.cs')
-rw-r--r--Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateData.cs1178
1 files changed, 1178 insertions, 0 deletions
diff --git a/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateData.cs b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateData.cs
new file mode 100644
index 00000000..f3c7b895
--- /dev/null
+++ b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateData.cs
@@ -0,0 +1,1178 @@
+// Amplify Shader Editor - Visual Shader Editing Tool
+// Copyright (c) Amplify Creations, Lda <info@amplify.pt>
+
+// THIS FILE IS DEPRECATED AND SHOULD NOT BE USED
+
+using System;
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace AmplifyShaderEditor
+{
+ [Serializable]
+ public class TemplateDataContainer
+ {
+ public int UNITY_VERSION = -1;
+ public TemplateData TemplateDataRef;
+ }
+
+ [Serializable]
+ public class VertexDataContainer
+ {
+ [SerializeField]
+ private List<TemplateVertexData> m_vertexData;
+
+ [SerializeField]
+ private string m_vertexDataId = string.Empty;
+
+ [SerializeField]
+ private int m_vertexDataStartIdx = -1;
+
+ public void Reload()
+ {
+ if( m_vertexData != null )
+ {
+ m_vertexData.Clear();
+ }
+ }
+
+ public void Destroy()
+ {
+ if( m_vertexData != null )
+ {
+ m_vertexData.Clear();
+ m_vertexData = null;
+ }
+ }
+
+
+ public List<TemplateVertexData> VertexData { get { return m_vertexData; } set { m_vertexData = value; } }
+ public string VertexDataId { get { return m_vertexDataId; } set { m_vertexDataId = value; } }
+ public int VertexDataStartIdx { get { return m_vertexDataStartIdx; } set { m_vertexDataStartIdx = value; } }
+ }
+
+ [Serializable]
+ public sealed class TemplateData : TemplateDataParent
+ {
+ [SerializeField]
+ private string m_templateBody = string.Empty;
+
+ [SerializeField]
+ private string m_shaderNameId = string.Empty;
+
+ [SerializeField]
+ private List<TemplateProperty> m_propertyList = new List<TemplateProperty>();
+ private Dictionary<string, TemplateProperty> m_propertyDict = new Dictionary<string, TemplateProperty>();
+
+ [SerializeField]
+ private List<TemplateInputData> m_inputDataList = new List<TemplateInputData>();
+ private Dictionary<int, TemplateInputData> m_inputDataDict = new Dictionary<int, TemplateInputData>();
+
+ //[SerializeField]
+ //private List<TemplateCodeSnippetBase> m_snippetElementsList = new List<TemplateCodeSnippetBase>();
+ //private Dictionary<string, TemplateCodeSnippetBase> m_snippetElementsDict = new Dictionary<string, TemplateCodeSnippetBase>();
+
+ [SerializeField]
+ private List<TemplateLocalVarData> m_localVarsList = new List<TemplateLocalVarData>();
+
+ [SerializeField]
+ private VertexDataContainer m_vertexDataContainer = new VertexDataContainer();
+
+ [SerializeField]
+ private TemplateInterpData m_interpolatorDataContainer;
+
+ [SerializeField]
+ private List<TemplateShaderPropertyData> m_availableShaderProperties = new List<TemplateShaderPropertyData>();
+
+ [SerializeField]
+ private TemplateFunctionData m_vertexFunctionData;
+
+ [SerializeField]
+ private TemplateFunctionData m_fragmentFunctionData;
+
+ [SerializeField]
+ private TemplateBlendData m_blendData = new TemplateBlendData();
+
+ [SerializeField]
+ private TemplateCullModeData m_cullModeData = new TemplateCullModeData();
+
+ [SerializeField]
+ private TemplateColorMaskData m_colorMaskData = new TemplateColorMaskData();
+
+ [SerializeField]
+ private TemplateStencilData m_stencilData = new TemplateStencilData();
+
+ [SerializeField]
+ private TemplateDepthData m_depthData = new TemplateDepthData();
+
+ [SerializeField]
+ private TemplateTagsModuleData m_tagData = new TemplateTagsModuleData();
+
+ public TemplateData()
+ {
+ m_templateType = TemplateDataType.LegacySinglePass;
+ }
+
+ public TemplateData( string name )
+ {
+ m_templateType = TemplateDataType.LegacySinglePass;
+ Name = name;
+ }
+
+ public TemplateData( string name, string guid )
+ {
+ m_templateType = TemplateDataType.LegacySinglePass;
+ m_communityTemplate = false;
+ if( !string.IsNullOrEmpty( guid ) )
+ {
+ string datapath = AssetDatabase.GUIDToAssetPath( guid );
+ if( string.IsNullOrEmpty( datapath ) )
+ {
+ m_isValid = false;
+ return;
+ }
+
+ string body = string.Empty;
+ try
+ {
+ body = IOUtils.LoadTextFileFromDisk( datapath );
+ }
+ catch( Exception e )
+ {
+ Debug.LogException( e );
+ m_isValid = false;
+ return;
+ }
+
+ if( !string.IsNullOrEmpty( body ) )
+ {
+ LoadTemplateBody( body );
+ Name = string.IsNullOrEmpty( name ) ? m_defaultShaderName : name;
+ m_guid = guid;
+ }
+ }
+ }
+
+ public TemplateData( string name, string guid, string body )
+ {
+ m_templateType = TemplateDataType.LegacySinglePass;
+ m_communityTemplate = true;
+ if( !string.IsNullOrEmpty( body ) )
+ {
+ LoadTemplateBody( body );
+ Name = string.IsNullOrEmpty( name ) ? m_defaultShaderName : name;
+ m_guid = guid;
+ }
+ }
+
+ public override bool Reload()
+ {
+ if( m_vertexDataContainer != null )
+ {
+ m_vertexDataContainer.Reload();
+ }
+
+ if( m_interpolatorDataContainer != null )
+ {
+ m_interpolatorDataContainer.Destroy();
+ }
+
+ if( m_availableShaderProperties != null )
+ {
+ m_availableShaderProperties.Clear();
+ }
+
+ if( m_propertyDict != null )
+ {
+ m_propertyDict.Clear();
+ }
+
+ if( m_propertyList != null )
+ {
+ m_propertyList.Clear();
+ }
+
+ if( m_inputDataDict != null )
+ {
+ m_inputDataDict.Clear();
+ }
+
+ if( m_inputDataList != null )
+ {
+ m_inputDataList.Clear();
+ }
+
+ if( m_localVarsList != null )
+ {
+ m_localVarsList.Clear();
+ }
+
+ //if( m_snippetElementsDict != null )
+ //{
+ // m_snippetElementsDict.Clear();
+ //}
+
+ //if( m_snippetElementsList != null )
+ //{
+ // for( int i = 0; i < m_snippetElementsList.Count; i++ )
+ // {
+ // GameObject.DestroyImmediate( m_snippetElementsList[ i ] );
+ // m_snippetElementsList[ i ] = null;
+ // }
+ // m_snippetElementsList.Clear();
+ //}
+
+ string datapath = AssetDatabase.GUIDToAssetPath( m_guid );
+ string body = string.Empty;
+ try
+ {
+ body = IOUtils.LoadTextFileFromDisk( datapath );
+ body = body.Replace( "\r\n", "\n" );
+ }
+ catch( Exception e )
+ {
+ Debug.LogException( e );
+ m_isValid = false;
+ }
+ LoadTemplateBody( body );
+ if( m_communityTemplate )
+ {
+ Name = m_defaultShaderName;
+ }
+ return true;
+ }
+
+ void LoadTemplateBody( string body )
+ {
+
+ m_templateBody = body.Replace( "\r\n", "\n" ); ;
+
+ if( m_templateBody.IndexOf( TemplatesManager.TemplateShaderNameBeginTag ) < 0 )
+ {
+ m_isValid = false;
+ return;
+ }
+
+ //Fetching common tags
+ FetchCommonTags();
+
+ //Fetch function code areas
+ FetchCodeAreas( TemplatesManager.TemplateVertexCodeBeginArea, MasterNodePortCategory.Vertex );
+ FetchCodeAreas( TemplatesManager.TemplateFragmentCodeBeginArea, MasterNodePortCategory.Fragment );
+
+ //Fetching inputs
+ FetchInputs( MasterNodePortCategory.Fragment );
+ FetchInputs( MasterNodePortCategory.Vertex );
+
+
+ //Fetch local variables must be done after fetching code areas as it needs them to see is variable is on vertex or fragment
+ TemplateHelperFunctions.FetchLocalVars( m_templateBody, ref m_localVarsList, m_vertexFunctionData, m_fragmentFunctionData );
+
+ //Fetch snippets
+ }
+
+ void FetchSubShaderProperties()
+ {
+ Match match = Regex.Match( m_templateBody, @"Pass\s*{" );
+ if( match.Groups.Count == 0 )
+ {
+ return;
+ }
+
+ int beginSubShader = m_templateBody.IndexOf( "SubShader" );
+ int endSubShader = match.Groups[ 0 ].Index;
+ if( beginSubShader > 0 && endSubShader > 0 && endSubShader > beginSubShader )
+ {
+ // ADD A PLACE TO INSERT GRAB PASSES
+ int passIndex = m_templateBody.IndexOf( TemplatesManager.TemplatePassTag );
+ if( passIndex < 0 )
+ {
+ int currIdx = endSubShader - 1;
+ string identation = string.Empty;
+ for( ; currIdx > 0; currIdx-- )
+ {
+ if( m_templateBody[ currIdx ] != '\n' )
+ {
+ identation = m_templateBody[ currIdx ] + identation;
+ }
+ else
+ {
+ identation = m_templateBody[ currIdx ] + identation;
+ break;
+ }
+ }
+ if( currIdx > 0 )
+ {
+ m_templateBody = m_templateBody.Insert( currIdx, identation + TemplatesManager.TemplatePassTag );
+ }
+ }
+
+ // GET ALL THE MODULES
+ string subBody = m_templateBody.Substring( beginSubShader, endSubShader - beginSubShader );
+ //CULL MODE
+ {
+ int cullIdx = subBody.IndexOf( "Cull" );
+ if( cullIdx > 0 )
+ {
+ int end = subBody.IndexOf( TemplatesManager.TemplateNewLine, cullIdx );
+ string cullParams = subBody.Substring( cullIdx, end - cullIdx );
+ m_cullModeData.CullModeId = cullParams;
+ TemplateHelperFunctions.CreateCullMode( cullParams, ref m_cullModeData );
+ if( m_cullModeData.DataCheck == TemplateDataCheck.Valid )
+ AddId( cullParams, false, string.Empty );
+ }
+ }
+ //COLOR MASK
+ {
+ int colorMaskIdx = subBody.IndexOf( "ColorMask" );
+ if( colorMaskIdx > 0 )
+ {
+ int end = subBody.IndexOf( TemplatesManager.TemplateNewLine, colorMaskIdx );
+ string colorMaskParams = subBody.Substring( colorMaskIdx, end - colorMaskIdx );
+ m_colorMaskData.ColorMaskId = colorMaskParams;
+ TemplateHelperFunctions.CreateColorMask( colorMaskParams, ref m_colorMaskData );
+ if( m_colorMaskData.DataCheck == TemplateDataCheck.Valid )
+ AddId( colorMaskParams, false );
+ }
+ }
+ //BlEND MODE
+ {
+ int blendModeIdx = subBody.IndexOf( "Blend" );
+ if( blendModeIdx > 0 )
+ {
+ int end = subBody.IndexOf( TemplatesManager.TemplateNewLine, blendModeIdx );
+ string blendParams = subBody.Substring( blendModeIdx, end - blendModeIdx );
+ m_blendData.BlendModeId = blendParams;
+ TemplateHelperFunctions.CreateBlendMode( blendParams, ref m_blendData );
+ if( m_blendData.ValidBlendMode )
+ {
+ AddId( blendParams, false );
+ }
+ }
+ }
+ //BLEND OP
+ {
+ int blendOpIdx = subBody.IndexOf( "BlendOp" );
+ if( blendOpIdx > 0 )
+ {
+ int end = subBody.IndexOf( TemplatesManager.TemplateNewLine, blendOpIdx );
+ string blendOpParams = subBody.Substring( blendOpIdx, end - blendOpIdx );
+ BlendData.BlendOpId = blendOpParams;
+ TemplateHelperFunctions.CreateBlendOp( blendOpParams, ref m_blendData );
+ if( m_blendData.ValidBlendOp )
+ {
+ AddId( blendOpParams, false );
+ }
+ }
+
+ m_blendData.DataCheck = ( m_blendData.ValidBlendMode || m_blendData.ValidBlendOp ) ? TemplateDataCheck.Valid : TemplateDataCheck.Invalid;
+ }
+
+ //STENCIL
+ {
+ int stencilIdx = subBody.IndexOf( "Stencil" );
+ if( stencilIdx > -1 )
+ {
+ int stencilEndIdx = subBody.IndexOf( "}", stencilIdx );
+ if( stencilEndIdx > 0 )
+ {
+ string stencilParams = subBody.Substring( stencilIdx, stencilEndIdx + 1 - stencilIdx );
+ m_stencilData.StencilBufferId = stencilParams;
+ TemplateHelperFunctions.CreateStencilOps( stencilParams, ref m_stencilData );
+ if( m_stencilData.DataCheck == TemplateDataCheck.Valid )
+ {
+ AddId( stencilParams, true );
+ }
+ }
+ }
+ }
+
+ //ZWRITE
+ {
+ int zWriteOpIdx = subBody.IndexOf( "ZWrite" );
+ if( zWriteOpIdx > -1 )
+ {
+ int zWriteEndIdx = subBody.IndexOf( TemplatesManager.TemplateNewLine, zWriteOpIdx );
+ if( zWriteEndIdx > 0 )
+ {
+ m_depthData.ZWriteModeId = subBody.Substring( zWriteOpIdx, zWriteEndIdx + 1 - zWriteOpIdx );
+ TemplateHelperFunctions.CreateZWriteMode( m_depthData.ZWriteModeId, ref m_depthData );
+ if( m_depthData.DataCheck == TemplateDataCheck.Valid )
+ {
+ AddId( m_depthData.ZWriteModeId, true );
+ }
+ }
+ }
+ }
+
+ //ZTEST
+ {
+ int zTestOpIdx = subBody.IndexOf( "ZTest" );
+ if( zTestOpIdx > -1 )
+ {
+ int zTestEndIdx = subBody.IndexOf( TemplatesManager.TemplateNewLine, zTestOpIdx );
+ if( zTestEndIdx > 0 )
+ {
+ m_depthData.ZTestModeId = subBody.Substring( zTestOpIdx, zTestEndIdx + 1 - zTestOpIdx );
+ TemplateHelperFunctions.CreateZTestMode( m_depthData.ZTestModeId, ref m_depthData );
+ if( m_depthData.DataCheck == TemplateDataCheck.Valid )
+ {
+ AddId( m_depthData.ZTestModeId, true );
+ }
+ }
+ }
+ }
+
+ //ZOFFSET
+ {
+ int zOffsetIdx = subBody.IndexOf( "Offset" );
+ if( zOffsetIdx > -1 )
+ {
+ int zOffsetEndIdx = subBody.IndexOf( TemplatesManager.TemplateNewLine, zOffsetIdx );
+ if( zOffsetEndIdx > 0 )
+ {
+ m_depthData.OffsetId = subBody.Substring( zOffsetIdx, zOffsetEndIdx + 1 - zOffsetIdx );
+ TemplateHelperFunctions.CreateZOffsetMode( m_depthData.OffsetId, ref m_depthData );
+ if( m_depthData.DataCheck == TemplateDataCheck.Valid )
+ {
+ AddId( m_depthData.OffsetId, true );
+ }
+ }
+ }
+
+ m_depthData.SetDataCheck();
+ }
+
+ //TAGS
+ {
+ int tagsIdx = subBody.IndexOf( "Tags" );
+ if( tagsIdx > -1 )
+ {
+ int tagsEndIdx = subBody.IndexOf( "}", tagsIdx );
+ if( tagsEndIdx > -1 )
+ {
+ m_tagData.Reset();
+ m_tagData.TagsId = subBody.Substring( tagsIdx, tagsEndIdx + 1 - tagsIdx );
+ TemplateHelperFunctions.CreateTags( ref m_tagData, true );
+ m_tagData.DataCheck = TemplateDataCheck.Valid;
+ AddId( m_tagData.TagsId, false );
+ }
+ else
+ {
+ m_tagData.DataCheck = TemplateDataCheck.Invalid;
+ }
+ }
+ else
+ {
+ m_tagData.DataCheck = TemplateDataCheck.Invalid;
+ }
+ }
+ }
+ }
+
+ void FetchCommonTags()
+ {
+ // Name
+ try
+ {
+ int nameBegin = m_templateBody.IndexOf( TemplatesManager.TemplateShaderNameBeginTag );
+ if( nameBegin < 0 )
+ {
+ // Not a template
+ return;
+ }
+
+ int nameEnd = m_templateBody.IndexOf( TemplatesManager.TemplateFullEndTag, nameBegin );
+ int defaultBegin = nameBegin + TemplatesManager.TemplateShaderNameBeginTag.Length;
+ int defaultLength = nameEnd - defaultBegin;
+ m_defaultShaderName = m_templateBody.Substring( defaultBegin, defaultLength );
+ int[] nameIdx = m_defaultShaderName.AllIndexesOf( "\"" );
+ nameIdx[ 0 ] += 1; // Ignore the " character from the string
+ m_defaultShaderName = m_defaultShaderName.Substring( nameIdx[ 0 ], nameIdx[ 1 ] - nameIdx[ 0 ] );
+ m_shaderNameId = m_templateBody.Substring( nameBegin, nameEnd + TemplatesManager.TemplateFullEndTag.Length - nameBegin );
+ AddId( m_shaderNameId, false );
+
+ }
+ catch( Exception e )
+ {
+ Debug.LogException( e );
+ m_isValid = false;
+ }
+
+ FetchSubShaderProperties();
+ // Vertex Data
+ {
+ int vertexDataTagBegin = m_templateBody.IndexOf( TemplatesManager.TemplateVertexDataTag );
+ if( vertexDataTagBegin > -1 )
+ {
+ m_vertexDataContainer.VertexDataStartIdx = vertexDataTagBegin;
+ int vertexDataTagEnd = m_templateBody.IndexOf( TemplatesManager.TemplateEndOfLine, vertexDataTagBegin );
+ m_vertexDataContainer.VertexDataId = m_templateBody.Substring( vertexDataTagBegin, vertexDataTagEnd + TemplatesManager.TemplateEndOfLine.Length - vertexDataTagBegin );
+ int dataBeginIdx = m_templateBody.LastIndexOf( '{', vertexDataTagBegin, vertexDataTagBegin );
+ string vertexData = m_templateBody.Substring( dataBeginIdx + 1, vertexDataTagBegin - dataBeginIdx );
+
+ int parametersBegin = vertexDataTagBegin + TemplatesManager.TemplateVertexDataTag.Length;
+ string parameters = m_templateBody.Substring( parametersBegin, vertexDataTagEnd - parametersBegin );
+ m_vertexDataContainer.VertexData = TemplateHelperFunctions.CreateVertexDataList( vertexData, parameters );
+ AddId( m_vertexDataContainer.VertexDataId );
+ }
+ }
+
+ // Available interpolators
+ try
+ {
+ int interpDataBegin = m_templateBody.IndexOf( TemplatesManager.TemplateInterpolatorBeginTag );
+ if( interpDataBegin > -1 )
+ {
+ int interpDataEnd = m_templateBody.IndexOf( TemplatesManager.TemplateEndOfLine, interpDataBegin );
+ string interpDataId = m_templateBody.Substring( interpDataBegin, interpDataEnd + TemplatesManager.TemplateEndOfLine.Length - interpDataBegin );
+
+ int dataBeginIdx = m_templateBody.LastIndexOf( '{', interpDataBegin, interpDataBegin );
+ string interpData = m_templateBody.Substring( dataBeginIdx + 1, interpDataBegin - dataBeginIdx );
+
+ m_interpolatorDataContainer = TemplateHelperFunctions.CreateInterpDataList( interpData, interpDataId, 8 );
+ m_interpolatorDataContainer.InterpDataId = interpDataId;
+ m_interpolatorDataContainer.InterpDataStartIdx = interpDataBegin;
+ AddId( interpDataId );
+ }
+ }
+ catch( Exception e )
+ {
+ Debug.LogException( e );
+ m_isValid = false;
+ }
+
+
+ try
+ {
+ Dictionary<string, TemplateShaderPropertyData> duplicatesHelper = new Dictionary<string, TemplateShaderPropertyData>();
+ m_availableShaderProperties = new List<TemplateShaderPropertyData>();
+
+ // Common Tags
+ for( int i = 0; i < TemplatesManager.CommonTags.Length; i++ )
+ {
+ int idx = m_templateBody.IndexOf( TemplatesManager.CommonTags[ i ].Id );
+ if( idx > -1 )
+ {
+ string currentId = TemplatesManager.CommonTags[ i ].Id;
+
+ TemplateCommonTagId commonTagId = (TemplateCommonTagId)i;
+ switch( commonTagId )
+ {
+ // Properties
+ case TemplateCommonTagId.Property:
+ {
+ TemplateHelperFunctions.CreateShaderPropertiesList( m_templateBody.Substring( 0, idx + TemplatesManager.CommonTags[ i ].Id.Length ), ref m_availableShaderProperties, ref duplicatesHelper );
+ }
+ break;
+ // Globals
+ case TemplateCommonTagId.Global:
+ {
+ TemplateHelperFunctions.CreateShaderGlobalsList( m_templateBody.Substring( 0, idx + TemplatesManager.CommonTags[ i ].Id.Length ), ref m_availableShaderProperties, ref duplicatesHelper );
+ }
+ break;
+
+ //Tags
+ //case TemplateCommonTagId.Tag:
+ //{
+ // m_propertyList[ m_propertyList.Count - 1 ].Indentation = " ";
+ //}
+ //break;
+ //case TemplateCommonTagId.CullMode:
+ //{
+ // int newId = idx + TemplatesManager.CommonTags[ i ].Id.Length;
+ // int end = m_templateBody.IndexOf( TemplatesManager.TemplateNewLine, newId );
+ // string cullParams = m_templateBody.Substring( newId, end - newId );
+ // currentId = m_templateBody.Substring( idx, end - idx );
+ // m_cullModeData.CullModeId = currentId;
+ // TemplateHelperFunctions.CreateCullMode( cullParams, ref m_cullModeData );
+ //}
+ //break;
+ //Blend Mode
+ //case TemplateCommonTagId.BlendMode:
+ //{
+ // int newId = idx + TemplatesManager.CommonTags[ i ].Id.Length;
+ // int end = m_templateBody.IndexOf( TemplatesManager.TemplateNewLine, newId );
+ // string blendParams = m_templateBody.Substring( newId, end - newId );
+ // currentId = m_templateBody.Substring( idx, end - idx );
+ // m_blendData.BlendModeId = currentId;
+ // TemplateHelperFunctions.CreateBlendMode( blendParams, ref m_blendData );
+ //}break;
+ //case TemplateCommonTagId.BlendOp:
+ //{
+ // int newId = idx + TemplatesManager.CommonTags[ i ].Id.Length;
+ // int end = m_templateBody.IndexOf( TemplatesManager.TemplateNewLine, newId );
+ // currentId = m_templateBody.Substring( idx, end - idx );
+ // BlendData.BlendOpId = currentId;
+ // TemplateHelperFunctions.CreateBlendOp( m_templateBody.Substring( newId, end - newId ), ref m_blendData );
+ //}break;
+ //case TemplateCommonTagId.ColorMask:
+ //{
+ // int newId = idx + TemplatesManager.CommonTags[ i ].Id.Length;
+ // int end = m_templateBody.IndexOf( TemplatesManager.TemplateNewLine, newId );
+ // string colorMaskParams = m_templateBody.Substring( newId, end - newId );
+ // currentId = m_templateBody.Substring( idx, end - idx );
+ // m_colorMaskData.ColorMaskId = currentId;
+ // TemplateHelperFunctions.CreateColorMask( colorMaskParams, ref m_colorMaskData );
+ //}
+ //break;
+ //case TemplateCommonTagId.StencilOp:
+ //{
+ // int id = m_templateBody.LastIndexOf( "Stencil" );
+ // if( id > -1 )
+ // {
+ // string stencilParams = m_templateBody.Substring( id, idx - id );
+ // currentId = stencilParams + TemplatesManager.TemplateStencilOpTag;
+ // m_stencilData.StencilBufferId = currentId;
+ // TemplateHelperFunctions.CreateStencilOps( stencilParams, ref m_stencilData );
+ // }
+
+ //}
+ //break;
+ default:
+ break;
+ }
+
+ //AddId( TemplatesManager.CommonTags[ i ] );
+ AddId( currentId, TemplatesManager.CommonTags[ i ].SearchIndentation, TemplatesManager.CommonTags[ i ].CustomIndentation );
+ }
+ }
+
+ duplicatesHelper.Clear();
+ duplicatesHelper = null;
+ }
+ catch( Exception e )
+ {
+ Debug.LogException( e );
+ m_isValid = false;
+ }
+ }
+
+ void FetchCodeAreas( string begin, MasterNodePortCategory category )
+ {
+ int areaBeginIndexes = m_templateBody.IndexOf( begin );
+
+ if( areaBeginIndexes > -1 )
+ {
+ int beginIdx = areaBeginIndexes + begin.Length;
+ int endIdx = m_templateBody.IndexOf( TemplatesManager.TemplateEndOfLine, beginIdx );
+ int length = endIdx - beginIdx;
+
+ string parameters = m_templateBody.Substring( beginIdx, length );
+
+ string[] parametersArr = parameters.Split( IOUtils.FIELD_SEPARATOR );
+
+ string id = m_templateBody.Substring( areaBeginIndexes, endIdx + TemplatesManager.TemplateEndOfLine.Length - areaBeginIndexes );
+ string inParameters = parametersArr[ 0 ];
+ string outParameters = ( parametersArr.Length > 1 ) ? parametersArr[ 1 ] : string.Empty;
+ if( category == MasterNodePortCategory.Fragment )
+ {
+ m_fragmentFunctionData = new TemplateFunctionData(-1, string.Empty, id, areaBeginIndexes, inParameters, outParameters, category );
+ }
+ else
+ {
+ m_vertexFunctionData = new TemplateFunctionData( -1, string.Empty,id, areaBeginIndexes, inParameters, outParameters, category );
+ }
+ AddId( id, true );
+ }
+ }
+
+ void FetchInputs( MasterNodePortCategory portCategory )
+ {
+ string beginTag = ( portCategory == MasterNodePortCategory.Fragment ) ? TemplatesManager.TemplateInputsFragBeginTag : TemplatesManager.TemplateInputsVertBeginTag;
+ int[] inputBeginIndexes = m_templateBody.AllIndexesOf( beginTag );
+ if( inputBeginIndexes != null && inputBeginIndexes.Length > 0 )
+ {
+ for( int i = 0; i < inputBeginIndexes.Length; i++ )
+ {
+ int inputEndIdx = m_templateBody.IndexOf( TemplatesManager.TemplateEndSectionTag, inputBeginIndexes[ i ] );
+ int defaultValueBeginIdx = inputEndIdx + TemplatesManager.TemplateEndSectionTag.Length;
+ int endLineIdx = m_templateBody.IndexOf( TemplatesManager.TemplateFullEndTag, defaultValueBeginIdx );
+
+ string defaultValue = m_templateBody.Substring( defaultValueBeginIdx, endLineIdx - defaultValueBeginIdx );
+ string tagId = m_templateBody.Substring( inputBeginIndexes[ i ], endLineIdx + TemplatesManager.TemplateFullEndTag.Length - inputBeginIndexes[ i ] );
+
+ int beginIndex = inputBeginIndexes[ i ] + beginTag.Length;
+ int length = inputEndIdx - beginIndex;
+ string inputData = m_templateBody.Substring( beginIndex, length );
+ string[] inputDataArray = inputData.Split( IOUtils.FIELD_SEPARATOR );
+ if( inputDataArray != null && inputDataArray.Length > 0 )
+ {
+ try
+ {
+ string portName = inputDataArray[ (int)TemplatePortIds.Name ];
+ WirePortDataType dataType = (WirePortDataType)Enum.Parse( typeof( WirePortDataType ), inputDataArray[ (int)TemplatePortIds.DataType ].ToUpper() );
+
+ int portUniqueIDArrIdx = (int)TemplatePortIds.UniqueId;
+ int portUniqueId = ( portUniqueIDArrIdx < inputDataArray.Length ) ? Convert.ToInt32( inputDataArray[ portUniqueIDArrIdx ] ) : -1;
+ if( portUniqueId < 0 )
+ portUniqueId = m_inputDataList.Count;
+
+ int portOrderArrayIdx = (int)TemplatePortIds.OrderId;
+ int portOrderId = ( portOrderArrayIdx < inputDataArray.Length ) ? Convert.ToInt32( inputDataArray[ portOrderArrayIdx ] ) : -1;
+ if( portOrderId < 0 )
+ portOrderId = m_inputDataList.Count;
+
+ AddInput( inputBeginIndexes[ i ], tagId, portName, defaultValue, dataType, portCategory, portUniqueId, portOrderId );
+ }
+ catch( Exception e )
+ {
+ Debug.LogException( e );
+ }
+ }
+ }
+ }
+ }
+
+ //void FetchSnippets()
+ //{
+ // int[] codeSnippetAttribBeginIndexes = m_templateBody.AllIndexesOf( TemplatesManager.TemplateCodeSnippetAttribBegin );
+ // int[] codeSnippetAttribEndIndexes = m_templateBody.AllIndexesOf( TemplatesManager.TemplateCodeSnippetAttribEnd );
+ // int[] codeSnippetEndIndexes = m_templateBody.AllIndexesOf( TemplatesManager.TemplateCodeSnippetEnd );
+
+ // if( codeSnippetAttribBeginIndexes != null && codeSnippetAttribBeginIndexes.Length > 0 &&
+ // codeSnippetAttribEndIndexes != null && codeSnippetAttribEndIndexes.Length > 0 &&
+ // codeSnippetEndIndexes != null && codeSnippetEndIndexes.Length > 0 &&
+ // codeSnippetEndIndexes.Length == codeSnippetAttribBeginIndexes.Length &&
+ // codeSnippetAttribBeginIndexes.Length == codeSnippetAttribEndIndexes.Length )
+ // {
+ // for( int i = 0; i < codeSnippetAttribBeginIndexes.Length; i++ )
+ // {
+ // // get attributes
+ // int startAttribIndex = codeSnippetAttribBeginIndexes[ i ] + TemplatesManager.TemplateCodeSnippetAttribBegin.Length;
+ // int lengthAttrib = codeSnippetAttribEndIndexes[ i ] - startAttribIndex;
+ // string snippetAttribs = m_templateBody.Substring( startAttribIndex, lengthAttrib );
+ // string[] snippetAttribsArr = snippetAttribs.Split( IOUtils.FIELD_SEPARATOR );
+ // if( snippetAttribsArr != null && snippetAttribsArr.Length > 0 )
+ // {
+ // string attribName = snippetAttribsArr[ (int)TemplateCodeSnippetInfoIdx.Name ];
+ // TemplateCodeSnippetType attribType = (TemplateCodeSnippetType)Enum.Parse( typeof( TemplateCodeSnippetType ), snippetAttribsArr[ (int)TemplateCodeSnippetInfoIdx.Type ] );
+ // if( m_snippetElementsDict.ContainsKey( attribName ) )
+ // {
+ // if( m_snippetElementsDict[ attribName ].Type != attribType )
+ // {
+ // if( DebugConsoleWindow.DeveloperMode )
+ // Debug.LogWarning( "Found incompatible types for snippet " + attribName );
+ // }
+ // }
+ // else
+ // {
+ // switch( attribType )
+ // {
+ // case TemplateCodeSnippetType.Toggle:
+ // {
+ // //Register must be done by first instantiang the correct type and register it on both containers
+ // //Overrides don't work if we use the container reference into the other
+ // TemplateCodeSnippetToggle newSnippet = ScriptableObject.CreateInstance<TemplateCodeSnippetToggle>();
+ // newSnippet.Init( attribName, attribType );
+ // m_snippetElementsDict.Add( attribName, newSnippet );
+ // m_snippetElementsList.Add( newSnippet );
+ // }
+ // break;
+ // }
+
+ // }
+ // // Add initial tag indentation
+ // int indentationIndex = codeSnippetAttribBeginIndexes[ i ];
+ // int lengthAdjust = 0;
+ // for( ; indentationIndex > 0; indentationIndex--, lengthAdjust++ )
+ // {
+ // if( m_templateBody[ indentationIndex ] == TemplatesManager.TemplateNewLine )
+ // {
+ // indentationIndex += 1;
+ // lengthAdjust -= 1;
+ // break;
+ // }
+ // }
+
+ // if( indentationIndex > 0 )
+ // {
+ // string snippetId = m_templateBody.Substring( indentationIndex,
+ // codeSnippetEndIndexes[ i ] + TemplatesManager.TemplateCodeSnippetEnd.Length - codeSnippetAttribBeginIndexes[ i ] + lengthAdjust );
+
+ // int snippetCodeStart = codeSnippetAttribEndIndexes[ i ] + TemplatesManager.TemplateCodeSnippetAttribEnd.Length;
+ // int snippetCodeLength = codeSnippetEndIndexes[ i ] - snippetCodeStart;
+ // //Remove possible identation characters present between tag and last instruction
+ // if( m_templateBody[ snippetCodeStart + snippetCodeLength - 1 ] != TemplatesManager.TemplateNewLine )
+ // {
+ // for( ; snippetCodeLength > 0; snippetCodeLength-- )
+ // {
+ // if( m_templateBody[ snippetCodeStart + snippetCodeLength - 1 ] == TemplatesManager.TemplateNewLine )
+ // break;
+ // }
+ // }
+
+ // if( snippetCodeLength > 0 )
+ // {
+ // string snippetCode = m_templateBody.Substring( snippetCodeStart, snippetCodeLength );
+ // TemplateCodeSnippetElement element = new TemplateCodeSnippetElement( snippetId, snippetCode );
+ // m_snippetElementsDict[ attribName ].AddSnippet( element );
+ // }
+ // }
+ // }
+ // }
+ // }
+ //}
+
+ //void RefreshSnippetInfo()
+ //{
+ // if( m_snippetElementsDict == null )
+ // {
+ // m_snippetElementsDict = new Dictionary<string, TemplateCodeSnippetBase>();
+ // }
+
+ // if( m_snippetElementsDict.Count != m_snippetElementsList.Count )
+ // {
+ // m_snippetElementsDict.Clear();
+ // for( int i = 0; i < m_snippetElementsList.Count; i++ )
+ // {
+ // m_snippetElementsDict.Add( m_snippetElementsList[ i ].NameId, m_snippetElementsList[ i ] );
+ // }
+ // }
+ //}
+
+ //public void DrawSnippetProperties( ParentNode owner )
+ //{
+ // for( int i = 0; i < m_snippetElementsList.Count; i++ )
+ // {
+ // m_snippetElementsList[ i ].DrawProperties( owner );
+ // }
+ //}
+
+ //public void InsertSnippets( ref string shaderBody )
+ //{
+ // for( int i = 0; i < m_snippetElementsList.Count; i++ )
+ // {
+ // m_snippetElementsList[ i ].InsertSnippet( ref shaderBody );
+ // }
+ //}
+
+ public void AddId( string ID, bool searchIndentation = true )
+ {
+ AddId( ID, searchIndentation, string.Empty );
+ }
+
+ public void AddId( string ID, bool searchIndentation, string customIndentation )
+ {
+ int propertyIndex = m_templateBody.IndexOf( ID );
+ if( propertyIndex > -1 )
+ {
+ if( searchIndentation )
+ {
+ int indentationIndex = -1;
+ for( int i = propertyIndex; i > 0; i-- )
+ {
+ if( m_templateBody[ i ] == TemplatesManager.TemplateNewLine )
+ {
+ indentationIndex = i + 1;
+ break;
+ }
+ }
+ if( indentationIndex > -1 )
+ {
+ int length = propertyIndex - indentationIndex;
+ string indentation = ( length > 0 ) ? m_templateBody.Substring( indentationIndex, length ) : string.Empty;
+ m_propertyList.Add( new TemplateProperty( ID, indentation, false ) );
+ }
+ }
+ else
+ {
+ m_propertyList.Add( new TemplateProperty( ID, customIndentation, true ) );
+ }
+ }
+ }
+
+ void BuildInfo()
+ {
+ if( m_propertyDict == null )
+ {
+ m_propertyDict = new Dictionary<string, TemplateProperty>();
+ }
+
+ if( m_propertyList.Count != m_propertyDict.Count )
+ {
+ m_propertyDict.Clear();
+ for( int i = 0; i < m_propertyList.Count; i++ )
+ {
+ m_propertyDict.Add( m_propertyList[ i ].Id, m_propertyList[ i ] );
+ }
+ }
+ }
+
+ public void ResetTemplateUsageData()
+ {
+ BuildInfo();
+ for( int i = 0; i < m_propertyList.Count; i++ )
+ {
+ m_propertyList[ i ].Used = false;
+ }
+ }
+
+ public void AddInput( int tagStartIdx, string tagId, string portName, string defaultValue, WirePortDataType dataType, MasterNodePortCategory portCategory, int portUniqueId, int portOrderId )
+ {
+ TemplateInputData inputData = new TemplateInputData( tagStartIdx, tagStartIdx, tagId, portName, defaultValue, dataType, portCategory, portUniqueId, portOrderId, string.Empty );
+ m_inputDataList.Add( inputData );
+ m_inputDataDict.Add( inputData.PortUniqueId, inputData );
+ AddId( tagId, false );
+ }
+
+ public override void Destroy()
+ {
+ if( m_vertexDataContainer != null )
+ {
+ m_vertexDataContainer.Destroy();
+ m_vertexDataContainer = null;
+ }
+
+ if( m_interpolatorDataContainer != null )
+ {
+ m_interpolatorDataContainer.Destroy();
+ m_interpolatorDataContainer = null;
+ }
+
+ if( m_availableShaderProperties != null )
+ {
+ m_availableShaderProperties.Clear();
+ m_availableShaderProperties = null;
+ }
+
+ if( m_propertyDict != null )
+ {
+ m_propertyDict.Clear();
+ m_propertyDict = null;
+ }
+
+ if( m_propertyList != null )
+ {
+ m_propertyList.Clear();
+ m_propertyList = null;
+ }
+
+ if( m_inputDataDict != null )
+ {
+ m_inputDataDict.Clear();
+ m_inputDataDict = null;
+ }
+
+ if( m_inputDataList != null )
+ {
+ m_inputDataList.Clear();
+ m_inputDataList = null;
+ }
+
+ if( m_localVarsList != null )
+ {
+ m_localVarsList.Clear();
+ m_localVarsList = null;
+ }
+ //if( m_snippetElementsDict != null )
+ //{
+ // m_snippetElementsDict.Clear();
+ // m_snippetElementsDict = null;
+ //}
+
+ //if( m_snippetElementsList != null )
+ //{
+ // for( int i = 0; i < m_snippetElementsList.Count; i++ )
+ // {
+ // GameObject.DestroyImmediate( m_snippetElementsList[ i ] );
+ // m_snippetElementsList[ i ] = null;
+ // }
+ // m_snippetElementsList.Clear();
+ // m_snippetElementsList = null;
+ //}
+
+ m_cullModeData = null;
+ m_blendData = null;
+ m_colorMaskData = null;
+ m_stencilData = null;
+ if( m_tagData != null )
+ {
+ m_tagData.Destroy();
+ m_tagData = null;
+ }
+ }
+
+ public void FillEmptyTags( ref string body )
+ {
+ body = body.Replace( TemplatesManager.TemplateLocalVarTag, string.Empty );
+ for( int i = 0; i < m_propertyList.Count; i++ )
+ {
+ if( !m_propertyList[ i ].Used )
+ {
+ if( m_propertyList[ i ].UseCustomIndentation )
+ {
+ body = body.Replace( m_propertyList[ i ].Id, string.Empty );
+ }
+ else
+ {
+ body = body.Replace( m_propertyList[ i ].Indentation + m_propertyList[ i ].Id, string.Empty );
+ }
+ }
+ }
+ }
+
+ public bool FillVertexInstructions( ref string body, params string[] values )
+ {
+ if( m_vertexFunctionData != null && !string.IsNullOrEmpty( m_vertexFunctionData.Id ) )
+ {
+ return FillTemplateBody( m_vertexFunctionData.Id, ref body, values );
+ }
+
+ if( values.Length > 0 )
+ {
+ UIUtils.ShowMessage( "Attemping to add vertex instructions on a template with no assigned vertex code area", MessageSeverity.Error );
+ return false;
+ }
+ return true;
+ }
+
+ public bool FillFragmentInstructions( ref string body, params string[] values )
+ {
+ if( m_fragmentFunctionData != null && !string.IsNullOrEmpty( m_fragmentFunctionData.Id ) )
+ {
+ return FillTemplateBody( m_fragmentFunctionData.Id, ref body, values );
+ }
+
+ if( values.Length > 0 )
+ {
+ UIUtils.ShowMessage( "Attemping to add fragment instructions on a template with no assigned vertex code area", MessageSeverity.Error );
+ return false;
+ }
+ return true;
+ }
+
+ // values must be unindented an without line feed
+ public bool FillTemplateBody( string id, ref string body, params string[] values )
+ {
+ if( values.Length == 0 )
+ {
+ return true;
+ }
+
+ BuildInfo();
+
+ if( m_propertyDict.ContainsKey( id ) )
+ {
+ string finalValue = string.Empty;
+ for( int i = 0; i < values.Length; i++ )
+ {
+
+ if( m_propertyDict[ id ].AutoLineFeed )
+ {
+ string[] valuesArr = values[ i ].Split( '\n' );
+ for( int j = 0; j < valuesArr.Length; j++ )
+ {
+ //first value will be automatically indented by the string replace
+ finalValue += ( ( i == 0 && j == 0 ) ? string.Empty : m_propertyDict[ id ].Indentation ) + valuesArr[ j ];
+ finalValue += TemplatesManager.TemplateNewLine;
+ }
+
+ }
+ else
+ {
+ //first value will be automatically indented by the string replace
+ finalValue += ( i == 0 ? string.Empty : m_propertyDict[ id ].Indentation ) + values[ i ];
+ }
+ }
+
+ body = body.Replace( id, finalValue );
+ m_propertyDict[ id ].Used = true;
+ return true;
+ }
+
+ if( values.Length > 1 || !string.IsNullOrEmpty( values[ 0 ] ) )
+ {
+ UIUtils.ShowMessage( string.Format( "Attempting to write data into inexistant tag {0}. Please review the template {1} body and consider adding the missing tag.", id, m_name ), MessageSeverity.Error );
+ return false;
+ }
+
+ return true;
+
+ }
+
+ public bool FillTemplateBody( string id, ref string body, List<PropertyDataCollector> values )
+ {
+ if( values.Count == 0 )
+ {
+ return true;
+ }
+
+ string[] array = new string[ values.Count ];
+ for( int i = 0; i < values.Count; i++ )
+ {
+ array[ i ] = values[ i ].PropertyName;
+ }
+ return FillTemplateBody( id, ref body, array );
+ }
+
+ public TemplateInputData InputDataFromId( int id )
+ {
+ if( m_inputDataDict == null )
+ m_inputDataDict = new Dictionary<int, TemplateInputData>();
+
+ if( m_inputDataDict.Count != m_inputDataList.Count )
+ {
+ m_inputDataDict.Clear();
+ for( int i = 0; i < m_inputDataList.Count; i++ )
+ {
+ m_inputDataDict.Add( m_inputDataList[ i ].PortUniqueId, m_inputDataList[ i ] );
+ }
+ }
+
+ if( m_inputDataDict.ContainsKey( id ) )
+ return m_inputDataDict[ id ];
+
+ return null;
+ }
+
+ public string GetVertexData( TemplateInfoOnSematics info )
+ {
+ int count = m_vertexDataContainer.VertexData.Count;
+ for( int i = 0; i < count; i++ )
+ {
+ if( m_vertexDataContainer.VertexData[ i ].DataInfo == info )
+ {
+ return string.Format( TemplateHelperFunctions.TemplateVarFormat, m_vertexFunctionData.InVarName, m_vertexDataContainer.VertexData[ i ].VarName );
+ }
+ }
+ return string.Empty;
+ }
+
+ public string GetInterpolatedData( TemplateInfoOnSematics info )
+ {
+ int count = m_interpolatorDataContainer.Interpolators.Count;
+ for( int i = 0; i < count; i++ )
+ {
+ if( m_interpolatorDataContainer.Interpolators[ i ].DataInfo == info )
+ {
+ return string.Format( TemplateHelperFunctions.TemplateVarFormat, m_fragmentFunctionData.InVarName, m_interpolatorDataContainer.Interpolators[ i ].VarName );
+ }
+ }
+ return string.Empty;
+ }
+
+ public string InterpDataId { get { return m_interpolatorDataContainer.InterpDataId; } }
+ public string VertexDataId { get { return m_vertexDataContainer.VertexDataId; } }
+ public string ShaderNameId { get { return m_shaderNameId; } set { m_shaderNameId = value; } }
+ public string TemplateBody { get { return m_templateBody; } set { m_templateBody = value; } }
+ public List<TemplateInputData> InputDataList { get { return m_inputDataList; } set { m_inputDataList = value; } }
+ public List<TemplateLocalVarData> LocalVarsList { get { return m_localVarsList; } }
+ public List<TemplateVertexData> VertexDataList { get { return m_vertexDataContainer.VertexData; } }
+ public TemplateInterpData InterpolatorData { get { return m_interpolatorDataContainer; } }
+ public TemplateFunctionData VertexFunctionData { get { return m_vertexFunctionData; } set { m_vertexFunctionData = value; } }
+ public TemplateFunctionData FragmentFunctionData { get { return m_fragmentFunctionData; } set { m_fragmentFunctionData = value; } }
+ public List<TemplateShaderPropertyData> AvailableShaderProperties { get { return m_availableShaderProperties; } set { m_availableShaderProperties = value; } }
+ public TemplateBlendData BlendData { get { return m_blendData; } set { m_blendData = value; } }
+ public TemplateCullModeData CullModeData { get { return m_cullModeData; } set { m_cullModeData = value; } }
+ public TemplateColorMaskData ColorMaskData { get { return m_colorMaskData; } set { m_colorMaskData = value; } }
+ public TemplateStencilData StencilData { get { return m_stencilData; } set { m_stencilData = value; } }
+ public TemplateDepthData DepthData { get { return m_depthData; } set { m_depthData = value; } }
+ public TemplateTagsModuleData TagData { get { return m_tagData; } set { m_tagData = value; } }
+ private List<TemplateProperty> PropertyList { get { return m_propertyList; } set { m_propertyList = value; } }
+ public VertexDataContainer VertexDataContainer { get { return m_vertexDataContainer; } set { m_vertexDataContainer = value; } }
+ public TemplateInterpData InterpolatorDataContainer { get { return m_interpolatorDataContainer; } set { m_interpolatorDataContainer = value; } }
+ }
+}
generated by cgit v1.1-26-g67d0 at 2025-05-28 14:04:20 +0000