void ValidateShaderStage()
{
List <MaterialSlot> slots = new List <MaterialSlot>();
GetInputSlots(slots);
foreach (MaterialSlot slot in slots)
{
slot.stageCapability = ShaderStageCapability.All;
}
var effectiveStage = ShaderStageCapability.All;
foreach (var slot in slots)
{
var stage = NodeUtils.GetEffectiveShaderStageCapability(slot, true);
if (stage != ShaderStageCapability.All)
{
effectiveStage = stage;
break;
}
}
foreach (MaterialSlot slot in slots)
{
slot.stageCapability = effectiveStage;
}
}
public override List<Port> GetCompatiblePorts(Port startAnchor, NodeAdapter nodeAdapter)
{
var compatibleAnchors = new List<Port>();
var startSlot = startAnchor.GetSlot();
if (startSlot == null)
return compatibleAnchors;
var startStage = startSlot.stageCapability;
if (startStage == ShaderStageCapability.All)
startStage = NodeUtils.GetEffectiveShaderStageCapability(startSlot, true) & NodeUtils.GetEffectiveShaderStageCapability(startSlot, false);
foreach (var candidateAnchor in ports.ToList())
{
var candidateSlot = candidateAnchor.GetSlot();
if (!startSlot.IsCompatibleWith(candidateSlot))
continue;
if (startStage != ShaderStageCapability.All)
{
var candidateStage = candidateSlot.stageCapability;
if (candidateStage == ShaderStageCapability.All)
candidateStage = NodeUtils.GetEffectiveShaderStageCapability(candidateSlot, true)
& NodeUtils.GetEffectiveShaderStageCapability(candidateSlot, false);
if (candidateStage != ShaderStageCapability.All && candidateStage != startStage)
continue;
}
compatibleAnchors.Add(candidateAnchor);
}
return compatibleAnchors;
}
private void ValidateShaderStage()
{
List<MaterialSlot> slots = new List<MaterialSlot>();
GetInputSlots(slots);
GetOutputSlots(slots);
var subGraphOutputNode = outputNode;
if (outputNode != null)
{
var outputStage = ((SubGraphOutputNode)subGraphOutputNode).effectiveShaderStage;
foreach(MaterialSlot slot in slots)
slot.stageCapability = outputStage;
}
ShaderStageCapability effectiveStage = ShaderStageCapability.All;
foreach(MaterialSlot slot in slots)
{
ShaderStageCapability stage = NodeUtils.GetEffectiveShaderStageCapability(slot, slot.slotType == SlotType.Output);
if(stage != ShaderStageCapability.All)
{
effectiveStage = stage;
break;
}
}
foreach(MaterialSlot slot in slots)
slot.stageCapability = effectiveStage;
}
static void CollectInputCapabilities(SubGraphAsset asset, GraphData graph)
{
// Collect each input's capabilities. There can be multiple property nodes
// contributing to the same input, so we cache these in a map while building
var inputCapabilities = new Dictionary <string, SlotCapability>();
// Walk all property node output slots, computing and caching the capabilities for that slot
var propertyNodes = graph.GetNodes <PropertyNode>();
foreach (var propertyNode in propertyNodes)
{
foreach (var slot in propertyNode.GetOutputSlots <MaterialSlot>())
{
var slotName = slot.RawDisplayName();
SlotCapability capabilityInfo;
if (!inputCapabilities.TryGetValue(slotName, out capabilityInfo))
{
capabilityInfo = new SlotCapability();
capabilityInfo.slotName = slotName;
inputCapabilities.Add(propertyNode.property.displayName, capabilityInfo);
}
capabilityInfo.capabilities &= NodeUtils.GetEffectiveShaderStageCapability(slot, false);
}
}
asset.inputCapabilities.AddRange(inputCapabilities.Values);
}
public bool IsCompatibleStageWith(MaterialSlot otherSlot)
{
var startStage = otherSlot.stageCapability;
if (startStage == ShaderStageCapability.All)
{
startStage = NodeUtils.GetEffectiveShaderStageCapability(otherSlot, true)
& NodeUtils.GetEffectiveShaderStageCapability(otherSlot, false);
}
return(startStage == ShaderStageCapability.All || stageCapability == ShaderStageCapability.All || stageCapability == startStage);
}
void ValidateShaderStage()
{
List <MaterialSlot> slots = new List <MaterialSlot>();
GetInputSlots(slots);
// Reset all input slots back to All, otherwise they'll be incorrectly configured when traversing below
foreach (MaterialSlot slot in slots)
{
slot.stageCapability = ShaderStageCapability.All;
}
foreach (var slot in slots)
{
slot.stageCapability = NodeUtils.GetEffectiveShaderStageCapability(slot, true);
}
}
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();
}
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.nodeProperties.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;
asset.outputs.Clear();
outputNode.GetInputSlots(asset.outputs);
List <AbstractMaterialNode> nodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(nodes, outputNode);
asset.effectiveShaderStage = ShaderStageCapability.All;
foreach (var slot in asset.outputs)
{
var stage = NodeUtils.GetEffectiveShaderStageCapability(slot, true);
if (stage != ShaderStageCapability.All)
{
asset.effectiveShaderStage = stage;
break;
}
}
asset.requirements = ShaderGraphRequirements.FromNodes(nodes, asset.effectiveShaderStage, false);
asset.inputs = graph.properties.ToList();
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, new GraphContext(asset.inputStructName), GenerationMode.ForReals);
registry.builder.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
}
registry.ProvideFunction(asset.functionName, sb =>
{
var graphContext = new GraphContext(asset.inputStructName);
GraphUtil.GenerateSurfaceInputStruct(sb, asset.requirements, asset.inputStructName);
sb.AppendNewLine();
// Generate arguments... first INPUTS
var arguments = new List <string>();
foreach (var prop in asset.inputs)
{
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 asset.outputs)
{
arguments.Add($"out {output.concreteValueType.ToShaderString(asset.outputPrecision)} {output.shaderOutputName}_{output.id}");
}
// 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, graphContext, GenerationMode.ForReals);
sb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
}
foreach (var slot in asset.outputs)
{
sb.AppendLine($"{slot.shaderOutputName}_{slot.id} = {outputNode.GetSlotValue(slot.id, GenerationMode.ForReals, asset.outputPrecision)};");
}
}
});
asset.functions.AddRange(registry.names.Select(x => new FunctionPair(x, registry.sources[x])));
var collector = new PropertyCollector();
asset.nodeProperties = collector.properties;
foreach (var node in nodes)
{
node.CollectShaderProperties(collector, GenerationMode.ForReals);
}
asset.OnBeforeSerialize();
}
static void ProcessSubGraph(Dictionary <string, SubGraphData> subGraphMap, FunctionRegistry registry, SubGraphData subGraphData, GraphData graph)
{
registry.names.Clear();
subGraphData.functionNames.Clear();
subGraphData.nodeProperties.Clear();
subGraphData.isValid = true;
graph.OnEnable();
graph.messageManager.ClearAll();
graph.ValidateGraph();
var assetPath = AssetDatabase.GUIDToAssetPath(subGraphData.assetGuid);
subGraphData.hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
subGraphData.inputStructName = $"Bindings_{subGraphData.hlslName}_{subGraphData.assetGuid}";
subGraphData.functionName = $"SG_{subGraphData.hlslName}_{subGraphData.assetGuid}";
subGraphData.path = graph.path;
var outputNode = (SubGraphOutputNode)graph.outputNode;
subGraphData.outputs.Clear();
outputNode.GetInputSlots(subGraphData.outputs);
List <AbstractMaterialNode> nodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(nodes, outputNode);
subGraphData.effectiveShaderStage = ShaderStageCapability.All;
foreach (var slot in subGraphData.outputs)
{
var stage = NodeUtils.GetEffectiveShaderStageCapability(slot, true);
if (stage != ShaderStageCapability.All)
{
subGraphData.effectiveShaderStage = stage;
break;
}
}
subGraphData.requirements = ShaderGraphRequirements.FromNodes(nodes, subGraphData.effectiveShaderStage, false);
subGraphData.inputs = graph.properties.ToList();
foreach (var node in nodes)
{
if (node.hasError)
{
subGraphData.isValid = false;
registry.ProvideFunction(subGraphData.functionName, sb => { });
return;
}
}
foreach (var node in nodes)
{
if (node is SubGraphNode subGraphNode)
{
var nestedData = subGraphMap[subGraphNode.subGraphGuid];
foreach (var functionName in nestedData.functionNames)
{
registry.names.Add(functionName);
}
}
else if (node is IGeneratesFunction generatesFunction)
{
generatesFunction.GenerateNodeFunction(registry, new GraphContext(subGraphData.inputStructName), GenerationMode.ForReals);
}
}
registry.ProvideFunction(subGraphData.functionName, sb =>
{
var graphContext = new GraphContext(subGraphData.inputStructName);
GraphUtil.GenerateSurfaceInputStruct(sb, subGraphData.requirements, subGraphData.inputStructName);
sb.AppendNewLine();
// Generate arguments... first INPUTS
var arguments = new List <string>();
foreach (var prop in subGraphData.inputs)
{
arguments.Add(string.Format("{0}", prop.GetPropertyAsArgumentString()));
}
// now pass surface inputs
arguments.Add(string.Format("{0} IN", subGraphData.inputStructName));
// Now generate outputs
foreach (var output in subGraphData.outputs)
{
arguments.Add($"out {output.concreteValueType.ToString(outputNode.precision)} {output.shaderOutputName}_{output.id}");
}
// Create the function prototype from the arguments
sb.AppendLine("void {0}({1})"
, subGraphData.functionName
, arguments.Aggregate((current, next) => $"{current}, {next}"));
// now generate the function
using (sb.BlockScope())
{
// Just grab the body from the active nodes
var bodyGenerator = new ShaderGenerator();
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode)
{
(node as IGeneratesBodyCode).GenerateNodeCode(bodyGenerator, graphContext, GenerationMode.ForReals);
}
}
foreach (var slot in subGraphData.outputs)
{
bodyGenerator.AddShaderChunk($"{slot.shaderOutputName}_{slot.id} = {outputNode.GetSlotValue(slot.id, GenerationMode.ForReals)};");
}
sb.Append(bodyGenerator.GetShaderString(1));
}
});
subGraphData.functionNames.AddRange(registry.names.Distinct());
var collector = new PropertyCollector();
subGraphData.nodeProperties = collector.properties;
foreach (var node in nodes)
{
node.CollectShaderProperties(collector, GenerationMode.ForReals);
}
subGraphData.OnBeforeSerialize();
}
public void SubGraphDescendentsTests()
{
var graphPath = targetUnityDirectoryPath + "/ShaderStageCapability_Graph.shadergraph";
string fileContents = File.ReadAllText(graphPath);
var graphGuid = AssetDatabase.AssetPathToGUID(graphPath);
var messageManager = new MessageManager();
GraphData graphData = new GraphData()
{
assetGuid = graphGuid, messageManager = messageManager
};
MultiJson.Deserialize(graphData, fileContents);
graphData.OnEnable();
graphData.ValidateGraph();
var subGraphnodeName = "ShaderStageCapability_SubGraph";
var subGraphNode = FindFirstNodeOfType <SubGraphNode>(graphData, subGraphnodeName);
if (subGraphNode == null)
{
Assert.Fail("Failed to find sub graph node for {0}", subGraphnodeName);
return;
}
var expectedSlotCapabilities = new Dictionary <string, ShaderStageCapability>
{
{ "NotConnectedOut", ShaderStageCapability.All },
{ "NotConnectedInput", ShaderStageCapability.All },
{ "InternalVertexLockedOut", ShaderStageCapability.Vertex },
{ "InternalFragmentLockedOut", ShaderStageCapability.Fragment },
{ "InternalBothLockedOut", ShaderStageCapability.None },
{ "InternalVertexLockedInput", ShaderStageCapability.Vertex },
{ "InternalFragmentLockedInput", ShaderStageCapability.Fragment },
{ "InternalBothLockedInput", ShaderStageCapability.None },
// Output A is connected to InputA which is attached to a vertex locked node in the parent graph
{ "OutputA", ShaderStageCapability.Vertex },
// Output B is connected to InputB which is attached to a fragment locked node in the parent graph
{ "OutputB", ShaderStageCapability.Fragment },
// OutputAB is connected to InputA and InputB
{ "OutputAB", ShaderStageCapability.None },
// InputC is connected to OutputC which is hooked up to the vertex output in the parent graph
{ "InputC", ShaderStageCapability.Vertex },
// InputD is connected to OutputD which is hooked up to the fragment output in the parent graph
{ "InputD", ShaderStageCapability.Fragment },
// InputEF is split into OutputE and OutputF which are hooked up to vertex and fragment outputs in the parent graph
{ "InputEF", ShaderStageCapability.None },
};
var slotNameToId = new Dictionary <string, MaterialSlot>();
var slots = subGraphNode.GetSlots <MaterialSlot>();
foreach (var slot in slots)
{
slotNameToId[slot.RawDisplayName()] = slot;
}
foreach (var expectedSlotResult in expectedSlotCapabilities)
{
var slotName = expectedSlotResult.Key;
var expectedSlotValue = expectedSlotResult.Value;
if (slotNameToId.TryGetValue(slotName, out var slot))
{
var capabilities = NodeUtils.GetEffectiveShaderStageCapability(slot, true) & NodeUtils.GetEffectiveShaderStageCapability(slot, false);
Assert.AreEqual(capabilities, expectedSlotValue, "Slot {0} expected shader capability {1} but was {2}", slotName, expectedSlotValue, capabilities);
}
else
{
Assert.Fail("Expected slot {0} wasn't found", slotName);
}
}
}
