public void SyncWith(TemplateModulesHelper other)
{
if (m_blendOpHelper.ValidData && other.BlendOpHelper.ValidData)
{
m_blendOpHelper.CopyFrom(other.BlendOpHelper, false);
}
if (m_cullModeHelper.ValidData && other.CullModeHelper.ValidData)
{
m_cullModeHelper.CopyFrom(other.CullModeHelper, false);
}
if (m_colorMaskHelper.ValidData && other.ColorMaskHelper.ValidData)
{
m_colorMaskHelper.CopyFrom(other.ColorMaskHelper, false);
}
if (m_stencilBufferHelper.ValidData && other.StencilBufferHelper.ValidData)
{
m_stencilBufferHelper.CopyFrom(other.StencilBufferHelper, false);
}
if (m_depthOphelper.ValidData && other.DepthOphelper.ValidData)
{
m_depthOphelper.CopyFrom(other.DepthOphelper, false);
}
if (m_shaderModelHelper.ValidData && other.ShaderModelHelper.ValidData)
{
m_shaderModelHelper.CopyFrom(other.ShaderModelHelper, false);
}
}
public override void Destroy()
{
base.Destroy();
m_subShaderModule.Destroy();
m_subShaderModule = null;
m_passModule.Destroy();
m_passModule = null;
m_containerGraph.MultiPassMasterNodes.RemoveNode(this);
}
public void CopyFrom(TemplateModulesHelper other)
{
m_allModulesMode = other.AllModulesMode;
if (other.BlendOpHelper.IsDirty)
{
m_blendOpHelper.CopyFrom(other.BlendOpHelper, true);
}
if (other.CullModeHelper.IsDirty)
{
m_cullModeHelper.CopyFrom(other.CullModeHelper, true);
}
if (other.ColorMaskHelper.IsDirty)
{
m_colorMaskHelper.CopyFrom(other.ColorMaskHelper, true);
}
if (other.StencilBufferHelper.IsDirty)
{
m_stencilBufferHelper.CopyFrom(other.StencilBufferHelper, true);
}
if (other.DepthOphelper.IsDirty)
{
m_depthOphelper.CopyFrom(other.DepthOphelper, true);
}
if (other.TagsHelper.IsDirty)
{
m_tagsHelper.CopyFrom(other.TagsHelper);
}
if (other.ShaderModelHelper.IsDirty)
{
m_shaderModelHelper.CopyFrom(other.ShaderModelHelper, true);
}
}
public void Draw(ParentNode owner, TemplateModulesData currentModule, TemplateModulesHelper parent = null)
{
if (currentModule.ShaderModel.DataCheck == TemplateDataCheck.Valid)
{
m_shaderModelHelper.Draw(owner);
}
m_isDirty = m_shaderModelHelper.IsDirty;
if (currentModule.CullModeData.DataCheck == TemplateDataCheck.Valid)
{
m_cullModeHelper.Draw(owner);
}
m_isDirty = m_isDirty || m_cullModeHelper.IsDirty;
if (currentModule.ColorMaskData.DataCheck == TemplateDataCheck.Valid)
{
m_colorMaskHelper.Draw(owner);
}
m_isDirty = m_isDirty || m_colorMaskHelper.IsDirty;
if (currentModule.DepthData.DataCheck == TemplateDataCheck.Valid)
{
m_depthOphelper.Draw(owner, false);
}
m_isDirty = m_isDirty || m_depthOphelper.IsDirty;
if (currentModule.BlendData.DataCheck == TemplateDataCheck.Valid)
{
m_blendOpHelper.Draw(owner, false);
}
m_isDirty = m_isDirty || m_blendOpHelper.IsDirty;
if (currentModule.StencilData.DataCheck == TemplateDataCheck.Valid)
{
CullMode cullMode = CullMode.Back;
if (currentModule.CullModeData.DataCheck == TemplateDataCheck.Valid)
{
cullMode = m_cullModeHelper.CurrentCullMode;
}
else if (parent != null && parent.CullModeHelper.ValidData)
{
cullMode = parent.CullModeHelper.CurrentCullMode;
}
m_stencilBufferHelper.Draw(owner, cullMode, false);
}
m_isDirty = m_isDirty || m_stencilBufferHelper.IsDirty;
if (currentModule.TagData.DataCheck == TemplateDataCheck.Valid)
{
m_tagsHelper.Draw(owner, false);
}
m_isDirty = m_isDirty || m_tagsHelper.IsDirty;
if (currentModule.PragmaTag.IsValid)
{
//m_additionalDefines.Draw( owner );
//m_additionalIncludes.Draw( owner );
//m_additionalPragmas.Draw( owner );
m_additionalDirectives.Draw(owner, false);
}
m_isDirty = m_isDirty ||
//m_additionalDefines.IsDirty ||
//m_additionalIncludes.IsDirty ||
//m_additionalPragmas.IsDirty ||
m_additionalDirectives.IsDirty;
}
void SetModuleData(TemplateModulesHelper module, bool isSubShader)
{
if (module.AdditionalPragmas.ValidData)
{
module.AdditionalPragmas.AddToDataCollector(ref m_currentDataCollector);
}
if (module.AdditionalIncludes.ValidData)
{
module.AdditionalIncludes.AddToDataCollector(ref m_currentDataCollector);
}
if (module.AdditionalDefines.ValidData)
{
module.AdditionalDefines.AddToDataCollector(ref m_currentDataCollector);
}
if (isSubShader)
{
if (module.ShaderModelHelper.ValidData)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleShaderModel, m_subShaderIdx, module.ShaderModelHelper.GenerateShaderData());
}
if (module.TagsHelper.ValidData)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleTag, m_subShaderIdx, module.TagsHelper.GenerateTags());
}
if (module.BlendOpHelper.ValidBlendMode)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleBlendMode, m_subShaderIdx, module.BlendOpHelper.CurrentBlendFactor);
}
if (module.BlendOpHelper.ValidBlendOp)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleBlendOp, m_subShaderIdx, module.BlendOpHelper.CurrentBlendOp);
}
if (module.CullModeHelper.ValidData)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleCullMode, m_subShaderIdx, module.CullModeHelper.GenerateShaderData());
}
if (module.ColorMaskHelper.ValidData)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleColorMask, m_subShaderIdx, module.ColorMaskHelper.GenerateShaderData());
}
if (module.DepthOphelper.ValidZTest)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleZTest, m_subShaderIdx, module.DepthOphelper.CurrentZTestMode);
}
if (module.DepthOphelper.ValidZWrite)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleZwrite, m_subShaderIdx, module.DepthOphelper.CurrentZWriteMode);
}
if (module.DepthOphelper.ValidOffset)
{
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleZOffset, m_subShaderIdx, module.DepthOphelper.CurrentOffset);
}
if (module.StencilBufferHelper.ValidData)
{
CullMode cullMode = (module.CullModeHelper.ValidData) ? module.CullModeHelper.CurrentCullMode : CullMode.Back;
string value = module.StencilBufferHelper.CreateStencilOp(cullMode);
m_templateMultiPass.SetSubShaderData(TemplateModuleDataType.ModuleStencil, m_subShaderIdx, value.Split('\n'));
}
}
else
{
if (module.ShaderModelHelper.ValidData)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleShaderModel, m_subShaderIdx, m_passIdx, module.ShaderModelHelper.GenerateShaderData());
}
if (module.TagsHelper.ValidData)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleTag, m_subShaderIdx, m_passIdx, module.TagsHelper.GenerateTags());
}
if (module.BlendOpHelper.ValidBlendMode)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleBlendMode, m_subShaderIdx, m_passIdx, module.BlendOpHelper.CurrentBlendFactor);
}
if (module.BlendOpHelper.ValidBlendOp)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleBlendOp, m_subShaderIdx, m_passIdx, module.BlendOpHelper.CurrentBlendOp);
}
if (module.CullModeHelper.ValidData)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleCullMode, m_subShaderIdx, m_passIdx, module.CullModeHelper.GenerateShaderData());
}
if (module.ColorMaskHelper.ValidData)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleColorMask, m_subShaderIdx, m_passIdx, module.ColorMaskHelper.GenerateShaderData());
}
if (module.DepthOphelper.ValidZTest)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleZTest, m_subShaderIdx, m_passIdx, module.DepthOphelper.CurrentZTestMode);
}
if (module.DepthOphelper.ValidZWrite)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleZwrite, m_subShaderIdx, m_passIdx, module.DepthOphelper.CurrentZWriteMode);
}
if (module.DepthOphelper.ValidOffset)
{
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleZOffset, m_subShaderIdx, m_passIdx, module.DepthOphelper.CurrentOffset);
}
if (module.StencilBufferHelper.ValidData)
{
CullMode cullMode = (module.CullModeHelper.ValidData) ? module.CullModeHelper.CurrentCullMode : CullMode.Back;
string value = module.StencilBufferHelper.CreateStencilOp(cullMode);
m_templateMultiPass.SetPassData(TemplateModuleDataType.ModuleStencil, m_subShaderIdx, m_passIdx, value.Split('\n'));
}
}
}
