public static string GetPreviewSubShader(AbstractMaterialNode node, ShaderGraphRequirements shaderGraphRequirements)
{
// Should never be called without a node
Debug.Assert(node != null);
var vertexOutputStruct = new ShaderStringBuilder(2);
var vertexShader = new ShaderStringBuilder(2);
var vertexShaderDescriptionInputs = new ShaderStringBuilder(2);
var vertexShaderOutputs = new ShaderStringBuilder(1);
var pixelShader = new ShaderStringBuilder(2);
var pixelShaderSurfaceInputs = new ShaderStringBuilder(2);
var pixelShaderSurfaceRemap = new ShaderStringBuilder(2);
ShaderGenerator.GenerateStandardTransforms(
0,
16,
vertexOutputStruct,
vertexShader,
vertexShaderDescriptionInputs,
vertexShaderOutputs,
pixelShader,
pixelShaderSurfaceInputs,
shaderGraphRequirements,
shaderGraphRequirements,
ShaderGraphRequirements.none,
ShaderGraphRequirements.none,
CoordinateSpace.World);
vertexShader.AppendLines(vertexShaderDescriptionInputs.ToString());
vertexShader.AppendLines(vertexShaderOutputs.ToString());
var outputSlot = node.GetOutputSlots <MaterialSlot>().FirstOrDefault();
// Sub Graph Output uses first input slot
if (node is SubGraphOutputNode)
{
outputSlot = node.GetInputSlots <MaterialSlot>().FirstOrDefault();
}
if (outputSlot != null)
{
var result = $"surf.{NodeUtils.GetHLSLSafeName(outputSlot.shaderOutputName)}_{outputSlot.id}";
pixelShaderSurfaceRemap.AppendLine("return all(isfinite({0})) ? {1} : {2};",
result, AdaptNodeOutputForPreview(node, outputSlot.id, result), nanOutput);
}
else
{
// No valid slots to display, so just show black.
// It's up to each node to error or warn as appropriate.
pixelShaderSurfaceRemap.AppendLine("return 0;");
}
// -------------------------------------
// Extra pixel shader work
var faceSign = new ShaderStringBuilder();
if (shaderGraphRequirements.requiresFaceSign)
{
faceSign.AppendLine(", half FaceSign : VFACE");
}
var res = subShaderTemplate.Replace("${Interpolators}", vertexOutputStruct.ToString());
res = res.Replace("${VertexShader}", vertexShader.ToString());
res = res.Replace("${FaceSign}", faceSign.ToString());
res = res.Replace("${LocalPixelShader}", pixelShader.ToString());
res = res.Replace("${SurfaceInputs}", pixelShaderSurfaceInputs.ToString());
res = res.Replace("${SurfaceOutputRemap}", pixelShaderSurfaceRemap.ToString());
return(res);
}
public void GetPropertiesDeclaration(ShaderStringBuilder builder, GenerationMode mode, ConcretePrecision inheritedPrecision)
{
foreach (var prop in properties)
{
prop.ValidateConcretePrecision(inheritedPrecision);
}
// build a list of all HLSL properties
var hlslProps = BuildHLSLPropertyList();
if (mode == GenerationMode.Preview)
{
builder.AppendLine("CBUFFER_START(UnityPerMaterial)");
// all non-gpu instanced properties (even non-batchable ones!)
// this is because for preview we convert all properties to UnityPerMaterial properties
// as we will be submitting the default preview values via the Material.. :)
foreach (var h in hlslProps)
{
if ((h.declaration == HLSLDeclaration.UnityPerMaterial) ||
(h.declaration == HLSLDeclaration.Global))
{
h.AppendTo(builder);
}
}
// gpu-instanced properties
var gpuInstancedProps = hlslProps.Where(h => h.declaration == HLSLDeclaration.HybridPerInstance);
if (gpuInstancedProps.Any())
{
builder.AppendLine("#ifdef UNITY_HYBRID_V1_INSTANCING_ENABLED");
foreach (var h in gpuInstancedProps)
{
h.AppendTo(builder, name => name + "_dummy");
}
builder.AppendLine("#else // V2");
foreach (var h in gpuInstancedProps)
{
h.AppendTo(builder);
}
builder.AppendLine("#endif");
}
builder.AppendLine("CBUFFER_END");
return;
}
// Hybrid V1 generates a special version of UnityPerMaterial, which has dummy constants for
// instanced properties, and regular constants for other properties.
// Hybrid V2 generates a perfectly normal UnityPerMaterial, but needs to append
// a UNITY_DOTS_INSTANCING_START/END block after it that contains the instanced properties.
#if !ENABLE_HYBRID_RENDERER_V2
builder.AppendLine("CBUFFER_START(UnityPerMaterial)");
// non-GPU-instanced batchable properties go first in the UnityPerMaterial cbuffer
foreach (var h in hlslProps)
{
if (h.declaration == HLSLDeclaration.UnityPerMaterial)
{
h.AppendTo(builder);
}
}
// followed by GPU-instanced batchable properties
var gpuInstancedProperties = hlslProps.Where(h => h.declaration == HLSLDeclaration.HybridPerInstance);
if (gpuInstancedProperties.Any())
{
builder.AppendLine("#ifdef UNITY_HYBRID_V1_INSTANCING_ENABLED");
foreach (var hlslProp in gpuInstancedProperties)
{
hlslProp.AppendTo(builder, name => name + "_dummy");
}
builder.AppendLine("#else");
foreach (var hlslProp in gpuInstancedProperties)
{
hlslProp.AppendTo(builder);
}
builder.AppendLine("#endif");
}
builder.AppendLine("CBUFFER_END");
#else
// TODO: need to test this path with HYBRID_RENDERER_V2 ...
builder.AppendLine("CBUFFER_START(UnityPerMaterial)");
int instancedCount = 0;
foreach (var h in hlslProps)
{
if (h.declaration == HLSLDeclaration.UnityPerMaterial)
{
h.AppendTo(builder);
}
else if (h.declaration == HLSLDeclaration.HybridPerInstance)
{
instancedCount++;
}
}
if (instancedCount > 0)
{
builder.AppendLine("// Hybrid instanced properties");
foreach (var h in hlslProps.Where(h => h.declaration == HLSLDeclaration.HybridPerInstance))
{
h.AppendTo(builder);
}
}
builder.AppendLine("CBUFFER_END");
if (instancedCount > 0)
{
builder.AppendLine("#if defined(UNITY_DOTS_INSTANCING_ENABLED)");
builder.AppendLine("// DOTS instancing definitions");
builder.AppendLine("UNITY_DOTS_INSTANCING_START(MaterialPropertyMetadata)");
foreach (var h in hlslProps.Where(h => h.declaration == HLSLDeclaration.HybridPerInstance))
{
var n = h.name;
string type = h.GetValueTypeString();
builder.AppendLine($" UNITY_DOTS_INSTANCED_PROP({type}, {n})");
}
builder.AppendLine("UNITY_DOTS_INSTANCING_END(MaterialPropertyMetadata)");
builder.AppendLine("// DOTS instancing usage macros");
foreach (var h in hlslProps.Where(h => h.declaration == HLSLDeclaration.HybridPerInstance))
{
var n = h.name;
string type = h.GetValueTypeString();
builder.AppendLine($"#define {n} UNITY_ACCESS_DOTS_INSTANCED_PROP_FROM_MACRO({type}, Metadata_{n})");
}
builder.AppendLine("#endif");
}
#endif
builder.AppendNewLine();
builder.AppendLine("// Object and Global properties");
foreach (var h in hlslProps)
{
if (h.declaration == HLSLDeclaration.Global)
{
h.AppendTo(builder);
}
}
}
// TODO: Fix this
static ShaderGraphVfxAsset GenerateVfxShaderGraphAsset(GraphData graph)
{
var target = graph.activeTargets.FirstOrDefault(x => x is VFXTarget) as VFXTarget;
if (target == null)
{
return(null);
}
var nl = Environment.NewLine;
var indent = new string(' ', 4);
var asset = ScriptableObject.CreateInstance <ShaderGraphVfxAsset>();
var result = asset.compilationResult = new GraphCompilationResult();
var mode = GenerationMode.ForReals;
asset.lit = target.lit;
asset.alphaClipping = target.alphaTest;
var assetGuid = graph.assetGuid;
var assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
var hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
var ports = new List <MaterialSlot>();
var nodes = new List <AbstractMaterialNode>();
foreach (var vertexBlock in graph.vertexContext.blocks)
{
vertexBlock.value.GetInputSlots(ports);
NodeUtils.DepthFirstCollectNodesFromNode(nodes, vertexBlock);
}
foreach (var fragmentBlock in graph.fragmentContext.blocks)
{
fragmentBlock.value.GetInputSlots(ports);
NodeUtils.DepthFirstCollectNodesFromNode(nodes, fragmentBlock);
}
//Remove inactive blocks from generation
{
var tmpCtx = new TargetActiveBlockContext(new List <BlockFieldDescriptor>(), null);
target.GetActiveBlocks(ref tmpCtx);
ports.RemoveAll(materialSlot =>
{
return(!tmpCtx.activeBlocks.Any(o => materialSlot.RawDisplayName() == o.displayName));
});
}
var bodySb = new ShaderStringBuilder(1);
var registry = new FunctionRegistry(new ShaderStringBuilder(), true);
foreach (var properties in graph.properties)
{
properties.ValidateConcretePrecision(graph.concretePrecision);
}
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode bodyGenerator)
{
bodySb.currentNode = node;
bodyGenerator.GenerateNodeCode(bodySb, mode);
bodySb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
if (node is IGeneratesFunction generatesFunction)
{
registry.builder.currentNode = node;
generatesFunction.GenerateNodeFunction(registry, mode);
}
}
bodySb.currentNode = null;
var portNodeSets = new HashSet <AbstractMaterialNode> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
var nodeSet = new HashSet <AbstractMaterialNode>();
NodeUtils.CollectNodeSet(nodeSet, port);
portNodeSets[portIndex] = nodeSet;
}
var portPropertySets = new HashSet <string> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertySets[portIndex] = new HashSet <string>();
}
foreach (var node in nodes)
{
if (!(node is PropertyNode propertyNode))
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(node))
{
portPropertySets[portIndex].Add(propertyNode.property.objectId);
}
}
}
var shaderProperties = new PropertyCollector();
foreach (var node in nodes)
{
node.CollectShaderProperties(shaderProperties, GenerationMode.ForReals);
}
asset.SetTextureInfos(shaderProperties.GetConfiguredTextures());
var codeSnippets = new List <string>();
var portCodeIndices = new List <int> [ports.Count];
var sharedCodeIndices = new List <int>();
for (var i = 0; i < portCodeIndices.Length; i++)
{
portCodeIndices[i] = new List <int>();
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"#include \"Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl\"{nl}");
for (var registryIndex = 0; registryIndex < registry.names.Count; registryIndex++)
{
var name = registry.names[registryIndex];
var source = registry.sources[name];
var precision = source.nodes.First().concretePrecision;
var hasPrecisionMismatch = false;
var nodeNames = new HashSet <string>();
foreach (var node in source.nodes)
{
nodeNames.Add(node.name);
if (node.concretePrecision != precision)
{
hasPrecisionMismatch = true;
break;
}
}
if (hasPrecisionMismatch)
{
var message = new StringBuilder($"Precision mismatch for function {name}:");
foreach (var node in source.nodes)
{
message.AppendLine($"{node.name} ({node.objectId}): {node.concretePrecision}");
}
throw new InvalidOperationException(message.ToString());
}
var code = source.code.Replace(PrecisionUtil.Token, precision.ToShaderString());
code = $"// Node: {string.Join(", ", nodeNames)}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code + nl);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
foreach (var node in source.nodes)
{
if (portNodeSet.Contains(node))
{
portCodeIndices[portIndex].Add(codeIndex);
break;
}
}
}
}
foreach (var property in graph.properties)
{
if (property.isExposable && property.generatePropertyBlock)
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.objectId))
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
}
ShaderStringBuilder builder = new ShaderStringBuilder();
property.ForeachHLSLProperty(h => h.AppendTo(builder));
codeSnippets.Add($"// Property: {property.displayName}{nl}{builder.ToCodeBlock()}{nl}{nl}");
}
var inputStructName = $"SG_Input_{assetGuid}";
var outputStructName = $"SG_Output_{assetGuid}";
var evaluationFunctionName = $"SG_Evaluate_{assetGuid}";
#region Input Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {inputStructName}{nl}{{{nl}");
#region Requirements
var portRequirements = new ShaderGraphRequirements[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var requirementsNodes = portNodeSets[portIndex].ToList();
requirementsNodes.Add(ports[portIndex].owner);
portRequirements[portIndex] = ShaderGraphRequirements.FromNodes(requirementsNodes, ports[portIndex].stageCapability);
}
var portIndices = new List <int>();
portIndices.Capacity = ports.Count;
void AddRequirementsSnippet(Func <ShaderGraphRequirements, bool> predicate, string snippet)
{
portIndices.Clear();
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
if (predicate(portRequirements[portIndex]))
{
portIndices.Add(portIndex);
}
}
if (portIndices.Count > 0)
{
foreach (var portIndex in portIndices)
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
codeSnippets.Add($"{indent}{snippet};{nl}");
}
}
void AddCoordinateSpaceSnippets(InterpolatorType interpolatorType, Func <ShaderGraphRequirements, NeededCoordinateSpace> selector)
{
foreach (var space in EnumInfo <CoordinateSpace> .values)
{
var neededSpace = space.ToNeededCoordinateSpace();
AddRequirementsSnippet(r => (selector(r) & neededSpace) > 0, $"float3 {space.ToVariableName(interpolatorType)}");
}
}
// TODO: Rework requirements system to make this better
AddCoordinateSpaceSnippets(InterpolatorType.Normal, r => r.requiresNormal);
AddCoordinateSpaceSnippets(InterpolatorType.Tangent, r => r.requiresTangent);
AddCoordinateSpaceSnippets(InterpolatorType.BiTangent, r => r.requiresBitangent);
AddCoordinateSpaceSnippets(InterpolatorType.ViewDirection, r => r.requiresViewDir);
AddCoordinateSpaceSnippets(InterpolatorType.Position, r => r.requiresPosition);
AddRequirementsSnippet(r => r.requiresVertexColor, $"float4 {ShaderGeneratorNames.VertexColor}");
AddRequirementsSnippet(r => r.requiresScreenPosition, $"float4 {ShaderGeneratorNames.ScreenPosition}");
AddRequirementsSnippet(r => r.requiresFaceSign, $"float4 {ShaderGeneratorNames.FaceSign}");
foreach (var uvChannel in EnumInfo <UVChannel> .values)
{
AddRequirementsSnippet(r => r.requiresMeshUVs.Contains(uvChannel), $"half4 {uvChannel.GetUVName()}");
}
AddRequirementsSnippet(r => r.requiresTime, $"float3 {ShaderGeneratorNames.TimeParameters}");
#endregion
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"}};{nl}{nl}");
#endregion
// VFX Code heavily relies on the slotId from the original MasterNodes
// Since we keep these around for upgrades anyway, for now it is simpler to use them
// Therefore we remap the output blocks back to the original Ids here
var originialPortIds = new int[ports.Count];
for (int i = 0; i < originialPortIds.Length; i++)
{
if (!VFXTarget.s_BlockMap.TryGetValue((ports[i].owner as BlockNode).descriptor, out var originalId))
{
continue;
}
// In Master Nodes we had a different BaseColor/Color slot id between Unlit/Lit
// In the stack we use BaseColor for both cases. Catch this here.
if (asset.lit && originalId == ShaderGraphVfxAsset.ColorSlotId)
{
originalId = ShaderGraphVfxAsset.BaseColorSlotId;
}
originialPortIds[i] = originalId;
}
#region Output Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {outputStructName}{nl}{{");
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}{port.concreteValueType.ToShaderString(graph.concretePrecision)} {port.shaderOutputName}_{originialPortIds[portIndex]};");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}}};{nl}{nl}");
#endregion
#region Graph Function
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{outputStructName} {evaluationFunctionName}({nl}{indent}{inputStructName} IN");
var inputProperties = new List <AbstractShaderProperty>();
var portPropertyIndices = new List <int> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertyIndices[portIndex] = new List <int>();
}
foreach (var property in graph.properties)
{
if (!property.isExposable || !property.generatePropertyBlock)
{
continue;
}
var propertyIndex = inputProperties.Count;
var codeIndex = codeSnippets.Count;
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.objectId))
{
portCodeIndices[portIndex].Add(codeIndex);
portPropertyIndices[portIndex].Add(propertyIndex);
}
}
inputProperties.Add(property);
codeSnippets.Add($",{nl}{indent}/* Property: {property.displayName} */ {property.GetPropertyAsArgumentStringForVFX()}");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"){nl}{{");
#region Node Code
for (var mappingIndex = 0; mappingIndex < bodySb.mappings.Count; mappingIndex++)
{
var mapping = bodySb.mappings[mappingIndex];
var code = bodySb.ToString(mapping.startIndex, mapping.count);
if (string.IsNullOrWhiteSpace(code))
{
continue;
}
code = $"{nl}{indent}// Node: {mapping.node.name}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(mapping.node))
{
portCodeIndices[portIndex].Add(codeIndex);
}
}
}
#endregion
#region Output Mapping
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}// VFXMasterNode{nl}{indent}{outputStructName} OUT;{nl}");
// Output mapping
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{indent}OUT.{port.shaderOutputName}_{originialPortIds[portIndex]} = {port.owner.GetSlotValue(port.id, GenerationMode.ForReals, graph.concretePrecision)};{nl}");
}
#endregion
// Function end
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{indent}return OUT;{nl}}}{nl}");
#endregion
result.codeSnippets = codeSnippets.ToArray();
result.sharedCodeIndices = sharedCodeIndices.ToArray();
result.outputCodeIndices = new IntArray[ports.Count];
for (var i = 0; i < ports.Count; i++)
{
result.outputCodeIndices[i] = portCodeIndices[i].ToArray();
}
var outputMetadatas = new OutputMetadata[ports.Count];
for (int portIndex = 0; portIndex < outputMetadatas.Length; portIndex++)
{
outputMetadatas[portIndex] = new OutputMetadata(portIndex, ports[portIndex].shaderOutputName, originialPortIds[portIndex]);
}
asset.SetOutputs(outputMetadatas);
asset.evaluationFunctionName = evaluationFunctionName;
asset.inputStructName = inputStructName;
asset.outputStructName = outputStructName;
asset.portRequirements = portRequirements;
asset.concretePrecision = graph.concretePrecision;
asset.SetProperties(inputProperties);
asset.outputPropertyIndices = new IntArray[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
asset.outputPropertyIndices[portIndex] = portPropertyIndices[portIndex].ToArray();
}
return(asset);
}
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
bool success = false;
if (IsSlotConnected(VirtualTextureInputId))
{
var vtProperty = GetSlotProperty(VirtualTextureInputId) as VirtualTextureShaderProperty;
if (vtProperty != null)
{
var layerOutputVariables = new List <string>();
int layerCount = vtProperty.value.layers.Count;
for (int i = 0; i < layerCount; i++)
{
if (IsSlotConnected(OutputSlotIds[i]))
{
// declare output variables up front
string layerOutputVariable = GetVariableNameForSlot(OutputSlotIds[i]);
sb.AppendLine("$precision4 " + layerOutputVariable + ";");
layerOutputVariables.Add(layerOutputVariable);
}
}
if (layerOutputVariables.Count > 0)
{
// assign feedback variable
sb.AppendIndentation();
if (!noFeedback)
{
sb.Append("float4 ");
sb.Append(GetFeedbackVariableName());
sb.Append(" = ");
}
sb.Append(GetFunctionName(out var unused));
sb.Append("(");
sb.Append(GetSlotValue(UVInputId, generationMode));
switch (lodCalculation)
{
case LodCalculation.VtLevel_Lod:
case LodCalculation.VtLevel_Bias:
sb.Append(", ");
sb.Append((lodCalculation == LodCalculation.VtLevel_Lod) ? GetSlotValue(LODInputId, generationMode) : GetSlotValue(BiasInputId, generationMode));
break;
case LodCalculation.VtLevel_Derivatives:
sb.Append(", ");
sb.Append(GetSlotValue(DxInputId, generationMode));
sb.Append(", ");
sb.Append(GetSlotValue(DyInputId, generationMode));
break;
}
sb.Append(", ");
sb.Append(vtProperty.referenceName);
foreach (string layerOutputVariable in layerOutputVariables)
{
sb.Append(", ");
sb.Append(layerOutputVariable);
}
sb.Append(");");
sb.AppendNewLine();
success = true;
}
}
}
if (!success)
{
// set all outputs to zero
for (int i = 0; i < kMaxLayers; i++)
{
if (IsSlotConnected(OutputSlotIds[i]))
{
// declare output variables up front
string layerOutputVariable = GetVariableNameForSlot(OutputSlotIds[i]);
sb.AppendLine("$precision4 " + layerOutputVariable + " = 0;");
}
}
// TODO: should really just disable feedback in this case (need different feedback interface to do this)
sb.AppendLine("$precision4 " + GetFeedbackVariableName() + " = 1;");
}
}
public virtual void AppendHLSLParameterDeclaration(ShaderStringBuilder sb, string paramName)
{
sb.Append(concreteValueType.ToShaderString());
sb.Append(" ");
sb.Append(paramName);
}
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);
}
if (masterNode.surfaceType == SurfaceType.Transparent && masterNode.alphaMode == AlphaMode.Premultiply)
{
defines.AddShaderChunk("#define _ALPHAPREMULTIPLY_ON 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 static GenerationResults GetShader(this AbstractMaterialGraph graph, AbstractMaterialNode node, GenerationMode mode, string name)
{
var results = new GenerationResults();
bool isUber = node == null;
var vertexInputs = new ShaderGenerator();
var vertexShader = new ShaderGenerator();
var surfaceDescriptionFunction = new ShaderGenerator();
var surfaceDescriptionStruct = new ShaderGenerator();
var functionBuilder = new ShaderStringBuilder();
var functionRegistry = new FunctionRegistry(functionBuilder);
var surfaceInputs = new ShaderGenerator();
surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
surfaceInputs.Indent();
var activeNodeList = ListPool <INode> .Get();
if (isUber)
{
var unmarkedNodes = graph.GetNodes <INode>().Where(x => !(x is IMasterNode)).ToDictionary(x => x.guid);
while (unmarkedNodes.Any())
{
var unmarkedNode = unmarkedNodes.FirstOrDefault();
Visit(activeNodeList, unmarkedNodes, unmarkedNode.Value);
}
}
else
{
NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, node);
}
var requirements = ShaderGraphRequirements.FromNodes(activeNodeList);
GenerateApplicationVertexInputs(requirements, 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);
}
results.previewMode = PreviewMode.Preview3D;
if (!isUber)
{
foreach (var pNode in activeNodeList.OfType <AbstractMaterialNode>())
{
if (pNode.previewMode == PreviewMode.Preview3D)
{
results.previewMode = PreviewMode.Preview3D;
break;
}
}
}
foreach (var channel in requirements.requiresMeshUVs.Distinct())
{
surfaceInputs.AddShaderChunk(String.Format("half4 {0};", channel.GetUVName()), false);
}
surfaceInputs.Deindent();
surfaceInputs.AddShaderChunk("};", false);
vertexShader.AddShaderChunk("GraphVertexInput PopulateVertexData(GraphVertexInput v){", false);
vertexShader.Indent();
vertexShader.AddShaderChunk("return v;", false);
vertexShader.Deindent();
vertexShader.AddShaderChunk("}", false);
var slots = new List <MaterialSlot>();
foreach (var activeNode in isUber ? activeNodeList.Where(n => ((AbstractMaterialNode)n).hasPreview) : ((INode)node).ToEnumerable())
{
if (activeNode is IMasterNode)
{
slots.AddRange(activeNode.GetInputSlots <MaterialSlot>());
}
else
{
slots.AddRange(activeNode.GetOutputSlots <MaterialSlot>());
}
}
GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, !isUber);
var shaderProperties = new PropertyCollector();
results.outputIdProperty = new Vector1ShaderProperty
{
displayName = "OutputId",
generatePropertyBlock = false,
value = -1
};
if (isUber)
{
shaderProperties.AddShaderProperty(results.outputIdProperty);
}
GenerateSurfaceDescription(
activeNodeList,
node,
graph,
surfaceDescriptionFunction,
functionRegistry,
shaderProperties,
requirements,
mode,
outputIdProperty: results.outputIdProperty);
var finalBuilder = new ShaderStringBuilder();
finalBuilder.AppendLine(@"Shader ""{0}""", name);
using (finalBuilder.BlockScope())
{
finalBuilder.AppendLine("Properties");
using (finalBuilder.BlockScope())
{
finalBuilder.AppendLines(shaderProperties.GetPropertiesBlock(0));
}
finalBuilder.AppendLine(@"HLSLINCLUDE");
finalBuilder.AppendLine("#define USE_LEGACY_UNITY_MATRIX_VARIABLES");
finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Common.hlsl""");
finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Packing.hlsl""");
finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Color.hlsl""");
finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/UnityInstancing.hlsl""");
finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/EntityLighting.hlsl""");
finalBuilder.AppendLine(@"#include ""ShaderGraphLibrary/ShaderVariables.hlsl""");
finalBuilder.AppendLine(@"#include ""ShaderGraphLibrary/ShaderVariablesFunctions.hlsl""");
finalBuilder.AppendLine(@"#include ""ShaderGraphLibrary/Functions.hlsl""");
finalBuilder.AppendLines(shaderProperties.GetPropertiesDeclaration(0));
finalBuilder.AppendLines(surfaceInputs.GetShaderString(0));
finalBuilder.Concat(functionBuilder);
finalBuilder.AppendLines(vertexInputs.GetShaderString(0));
finalBuilder.AppendLines(surfaceDescriptionStruct.GetShaderString(0));
finalBuilder.AppendLines(vertexShader.GetShaderString(0));
finalBuilder.AppendLines(surfaceDescriptionFunction.GetShaderString(0));
finalBuilder.AppendLine(@"ENDHLSL");
finalBuilder.AppendLines(ShaderGenerator.GetPreviewSubShader(node, requirements));
ListPool <INode> .Release(activeNodeList);
}
results.configuredTextures = shaderProperties.GetConfiguredTexutres();
ShaderSourceMap sourceMap;
results.shader = finalBuilder.ToString(out sourceMap);
results.sourceMap = sourceMap;
return(results);
}
public static void GenerateApplicationVertexInputs(ShaderGraphRequirements graphRequirements, ShaderStringBuilder vertexInputs)
{
vertexInputs.AppendLine("struct GraphVertexInput");
using (vertexInputs.BlockSemicolonScope())
{
vertexInputs.AppendLine("float4 vertex : POSITION;");
if (graphRequirements.requiresNormal != NeededCoordinateSpace.None || graphRequirements.requiresBitangent != NeededCoordinateSpace.None)
{
vertexInputs.AppendLine("float3 normal : NORMAL;");
}
if (graphRequirements.requiresTangent != NeededCoordinateSpace.None || graphRequirements.requiresBitangent != NeededCoordinateSpace.None)
{
vertexInputs.AppendLine("float4 tangent : TANGENT;");
}
if (graphRequirements.requiresVertexColor)
{
vertexInputs.AppendLine("float4 color : COLOR;");
}
foreach (var channel in graphRequirements.requiresMeshUVs.Distinct())
{
vertexInputs.AppendLine("float4 texcoord{0} : TEXCOORD{0};", (int)channel);
}
vertexInputs.AppendLine("UNITY_VERTEX_INPUT_INSTANCE_ID");
}
}
public static GenerationResults GetShader(this GraphData graph, AbstractMaterialNode node, GenerationMode mode, string name)
{
// ----------------------------------------------------- //
// SETUP //
// ----------------------------------------------------- //
// -------------------------------------
// String builders
var finalShader = new ShaderStringBuilder();
var results = new GenerationResults();
var shaderProperties = new PropertyCollector();
var shaderKeywords = new KeywordCollector();
var shaderPropertyUniforms = new ShaderStringBuilder();
var shaderKeywordDeclarations = new ShaderStringBuilder();
var shaderKeywordPermutations = new ShaderStringBuilder(1);
var functionBuilder = new ShaderStringBuilder();
var functionRegistry = new FunctionRegistry(functionBuilder);
var vertexDescriptionFunction = new ShaderStringBuilder(0);
var surfaceDescriptionInputStruct = new ShaderStringBuilder(0);
var surfaceDescriptionStruct = new ShaderStringBuilder(0);
var surfaceDescriptionFunction = new ShaderStringBuilder(0);
var vertexInputs = new ShaderStringBuilder(0);
graph.CollectShaderKeywords(shaderKeywords, mode);
if (graph.GetKeywordPermutationCount() > ShaderGraphPreferences.variantLimit)
{
graph.AddValidationError(node.tempId, ShaderKeyword.kVariantLimitWarning, Rendering.ShaderCompilerMessageSeverity.Error);
results.configuredTextures = shaderProperties.GetConfiguredTexutres();
results.shader = string.Empty;
return(results);
}
// -------------------------------------
// Get Slot and Node lists
var activeNodeList = ListPool <AbstractMaterialNode> .Get();
NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, node);
var slots = new List <MaterialSlot>();
if (node is IMasterNode || node is SubGraphOutputNode)
{
slots.AddRange(node.GetInputSlots <MaterialSlot>());
}
else
{
var outputSlots = node.GetOutputSlots <MaterialSlot>().ToList();
if (outputSlots.Count > 0)
{
slots.Add(outputSlots[0]);
}
}
// -------------------------------------
// Get Requirements
var requirements = ShaderGraphRequirements.FromNodes(activeNodeList, ShaderStageCapability.Fragment);
// ----------------------------------------------------- //
// KEYWORDS //
// ----------------------------------------------------- //
// -------------------------------------
// Get keyword permutations
graph.CollectShaderKeywords(shaderKeywords, mode);
// Track permutation indicies for all nodes and requirements
List <int>[] keywordPermutationsPerNode = new List <int> [activeNodeList.Count];
// -------------------------------------
// Evaluate all permutations
for (int i = 0; i < shaderKeywords.permutations.Count; i++)
{
// Get active nodes for this permutation
var localNodes = ListPool <AbstractMaterialNode> .Get();
NodeUtils.DepthFirstCollectNodesFromNode(localNodes, node, keywordPermutation: shaderKeywords.permutations[i]);
// Track each pixel node in this permutation
foreach (AbstractMaterialNode pixelNode in localNodes)
{
int nodeIndex = activeNodeList.IndexOf(pixelNode);
if (keywordPermutationsPerNode[nodeIndex] == null)
{
keywordPermutationsPerNode[nodeIndex] = new List <int>();
}
keywordPermutationsPerNode[nodeIndex].Add(i);
}
// Get active requirements for this permutation
var localSurfaceRequirements = ShaderGraphRequirements.FromNodes(localNodes, ShaderStageCapability.Fragment, false);
var localPixelRequirements = ShaderGraphRequirements.FromNodes(localNodes, ShaderStageCapability.Fragment);
}
// ----------------------------------------------------- //
// START VERTEX DESCRIPTION //
// ----------------------------------------------------- //
// -------------------------------------
// Generate Vertex Description function
vertexDescriptionFunction.AppendLine("GraphVertexInput PopulateVertexData(GraphVertexInput v)");
using (vertexDescriptionFunction.BlockScope())
{
vertexDescriptionFunction.AppendLine("return v;");
}
// ----------------------------------------------------- //
// START SURFACE DESCRIPTION //
// ----------------------------------------------------- //
// -------------------------------------
// Generate Input structure for Surface Description function
// Surface Description Input requirements are needed to exclude intermediate translation spaces
GenerateSurfaceInputStruct(surfaceDescriptionInputStruct, requirements, "SurfaceDescriptionInputs");
results.previewMode = PreviewMode.Preview2D;
foreach (var pNode in activeNodeList)
{
if (pNode.previewMode == PreviewMode.Preview3D)
{
results.previewMode = PreviewMode.Preview3D;
break;
}
}
// -------------------------------------
// Generate Output structure for Surface Description function
GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, useIdsInNames: !(node is IMasterNode));
// -------------------------------------
// Generate Surface Description function
GenerateSurfaceDescriptionFunction(
activeNodeList,
keywordPermutationsPerNode,
node,
graph,
surfaceDescriptionFunction,
functionRegistry,
shaderProperties,
shaderKeywords,
mode,
outputIdProperty: results.outputIdProperty);
// ----------------------------------------------------- //
// GENERATE VERTEX > PIXEL PIPELINE //
// ----------------------------------------------------- //
// -------------------------------------
// Keyword declarations
shaderKeywords.GetKeywordsDeclaration(shaderKeywordDeclarations, mode);
// -------------------------------------
// Property uniforms
shaderProperties.GetPropertiesDeclaration(shaderPropertyUniforms, mode, graph.concretePrecision);
// -------------------------------------
// Generate Input structure for Vertex shader
GenerateApplicationVertexInputs(requirements, vertexInputs);
// ----------------------------------------------------- //
// FINALIZE //
// ----------------------------------------------------- //
// -------------------------------------
// Build final shader
finalShader.AppendLine(@"Shader ""{0}""", name);
using (finalShader.BlockScope())
{
SubShaderGenerator.GeneratePropertiesBlock(finalShader, shaderProperties, shaderKeywords, mode);
finalShader.AppendNewLine();
finalShader.AppendLine(@"HLSLINCLUDE");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.render-pipelines.core/ShaderLibrary/EntityLighting.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.shadergraph/ShaderGraphLibrary/ShaderVariables.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.shadergraph/ShaderGraphLibrary/ShaderVariablesFunctions.hlsl""");
finalShader.AppendLine(@"#include ""Assets/Scripts/URP/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl""");
finalShader.AppendLines(shaderKeywordDeclarations.ToString());
finalShader.AppendLine(@"#define SHADERGRAPH_PREVIEW 1");
finalShader.AppendNewLine();
finalShader.AppendLines(shaderKeywordPermutations.ToString());
finalShader.AppendLines(shaderPropertyUniforms.ToString());
finalShader.AppendNewLine();
finalShader.AppendLines(surfaceDescriptionInputStruct.ToString());
finalShader.AppendNewLine();
finalShader.Concat(functionBuilder);
finalShader.AppendNewLine();
finalShader.AppendLines(surfaceDescriptionStruct.ToString());
finalShader.AppendNewLine();
finalShader.AppendLines(surfaceDescriptionFunction.ToString());
finalShader.AppendNewLine();
finalShader.AppendLines(vertexInputs.ToString());
finalShader.AppendNewLine();
finalShader.AppendLines(vertexDescriptionFunction.ToString());
finalShader.AppendNewLine();
finalShader.AppendLine(@"ENDHLSL");
finalShader.AppendLines(ShaderGenerator.GetPreviewSubShader(node, requirements));
ListPool <AbstractMaterialNode> .Release(activeNodeList);
}
// -------------------------------------
// Finalize
results.configuredTextures = shaderProperties.GetConfiguredTexutres();
ShaderSourceMap sourceMap;
results.shader = finalShader.ToString(out sourceMap);
results.sourceMap = sourceMap;
return(results);
}
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
sb.AppendLine(string.Format("$precision3 {0} = $precision3{1};", GetVariableNameForSlot(kOutputSlotId), m_MaterialList[material].ToString(CultureInfo.InvariantCulture)));
}
// Node generations
public virtual void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
sb.AppendLine(string.Format("$precision {0} = {1}_TexelSize.z;", GetVariableNameForSlot(OutputSlotWId), GetSlotValue(TextureInputId, generationMode)));
sb.AppendLine(string.Format("$precision {0} = {1}_TexelSize.w;", GetVariableNameForSlot(OutputSlotHId), GetSlotValue(TextureInputId, generationMode)));
}
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
sb.AppendLine(string.Format("$precision {0} = {1};"
, GetVariableNameForNode()
, m_constantList[constant].ToString(CultureInfo.InvariantCulture)));
}
public void GenerateNodeCode(ShaderStringBuilder sb, GraphContext graphContext, GenerationMode generationMode)
{
var inputValue = GetSlotValue(InputSlotXId, generationMode);
sb.AppendLine(string.Format("$precision {0} = {1};", GetVariableNameForSlot(OutputSlotId), inputValue));
}
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 GetPropertiesDeclaration(ShaderStringBuilder builder, GenerationMode mode, ConcretePrecision inheritedPrecision)
{
foreach (var prop in properties)
{
prop.ValidateConcretePrecision(inheritedPrecision);
}
if (mode == GenerationMode.Preview)
{
builder.AppendLine("CBUFFER_START(UnityPerMaterial)");
foreach (var prop in properties.Where(p => !p.gpuInstanced)) // all non-gpu instanced properties (even non-batchable ones) - preview is weird
{
prop.AppendBatchablePropertyDeclarations(builder);
prop.AppendNonBatchablePropertyDeclarations(builder);
}
var GPUInstancedProperties = properties.Where(p => p.gpuInstanced);
if (GPUInstancedProperties.Any())
{
builder.AppendLine("#ifdef UNITY_HYBRID_V1_INSTANCING_ENABLED");
foreach (var prop in GPUInstancedProperties)
{
prop.AppendBatchablePropertyDeclarations(builder, "_dummy;");
}
builder.AppendLine("#else");
foreach (var prop in GPUInstancedProperties)
{
prop.AppendBatchablePropertyDeclarations(builder);
}
builder.AppendLine("#endif");
}
builder.AppendLine("CBUFFER_END");
return;
}
// Hybrid V1 generates a special version of UnityPerMaterial, which has dummy constants for
// instanced properties, and regular constants for other properties.
// Hybrid V2 generates a perfectly normal UnityPerMaterial, but needs to append
// a UNITY_DOTS_INSTANCING_START/END block after it that contains the instanced properties.
#if !ENABLE_HYBRID_RENDERER_V2
builder.AppendLine("CBUFFER_START(UnityPerMaterial)");
// non-GPU instanced properties go first in the UnityPerMaterial cbuffer
var batchableProperties = properties.Where(n => n.generatePropertyBlock && n.hasBatchableProperties);
foreach (var prop in batchableProperties)
{
if (!prop.gpuInstanced)
{
prop.AppendBatchablePropertyDeclarations(builder);
}
}
var batchableGPUInstancedProperties = batchableProperties.Where(p => p.gpuInstanced);
if (batchableGPUInstancedProperties.Any())
{
builder.AppendLine("#ifdef UNITY_HYBRID_V1_INSTANCING_ENABLED");
foreach (var prop in batchableGPUInstancedProperties)
{
// TODO: why is this inserting a dummy value? this won't work on complex properties...
prop.AppendBatchablePropertyDeclarations(builder, "_dummy;");
}
builder.AppendLine("#else");
foreach (var prop in batchableGPUInstancedProperties)
{
prop.AppendBatchablePropertyDeclarations(builder);
}
builder.AppendLine("#endif");
}
builder.AppendLine("CBUFFER_END");
#else
// TODO: need to test this path with HYBRID_RENDERER_V2 ...
builder.AppendLine("CBUFFER_START(UnityPerMaterial)");
int instancedCount = 0;
foreach (var prop in properties.Where(n => n.generatePropertyBlock && n.hasBatchableProperties))
{
if (!prop.gpuInstanced)
{
prop.AppendBatchablePropertyDeclarations(builder);
}
else
{
instancedCount++;
}
}
if (instancedCount > 0)
{
builder.AppendLine("// Hybrid instanced properties");
foreach (var prop in properties.Where(n => n.generatePropertyBlock && n.hasBatchableProperties))
{
if (prop.gpuInstanced)
{
prop.AppendBatchablePropertyDeclarations(builder);
}
}
}
builder.AppendLine("CBUFFER_END");
if (instancedCount > 0)
{
builder.AppendLine("#if defined(UNITY_DOTS_INSTANCING_ENABLED)");
builder.AppendLine("// DOTS instancing definitions");
builder.AppendLine("UNITY_DOTS_INSTANCING_START(MaterialPropertyMetadata)");
foreach (var prop in properties.Where(n => n.generatePropertyBlock && n.hasBatchableProperties))
{
if (prop.gpuInstanced)
{
var n = prop.referenceName;
string type = prop.concreteShaderValueType.ToShaderString(prop.concretePrecision);
builder.AppendLine($" UNITY_DOTS_INSTANCED_PROP({type}, {n})");
}
}
builder.AppendLine("UNITY_DOTS_INSTANCING_END(MaterialPropertyMetadata)");
builder.AppendLine("// DOTS instancing usage macros");
foreach (var prop in properties.Where(n => n.generatePropertyBlock && n.hasBatchableProperties))
{
if (prop.gpuInstanced)
{
var n = prop.referenceName;
string type = prop.concreteShaderValueType.ToShaderString(prop.concretePrecision);
builder.AppendLine($"#define {n} UNITY_ACCESS_DOTS_INSTANCED_PROP_FROM_MACRO({type}, Metadata_{n})");
}
}
builder.AppendLine("#endif");
}
#endif
// declare non-batchable properties
foreach (var prop in properties.Where(n => n.hasNonBatchableProperties || !n.generatePropertyBlock))
{
if (prop.hasBatchableProperties && !prop.generatePropertyBlock) // batchable properties that don't generate property block can't be instanced, get put here
{
prop.AppendBatchablePropertyDeclarations(builder);
}
prop.AppendNonBatchablePropertyDeclarations(builder);
}
}
public static void GetKeywordPermutationDeclarations(ShaderStringBuilder sb, List <List <KeyValuePair <ShaderKeyword, int> > > permutations)
{
if (permutations.Count == 0)
{
return;
}
for (int p = 0; p < permutations.Count; p++)
{
// ShaderStringBuilder.Append doesnt apply indentation
sb.AppendIndentation();
// Append correct if
bool isLast = false;
if (p == 0)
{
sb.Append("#if ");
}
else if (p == permutations.Count - 1)
{
sb.Append("#else");
isLast = true;
}
else
{
sb.Append("#elif ");
}
// Last permutation is always #else
if (!isLast)
{
// Track whether && is required
bool appendAnd = false;
// Iterate all keywords that are part of the permutation
for (int i = 0; i < permutations[p].Count; i++)
{
// When previous keyword was inserted subsequent requires &&
string and = appendAnd ? " && " : string.Empty;
switch (permutations[p][i].Key.keywordType)
{
case KeywordType.Enum:
{
sb.Append($"{and}defined({permutations[p][i].Key.referenceName}_{permutations[p][i].Key.entries[permutations[p][i].Value].referenceName})");
appendAnd = true;
break;
}
case KeywordType.Boolean:
{
// HLSL does not support a !value predicate
if (permutations[p][i].Value != 0)
{
continue;
}
sb.Append($"{and}defined({permutations[p][i].Key.referenceName})");
appendAnd = true;
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
}
sb.AppendNewLine();
// Define the matching permutation keyword
sb.IncreaseIndent();
sb.AppendLine($"#define KEYWORD_PERMUTATION_{p}");
sb.DecreaseIndent();
}
// End statement
sb.AppendLine("#endif");
}
public static bool GenerateShaderPass(AbstractMaterialNode masterNode, ShaderPass pass, GenerationMode mode,
ActiveFields activeFields, ShaderGenerator result, List <string> sourceAssetDependencyPaths,
List <Dependency[]> dependencies, string resourceClassName, string assemblyName)
{
// --------------------------------------------------
// 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();
masterNode.owner.CollectShaderKeywords(keywordCollector, mode);
// Get upstream nodes from ShaderPass port mask
List <AbstractMaterialNode> vertexNodes;
List <AbstractMaterialNode> pixelNodes;
GetUpstreamNodesForShaderPass(masterNode, 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;
GetActiveFieldsAndPermutationsForNodes(masterNode, pass, keywordCollector, vertexNodes, pixelNodes,
vertexNodePermutations, pixelNodePermutations, activeFields, out graphRequirements);
// GET CUSTOM ACTIVE FIELDS HERE!
// Get active fields from ShaderPass
AddRequiredFields(pass.requiredAttributes, activeFields.baseInstance);
AddRequiredFields(pass.requiredVaryings, activeFields.baseInstance);
// Get Port references from ShaderPass
var pixelSlots = FindMaterialSlotsOnNode(pass.pixelPorts, masterNode);
var vertexSlots = FindMaterialSlotsOnNode(pass.vertexPorts, masterNode);
// 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)
{
ShaderSpliceUtil.ApplyDependencies(instance, dependencies);
}
// --------------------------------------------------
// 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>");
}
// Render state
BuildRenderStatesFromPass(pass, ref spliceCommands);
// --------------------------------------------------
// Pass Code
// Pragmas
using (var passPragmaBuilder = new ShaderStringBuilder())
{
if (pass.pragmas != null)
{
foreach (string pragma in pass.pragmas)
{
passPragmaBuilder.AppendLine($"#pragma {pragma}");
}
}
if (passPragmaBuilder.length == 0)
{
passPragmaBuilder.AppendLine("// PassPragmas: <None>");
}
spliceCommands.Add("PassPragmas", passPragmaBuilder.ToCodeBlack());
}
// Includes
using (var passIncludeBuilder = new ShaderStringBuilder())
{
if (pass.includes != null)
{
foreach (string include in pass.includes)
{
passIncludeBuilder.AppendLine($"#include \"{include}\"");
}
}
if (passIncludeBuilder.length == 0)
{
passIncludeBuilder.AppendLine("// PassIncludes: <None>");
}
spliceCommands.Add("PassIncludes", passIncludeBuilder.ToCodeBlack());
}
// Keywords
using (var passKeywordBuilder = new ShaderStringBuilder())
{
if (pass.keywords != null)
{
foreach (KeywordDescriptor keyword in pass.keywords)
{
passKeywordBuilder.AppendLine(keyword.ToDeclarationString());
}
}
if (passKeywordBuilder.length == 0)
{
passKeywordBuilder.AppendLine("// PassKeywords: <None>");
}
spliceCommands.Add("PassKeywords", passKeywordBuilder.ToCodeBlack());
}
// --------------------------------------------------
// Graph Vertex
var vertexBuilder = new ShaderStringBuilder();
// If vertex modification enabled
if (activeFields.baseInstance.Contains("features.graphVertex"))
{
// Setup
string vertexGraphInputName = "VertexDescriptionInputs";
string vertexGraphOutputName = "VertexDescription";
string vertexGraphFunctionName = "VertexDescriptionFunction";
var vertexGraphInputGenerator = new ShaderGenerator();
var vertexGraphFunctionBuilder = new ShaderStringBuilder();
var vertexGraphOutputBuilder = new ShaderStringBuilder();
// Build vertex graph inputs
ShaderSpliceUtil.BuildType(GetTypeForStruct("VertexDescriptionInputs", resourceClassName, assemblyName), activeFields, vertexGraphInputGenerator, isDebug);
// Build vertex graph outputs
// Add struct fields to active fields
SubShaderGenerator.GenerateVertexDescriptionStruct(vertexGraphOutputBuilder, vertexSlots, vertexGraphOutputName, activeFields.baseInstance);
// Build vertex graph functions from ShaderPass vertex port mask
SubShaderGenerator.GenerateVertexDescriptionFunction(
masterNode.owner as GraphData,
vertexGraphFunctionBuilder,
functionRegistry,
propertyCollector,
keywordCollector,
mode,
masterNode,
vertexNodes,
vertexNodePermutations,
vertexSlots,
vertexGraphInputName,
vertexGraphFunctionName,
vertexGraphOutputName);
// Generate final shader strings
vertexBuilder.AppendLines(vertexGraphInputGenerator.GetShaderString(0, false));
vertexBuilder.AppendNewLine();
vertexBuilder.AppendLines(vertexGraphOutputBuilder.ToString());
vertexBuilder.AppendNewLine();
vertexBuilder.AppendLines(vertexGraphFunctionBuilder.ToString());
}
// Add to splice commands
if (vertexBuilder.length == 0)
{
vertexBuilder.AppendLine("// GraphVertex: <None>");
}
spliceCommands.Add("GraphVertex", vertexBuilder.ToCodeBlack());
// --------------------------------------------------
// Graph Pixel
// Setup
string pixelGraphInputName = "SurfaceDescriptionInputs";
string pixelGraphOutputName = "SurfaceDescription";
string pixelGraphFunctionName = "SurfaceDescriptionFunction";
var pixelGraphInputGenerator = new ShaderGenerator();
var pixelGraphOutputBuilder = new ShaderStringBuilder();
var pixelGraphFunctionBuilder = new ShaderStringBuilder();
// Build pixel graph inputs
ShaderSpliceUtil.BuildType(GetTypeForStruct("SurfaceDescriptionInputs", resourceClassName, assemblyName), activeFields, pixelGraphInputGenerator, isDebug);
// Build pixel graph outputs
// Add struct fields to active fields
SubShaderGenerator.GenerateSurfaceDescriptionStruct(pixelGraphOutputBuilder, pixelSlots, pixelGraphOutputName, activeFields.baseInstance);
// Build pixel graph functions from ShaderPass pixel port mask
SubShaderGenerator.GenerateSurfaceDescriptionFunction(
pixelNodes,
pixelNodePermutations,
masterNode,
masterNode.owner as GraphData,
pixelGraphFunctionBuilder,
functionRegistry,
propertyCollector,
keywordCollector,
mode,
pixelGraphFunctionName,
pixelGraphOutputName,
null,
pixelSlots,
pixelGraphInputName);
using (var pixelBuilder = new ShaderStringBuilder())
{
// Generate final shader strings
pixelBuilder.AppendLines(pixelGraphInputGenerator.GetShaderString(0, false));
pixelBuilder.AppendNewLine();
pixelBuilder.AppendLines(pixelGraphOutputBuilder.ToString());
pixelBuilder.AppendNewLine();
pixelBuilder.AppendLines(pixelGraphFunctionBuilder.ToString());
// Add to splice commands
if (pixelBuilder.length == 0)
{
pixelBuilder.AppendLine("// GraphPixel: <None>");
}
spliceCommands.Add("GraphPixel", pixelBuilder.ToCodeBlack());
}
// --------------------------------------------------
// Graph Functions
if (functionBuilder.length == 0)
{
functionBuilder.AppendLine("// GraphFunctions: <None>");
}
spliceCommands.Add("GraphFunctions", functionBuilder.ToCodeBlack());
// --------------------------------------------------
// Graph Keywords
using (var keywordBuilder = new ShaderStringBuilder())
{
keywordCollector.GetKeywordsDeclaration(keywordBuilder, mode);
if (keywordBuilder.length == 0)
{
keywordBuilder.AppendLine("// GraphKeywords: <None>");
}
spliceCommands.Add("GraphKeywords", keywordBuilder.ToCodeBlack());
}
// --------------------------------------------------
// Graph Properties
using (var propertyBuilder = new ShaderStringBuilder())
{
propertyCollector.GetPropertiesDeclaration(propertyBuilder, mode, masterNode.owner.concretePrecision);
if (propertyBuilder.length == 0)
{
propertyBuilder.AppendLine("// GraphProperties: <None>");
}
spliceCommands.Add("GraphProperties", propertyBuilder.ToCodeBlack());
}
// --------------------------------------------------
// Graph Defines
using (var graphDefines = new ShaderStringBuilder())
{
graphDefines.AppendLine("#define {0}", pass.referenceName);
if (graphRequirements.permutationCount > 0)
{
List <int> activePermutationIndices;
// Depth Texture
activePermutationIndices = graphRequirements.allPermutations.instances
.Where(p => p.requirements.requiresDepthTexture)
.Select(p => p.permutationIndex)
.ToList();
if (activePermutationIndices.Count > 0)
{
graphDefines.AppendLine(KeywordUtil.GetKeywordPermutationSetConditional(activePermutationIndices));
graphDefines.AppendLine("#define REQUIRE_DEPTH_TEXTURE");
graphDefines.AppendLine("#endif");
}
// Opaque Texture
activePermutationIndices = graphRequirements.allPermutations.instances
.Where(p => p.requirements.requiresCameraOpaqueTexture)
.Select(p => p.permutationIndex)
.ToList();
if (activePermutationIndices.Count > 0)
{
graphDefines.AppendLine(KeywordUtil.GetKeywordPermutationSetConditional(activePermutationIndices));
graphDefines.AppendLine("#define REQUIRE_OPAQUE_TEXTURE");
graphDefines.AppendLine("#endif");
}
}
else
{
// Depth Texture
if (graphRequirements.baseInstance.requirements.requiresDepthTexture)
{
graphDefines.AppendLine("#define REQUIRE_DEPTH_TEXTURE");
}
// Opaque Texture
if (graphRequirements.baseInstance.requirements.requiresCameraOpaqueTexture)
{
graphDefines.AppendLine("#define REQUIRE_OPAQUE_TEXTURE");
}
}
// Add to splice commands
spliceCommands.Add("GraphDefines", graphDefines.ToCodeBlack());
}
// --------------------------------------------------
// Main
// Main include is expected to contain vert/frag definitions for the pass
// This must be defined after all graph code
using (var mainBuilder = new ShaderStringBuilder())
{
mainBuilder.AppendLine($"#include \"{pass.varyingsInclude}\"");
mainBuilder.AppendLine($"#include \"{pass.passInclude}\"");
// Add to splice commands
spliceCommands.Add("MainInclude", mainBuilder.ToCodeBlack());
}
// --------------------------------------------------
// Debug
// Debug output all active fields
using (var debugBuilder = new ShaderStringBuilder())
{
if (isDebug)
{
// Active fields
debugBuilder.AppendLine("// ACTIVE FIELDS:");
foreach (string field in activeFields.baseInstance.fields)
{
debugBuilder.AppendLine("// " + field);
}
}
if (debugBuilder.length == 0)
{
debugBuilder.AppendLine("// <None>");
}
// Add to splice commands
spliceCommands.Add("Debug", debugBuilder.ToCodeBlack());
}
// --------------------------------------------------
// Finalize
// Get Template
string templateLocation = GetTemplatePath("PassMesh.template");
if (!File.Exists(templateLocation))
{
return(false);
}
// Get Template preprocessor
string templatePath = "Assets/com.unity.render-pipelines.universal/Editor/ShaderGraph/Templates";
var templatePreprocessor = new ShaderSpliceUtil.TemplatePreprocessor(activeFields, spliceCommands,
isDebug, templatePath, sourceAssetDependencyPaths, assemblyName, resourceClassName);
// Process Template
templatePreprocessor.ProcessTemplateFile(templateLocation);
result.AddShaderChunk(templatePreprocessor.GetShaderCode().ToString(), false);
return(true);
}
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();
}
// Node generations
public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
{
var sb = new ShaderStringBuilder();
sb.AppendLine("{0}3 {1}_UV = {2} * {3};", precision, GetVariableNameForNode(),
GetSlotValue(PositionInputId, generationMode), GetSlotValue(TileInputId, generationMode));
//Sampler input slot
var samplerSlot = FindInputSlot <MaterialSlot>(SamplerInputId);
var edgesSampler = owner.GetEdges(samplerSlot.slotReference);
var id = GetSlotValue(TextureInputId, generationMode);
switch (textureType)
{
// Whiteout blend method
// https://medium.com/@bgolus/normal-mapping-for-a-triplanar-shader-10bf39dca05a
case TextureType.Normal:
sb.AppendLine("{0}3 {1}_Blend = max(pow(abs({2}), {3}), 0);", precision, GetVariableNameForNode(),
GetSlotValue(NormalInputId, generationMode), GetSlotValue(BlendInputId, generationMode));
sb.AppendLine("{0}_Blend /= ({0}_Blend.x + {0}_Blend.y + {0}_Blend.z ).xxx;", GetVariableNameForNode());
sb.AppendLine("{0}3 {1}_X = UnpackNormalmapRGorAG(SAMPLE_TEXTURE2D({2}, {3}, {1}_UV.zy));"
, precision
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("{0}3 {1}_Y = UnpackNormalmapRGorAG(SAMPLE_TEXTURE2D({2}, {3}, {1}_UV.xz));"
, precision
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("{0}3 {1}_Z = UnpackNormalmapRGorAG(SAMPLE_TEXTURE2D({2}, {3}, {1}_UV.xy));"
, precision
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("{0}_X = {1}3({0}_X.xy + {2}.zy, abs({0}_X.z) * {2}.x);"
, GetVariableNameForNode()
, precision
, GetSlotValue(NormalInputId, generationMode));
sb.AppendLine("{0}_Y = {1}3({0}_Y.xy + {2}.xz, abs({0}_Y.z) * {2}.y);"
, GetVariableNameForNode()
, precision
, GetSlotValue(NormalInputId, generationMode));
sb.AppendLine("{0}_Z = {1}3({0}_Z.xy + {2}.xy, abs({0}_Z.z) * {2}.z);"
, GetVariableNameForNode()
, precision
, GetSlotValue(NormalInputId, generationMode));
sb.AppendLine("{0}4 {1} = {0}4(normalize({2}_X.zyx * {2}_Blend.x + {2}_Y.xzy * {2}_Blend.y + {2}_Z.xyz * {2}_Blend.z), 1);"
, precision
, GetVariableNameForSlot(OutputSlotId)
, GetVariableNameForNode());
sb.AppendLine("float3x3 {0}_Transform = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);", GetVariableNameForNode());
sb.AppendLine("{0}.rgb = TransformWorldToTangent({0}.rgb, {1}_Transform);"
, GetVariableNameForSlot(OutputSlotId)
, GetVariableNameForNode());
break;
default:
sb.AppendLine("{0}3 {1}_Blend = pow(abs({2}), {3});", precision, GetVariableNameForNode(),
GetSlotValue(NormalInputId, generationMode), GetSlotValue(BlendInputId, generationMode));
sb.AppendLine("{0}_Blend /= dot({0}_Blend, 1.0);", GetVariableNameForNode());
sb.AppendLine("{0}4 {1}_X = SAMPLE_TEXTURE2D({2}, {3}, {1}_UV.zy);"
, precision
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("{0}4 {1}_Y = SAMPLE_TEXTURE2D({2}, {3}, {1}_UV.xz);"
, precision
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("{0}4 {1}_Z = SAMPLE_TEXTURE2D({2}, {3}, {1}_UV.xy);"
, precision
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("{0}4 {1} = {2}_X * {2}_Blend.x + {2}_Y * {2}_Blend.y + {2}_Z * {2}_Blend.z;"
, precision
, GetVariableNameForSlot(OutputSlotId)
, GetVariableNameForNode());
break;
}
visitor.AddShaderChunk(sb.ToString(), false);
}
static ShaderGraphVfxAsset GenerateVfxShaderGraphAsset(VfxMasterNode masterNode)
{
var nl = Environment.NewLine;
var indent = new string(' ', 4);
var asset = ScriptableObject.CreateInstance <ShaderGraphVfxAsset>();
var result = asset.compilationResult = new GraphCompilationResult();
var mode = GenerationMode.ForReals;
var graph = masterNode.owner;
asset.lit = masterNode.lit.isOn;
var assetGuid = masterNode.owner.assetGuid;
var assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
var hlslName = NodeUtils.GetHLSLSafeName(Path.GetFileNameWithoutExtension(assetPath));
var ports = new List <MaterialSlot>();
masterNode.GetInputSlots(ports);
var nodes = new List <AbstractMaterialNode>();
NodeUtils.DepthFirstCollectNodesFromNode(nodes, masterNode);
var bodySb = new ShaderStringBuilder(1);
var registry = new FunctionRegistry(new ShaderStringBuilder(), true);
foreach (var properties in graph.properties)
{
properties.ValidateConcretePrecision(graph.concretePrecision);
}
foreach (var node in nodes)
{
if (node is IGeneratesBodyCode bodyGenerator)
{
bodySb.currentNode = node;
bodyGenerator.GenerateNodeCode(bodySb, mode);
bodySb.ReplaceInCurrentMapping(PrecisionUtil.Token, node.concretePrecision.ToShaderString());
}
if (node is IGeneratesFunction generatesFunction)
{
registry.builder.currentNode = node;
generatesFunction.GenerateNodeFunction(registry, mode);
}
}
bodySb.currentNode = null;
var portNodeSets = new HashSet <AbstractMaterialNode> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
var nodeSet = new HashSet <AbstractMaterialNode>();
NodeUtils.CollectNodeSet(nodeSet, port);
portNodeSets[portIndex] = nodeSet;
}
var portPropertySets = new HashSet <Guid> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertySets[portIndex] = new HashSet <Guid>();
}
foreach (var node in nodes)
{
if (!(node is PropertyNode propertyNode))
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(node))
{
portPropertySets[portIndex].Add(propertyNode.propertyGuid);
}
}
}
var shaderProperties = new PropertyCollector();
foreach (var node in nodes)
{
node.CollectShaderProperties(shaderProperties, GenerationMode.ForReals);
}
asset.SetTextureInfos(shaderProperties.GetConfiguredTexutres());
var codeSnippets = new List <string>();
var portCodeIndices = new List <int> [ports.Count];
var sharedCodeIndices = new List <int>();
for (var i = 0; i < portCodeIndices.Length; i++)
{
portCodeIndices[i] = new List <int>();
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"#include \"Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl\"{nl}");
for (var registryIndex = 0; registryIndex < registry.names.Count; registryIndex++)
{
var name = registry.names[registryIndex];
var source = registry.sources[name];
var precision = source.nodes.First().concretePrecision;
var hasPrecisionMismatch = false;
var nodeNames = new HashSet <string>();
foreach (var node in source.nodes)
{
nodeNames.Add(node.name);
if (node.concretePrecision != precision)
{
hasPrecisionMismatch = true;
break;
}
}
if (hasPrecisionMismatch)
{
var message = new StringBuilder($"Precision mismatch for function {name}:");
foreach (var node in source.nodes)
{
message.AppendLine($"{node.name} ({node.guid}): {node.concretePrecision}");
}
throw new InvalidOperationException(message.ToString());
}
var code = source.code.Replace(PrecisionUtil.Token, precision.ToShaderString());
code = $"// Node: {string.Join(", ", nodeNames)}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code + nl);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
foreach (var node in source.nodes)
{
if (portNodeSet.Contains(node))
{
portCodeIndices[portIndex].Add(codeIndex);
break;
}
}
}
}
foreach (var property in graph.properties)
{
if (property.isExposable && property.generatePropertyBlock)
{
continue;
}
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.guid))
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
}
codeSnippets.Add($"// Property: {property.displayName}{nl}{property.GetPropertyDeclarationString()}{nl}{nl}");
}
var inputStructName = $"SG_Input_{assetGuid}";
var outputStructName = $"SG_Output_{assetGuid}";
var evaluationFunctionName = $"SG_Evaluate_{assetGuid}";
#region Input Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {inputStructName}{nl}{{{nl}");
#region Requirements
var portRequirements = new ShaderGraphRequirements[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portRequirements[portIndex] = ShaderGraphRequirements.FromNodes(portNodeSets[portIndex].ToList(), ports[portIndex].stageCapability);
}
var portIndices = new List <int>();
portIndices.Capacity = ports.Count;
void AddRequirementsSnippet(Func <ShaderGraphRequirements, bool> predicate, string snippet)
{
portIndices.Clear();
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
if (predicate(portRequirements[portIndex]))
{
portIndices.Add(portIndex);
}
}
if (portIndices.Count > 0)
{
foreach (var portIndex in portIndices)
{
portCodeIndices[portIndex].Add(codeSnippets.Count);
}
codeSnippets.Add($"{indent}{snippet};{nl}");
}
}
void AddCoordinateSpaceSnippets(InterpolatorType interpolatorType, Func <ShaderGraphRequirements, NeededCoordinateSpace> selector)
{
foreach (var space in EnumInfo <CoordinateSpace> .values)
{
var neededSpace = space.ToNeededCoordinateSpace();
AddRequirementsSnippet(r => (selector(r) & neededSpace) > 0, $"float3 {space.ToVariableName(interpolatorType)}");
}
}
// TODO: Rework requirements system to make this better
AddCoordinateSpaceSnippets(InterpolatorType.Normal, r => r.requiresNormal);
AddCoordinateSpaceSnippets(InterpolatorType.Tangent, r => r.requiresTangent);
AddCoordinateSpaceSnippets(InterpolatorType.BiTangent, r => r.requiresBitangent);
AddCoordinateSpaceSnippets(InterpolatorType.ViewDirection, r => r.requiresViewDir);
AddCoordinateSpaceSnippets(InterpolatorType.Position, r => r.requiresPosition);
AddRequirementsSnippet(r => r.requiresVertexColor, $"float4 {ShaderGeneratorNames.VertexColor}");
AddRequirementsSnippet(r => r.requiresScreenPosition, $"float4 {ShaderGeneratorNames.ScreenPosition}");
AddRequirementsSnippet(r => r.requiresFaceSign, $"float4 {ShaderGeneratorNames.FaceSign}");
foreach (var uvChannel in EnumInfo <UVChannel> .values)
{
AddRequirementsSnippet(r => r.requiresMeshUVs.Contains(uvChannel), $"half4 {uvChannel.GetUVName()}");
}
AddRequirementsSnippet(r => r.requiresTime, $"float3 {ShaderGeneratorNames.TimeParameters}");
#endregion
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"}};{nl}{nl}");
#endregion
#region Output Struct
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"struct {outputStructName}{nl}{{");
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}{port.concreteValueType.ToShaderString(graph.concretePrecision)} {port.shaderOutputName}_{port.id};");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}}};{nl}{nl}");
#endregion
#region Graph Function
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{outputStructName} {evaluationFunctionName}({nl}{indent}{inputStructName} IN");
var inputProperties = new List <AbstractShaderProperty>();
var portPropertyIndices = new List <int> [ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
portPropertyIndices[portIndex] = new List <int>();
}
foreach (var property in graph.properties)
{
if (!property.isExposable || !property.generatePropertyBlock)
{
continue;
}
var propertyIndex = inputProperties.Count;
var codeIndex = codeSnippets.Count;
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portPropertySet = portPropertySets[portIndex];
if (portPropertySet.Contains(property.guid))
{
portCodeIndices[portIndex].Add(codeIndex);
portPropertyIndices[portIndex].Add(propertyIndex);
}
}
inputProperties.Add(property);
codeSnippets.Add($",{nl}{indent}/* Property: {property.displayName} */ {property.GetPropertyAsArgumentString()}");
}
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"){nl}{{");
#region Node Code
for (var mappingIndex = 0; mappingIndex < bodySb.mappings.Count; mappingIndex++)
{
var mapping = bodySb.mappings[mappingIndex];
var code = bodySb.ToString(mapping.startIndex, mapping.count);
if (string.IsNullOrWhiteSpace(code))
{
continue;
}
code = $"{nl}{indent}// Node: {mapping.node.name}{nl}{code}";
var codeIndex = codeSnippets.Count;
codeSnippets.Add(code);
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var portNodeSet = portNodeSets[portIndex];
if (portNodeSet.Contains(mapping.node))
{
portCodeIndices[portIndex].Add(codeIndex);
}
}
}
#endregion
#region Output Mapping
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{nl}{indent}// {masterNode.name}{nl}{indent}{outputStructName} OUT;{nl}");
// Output mapping
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
var port = ports[portIndex];
portCodeIndices[portIndex].Add(codeSnippets.Count);
codeSnippets.Add($"{indent}OUT.{port.shaderOutputName}_{port.id} = {masterNode.GetSlotValue(port.id, GenerationMode.ForReals, graph.concretePrecision)};{nl}");
}
#endregion
// Function end
sharedCodeIndices.Add(codeSnippets.Count);
codeSnippets.Add($"{indent}return OUT;{nl}}}{nl}");
#endregion
result.codeSnippets = codeSnippets.ToArray();
result.sharedCodeIndices = sharedCodeIndices.ToArray();
result.outputCodeIndices = new IntArray[ports.Count];
for (var i = 0; i < ports.Count; i++)
{
result.outputCodeIndices[i] = portCodeIndices[i].ToArray();
}
asset.SetOutputs(ports.Select((t, i) => new OutputMetadata(i, t.shaderOutputName, t.id)).ToArray());
asset.evaluationFunctionName = evaluationFunctionName;
asset.inputStructName = inputStructName;
asset.outputStructName = outputStructName;
asset.portRequirements = portRequirements;
asset.concretePrecision = graph.concretePrecision;
asset.SetProperties(inputProperties);
asset.outputPropertyIndices = new IntArray[ports.Count];
for (var portIndex = 0; portIndex < ports.Count; portIndex++)
{
asset.outputPropertyIndices[portIndex] = portPropertyIndices[portIndex].ToArray();
}
return(asset);
}
public FunctionRegistry(ShaderStringBuilder builder)
{
m_Builder = builder;
}
public void GenerateNodeCode(ShaderStringBuilder sb, GraphContext graphContext, GenerationMode generationMode)
{
var graph = owner as GraphData;
var property = graph.properties.FirstOrDefault(x => x.guid == propertyGuid);
if (property == null)
{
return;
}
if (property is Vector1ShaderProperty)
{
var result = string.Format("$precision {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Vector2ShaderProperty)
{
var result = string.Format("$precision2 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Vector3ShaderProperty)
{
var result = string.Format("$precision3 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Vector4ShaderProperty)
{
var result = string.Format("$precision4 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is ColorShaderProperty)
{
var result = string.Format("$precision4 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is BooleanShaderProperty)
{
var result = string.Format("$precision {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Matrix2ShaderProperty)
{
var result = string.Format("$precision2x2 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Matrix3ShaderProperty)
{
var result = string.Format("$precision3x3 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Matrix4ShaderProperty)
{
var result = string.Format("$precision4x4 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is SamplerStateShaderProperty)
{
SamplerStateShaderProperty samplerStateProperty = property as SamplerStateShaderProperty;
var result = string.Format("SamplerState {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, samplerStateProperty.referenceName);
sb.AppendLine(result);
}
else if (property is GradientShaderProperty)
{
if (generationMode == GenerationMode.Preview)
{
var result = string.Format("Gradient {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, GradientUtils.GetGradientForPreview(property.referenceName));
sb.AppendLine(result);
}
else
{
var result = string.Format("Gradient {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
}
}
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 static void GenerateStandardTransforms(
int interpolatorStartIndex,
int maxInterpolators,
ShaderStringBuilder vertexOutputStruct,
ShaderStringBuilder vertexShader,
ShaderStringBuilder vertexShaderDescriptionInputs,
ShaderStringBuilder vertexShaderOutputs,
ShaderStringBuilder pixelShader,
ShaderStringBuilder pixelShaderSurfaceInputs,
ShaderGraphRequirements pixelRequirements,
ShaderGraphRequirements surfaceRequirements,
ShaderGraphRequirements modelRequiements,
ShaderGraphRequirements vertexRequirements,
CoordinateSpace preferredCoordinateSpace)
{
// ----------------------------------------------------- //
// SETUP //
// ----------------------------------------------------- //
// -------------------------------------
// Tangent space requires going via World space
if (preferredCoordinateSpace == CoordinateSpace.Tangent)
{
preferredCoordinateSpace = CoordinateSpace.World;
}
// -------------------------------------
// Generate combined graph requirements
var graphModelRequirements = pixelRequirements.Union(modelRequiements);
var combinedRequirements = vertexRequirements.Union(graphModelRequirements);
int interpolatorIndex = interpolatorStartIndex;
// ----------------------------------------------------- //
// GENERATE VERTEX > PIXEL PIPELINE //
// ----------------------------------------------------- //
// -------------------------------------
// If any stage requires component write into vertex stage
// If model or pixel requires component write into interpolators and pixel stage
// -------------------------------------
// Position
if (combinedRequirements.requiresPosition > 0)
{
var name = preferredCoordinateSpace.ToVariableName(InterpolatorType.Position);
var preferredSpacePosition = ConvertBetweenSpace("v.vertex", CoordinateSpace.Object, preferredCoordinateSpace, InputType.Position);
vertexShader.AppendLine("float3 {0} = {1}.xyz;", name, preferredSpacePosition);
if (graphModelRequirements.requiresPosition > 0)
{
vertexOutputStruct.AppendLine("float3 {0} : TEXCOORD{1};", name, interpolatorIndex);
vertexShaderOutputs.AppendLine("o.{0} = {0};", name);
pixelShader.AppendLine("float3 {0} = IN.{0};", name);
interpolatorIndex++;
}
}
// -------------------------------------
// Normal
// Bitangent needs Normal for x product
if (combinedRequirements.requiresNormal > 0 || combinedRequirements.requiresBitangent > 0)
{
var name = preferredCoordinateSpace.ToVariableName(InterpolatorType.Normal);
vertexShader.AppendLine("float3 {0} = normalize({1});", name, ConvertBetweenSpace("v.normal", CoordinateSpace.Object, preferredCoordinateSpace, InputType.Normal));
if (graphModelRequirements.requiresNormal > 0 || graphModelRequirements.requiresBitangent > 0)
{
vertexOutputStruct.AppendLine("float3 {0} : TEXCOORD{1};", name, interpolatorIndex);
vertexShaderOutputs.AppendLine("o.{0} = {0};", name);
pixelShader.AppendLine("float3 {0} = IN.{0};", name);
interpolatorIndex++;
}
}
// -------------------------------------
// Tangent
if (combinedRequirements.requiresTangent > 0 || combinedRequirements.requiresBitangent > 0)
{
var name = preferredCoordinateSpace.ToVariableName(InterpolatorType.Tangent);
vertexShader.AppendLine("float3 {0} = normalize({1});", name, ConvertBetweenSpace("v.tangent.xyz", CoordinateSpace.Object, preferredCoordinateSpace, InputType.Vector));
if (graphModelRequirements.requiresTangent > 0 || graphModelRequirements.requiresBitangent > 0)
{
vertexOutputStruct.AppendLine("float3 {0} : TEXCOORD{1};", name, interpolatorIndex);
vertexShaderOutputs.AppendLine("o.{0} = {0};", name);
pixelShader.AppendLine("float3 {0} = IN.{0};", name);
interpolatorIndex++;
}
}
// -------------------------------------
// Bitangent
if (combinedRequirements.requiresBitangent > 0)
{
var name = preferredCoordinateSpace.ToVariableName(InterpolatorType.BiTangent);
vertexShader.AppendLine("float3 {0} = cross({1}, {2}.xyz) * {3};",
name,
preferredCoordinateSpace.ToVariableName(InterpolatorType.Normal),
preferredCoordinateSpace.ToVariableName(InterpolatorType.Tangent),
"v.tangent.w");
if (graphModelRequirements.requiresBitangent > 0)
{
vertexOutputStruct.AppendLine("float3 {0} : TEXCOORD{1};", name, interpolatorIndex);
vertexShaderOutputs.AppendLine("o.{0} = {0};", name);
pixelShader.AppendLine("float3 {0} = IN.{0};", name);
interpolatorIndex++;
}
}
// -------------------------------------
// View Direction
if (combinedRequirements.requiresViewDir > 0)
{
var name = preferredCoordinateSpace.ToVariableName(InterpolatorType.ViewDirection);
const string worldSpaceViewDir = "_WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4(v.vertex.xyz, 1.0)).xyz";
var preferredSpaceViewDir = ConvertBetweenSpace(worldSpaceViewDir, CoordinateSpace.World, preferredCoordinateSpace, InputType.Vector);
vertexShader.AppendLine("float3 {0} = {1};", name, preferredSpaceViewDir);
if (graphModelRequirements.requiresViewDir > 0)
{
vertexOutputStruct.AppendLine("float3 {0} : TEXCOORD{1};", name, interpolatorIndex);
vertexShaderOutputs.AppendLine("o.{0} = {0};", name);
pixelShader.AppendLine("float3 {0} = IN.{0};", name);
interpolatorIndex++;
}
}
// -------------------------------------
// Tangent space transform matrix
if (combinedRequirements.NeedsTangentSpace())
{
var tangent = preferredCoordinateSpace.ToVariableName(InterpolatorType.Tangent);
var bitangent = preferredCoordinateSpace.ToVariableName(InterpolatorType.BiTangent);
var normal = preferredCoordinateSpace.ToVariableName(InterpolatorType.Normal);
if (vertexRequirements.NeedsTangentSpace())
{
vertexShader.AppendLine("float3x3 tangentSpaceTransform = float3x3({0},{1},{2});",
tangent, bitangent, normal);
}
if (graphModelRequirements.NeedsTangentSpace())
{
pixelShader.AppendLine("float3x3 tangentSpaceTransform = float3x3({0},{1},{2});",
tangent, bitangent, normal);
}
}
// -------------------------------------
// Vertex Color
if (combinedRequirements.requiresVertexColor)
{
var vertexColor = "v.color";
vertexShader.AppendLine("float4 {0} = {1};", ShaderGeneratorNames.VertexColor, vertexColor);
if (graphModelRequirements.requiresVertexColor)
{
vertexOutputStruct.AppendLine("float4 {0} : COLOR;", ShaderGeneratorNames.VertexColor);
vertexShaderOutputs.AppendLine("o.{0} = {0};", ShaderGeneratorNames.VertexColor);
pixelShader.AppendLine("float4 {0} = IN.{0};", ShaderGeneratorNames.VertexColor);
}
}
// -------------------------------------
// Screen Position
if (combinedRequirements.requiresScreenPosition)
{
var screenPosition = "ComputeScreenPos(mul(GetWorldToHClipMatrix(), mul(GetObjectToWorldMatrix(), v.vertex)), _ProjectionParams.x)";
vertexShader.AppendLine("float4 {0} = {1};", ShaderGeneratorNames.ScreenPosition, screenPosition);
if (graphModelRequirements.requiresScreenPosition)
{
vertexOutputStruct.AppendLine("float4 {0} : TEXCOORD{1};", ShaderGeneratorNames.ScreenPosition, interpolatorIndex);
vertexShaderOutputs.AppendLine("o.{0} = {0};", ShaderGeneratorNames.ScreenPosition);
pixelShader.AppendLine("float4 {0} = IN.{0};", ShaderGeneratorNames.ScreenPosition);
interpolatorIndex++;
}
}
// -------------------------------------
// UV
foreach (var channel in combinedRequirements.requiresMeshUVs.Distinct())
{
vertexShader.AppendLine("float4 {0} = v.texcoord{1};", channel.GetUVName(), (int)channel);
}
foreach (var channel in graphModelRequirements.requiresMeshUVs.Distinct())
{
vertexOutputStruct.AppendLine("half4 {0} : TEXCOORD{1};", channel.GetUVName(), interpolatorIndex == 0 ? "" : interpolatorIndex.ToString());
vertexShaderOutputs.AppendLine("o.{0} = {0};", channel.GetUVName());
pixelShader.AppendLine("float4 {0} = IN.{0};", channel.GetUVName());
interpolatorIndex++;
}
// ----------------------------------------------------- //
// TRANSLATE NEEDED SPACES //
// ----------------------------------------------------- //
// -------------------------------------
// Generate the space translations needed by the vertex description
GenerateSpaceTranslations(vertexRequirements.requiresNormal, InterpolatorType.Normal, preferredCoordinateSpace,
InputType.Normal, vertexShader, Dimension.Three);
GenerateSpaceTranslations(vertexRequirements.requiresTangent, InterpolatorType.Tangent, preferredCoordinateSpace,
InputType.Vector, vertexShader, Dimension.Three);
GenerateSpaceTranslations(vertexRequirements.requiresBitangent, InterpolatorType.BiTangent, preferredCoordinateSpace,
InputType.Vector, vertexShader, Dimension.Three);
GenerateSpaceTranslations(vertexRequirements.requiresViewDir, InterpolatorType.ViewDirection, preferredCoordinateSpace,
InputType.Vector, vertexShader, Dimension.Three);
GenerateSpaceTranslations(vertexRequirements.requiresPosition, InterpolatorType.Position, preferredCoordinateSpace,
InputType.Position, vertexShader, Dimension.Three);
// -------------------------------------
// Generate the space translations needed by the surface description and model
GenerateSpaceTranslations(graphModelRequirements.requiresNormal, InterpolatorType.Normal, preferredCoordinateSpace,
InputType.Normal, pixelShader, Dimension.Three);
GenerateSpaceTranslations(graphModelRequirements.requiresTangent, InterpolatorType.Tangent, preferredCoordinateSpace,
InputType.Vector, pixelShader, Dimension.Three);
GenerateSpaceTranslations(graphModelRequirements.requiresBitangent, InterpolatorType.BiTangent, preferredCoordinateSpace,
InputType.Vector, pixelShader, Dimension.Three);
GenerateSpaceTranslations(graphModelRequirements.requiresViewDir, InterpolatorType.ViewDirection, preferredCoordinateSpace,
InputType.Vector, pixelShader, Dimension.Three);
GenerateSpaceTranslations(graphModelRequirements.requiresPosition, InterpolatorType.Position, preferredCoordinateSpace,
InputType.Position, pixelShader, Dimension.Three);
// ----------------------------------------------------- //
// START SURFACE DESCRIPTION //
// ----------------------------------------------------- //
// -------------------------------------
// Copy the locally defined values into the surface description
// structure using the requirements for ONLY the shader graph pixel stage
// additional requirements have come from the lighting model
// and are not needed in the shader graph
{
var replaceString = "surfaceInput.{0} = {0};";
GenerateSpaceTranslationSurfaceInputs(surfaceRequirements.requiresNormal, InterpolatorType.Normal, pixelShaderSurfaceInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(surfaceRequirements.requiresTangent, InterpolatorType.Tangent, pixelShaderSurfaceInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(surfaceRequirements.requiresBitangent, InterpolatorType.BiTangent, pixelShaderSurfaceInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(surfaceRequirements.requiresViewDir, InterpolatorType.ViewDirection, pixelShaderSurfaceInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(surfaceRequirements.requiresPosition, InterpolatorType.Position, pixelShaderSurfaceInputs, replaceString);
}
if (pixelRequirements.requiresVertexColor)
{
pixelShaderSurfaceInputs.AppendLine("surfaceInput.{0} = {0};", ShaderGeneratorNames.VertexColor);
}
if (pixelRequirements.requiresScreenPosition)
{
pixelShaderSurfaceInputs.AppendLine("surfaceInput.{0} = {0};", ShaderGeneratorNames.ScreenPosition);
}
if (pixelRequirements.requiresFaceSign)
{
pixelShaderSurfaceInputs.AppendLine("surfaceInput.{0} = {0};", ShaderGeneratorNames.FaceSign);
}
foreach (var channel in pixelRequirements.requiresMeshUVs.Distinct())
{
pixelShaderSurfaceInputs.AppendLine("surfaceInput.{0} = {0};", ShaderGeneratorNames.GetUVName(channel));
}
// ----------------------------------------------------- //
// START VERTEX DESCRIPTION //
// ----------------------------------------------------- //
// -------------------------------------
// Copy the locally defined values into the vertex description
// structure using the requirements for ONLY the shader graph vertex stage
// additional requirements have come from the lighting model
// and are not needed in the shader graph
{
var replaceString = "vdi.{0} = {0};";
GenerateSpaceTranslationSurfaceInputs(vertexRequirements.requiresNormal, InterpolatorType.Normal, vertexShaderDescriptionInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(vertexRequirements.requiresTangent, InterpolatorType.Tangent, vertexShaderDescriptionInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(vertexRequirements.requiresBitangent, InterpolatorType.BiTangent, vertexShaderDescriptionInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(vertexRequirements.requiresViewDir, InterpolatorType.ViewDirection, vertexShaderDescriptionInputs, replaceString);
GenerateSpaceTranslationSurfaceInputs(vertexRequirements.requiresPosition, InterpolatorType.Position, vertexShaderDescriptionInputs, replaceString);
}
if (vertexRequirements.requiresVertexColor)
{
vertexShaderDescriptionInputs.AppendLine("vdi.{0} = {0};", ShaderGeneratorNames.VertexColor);
}
if (vertexRequirements.requiresScreenPosition)
{
vertexShaderDescriptionInputs.AppendLine("vdi.{0} = {0};", ShaderGeneratorNames.ScreenPosition);
}
foreach (var channel in vertexRequirements.requiresMeshUVs.Distinct())
{
vertexShaderDescriptionInputs.AppendLine("vdi.{0} = {0};", channel.GetUVName(), (int)channel);
}
}
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)));
}
public static string GetPreviewSubShader(AbstractMaterialNode node, ShaderGraphRequirements shaderGraphRequirements)
{
var vertexOutputStruct = new ShaderStringBuilder(2);
var vertexShader = new ShaderStringBuilder(2);
var vertexShaderDescriptionInputs = new ShaderStringBuilder(2);
var vertexShaderOutputs = new ShaderStringBuilder(1);
var pixelShader = new ShaderStringBuilder(2);
var pixelShaderSurfaceInputs = new ShaderStringBuilder(2);
var pixelShaderSurfaceRemap = new ShaderStringBuilder(2);
ShaderGenerator.GenerateStandardTransforms(
0,
16,
vertexOutputStruct,
vertexShader,
vertexShaderDescriptionInputs,
vertexShaderOutputs,
pixelShader,
pixelShaderSurfaceInputs,
shaderGraphRequirements,
shaderGraphRequirements,
ShaderGraphRequirements.none,
ShaderGraphRequirements.none,
CoordinateSpace.World);
vertexShader.AppendLines(vertexShaderDescriptionInputs.ToString());
vertexShader.AppendLines(vertexShaderOutputs.ToString());
if (node != null)
{
var outputSlot = node.GetOutputSlots <MaterialSlot>().FirstOrDefault();
if (outputSlot != null)
{
var result = string.Format("surf.{0}", node.GetVariableNameForSlot(outputSlot.id));
pixelShaderSurfaceRemap.AppendLine("return {0};", AdaptNodeOutputForPreview(node, outputSlot.id, result));
}
else
{
pixelShaderSurfaceRemap.AppendLine("return 0;");
}
}
else
{
pixelShaderSurfaceRemap.AppendLine("return all(isfinite(surf.PreviewOutput)) ? surf.PreviewOutput : float4(1.0f, 0.0f, 1.0f, 1.0f);");
}
// -------------------------------------
// Extra pixel shader work
var faceSign = new ShaderStringBuilder();
if (shaderGraphRequirements.requiresFaceSign)
{
faceSign.AppendLine(", half FaceSign : VFACE");
}
var res = subShaderTemplate.Replace("${Interpolators}", vertexOutputStruct.ToString());
res = res.Replace("${VertexShader}", vertexShader.ToString());
res = res.Replace("${FaceSign}", faceSign.ToString());
res = res.Replace("${LocalPixelShader}", pixelShader.ToString());
res = res.Replace("${SurfaceInputs}", pixelShaderSurfaceInputs.ToString());
res = res.Replace("${SurfaceOutputRemap}", pixelShaderSurfaceRemap.ToString());
return(res);
}
// Node generations
public virtual void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
sb.AppendLine("$precision3 {0}_UV = {1} * {2};", GetVariableNameForNode(),
GetSlotValue(PositionInputId, generationMode), GetSlotValue(TileInputId, generationMode));
//Sampler input slot
var samplerSlot = FindInputSlot <MaterialSlot>(SamplerInputId);
var edgesSampler = owner.GetEdges(samplerSlot.slotReference);
var id = GetSlotValue(TextureInputId, generationMode);
switch (textureType)
{
// Whiteout blend method
// https://medium.com/@bgolus/normal-mapping-for-a-triplanar-shader-10bf39dca05a
case TextureType.Normal:
// See comment for default case.
sb.AppendLine("$precision3 {0}_Blend = SafePositivePow_$precision({1}, min({2}, floor(log2(Min_$precision())/log2(1/sqrt(3)))) );"
, GetVariableNameForNode()
, GetSlotValue(NormalInputId, generationMode)
, GetSlotValue(BlendInputId, generationMode));
sb.AppendLine("{0}_Blend /= ({0}_Blend.x + {0}_Blend.y + {0}_Blend.z ).xxx;", GetVariableNameForNode());
sb.AppendLine("$precision3 {0}_X = UnpackNormal(SAMPLE_TEXTURE2D({1}, {2}, {0}_UV.zy));"
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("$precision3 {0}_Y = UnpackNormal(SAMPLE_TEXTURE2D({1}, {2}, {0}_UV.xz));"
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("$precision3 {0}_Z = UnpackNormal(SAMPLE_TEXTURE2D({1}, {2}, {0}_UV.xy));"
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("{0}_X = $precision3({0}_X.xy + {1}.zy, abs({0}_X.z) * {1}.x);"
, GetVariableNameForNode()
, GetSlotValue(NormalInputId, generationMode));
sb.AppendLine("{0}_Y = $precision3({0}_Y.xy + {1}.xz, abs({0}_Y.z) * {1}.y);"
, GetVariableNameForNode()
, GetSlotValue(NormalInputId, generationMode));
sb.AppendLine("{0}_Z = $precision3({0}_Z.xy + {1}.xy, abs({0}_Z.z) * {1}.z);"
, GetVariableNameForNode()
, GetSlotValue(NormalInputId, generationMode));
sb.AppendLine("$precision4 {0} = $precision4(normalize({1}_X.zyx * {1}_Blend.x + {1}_Y.xzy * {1}_Blend.y + {1}_Z.xyz * {1}_Blend.z), 1);"
, GetVariableNameForSlot(OutputSlotId)
, GetVariableNameForNode());
sb.AppendLine("$precision3x3 {0}_Transform = $precision3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);", GetVariableNameForNode());
sb.AppendLine("{0}.rgb = TransformWorldToTangent({0}.rgb, {1}_Transform);"
, GetVariableNameForSlot(OutputSlotId)
, GetVariableNameForNode());
break;
default:
// We want the sum of the 3 blend weights (by which we normalize them) to be > 0.
// Max safe exponent is log2(REAL_MIN)/log2(1/sqrt(3)):
// Take the set of all possible normalized vectors, make a set from selecting the maximum component of each 3-vectors from the previous set,
// the minimum (:= min_of_max) of that new set is 1/sqrt(3) (by the fact vectors are normalized).
// We then want a maximum exponent such that
// precision_min < min_of_max^exponent_max
// where exponent_max is blend,
// log(precision_min) < log(min_of_max) * exponent_max
// log(precision_min) / log(min_of_max) > exponent_max
sb.AppendLine("$precision3 {0}_Blend = SafePositivePow_$precision({1}, min({2}, floor(log2(Min_$precision())/log2(1/sqrt(3)))) );"
, GetVariableNameForNode()
, GetSlotValue(NormalInputId, generationMode)
, GetSlotValue(BlendInputId, generationMode));
sb.AppendLine("{0}_Blend /= dot({0}_Blend, 1.0);", GetVariableNameForNode());
sb.AppendLine("$precision4 {0}_X = SAMPLE_TEXTURE2D({1}, {2}, {0}_UV.zy);"
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("$precision4 {0}_Y = SAMPLE_TEXTURE2D({1}, {2}, {0}_UV.xz);"
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("$precision4 {0}_Z = SAMPLE_TEXTURE2D({1}, {2}, {0}_UV.xy);"
, GetVariableNameForNode()
, id
, edgesSampler.Any() ? GetSlotValue(SamplerInputId, generationMode) : "sampler" + id);
sb.AppendLine("$precision4 {0} = {1}_X * {1}_Blend.x + {1}_Y * {1}_Blend.y + {1}_Z * {1}_Blend.z;"
, GetVariableNameForSlot(OutputSlotId)
, GetVariableNameForNode());
break;
}
}
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
var keyword = owner.keywords.FirstOrDefault(x => x.guid == keywordGuid);
if (keyword == null)
{
return;
}
var outputSlot = FindOutputSlot <MaterialSlot>(OutputSlotId);
switch (keyword.keywordType)
{
case KeywordType.Boolean:
{
// Get values
var onValue = GetSlotValue(1, generationMode);
var offValue = GetSlotValue(2, generationMode);
// Append code
sb.AppendLine($"#if defined({keyword.referenceName})");
sb.AppendLine(string.Format($"{outputSlot.concreteValueType.ToShaderString()} {GetVariableNameForSlot(OutputSlotId)} = {onValue};"));
sb.AppendLine("#else");
sb.AppendLine(string.Format($"{outputSlot.concreteValueType.ToShaderString()} {GetVariableNameForSlot(OutputSlotId)} = {offValue};"));
sb.AppendLine("#endif");
break;
}
case KeywordType.Enum:
{
// Iterate all entries in the keyword
for (int i = 0; i < keyword.entries.Count; i++)
{
// Insert conditional
if (i == 0)
{
sb.AppendLine($"#if defined({keyword.referenceName}_{keyword.entries[i].referenceName})");
}
else if (i == keyword.entries.Count - 1)
{
sb.AppendLine("#else");
}
else
{
sb.AppendLine($"#elif defined({keyword.referenceName}_{keyword.entries[i].referenceName})");
}
// Append per-slot code
var value = GetSlotValue(GetSlotIdForPermutation(new KeyValuePair <ShaderKeyword, int>(keyword, i)), generationMode);
sb.AppendLine(string.Format($"{outputSlot.concreteValueType.ToShaderString()} {GetVariableNameForSlot(OutputSlotId)} = {value};"));
}
// End condition
sb.AppendLine("#endif");
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
{
NodeUtils.SlotConfigurationExceptionIfBadConfiguration(this, new[] { InputSlotId }, new[] { OutputSlotId });
string inputValue = string.Format("{0}.xyz", GetSlotValue(InputSlotId, generationMode));
string targetTransformString = "tangentTransform_" + conversion.from.ToString();
string transposeTargetTransformString = "transposeTangent";
string transformString = "";
string tangentTransformSpace = conversion.from.ToString();
bool requiresTangentTransform = false;
bool requiresTransposeTangentTransform = false;
if (conversion.from == CoordinateSpace.World)
{
if (conversion.to == CoordinateSpace.World)
{
transformString = inputValue;
}
else if (conversion.to == CoordinateSpace.Object)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToObjectDir({0})" : "TransformWorldToObject({0})", inputValue);
}
else if (conversion.to == CoordinateSpace.Tangent)
{
requiresTangentTransform = true;
transformString = string.Format("TransformWorldToTangent({0}, {1})", inputValue, targetTransformString);
}
else if (conversion.to == CoordinateSpace.View)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToViewDir({0})" : "TransformWorldToView({0})", inputValue);
}
else if (conversion.to == CoordinateSpace.AbsoluteWorld)
{
transformString = string.Format("GetAbsolutePositionWS({0})", inputValue);
}
}
else if (conversion.from == CoordinateSpace.Object)
{
if (conversion.to == CoordinateSpace.World)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformObjectToWorldDir({0})" : "TransformObjectToWorld({0})", inputValue);
}
else if (conversion.to == CoordinateSpace.Object)
{
transformString = inputValue;
}
else if (conversion.to == CoordinateSpace.Tangent)
{
requiresTangentTransform = true;
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToTangent(TransformObjectToWorldDir({0}), {1})" : "TransformWorldToTangent(TransformObjectToWorld({0}), {1})", inputValue, targetTransformString);
}
else if (conversion.to == CoordinateSpace.View)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToViewDir(TransformObjectToWorldDir({0}))" : "TransformWorldToView(TransformObjectToWorld({0}))", inputValue);
}
if (conversion.to == CoordinateSpace.AbsoluteWorld)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformObjectToWorldDir({0})" : "GetAbsolutePositionWS(TransformObjectToWorld({0}))", inputValue);
}
}
else if (conversion.from == CoordinateSpace.Tangent)
{
if (conversion.to == CoordinateSpace.World)
{
requiresTransposeTangentTransform = true;
transformString = string.Format("mul({0}, {1}).xyz", transposeTargetTransformString, inputValue);
}
else if (conversion.to == CoordinateSpace.Object)
{
requiresTransposeTangentTransform = true;
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToObjectDir(mul({0}, {1}).xyz)" : "TransformWorldToObject(mul({0}, {1}).xyz)", transposeTargetTransformString, inputValue);
}
else if (conversion.to == CoordinateSpace.Tangent)
{
transformString = inputValue;
}
else if (conversion.to == CoordinateSpace.View)
{
requiresTransposeTangentTransform = true;
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToViewDir(mul({0}, {1}).xyz)" : "TransformWorldToView(mul({0}, {1}).xyz)", transposeTargetTransformString, inputValue);
}
if (conversion.to == CoordinateSpace.AbsoluteWorld)
{
requiresTransposeTangentTransform = true;
transformString = string.Format("GetAbsolutePositionWS(mul({0}, {1})).xyz", transposeTargetTransformString, inputValue);
}
}
else if (conversion.from == CoordinateSpace.View)
{
if (conversion.to == CoordinateSpace.World)
{
transformString = string.Format("mul(UNITY_MATRIX_I_V, $precision4({0}, 1)).xyz", inputValue);
}
else if (conversion.to == CoordinateSpace.Object)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToObjectDir(mul(UNITY_MATRIX_I_V, $precision4({0}, 1) ).xyz)" : "TransformWorldToObject(mul(UNITY_MATRIX_I_V, $precision4({0}, 1) ).xyz)", inputValue);
}
else if (conversion.to == CoordinateSpace.Tangent)
{
requiresTangentTransform = true;
tangentTransformSpace = CoordinateSpace.World.ToString();
transformString = string.Format("TransformWorldToTangent(mul(UNITY_MATRIX_I_V, $precision4({0}, 1) ).xyz, {1})", inputValue, targetTransformString);
}
else if (conversion.to == CoordinateSpace.View)
{
transformString = inputValue;
}
else if (conversion.to == CoordinateSpace.AbsoluteWorld)
{
transformString = string.Format("GetAbsolutePositionWS(mul(UNITY_MATRIX_I_V, $precision4({0}, 1))).xyz", inputValue);
}
}
else if (conversion.from == CoordinateSpace.AbsoluteWorld)
{
if (conversion.to == CoordinateSpace.World)
{
transformString = string.Format("GetCameraRelativePositionWS({0})", inputValue);
}
else if (conversion.to == CoordinateSpace.Object)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToObjectDir({0})" : "TransformWorldToObject({0})", inputValue);
}
else if (conversion.to == CoordinateSpace.Tangent)
{
requiresTangentTransform = true;
tangentTransformSpace = CoordinateSpace.World.ToString();
transformString = string.Format("TransformWorldToTangent(GetCameraRelativePositionWS({0}), {1})", inputValue, targetTransformString);
}
else if (conversion.to == CoordinateSpace.View)
{
transformString = string.Format(conversionType == ConversionType.Direction ? "TransformWorldToViewDir(GetCameraRelativePositionWS({0}))" : "TransformWorldToView(GetCameraRelativePositionWS({0}))", inputValue);
}
else if (conversion.to == CoordinateSpace.AbsoluteWorld)
{
transformString = inputValue;
}
}
if (requiresTransposeTangentTransform)
{
sb.AppendLine(string.Format("$precision3x3 {0} = transpose($precision3x3(IN.{1}SpaceTangent, IN.{1}SpaceBiTangent, IN.{1}SpaceNormal));", transposeTargetTransformString, CoordinateSpace.World.ToString()));
}
else if (requiresTangentTransform)
{
sb.AppendLine(string.Format("$precision3x3 {0} = $precision3x3(IN.{1}SpaceTangent, IN.{1}SpaceBiTangent, IN.{1}SpaceNormal);", targetTransformString, tangentTransformSpace));
}
sb.AppendLine("{0} {1} = {2};", FindOutputSlot <MaterialSlot>(OutputSlotId).concreteValueType.ToShaderString(),
GetVariableNameForSlot(OutputSlotId),
transformString);
}
public void GenerateNodeCode(ShaderStringBuilder sb, GraphContext graphContext, GenerationMode generationMode)
{
sb.AppendLine(string.Format("$precision4 {0} = {1};", GetVariableNameForSlot(kOutputSlotId), m_ScreenSpaceType.ToValueAsVariable()));
}