void BuildShader()
{
var activeNodeList = Graphing.ListPool <AbstractMaterialNode> .Get();
NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, m_OutputNode);
var shaderProperties = new PropertyCollector();
var shaderKeywords = new KeywordCollector();
m_GraphData.CollectShaderProperties(shaderProperties, m_Mode);
m_GraphData.CollectShaderKeywords(shaderKeywords, m_Mode);
if (m_GraphData.GetKeywordPermutationCount() > ShaderGraphPreferences.variantLimit)
{
m_GraphData.AddValidationError(m_OutputNode.guid, ShaderKeyword.kVariantLimitWarning, Rendering.ShaderCompilerMessageSeverity.Error);
m_ConfiguredTextures = shaderProperties.GetConfiguredTexutres();
m_Builder.AppendLines(ShaderGraphImporter.k_ErrorShader);
}
GetTargetImplementations();
foreach (var activeNode in activeNodeList.OfType <AbstractMaterialNode>())
{
activeNode.CollectShaderProperties(shaderProperties, m_Mode);
}
m_Builder.AppendLine(@"Shader ""{0}""", m_Name);
using (m_Builder.BlockScope())
{
GenerationUtils.GeneratePropertiesBlock(m_Builder, shaderProperties, shaderKeywords, m_Mode);
for (int i = 0; i < m_TargetImplementations.Length; i++)
{
TargetSetupContext context = new TargetSetupContext();
context.SetMasterNode(m_OutputNode as IMasterNode);
// Instead of setup target, we can also just do get context
m_TargetImplementations[i].SetupTarget(ref context);
GetAssetDependencyPaths(context);
GenerateSubShader(i, context.descriptor);
}
// Either grab the pipeline default for the active node or the user override
if (m_OutputNode is ICanChangeShaderGUI canChangeShaderGui)
{
string customEditor = GenerationUtils.FinalCustomEditorString(canChangeShaderGui);
if (customEditor != null)
{
m_Builder.AppendLine("CustomEditor \"" + customEditor + "\"");
}
}
m_Builder.AppendLine(@"FallBack ""Hidden/Shader Graph/FallbackError""");
}
m_ConfiguredTextures = shaderProperties.GetConfiguredTexutres();
}
public static void GenerateVertexDescriptionFunction(
GraphData graph,
ShaderStringBuilder builder,
FunctionRegistry functionRegistry,
PropertyCollector shaderProperties,
KeywordCollector shaderKeywords,
GenerationMode mode,
AbstractMaterialNode rootNode,
List <AbstractMaterialNode> nodes,
List <int>[] keywordPermutationsPerNode,
List <MaterialSlot> slots,
string graphInputStructName = "VertexDescriptionInputs",
string functionName = "PopulateVertexData",
string graphOutputStructName = k_VertexDescriptionStructName)
{
if (graph == null)
{
return;
}
graph.CollectShaderProperties(shaderProperties, mode);
builder.AppendLine("{0} {1}({2} IN)", graphOutputStructName, functionName, graphInputStructName);
using (builder.BlockScope())
{
builder.AppendLine("{0} description = ({0})0;", graphOutputStructName);
for (int i = 0; i < nodes.Count; i++)
{
GenerateDescriptionForNode(nodes[i], keywordPermutationsPerNode[i], functionRegistry, builder,
shaderProperties, shaderKeywords,
graph, mode);
}
functionRegistry.builder.currentNode = null;
builder.currentNode = null;
if (slots.Count != 0)
{
foreach (var slot in slots)
{
var isSlotConnected = slot.owner.owner.GetEdges(slot.slotReference).Any();
var slotName = NodeUtils.GetHLSLSafeName(slot.shaderOutputName);
var slotValue = isSlotConnected ?
((AbstractMaterialNode)slot.owner).GetSlotValue(slot.id, mode, slot.owner.concretePrecision) : slot.GetDefaultValue(mode, slot.owner.concretePrecision);
builder.AppendLine("description.{0} = {1};", slotName, slotValue);
}
}
builder.AppendLine("return description;");
}
}
public static void GenerateSurfaceDescriptionFunction(
List <AbstractMaterialNode> nodes,
List <int>[] keywordPermutationsPerNode,
AbstractMaterialNode rootNode,
GraphData graph,
ShaderStringBuilder surfaceDescriptionFunction,
FunctionRegistry functionRegistry,
PropertyCollector shaderProperties,
KeywordCollector shaderKeywords,
GenerationMode mode,
string functionName = "PopulateSurfaceData",
string surfaceDescriptionName = "SurfaceDescription",
Vector1ShaderProperty outputIdProperty = null,
IEnumerable <MaterialSlot> slots = null,
string graphInputStructName = "SurfaceDescriptionInputs")
{
if (graph == null)
{
return;
}
graph.CollectShaderProperties(shaderProperties, mode);
surfaceDescriptionFunction.AppendLine(String.Format("{0} {1}(SurfaceDescriptionInputs IN)", surfaceDescriptionName, functionName), false);
using (surfaceDescriptionFunction.BlockScope())
{
surfaceDescriptionFunction.AppendLine("{0} surface = ({0})0;", surfaceDescriptionName);
for (int i = 0; i < nodes.Count; i++)
{
GenerateDescriptionForNode(nodes[i], keywordPermutationsPerNode[i], functionRegistry, surfaceDescriptionFunction,
shaderProperties, shaderKeywords,
graph, mode);
}
functionRegistry.builder.currentNode = null;
surfaceDescriptionFunction.currentNode = null;
GenerateSurfaceDescriptionRemap(graph, rootNode, slots,
surfaceDescriptionFunction, mode);
surfaceDescriptionFunction.AppendLine("return surface;");
}
}
