public string SanitizePropertyName(string displayName, Guid guid = default(Guid))
{
displayName = displayName.Trim();
return(GraphUtil.SanitizeName(m_Properties.Where(p => p.guid != guid).Select(p => p.displayName), "{0} ({1})", displayName));
}
private static string GetShaderPassFromTemplate(string template, PBRMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions)
{
var builder = new ShaderStringBuilder();
builder.IncreaseIndent();
builder.IncreaseIndent();
var vertexInputs = new ShaderGenerator();
var surfaceVertexShader = new ShaderGenerator();
var surfaceDescriptionFunction = new ShaderGenerator();
var surfaceDescriptionStruct = new ShaderGenerator();
var functionRegistry = new FunctionRegistry(builder);
var surfaceInputs = new ShaderGenerator();
var shaderProperties = new PropertyCollector();
surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
surfaceInputs.Indent();
var activeNodeList = ListPool <INode> .Get();
NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
var requirements = ShaderGraphRequirements.FromNodes(activeNodeList);
var modelRequiements = ShaderGraphRequirements.none;
modelRequiements.requiresNormal |= NeededCoordinateSpace.World;
modelRequiements.requiresTangent |= NeededCoordinateSpace.World;
modelRequiements.requiresBitangent |= NeededCoordinateSpace.World;
modelRequiements.requiresPosition |= NeededCoordinateSpace.World;
modelRequiements.requiresViewDir |= NeededCoordinateSpace.World;
modelRequiements.requiresMeshUVs.Add(UVChannel.UV1);
GraphUtil.GenerateApplicationVertexInputs(requirements.Union(modelRequiements), vertexInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresViewDir, InterpolatorType.ViewDirection, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresPosition, InterpolatorType.Position, surfaceInputs);
if (requirements.requiresVertexColor)
{
surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.VertexColor), false);
}
if (requirements.requiresScreenPosition)
{
surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.ScreenPosition), false);
}
foreach (var channel in requirements.requiresMeshUVs.Distinct())
{
surfaceInputs.AddShaderChunk(string.Format("half4 {0};", channel.GetUVName()), false);
}
surfaceInputs.Deindent();
surfaceInputs.AddShaderChunk("};", false);
surfaceVertexShader.AddShaderChunk("GraphVertexInput PopulateVertexData(GraphVertexInput v){", false);
surfaceVertexShader.Indent();
surfaceVertexShader.AddShaderChunk("return v;", false);
surfaceVertexShader.Deindent();
surfaceVertexShader.AddShaderChunk("}", false);
var slots = new List <MaterialSlot>();
foreach (var id in pass.PixelShaderSlots)
{
slots.Add(masterNode.FindSlot <MaterialSlot>(id));
}
GraphUtil.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
var usedSlots = new List <MaterialSlot>();
foreach (var id in pass.PixelShaderSlots)
{
usedSlots.Add(masterNode.FindSlot <MaterialSlot>(id));
}
GraphUtil.GenerateSurfaceDescription(
activeNodeList,
masterNode,
masterNode.owner as AbstractMaterialGraph,
surfaceDescriptionFunction,
functionRegistry,
shaderProperties,
requirements,
mode,
"PopulateSurfaceData",
"SurfaceDescription",
null,
usedSlots);
var graph = new ShaderGenerator();
graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
graph.AddShaderChunk(builder.ToString(), false);
graph.AddShaderChunk(vertexInputs.GetShaderString(2), false);
graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
var blendingVisitor = new ShaderGenerator();
var cullingVisitor = new ShaderGenerator();
var zTestVisitor = new ShaderGenerator();
var zWriteVisitor = new ShaderGenerator();
materialOptions.GetBlend(blendingVisitor);
materialOptions.GetCull(cullingVisitor);
materialOptions.GetDepthTest(zTestVisitor);
materialOptions.GetDepthWrite(zWriteVisitor);
var interpolators = new ShaderGenerator();
var localVertexShader = new ShaderGenerator();
var localPixelShader = new ShaderGenerator();
var localSurfaceInputs = new ShaderGenerator();
var surfaceOutputRemap = new ShaderGenerator();
ShaderGenerator.GenerateStandardTransforms(
3,
10,
interpolators,
localVertexShader,
localPixelShader,
localSurfaceInputs,
requirements,
modelRequiements,
CoordinateSpace.World);
ShaderGenerator defines = new ShaderGenerator();
if (masterNode.IsSlotConnected(PBRMasterNode.NormalSlotId))
{
defines.AddShaderChunk("#define _NORMALMAP 1", true);
}
if (masterNode.model == PBRMasterNode.Model.Specular)
{
defines.AddShaderChunk("#define _SPECULAR_SETUP 1", true);
}
if (masterNode.IsSlotConnected(PBRMasterNode.AlphaThresholdSlotId))
{
defines.AddShaderChunk("#define _AlphaClip 1", true);
}
var templateLocation = ShaderGenerator.GetTemplatePath(template);
foreach (var slot in usedSlots)
{
surfaceOutputRemap.AddShaderChunk(string.Format("{0} = surf.{0};", slot.shaderOutputName), true);
}
if (!File.Exists(templateLocation))
{
return(string.Empty);
}
var subShaderTemplate = File.ReadAllText(templateLocation);
var resultPass = subShaderTemplate.Replace("${Defines}", defines.GetShaderString(3));
resultPass = resultPass.Replace("${Graph}", graph.GetShaderString(3));
resultPass = resultPass.Replace("${Interpolators}", interpolators.GetShaderString(3));
resultPass = resultPass.Replace("${VertexShader}", localVertexShader.GetShaderString(3));
resultPass = resultPass.Replace("${LocalPixelShader}", localPixelShader.GetShaderString(3));
resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
resultPass = resultPass.Replace("${Tags}", string.Empty);
resultPass = resultPass.Replace("${Blending}", blendingVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${Culling}", cullingVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
return(resultPass);
}
public sealed override void UpdateNodeAfterDeserialization()
{
var method = GetFunctionToConvert();
if (method == null)
{
throw new ArgumentException("Mapped method is null on node" + this);
}
if (method.ReturnType != typeof(string))
{
throw new ArgumentException("Mapped function should return string");
}
// validate no duplicates
var slotAtributes = method.GetParameters().Select(GetSlotAttribute).ToList();
if (slotAtributes.Any(x => x == null))
{
throw new ArgumentException("Missing SlotAttribute on " + method.Name);
}
if (slotAtributes.GroupBy(x => x.slotId).Any(x => x.Count() > 1))
{
throw new ArgumentException("Duplicate SlotAttribute on " + method.Name);
}
List <MaterialSlot> slots = new List <MaterialSlot>();
foreach (var par in method.GetParameters())
{
var attribute = GetSlotAttribute(par);
var name = GraphUtil.ConvertCamelCase(par.Name, true);
MaterialSlot s;
if (attribute.binding == Binding.None && !par.IsOut && par.ParameterType == typeof(Color))
{
s = new ColorRGBAMaterialSlot(attribute.slotId, name, par.Name, SlotType.Input, attribute.defaultValue ?? Vector4.zero, stageCapability: attribute.stageCapability, hidden: attribute.hidden);
}
else if (attribute.binding == Binding.None && !par.IsOut && par.ParameterType == typeof(ColorRGBA))
{
s = new ColorRGBAMaterialSlot(attribute.slotId, name, par.Name, SlotType.Input, attribute.defaultValue ?? Vector4.zero, stageCapability: attribute.stageCapability, hidden: attribute.hidden);
}
else if (attribute.binding == Binding.None && !par.IsOut && par.ParameterType == typeof(ColorRGB))
{
s = new ColorRGBMaterialSlot(attribute.slotId, name, par.Name, SlotType.Input, attribute.defaultValue ?? Vector4.zero, ColorMode.Default, stageCapability: attribute.stageCapability, hidden: attribute.hidden);
}
else if (attribute.binding == Binding.None || par.IsOut)
{
s = MaterialSlot.CreateMaterialSlot(
ConvertTypeToSlotValueType(par),
attribute.slotId,
name,
par.Name,
par.IsOut ? SlotType.Output : SlotType.Input,
attribute.defaultValue ?? Vector4.zero,
shaderStageCapability: attribute.stageCapability,
hidden: attribute.hidden);
}
else
{
s = CreateBoundSlot(attribute.binding, attribute.slotId, name, par.Name, attribute.stageCapability, attribute.hidden);
}
slots.Add(s);
m_Slots.Add(attribute);
}
foreach (var slot in slots)
{
AddSlot(slot);
}
RemoveSlotsNameNotMatching(slots.Select(x => x.id));
}
public void OnAfterDeserialize()
{
// have to deserialize 'globals' before nodes
m_Properties = SerializationHelper.Deserialize <AbstractShaderProperty>(m_SerializedProperties, GraphUtil.GetLegacyTypeRemapping());
var nodes = SerializationHelper.Deserialize <AbstractMaterialNode>(m_SerializableNodes, GraphUtil.GetLegacyTypeRemapping());
m_Nodes = new List <AbstractMaterialNode>(nodes.Count);
m_NodeDictionary = new Dictionary <Guid, AbstractMaterialNode>(nodes.Count);
foreach (var node in nodes.OfType <AbstractMaterialNode>())
{
node.owner = this;
node.UpdateNodeAfterDeserialization();
node.tempId = new Identifier(m_Nodes.Count);
m_Nodes.Add(node);
m_NodeDictionary.Add(node.guid, node);
if (m_GroupNodes.ContainsKey(node.groupGuid))
{
m_GroupNodes[node.groupGuid].Add(node);
}
else
{
m_GroupNodes.Add(node.groupGuid, new List <AbstractMaterialNode>()
{
node
});
}
}
m_SerializableNodes = null;
m_Edges = SerializationHelper.Deserialize <IEdge>(m_SerializableEdges, GraphUtil.GetLegacyTypeRemapping());
m_SerializableEdges = null;
foreach (var edge in m_Edges)
{
AddEdgeToNodeEdges(edge);
}
m_OutputNode = null;
}
public virtual void OnAfterDeserialize()
{
if (!string.IsNullOrEmpty(m_GuidSerialized))
{
m_Guid = new Guid(m_GuidSerialized);
}
else
{
m_Guid = Guid.NewGuid();
}
if (!string.IsNullOrEmpty(m_GroupGuidSerialized))
{
m_GroupGuid = new Guid(m_GroupGuidSerialized);
}
else
{
m_GroupGuid = Guid.Empty;
}
m_Slots = SerializationHelper.Deserialize <ISlot>(m_SerializableSlots, GraphUtil.GetLegacyTypeRemapping());
m_SerializableSlots = null;
foreach (var s in m_Slots)
{
s.owner = this;
}
UpdateNodeAfterDeserialization();
}
public override void OnInspectorGUI()
{
GraphData GetGraphData(AssetImporter importer)
{
var textGraph = File.ReadAllText(importer.assetPath, Encoding.UTF8);
var graphObject = CreateInstance <GraphObject>();
graphObject.hideFlags = HideFlags.HideAndDontSave;
bool isSubGraph;
var extension = Path.GetExtension(importer.assetPath).Replace(".", "");
switch (extension)
{
case ShaderGraphImporter.Extension:
isSubGraph = false;
break;
case ShaderGraphImporter.LegacyExtension:
isSubGraph = false;
break;
case ShaderSubGraphImporter.Extension:
isSubGraph = true;
break;
default:
throw new Exception($"Invalid file extension {extension}");
}
var assetGuid = AssetDatabase.AssetPathToGUID(importer.assetPath);
graphObject.graph = new GraphData
{
assetGuid = assetGuid,
isSubGraph = isSubGraph,
messageManager = null
};
MultiJson.Deserialize(graphObject.graph, textGraph);
graphObject.graph.OnEnable();
graphObject.graph.ValidateGraph();
return(graphObject.graph);
}
if (GUILayout.Button("Open Shader Editor"))
{
AssetImporter importer = target as AssetImporter;
Debug.Assert(importer != null, "importer != null");
ShowGraphEditWindow(importer.assetPath);
}
using (var horizontalScope = new GUILayout.HorizontalScope("box"))
{
AssetImporter importer = target as AssetImporter;
string assetName = Path.GetFileNameWithoutExtension(importer.assetPath);
string path = String.Format("Temp/GeneratedFromGraph-{0}.shader", assetName.Replace(" ", ""));
bool alreadyExists = File.Exists(path);
bool update = false;
bool open = false;
if (GUILayout.Button("View Generated Shader"))
{
update = true;
open = true;
}
if (alreadyExists && GUILayout.Button("Regenerate"))
{
update = true;
}
if (update)
{
var graphData = GetGraphData(importer);
var generator = new Generator(graphData, null, GenerationMode.ForReals, assetName, humanReadable: true);
if (!GraphUtil.WriteToFile(path, generator.generatedShader))
{
open = false;
}
}
if (open)
{
GraphUtil.OpenFile(path);
}
}
if (Unsupported.IsDeveloperMode())
{
if (GUILayout.Button("View Preview Shader"))
{
AssetImporter importer = target as AssetImporter;
string assetName = Path.GetFileNameWithoutExtension(importer.assetPath);
string path = String.Format("Temp/GeneratedFromGraph-{0}-Preview.shader", assetName.Replace(" ", ""));
var graphData = GetGraphData(importer);
var generator = new Generator(graphData, null, GenerationMode.Preview, $"{assetName}-Preview", humanReadable: true);
if (GraphUtil.WriteToFile(path, generator.generatedShader))
{
GraphUtil.OpenFile(path);
}
}
}
if (GUILayout.Button("Copy Shader"))
{
AssetImporter importer = target as AssetImporter;
string assetName = Path.GetFileNameWithoutExtension(importer.assetPath);
var graphData = GetGraphData(importer);
var generator = new Generator(graphData, null, GenerationMode.ForReals, assetName, humanReadable: true);
GUIUtility.systemCopyBuffer = generator.generatedShader;
}
ApplyRevertGUI();
if (materialEditor)
{
EditorGUILayout.Space();
materialEditor.DrawHeader();
using (new EditorGUI.DisabledGroupScope(true))
materialEditor.OnInspectorGUI();
}
}
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}");
}
// 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} = {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();
}
private static string GetShaderPassFromTemplate(UnlitMasterNode masterNode, Pass pass, GenerationMode mode)
{
var builder = new ShaderStringBuilder();
builder.IncreaseIndent();
builder.IncreaseIndent();
var surfaceDescriptionFunction = new ShaderGenerator();
var surfaceDescriptionStruct = new ShaderGenerator();
var surfaceInputs = new ShaderGenerator();
var functionRegistry = new FunctionRegistry(builder);
var shaderProperties = new PropertyCollector();
surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
surfaceInputs.Indent();
var activeNodeList = ListPool <INode> .Get();
NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
var requirements = ShaderGraphRequirements.FromNodes(activeNodeList);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresViewDir, InterpolatorType.ViewDirection, surfaceInputs);
ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresPosition, InterpolatorType.Position, surfaceInputs);
ShaderGenerator defines = new ShaderGenerator();
defines.AddShaderChunk(string.Format("#define SHADERPASS {0}", pass.ShaderPassName), true);
if (requirements.requiresVertexColor)
{
surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.VertexColor), false);
}
if (requirements.requiresScreenPosition)
{
surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.ScreenPosition), false);
}
foreach (var channel in requirements.requiresMeshUVs.Distinct())
{
surfaceInputs.AddShaderChunk(string.Format("half4 {0};", channel.GetUVName()), false);
defines.AddShaderChunk(string.Format("#define ATTRIBUTES_NEED_TEXCOORD{0}", (int)channel), true);
defines.AddShaderChunk(string.Format("#define VARYINGS_NEED_TEXCOORD{0}", (int)channel), true);
}
surfaceInputs.Deindent();
surfaceInputs.AddShaderChunk("};", false);
var slots = new List <MaterialSlot>();
foreach (var id in pass.PixelShaderSlots)
{
var slot = masterNode.FindSlot <MaterialSlot>(id);
if (slot != null)
{
slots.Add(slot);
}
}
GraphUtil.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
var usedSlots = new List <MaterialSlot>();
foreach (var id in pass.PixelShaderSlots)
{
usedSlots.Add(masterNode.FindSlot <MaterialSlot>(id));
}
GraphUtil.GenerateSurfaceDescription(
activeNodeList,
masterNode,
masterNode.owner as AbstractMaterialGraph,
surfaceDescriptionFunction,
functionRegistry,
shaderProperties,
requirements,
mode,
"PopulateSurfaceData",
"SurfaceDescription",
null,
usedSlots);
var graph = new ShaderGenerator();
graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
graph.AddShaderChunk(builder.ToString(), false);
graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
var tagsVisitor = new ShaderGenerator();
var blendingVisitor = new ShaderGenerator();
var cullingVisitor = new ShaderGenerator();
var zTestVisitor = new ShaderGenerator();
var zWriteVisitor = new ShaderGenerator();
var materialOptions = new SurfaceMaterialOptions();
materialOptions.GetTags(tagsVisitor);
materialOptions.GetBlend(blendingVisitor);
materialOptions.GetCull(cullingVisitor);
materialOptions.GetDepthTest(zTestVisitor);
materialOptions.GetDepthWrite(zWriteVisitor);
var localPixelShader = new ShaderGenerator();
var localSurfaceInputs = new ShaderGenerator();
var surfaceOutputRemap = new ShaderGenerator();
foreach (var channel in requirements.requiresMeshUVs.Distinct())
{
localSurfaceInputs.AddShaderChunk(string.Format("surfaceInput.{0} = {1};", channel.GetUVName(), string.Format("half4(input.texCoord{0}, 0, 0)", (int)channel)), false);
}
var templateLocation = ShaderGenerator.GetTemplatePath("HDUnlitPassForward.template");
foreach (var slot in usedSlots)
{
surfaceOutputRemap.AddShaderChunk(slot.shaderOutputName
+ " = surf."
+ slot.shaderOutputName + ";", true);
}
if (!File.Exists(templateLocation))
{
return(string.Empty);
}
var subShaderTemplate = File.ReadAllText(templateLocation);
var resultPass = subShaderTemplate.Replace("${Defines}", defines.GetShaderString(3));
resultPass = resultPass.Replace("${Graph}", graph.GetShaderString(3));
resultPass = resultPass.Replace("${LocalPixelShader}", localPixelShader.GetShaderString(3));
resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
resultPass = resultPass.Replace("${LightMode}", pass.Name);
resultPass = resultPass.Replace("${ShaderPassInclude}", pass.ShaderPassInclude);
resultPass = resultPass.Replace("${Tags}", tagsVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${Blending}", blendingVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${Culling}", cullingVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
resultPass = resultPass.Replace("${LOD}", "" + materialOptions.lod);
return(resultPass);
}
public override void OnAfterDeserialize()
{
m_SubShaders = SerializationHelper.Deserialize <T>(m_SerializableSubShaders, GraphUtil.GetLegacyTypeRemapping());
m_SubShaders.RemoveAll(x => x == null);
m_SerializableSubShaders = null;
base.OnAfterDeserialize();
}
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.SetConcretePrecision(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}");
}
// 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("{0} = {1};", slot.shaderOutputName, 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();
}
public void GenerateNodeCode(ShaderStringBuilder sb, GraphContext graphContext, GenerationMode generationMode)
{
if (subGraphData == null || hasError)
{
var outputSlots = new List <MaterialSlot>();
GetOutputSlots(outputSlots);
foreach (var slot in outputSlots)
{
sb.AppendLine($"{slot.concreteValueType.ToShaderString(subGraphData.outputPrecision)} {GetVariableNameForSlot(slot.id)} = {slot.GetDefaultValue(GenerationMode.ForReals)};");
}
return;
}
var inputVariableName = $"_{GetVariableNameForNode()}";
GraphUtil.GenerateSurfaceInputTransferCode(sb, subGraphData.requirements, subGraphData.inputStructName, inputVariableName);
foreach (var outSlot in subGraphData.outputs)
{
sb.AppendLine("{0} {1};", outSlot.concreteValueType.ToShaderString(subGraphData.outputPrecision), GetVariableNameForSlot(outSlot.id));
}
var arguments = new List <string>();
foreach (var prop in subGraphData.inputs)
{
prop.SetConcretePrecision(subGraphData.graphPrecision);
var inSlotId = m_PropertyIds[m_PropertyGuids.IndexOf(prop.guid.ToString())];
if (prop is TextureShaderProperty)
{
arguments.Add(string.Format("TEXTURE2D_ARGS({0}, sampler{0})", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
}
else if (prop is Texture2DArrayShaderProperty)
{
arguments.Add(string.Format("TEXTURE2D_ARRAY_ARGS({0}, sampler{0})", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
}
else if (prop is Texture3DShaderProperty)
{
arguments.Add(string.Format("TEXTURE3D_ARGS({0}, sampler{0})", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
}
else if (prop is CubemapShaderProperty)
{
arguments.Add(string.Format("TEXTURECUBE_ARGS({0}, sampler{0})", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
}
else
{
arguments.Add(string.Format("{0}", GetSlotValue(inSlotId, generationMode, prop.concretePrecision)));
}
}
// pass surface inputs through
arguments.Add(inputVariableName);
foreach (var outSlot in subGraphData.outputs)
{
arguments.Add(GetVariableNameForSlot(outSlot.id));
}
sb.AppendLine("{0}({1});", subGraphData.functionName, arguments.Aggregate((current, next) => string.Format("{0}, {1}", current, next)));
}
public static void CreateCustomMasterMaterialGraph()
{
GraphUtil.CreateNewGraph(new CustomMasterNode());
}
public static void CreateBlankShaderGraph()
{
GraphUtil.CreateNewGraph();
}