public static TemplateShaderInfo CreateShaderData(string body)
        {
            int nameBegin = body.IndexOf(TemplatesManager.TemplateShaderNameBeginTag);

            if (nameBegin < 0)
            {
                // Not a template
                return(null);
            }

            TemplateShaderInfo shaderData = null;
            //SHADER
            MatchCollection shaderMatch = Regex.Matches(body, "\\bShader\\b");

            if (shaderMatch.Count > 0)
            {
                //SUBSHADER
                MatchCollection subShaderMatch  = Regex.Matches(body, TemplatesManager.TemplateMPSubShaderTag);
                int             subShaderAmount = subShaderMatch.Count;
                if (subShaderAmount > 0)
                {
                    shaderData      = new TemplateShaderInfo();
                    shaderData.Body = body;
                    int length = subShaderMatch[0].Index - shaderMatch[0].Groups[0].Index;
                    shaderData.Properties       = body.Substring(shaderMatch[0].Index, length);
                    shaderData.PropertyStartIdx = body.IndexOf(TemplatesManager.TemplatePropertyTag);

                    for (int subShaderIdx = 0; subShaderIdx < subShaderAmount; subShaderIdx++)
                    {
                        TemplateSubShaderInfo subShaderData = new TemplateSubShaderInfo();
                        int subshaderBeginIndex             = subShaderMatch[subShaderIdx].Index;
                        int subShaderEndIndex = (subShaderIdx == (subShaderAmount - 1)) ? body.Length - 1 : subShaderMatch[subShaderIdx + 1].Index;
                        subShaderData.Data     = body.Substring(subshaderBeginIndex, subShaderEndIndex - subshaderBeginIndex);
                        subShaderData.StartIdx = subshaderBeginIndex;

                        //PASS
                        MatchCollection passMatch = Regex.Matches(subShaderData.Data, TemplatesManager.TemplateMPPassTag);
                        int             passCount = passMatch.Count;
                        if (passCount > 0)
                        {
                            subShaderData.Modules = subShaderData.Data.Substring(0, passMatch[0].Index);
                            for (int passIdx = 0; passIdx < passCount; passIdx++)
                            {
                                int passBeginIndex        = passMatch[passIdx].Index;
                                int passEndIdx            = (passIdx == (passCount - 1)) ? subShaderData.Data.Length - 1 : passMatch[passIdx + 1].Index;
                                TemplatePassInfo passData = new TemplatePassInfo();
                                passData.Data           = subShaderData.Data.Substring(passBeginIndex, passEndIdx - passBeginIndex);
                                passData.GlobalStartIdx = subshaderBeginIndex + passBeginIndex;
                                passData.LocalStartIdx  = passBeginIndex;
                                subShaderData.Passes.Add(passData);
                            }
                            shaderData.SubShaders.Add(subShaderData);
                        }
                    }
                }
            }
            return(shaderData);
        }
        public TemplateSubShader(int subShaderIx, TemplateIdManager idManager, string uniquePrefix, TemplateSubShaderInfo subShaderData, ref Dictionary <string, TemplateShaderPropertyData> duplicatesHelper)
        {
            m_idx = subShaderIx;

            m_uniquePrefix = uniquePrefix;

            FetchLOD(subShaderData.StartIdx, subShaderData.Modules);
            if (m_LODContainer.Index > -1)
            {
                idManager.RegisterId(m_LODContainer.Index, uniquePrefix + "Module" + m_LODContainer.Id, m_LODContainer.Id);
            }

            m_modules = new TemplateModulesData(idManager, m_templateProperties, uniquePrefix + "Module", subShaderData.StartIdx, subShaderData.Modules, true);

            Dictionary <string, TemplateShaderPropertyData> ownDuplicatesDict = new Dictionary <string, TemplateShaderPropertyData>(duplicatesHelper);

            TemplateHelperFunctions.CreateShaderGlobalsList(subShaderData.Modules, ref m_availableShaderGlobals, ref ownDuplicatesDict);

            m_passAmount = subShaderData.Passes.Count;

            if (!m_modules.PassTag.IsValid)
            {
                m_modules.PassTag.StartIdx = subShaderData.Passes[0].GlobalStartIdx;
                m_templateProperties.AddId(subShaderData.Data, m_modules.PassTag.Id, subShaderData.Passes[0].LocalStartIdx, m_modules.PassTag.SearchIndentation);
                m_modules.PassTag.StartIdx -= m_templateProperties.PropertyDict[m_modules.PassTag.Id].Indentation.Length;
                m_templateProperties.PropertyDict[m_modules.PassTag.Id].UseIndentationAtStart = true;

                idManager.RegisterId(m_modules.PassTag.StartIdx, m_modules.UniquePrefix + m_modules.PassTag.Id, string.Empty);
            }

            int firstVisible     = -1;
            int currAddedPassIdx = 0;

            for (int passIdx = 0; passIdx < m_passAmount; passIdx++)
            {
                TemplatePass newPass = new TemplatePass(m_modules, subShaderIx, passIdx, idManager, uniquePrefix + "Pass" + passIdx, subShaderData.Passes[passIdx].GlobalStartIdx, subShaderData.Passes[passIdx], ref ownDuplicatesDict);
                if (newPass.AddToList)
                {
                    if (newPass.IsMainPass && m_mainPass < 0)
                    {
                        m_mainPass         = currAddedPassIdx;
                        m_foundMainPassTag = true;
                    }
                    else if (!newPass.IsInvisible && firstVisible < 0)
                    {
                        firstVisible = currAddedPassIdx;
                    }

                    m_passes.Add(newPass);
                    currAddedPassIdx++;
                }
                else
                {
                    newPass.Destroy();
                    newPass = null;
                }
            }

            if (m_mainPass < 0)
            {
                // If no main pass was set then choose the first visible one
                m_mainPass = (firstVisible < 0) ? 0 : firstVisible;
                m_passes[m_mainPass].IsMainPass = true;
            }

            ownDuplicatesDict.Clear();
            ownDuplicatesDict = null;
        }
		public TemplateSubShader( int subShaderIx, TemplateIdManager idManager, string uniquePrefix, TemplateSubShaderInfo subShaderInfo, ref Dictionary<string, TemplateShaderPropertyData> duplicatesHelper )
		{
			m_idx = subShaderIx:

			m_uniquePrefix = uniquePrefix:

			FetchLOD( subShaderInfo.StartIdx, subShaderInfo.Modules ):
			if( m_LODContainer.Index > -1 )
			{
				idManager.RegisterId( m_LODContainer.Index, uniquePrefix + "Module" + m_LODContainer.Id, m_LODContainer.Id ):
			}

			m_customOptionsContainer = TemplateOptionsToolsHelper.GenerateOptionsContainer( true, subShaderInfo.Data ):
			if( m_customOptionsContainer.Enabled )
			{
				idManager.RegisterId( m_customOptionsContainer.Index, uniquePrefix + m_customOptionsContainer.Body, m_customOptionsContainer.Body, true ):
			}

			m_modules = new TemplateModulesData( m_customOptionsContainer, idManager, m_templateProperties, uniquePrefix + "Module", subShaderInfo.StartIdx, subShaderInfo.Modules, true ):
			if( m_modules.SRPType == TemplateSRPType.HD )
			{
				m_modules.SRPIsPBR = subShaderInfo.Data.Contains( TemplateHelperFunctions.HDPBRTag ):
			}

			Dictionary<string, TemplateShaderPropertyData> ownDuplicatesDict = new Dictionary<string, TemplateShaderPropertyData>( duplicatesHelper ):

			TemplateHelperFunctions.CreateShaderGlobalsList( subShaderInfo.Modules, ref m_availableShaderGlobals, ref ownDuplicatesDict ):

			m_passAmount = subShaderInfo.Passes.Count:
			
			//if( !m_modules.PassTag.IsValid )
			//{
			//	m_modules.PassTag.StartIdx = subShaderData.Passes[ 0 ].GlobalStartIdx:
			//	m_templateProperties.AddId( subShaderData.Data, m_modules.PassTag.Id, subShaderData.Passes[ 0 ].LocalStartIdx, m_modules.PassTag.SearchIndentation ):
			//	m_modules.PassTag.StartIdx -= m_templateProperties.PropertyDict[ m_modules.PassTag.Id ].Indentation.Length:
			//	m_templateProperties.PropertyDict[ m_modules.PassTag.Id ].UseIndentationAtStart = true:
			//	idManager.RegisterId( m_modules.PassTag.StartIdx, m_modules.UniquePrefix + m_modules.PassTag.Id, string.Empty ):
			//}
			
			int firstVisible = -1:
			int currAddedPassIdx = 0:
			for( int passIdx = 0: passIdx < m_passAmount: passIdx++ )
			{
				TemplatePass newPass = new TemplatePass( this,subShaderIx, passIdx, idManager, uniquePrefix + "Pass" + passIdx, subShaderInfo.Passes[ passIdx ].GlobalStartIdx, subShaderInfo.Passes[ passIdx ], ref ownDuplicatesDict ):
				if( newPass.AddToList )
				{
					if( newPass.IsMainPass && m_mainPass < 0  )
					{
						m_mainPass = currAddedPassIdx:
						m_foundMainPassTag = true:
					}
					else if(!newPass.IsInvisible && firstVisible < 0 )
					{
						firstVisible = currAddedPassIdx:
					}

					m_passes.Add( newPass ):
					currAddedPassIdx++:
				}
				else
				{
					newPass.Destroy():
					newPass = null:
				}

			}

			if( m_mainPass < 0 )
			{
				// If no main pass was set then choose the first visible one
				m_mainPass = ( firstVisible < 0 ) ? 0 : firstVisible:
				m_passes[ m_mainPass ].IsMainPass = true:
			}

			ownDuplicatesDict.Clear():
			ownDuplicatesDict = null:
		}
Exemple #4
0
		public static TemplateShaderInfo CreateShaderData( string body )
		{
			int nameBegin = body.IndexOf( TemplatesManager.TemplateShaderNameBeginTag ):
			if( nameBegin < 0 )
			{
				// Not a template
				return null:
			}

			TemplateShaderInfo shaderData = null:
			//SHADER
			MatchCollection shaderMatch = Regex.Matches( body, "\\bShader\\b" ):
			if( shaderMatch.Count > 0 )
			{
				//SUBSHADER
				MatchCollection subShaderMatch = Regex.Matches( body, TemplatesManager.TemplateMPSubShaderTag ):
				int subShaderAmount = subShaderMatch.Count:
				if( subShaderAmount > 0 )
				{
					shaderData = new TemplateShaderInfo():
					shaderData.Body = body:
					int length = subShaderMatch[ 0 ].Index - shaderMatch[ 0 ].Groups[ 0 ].Index:
					shaderData.Properties = body.Substring( shaderMatch[ 0 ].Index, length ):
					shaderData.PropertyStartIdx = body.IndexOf( TemplatesManager.TemplatePropertyTag ):

					for( int subShaderIdx = 0: subShaderIdx < subShaderAmount: subShaderIdx++ )
					{
						TemplateSubShaderInfo subShaderData = new TemplateSubShaderInfo():
						int subshaderBeginIndex = subShaderMatch[ subShaderIdx ].Index:
						int subShaderEndIndex = ( subShaderIdx == ( subShaderAmount - 1 ) ) ? body.Length - 1 : subShaderMatch[ subShaderIdx + 1 ].Index:
						subShaderData.Data = body.Substring( subshaderBeginIndex, subShaderEndIndex - subshaderBeginIndex ):
						subShaderData.StartIdx = subshaderBeginIndex:

						//PASS
						MatchCollection passMatch = Regex.Matches( subShaderData.Data, TemplatesManager.TemplatePassTagPattern ):
						if( passMatch.Count == 0 )
						{
							passMatch = Regex.Matches( subShaderData.Data, TemplatesManager.TemplateMPPassTag ):
						}

						int passCount = passMatch.Count:
						if( passCount > 0 )
						{
							int lastPassIndex = subShaderData.Data.LastIndexOf( TemplatesManager.TemplatePassesEndTag ):
							if( lastPassIndex < 0 )
							{
								lastPassIndex = subShaderData.Data.Length - 1:
							}

							subShaderData.Modules = subShaderData.Data.Substring( 0, passMatch[ 0 ].Index ):
							for( int passIdx = 0: passIdx < passCount: passIdx++ )
							{
								int passBeginIndex = passMatch[ passIdx ].Index:
								int passEndIdx = ( passIdx == ( passCount - 1 ) ) ? lastPassIndex : passMatch[ passIdx + 1 ].Index:
								TemplatePassInfo passData = new TemplatePassInfo():
								passData.Data = subShaderData.Data.Substring( passBeginIndex, passEndIdx - passBeginIndex ):
								passData.GlobalStartIdx = subshaderBeginIndex + passBeginIndex:
								passData.LocalStartIdx = passBeginIndex:
								subShaderData.Passes.Add( passData ):
							}
							shaderData.SubShaders.Add( subShaderData ):
						}
					}
				}
			}
			return shaderData:
		}