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();
}
protected override string GetOutputForSlot(SlotReference fromSocketRef, ConcreteSlotValueType valueType, GenerationMode generationMode)
{
var slotRef = NodeUtils.DepthFirstCollectRedirectNodeFromNode(this);
var fromLeftNode = owner.GetNodeFromGuid<AbstractMaterialNode>(slotRef.nodeGuid);
if (fromLeftNode is RedirectNodeData)
{
return GetSlotValue(kInputSlotID, generationMode);
}
if (fromLeftNode != null)
{
return GenerationUtils.AdaptNodeOutput(fromLeftNode, slotRef.slotId, valueType);
}
return base.GetOutputForSlot(fromSocketRef, valueType, generationMode);
}
protected internal override string GetOutputForSlot(SlotReference fromSocketRef, ConcreteSlotValueType valueType, GenerationMode generationMode)
{
var slotRef = NodeUtils.DepthFirstCollectRedirectNodeFromNode(this);
var fromLeftNode = slotRef.node;
if (fromLeftNode is RedirectNodeData)
{
return(GetSlotValue(kInputSlotID, generationMode));
}
if (fromLeftNode != null)
{
return(GenerationUtils.AdaptNodeOutput(fromLeftNode, slotRef.slotId, valueType));
}
return(base.GetOutputForSlot(fromSocketRef, valueType, generationMode));
}
public static ActiveFields GatherActiveFieldsFromNode(AbstractMaterialNode outputNode, PassDescriptor pass)
{
var activeFields = new ActiveFields();
if (outputNode is IMasterNode masterNode)
{
var fields = GenerationUtils.GetActiveFieldsFromConditionals(masterNode.GetConditionalFields(pass));
foreach (FieldDescriptor field in fields)
{
activeFields.baseInstance.Add(field);
}
}
// Preview shader
else
{
activeFields.baseInstance.Add(Fields.GraphPixel);
}
return(activeFields);
}
void GenerateSubShader(int targetIndex, SubShaderDescriptor descriptor)
{
if (descriptor.passes == null)
{
return;
}
// Early out of preview generation if no passes are used in preview
if (m_Mode == GenerationMode.Preview && descriptor.generatesPreview == false)
{
return;
}
m_Builder.AppendLine("SubShader");
using (m_Builder.BlockScope())
{
GenerationUtils.GenerateSubShaderTags(m_OutputNode as IMasterNode, descriptor, m_Builder);
foreach (PassCollection.Item pass in descriptor.passes)
{
var activeFields = GatherActiveFieldsFromNode(m_OutputNode, pass.descriptor);
// TODO: cleanup this preview check, needed for HD decal preview pass
if (m_Mode == GenerationMode.Preview)
{
activeFields.baseInstance.Add(Fields.IsPreview);
}
// Check masternode fields for valid passes
if (pass.TestActive(activeFields))
{
GenerateShaderPass(targetIndex, pass.descriptor, activeFields);
}
}
}
}
static void ProcessSubGraph(SubGraphAsset asset, GraphData graph)
{
var registry = new FunctionRegistry(new ShaderStringBuilder(), true);
registry.names.Clear();
asset.functions.Clear();
asset.isValid = true;
graph.OnEnable();
graph.messageManager.ClearAll();
graph.ValidateGraph();
var assetPath = AssetDatabase.GUIDToAssetPath(asset.assetGuid);
asset.hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
asset.inputStructName = $"Bindings_{asset.hlslName}_{asset.assetGuid}";
asset.functionName = $"SG_{asset.hlslName}_{asset.assetGuid}";
asset.path = graph.path;
var outputNode = graph.outputNode;
var outputSlots = PooledList <MaterialSlot> .Get();
outputNode.GetInputSlots(outputSlots);
List <AbstractMaterialNode> nodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(nodes, outputNode);
asset.effectiveShaderStage = ShaderStageCapability.All;
foreach (var slot in outputSlots)
{
var stage = NodeUtils.GetEffectiveShaderStageCapability(slot, true);
if (stage != ShaderStageCapability.All)
{
asset.effectiveShaderStage = stage;
break;
}
}
asset.vtFeedbackVariables = VirtualTexturingFeedbackUtils.GetFeedbackVariables(outputNode as SubGraphOutputNode);
asset.requirements = ShaderGraphRequirements.FromNodes(nodes, asset.effectiveShaderStage, false);
asset.graphPrecision = graph.concretePrecision;
asset.outputPrecision = outputNode.concretePrecision;
asset.previewMode = graph.previewMode;
GatherDescendentsFromGraph(new GUID(asset.assetGuid), out var containsCircularDependency, out var descendents);
asset.descendents.AddRange(descendents.Select(g => g.ToString()));
asset.descendents.Sort(); // ensure deterministic order
var childrenSet = new HashSet <string>();
var anyErrors = false;
foreach (var node in nodes)
{
if (node is SubGraphNode subGraphNode)
{
var subGraphGuid = subGraphNode.subGraphGuid;
childrenSet.Add(subGraphGuid);
}
if (node.hasError)
{
anyErrors = true;
}
asset.children = childrenSet.ToList();
asset.children.Sort(); // ensure deterministic order
}
if (!anyErrors && containsCircularDependency)
{
Debug.LogError($"Error in Graph at {assetPath}: Sub Graph contains a circular dependency.", asset);
anyErrors = true;
}
if (anyErrors)
{
asset.isValid = false;
registry.ProvideFunction(asset.functionName, sb => { });
return;
}
foreach (var node in nodes)
{
if (node is IGeneratesFunction generatesFunction)
{
registry.builder.currentNode = node;
generatesFunction.GenerateNodeFunction(registry, GenerationMode.ForReals);
registry.builder.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
}
// provide top level subgraph function
registry.ProvideFunction(asset.functionName, sb =>
{
GenerationUtils.GenerateSurfaceInputStruct(sb, asset.requirements, asset.inputStructName);
sb.AppendNewLine();
// Generate arguments... first INPUTS
var arguments = new List <string>();
foreach (var prop in graph.properties)
{
prop.ValidateConcretePrecision(asset.graphPrecision);
arguments.Add(prop.GetPropertyAsArgumentString());
}
// now pass surface inputs
arguments.Add(string.Format("{0} IN", asset.inputStructName));
// Now generate outputs
foreach (MaterialSlot output in outputSlots)
{
arguments.Add($"out {output.concreteValueType.ToShaderString(asset.outputPrecision)} {output.shaderOutputName}_{output.id}");
}
// Vt Feedback arguments
foreach (var output in asset.vtFeedbackVariables)
{
arguments.Add($"out {ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Single)} {output}_out");
}
// Create the function prototype from the arguments
sb.AppendLine("void {0}({1})"
, asset.functionName
, arguments.Aggregate((current, next) => $"{current}, {next}"));
// now generate the function
using (sb.BlockScope())
{
// Just grab the body from the active nodes
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode generatesBodyCode)
{
sb.currentNode = node;
generatesBodyCode.GenerateNodeCode(sb, GenerationMode.ForReals);
sb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
}
foreach (var slot in outputSlots)
{
sb.AppendLine($"{slot.shaderOutputName}_{slot.id} = {outputNode.GetSlotValue(slot.id, GenerationMode.ForReals, asset.outputPrecision)};");
}
foreach (var slot in asset.vtFeedbackVariables)
{
sb.AppendLine($"{slot}_out = {slot};");
}
}
});
asset.functions.AddRange(registry.names.Select(x => new FunctionPair(x, registry.sources[x].code)));
var collector = new PropertyCollector();
foreach (var node in nodes)
{
int previousPropertyCount = Math.Max(0, collector.properties.Count - 1);
node.CollectShaderProperties(collector, GenerationMode.ForReals);
// This is a stop-gap to prevent the autogenerated values from JsonObject and ShaderInput from
// resulting in non-deterministic import data. While we should move to local ids in the future,
// this will prevent cascading shader recompilations.
for (int i = previousPropertyCount; i < collector.properties.Count; ++i)
{
var prop = collector.properties[i];
var namespaceId = node.objectId;
var nameId = prop.referenceName;
prop.OverrideObjectId(namespaceId, nameId + "_ObjectId_" + i);
prop.OverrideGuid(namespaceId, nameId + "_Guid_" + i);
}
}
asset.WriteData(graph.properties, graph.keywords, collector.properties, outputSlots, graph.unsupportedTargets);
outputSlots.Dispose();
}
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
if (asset == null || hasError)
{
var outputSlots = new List <MaterialSlot>();
GetOutputSlots(outputSlots);
var outputPrecision = asset != null ? asset.outputPrecision : ConcretePrecision.Single;
foreach (var slot in outputSlots)
{
sb.AppendLine($"{slot.concreteValueType.ToShaderString(outputPrecision)} {GetVariableNameForSlot(slot.id)} = {slot.GetDefaultValue(GenerationMode.ForReals)};");
}
return;
}
var inputVariableName = $"_{GetVariableNameForNode()}";
GenerationUtils.GenerateSurfaceInputTransferCode(sb, asset.requirements, asset.inputStructName, inputVariableName);
foreach (var outSlot in asset.outputs)
{
sb.AppendLine("{0} {1};", outSlot.concreteValueType.ToShaderString(asset.outputPrecision), GetVariableNameForSlot(outSlot.id));
}
var arguments = new List <string>();
foreach (var prop in asset.inputs)
{
prop.ValidateConcretePrecision(asset.graphPrecision);
var inSlotId = m_PropertyIds[m_PropertyGuids.IndexOf(prop.guid.ToString())];
arguments.Add(GetSlotValue(inSlotId, generationMode, prop.concretePrecision));
}
// pass surface inputs through
arguments.Add(inputVariableName);
foreach (var outSlot in asset.outputs)
{
arguments.Add(GetVariableNameForSlot(outSlot.id));
}
foreach (var feedbackSlot in asset.vtFeedbackVariables)
{
string feedbackVar = GetVariableNameForNode() + "_" + feedbackSlot;
sb.AppendLine("{0} {1};", ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Single), feedbackVar);
arguments.Add(feedbackVar);
}
sb.AppendIndentation();
sb.Append(asset.functionName);
sb.Append("(");
bool firstArg = true;
foreach (var arg in arguments)
{
if (!firstArg)
{
sb.Append(", ");
}
firstArg = false;
sb.Append(arg);
}
sb.Append(");");
sb.AppendNewLine();
}
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
if (asset == null || hasError)
{
var outputSlots = new List <MaterialSlot>();
GetOutputSlots(outputSlots);
var outputPrecision = asset != null ? asset.outputPrecision : ConcretePrecision.Float;
foreach (var slot in outputSlots)
{
sb.AppendLine($"{slot.concreteValueType.ToShaderString(outputPrecision)} {GetVariableNameForSlot(slot.id)} = {slot.GetDefaultValue(GenerationMode.ForReals)};");
}
return;
}
var inputVariableName = $"_{GetVariableNameForNode()}";
GenerationUtils.GenerateSurfaceInputTransferCode(sb, asset.requirements, asset.inputStructName, inputVariableName);
foreach (var outSlot in asset.outputs)
{
sb.AppendLine("{0} {1};", outSlot.concreteValueType.ToShaderString(asset.outputPrecision), GetVariableNameForSlot(outSlot.id));
}
var arguments = new List <string>();
foreach (var prop in asset.inputs)
{
prop.ValidateConcretePrecision(asset.graphPrecision);
var inSlotId = m_PropertyIds[m_PropertyGuids.IndexOf(prop.guid.ToString())];
switch (prop)
{
case Texture2DShaderProperty texture2DProp:
arguments.Add(string.Format("TEXTURE2D_ARGS({0}, sampler{0}), {0}_TexelSize", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
break;
case Texture2DArrayShaderProperty texture2DArrayProp:
arguments.Add(string.Format("TEXTURE2D_ARRAY_ARGS({0}, sampler{0})", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
break;
case Texture3DShaderProperty texture3DProp:
arguments.Add(string.Format("TEXTURE3D_ARGS({0}, sampler{0})", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
break;
case CubemapShaderProperty cubemapProp:
arguments.Add(string.Format("TEXTURECUBE_ARGS({0}, sampler{0})", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
break;
default:
arguments.Add(string.Format("{0}", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
break;
}
}
// pass surface inputs through
arguments.Add(inputVariableName);
foreach (var outSlot in asset.outputs)
{
arguments.Add(GetVariableNameForSlot(outSlot.id));
}
foreach (var feedbackSlot in asset.vtFeedbackVariables)
{
string feedbackVar = GetVariableNameForNode() + "_" + feedbackSlot;
sb.AppendLine("{0} {1};", ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Float), feedbackVar);
arguments.Add(feedbackVar);
}
sb.AppendLine("{0}({1});", asset.functionName, arguments.Aggregate((current, next) => string.Format("{0}, {1}", current, next)));
}
static void ProcessSubGraph(SubGraphAsset asset, GraphData graph)
{
var graphIncludes = new IncludeCollection();
var registry = new FunctionRegistry(new ShaderStringBuilder(), graphIncludes, true);
asset.functions.Clear();
asset.isValid = true;
graph.OnEnable();
graph.messageManager.ClearAll();
graph.ValidateGraph();
var assetPath = AssetDatabase.GUIDToAssetPath(asset.assetGuid);
asset.hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
asset.inputStructName = $"Bindings_{asset.hlslName}_{asset.assetGuid}_$precision";
asset.functionName = $"SG_{asset.hlslName}_{asset.assetGuid}_$precision";
asset.path = graph.path;
var outputNode = graph.outputNode;
var outputSlots = PooledList <MaterialSlot> .Get();
outputNode.GetInputSlots(outputSlots);
List <AbstractMaterialNode> nodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(nodes, outputNode);
asset.effectiveShaderStage = ShaderStageCapability.All;
foreach (var slot in outputSlots)
{
var stage = NodeUtils.GetEffectiveShaderStageCapability(slot, true);
if (stage != ShaderStageCapability.All)
{
asset.effectiveShaderStage = stage;
break;
}
}
asset.vtFeedbackVariables = VirtualTexturingFeedbackUtils.GetFeedbackVariables(outputNode as SubGraphOutputNode);
asset.requirements = ShaderGraphRequirements.FromNodes(nodes, asset.effectiveShaderStage, false);
// output precision is whatever the output node has as a graph precision, falling back to the graph default
asset.outputGraphPrecision = outputNode.graphPrecision.GraphFallback(graph.graphDefaultPrecision);
// this saves the graph precision, which indicates whether this subgraph is switchable or not
asset.subGraphGraphPrecision = graph.graphDefaultPrecision;
asset.previewMode = graph.previewMode;
asset.includes = graphIncludes;
GatherDescendentsFromGraph(new GUID(asset.assetGuid), out var containsCircularDependency, out var descendents);
asset.descendents.AddRange(descendents.Select(g => g.ToString()));
asset.descendents.Sort(); // ensure deterministic order
var childrenSet = new HashSet <string>();
var anyErrors = false;
foreach (var node in nodes)
{
if (node is SubGraphNode subGraphNode)
{
var subGraphGuid = subGraphNode.subGraphGuid;
childrenSet.Add(subGraphGuid);
}
if (node.hasError)
{
anyErrors = true;
}
asset.children = childrenSet.ToList();
asset.children.Sort(); // ensure deterministic order
}
if (!anyErrors && containsCircularDependency)
{
Debug.LogError($"Error in Graph at {assetPath}: Sub Graph contains a circular dependency.", asset);
anyErrors = true;
}
if (anyErrors)
{
asset.isValid = false;
registry.ProvideFunction(asset.functionName, sb => {});
return;
}
foreach (var node in nodes)
{
if (node is IGeneratesFunction generatesFunction)
{
registry.builder.currentNode = node;
generatesFunction.GenerateNodeFunction(registry, GenerationMode.ForReals);
}
}
// provide top level subgraph function
// NOTE: actual concrete precision here shouldn't matter, it's irrelevant when building the subgraph asset
registry.ProvideFunction(asset.functionName, asset.subGraphGraphPrecision, ConcretePrecision.Single, sb =>
{
GenerationUtils.GenerateSurfaceInputStruct(sb, asset.requirements, asset.inputStructName);
sb.AppendNewLine();
// Generate the arguments... first INPUTS
var arguments = new List <string>();
foreach (var prop in graph.properties)
{
// apply fallback to the graph default precision (but don't convert to concrete)
// this means "graph switchable" properties will use the precision token
GraphPrecision propGraphPrecision = prop.precision.ToGraphPrecision(graph.graphDefaultPrecision);
string precisionString = propGraphPrecision.ToGenericString();
arguments.Add(prop.GetPropertyAsArgumentString(precisionString));
if (prop.isConnectionTestable)
{
arguments.Add($"bool {prop.GetConnectionStateHLSLVariableName()}");
}
}
{
var dropdowns = graph.dropdowns;
foreach (var dropdown in dropdowns)
{
arguments.Add($"int {dropdown.referenceName}");
}
}
// now pass surface inputs
arguments.Add(string.Format("{0} IN", asset.inputStructName));
// Now generate output arguments
foreach (MaterialSlot output in outputSlots)
{
arguments.Add($"out {output.concreteValueType.ToShaderString(asset.outputGraphPrecision.ToGenericString())} {output.shaderOutputName}_{output.id}");
}
// Vt Feedback output arguments (always full float4)
foreach (var output in asset.vtFeedbackVariables)
{
arguments.Add($"out {ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Single)} {output}_out");
}
// Create the function prototype from the arguments
sb.AppendLine("void {0}({1})"
, asset.functionName
, arguments.Aggregate((current, next) => $"{current}, {next}"));
// now generate the function
using (sb.BlockScope())
{
// Just grab the body from the active nodes
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode generatesBodyCode)
{
sb.currentNode = node;
generatesBodyCode.GenerateNodeCode(sb, GenerationMode.ForReals);
if (node.graphPrecision == GraphPrecision.Graph)
{
// code generated by nodes that use graph precision stays in generic form with embedded tokens
// those tokens are replaced when this subgraph function is pulled into a graph that defines the precision
}
else
{
sb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
}
}
foreach (var slot in outputSlots)
{
sb.AppendLine($"{slot.shaderOutputName}_{slot.id} = {outputNode.GetSlotValue(slot.id, GenerationMode.ForReals)};");
}
foreach (var slot in asset.vtFeedbackVariables)
{
sb.AppendLine($"{slot}_out = {slot};");
}
}
});
// save all of the node-declared functions to the subgraph asset
foreach (var name in registry.names)
{
var source = registry.sources[name];
var func = new FunctionPair(name, source.code, source.graphPrecisionFlags);
asset.functions.Add(func);
}
var collector = new PropertyCollector();
foreach (var node in nodes)
{
int previousPropertyCount = Math.Max(0, collector.propertyCount - 1);
node.CollectShaderProperties(collector, GenerationMode.ForReals);
// This is a stop-gap to prevent the autogenerated values from JsonObject and ShaderInput from
// resulting in non-deterministic import data. While we should move to local ids in the future,
// this will prevent cascading shader recompilations.
for (int i = previousPropertyCount; i < collector.propertyCount; ++i)
{
var prop = collector.GetProperty(i);
var namespaceId = node.objectId;
var nameId = prop.referenceName;
prop.OverrideObjectId(namespaceId, nameId + "_ObjectId_" + i);
prop.OverrideGuid(namespaceId, nameId + "_Guid_" + i);
}
}
asset.WriteData(graph.properties, graph.keywords, graph.dropdowns, collector.properties, outputSlots, graph.unsupportedTargets);
outputSlots.Dispose();
}
static void ProcessSubGraph(SubGraphAsset asset, GraphData graph)
{
var registry = new FunctionRegistry(new ShaderStringBuilder(), true);
registry.names.Clear();
asset.functions.Clear();
asset.isValid = true;
graph.OnEnable();
graph.messageManager.ClearAll();
graph.ValidateGraph();
var assetPath = AssetDatabase.GUIDToAssetPath(asset.assetGuid);
asset.hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
asset.inputStructName = $"Bindings_{asset.hlslName}_{asset.assetGuid}";
asset.functionName = $"SG_{asset.hlslName}_{asset.assetGuid}";
asset.path = graph.path;
var outputNode = (SubGraphOutputNode)graph.outputNode;
var outputSlots = PooledList <MaterialSlot> .Get();
outputNode.GetInputSlots(outputSlots);
List <AbstractMaterialNode> nodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(nodes, outputNode);
asset.effectiveShaderStage = ShaderStageCapability.All;
foreach (var slot in outputSlots)
{
var stage = NodeUtils.GetEffectiveShaderStageCapability(slot, true);
if (stage != ShaderStageCapability.All)
{
asset.effectiveShaderStage = stage;
break;
}
}
asset.vtFeedbackVariables = VirtualTexturingFeedbackUtils.GetFeedbackVariables(outputNode);
asset.requirements = ShaderGraphRequirements.FromNodes(nodes, asset.effectiveShaderStage, false);
asset.graphPrecision = graph.concretePrecision;
asset.outputPrecision = outputNode.concretePrecision;
GatherFromGraph(assetPath, out var containsCircularDependency, out var descendents);
asset.descendents.AddRange(descendents);
var childrenSet = new HashSet <string>();
var anyErrors = false;
foreach (var node in nodes)
{
if (node is SubGraphNode subGraphNode)
{
var subGraphGuid = subGraphNode.subGraphGuid;
if (childrenSet.Add(subGraphGuid))
{
asset.children.Add(subGraphGuid);
}
}
if (node.hasError)
{
anyErrors = true;
}
}
if (!anyErrors && containsCircularDependency)
{
Debug.LogError($"Error in Graph at {assetPath}: Sub Graph contains a circular dependency.", asset);
anyErrors = true;
}
if (anyErrors)
{
asset.isValid = false;
registry.ProvideFunction(asset.functionName, sb => { });
return;
}
foreach (var node in nodes)
{
if (node is IGeneratesFunction generatesFunction)
{
registry.builder.currentNode = node;
generatesFunction.GenerateNodeFunction(registry, GenerationMode.ForReals);
registry.builder.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
}
registry.ProvideFunction(asset.functionName, sb =>
{
GenerationUtils.GenerateSurfaceInputStruct(sb, asset.requirements, asset.inputStructName);
sb.AppendNewLine();
// Generate arguments... first INPUTS
var arguments = new List <string>();
foreach (var prop in graph.properties)
{
prop.ValidateConcretePrecision(asset.graphPrecision);
arguments.Add(string.Format("{0}", prop.GetPropertyAsArgumentString()));
}
// now pass surface inputs
arguments.Add(string.Format("{0} IN", asset.inputStructName));
// Now generate outputs
foreach (var output in outputSlots)
{
arguments.Add($"out {output.concreteValueType.ToShaderString(asset.outputPrecision)} {output.shaderOutputName}_{output.id}");
}
// Vt Feedback arguments
foreach (var output in asset.vtFeedbackVariables)
{
arguments.Add($"out {ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Float)} {output}_out");
}
// Create the function prototype from the arguments
sb.AppendLine("void {0}({1})"
, asset.functionName
, arguments.Aggregate((current, next) => $"{current}, {next}"));
// now generate the function
using (sb.BlockScope())
{
// Just grab the body from the active nodes
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode generatesBodyCode)
{
sb.currentNode = node;
generatesBodyCode.GenerateNodeCode(sb, GenerationMode.ForReals);
sb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
}
foreach (var slot in outputSlots)
{
sb.AppendLine($"{slot.shaderOutputName}_{slot.id} = {outputNode.GetSlotValue(slot.id, GenerationMode.ForReals, asset.outputPrecision)};");
}
foreach (var slot in asset.vtFeedbackVariables)
{
sb.AppendLine($"{slot}_out = {slot};");
}
}
});
asset.functions.AddRange(registry.names.Select(x => new FunctionPair(x, registry.sources[x].code)));
var collector = new PropertyCollector();
foreach (var node in nodes)
{
node.CollectShaderProperties(collector, GenerationMode.ForReals);
}
asset.WriteData(graph.properties, graph.keywords, collector.properties, outputSlots);
outputSlots.Dispose();
}
void GenerateShaderPass(int targetIndex, PassDescriptor pass, ActiveFields activeFields)
{
// Early exit if pass is not used in preview
if (m_Mode == GenerationMode.Preview && !pass.useInPreview)
{
return;
}
// --------------------------------------------------
// Debug
// Get scripting symbols
BuildTargetGroup buildTargetGroup = EditorUserBuildSettings.selectedBuildTargetGroup;
string defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(buildTargetGroup);
bool isDebug = defines.Contains(kDebugSymbol);
// --------------------------------------------------
// Setup
// Initiailize Collectors
var propertyCollector = new PropertyCollector();
var keywordCollector = new KeywordCollector();
m_OutputNode.owner.CollectShaderKeywords(keywordCollector, m_Mode);
// Get upstream nodes from ShaderPass port mask
List <AbstractMaterialNode> vertexNodes;
List <AbstractMaterialNode> pixelNodes;
GenerationUtils.GetUpstreamNodesForShaderPass(m_OutputNode, pass, out vertexNodes, out pixelNodes);
// Track permutation indices for all nodes
List <int>[] vertexNodePermutations = new List <int> [vertexNodes.Count];
List <int>[] pixelNodePermutations = new List <int> [pixelNodes.Count];
// Get active fields from upstream Node requirements
ShaderGraphRequirementsPerKeyword graphRequirements;
GenerationUtils.GetActiveFieldsAndPermutationsForNodes(m_OutputNode, pass, keywordCollector, vertexNodes, pixelNodes,
vertexNodePermutations, pixelNodePermutations, activeFields, out graphRequirements);
// GET CUSTOM ACTIVE FIELDS HERE!
// Get active fields from ShaderPass
GenerationUtils.AddRequiredFields(pass.requiredFields, activeFields.baseInstance);
// Get Port references from ShaderPass
List <MaterialSlot> pixelSlots;
List <MaterialSlot> vertexSlots;
if (m_OutputNode is IMasterNode)
{
pixelSlots = GenerationUtils.FindMaterialSlotsOnNode(pass.pixelPorts, m_OutputNode);
vertexSlots = GenerationUtils.FindMaterialSlotsOnNode(pass.vertexPorts, m_OutputNode);
}
else if (m_OutputNode is SubGraphOutputNode)
{
pixelSlots = new List <MaterialSlot>()
{
m_OutputNode.GetInputSlots <MaterialSlot>().FirstOrDefault(),
};
vertexSlots = new List <MaterialSlot>();
}
else
{
pixelSlots = new List <MaterialSlot>()
{
new Vector4MaterialSlot(0, "Out", "Out", SlotType.Output, Vector4.zero)
{
owner = m_OutputNode
},
};
vertexSlots = new List <MaterialSlot>();
}
// Function Registry
var functionBuilder = new ShaderStringBuilder();
var functionRegistry = new FunctionRegistry(functionBuilder);
// Hash table of named $splice(name) commands
// Key: splice token
// Value: string to splice
Dictionary <string, string> spliceCommands = new Dictionary <string, string>();
// --------------------------------------------------
// Dependencies
// Propagate active field requirements using dependencies
// Must be executed before types are built
foreach (var instance in activeFields.all.instances)
{
GenerationUtils.ApplyFieldDependencies(instance, pass.fieldDependencies);
}
// --------------------------------------------------
// Pass Setup
// Name
if (!string.IsNullOrEmpty(pass.displayName))
{
spliceCommands.Add("PassName", $"Name \"{pass.displayName}\"");
}
else
{
spliceCommands.Add("PassName", "// Name: <None>");
}
// Tags
if (!string.IsNullOrEmpty(pass.lightMode))
{
spliceCommands.Add("LightMode", $"\"LightMode\" = \"{pass.lightMode}\"");
}
else
{
spliceCommands.Add("LightMode", "// LightMode: <None>");
}
// --------------------------------------------------
// Pass Code
// Render State
using (var renderStateBuilder = new ShaderStringBuilder())
{
// Render states need to be separated by RenderState.Type
// The first passing ConditionalRenderState of each type is inserted
foreach (RenderStateType type in Enum.GetValues(typeof(RenderStateType)))
{
var renderStates = pass.renderStates?.Where(x => x.descriptor.type == type);
if (renderStates != null)
{
foreach (RenderStateCollection.Item renderState in renderStates)
{
if (renderState.TestActive(activeFields))
{
renderStateBuilder.AppendLine(renderState.value);
break;
}
}
}
}
string command = GenerationUtils.GetSpliceCommand(renderStateBuilder.ToCodeBlock(), "RenderState");
spliceCommands.Add("RenderState", command);
}
// Pragmas
using (var passPragmaBuilder = new ShaderStringBuilder())
{
if (pass.pragmas != null)
{
foreach (PragmaCollection.Item pragma in pass.pragmas)
{
if (pragma.TestActive(activeFields))
{
passPragmaBuilder.AppendLine(pragma.value);
}
}
}
string command = GenerationUtils.GetSpliceCommand(passPragmaBuilder.ToCodeBlock(), "PassPragmas");
spliceCommands.Add("PassPragmas", command);
}
// Includes
using (var preGraphIncludeBuilder = new ShaderStringBuilder())
{
if (pass.includes != null)
{
foreach (IncludeCollection.Item include in pass.includes.Where(x => x.descriptor.location == IncludeLocation.Pregraph))
{
if (include.TestActive(activeFields))
{
preGraphIncludeBuilder.AppendLine(include.value);
}
}
}
string command = GenerationUtils.GetSpliceCommand(preGraphIncludeBuilder.ToCodeBlock(), "PreGraphIncludes");
spliceCommands.Add("PreGraphIncludes", command);
}
using (var postGraphIncludeBuilder = new ShaderStringBuilder())
{
if (pass.includes != null)
{
foreach (IncludeCollection.Item include in pass.includes.Where(x => x.descriptor.location == IncludeLocation.Postgraph))
{
if (include.TestActive(activeFields))
{
postGraphIncludeBuilder.AppendLine(include.value);
}
}
}
string command = GenerationUtils.GetSpliceCommand(postGraphIncludeBuilder.ToCodeBlock(), "PostGraphIncludes");
spliceCommands.Add("PostGraphIncludes", command);
}
// Keywords
using (var passKeywordBuilder = new ShaderStringBuilder())
{
if (pass.keywords != null)
{
foreach (KeywordCollection.Item keyword in pass.keywords)
{
if (keyword.TestActive(activeFields))
{
passKeywordBuilder.AppendLine(keyword.value);
}
}
}
string command = GenerationUtils.GetSpliceCommand(passKeywordBuilder.ToCodeBlock(), "PassKeywords");
spliceCommands.Add("PassKeywords", command);
}
// -----------------------------
// Generated structs and Packing code
var interpolatorBuilder = new ShaderStringBuilder();
var passStructs = new List <StructDescriptor>();
if (pass.structs != null)
{
passStructs.AddRange(pass.structs.Select(x => x.descriptor));
foreach (StructCollection.Item shaderStruct in pass.structs)
{
if (shaderStruct.descriptor.packFields == false)
{
continue; //skip structs that do not need interpolator packs
}
List <int> packedCounts = new List <int>();
var packStruct = new StructDescriptor();
//generate packed functions
if (activeFields.permutationCount > 0)
{
var generatedPackedTypes = new Dictionary <string, (ShaderStringBuilder, List <int>)>();
foreach (var instance in activeFields.allPermutations.instances)
{
var instanceGenerator = new ShaderStringBuilder();
GenerationUtils.GenerateInterpolatorFunctions(shaderStruct.descriptor, instance, out instanceGenerator);
var key = instanceGenerator.ToCodeBlock();
if (generatedPackedTypes.TryGetValue(key, out var value))
{
value.Item2.Add(instance.permutationIndex);
}
else
{
generatedPackedTypes.Add(key, (instanceGenerator, new List <int> {
instance.permutationIndex
}));
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
var outputGraphPrecision = asset?.outputGraphPrecision ?? GraphPrecision.Single;
var outputPrecision = outputGraphPrecision.ToConcrete(concretePrecision);
if (asset == null || hasError)
{
var outputSlots = new List <MaterialSlot>();
GetOutputSlots(outputSlots);
foreach (var slot in outputSlots)
{
sb.AppendLine($"{slot.concreteValueType.ToShaderString(outputPrecision)} {GetVariableNameForSlot(slot.id)} = {slot.GetDefaultValue(GenerationMode.ForReals)};");
}
return;
}
var inputVariableName = $"_{GetVariableNameForNode()}";
GenerationUtils.GenerateSurfaceInputTransferCode(sb, asset.requirements, asset.inputStructName, inputVariableName);
// declare output variables
foreach (var outSlot in asset.outputs)
{
sb.AppendLine("{0} {1};", outSlot.concreteValueType.ToShaderString(outputPrecision), GetVariableNameForSlot(outSlot.id));
}
var arguments = new List <string>();
foreach (AbstractShaderProperty prop in asset.inputs)
{
// setup the property concrete precision (fallback to node concrete precision when it's switchable)
prop.SetupConcretePrecision(this.concretePrecision);
var inSlotId = m_PropertyIds[m_PropertyGuids.IndexOf(prop.guid.ToString())];
arguments.Add(GetSlotValue(inSlotId, generationMode, prop.concretePrecision));
if (prop.isConnectionTestable)
{
arguments.Add(IsSlotConnected(inSlotId) ? "true" : "false");
}
}
var dropdowns = asset.dropdowns;
foreach (var dropdown in dropdowns)
{
var name = GetDropdownEntryName(dropdown.referenceName);
if (dropdown.ContainsEntry(name))
{
arguments.Add(dropdown.IndexOfName(name).ToString());
}
else
{
arguments.Add(dropdown.value.ToString());
}
}
// pass surface inputs through
arguments.Add(inputVariableName);
foreach (var outSlot in asset.outputs)
{
arguments.Add(GetVariableNameForSlot(outSlot.id));
}
foreach (var feedbackSlot in asset.vtFeedbackVariables)
{
string feedbackVar = GetVariableNameForNode() + "_" + feedbackSlot;
sb.AppendLine("{0} {1};", ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Single), feedbackVar);
arguments.Add(feedbackVar);
}
sb.AppendIndentation();
sb.Append(asset.functionName);
sb.Append("(");
bool firstArg = true;
foreach (var arg in arguments)
{
if (!firstArg)
{
sb.Append(", ");
}
firstArg = false;
sb.Append(arg);
}
sb.Append(");");
sb.AppendNewLine();
}
