You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
770 lines
27 KiB
770 lines
27 KiB
// Amplify Shader Editor - Visual Shader Editing Tool
|
|
// Copyright (c) Amplify Creations, Lda <info@amplify.pt>
|
|
|
|
// THIS FILE IS DEPRECATED AND SHOULD NOT BE USED
|
|
|
|
#define SHOW_TEMPLATE_HELP_BOX
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
|
|
namespace AmplifyShaderEditor
|
|
{
|
|
[Serializable]
|
|
[NodeAttributes( "Template Master Node", "Master", "Shader Generated according to template rules", null, KeyCode.None, false, true, "Template MultiPass Master Node", typeof( TemplateMultiPassMasterNode ) )]
|
|
public sealed class TemplateMasterNode : MasterNode
|
|
{
|
|
private const string WarningMessage = "Templates is a feature that is still heavily under development and users may experience some problems.\nPlease email support@amplify.pt if any issue occurs.";
|
|
private const string CurrentTemplateLabel = "Current Template";
|
|
private const string OpenTemplateStr = "Edit Template";
|
|
|
|
//protected const string SnippetsFoldoutStr = " Snippets";
|
|
//[SerializeField]
|
|
//private bool m_snippetsFoldout = true;
|
|
|
|
[NonSerialized]
|
|
private TemplateData m_currentTemplate = null;
|
|
|
|
private bool m_fireTemplateChange = false;
|
|
private bool m_fetchMasterNodeCategory = false;
|
|
private bool m_reRegisterTemplateData = false;
|
|
|
|
[SerializeField]
|
|
private string m_templateGUID = string.Empty;
|
|
|
|
[SerializeField]
|
|
private string m_templateName = string.Empty;
|
|
|
|
[SerializeField]
|
|
private TemplatesBlendModule m_blendOpHelper = new TemplatesBlendModule();
|
|
|
|
[SerializeField]
|
|
private TemplateAlphaToMaskModule m_alphaToMaskHelper = new TemplateAlphaToMaskModule();
|
|
|
|
[SerializeField]
|
|
private TemplateCullModeModule m_cullModeHelper = new TemplateCullModeModule();
|
|
|
|
[SerializeField]
|
|
private TemplateColorMaskModule m_colorMaskHelper = new TemplateColorMaskModule();
|
|
|
|
[SerializeField]
|
|
private TemplatesStencilBufferModule m_stencilBufferHelper = new TemplatesStencilBufferModule();
|
|
|
|
[SerializeField]
|
|
private TemplateDepthModule m_depthOphelper = new TemplateDepthModule();
|
|
|
|
[SerializeField]
|
|
private TemplateTagsModule m_tagsHelper = new TemplateTagsModule();
|
|
|
|
protected override void CommonInit( int uniqueId )
|
|
{
|
|
base.CommonInit( uniqueId );
|
|
m_masterNodeCategory = 1;// First Template
|
|
m_marginPreviewLeft = 20;
|
|
m_insideSize.y = 60;
|
|
m_customPrecision = true;
|
|
}
|
|
|
|
public override void ReleaseResources()
|
|
{
|
|
if( m_currentTemplate != null && m_currentTemplate.AvailableShaderProperties != null )
|
|
{
|
|
// Unregister old template properties
|
|
int oldPropertyCount = m_currentTemplate.AvailableShaderProperties.Count;
|
|
for( int i = 0; i < oldPropertyCount; i++ )
|
|
{
|
|
UIUtils.ReleaseUniformName( UniqueId, m_currentTemplate.AvailableShaderProperties[ i ].PropertyName );
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void OnEnable()
|
|
{
|
|
base.OnEnable();
|
|
m_reRegisterTemplateData = true;
|
|
}
|
|
|
|
void FetchInfoFromTemplate()
|
|
{
|
|
if( m_currentTemplate.BlendData.DataCheck == TemplateDataCheck.Valid )
|
|
m_blendOpHelper.ConfigureFromTemplateData( m_currentTemplate.BlendData );
|
|
|
|
if( m_currentTemplate.AlphaToMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
m_alphaToMaskHelper.ConfigureFromTemplateData( m_currentTemplate.AlphaToMaskData );
|
|
|
|
if( m_currentTemplate.CullModeData.DataCheck == TemplateDataCheck.Valid )
|
|
m_cullModeHelper.ConfigureFromTemplateData( m_currentTemplate.CullModeData );
|
|
|
|
if( m_currentTemplate.ColorMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
m_colorMaskHelper.ConfigureFromTemplateData( m_currentTemplate.ColorMaskData );
|
|
|
|
if( m_currentTemplate.StencilData.DataCheck == TemplateDataCheck.Valid )
|
|
m_stencilBufferHelper.ConfigureFromTemplateData( m_currentTemplate.StencilData );
|
|
|
|
if( m_currentTemplate.DepthData.DataCheck == TemplateDataCheck.Valid )
|
|
m_depthOphelper.ConfigureFromTemplateData( m_currentTemplate.DepthData );
|
|
|
|
if( m_currentTemplate.TagData.DataCheck == TemplateDataCheck.Valid )
|
|
m_tagsHelper.ConfigureFromTemplateData( m_currentTemplate.TagData );
|
|
}
|
|
|
|
void FetchCurrentTemplate()
|
|
{
|
|
m_currentTemplate = m_containerGraph.ParentWindow.TemplatesManagerInstance.GetTemplate( m_templateGUID ) as TemplateData;
|
|
if( m_currentTemplate == null )
|
|
{
|
|
m_currentTemplate = m_containerGraph.ParentWindow.TemplatesManagerInstance.GetTemplate( m_templateName ) as TemplateData;
|
|
}
|
|
|
|
if( m_currentTemplate != null )
|
|
{
|
|
if( m_inputPorts.Count != m_currentTemplate.InputDataList.Count )
|
|
{
|
|
DeleteAllInputConnections( true );
|
|
|
|
List<TemplateInputData> inputDataList = m_currentTemplate.InputDataList;
|
|
int count = inputDataList.Count;
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
AddInputPort( inputDataList[ i ].DataType, false, inputDataList[ i ].PortName, inputDataList[ i ].OrderId, inputDataList[ i ].PortCategory, inputDataList[ i ].PortUniqueId );
|
|
}
|
|
FetchInfoFromTemplate();
|
|
}
|
|
else
|
|
{
|
|
List<TemplateInputData> inputDataList = m_currentTemplate.InputDataList;
|
|
int count = inputDataList.Count;
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
m_inputPorts[ i ].ChangeProperties( inputDataList[ i ].PortName, inputDataList[ i ].DataType, false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void RefreshAvailableCategories()
|
|
{
|
|
FetchCurrentTemplate();
|
|
|
|
int templateCount = m_containerGraph.ParentWindow.TemplatesManagerInstance.TemplateCount;
|
|
m_availableCategories = new MasterNodeCategoriesData[ templateCount + 1 ];
|
|
m_availableCategoryLabels = new GUIContent[ templateCount + 1 ];
|
|
|
|
m_availableCategories[ 0 ] = new MasterNodeCategoriesData( AvailableShaderTypes.SurfaceShader, string.Empty );
|
|
m_availableCategoryLabels[ 0 ] = new GUIContent( "Surface" );
|
|
if( m_currentTemplate == null )
|
|
{
|
|
m_masterNodeCategory = -1;
|
|
}
|
|
|
|
for( int i = 0; i < templateCount; i++ )
|
|
{
|
|
int idx = i + 1;
|
|
TemplateData templateData = m_containerGraph.ParentWindow.TemplatesManagerInstance.GetTemplate( i ) as TemplateData;
|
|
|
|
if( m_currentTemplate != null && m_currentTemplate.GUID.Equals( templateData.GUID ) )
|
|
m_masterNodeCategory = idx;
|
|
|
|
m_availableCategories[ idx ] = new MasterNodeCategoriesData( AvailableShaderTypes.Template, templateData.GUID );
|
|
m_availableCategoryLabels[ idx ] = new GUIContent( templateData.Name );
|
|
}
|
|
}
|
|
|
|
void SetCategoryIdxFromTemplate()
|
|
{
|
|
int templateCount = m_containerGraph.ParentWindow.TemplatesManagerInstance.TemplateCount;
|
|
for( int i = 0; i < templateCount; i++ )
|
|
{
|
|
int idx = i + 1;
|
|
TemplateData templateData = m_containerGraph.ParentWindow.TemplatesManagerInstance.GetTemplate( i ) as TemplateData;
|
|
if( templateData != null && m_currentTemplate != null && m_currentTemplate.GUID.Equals( templateData.GUID ) )
|
|
m_masterNodeCategory = idx;
|
|
}
|
|
}
|
|
|
|
public void SetTemplate( TemplateData newTemplate, bool writeDefaultData, bool fetchMasterNodeCategory )
|
|
{
|
|
ReleaseResources();
|
|
|
|
if( newTemplate == null || newTemplate.InputDataList == null )
|
|
return;
|
|
|
|
m_fetchMasterNodeCategory = fetchMasterNodeCategory;
|
|
|
|
DeleteAllInputConnections( true );
|
|
m_currentTemplate = newTemplate;
|
|
m_currentShaderData = newTemplate.Name;
|
|
|
|
List<TemplateInputData> inputDataList = newTemplate.InputDataList;
|
|
int count = inputDataList.Count;
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
AddInputPort( inputDataList[ i ].DataType, false, inputDataList[ i ].PortName, inputDataList[ i ].OrderId, inputDataList[ i ].PortCategory, inputDataList[ i ].PortUniqueId );
|
|
}
|
|
|
|
if( writeDefaultData )
|
|
{
|
|
ShaderName = newTemplate.DefaultShaderName;
|
|
}
|
|
|
|
RegisterProperties();
|
|
m_fireTemplateChange = true;
|
|
m_templateGUID = newTemplate.GUID;
|
|
m_templateName = newTemplate.DefaultShaderName;
|
|
FetchInfoFromTemplate();
|
|
}
|
|
|
|
void RegisterProperties()
|
|
{
|
|
if( m_currentTemplate != null )
|
|
{
|
|
m_reRegisterTemplateData = false;
|
|
// Register old template properties
|
|
int newPropertyCount = m_currentTemplate.AvailableShaderProperties.Count;
|
|
for( int i = 0; i < newPropertyCount; i++ )
|
|
{
|
|
int nodeId = UIUtils.CheckUniformNameOwner( m_currentTemplate.AvailableShaderProperties[ i ].PropertyName );
|
|
if( nodeId > -1 )
|
|
{
|
|
ParentNode node = m_containerGraph.GetNode( nodeId );
|
|
if( node != null )
|
|
{
|
|
UIUtils.ShowMessage( string.Format( "Template requires property name {0} which is currently being used by {1}. Please rename it and reload template.", m_currentTemplate.AvailableShaderProperties[ i ].PropertyName, node.Attributes.Name ) );
|
|
}
|
|
else
|
|
{
|
|
UIUtils.ShowMessage( string.Format( "Template requires property name {0} which is currently being on your graph. Please rename it and reload template.", m_currentTemplate.AvailableShaderProperties[ i ].PropertyName ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UIUtils.RegisterUniformName( UniqueId, m_currentTemplate.AvailableShaderProperties[ i ].PropertyName );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void DrawProperties()
|
|
{
|
|
if( m_currentTemplate == null )
|
|
return;
|
|
|
|
base.DrawProperties();
|
|
|
|
bool generalIsVisible = ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedGeneralShaderOptions;
|
|
NodeUtils.DrawPropertyGroup( ref generalIsVisible, GeneralFoldoutStr, DrawGeneralOptions );
|
|
ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedGeneralShaderOptions = generalIsVisible;
|
|
|
|
if( m_currentTemplate.AlphaToMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
m_alphaToMaskHelper.Draw( this );
|
|
|
|
if( m_currentTemplate.BlendData.DataCheck == TemplateDataCheck.Valid )
|
|
m_blendOpHelper.Draw( this );
|
|
|
|
|
|
if( m_currentTemplate.StencilData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
CullMode cullMode = ( m_currentTemplate.CullModeData.DataCheck == TemplateDataCheck.Valid ) ? m_cullModeHelper.CurrentCullMode : CullMode.Back;
|
|
m_stencilBufferHelper.Draw( this, cullMode );
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.DataCheck == TemplateDataCheck.Valid )
|
|
m_depthOphelper.Draw( this );
|
|
|
|
if( m_currentTemplate.TagData.DataCheck == TemplateDataCheck.Valid )
|
|
m_tagsHelper.Draw( this );
|
|
|
|
DrawMaterialInputs( UIUtils.MenuItemToolbarStyle );
|
|
|
|
// NodeUtils.DrawPropertyGroup( ref m_snippetsFoldout, SnippetsFoldoutStr, DrawSnippetOptions );
|
|
if( GUILayout.Button( OpenTemplateStr ) && m_currentTemplate != null )
|
|
{
|
|
try
|
|
{
|
|
string pathname = AssetDatabase.GUIDToAssetPath( m_currentTemplate.GUID );
|
|
if( !string.IsNullOrEmpty( pathname ) )
|
|
{
|
|
Shader selectedTemplate = AssetDatabase.LoadAssetAtPath<Shader>( pathname );
|
|
if( selectedTemplate != null )
|
|
{
|
|
AssetDatabase.OpenAsset( selectedTemplate, 1 );
|
|
}
|
|
}
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
Debug.LogException( e );
|
|
}
|
|
}
|
|
|
|
#if SHOW_TEMPLATE_HELP_BOX
|
|
EditorGUILayout.HelpBox( WarningMessage, MessageType.Warning );
|
|
#endif
|
|
|
|
}
|
|
|
|
public void DrawGeneralOptions()
|
|
{
|
|
DrawShaderName();
|
|
DrawCurrentShaderType();
|
|
EditorGUI.BeginChangeCheck();
|
|
DrawPrecisionProperty( false );
|
|
if( EditorGUI.EndChangeCheck() )
|
|
ContainerGraph.CurrentPrecision = m_currentPrecisionType;
|
|
|
|
DrawSamplingMacros();
|
|
|
|
if( m_currentTemplate.CullModeData.DataCheck == TemplateDataCheck.Valid )
|
|
m_cullModeHelper.Draw( this );
|
|
|
|
if( m_currentTemplate.ColorMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
m_colorMaskHelper.Draw( this );
|
|
}
|
|
|
|
//public void DrawSnippetOptions()
|
|
//{
|
|
// m_currentTemplate.DrawSnippetProperties( this );
|
|
//}
|
|
|
|
bool CreateInstructionsForList( ref List<InputPort> ports, ref string shaderBody, ref List<string> vertexInstructions, ref List<string> fragmentInstructions )
|
|
{
|
|
if( ports.Count == 0 )
|
|
return true;
|
|
|
|
bool isValid = true;
|
|
UIUtils.CurrentWindow.CurrentGraph.ResetNodesLocalVariables();
|
|
for( int i = 0; i < ports.Count; i++ )
|
|
{
|
|
TemplateInputData inputData = m_currentTemplate.InputDataFromId( ports[ i ].PortId );
|
|
if( ports[ i ].IsConnected )
|
|
{
|
|
m_currentDataCollector.ResetInstructions();
|
|
m_currentDataCollector.ResetVertexInstructions();
|
|
|
|
m_currentDataCollector.PortCategory = ports[ i ].Category;
|
|
string newPortInstruction = ports[ i ].GeneratePortInstructions( ref m_currentDataCollector );
|
|
|
|
|
|
if( m_currentDataCollector.DirtySpecialLocalVariables )
|
|
{
|
|
string cleanVariables = m_currentDataCollector.SpecialLocalVariables.Replace( "\t", string.Empty );
|
|
m_currentDataCollector.AddInstructions( cleanVariables, false );
|
|
m_currentDataCollector.ClearSpecialLocalVariables();
|
|
}
|
|
|
|
if( m_currentDataCollector.DirtyVertexVariables )
|
|
{
|
|
string cleanVariables = m_currentDataCollector.VertexLocalVariables.Replace( "\t", string.Empty );
|
|
m_currentDataCollector.AddVertexInstruction( cleanVariables, UniqueId, false );
|
|
m_currentDataCollector.ClearVertexLocalVariables();
|
|
}
|
|
|
|
// fill functions
|
|
for( int j = 0; j < m_currentDataCollector.InstructionsList.Count; j++ )
|
|
{
|
|
fragmentInstructions.Add( m_currentDataCollector.InstructionsList[ j ].PropertyName );
|
|
}
|
|
|
|
for( int j = 0; j < m_currentDataCollector.VertexDataList.Count; j++ )
|
|
{
|
|
vertexInstructions.Add( m_currentDataCollector.VertexDataList[ j ].PropertyName );
|
|
}
|
|
|
|
isValid = m_currentTemplate.FillTemplateBody( inputData.TagId, ref shaderBody, newPortInstruction ) && isValid;
|
|
}
|
|
else
|
|
{
|
|
isValid = m_currentTemplate.FillTemplateBody( inputData.TagId, ref shaderBody, inputData.DefaultValue ) && isValid;
|
|
}
|
|
}
|
|
return isValid;
|
|
}
|
|
|
|
public override void Draw( DrawInfo drawInfo )
|
|
{
|
|
base.Draw( drawInfo );
|
|
|
|
if( m_currentTemplate == null )
|
|
{
|
|
FetchCurrentTemplate();
|
|
}
|
|
|
|
if( m_reRegisterTemplateData )
|
|
{
|
|
RegisterProperties();
|
|
}
|
|
|
|
if( m_containerGraph.IsInstancedShader )
|
|
{
|
|
DrawInstancedIcon( drawInfo );
|
|
}
|
|
|
|
if( m_fetchMasterNodeCategory )
|
|
{
|
|
if( m_availableCategories != null )
|
|
{
|
|
m_fetchMasterNodeCategory = false;
|
|
SetCategoryIdxFromTemplate();
|
|
}
|
|
}
|
|
|
|
if( m_fireTemplateChange )
|
|
{
|
|
m_fireTemplateChange = false;
|
|
m_containerGraph.FireMasterNodeReplacedEvent();
|
|
}
|
|
}
|
|
|
|
public override void UpdateFromShader( Shader newShader )
|
|
{
|
|
if( m_currentMaterial != null )
|
|
{
|
|
m_currentMaterial.shader = newShader;
|
|
}
|
|
CurrentShader = newShader;
|
|
}
|
|
|
|
public override void UpdateMasterNodeMaterial( Material material )
|
|
{
|
|
m_currentMaterial = material;
|
|
FireMaterialChangedEvt();
|
|
}
|
|
|
|
public override Shader Execute( string pathname, bool isFullPath )
|
|
{
|
|
if( m_currentTemplate == null )
|
|
return m_currentShader;
|
|
|
|
//Create data collector
|
|
ForceReordering();
|
|
base.Execute( pathname, isFullPath );
|
|
|
|
SetupNodeCategories();
|
|
|
|
m_currentDataCollector.TemplateDataCollectorInstance.BuildFromTemplateData( m_currentDataCollector, m_currentTemplate );
|
|
int shaderPropertiesAmount = m_currentTemplate.AvailableShaderProperties.Count;
|
|
for( int i = 0; i < shaderPropertiesAmount; i++ )
|
|
{
|
|
m_currentDataCollector.SoftRegisterUniform( m_currentTemplate.AvailableShaderProperties[ i ] );
|
|
}
|
|
m_containerGraph.CheckPropertiesAutoRegister( ref m_currentDataCollector );
|
|
|
|
//Sort ports by both
|
|
List<InputPort> fragmentPorts = new List<InputPort>();
|
|
List<InputPort> vertexPorts = new List<InputPort>();
|
|
SortInputPorts( ref vertexPorts, ref fragmentPorts );
|
|
|
|
string shaderBody = m_currentTemplate.TemplateBody;
|
|
|
|
List<string> vertexInstructions = new List<string>();
|
|
List<string> fragmentInstructions = new List<string>();
|
|
|
|
bool validBody = true;
|
|
|
|
validBody = CreateInstructionsForList( ref fragmentPorts, ref shaderBody, ref vertexInstructions, ref fragmentInstructions ) && validBody;
|
|
ContainerGraph.ResetNodesLocalVariablesIfNot( MasterNodePortCategory.Vertex );
|
|
validBody = CreateInstructionsForList( ref vertexPorts, ref shaderBody, ref vertexInstructions, ref fragmentInstructions ) && validBody;
|
|
|
|
m_currentTemplate.ResetTemplateUsageData();
|
|
|
|
// Fill vertex interpolators assignment
|
|
for( int i = 0; i < m_currentDataCollector.VertexInterpDeclList.Count; i++ )
|
|
{
|
|
vertexInstructions.Add( m_currentDataCollector.VertexInterpDeclList[ i ] );
|
|
}
|
|
|
|
vertexInstructions.AddRange( m_currentDataCollector.TemplateDataCollectorInstance.GetInterpUnusedChannels() );
|
|
//Fill common local variables and operations
|
|
|
|
validBody = m_currentTemplate.FillVertexInstructions( ref shaderBody, vertexInstructions.ToArray() ) && validBody;
|
|
validBody = m_currentTemplate.FillFragmentInstructions( ref shaderBody, fragmentInstructions.ToArray() ) && validBody;
|
|
|
|
// Add Instanced Properties
|
|
if( m_containerGraph.IsInstancedShader )
|
|
{
|
|
m_currentDataCollector.TabifyInstancedVars();
|
|
m_currentDataCollector.InstancedPropertiesList.Insert( 0, new PropertyDataCollector( -1, string.Format( IOUtils.InstancedPropertiesBegin, UIUtils.RemoveInvalidCharacters( m_shaderName ) ) ) );
|
|
m_currentDataCollector.InstancedPropertiesList.Add( new PropertyDataCollector( -1, IOUtils.InstancedPropertiesEnd ) );
|
|
m_currentDataCollector.UniformsList.AddRange( m_currentDataCollector.InstancedPropertiesList );
|
|
}
|
|
|
|
//Add Functions
|
|
m_currentDataCollector.UniformsList.AddRange( m_currentDataCollector.FunctionsList );
|
|
|
|
// Fill common tags
|
|
m_currentDataCollector.IncludesList.AddRange( m_currentDataCollector.PragmasList );
|
|
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.ShaderNameId, ref shaderBody, string.Format( TemplatesManager.NameFormatter, m_shaderName ) ) && validBody;
|
|
validBody = m_currentTemplate.FillTemplateBody( TemplatesManager.TemplatePassTag, ref shaderBody, m_currentDataCollector.GrabPassList ) && validBody;
|
|
validBody = m_currentTemplate.FillTemplateBody( TemplatesManager.TemplatePragmaTag, ref shaderBody, m_currentDataCollector.IncludesList ) && validBody;
|
|
//validBody = m_currentTemplate.FillTemplateBody( TemplatesManager.TemplateTagsTag, ref shaderBody, m_currentDataCollector.TagsList ) && validBody;
|
|
validBody = m_currentTemplate.FillTemplateBody( TemplatesManager.TemplatePropertyTag, ref shaderBody, m_currentDataCollector.BuildUnformatedPropertiesStringArr() ) && validBody;
|
|
validBody = m_currentTemplate.FillTemplateBody( TemplatesManager.TemplateGlobalsTag, ref shaderBody, m_currentDataCollector.UniformsList ) && validBody;
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.VertexDataId, ref shaderBody, m_currentDataCollector.VertexInputList.ToArray() ) && validBody;
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.InterpDataId, ref shaderBody, m_currentDataCollector.InterpolatorList.ToArray() ) && validBody;
|
|
|
|
if( m_currentTemplate.BlendData.ValidBlendMode )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.BlendData.BlendModeId, ref shaderBody, m_blendOpHelper.CurrentBlendFactor ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.BlendData.ValidBlendOp )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.BlendData.BlendOpId, ref shaderBody, m_blendOpHelper.CurrentBlendOp ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.AlphaToMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.AlphaToMaskData.AlphaToMaskId, ref shaderBody, m_alphaToMaskHelper.GenerateShaderData( false ) ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.ValidZWrite )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.DepthData.ZWriteModeId, ref shaderBody, m_depthOphelper.CurrentZWriteMode ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.ValidZTest )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.DepthData.ZTestModeId, ref shaderBody, m_depthOphelper.CurrentZTestMode ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.ValidOffset )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.DepthData.OffsetId, ref shaderBody, m_depthOphelper.CurrentOffset ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.CullModeData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.CullModeData.CullModeId, ref shaderBody, m_cullModeHelper.GenerateShaderData(false) ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.ColorMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.ColorMaskData.ColorMaskId, ref shaderBody, m_colorMaskHelper.GenerateShaderData( false ) ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.StencilData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
CullMode cullMode = ( m_currentTemplate.CullModeData.DataCheck == TemplateDataCheck.Valid ) ? m_cullModeHelper.CurrentCullMode : CullMode.Back;
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.StencilData.StencilBufferId, ref shaderBody, m_stencilBufferHelper.CreateStencilOp( cullMode ) ) && validBody;
|
|
}
|
|
|
|
if( m_currentTemplate.TagData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( m_currentTemplate.TagData.TagsId, ref shaderBody, m_tagsHelper.GenerateTags() ) && validBody;
|
|
}
|
|
|
|
if( m_currentDataCollector.TemplateDataCollectorInstance.HasVertexInputParams )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( TemplatesManager.TemplateInputsVertParamsTag, ref shaderBody, m_currentDataCollector.TemplateDataCollectorInstance.VertexInputParamsStr ) && validBody;
|
|
}
|
|
|
|
if( m_currentDataCollector.TemplateDataCollectorInstance.HasFragmentInputParams )
|
|
{
|
|
validBody = m_currentTemplate.FillTemplateBody( TemplatesManager.TemplateInputsFragParamsTag, ref shaderBody, m_currentDataCollector.TemplateDataCollectorInstance.FragInputParamsStr ) && validBody;
|
|
}
|
|
|
|
m_currentTemplate.FillEmptyTags( ref shaderBody );
|
|
|
|
//m_currentTemplate.InsertSnippets( ref shaderBody );
|
|
|
|
vertexInstructions.Clear();
|
|
vertexInstructions = null;
|
|
|
|
fragmentInstructions.Clear();
|
|
fragmentInstructions = null;
|
|
if( validBody )
|
|
{
|
|
UpdateShaderAsset( ref pathname, ref shaderBody, isFullPath );
|
|
}
|
|
|
|
return m_currentShader;
|
|
}
|
|
|
|
public override void ReadFromString( ref string[] nodeParams )
|
|
{
|
|
base.ReadFromString( ref nodeParams );
|
|
try
|
|
{
|
|
ShaderName = GetCurrentParam( ref nodeParams );
|
|
if( m_shaderName.Length > 0 )
|
|
ShaderName = UIUtils.RemoveShaderInvalidCharacters( ShaderName );
|
|
|
|
string templateGUID = GetCurrentParam( ref nodeParams );
|
|
string templateShaderName = string.Empty;
|
|
if( UIUtils.CurrentShaderVersion() > 13601 )
|
|
{
|
|
templateShaderName = GetCurrentParam( ref nodeParams );
|
|
}
|
|
|
|
TemplateData template = m_containerGraph.ParentWindow.TemplatesManagerInstance.GetTemplate( templateGUID ) as TemplateData;
|
|
if( template != null )
|
|
{
|
|
SetTemplate( template, false, true );
|
|
}
|
|
else
|
|
{
|
|
template = m_containerGraph.ParentWindow.TemplatesManagerInstance.GetTemplateByName( templateShaderName ) as TemplateData;
|
|
if( template != null )
|
|
{
|
|
SetTemplate( template, false, true );
|
|
}
|
|
else
|
|
{
|
|
m_masterNodeCategory = -1;
|
|
}
|
|
}
|
|
|
|
if( UIUtils.CurrentShaderVersion() > 13902 )
|
|
{
|
|
//BLEND MODULE
|
|
if( m_currentTemplate.BlendData.ValidBlendMode )
|
|
{
|
|
m_blendOpHelper.ReadBlendModeFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
|
|
if( m_currentTemplate.BlendData.ValidBlendOp )
|
|
{
|
|
m_blendOpHelper.ReadBlendOpFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
|
|
//CULL MODE
|
|
if( m_currentTemplate.CullModeData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
m_cullModeHelper.ReadFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
|
|
//COLOR MASK
|
|
if( m_currentTemplate.ColorMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
m_colorMaskHelper.ReadFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
|
|
//STENCIL BUFFER
|
|
if( m_currentTemplate.StencilData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
m_stencilBufferHelper.ReadFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
}
|
|
|
|
if( UIUtils.CurrentShaderVersion() > 14202 )
|
|
{
|
|
//DEPTH OPTIONS
|
|
if( m_currentTemplate.DepthData.ValidZWrite )
|
|
{
|
|
m_depthOphelper.ReadZWriteFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.ValidZTest )
|
|
{
|
|
m_depthOphelper.ReadZTestFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.ValidOffset )
|
|
{
|
|
m_depthOphelper.ReadOffsetFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
}
|
|
|
|
//TAGS
|
|
if( UIUtils.CurrentShaderVersion() > 14301 )
|
|
{
|
|
if( m_currentTemplate.TagData.DataCheck == TemplateDataCheck.Valid )
|
|
m_tagsHelper.ReadFromString( ref m_currentReadParamIdx, ref nodeParams );
|
|
}
|
|
|
|
if( UIUtils.CurrentShaderVersion() > 18302 )
|
|
SamplingMacros = Convert.ToBoolean( GetCurrentParam( ref nodeParams ) );
|
|
else
|
|
SamplingMacros = false;
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
Debug.LogException( e, this );
|
|
}
|
|
m_containerGraph.CurrentCanvasMode = NodeAvailability.TemplateShader;
|
|
m_containerGraph.CurrentPrecision = m_currentPrecisionType;
|
|
}
|
|
|
|
public override void WriteToString( ref string nodeInfo, ref string connectionsInfo )
|
|
{
|
|
base.WriteToString( ref nodeInfo, ref connectionsInfo );
|
|
IOUtils.AddFieldValueToString( ref nodeInfo, m_shaderName );
|
|
IOUtils.AddFieldValueToString( ref nodeInfo, ( m_currentTemplate != null ) ? m_currentTemplate.GUID : string.Empty );
|
|
IOUtils.AddFieldValueToString( ref nodeInfo, ( m_currentTemplate != null ) ? m_currentTemplate.DefaultShaderName : string.Empty );
|
|
|
|
//BLEND MODULE
|
|
if( m_currentTemplate.BlendData.ValidBlendMode )
|
|
{
|
|
m_blendOpHelper.WriteBlendModeToString( ref nodeInfo );
|
|
}
|
|
|
|
if( m_currentTemplate.BlendData.ValidBlendOp )
|
|
{
|
|
m_blendOpHelper.WriteBlendOpToString( ref nodeInfo );
|
|
}
|
|
|
|
//CULL MODULE
|
|
if( m_currentTemplate.CullModeData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
m_cullModeHelper.WriteToString( ref nodeInfo );
|
|
}
|
|
|
|
//COLOR MASK MODULE
|
|
if( m_currentTemplate.ColorMaskData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
m_colorMaskHelper.WriteToString( ref nodeInfo );
|
|
}
|
|
|
|
//STENCIL BUFFER MODULE
|
|
if( m_currentTemplate.StencilData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
m_stencilBufferHelper.WriteToString( ref nodeInfo );
|
|
}
|
|
|
|
//DEPTH MODULE
|
|
if( m_currentTemplate.DepthData.ValidZWrite )
|
|
{
|
|
m_depthOphelper.WriteZWriteToString( ref nodeInfo );
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.ValidZTest )
|
|
{
|
|
m_depthOphelper.WriteZTestToString( ref nodeInfo );
|
|
}
|
|
|
|
if( m_currentTemplate.DepthData.ValidOffset )
|
|
{
|
|
m_depthOphelper.WriteOffsetToString( ref nodeInfo );
|
|
}
|
|
|
|
//TAGS
|
|
if( m_currentTemplate.TagData.DataCheck == TemplateDataCheck.Valid )
|
|
{
|
|
m_tagsHelper.WriteToString( ref nodeInfo );
|
|
}
|
|
|
|
IOUtils.AddFieldValueToString( ref nodeInfo, m_samplingMacros );
|
|
}
|
|
|
|
public override void Destroy()
|
|
{
|
|
base.Destroy();
|
|
m_currentTemplate = null;
|
|
m_blendOpHelper = null;
|
|
m_alphaToMaskHelper = null;
|
|
m_cullModeHelper = null;
|
|
m_colorMaskHelper.Destroy();
|
|
m_colorMaskHelper = null;
|
|
m_stencilBufferHelper.Destroy();
|
|
m_stencilBufferHelper = null;
|
|
m_tagsHelper.Destroy();
|
|
m_tagsHelper = null;
|
|
|
|
}
|
|
|
|
public TemplateData CurrentTemplate { get { return m_currentTemplate; } }
|
|
}
|
|
}
|