public MidElementCtorApp(
SourceRange range,
MidElementDecl element,
IEnumerable<MidElementCtorArg> args)
: base(range, new MidElementType(element))
{
_element = element;
_args = args.ToArray();
}
public MidAttributeDecl(
Identifier name,
MidElementDecl element,
MidType type,
MidExp exp )
{
_name = name;
_element = element;
_type = type;
_exp = exp;
}
public MidAttributeDecl(
Identifier name,
MidElementDecl element,
MidType type,
MidExp exp)
{
_name = name;
_element = element;
_type = type;
_exp = exp;
}
public MidLocalEmitEnv(
MidEmitEnv parent,
IdentifierFactory identifiers,
MidElementDecl element,
MidExpFactory exps)
: base(parent)
{
_identifiers = identifiers;
_element = element;
_exps = exps;
}
public static void Dump(
this MidElementDecl element,
Span span)
{
span.WriteLine("element {0} {{", element.Name);
var inner = span.IndentSpan();
foreach (var a in element.Attributes)
{
a.Dump(inner);
}
span.WriteLine("}");
}
private MidMemberDecl EmitMemberDeclImpl(
MidFacetDecl midFacet,
IResElementDecl resElement,
MidEmitEnv env)
{
var midElement = new MidElementDecl(midFacet, resElement.Name);
midElement.DoneBuilding();
midFacet.AddElement(midElement);
return(midElement);
}
private MidExp EmitAttrExp(
MidElementDecl midElement,
MidType midType,
IResExp resExp,
MidEmitEnv env)
{
var savedElement = _currentElement;
_currentElement = midElement;
var result = EmitLocalExp(resExp, env, midElement);
_currentElement = savedElement;
return(result);
}
private MidVal EmitValToElementImpl(
IResExp resExp,
MidElementDecl element,
MidEmitEnv parentEnv)
{
var midExp = EmitLocalExp(resExp, parentEnv, element);
if (midExp is MidVal)
{
return((MidVal)midExp);
}
var midType = EmitTypeExp(resExp.Type, parentEnv);
var attr = element.CacheAttr(
midExp,
midType);
return(_exps.AttributeRef(resExp.Range, attr));
}
private MidVal EmitValToElement(
IResExp resExp,
MidElementDecl element,
MidEmitEnv parentEnv)
{
if (element == _currentElement)
{
return(EmitVal(resExp, parentEnv));
}
var savedElement = _currentElement;
_currentElement = element;
var result = EmitValToElementImpl(
resExp,
element,
parentEnv);
_currentElement = savedElement;
return(result);
}
public void Collect(
MidPipelineDecl pipeline,
MidElementDecl element,
MidAttributeDecl attribute)
{
if (!attribute.IsOutput)
return;
if (!(attribute.Type is MidStructRef))
return;
// Unmark the attribute as an output...
attribute.IsOutput = false;
var structType = (MidStructRef)attribute.Type;
AttributeInfo attrInfo;
attrInfo.AttrDecl = attribute;
attrInfo.Fields = (from f in structType.Fields
select CreateField(pipeline, element, attribute, f)).ToArray();
_replacePass._attrInfos[attribute] = attrInfo;
}
public ConnectorTypeHLSL(
string name,
MidElementDecl element)
: base(name)
{
_elementDecl = element;
}
private EmitValHLSL DeclareAndInitRecord(
Span span,
MidElementDecl record,
EmitValHLSL destVar)
{
var recordVal = EvaluateRecordAttrs(span, record);
DeclareAndInitLocal(
destVar,
recordVal,
span);
return destVar;
}
public void AddElement(MidElementDecl element)
{
_elements.Add(element);
}
public MidElementType(
MidElementDecl element)
{
_element = element;
}
public IAggTypeHLSL EmitType(MidElementDecl element)
{
IAggTypeHLSL result;
if (_elementTypes.TryGetValue(element, out result))
return result;
// Actually emit the type, then...
var name = string.Format("Tup_{0}", element.Name.ToString());
TupleTypeHLSL tupleType = new TupleTypeHLSL(name);
_elementTypes[element] = tupleType;
foreach (var a in element.Attributes)
{
if (!a.IsOutput) continue;
var attrName = MapName(a);
tupleType.AddField(
attrName,
EmitType(a.Type));
}
return tupleType;
}
// Main shader body stuff
public EmitValHLSL EmitConnectorCtor(
Span span,
MidElementDecl element)
{
var name = _shared.GenerateName("__result");
var type = GenerateConnectorType(element);
var val = type.CreateVal(name);
DeclareAndInitRecord(
span,
element,
val);
return val;
}
public ElementCtorInfo(
string name,
MidElementDecl elementDecl,
IEnumerable<MidAttributeDecl> inputAttributes)
{
_name = name;
_elementDecl = elementDecl;
_inputAttributes = inputAttributes.ToArray();
}
public override void EmitImplSetup()
{
constantElement = GetElement("Constant");
var uniformElement = GetElement("Uniform");
var fineVertexElement = GetElement("FineVertex");
var rasterVertexElement = GetElement("RasterVertex");
InitBlock.AppendComment("D3D11 Domain Shader");
var tessEnabledAttr = FindAttribute( constantElement, "__D3D11TessellationEnabled" );
if( tessEnabledAttr == null )
{
return;
}
var outputPatchElement = GetElement( "OutputPatch" );
var controlPointElement = GetElement( "ControlPoint" );
// \todo: Need to check whether GS is enabled.
var gsEnabledAttr = FindAttribute( constantElement, "__D3D11GeometryShaderEnabled" );
var outputElement = fineVertexElement;
if( gsEnabledAttr == null )
{
outputElement = rasterVertexElement;
}
hlslContext = new EmitContextHLSL(SharedHLSL, Range, this.EmitClass.GetName());
var entryPointSpan = hlslContext.EntryPointSpan;
var outputControlPointCount = GetAttribute(constantElement, "HS_OutputControlPointCount");
var tsDomain = GetAttribute(constantElement, "TS_Domain");
// Bind a bunch of attributes that really represent constants:
hlslContext.BindAttrLit(
GetAttribute(constantElement, "TriangleDomain"),
"tri");
hlslContext.BindAttrLit(
GetAttribute(constantElement, "QuadDomain"),
"quad");
hlslContext.BindAttrLit(
GetAttribute(constantElement, "FractionalOddPartitioning"),
"fractional_odd");
hlslContext.BindAttrLit(
GetAttribute(constantElement, "IntegerPartitioning"),
"integer");
hlslContext.BindAttrLit(
GetAttribute(constantElement, "TriangleCWTopology"),
"triangle_cw");
hlslContext.GenerateConnectorType(controlPointElement);
hlslContext.GenerateConnectorType(outputElement);
entryPointSpan.WriteLine("[domain(\"{0}\")]",
hlslContext.EmitAttrLit( tsDomain ));
entryPointSpan.WriteLine("{0} main(",
hlslContext.GenerateConnectorType(outputElement));
bool first = true;
if (outputPatchElement.Attributes.Any((a) => a.IsOutput))
{
hlslContext.DeclareConnectorAndBind(
outputPatchElement,
GetAttribute(fineVertexElement, "__op2dv"),
ref first,
entryPointSpan);
}
// \todo: These should not be required, but seem related
// to an fxc bug where it expects the tess-factor inputs
// to be re-declared in the DS...
var edgeFactors = GetAttribute(outputPatchElement, "HS_EdgeFactors");
var insideFactors = GetAttribute(outputPatchElement, "HS_InsideFactors");
/*
hlslContext.DeclareParamAndBind(
edgeFactors,
"SV_TessFactor",
ref first,
entryPointSpan);
hlslContext.DeclareParamAndBind(
insideFactors,
"SV_InsideTessFactor",
ref first,
entryPointSpan);
*/
hlslContext.DeclareParamAndBind(
GetAttribute(fineVertexElement, "DS_DomainLocation"),
"SV_DomainLocation",
ref first,
entryPointSpan);
hlslContext.DeclareParamAndBind(
GetAttribute(fineVertexElement, "DS_InputControlPoints"),
null,
ref first,
entryPointSpan);
/*
entryPointSpan.WriteLine(",");
entryPointSpan.WriteLine("\tconst OutputPatch<{0}, {1}> DS_InputControlPoints",
hlslContext.GenerateConnectorType(outputControlPointElement),
hlslContext.EmitAttribRef(
outputControlPointCount,
null));
*/
entryPointSpan.WriteLine("\t)");
entryPointSpan.WriteLine("{");
if (fineVertexElement != outputElement)
{
hlslContext.EmitTempRecordCtor(
entryPointSpan,
fineVertexElement,
GetAttribute(rasterVertexElement, "__f2rhelper"));
}
var output = hlslContext.EmitConnectorCtor(
entryPointSpan,
outputElement );
entryPointSpan.WriteLine("\treturn {0};", output);
entryPointSpan.WriteLine("}");
hlslContext.EmitConstantBufferDecl();
EmitShaderSetup(
hlslContext,
"ds_5_0",
"Domain",
"DS");
}
public void SimplifyElement(MidElementDecl element)
{
foreach (var a in element.Attributes)
SimplifyAttribute(a);
}
public void CollectElementInfo( MidElementDecl element )
{
foreach( var a in element.Attributes )
CollectAttributeInfo( a );
foreach( var wrapper in element.AttributeWrappers )
{
_mapOldToWrapper[ wrapper.Attribute ] = wrapper;
}
}
protected MidAttributeWrapperDecl GetAttribute(MidElementDecl element, string name)
{
var result = FindAttribute(element, name);
if (result != null)
return result;
throw new NotImplementedException();
}
protected MidAttributeWrapperDecl FindAttribute(MidElementDecl element, string name)
{
foreach (var a in element.AttributeWrappers)
{
if (a.Name == Identifiers.simpleIdentifier(name))
return a;
}
return null;
}
public override void EmitImplSetup()
{
constantElement = GetElement( "Constant" );
InitBlock.AppendComment( "D3D11 Geometry Shader" );
var gsEnabledAttr = FindAttribute( constantElement, "__D3D11GeometryShaderEnabled" );
if( gsEnabledAttr == null )
{
return;
}
var uniformElement = GetElement( "Uniform" );
var fineVertexElement = GetElement( "FineVertex" );
var rasterVertexElement = GetElement( "RasterVertex" );
var geometryInputElement = GetElement( "GeometryInput" );
var geometryOutputElement = GetElement( "GeometryOutput" );
hlslContext = new EmitContextHLSL( SharedHLSL, Range, this.EmitClass.GetName() );
var entryPointSpan = hlslContext.EntryPointSpan;
var gsInstanceCount = GetAttribute( constantElement, "GS_InstanceCount" );
var gsInputVertexCount = GetAttribute( constantElement, "GS_InputVertexCount" );
var gsMaxOutputVertexCount = GetAttribute( constantElement, "GS_MaxOutputVertexCount" );
var gsInstanceID = GetAttribute( geometryInputElement, "GS_InstanceID" );
var gsInputVertices = GetAttribute( geometryInputElement, "GS_InputVertices" );
var gsOutputStream = GetAttribute( geometryOutputElement, "GS_OutputStream" );
hlslContext.GenerateConnectorType(fineVertexElement);
hlslContext.GenerateConnectorType(rasterVertexElement);
entryPointSpan.WriteLine( "[instance({0})]",
hlslContext.EmitAttrLit( gsInstanceCount ) );
entryPointSpan.WriteLine( "[maxvertexcount({0})]",
hlslContext.EmitAttrLit( gsMaxOutputVertexCount ) );
entryPointSpan.WriteLine( "void main(" );
bool first = true;
// \todo: "triangle" or appropriate prefix...
hlslContext.DeclareParamAndBind(
gsInputVertices,
hlslContext.MakeArrayType(
hlslContext.GenerateConnectorType(fineVertexElement),
hlslContext.EmitAttribRef(gsInputVertexCount, null)),
null,
ref first,
entryPointSpan,
prefix: "triangle ");
hlslContext.DeclareParamAndBind(
gsOutputStream,
null,
ref first,
entryPointSpan,
prefix: "inout ");
hlslContext.DeclareParamAndBind(
gsInstanceID,
"SV_GSInstanceID",
ref first,
entryPointSpan );
entryPointSpan.WriteLine( "\t)" );
entryPointSpan.WriteLine( "{" );
var gi2go = hlslContext.EmitTempRecordCtor(
entryPointSpan,
geometryInputElement,
GetAttribute(geometryOutputElement, "__gi2go"));
hlslContext.BindAttr(
GetAttribute(rasterVertexElement, "__gi2rv"),
gi2go);
var output = hlslContext.EmitConnectorCtor(
entryPointSpan,
geometryOutputElement );
entryPointSpan.WriteLine( "}" );
hlslContext.EmitConstantBufferDecl();
EmitShaderSetup(
hlslContext,
"gs_5_0",
"Geometry",
"GS" );
}
private EmitValHLSL EvaluateRecordAttrs(
Span span,
MidElementDecl record )
{
var recordType = EmitType(record);
var attribVals = (from a in record.Attributes
where a.IsOutput
select EmitAttribRef(a, span)).Eager();
var recordVal = new TupleValHLSL(
recordType,
attribVals);
return recordVal;
}
private ElementCtorInfo GetElementCtor(MidElementDecl elementDecl)
{
ElementCtorInfo result;
if (_elementCtors.TryGetValue(elementDecl, out result))
return result;
string name = "Ctor_" + elementDecl.Name.ToString();
var inputAttributes = (from a in elementDecl.Attributes
where a.Exp == null // \todo: real test for input-ness
select a).ToArray();
result = new ElementCtorInfo(
name,
elementDecl,
inputAttributes);
var span = new Span();
span.WriteLine("void {0}(", name);
var resultType = EmitType(elementDecl);
bool first = true;
var resultParam = DeclareOutParam("__result", resultType, span, ref first);
foreach (var a in inputAttributes)
{
var attrName = MapName(a);
var attrType = EmitType(a.Type);
var attrParam = DeclareParam(
attrName,
attrType,
span,
ref first);
_attrVals[a] = attrParam;
}
span.WriteLine(")");
span.WriteLine("{");
var resultAttrs = (from a in elementDecl.Attributes
where a.IsOutput
select EmitAttribRef(a, span)).ToArray();
var resultVal = new TupleValHLSL(
(IAggTypeHLSL) resultType,
resultAttrs);
Assign(resultParam, resultVal, span);
span.WriteLine("}");
_subroutineHeaderSpan.Add(span);
_elementCtors[elementDecl] = result;
return result;
}
public static void UnmarkOutputs( MidElementDecl element )
{
foreach( var a in element.Attributes )
UnmarkOutputs( a );
}
public void DeclareConnectorAndBind(
MidElementDecl element,
MidAttributeWrapperDecl attr,
ref bool firstParam,
Span span)
{
var attrType = GenerateConnectorType(element);
DeclareParamAndBind(
attr,
attrType,
null,
ref firstParam,
span );
}
public void AddElement(MidElementDecl element)
{
_elements.Add(element);
}
public EmitValHLSL EmitTempRecordCtor(
Span span,
MidElementDecl recordToConstruct,
MidAttributeWrapperDecl wrapper )
{
var attr = wrapper.Attribute;
var attrName = attr.Name.ToString();
var attrType = EmitType(attr.Type);
var attrVal = attrType.CreateVal(attrName);
BindAttr(attr, attrVal);
return DeclareAndInitRecord(
span,
recordToConstruct,
attrVal);
}
// Generate "connector" struct type for a particular stage
public ConnectorTypeHLSL GenerateConnectorType(MidElementDecl element)
{
if (_elementTypes.ContainsKey(element) && !_connectorTypes.ContainsKey(element))
{
throw new NotImplementedException();
}
ConnectorTypeHLSL result;
if (_connectorTypes.TryGetValue(element, out result))
return result;
// Actually emit the type, then...
var name = string.Format("T_{0}", element.Name.ToString());
result = new ConnectorTypeHLSL(name, element);
_connectorTypes[element] = result;
_elementTypes[element] = result;
var span = new Span();
span.WriteLine("struct {0}", result);
span.WriteLine("{");
var memberSpan = span.IndentSpan();
foreach (var a in element.Attributes)
{
// Only output attributes go in the connector
if (!a.IsOutput) continue;
var attrName = MapName(a);
var attrType = EmitType(a.Type);
var rawName = a.Name.ToString();
string semantic = "";
switch (rawName)
{
case "HS_EdgeFactors":
semantic = ": SV_TessFactor";
break;
case "HS_InsideFactors":
semantic = ": SV_InsideTessFactor";
break;
case "__RS_Position":
semantic = ": SV_Position";
break;
case "__RS_RenderTargetArrayIndex":
semantic = ": SV_RenderTargetArrayIndex";
break;
default:
semantic = string.Format(" : USER_{0}", attrName);
break;
}
var attrRep = DeclareConnectorFields(
attrType,
attrName,
semantic,
memberSpan.IndentSpan() );
result.AddField(
attrName,
attrRep);
}
span.WriteLine("};");
span.WriteLine();
_typeHeaderSpan.Add(span);
return result;
}
public void ApplyToElement(MidElementDecl element)
{
foreach (var a in element.Attributes)
ApplyToAttribute(a);
}
public EmitValHLSL InitRecord(
Span span,
MidElementDecl record,
EmitValHLSL destVar)
{
var recordVal = EvaluateRecordAttrs(span, record);
Assign(
destVar,
recordVal,
span);
return destVar;
}
public MidElementType(
MidElementDecl element)
{
_element = element;
}
private FieldInfo CreateField(
MidPipelineDecl pipeline,
MidElementDecl element,
MidAttributeDecl attribute,
MidFieldDecl field)
{
var midExp = _exps.FieldRef(
attribute.Range,
_exps.AttributeRef( attribute.Range, attribute ),
field );
var name = _identifiers.unique(
string.Format( "{0}_{1}", attribute.Name, field.Name ) );
var newAttr = element.CacheAttr(
midExp,
field.Type);
newAttr.TrySetName(name, attribute.Range);
return new FieldInfo{
AttrDecl = newAttr,
FieldDecl = field};
}
