public override void DefaultVisit(Node node)
{
if (node is Expression || node is TypeBase)
VisitTypeInferencer((ITypeInferencer)node);
base.DefaultVisit(node);
}
public override void DefaultVisit(Node node)
{
base.DefaultVisit(node);
var typeBase = node as TypeBase;
if (typeBase != null)
AddReference(GetDeclarationContainer(), (Node)typeBase.TypeInference.Declaration);
}
/// <summary>
/// Visits the specified node.
/// </summary>
/// <param name="node">The node.</param>
/// <returns>The filtered node</returns>
public override Node DefaultVisit(Node node)
{
node = FilterFunction(node);
if (node != null)
node = base.DefaultVisit(node);
return node;
}
public override void DefaultVisit(Node node)
{
var expression = node as Expression;
if (expression != null)
{
if (!(expression is BinaryExpression || expression is MethodInvocationExpression || expression is VariableReferenceExpression || expression is LiteralExpression || expression is ParenthesizedExpression || expression is UnaryExpression))
result.Error("Expression evaluation [{0}] is not supported", expression.Span, expression);
}
}
public override Node DefaultVisit(Node node)
{
if (node == nodeToReplace)
{
complete = true;
return replacementNode;
}
return base.DefaultVisit(node);
}
protected override Node Visit(Node node)
{
if (node == nodeToReplace)
{
complete = true;
return replacementNode;
}
return base.Visit(node);
}
protected override Node Visit(Node node)
{
node.RemoveTag(ParadoxTags.ConstantBuffer);
node.RemoveTag(ParadoxTags.ShaderScope);
node.RemoveTag(ParadoxTags.StaticRef);
node.RemoveTag(ParadoxTags.ExternRef);
node.RemoveTag(ParadoxTags.StageInitRef);
node.RemoveTag(ParadoxTags.CurrentShader);
node.RemoveTag(ParadoxTags.VirtualTableReference);
node.RemoveTag(ParadoxTags.BaseDeclarationMixin);
node.RemoveTag(ParadoxTags.ShaderScope);
return base.Visit(node);
}
public override void DefaultVisit(Node node)
{
// Keeping it for ShaderLinker (removed by XenkoShaderCleaner)
//node.RemoveTag(XenkoTags.ConstantBuffer);
node.RemoveTag(XenkoTags.ShaderScope);
node.RemoveTag(XenkoTags.StaticRef);
node.RemoveTag(XenkoTags.ExternRef);
node.RemoveTag(XenkoTags.StageInitRef);
node.RemoveTag(XenkoTags.CurrentShader);
node.RemoveTag(XenkoTags.VirtualTableReference);
node.RemoveTag(XenkoTags.BaseDeclarationMixin);
node.RemoveTag(XenkoTags.ShaderScope);
base.DefaultVisit(node);
}
protected override bool PreVisitNode(Node node)
{
// Sometimes it is desirable that constant buffer are not modified so that
// they can be shared between different stages, even if some variables are unused.
// In this case, use symetric reference so that using a constant buffer will include all its variables.
if (KeepConstantBuffers && currentConstantBuffer != null && node is IDeclaration)
{
AddReference(node, currentConstantBuffer);
AddReference(currentConstantBuffer, node);
}
return base.PreVisitNode(node);
}
public override Node DefaultVisit(Node node)
{
var qualifierNode = node as IQualifiers;
if (qualifierNode != null)
{
qualifierNode.Qualifiers.Values.Remove(XenkoStorageQualifier.Stream);
qualifierNode.Qualifiers.Values.Remove(XenkoStorageQualifier.Stage);
qualifierNode.Qualifiers.Values.Remove(XenkoStorageQualifier.PatchStream);
qualifierNode.Qualifiers.Values.Remove(XenkoStorageQualifier.Override);
qualifierNode.Qualifiers.Values.Remove(XenkoStorageQualifier.Clone);
qualifierNode.Qualifiers.Values.Remove(XenkoStorageQualifier.Stage);
}
return base.DefaultVisit(node);
}
public override void DefaultVisit(Node node)
{
base.DefaultVisit(node);
var typeBase = node as TypeBase;
if (typeBase != null)
{
if (sourceManager.IsClassExists(typeBase.Name.Text))
{
FoundClasses.Add(typeBase.Name.Text);
}
else if (typeBase is ShaderTypeName)
{
// Special case for ShaderTypeName as we must generate an error if it is not found
log.Error(XenkoMessageCode.ErrorClassNotFound, typeBase.Span, typeBase.Name.Text);
}
}
}
public ParadoxReplaceVisitor(Node toReplace, Node replacement) : base(false, false)
{
nodeToReplace = toReplace;
replacementNode = replacement;
}
public override void DefaultVisit(Node node)
{
base.DefaultVisit(node);
var typeBase = node as TypeBase;
if (typeBase != null)
{
// Unhandled types only
if (!(typeBase is TypeName || typeBase is ScalarType || typeBase is MatrixType || typeBase is TextureType || typeBase.IsStateType() || typeBase is ArrayType))
{
Write(typeBase.Name);
ProcessInitialValueStatus = true;
}
}
}
private LocalParameterKey GetLinkParameterKey(Node node)
{
var qualifiers = node as IQualifiers;
var attributable = node as IAttributes;
if ((qualifiers != null && (qualifiers.Qualifiers.Contains(SiliconStudio.Shaders.Ast.Hlsl.StorageQualifier.Static) ||
qualifiers.Qualifiers.Contains(StorageQualifier.Const) ||
qualifiers.Qualifiers.Contains(SiliconStudio.Shaders.Ast.Hlsl.StorageQualifier.Groupshared)
)) || attributable == null)
{
return null;
}
bool isColor = attributable.Attributes.OfType<AttributeDeclaration>().Any(x => x.Name == "Color");
foreach (var annotation in attributable.Attributes.OfType<AttributeDeclaration>())
{
if (annotation.Name != "Link" || annotation.Parameters.Count < 1)
{
continue;
}
var variableName = (string)annotation.Parameters[0].Value;
var parameterKey = new LocalParameterKey() {Name = variableName};
var variable = node as Variable;
if (variable != null)
{
var variableType = variable.Type;
if (variableType.TypeInference.TargetType != null)
variableType = variableType.TypeInference.TargetType;
if (variableType is ArrayType)
{
var arrayType = (ArrayType)variableType;
variableType = arrayType.Type;
parameterKey.Count = (int)((LiteralExpression)arrayType.Dimensions[0]).Literal.Value;
if (variableType.TypeInference.TargetType != null)
variableType = variableType.TypeInference.TargetType;
}
if (variableType.IsBuiltIn)
{
var variableTypeName = variableType.Name.Text.ToLower();
switch (variableTypeName)
{
case "cbuffer":
parameterKey.Class = EffectParameterClass.ConstantBuffer;
parameterKey.Type = EffectParameterType.ConstantBuffer;
break;
case "tbuffer":
parameterKey.Class = EffectParameterClass.TextureBuffer;
parameterKey.Type = EffectParameterType.TextureBuffer;
break;
case "structuredbuffer":
parameterKey.Class = EffectParameterClass.ShaderResourceView;
parameterKey.Type = EffectParameterType.StructuredBuffer;
break;
case "rwstructuredbuffer":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.RWStructuredBuffer;
break;
case "consumestructuredbuffer":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.ConsumeStructuredBuffer;
break;
case "appendstructuredbuffer":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.AppendStructuredBuffer;
break;
case "buffer":
parameterKey.Class = EffectParameterClass.ShaderResourceView;
parameterKey.Type = EffectParameterType.Buffer;
break;
case "rwbuffer":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.RWBuffer;
break;
case "byteaddressbuffer":
parameterKey.Class = EffectParameterClass.ShaderResourceView;
parameterKey.Type = EffectParameterType.ByteAddressBuffer;
break;
case "rwbyteaddressbuffer":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.RWByteAddressBuffer;
break;
case "texture1d":
parameterKey.Class = EffectParameterClass.ShaderResourceView;
parameterKey.Type = EffectParameterType.Texture1D;
break;
case "texturecube":
parameterKey.Class = EffectParameterClass.ShaderResourceView;
parameterKey.Type = EffectParameterType.TextureCube;
break;
case "texture2d":
parameterKey.Class = EffectParameterClass.ShaderResourceView;
parameterKey.Type = EffectParameterType.Texture2D;
break;
case "texture3d":
parameterKey.Class = EffectParameterClass.ShaderResourceView;
parameterKey.Type = EffectParameterType.Texture3D;
break;
case "rwtexture1d":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.RWTexture1D;
break;
case "rwtexture2d":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.RWTexture2D;
break;
case "rwtexture3d":
parameterKey.Class = EffectParameterClass.UnorderedAccessView;
parameterKey.Type = EffectParameterType.RWTexture3D;
break;
case "samplerstate":
parameterKey.Class = EffectParameterClass.Sampler;
parameterKey.Type = EffectParameterType.Sampler;
break;
}
}
else if (variableType is ScalarType)
{
// Uint and int are collapsed to int
if (variableType == ScalarType.Int || variableType == ScalarType.UInt)
{
parameterKey.Class = EffectParameterClass.Scalar;
parameterKey.Type = variableType == ScalarType.Int ? EffectParameterType.Int : EffectParameterType.UInt;
}
else if (variableType == ScalarType.Float)
{
parameterKey.Class = EffectParameterClass.Scalar;
parameterKey.Type = EffectParameterType.Float;
}
else if (variableType == ScalarType.Bool)
{
parameterKey.Class = EffectParameterClass.Scalar;
parameterKey.Type = EffectParameterType.Bool;
}
parameterKey.RowCount = 1;
parameterKey.ColumnCount = 1;
}
else if (variableType is VectorType)
{
if (variableType == VectorType.Float2 || variableType == VectorType.Float3 || variableType == VectorType.Float4)
{
parameterKey.Class = isColor ? EffectParameterClass.Color : EffectParameterClass.Vector;
parameterKey.Type = EffectParameterType.Float;
}
else if (variableType == VectorType.Int2 || variableType == VectorType.Int3 || variableType == VectorType.Int4)
{
parameterKey.Class = EffectParameterClass.Vector;
parameterKey.Type = EffectParameterType.Int;
}
else if (variableType == VectorType.UInt2 || variableType == VectorType.UInt3 || variableType == VectorType.UInt4)
{
parameterKey.Class = EffectParameterClass.Vector;
parameterKey.Type = EffectParameterType.UInt;
}
parameterKey.RowCount = 1;
parameterKey.ColumnCount = (variableType as VectorType).Dimension;
}
else if (variableType is MatrixType)
{
parameterKey.Class = EffectParameterClass.MatrixColumns;
parameterKey.Type = EffectParameterType.Float;
parameterKey.RowCount = (variableType as MatrixType).RowCount;
parameterKey.ColumnCount = (variableType as MatrixType).ColumnCount;
}
else if (variableType is StructType)
{
parameterKey.Class = EffectParameterClass.Struct;
parameterKey.RowCount = 1;
parameterKey.ColumnCount = 1;
}
}
return parameterKey;
}
return null;
}
private Node OnProcessor(Node nodeArg, ref NodeProcessorContext explorer)
{
return VisitDynamic(nodeArg);
}
protected override Node Visit(Node node)
{
if (node is IDeclaration)
{
var parameterKey = this.GetLinkParameterKey(node);
if (parameterKey != null)
LinkVariable(effectReflection, ((IDeclaration)node).Name, parameterKey);
}
node.Childrens(OnProcessor);
return node;
}
/// <summary>
/// Helper to collects the referenced declarations recursively.
/// </summary>
/// <param name="collectedReferences">The collected declarations.</param>
/// <param name="reference">The reference to collect.</param>
private void CollectReferences(List<Node> collectedReferences, Node reference)
{
if (!collectedReferences.Contains(reference))
{
// Collect reference (if not already added)
collectedReferences.Add(reference);
// Collect recursively
HashSet<Node> referencedFunctions;
if (indirectReferences.TryGetValue((Node)reference, out referencedFunctions))
{
foreach (var referencedFunction in referencedFunctions)
CollectReferences(collectedReferences, referencedFunction);
}
}
}
/// <summary>
/// Writes a link line using #line preprocessing directive with the specified node
/// </summary>
/// <param name="node">The node to use the Span.</param>
/// <returns>This instance</returns>
protected ShaderWriter WriteLinkLine(Node node)
{
if (!EnablePreprocessorLine || node.Span.Location.Line == 0)
return this;
var newSourceFile = node.Span.Location.FileSource;
var sourceLocation = string.Empty;
if (previousSourceFileName != newSourceFile)
{
sourceLocation = string.Format(" \"{0}\"", newSourceFile);
previousSourceFileName = newSourceFile;
}
Append(Environment.NewLine).Append("#line {0}{1}", node.Span.Location.Line, sourceLocation).Append(Environment.NewLine);
NewLine = true;
lineCount++;
return this;
}
public bool Run(Node startNode)
{
Visit(startNode);
return complete;
}
/// <summary>
/// Replace a MemberReferenceExpression by a VariableReferenceExpression in the AST
/// </summary>
/// <param name="memberReferenceExpression">the member reference expression.</param>
/// <param name="variableReferenceExpression">the variable reference expression.</param>
/// <param name="parentNode">the parent node.</param>
private static void ReplaceMemberReferenceExpressionByVariableReferenceExpression(MemberReferenceExpression memberReferenceExpression, VariableReferenceExpression variableReferenceExpression, Node parentNode)
{
var replacor = new XenkoReplaceVisitor(memberReferenceExpression, variableReferenceExpression);
replacor.Run(parentNode);
}
public ExpressionNodeCouple(Expression expression, Node node)
{
Expression = expression;
Node = node;
}
private static bool CanStrip(Node declaration, ICollection<Node> collectedReferences, bool stripUniforms)
{
if (declaration is Variable)
{
var variableDeclaration = (Variable)declaration;
if ((!stripUniforms && variableDeclaration.Qualifiers.Contains(Ast.StorageQualifier.Uniform)))
return false;
if (variableDeclaration.IsGroup)
{
variableDeclaration.SubVariables.RemoveAll(x => !collectedReferences.Contains(x));
if (variableDeclaration.SubVariables.Count == 0)
{
return true;
}
}
else if (!collectedReferences.Contains(declaration))
{
return true;
}
}
else if (declaration is IDeclaration && !collectedReferences.Contains(declaration))
{
return true;
}
else if (declaration is ConstantBuffer)
{
// Strip cbuffer only if all of its member can be
var constantBuffer = (ConstantBuffer)declaration;
foreach (var member in constantBuffer.Members)
{
if (!CanStrip(member, collectedReferences, stripUniforms))
return false;
}
return true;
}
return false;
}
public void Run(Node startNode)
{
VisitDynamic(startNode);
}
public MemberReferenceExpressionNodeCouple(MemberReferenceExpression member, Node node)
{
Member = member;
Node = node;
}
/// <summary>
/// Searches from the specified node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="filter">The filter function to apply to each node.</param>
/// <param name="buildScopeDeclaration">if set to <c>true</c> [build scope declaration].</param>
/// <param name="useNodeStack">if set to <c>true</c> [use node stack].</param>
public static void Run(Node node, Func<Node, Node> filter, bool buildScopeDeclaration = false, bool useNodeStack = false)
{
var visitor = new SearchVisitor(filter, buildScopeDeclaration, useNodeStack);
visitor.VisitDynamic(node);
}
/// <summary>
/// Initializes a new instance of the <see cref="DeclarationStatement"/> class.
/// </summary>
/// <param name="content">
/// The content.
/// </param>
public DeclarationStatement(Node content)
{
Content = content;
}
protected override bool PreVisitNode(Node node)
{
var fileSource = Path.GetFileName(node.Span.Location.FileSource);
if (string.Compare(fileSource, "internal_hlsl_declarations.hlsl", true) != 0 && node.Span.Length > 0)
{
while (SourceLocations.Count < lineCount)
{
SourceLocations.Add(new SourceLocation(node.Span.Location.FileSource, node.Span.Location.Position, node.Span.Location.Line, 1));
}
}
return base.PreVisitNode(node);
}
public void Run(Node initialNode)
{
Visit(initialNode);
}
public StatementNodeCouple(Statement statement, Node node)
{
Statement = statement;
Node = node;
}
private void AddReference(Node parent, Node declaration)
{
if (parent != null && declaration != null)
{
HashSet<Node> childReferences;
if (!indirectReferences.TryGetValue(parent, out childReferences))
{
childReferences = new HashSet<Node>();
indirectReferences[parent] = childReferences;
}
if (!childReferences.Contains(declaration))
childReferences.Add(declaration);
}
}
