public override void RefreshAvailableCategories()
{
FetchCurrentTemplate();
int templateCount = TemplatesManager.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 Shader");
if (m_currentTemplate == null)
{
m_masterNodeCategory = -1;
}
for (int i = 0; i < templateCount; i++)
{
int idx = i + 1;
TemplateData templateData = TemplatesManager.GetTemplate(i);
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);
}
}
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 templateName = GetCurrentParam(ref nodeParams);
TemplateData template = TemplatesManager.GetTemplate(templateName);
if (template != null)
{
SetTemplate(template, false, true);
}
else
{
m_masterNodeCategory = -1;
}
}
catch (Exception e)
{
Debug.LogException(e, this);
}
m_containerGraph.CurrentCanvasMode = NodeAvailability.TemplateShader;
}
void FetchCurrentTemplate()
{
m_currentTemplate = TemplatesManager.GetTemplate(m_templateGUID);
if (m_currentTemplate == null)
{
m_currentTemplate = TemplatesManager.GetTemplate(m_templateName);
}
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 static void Destroy()
{
if (DummyManager != null)
{
DummyManager.Destroy();
ScriptableObject.DestroyImmediate(DummyManager);
DummyManager = null;
}
}
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 = TemplatesManager.GetTemplate(templateGUID);
if (template != null)
{
SetTemplate(template, false, true);
}
else
{
template = TemplatesManager.GetTemplateByName(templateShaderName);
if (template != null)
{
SetTemplate(template, false, true);
}
else
{
m_masterNodeCategory = -1;
}
}
////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 );
//}
}
catch (Exception e)
{
Debug.LogException(e, this);
}
m_containerGraph.CurrentCanvasMode = NodeAvailability.TemplateShader;
}
void SetCategoryIdxFromTemplate()
{
int templateCount = TemplatesManager.TemplateCount;
for (int i = 0; i < templateCount; i++)
{
int idx = i + 1;
TemplateData templateData = TemplatesManager.GetTemplate(i);
if (templateData != null && m_currentTemplate != null && m_currentTemplate.GUID.Equals(templateData.GUID))
{
m_masterNodeCategory = idx;
}
}
}
void InitAvailableCategories()
{
int templateCount = TemplatesManager.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 Shader");
for (int i = 0; i < templateCount; i++)
{
int idx = i + 1;
TemplateData templateData = TemplatesManager.GetTemplate(i);
m_availableCategories[idx] = new MasterNodeCategoriesData(AvailableShaderTypes.Template, templateData.GUID);
m_availableCategoryLabels[idx] = new GUIContent(templateData.Name);
}
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
if (!TemplatesManager.Initialized)
{
TemplatesManager.Init();
}
bool markForRefresh = false;
for (int i = 0; i < importedAssets.Length; i++)
{
if (TemplateHelperFunctions.CheckIfTemplate(importedAssets[i]))
{
markForRefresh = true;
break;
}
}
if (deletedAssets.Length > 0)
{
if (deletedAssets[0].IndexOf(Constants.InvalidPostProcessDatapath) < 0)
{
for (int i = 0; i < deletedAssets.Length; i++)
{
string guid = AssetDatabase.AssetPathToGUID(deletedAssets[i]);
TemplateData templateData = TemplatesManager.GetTemplate(guid);
if (templateData != null)
{
// Close any window using that template
int windowCount = IOUtils.AllOpenedWindows.Count;
for (int windowIdx = 0; windowIdx < windowCount; windowIdx++)
{
TemplateMasterNode masterNode = IOUtils.AllOpenedWindows[windowIdx].CurrentGraph.CurrentMasterNode as TemplateMasterNode;
if (masterNode != null && masterNode.CurrentTemplate.GUID.Equals(templateData.GUID))
{
IOUtils.AllOpenedWindows[windowIdx].Close();
}
}
TemplatesManager.RemoveTemplate(templateData);
markForRefresh = true;
}
}
}
}
for (int i = 0; i < movedAssets.Length; i++)
{
if (TemplateHelperFunctions.CheckIfTemplate(movedAssets[i]))
{
markForRefresh = true;
break;
}
}
for (int i = 0; i < movedFromAssetPaths.Length; i++)
{
if (TemplateHelperFunctions.CheckIfTemplate(movedFromAssetPaths[i]))
{
markForRefresh = true;
break;
}
}
if (markForRefresh)
{
TemplatesManager.CreateTemplateMenuItems();
int windowCount = IOUtils.AllOpenedWindows.Count;
for (int windowIdx = 0; windowIdx < windowCount; windowIdx++)
{
IOUtils.AllOpenedWindows[windowIdx].CurrentGraph.ForceCategoryRefresh();
}
}
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
TemplatesManager templatesManager;
bool firstTimeDummyFlag = false;
if (UIUtils.CurrentWindow == null)
{
if (DummyManager == null)
{
DummyManager = ScriptableObject.CreateInstance <TemplatesManager>();
DummyManager.hideFlags = HideFlags.HideAndDontSave;
firstTimeDummyFlag = true;
}
templatesManager = DummyManager;
}
else
{
Destroy();
templatesManager = UIUtils.CurrentWindow.TemplatesManagerInstance;
}
if (templatesManager == null)
{
return;
}
if (!templatesManager.Initialized)
{
templatesManager.Init();
}
bool refreshMenuItems = false;
for (int i = 0; i < importedAssets.Length; i++)
{
if (TemplateHelperFunctions.CheckIfTemplate(importedAssets[i]))
{
string guid = AssetDatabase.AssetPathToGUID(importedAssets[i]);
TemplateDataParent templateData = templatesManager.GetTemplate(guid);
if (templateData != null)
{
refreshMenuItems = templateData.Reload() || refreshMenuItems || firstTimeDummyFlag;
int windowCount = IOUtils.AllOpenedWindows.Count;
AmplifyShaderEditorWindow currWindow = UIUtils.CurrentWindow;
for (int windowIdx = 0; windowIdx < windowCount; windowIdx++)
{
if (IOUtils.AllOpenedWindows[windowIdx].OutsideGraph.CurrentCanvasMode == NodeAvailability.TemplateShader)
{
if (IOUtils.AllOpenedWindows[windowIdx].OutsideGraph.MultiPassMasterNodes.NodesList[0].CurrentTemplate == templateData)
{
UIUtils.CurrentWindow = IOUtils.AllOpenedWindows[windowIdx];
IOUtils.AllOpenedWindows[windowIdx].OutsideGraph.ForceMultiPassMasterNodesRefresh();
}
}
}
UIUtils.CurrentWindow = currWindow;
}
else
{
refreshMenuItems = true;
string name = TemplatesManager.OfficialTemplates.ContainsKey(guid) ? TemplatesManager.OfficialTemplates[guid] : string.Empty;
TemplateMultiPass mp = TemplateMultiPass.CreateInstance <TemplateMultiPass>();
mp.Init(name, guid, true);
templatesManager.AddTemplate(mp);
}
}
}
if (deletedAssets.Length > 0)
{
if (deletedAssets[0].IndexOf(Constants.InvalidPostProcessDatapath) < 0)
{
for (int i = 0; i < deletedAssets.Length; i++)
{
string guid = AssetDatabase.AssetPathToGUID(deletedAssets[i]);
TemplateDataParent templateData = templatesManager.GetTemplate(guid);
if (templateData != null)
{
// Close any window using that template
int windowCount = IOUtils.AllOpenedWindows.Count;
for (int windowIdx = 0; windowIdx < windowCount; windowIdx++)
{
TemplateMasterNode masterNode = IOUtils.AllOpenedWindows[windowIdx].CurrentGraph.CurrentMasterNode as TemplateMasterNode;
if (masterNode != null && masterNode.CurrentTemplate.GUID.Equals(templateData.GUID))
{
IOUtils.AllOpenedWindows[windowIdx].Close();
}
}
templatesManager.RemoveTemplate(templateData);
refreshMenuItems = true;
}
}
}
}
//for ( int i = 0; i < movedAssets.Length; i++ )
//{
// if ( TemplateHelperFunctions.CheckIfTemplate( movedAssets[ i ] ) )
// {
// refreshMenuItems = true;
// break;
// }
//}
//for ( int i = 0; i < movedFromAssetPaths.Length; i++ )
//{
// if ( TemplateHelperFunctions.CheckIfTemplate( movedFromAssetPaths[ i ] ) )
// {
// refreshMenuItems = true;
// break;
// }
//}
if (refreshMenuItems)
{
//UnityEngine.Debug.Log( "Refresh Menu Items" );
refreshMenuItems = false;
templatesManager.CreateTemplateMenuItems();
AmplifyShaderEditorWindow currWindow = UIUtils.CurrentWindow;
int windowCount = IOUtils.AllOpenedWindows.Count;
for (int windowIdx = 0; windowIdx < windowCount; windowIdx++)
{
UIUtils.CurrentWindow = IOUtils.AllOpenedWindows[windowIdx];
IOUtils.AllOpenedWindows[windowIdx].CurrentGraph.ForceCategoryRefresh();
}
UIUtils.CurrentWindow = currWindow;
}
}
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 = TemplatesManager.GetTemplate(templateGUID);
if (template != null)
{
SetTemplate(template, false, true);
}
else
{
template = TemplatesManager.GetTemplateByName(templateShaderName);
if (template != null)
{
SetTemplate(template, false, true);
}
else
{
m_masterNodeCategory = -1;
}
}
#if TEMPLATE_MODULES
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);
}
}
#endif
}
catch (Exception e)
{
Debug.LogException(e, this);
}
m_containerGraph.CurrentCanvasMode = NodeAvailability.TemplateShader;
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
if (UIUtils.CurrentWindow == null)
{
return;
}
TemplatesManager templatesManager = UIUtils.CurrentWindow.TemplatesManagerInstance;
if (templatesManager == null)
{
return;
}
if (!templatesManager.Initialized)
{
templatesManager.Init();
}
bool refreshMenuItems = false;
for (int i = 0; i < importedAssets.Length; i++)
{
if (TemplateHelperFunctions.CheckIfTemplate(importedAssets[i]))
{
string guid = AssetDatabase.AssetPathToGUID(importedAssets[i]);
TemplateDataParent templateData = templatesManager.GetTemplate(guid);
if (templateData != null)
{
refreshMenuItems = templateData.Reload() || refreshMenuItems;
}
else
{
refreshMenuItems = true;
string name = TemplatesManager.OfficialTemplates.ContainsKey(guid) ? TemplatesManager.OfficialTemplates[guid] : string.Empty;
TemplateMultiPass mp = TemplateMultiPass.CreateInstance <TemplateMultiPass>();
mp.Init(name, guid, true);
templatesManager.AddTemplate(mp);
}
}
}
if (deletedAssets.Length > 0)
{
if (deletedAssets[0].IndexOf(Constants.InvalidPostProcessDatapath) < 0)
{
for (int i = 0; i < deletedAssets.Length; i++)
{
string guid = AssetDatabase.AssetPathToGUID(deletedAssets[i]);
TemplateDataParent templateData = templatesManager.GetTemplate(guid);
if (templateData != null)
{
// Close any window using that template
int windowCount = IOUtils.AllOpenedWindows.Count;
for (int windowIdx = 0; windowIdx < windowCount; windowIdx++)
{
TemplateMasterNode masterNode = IOUtils.AllOpenedWindows[windowIdx].CurrentGraph.CurrentMasterNode as TemplateMasterNode;
if (masterNode != null && masterNode.CurrentTemplate.GUID.Equals(templateData.GUID))
{
IOUtils.AllOpenedWindows[windowIdx].Close();
}
}
templatesManager.RemoveTemplate(templateData);
refreshMenuItems = true;
}
}
}
}
//for ( int i = 0; i < movedAssets.Length; i++ )
//{
// if ( TemplateHelperFunctions.CheckIfTemplate( movedAssets[ i ] ) )
// {
// refreshMenuItems = true;
// break;
// }
//}
//for ( int i = 0; i < movedFromAssetPaths.Length; i++ )
//{
// if ( TemplateHelperFunctions.CheckIfTemplate( movedFromAssetPaths[ i ] ) )
// {
// refreshMenuItems = true;
// break;
// }
//}
if (refreshMenuItems)
{
//UnityEngine.Debug.Log( "Refresh Menu Items" );
refreshMenuItems = false;
templatesManager.CreateTemplateMenuItems();
int windowCount = IOUtils.AllOpenedWindows.Count;
for (int windowIdx = 0; windowIdx < windowCount; windowIdx++)
{
IOUtils.AllOpenedWindows[windowIdx].CurrentGraph.ForceCategoryRefresh();
}
}
}
public static void CreateTemplateMenuItems()
{
TemplatesManager.CreateTemplateMenuItems();
}
public override void ReadFromDeprecated(ref string[] nodeParams, Type oldType = null)
{
base.ReadFromString(ref nodeParams);
try
{
string currShaderName = GetCurrentParam(ref nodeParams);
if (currShaderName.Length > 0)
{
currShaderName = UIUtils.RemoveShaderInvalidCharacters(currShaderName);
}
string templateGUID = GetCurrentParam(ref nodeParams);
string templateShaderName = string.Empty;
if (UIUtils.CurrentShaderVersion() > 13601)
{
templateShaderName = GetCurrentParam(ref nodeParams);
}
TemplateMultiPass template = TemplatesManager.GetTemplate(templateGUID) as TemplateMultiPass;
if (template != null)
{
m_templateGUID = templateGUID;
SetTemplate(null, false, true, 0, 0);
}
else
{
template = TemplatesManager.GetTemplateByName(templateShaderName) as TemplateMultiPass;
if (template != null)
{
m_templateGUID = template.GUID;
SetTemplate(null, false, true, 0, 0);
}
else
{
m_masterNodeCategory = -1;
}
}
// only in here, after SetTemplate, we know if shader name is to be used as title or not
ShaderName = currShaderName;
if (UIUtils.CurrentShaderVersion() > 13902)
{
//BLEND MODULE
if (m_templateMultiPass.SubShaders[0].Modules.BlendData.ValidBlendMode)
{
m_subShaderModule.BlendOpHelper.ReadBlendModeFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.BlendData.ValidBlendMode)
{
m_passModule.BlendOpHelper.ReadBlendModeFromString(ref m_currentReadParamIdx, ref nodeParams);
}
if (m_templateMultiPass.SubShaders[0].Modules.BlendData.ValidBlendOp)
{
m_subShaderModule.BlendOpHelper.ReadBlendOpFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.BlendData.ValidBlendOp)
{
m_passModule.BlendOpHelper.ReadBlendOpFromString(ref m_currentReadParamIdx, ref nodeParams);
}
//CULL MODE
if (m_templateMultiPass.SubShaders[0].Modules.CullModeData.DataCheck == TemplateDataCheck.Valid)
{
m_subShaderModule.CullModeHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.CullModeData.DataCheck == TemplateDataCheck.Valid)
{
m_passModule.CullModeHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
//COLOR MASK
if (m_templateMultiPass.SubShaders[0].Modules.ColorMaskData.DataCheck == TemplateDataCheck.Valid)
{
m_subShaderModule.ColorMaskHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.ColorMaskData.DataCheck == TemplateDataCheck.Valid)
{
m_passModule.ColorMaskHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
//STENCIL BUFFER
if (m_templateMultiPass.SubShaders[0].Modules.StencilData.DataCheck == TemplateDataCheck.Valid)
{
m_subShaderModule.StencilBufferHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.StencilData.DataCheck == TemplateDataCheck.Valid)
{
m_passModule.StencilBufferHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
}
if (UIUtils.CurrentShaderVersion() > 14202)
{
//DEPTH OPTIONS
if (m_templateMultiPass.SubShaders[0].Modules.DepthData.ValidZWrite)
{
m_subShaderModule.DepthOphelper.ReadZWriteFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.DepthData.ValidZWrite)
{
m_passModule.DepthOphelper.ReadZWriteFromString(ref m_currentReadParamIdx, ref nodeParams);
}
if (m_templateMultiPass.SubShaders[0].Modules.DepthData.ValidZTest)
{
m_subShaderModule.DepthOphelper.ReadZTestFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.DepthData.ValidZTest)
{
m_subShaderModule.DepthOphelper.ReadZTestFromString(ref m_currentReadParamIdx, ref nodeParams);
}
if (m_templateMultiPass.SubShaders[0].Modules.DepthData.ValidOffset)
{
m_subShaderModule.DepthOphelper.ReadOffsetFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.DepthData.ValidOffset)
{
m_passModule.DepthOphelper.ReadOffsetFromString(ref m_currentReadParamIdx, ref nodeParams);
}
}
//TAGS
if (UIUtils.CurrentShaderVersion() > 14301)
{
if (m_templateMultiPass.SubShaders[0].Modules.TagData.DataCheck == TemplateDataCheck.Valid)
{
m_subShaderModule.TagsHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
else if (m_templateMultiPass.SubShaders[0].Passes[0].Modules.TagData.DataCheck == TemplateDataCheck.Valid)
{
m_passModule.TagsHelper.ReadFromString(ref m_currentReadParamIdx, ref nodeParams);
}
}
}
catch (Exception e)
{
Debug.LogException(e, this);
}
m_containerGraph.CurrentCanvasMode = NodeAvailability.TemplateShader;
}
public void SetTemplate(TemplateMultiPass template, bool writeDefaultData, bool fetchMasterNodeCategory, int subShaderIdx, int passIdx)
{
if (subShaderIdx > -1)
{
m_subShaderIdx = subShaderIdx;
}
if (passIdx > -1)
{
m_passIdx = passIdx;
}
ReleaseResources();
m_templateMultiPass = (template == null) ? TemplatesManager.GetTemplate(m_templateGUID) as TemplateMultiPass : template;
if (m_templateMultiPass != null)
{
if (m_subShaderIdx >= m_templateMultiPass.SubShaders.Count ||
m_passIdx >= m_templateMultiPass.SubShaders[m_subShaderIdx].Passes.Count)
{
if (DebugConsoleWindow.DeveloperMode)
{
Debug.LogFormat("Inexisting pass {0}. Cancelling template fetch", m_originalPassName);
}
return;
}
m_isMainOutputNode = m_templateMultiPass.SubShaders[m_subShaderIdx].Passes[m_passIdx].IsMainPass;
if (m_isMainOutputNode)
{
// We cannot use UIUtils.MasterNodeOnTexture.height since this method can be
// called before UIUtils is initialized
m_insideSize.y = 55;
}
else
{
m_insideSize.y = 0;
}
//IsMainOutputNode = m_mainMPMasterNode;
m_isInvisible = m_templateMultiPass.SubShaders[m_subShaderIdx].Passes[m_passIdx].IsInvisible;
m_originalPassName = m_templateMultiPass.SubShaders[m_subShaderIdx].Passes[m_passIdx].PassNameContainer.Data;
m_shaderNameIsTitle = (m_templateMultiPass.SubShaders[m_subShaderIdx].Passes.Count == 1);
if (m_templateMultiPass.SubShaders[m_subShaderIdx].LODContainer.Index > -1)
{
m_subShaderLODStr = m_templateMultiPass.SubShaders[m_subShaderIdx].LODContainer.Id;
m_subShaderLOD = Convert.ToInt32(m_templateMultiPass.SubShaders[m_subShaderIdx].LODContainer.Data);
}
else
{
m_subShaderLOD = -1;
}
m_fetchMasterNodeCategory = fetchMasterNodeCategory;
m_templateGUID = m_templateMultiPass.GUID;
UpdatePortInfo();
//bool updateInfofromTemplate = UpdatePortInfo();
//if( updateInfofromTemplate )
//{
m_subShaderModule.FetchDataFromTemplate(m_templateMultiPass.SubShaders[m_subShaderIdx].Modules);
m_passModule.FetchDataFromTemplate(m_templateMultiPass.SubShaders[m_subShaderIdx].Passes[m_passIdx].Modules);
//}
RegisterProperties();
if (writeDefaultData)
{
ShaderName = m_templateMultiPass.DefaultShaderName;
m_passName = m_templateMultiPass.SubShaders[m_subShaderIdx].Passes[m_passIdx].PassNameContainer.Data;
if (!m_templateMultiPass.IsSinglePass && !m_shaderNameIsTitle)
{
SetClippedTitle(m_passName);
}
}
UpdateSubShaderPassStr();
if (m_isMainOutputNode)
{
m_fireTemplateChange = true;
}
}
}
