/// <summary>
/// The create string literal ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateStringLiteralAst(ParsingContext context, ParseTreeNode node)
{
var value = Ast <Literal>(node);
value.SubLiterals = new List <Literal>();
//// string_literal.Rule =
//// string_literal_raw.List();
var text = new StringBuilder();
var textValue = new StringBuilder();
foreach (var childNode in node.ChildNodes[0].ChildNodes)
{
var subLiteral = new Literal
{
Span = SpanConverter.Convert(childNode.Span),
Value = childNode.AstNode,
Text = childNode.Token.Text
};
value.SubLiterals.Add(subLiteral);
textValue.Append(subLiteral.Value);
}
text.Append("\"").Append(textValue).Append("\"");
value.Value = textValue.ToString();
value.Text = text.ToString();
}
/// <summary>
/// The create expression statement ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateExpressionStatementAst(ParsingContext context, ParseTreeNode node)
{
//// expression_statement.Rule =
//// empty_statement
//// | expression + ";";
if (node.ChildNodes[0].AstNode is EmptyStatement)
{
node.AstNode = node.ChildNodes[0].AstNode;
return;
}
var expressionStatement = Ast <ExpressionStatement>(node);
if (node.ChildNodes[0].AstNode is Expression)
{
// Standard expression statement
expressionStatement.Expression = (Expression)node.ChildNodes[0].AstNode;
}
else
{
// Expression statement like "break;" "continue;" "discard;"
// Standard expression statement
CreateIdentifierAst(context, node.ChildNodes[0]);
expressionStatement.Expression = new KeywordExpression((Identifier)node.ChildNodes[0].AstNode)
{
Span = SpanConverter.Convert(node.Span)
};
}
}
/// <summary>
/// The create pack offset ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreatePackOffsetAst(ParsingContext context, ParseTreeNode node)
{
//// [0] [1] [2] [3]
// _(":") + "packoffset" + "(" + identifier + ")";
node.AstNode = new PackOffset()
{
Value = (Identifier)node.ChildNodes[2].AstNode, Span = SpanConverter.Convert(node.Span)
};
}
/// <summary>
/// The create semantic ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateSemanticAst(ParsingContext context, ParseTreeNode node)
{
//// [0]
// ":" + identifier
node.AstNode = new Semantic()
{
Name = (Identifier)node.ChildNodes[0].AstNode, Span = SpanConverter.Convert(node.Span)
};
}
/// <summary>
/// The create statement ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateStatementAst(ParsingContext context, ParseTreeNode node)
{
// statement.Rule =
// attribute_list_opt + statement_raw;
var value = (Statement)node.ChildNodes[1].AstNode;
node.AstNode = value;
value.Span = SpanConverter.Convert(node.Span);
value.Attributes = (List <AttributeBase>)node.ChildNodes[0].AstNode;
}
public void Render(Camera camera)
{
if (Surface.Resolution.X != depthBuffer.Description.Width || Surface.Resolution.Y != depthBuffer.Description.Height)
{
OnResize();
}
var context = Surface.Context;
Shapes.MeshCache.FlushPendingUploads(context);
context.Rasterizer.SetViewport(0, 0, Surface.Resolution.X, Surface.Resolution.Y, 0.0f, 1.0f);
//Note reversed depth.
context.ClearDepthStencilView(dsv, DepthStencilClearFlags.Depth, 0, 0);
context.ClearRenderTargetView(rtv, new SharpDX.Mathematics.Interop.RawColor4());
context.OutputMerger.SetRenderTargets(dsv, rtv);
context.Rasterizer.State = rasterizerState;
context.OutputMerger.SetDepthStencilState(opaqueDepthState);
//All ray traced shapes use analytic coverage writes to get antialiasing.
context.OutputMerger.SetBlendState(a2cBlendState);
SphereRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.spheres.Span), 0, Shapes.spheres.Count);
CapsuleRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.capsules.Span), 0, Shapes.capsules.Count);
CylinderRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.cylinders.Span), 0, Shapes.cylinders.Count);
//Non-raytraced shapes just use regular opaque rendering.
context.OutputMerger.SetBlendState(opaqueBlendState);
BoxRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.boxes.Span), 0, Shapes.boxes.Count);
TriangleRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.triangles.Span), 0, Shapes.triangles.Count);
MeshRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.meshes.Span), 0, Shapes.meshes.Count);
LineRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Lines.lines.Span), 0, Lines.lines.Count);
Background.Render(context, camera);
//Resolve MSAA rendering down to a single sample buffer for screenspace work.
//Note that we're not bothering to properly handle tonemapping during the resolve. That's going to hurt quality a little, but the demos don't make use of very wide ranges.
//(If for some reason you end up expanding the demos to make use of wider HDR, you can make this a custom resolve pretty easily.)
context.ResolveSubresource(colorBuffer, 0, resolvedColorBuffer, 0, Format.R16G16B16A16_Float);
context.OutputMerger.SetRenderTargets(resolvedRTV);
//Glyph and screenspace line drawing rely on the same premultiplied alpha blending transparency. We'll handle their state out here.
context.OutputMerger.SetBlendState(uiBlendState);
context.OutputMerger.SetDepthStencilState(uiDepthState);
ImageRenderer.PreparePipeline(context);
ImageBatcher.Flush(context, Surface.Resolution, ImageRenderer);
UILineBatcher.Flush(context, Surface.Resolution, UILineRenderer);
GlyphRenderer.PreparePipeline(context);
TextBatcher.Flush(context, Surface.Resolution, GlyphRenderer);
//Note that, for now, the compress to swap handles its own depth state since it's the only post processing stage.
context.OutputMerger.SetBlendState(opaqueBlendState);
context.Rasterizer.State = rasterizerState;
CompressToSwap.Render(context, resolvedSRV, Surface.RTV);
}
/// <summary>
/// The create qualifiers.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateQualifiers(ParsingContext context, ParseTreeNode node)
{
var qualifier = node.ChildNodes.Count == 0 ? Qualifier.None : CollectQualifiers(node.ChildNodes[0]);
if (qualifier != Qualifier.None)
{
qualifier.Span = SpanConverter.Convert(node.Span);
}
node.AstNode = qualifier;
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="node">The node.</param>
/// <returns>An expression</returns>
protected static Expression GetExpression(ParseTreeNode node)
{
if (node.AstNode is Identifier)
{
return(new VariableReferenceExpression((Identifier)node.AstNode)
{
Span = SpanConverter.Convert(node.Span)
});
}
return((Expression)node.AstNode);
}
/// <summary>
/// The create storage qualifier.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected virtual void CreateStorageQualifier(ParsingContext context, ParseTreeNode node)
{
var qualifier = Qualifier.None;
if (node.ChildNodes.Count == 1)
{
qualifier = Shaders.Ast.StorageQualifier.Parse(node.ChildNodes[0].Token.Text);
qualifier.Span = SpanConverter.Convert(node.Span);
}
node.AstNode = qualifier;
}
public void Render(Camera camera)
{
if (Surface.Resolution.X != width || Surface.Resolution.Y != height)
{
OnResize();
}
Shapes.MeshCache.FlushPendingUploads();
GL.BindFramebuffer(FramebufferTarget.Framebuffer, framebuffer);
//Note reversed depth.
GL.ClearDepth(0.0f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Enable(EnableCap.CullFace);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Greater);
//All ray traced shapes use analytic coverage writes to get antialiasing.
GL.Enable(EnableCap.SampleAlphaToCoverage);
SphereRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.spheres.Span), 0, Shapes.spheres.Count);
CapsuleRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.capsules.Span), 0, Shapes.capsules.Count);
CylinderRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.cylinders.Span), 0, Shapes.cylinders.Count);
//Non-raytraced shapes just use regular opaque rendering.
GL.Disable(EnableCap.SampleAlphaToCoverage);
BoxRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.boxes.Span), 0, Shapes.boxes.Count);
TriangleRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.triangles.Span), 0, Shapes.triangles.Count);
MeshRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.meshes.Span), 0, Shapes.meshes.Count);
LineRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Lines.lines.Span), 0, Lines.lines.Count);
Background.Render(camera);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
//Resolve MSAA rendering down to a single sample buffer for screenspace work.
//Note that we're not bothering to properly handle tonemapping during the resolve. That's going to hurt quality a little, but the demos don't make use of very wide ranges.
//(If for some reason you end up expanding the demos to make use of wider HDR, you can make this a custom resolve pretty easily.)
GL.BlitNamedFramebuffer(framebuffer, resolvedFramebuffer, 0, 0, width, height, 0, 0, width, height, ClearBufferMask.ColorBufferBit, BlitFramebufferFilter.Nearest);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, resolvedFramebuffer);
//Glyph and screenspace line drawing rely on the same premultiplied alpha blending transparency. We'll handle their state out here.
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha);
GL.BlendEquation(BlendEquationMode.FuncAdd);
ImageRenderer.PreparePipeline();
ImageBatcher.Flush(Surface.Resolution, ImageRenderer);
UILineBatcher.Flush(Surface.Resolution, UILineRenderer);
GlyphRenderer.PreparePipeline();
TextBatcher.Flush(Surface.Resolution, GlyphRenderer);
GL.Disable(EnableCap.Blend);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
CompressToSwap.Render(resolvedColorBuffer);
}
/// <summary>
/// The create identifier composite list.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateIdentifierCompositeList(ParsingContext context, ParseTreeNode node)
{
var values = Ast <List <Identifier> >(node);
foreach (var subNode in node.ChildNodes)
{
values.Add(new Identifier(subNode.Token.Text)
{
Span = SpanConverter.Convert(subNode.Span)
});
}
}
protected override void CreateStorageQualifier(ParsingContext context, ParseTreeNode node)
{
var qualifier = AstCompositeEnum <Qualifier>(node);
if (node.ChildNodes.Count == 1)
{
qualifier = Shaders.Ast.Hlsl.StorageQualifier.Parse(node.ChildNodes[0].Token.Text);
qualifier.Span = SpanConverter.Convert(node.Span);
}
// Use Hlsl Storage Qualifiers to parse the qualifier
node.AstNode = qualifier;
}
/// <summary>
/// The ast.
/// </summary>
/// <param name="node">
/// </param>
/// <typeparam name="T">
/// </typeparam>
/// <returns>
/// </returns>
protected static T Ast <T>(ParseTreeNode node) where T : class, new()
{
T value = new T();
object obj = value;
node.AstNode = value;
if (value is Node)
{
((Node)obj).Span = SpanConverter.Convert(node.Span);
}
return(value);
}
/// <summary>
/// The create parameter qualifier.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected virtual void CreateParameterQualifier(ParsingContext context, ParseTreeNode node)
{
//// [0]
//// storage_class_specifier | _("in") | "out" | "inout" | "point" | "line" | "triangle" | "triangleadj";
if (node.ChildNodes[0].AstNode is Qualifier)
{
node.AstNode = node.ChildNodes[0].AstNode;
}
else
{
var qualifier = Shaders.Ast.Hlsl.ParameterQualifier.Parse(node.ChildNodes[0].Token.Text);
qualifier.Span = SpanConverter.Convert(node.Span);
node.AstNode = qualifier;
}
}
/// <summary>
/// The collect qualifiers.
/// </summary>
/// <param name="node">
/// </param>
/// <returns>
/// </returns>
protected static Qualifier CollectQualifiers(ParseTreeNode node)
{
var value = Qualifier.None;
foreach (var subNode in node.ChildNodes)
{
value |= (Qualifier)subNode.AstNode;
}
if (value != Qualifier.None)
{
value.Span = SpanConverter.Convert(node.Span);
}
return(value);
}
private NonTerminal CreateScalarTerminal <T>(T scalarType) where T : ScalarType, new()
{
return(new NonTerminal(
scalarType.Name,
(context, node) =>
{
var value = Ast <T>(node);
value.Name = new Identifier(scalarType.Name)
{
Span = SpanConverter.Convert(node.Span)
};
value.Type = scalarType.Type;
})
{
Rule = Keyword(scalarType.Name)
});
}
/// <summary>
/// The create method declaration raw ast.
/// </summary>
/// <param name="context">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateMethodDeclarationRawAst(ParsingContext context, ParseTreeNode node)
{
//// method_declaration_raw.Rule =
//// [0] [1] [2] [3]
//// attribute_qualifier_pre + declaration_specifiers + method_declarator + method_qualifier_post;
var methodDeclaration = (MethodDeclaration)node.ChildNodes[2].AstNode;
node.AstNode = methodDeclaration;
methodDeclaration.Span = SpanConverter.Convert(node.Span);
methodDeclaration.Attributes.AddRange((List <AttributeBase>)node.ChildNodes[0].AstNode);
var declarationSpecifiers = (Tuple <Qualifier, TypeBase>)node.ChildNodes[1].AstNode;
methodDeclaration.Qualifiers = declarationSpecifiers.Item1;
methodDeclaration.ReturnType = declarationSpecifiers.Item2;
methodDeclaration.Qualifiers |= (Qualifier)node.ChildNodes[3].AstNode;
methodDeclaration.UpdateParameters();
}
/// <summary>
/// The create cast expression ast.
/// </summary>
/// <param name="parsingcontext">
/// </param>
/// <param name="node">
/// </param>
protected static void CreateCastExpressionAst(ParsingContext parsingcontext, ParseTreeNode node)
{
// [0] [1] [2] [3] [4]
// "(" + type_for_cast + rank_specifier.Star() + ")" + cast_expression;
var value = Ast <CastExpression>(node);
var type = (TypeBase)node.ChildNodes[1].AstNode;
if (node.ChildNodes[2].ChildNodes.Count > 0)
{
var arrayType = new ArrayType {
Type = type, Span = SpanConverter.Convert(node.ChildNodes[2].Span)
};
FillListFromNodes(node.ChildNodes[2].ChildNodes, arrayType.Dimensions);
type = arrayType;
}
value.Target = type;
value.From = (Expression)node.ChildNodes[4].AstNode;
}
protected static void CreateTypeFromTokenAst <T>(ParsingContext parsingcontext, ParseTreeNode node) where T : TypeBase, new()
{
if (node.ChildNodes.Count == 1 && node.ChildNodes[0].AstNode is T)
{
node.AstNode = node.ChildNodes[0].AstNode;
}
else
{
var value = Ast <T>(node);
var nextNode = node;
while (nextNode.Token == null)
{
nextNode = nextNode.ChildNodes[0];
}
value.Name = new Identifier(nextNode.Token.Text)
{
Span = SpanConverter.Convert(node.Span)
};
}
}
private static void HandleMessages(ParseTree parseTree, string file, ParsingResult result)
{
foreach (var parserMessage in parseTree.ParserMessages)
{
var level = new ReportMessageLevel();
switch (parserMessage.Level)
{
case ParserErrorLevel.Info:
level = ReportMessageLevel.Info;
break;
case ParserErrorLevel.Error:
level = ReportMessageLevel.Error;
break;
case ParserErrorLevel.Warning:
level = ReportMessageLevel.Warning;
break;
}
result.Messages.Add(new ReportMessage(level, "", parserMessage.Message, new Ast.SourceSpan(SpanConverter.Convert(parserMessage.Location), 0)));
if (parserMessage.Level != ParserErrorLevel.Info)
{
result.HasErrors = true;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HlslGrammar"/> class.
/// </summary>
public HlslGrammar()
{
GrammarComments = "Hlsl version 5.0";
Term(string_literal_raw, TokenCategory.String, TokenType.StringLiteral);
Punc("::", TokenType.IdentifierSeparator);
// ------------------------------------------------------------------------------------
// Comments
// ------------------------------------------------------------------------------------
identifier_ns_list.Rule = MakePlusRule(identifier_ns_list, ToTerm("::"), identifier_raw);
identifier_dot_list.Rule = MakePlusRule(identifier_dot_list, ToTerm("."), identifier_raw);
identifier_ns.Rule = identifier_raw + "::" + identifier_ns_list;
identifier_dot.Rule = identifier_or_generic + ToTerm(".") + identifier_dot_list;
identifier_or_dot.Rule = identifier | identifier_dot;
identifier.Rule |= identifier_ns;
semi_opt.Rule = Empty | PreferShiftHere() + ";";
//Prepare term set for conflict resolution
_skipTokensInPreview.UnionWith(new[] { ToTerm("."), identifier_raw, ToTerm(","), ToTerm("::"), ToTerm("["), ToTerm("]"), float_literal, integer_literal });
var genericResolverHint = new GenericResolverHint(_skipTokensInPreview);
less_than.Rule = genericResolverHint + "<";
// ------------------------------------------------------------------------------------
// Types
// ------------------------------------------------------------------------------------
// String
string_literal.Rule = string_literal_raw.List();
string_literal_raw.AstNodeCreator = CreateStringRawLiteral;
// Add string to literals
literal.Rule |= string_literal;
float_qualifier.Rule = Keyword("unorm") | Keyword("snorm");
// scalars
var scalarTypes = new[] { ScalarType.Bool, ScalarType.Int, ScalarType.UInt, ScalarType.Float, ScalarType.Half, ScalarType.Double };
foreach (var scalarType in scalarTypes)
{
NonTerminal scalarTerm;
var localScalarType = scalarType;
if (scalarType == ScalarType.Float)
{
scalarTerm = new NonTerminal(
"float",
(context, node) =>
{
var dynamicFloatType = Ast <ScalarType>(node);
dynamicFloatType.Name = new Identifier(localScalarType.Name)
{
Span = SpanConverter.Convert(node.Span)
};
dynamicFloatType.Type = localScalarType.Type;
dynamicFloatType.Qualifiers = Qualifier.None;
if (node.ChildNodes.Count == 2)
{
dynamicFloatType.Qualifiers = (Qualifier)node.ChildNodes[0].AstNode;
}
})
{
Rule = Keyword("float", true) | float_qualifier + Keyword("float", true)
};
}
else
{
scalarTerm = CreateScalarTerminal(scalarType);
}
if (scalars.Rule == null)
{
scalars.Rule = scalarTerm;
}
else
{
scalars.Rule |= scalarTerm;
}
}
// Buffer Rules
buffer_type.Rule = TypeName("Buffer") + less_than + simple_type_or_type_name + ">";
// Vectors Rules
vector_type.AstNodeCreator = CreateVectorAst;
vector_type.Rule = Keyword("vector") + less_than + scalars_or_typename + "," + number + ">";
vector_type_list.Rule = vector_type;
// Add all vector int1 int2 int3 int4... float1 float2 float3 float4... etc.
foreach (var scalarTypeIt in scalarTypes)
{
var scalarType = scalarTypeIt;
for (var dim = 1; dim <= 4; dim++)
{
var vectorTypeInstance = new VectorType(scalarTypeIt, dim);
var nonGenericType = vectorTypeInstance.ToNonGenericType();
var name = nonGenericType.Name.Text;
vector_type_list.Rule |= new NonTerminal(name,
(ctx, node) =>
{
var typeName = vectorTypeInstance.ToNonGenericType(SpanConverter.Convert(node.Span));
node.AstNode = typeName;
})
{
Rule = Keyword(name)
};
}
}
// Matrices
matrix_type_simple.Rule = Keyword("matrix");
matrix_type_simple.AstNodeCreator = (ctx, node) =>
{
var typeName = Ast <TypeName>(node);
typeName.Name = new Identifier("matrix")
{
Span = SpanConverter.Convert(node.Span)
};
typeName.TypeInference.TargetType = new MatrixType(ScalarType.Float, 4, 4);
};
matrix_type.Rule = Keyword("matrix") + less_than + scalars_or_typename + "," + number + "," + number + ">";
matrix_type.AstNodeCreator = CreateMatrixAst;
matrix_type_list.Rule = matrix_type | matrix_type_simple;
// Add all matrix typedefs: int1x1 int1x2... float1x1 float1x2 float1x3 float1x4... etc.
foreach (var scalarTypeIt in scalarTypes)
{
var scalarType = scalarTypeIt;
for (var dimX = 1; dimX <= 4; dimX++)
{
for (var dimY = 1; dimY <= 4; dimY++)
{
var matrixTypeInstance = new MatrixType(scalarTypeIt, dimY, dimX);
var nonGenericType = matrixTypeInstance.ToNonGenericType();
var name = nonGenericType.Name.Text;
// var typeName = new TypeName(name) { Alias = matrixTypeInstance };
matrix_type_list.Rule |= new NonTerminal(
name,
(ctx, node) =>
{
var typeName = matrixTypeInstance.ToNonGenericType(SpanConverter.Convert(node.Span));
node.AstNode = typeName;
})
{
Rule = Keyword(name)
};
}
}
}
// Sampler types
state_type.Rule = CreateRuleFromObjectTypes(
StateType.BlendState,
StateType.DepthStencilState,
StateType.RasterizerState,
SamplerStateType.SamplerState,
SamplerStateType.SamplerStateOld,
SamplerStateType.SamplerComparisonState);
sampler_type.Rule = CreateRuleFromObjectTypes(
SamplerType.Sampler,
SamplerType.Sampler1D,
SamplerType.Sampler2D,
SamplerType.Sampler3D,
SamplerType.SamplerCube);
sampler_type.AstNodeCreator = CreateTypeFromTokenAst <SamplerType>;
// Texture types
texture_type_profile_4.Rule = CreateRuleFromObjectTypes(
TextureType.Texture1D,
TextureType.Texture1DArray,
TextureType.Texture2D,
TextureType.Texture2DArray,
TextureType.Texture3D,
TextureType.TextureCube);
texture_type.Rule = Keyword("texture") | texture_type_profile_4;
// ByteAddressBuffer
byte_address_buffer.Rule = TypeName("ByteAddressBuffer") | TypeName("RWByteAddressBuffer");
// StructuredBuffer
structured_buffer_type.Rule = TypeName("AppendStructuredBuffer") | TypeName("ConsumeStructuredBuffer") | TypeName("RWStructuredBuffer") | TypeName("StructuredBuffer");
structured_buffer.Rule = structured_buffer_type + less_than + scalars_and_vectors + ">";
// RWTexture.*
texture_type_profile_5.Rule = TypeName("RWBuffer") | TypeName("RWTexture1D") | TypeName("RWTexture1DArray") | TypeName("RWTexture2D") | TypeName("RWTexture2DArray") | TypeName("RWTexture3D");
texture_generic_simple_type.Rule = texture_type_profile_4 + less_than + scalars_and_vectors + ">"
| texture_type_profile_5 + less_than + scalars_and_vectors + ">";
texture_dms_type_profile_5.Rule = TypeName("Texture2DMS") | TypeName("Texture2DMSArray");
texture_generic_dms_type.Rule = texture_dms_type_profile_5 + less_than + scalars_and_vectors + ">"
| texture_dms_type_profile_5 + less_than + scalars_and_vectors + "," + number + ">";
texture_generic_type.Rule = texture_generic_simple_type | texture_generic_dms_type;
// HullShader/DomainShader InputPatch/OutputPatch
patch_type.Rule = TypeName("InputPatch") | TypeName("OutputPatch");
patch_generic_type.Rule = patch_type + less_than + type + "," + number + ">";
texture_type_list.Rule = texture_type | texture_generic_type;
// Types used by the geometry shader
geometry_stream.Rule = line_stream | point_stream | triangle_stream | stream_output_object;
triangle_stream.Rule = TypeName("TriangleStream") + less_than + type + ">";
point_stream.Rule = TypeName("PointStream") + less_than + type + ">";
line_stream.Rule = TypeName("LineStream") + less_than + type + ">";
stream_output_object.Rule = TypeName("StreamOutputObject") + less_than + type + ">";
//// Shader object
//// shader_objects.Rule = ToTerm("VertexShader") | "PixelShader" | "GeometryShader";
string_type.Rule = Keyword("string");
// Add string to simple types
simple_type.Rule |= string_type;
// Add Object types
object_type.Rule |= buffer_type
| state_type
| texture_type_list
| byte_address_buffer
| structured_buffer
| patch_generic_type
| interface_specifier
| class_specifier
| geometry_stream;
////| shader_objects;
// Type name
typename_for_cast.Rule = identifier + new IdentifierResolverHint(true);
identifier_generic_parameter_list.Rule = MakePlusRule(identifier_generic_parameter_list, ToTerm(","), identifier_sub_generic);
identifier_sub_generic.Rule = identifier_or_generic;
identifier_sub_generic.AstNodeCreator = CreateIdentifierSubGenericAst;
//identifier_generic.Rule = identifier + new IdentifierResolverHint(true) + "<" + identifier_generic_parameter_list + ">";
identifier_generic.Rule = identifier + new GenericResolverHint(_skipTokensInPreview) + "<" + identifier_generic_parameter_list + ">";
identifier_or_generic.Rule = identifier + new IdentifierResolverHint(true)
| identifier_generic + this.ReduceHere();
type_generic.Rule = identifier_or_generic;
// Type used for cast (use valuetype)
type_for_cast.Rule = typename_for_cast
| value_type;
// ------------------------------------------------------------------------------------
// Expressions
// ------------------------------------------------------------------------------------
// Add special variable allowed as variable name and keyword
identifier_extended.Rule |= Keyword("sample") | Keyword("point");
// postfix_expression
postfix_expression.Rule |= compile_expression
| asm_expression
| state_expression;
compile_expression.Rule = Keyword("compile") + identifier + method_invoke_expression_simple;
// Match an asm block: asm { ... }
asm_expression.Rule = asm_block;
KeyTerms.Add(asm_block.Name, asm_block);
state_expression.Rule = state_type + state_initializer;
// Add cast_expression
cast_expression_raw.Rule = "(" + type_for_cast + rank_specifier.ListOpt() + ")" + cast_expression;
cast_expression.Rule |= cast_expression_raw;
// Syntax is for example: texture = <g_textureref>;
identifier_special_reference_expression.Rule = less_than + indexable_identifier + ">";
identifier_keyword.Rule = Keyword("texture");
simple_assignment_expression_statement.Rule |= indexable_identifier + assignment_operator + identifier_special_reference_expression + ";"
| identifier_keyword + assignment_operator + identifier_special_reference_expression + ";"
| identifier_keyword + assignment_operator + expression + ";";
state_initializer.Rule = "{" + simple_assignment_expression_statement.ListOpt() + "}";
// ------------------------------------------------------------------------------------
// Attribute modifiers
// ------------------------------------------------------------------------------------
attribute_qualifier_pre.Rule = attribute_list_opt;
attribute_list_opt.Rule = MakeStarRule(attribute_list_opt, null, attribute_modifier);
attribute_modifier.Rule = "[" + identifier + "]"
| "[" + identifier + "(" + literal_list.Opt() + ")" + "]";
// ------------------------------------------------------------------------------------
// Variable modifiers
// ------------------------------------------------------------------------------------
// storageClass = Storage_Class + Type_Modifier
storage_qualifier.Rule |= Keyword("extern") | Keyword("nointerpolation") | Keyword("precise") | Keyword("shared") | Keyword("groupshared") | Keyword("static") | Keyword("volatile")
| Keyword("row_major") | Keyword("column_major") | Keyword("linear") | Keyword("centroid") | Keyword("noperspective") | Keyword("sample") | Keyword("unsigned")
| Keyword("inline");
semantic.Rule = ToTerm(":") + identifier;
packoffset.Rule = ToTerm(":") + Keyword("packoffset") + "(" + identifier_or_dot + ")";
register.Rule = ToTerm(":") + Keyword("register") + "(" + indexable_identifier + ")"
| ToTerm(":") + Keyword("register") + "(" + identifier + "," + indexable_identifier + ")";
variable_declarator_qualifier_post_hlsl.Rule = Empty
| semantic
| semantic + packoffset + register.ListOpt()
| semantic + register.List()
| packoffset + register.ListOpt()
| register.List();
variable_declarator_qualifier_post.Rule = variable_declarator_qualifier_post_hlsl;
// ------------------------------------------------------------------------------------
// Declarations
// ------------------------------------------------------------------------------------
// Add typedef and constant buffer resource
declaration.Rule |= typedef_declaration
| constant_buffer_resource;
indexable_identifier_declarator_list.Rule = MakePlusRule(indexable_identifier_declarator_list, ToTerm(","), indexable_identifier_declarator);
// typedef [const] Type Name[Index];
typedef_declaration.Rule = Keyword("typedef") + type + indexable_identifier_declarator_list + ";"
| Keyword("typedef") + storage_qualifier + type + indexable_identifier_declarator_list + ";";
annotations.Rule = less_than + variable_declaration_raw.ListOpt() + ">";
annotations_opt.Rule = Empty | annotations;
// todo: add annotations_opt to variable_declarator qualifier post
// Add annotations to variable declarator
variable_declarator_raw.Rule += annotations_opt;
// Add special
variable_declarator.Rule |= variable_declarator_raw + state_initializer
| variable_declarator_raw + state_array_initializer;
state_initializer_list.Rule = MakePlusRule(state_initializer_list, ToTerm(","), state_initializer);
state_array_initializer.Rule = "{" + state_initializer_list + "}"
| "{" + state_initializer_list + "," + "}";
// interface definition
interface_specifier.Rule = Keyword("interface") + identifier_or_generic + "{" + method_declaration.ListOpt() + "}";
// class definition
class_specifier.Rule = Keyword("class") + identifier_or_generic + class_base_type + "{" + scope_declaration.ListOpt() + "}";
class_base_type_list.Rule = MakePlusRule(class_base_type_list, ToTerm(","), type_generic);
class_base_type.Rule = (ToTerm(":") + class_base_type_list).Opt();
// buffer definition
constant_buffer_resource_type.Rule = Keyword("cbuffer") | Keyword("tbuffer");
constant_buffer_resource.Rule = attribute_qualifier_pre + constant_buffer_resource_type + identifier.Opt() + register.Opt() + "{" + declaration.ListOpt() + "}" + semi_opt;
semantic_list_opt.Rule = semantic.ListOpt();
// Method
method_qualifier_post.Rule = semantic_list_opt;
method_operator_identifier.Rule = Keyword("operator") + "[" + "]"
| Keyword("operator") + "[" + "]" + "[" + "]";
method_special_identifier.Rule = identifier_extended + "." + method_operator_identifier | method_operator_identifier;
method_declarator.Rule |= method_special_identifier + "(" + parameter_list + ")";
parameter_qualifier.Rule = storage_qualifier | Keyword("in") | Keyword("out") | Keyword("inout") | Keyword("point") | Keyword("line") | Keyword("lineadj") | Keyword("triangle") | Keyword("triangleadj");
parameter_qualifier.AstNodeCreator = CreateParameterQualifier;
parameter_qualifier_pre_list_opt.Rule = parameter_qualifier.ListOpt();
parameter_qualifier_pre.Rule = parameter_qualifier_pre_list_opt;
// Make parameter_qualifier_pre transient as there is nothing else to parse then parameter_qualifier_pre_list_opt
parameter_qualifier_pre.Flags = TermFlags.IsTransient | TermFlags.NoAstNode;
parameter_qualifier_post.Rule = semantic_list_opt
| "=" + initializer + semantic_list_opt;
parameter_qualifier_post.AstNodeCreator = CreateParameterQualifierPost;
// ------------------------------------------------------------------------------------
// Technique/pass
// ------------------------------------------------------------------------------------
// technique
technique_keyword.Rule = Keyword("technique") | Keyword("Technique") | Keyword("technique10") | Keyword("Technique10") | Keyword("technique11") | Keyword("Technique11");
technique_definition.Rule = attribute_qualifier_pre + technique_keyword + identifier.Opt() + annotations_opt + "{" + pass_definition.List() + "}" + semi_opt;
// pass
pass_keyword.Rule = Keyword("pass") | Keyword("Pass");
pass_statement.Rule = method_invoke_expression_simple + ";"
| simple_assignment_expression_statement;
pass_definition.Rule = attribute_qualifier_pre + pass_keyword + identifier.Opt() + annotations_opt + "{" + pass_statement.ListOpt() + "}" + semi_opt;
// ------------------------------------------------------------------------------------
// Top Level
// ------------------------------------------------------------------------------------
// Add the technique to the top level
toplevel_declaration.Rule |= technique_definition;
/*
* //// ------------------------------------------------------------------------------------
* //// Xenko Grammar
* //// ------------------------------------------------------------------------------------
* //var identifier_csharp = new NonTerminal("identifier_csharp");
* //var group = new NonTerminal("group");
* //var using_statement = new NonTerminal("using_statement");
* //group.Rule = "group" + identifier + "{" + scope_declaration.ListOpt() + "}";
* //identifier_csharp.Rule = MakePlusRule(identifier_csharp, ToTerm("."), identifier);
* //using_statement.Rule = "using" + identifier + "=" + identifier_csharp + ";"
* // | "using" + identifier_csharp + ";";
* //scope_declaration.Rule |= using_statement;
* //toplevel_declaration.Rule |= group;
*/
// ------------------------------------------------------------------------------------
// Globals
// ------------------------------------------------------------------------------------
// LanguageFlags = LanguageFlags.NewLineBeforeEOF;
LanguageFlags |= LanguageFlags.CreateAst;
}
public override void Convert(ReadOnlySpan <TiffBgra64> source, Span <TiffGray16> destination)
{
SpanConverter.Convert(source, destination);
}
public override void Convert(ReadOnlySpan <TiffCmyk64> source, Span <TiffCmyk32> destination)
{
SpanConverter.Convert(source, destination);
}
public override void Convert(ReadOnlySpan <TiffBgr24> source, Span <TiffRgba32> destination)
{
SpanConverter.Convert(source, destination);
}
public override void Convert(ReadOnlySpan <TiffGray8> source, Span <TiffRgb24> destination)
{
SpanConverter.Convert(source, destination);
}
