public IEmitVal EmitExp(
MidExp exp,
IEmitBlock block,
EmitEnv env)
{
return(EmitExpImpl((dynamic)exp, block, env));
}
public MidAttributeDecl(
Identifier name,
MidElementDecl element,
MidType type,
MidExp exp )
{
_name = name;
_element = element;
_type = type;
_exp = exp;
}
public MidLetExp(
SourceRange range,
MidVar var,
MidExp exp,
MidExp body)
: base(range, new MidDummyType())
{
_var = var;
_exp = exp;
_body = body;
}
public static void MarkOutputs(MidExp exp)
{
MidTransform transform = new MidTransform(
(e) =>
{
if (e is MidAttributeFetch)
((MidAttributeFetch)e).Attribute.IsOutput = true;
return e;
});
transform.Transform(exp);
}
private void SetSource(
ref MidExp srcExp,
MidAttributeDecl attr)
{
if (srcExp != null)
{
if (srcExp is MidAttributeRef)
{
var srcAttr = ((MidAttributeRef)srcExp).Decl;
if (srcAttr != attr)
{
throw OperationTooComplexError(srcExp.Range);
}
}
else
{
throw OperationTooComplexError(srcExp.Range);
}
}
srcExp = new MidAttributeRef(attr.Range, attr, new LazyFactory());
}
private AttrInfo DecomposeAttr(
MidExp exp,
DecomposeAttrContext context)
{
return(DecomposeAttrImpl((dynamic)exp, context));
}
public EmitValHLSL EmitExp(
MidExp exp,
Span span)
{
if (exp is MidVal)
return EmitVal((MidVal)exp, span);
EmitValHLSL expVal = EmitExpRaw(exp, span);
if (exp is MidLetExp)
return expVal;
if (exp.Type == null)
{
throw new NotImplementedException();
}
if (exp.Type is MidVoidType)
{
return VoidVal;
}
if (expVal is VoidValHLSL)
{
return expVal;
}
// \todo: Why not use the type of the result?
var expType = EmitType(exp.Type);
var temp = expType.CreateVal(
_shared.GenerateName("_t"));
DeclareAndInitLocal(
temp,
expVal,
span);
return temp;
}
private AttrInfo DecomposeAttrImpl(
MidExp exp,
DecomposeAttrContext context)
{
throw OperationTooComplexError(exp.Range);
}
// Expressions
public void PreEmitExp(
MidExp exp,
Span span)
{
PreEmitExpImpl((dynamic)exp, span);
}
private EmitValHLSL EmitExpRaw(MidExp exp, Span span)
{
return EmitExpImpl((dynamic)exp, span);
}
private bool UsesVar(
MidExp exp,
MidVar var)
{
bool result = false;
var transform = new MidTransform(
(e) =>
{
if (e is MidVarRef && (e as MidVarRef).Var == var)
result = true;
return e;
});
transform.Transform(exp);
return result;
}
private AttributeInfo DecomposeAttrImpl(
SourceRange range,
MidExp exp)
{
throw OperationTooComplex(exp.Range);
}
public MidLabelExp(
SourceRange range,
MidLabel label,
MidExp body,
MidType type)
: base(range, type)
{
_label = label;
_body = body;
}
private MidExp TryFoldPath(
MidVar var,
MidExp exp,
MidPath path)
{
if (exp is MidFieldRef)
{
var midFieldRef = (MidFieldRef)exp;
if (midFieldRef.Obj is MidVarRef)
{
var midVarRef = (MidVarRef) midFieldRef.Obj;
if (midVarRef.Var == var)
{
midFieldRef.Obj = path;
return midFieldRef;
}
}
}
return exp;
}
private MidExp PreTransform(MidExp exp)
{
if (_preTransform == null)
return exp;
return _preTransform(exp);
}
public void TransformChildren(MidExp exp)
{
TransformChildrenImpl((dynamic)exp);
}
public MidExp Transform(MidExp exp)
{
var e = PreTransform(exp);
TransformChildren(e);
e = PostTransform(e);
return e;
}
public MidExp PreTransform(MidExp exp)
{
return exp;
}
private MidExp Replace(
MidExp exp)
{
return ReplaceImpl((dynamic)exp);
}
private MidExp SimplifyLabelExpImpl(
MidLabelExp labelExp,
MidExp exp,
SimplifyEnv env)
{
if (!UsesLabel(exp, labelExp.Label))
return exp;
return labelExp;
}
private AttrInfo DecomposeAttrImpl(
MidExp exp,
DecomposeAttrContext context)
{
throw OperationTooComplexError(exp.Range);
}
private bool UsesLabel(
MidExp exp,
MidLabel label)
{
bool result = false;
var transform = new MidTransform(
(e) =>
{
if (e is MidBreakExp && (e as MidBreakExp).Label == label)
result = true;
return e;
});
transform.Transform(exp);
return result;
}
//
public override void EmitImplSetup()
{
var uniformElement = GetElement("Uniform");
var rasterVertex = GetElement("RasterVertex");
var fragmentElement = GetElement("Fragment");
var pixelElement = GetElement("Pixel");
// Find all render targets:
renderTargetAttributes = (from a in pixelElement.Attributes
where a.Exp != null
where a.IsOutput
select a).ToArray();
renderTargetCount = renderTargetAttributes.Length;
// Depth-stencil view
depthStencilViewAttribute = GetAttribute(uniformElement, "depthStencilView");
// Compute the setup required by the OM
// Blending stuff
var blendStateType = EmitTarget.GetOpaqueType("ID3D11BlendState*");
blendStateField = EmitClass.AddPrivateField(
blendStateType,
"_blendState");
_renderTargetBlendDescs = new TargetBlendDesc[renderTargetCount];
_renderTargetSources = new SourceInfo[renderTargetCount];
for (int ii = 0; ii < renderTargetCount; ++ii)
{
DecomposeAttr(renderTargetAttributes[ii], ii);
}
var rtBlendDescType = EmitTarget.GetBuiltinType("D3D11_RENDER_TARGET_BLEND_DESC");
var blendSpecVals = (from desc in _renderTargetBlendDescs
select InitBlock.Struct(
"D3D11_RENDER_TARGET_BLEND_DESC",
InitBlock.LiteralBool(desc.blendEnable),
InitBlock.Enum32(desc.color.srcBlend),
InitBlock.Enum32(desc.color.destBlend),
InitBlock.Enum32(desc.color.op),
InitBlock.Enum32(desc.alpha.srcBlend),
InitBlock.Enum32(desc.alpha.destBlend),
InitBlock.Enum32(desc.alpha.op),
InitBlock.LiteralU32(desc.writeMask))).ToList();
while (blendSpecVals.Count < 8) // \todo: get the limits from somwhere!!!
{
blendSpecVals.Add(
InitBlock.Struct(
"D3D11_RENDER_TARGET_BLEND_DESC",
InitBlock.LiteralBool(false),
InitBlock.Enum32("D3D11_BLEND", "D3D11_BLEND_ONE", D3D11_BLEND.D3D11_BLEND_ONE),
InitBlock.Enum32("D3D11_BLEND", "D3D11_BLEND_ZERO", D3D11_BLEND.D3D11_BLEND_ZERO),
InitBlock.Enum32("D3D11_BLEND_OP", "D3D11_BLEND_OP_ADD", D3D11_BLEND_OP.D3D11_BLEND_OP_ADD),
InitBlock.Enum32("D3D11_BLEND", "D3D11_BLEND_ONE", D3D11_BLEND.D3D11_BLEND_ONE),
InitBlock.Enum32("D3D11_BLEND", "D3D11_BLEND_ZERO", D3D11_BLEND.D3D11_BLEND_ZERO),
InitBlock.Enum32("D3D11_BLEND_OP", "D3D11_BLEND_OP_ADD", D3D11_BLEND_OP.D3D11_BLEND_OP_ADD),
InitBlock.LiteralU32((UInt32)D3D11_COLOR_WRITE_ENABLE.D3D11_COLOR_WRITE_ENABLE_ALL)));
}
var blendSpecsVal = InitBlock.Array(
rtBlendDescType,
blendSpecVals);
InitBlock.AppendComment("D3D11 Output Merger");
var blendDescVal =
InitBlock.Temp("blendDesc",
InitBlock.Struct(
"D3D11_BLEND_DESC",
InitBlock.LiteralBool(false),
InitBlock.LiteralBool(true),
blendSpecsVal));
InitBlock.SetArrow(
CtorThis,
blendStateField,
EmitTarget.GetNullPointer(blendStateType));
InitBlock.CallCOM(
CtorDevice,
"ID3D11Device",
"CreateBlendState",
blendDescVal.GetAddress(),
InitBlock.GetArrow(CtorThis, blendStateField).GetAddress());
DtorBlock.CallCOM(
DtorBlock.GetArrow(DtorThis, blendStateField),
"IUnknown",
"Release");
// Emit HLSL code for PS
InitBlock.AppendComment("D3D11 Pixel Shader");
hlslContext = new EmitContextHLSL(SharedHLSL, Range, this.EmitClass.GetName());
var entryPointSpan = hlslContext.EntryPointSpan;
entryPointSpan.WriteLine("void main(");
bool firstParam = true;
hlslContext.DeclareConnectorAndBind(
rasterVertex,
GetAttribute(fragmentElement, "__rv2f"),
ref firstParam,
entryPointSpan);
hlslContext.DeclareParamAndBind(
GetAttribute(fragmentElement, "PS_ScreenSpacePosition"),
"SV_Position",
ref firstParam,
entryPointSpan);
for (int ii = 0; ii < renderTargetCount; ++ii)
{
if (!firstParam)
{
entryPointSpan.WriteLine(",");
}
firstParam = false;
var sourceInfo = _renderTargetSources[ii];
MidExp exp = null;
if (sourceInfo.combinedExp != null)
{
// \todo: Validate other bits and bobs!!!
exp = sourceInfo.combinedExp;
}
else
{
throw new NotImplementedException();
}
entryPointSpan.Write("\tout {1} target{0} : SV_Target{0}", ii,
hlslContext.EmitType(exp.Type));
}
entryPointSpan.WriteLine(" )");
entryPointSpan.WriteLine("{");
hlslContext.EmitTempRecordCtor(
entryPointSpan,
fragmentElement,
GetAttribute(pixelElement, "__ps2om"));
var psCullFragmentAttr = GetAttribute(fragmentElement, "PS_CullFragment");
entryPointSpan.WriteLine("\tif( {0} ) discard;",
hlslContext.EmitAttribRef(psCullFragmentAttr, entryPointSpan));
for (int ii = 0; ii < renderTargetCount; ++ii)
{
var sourceInfo = _renderTargetSources[ii];
MidExp exp = null;
if (sourceInfo.combinedExp != null)
{
// \todo: Validate other bits and bobs!!!
exp = sourceInfo.combinedExp;
}
else
{
throw new NotImplementedException();
}
entryPointSpan.WriteLine("\ttarget{0} = {1};",
ii,
hlslContext.EmitExp(exp, entryPointSpan));
}
entryPointSpan.WriteLine("}");
hlslContext.EmitConstantBufferDecl();
//
EmitShaderSetup(
hlslContext,
"ps_5_0",
"Pixel",
"PS");
}
private AttributeInfo DecomposeAttr(
SourceRange range,
MidExp exp)
{
return(DecomposeAttrImpl(range, (dynamic)exp));
}
protected IEmitVal EmitExp(MidExp midExp, IEmitBlock block, EmitEnv env)
{
return(EmitContext.EmitExp(midExp, block, env));
}
public MidAttributeDecl CacheAttr(
MidExp exp,
MidType type )
{
MidAttributeDecl attrDecl = null;
if( _attrCache.TryGetValue( exp, out attrDecl ) )
return attrDecl;
if( exp is MidAttributeRef )
{
var attrRef = (MidAttributeRef) exp;
attrDecl = attrRef.Decl;
if( attrDecl.Element == this && attrDecl.Exp != null )
{
_attrCache[ exp ] = attrDecl;
return attrDecl;
}
}
attrDecl = new MidAttributeDecl(
_name.Factory.unique( "attr" ),
this,
type,
exp );
_attrCache[ exp ] = attrDecl;
AddAttribute( attrDecl );
return attrDecl;
}
protected IEmitVal EmitExp(MidExp midExp, IEmitBlock block, EmitEnv env)
{
return EmitContext.EmitExp(midExp, block, env);
}
private string EmitAttrLit(
MidExp exp )
{
return EmitAttrLitImpl((dynamic)exp);
}
public MidExp CleanupExp( MidExp exp )
{
return exp;
}
private int GetIntLit(MidExp exp)
{
if (exp is MidLit)
return ((MidLit<Int32>)exp).Value;
else if (exp is MidAttributeRef)
return GetIntLit(((MidAttributeRef)exp).Decl.Exp);
else
throw new NotImplementedException();
}
private bool MightHaveSideEffects(
MidExp exp )
{
bool result = false;
var transform = new MidTransform(
(e) =>
{
if (e is MidAssignExp)
result = true;
if (e is MidBreakExp)
result = true;
if (e is MidIfExp)
result = true;
if (e is MidForExp)
result = true;
if (e is MidBuiltinApp)
{
// \todo: Need a *huge* fix for this. Stdlib functions that might
// have side-effects need to be marked in some way to avoid this kind of thing... :(
var app = (MidBuiltinApp)e;
if (app.Decl.Name.ToString() == "Append")
result = true;
}
return e;
});
transform.Transform(exp);
return result;
}
private AttrInfo DecomposeAttr(
MidExp exp,
DecomposeAttrContext context)
{
return DecomposeAttrImpl((dynamic)exp, context);
}
private AttributeInfo DecomposeAttr(
SourceRange range,
MidExp exp)
{
return DecomposeAttrImpl(range, (dynamic)exp);
}
private void SetSource(
ref MidExp srcExp,
MidAttributeDecl attr)
{
if( srcExp != null )
{
if (srcExp is MidAttributeRef)
{
var srcAttr = ((MidAttributeRef)srcExp).Decl;
if (srcAttr != attr)
{
throw OperationTooComplexError(srcExp.Range);
}
}
else
{
throw OperationTooComplexError(srcExp.Range);
}
}
srcExp = new MidAttributeRef(attr.Range, attr, new LazyFactory());
}
private MidExp SimplifyExpImpl(MidExp exp, SimplifyEnv env)
{
return exp;
}
private MidExp SimplifyExp(MidExp exp, SimplifyEnv env)
{
if (exp == null)
return null;
var transform = new MidTransform(
null, // no pre-transform
(e) => SimplifyExpImpl((dynamic)e, env));
return transform.Transform(exp);
}
private AttributeInfo DecomposeAttrImpl(
SourceRange range,
MidExp exp)
{
throw OperationTooComplex(exp.Range);
}
