public IEmitVal GetArrow(IEmitVal obj, IEmitField field)
{
return(new EmitValCPP(
Target,
string.Format("({0}->{1})", obj, field),
field.Type));
}
public void CallCOM(
IEmitVal obj,
string interfaceName,
string methodName,
params IEmitVal[] args)
{
_span.WriteLine("// CallCOM: {0}::{1}", interfaceName, methodName);
_span.Write(
"{0}->{1}(",
obj,
methodName);
bool first = true;
foreach (var a in args)
{
if (!first)
{
_span.Write(", ");
}
first = false;
_span.Write("{0}", a);
}
_span.WriteLine(");");
}
public IEmitVal EmitAttributeRef(
MidAttributeDecl decl,
IEmitBlock block,
EmitEnv env)
{
if (env.ContainsKey(decl))
{
return(env.Lookup(decl, block));
}
IEmitVal attributeVal = null;
if (decl.Exp != null)
{
attributeVal = block.Temp(
decl.Name.ToString(),
EmitExp(decl.Exp, block, env));
}
else
{
// \todo: This is a *huge* hack,
// since we use @Constant attributes
// to make various D3D constants visible... :(
attributeVal = block.BuiltinApp(
EmitType(decl.Type, env),
decl.Name.ToString(),
null);
}
env.Insert(decl, (b) => attributeVal);
return(attributeVal);
}
private IEmitVal Un(IEmitVal val)
{
if (val is LazyEmitVal)
{
return(((LazyEmitVal)val).Val);
}
return(val);
}
public void SetArrow(IEmitVal obj, IEmitField field, IEmitVal val)
{
_span.WriteLine(
"{0}->{1} = {2};",
obj,
field,
val);
}
public IEmitVal CastRawPointer(IEmitVal val, IEmitType type)
{
var ty = type ?? Target.Pointer(Target.GetBuiltinType("unsigned char"));
return(new EmitValCPP(
Target,
string.Format("(({0}) {1})", ty, val),
ty));
}
public IEmitVal GetBuiltinField(
IEmitVal obj,
string fieldName,
IEmitType fieldType)
{
return(new EmitValCPP(
Target,
string.Format("({0}.{1})", obj, fieldName),
fieldType));
}
public void StoreRaw(
IEmitVal basePointer,
UInt32 offset,
IEmitVal val)
{
_span.WriteLine(
"*(({0}) (({1}) + ({2}))) = {3};",
val.Type.Pointer(),
basePointer,
offset,
val);
}
public IEmitVal Temp(
string name,
IEmitVal val)
{
var type = (IEmitTypeCPP)val.Type;
var sym = GenSym(name);
_span.WriteLine(
"{0} = {1};",
type.Declare(sym),
val);
return(new EmitValCPP(Target, sym, type, ((EmitValCPP)val).IsOwnAddress));
}
public void StoreRaw(IEmitVal basePointer, uint offset, IEmitVal val)
{
Defer((b) => { b.StoreRaw(Un(basePointer), offset, Un(val)); });
}
public void SetArrow(IEmitVal obj, IEmitField field, IEmitVal val)
{
_span.WriteLine(
"{0}->{1} = {2};",
obj,
field,
val);
}
public IEmitVal GetArrow(IEmitVal obj, IEmitField field)
{
return new EmitValCPP(
Target,
string.Format("({0}->{1})", obj, field),
field.Type);
}
public void CallCOM(
IEmitVal obj,
string interfaceName,
string methodName,
params IEmitVal[] args)
{
_span.WriteLine("// CallCOM: {0}::{1}", interfaceName, methodName);
_span.Write(
"{0}->{1}(",
obj,
methodName);
bool first = true;
foreach (var a in args)
{
if (!first)
_span.Write(", ");
first = false;
_span.Write("{0}", a);
}
_span.WriteLine(");");
}
public IEmitVal CastRawPointer(IEmitVal val, IEmitType type)
{
return Defer((b) => b.CastRawPointer(Un(val), Un(type)));
}
public IEmitVal BuiltinApp(IEmitType type, string template, IEmitVal[] args)
{
return Defer((b) => b.BuiltinApp(Un(type), template, Un(args)));
}
private IEmitVal Un(IEmitVal val)
{
if (val is LazyEmitVal)
{
return ((LazyEmitVal)val).Val;
}
return val;
}
public IEmitVal GetArrow(IEmitVal obj, IEmitField field)
{
return(Defer((b) => b.GetArrow(Un(obj), field)));
}
public void CallCOM(IEmitVal obj, string interfaceName, string methodName, params IEmitVal[] args)
{
Defer((b) => { b.CallCOM(Un(obj), interfaceName, methodName, Un(args)); });
}
public IEmitVal GetBuiltinField(IEmitVal obj, string fieldName, IEmitType fieldType)
{
return(Defer((b) => b.GetBuiltinField(Un(obj), fieldName, Un(fieldType))));
}
public IEmitVal CastRawPointer(IEmitVal val, IEmitType type)
{
return(Defer((b) => b.CastRawPointer(Un(val), Un(type))));
}
public void StoreRaw(IEmitVal basePointer, uint offset, IEmitVal val)
{
Defer((b) => { b.StoreRaw(Un(basePointer), offset, Un(val)); });
}
public IEmitVal Temp(string name, IEmitVal val)
{
return Defer((b) => b.Temp(name, Un(val)));
}
public IEmitVal Temp(string name, IEmitVal val)
{
return(Defer((b) => b.Temp(name, Un(val))));
}
public IEmitVal Array(IEmitType elementType, IEmitVal[] elements)
{
return Defer((b) => b.Array(Un(elementType), Un(elements)));
}
public static IEmitVal CastRawPointer(
this IEmitBlock block,
IEmitVal val )
{
return block.CastRawPointer( val, null );
}
public void CallCOM(IEmitVal obj, string interfaceName, string methodName, params IEmitVal[] args)
{
Defer((b) => { b.CallCOM(Un(obj), interfaceName, methodName, Un(args)); });
}
public IEmitVal Temp(
string name,
IEmitVal val )
{
var type = (IEmitTypeCPP) val.Type;
var sym = GenSym(name);
_span.WriteLine(
"{0} = {1};",
type.Declare(sym),
val);
return new EmitValCPP(Target, sym, type, ((EmitValCPP) val).IsOwnAddress);
}
public IEmitVal BuiltinApp(
IEmitType type,
string template,
IEmitVal[] args)
{
var valString = args == null ? template :
string.Format(template, args);
if (type == null || (type == Target.VoidType))
{
_span.WriteLine("{0};", valString);
return null;
}
return new EmitValCPP(
Target,
valString,
type);
}
public IEmitVal Array(
IEmitType elementType,
IEmitVal[] elements)
{
var span = new Span();
span.WriteLine("{");
foreach (var e in elements)
{
span.WriteLine("\t{0},", e);
}
span.Write("}");
return new EmitValCPP(
Target,
span.ToString(),
Target.Array(elementType, elements.Length),
true);
}
public IEmitVal CastRawPointer(IEmitVal val, IEmitType type)
{
var ty = type ?? Target.Pointer( Target.GetBuiltinType( "unsigned char" ) );
return new EmitValCPP(
Target,
string.Format( "(({0}) {1})", ty, val ),
ty);
}
private void EmitPipeline(
IEmitModule emitModule,
MidPipelineDecl midPipeline)
{
var range = midPipeline.Range;
// Create the class to represent the pipeline
EmitClassFlags ifaceFlags = EmitClassFlags.None;
EmitClassFlags implFlags = EmitClassFlags.Hidden | EmitClassFlags.Implementation;
if (!midPipeline.IsPrimary)
{
ifaceFlags |= EmitClassFlags.Mixin;
// The "impl" class is treated as always primary
}
// this is a terrible horrible hack to detect a stdlib clas
// (which means we *don't* want it in the generated header...
var className = midPipeline.Name.ToString();
if (className.StartsWith("D3D11"))
{
ifaceFlags |= EmitClassFlags.Internal;
implFlags |= EmitClassFlags.Internal;
className = string.Format("spark::d3d11::{0}", className);
}
var baseFacets = (from f in midPipeline.Facets
where f != midPipeline.DirectFacet
select f).ToArray();
var primaryBaseFacet = (from f in baseFacets
where f.OriginalShaderClass.Decl.IsPrimary
select f).FirstOrDefault();
ShaderClassInfo primaryBaseInfo = null;
IEmitClass primaryBaseClass = null;
if (primaryBaseFacet != null)
{
primaryBaseInfo = _mapShaderClassToInfo[primaryBaseFacet.OriginalShaderClass.Decl];
primaryBaseClass = primaryBaseInfo.InterfaceClass;
}
var pipelineEnv = new EmitEnv(_moduleEnv);
IEmitClass ifaceClass = emitModule.CreateClass(
className,
midPipeline.IsPrimary ? primaryBaseClass : null,
ifaceFlags);
var info = new ShaderClassInfo
{
MidClassDecl = midPipeline,
InheritedFacets = new ShaderFacetInfo[midPipeline.Facets.Count() - 1],
};
info.InterfaceClass = ifaceClass;
_mapShaderClassToInfo[midPipeline] = info;
// Before we create fields declared in Spark, we
// first create the "hidden" fields that represent
// an instance at run-time:
if (primaryBaseInfo == null && midPipeline.IsPrimary)
{
// We need two fields here for any root-of-the-hierarchy
// class (which should actually be declared off in a header somewhere).
// The first is a "class info" pointer:
ifaceClass.AddPrivateField(
Target.GetOpaqueType("void*"),
"__classInfo");
// The second is the reference-count field:
ifaceClass.AddPrivateField(
Target.GetBuiltinType("UINT"),
"__referenceCount");
}
// Create fields to represent the various attributes
var constantElement = GetElement(midPipeline, "Constant");
var uniformElement = GetElement(midPipeline, "Uniform");
// Direct facet:
var directFacetDecl = midPipeline.DirectFacet;
var directFacetInfo = CreateDirectFacet(
directFacetDecl,
constantElement,
uniformElement,
ifaceClass,
pipelineEnv);
info.DirectFacet = directFacetInfo;
ifaceClass.WrapperWriteLineProtected(
"{0}* _StaticCastImpl( void* ) {{ return this; }}",
className);
// Base-class facet, if any
if (primaryBaseInfo != null)
{
if (midPipeline.IsPrimary)
{
AddPrimaryBaseFacet(
info,
primaryBaseInfo,
(b, shaderObj) => shaderObj);
}
else
{
var fieldName = "_Base_" + primaryBaseInfo.MidClassDecl.Name.ToString();
var fieldType = primaryBaseInfo.InterfaceClass.Pointer();
var facetField = ifaceClass.AddPrivateField(
fieldType,
fieldName);
info.DirectFacet.Mixins.Add(
new ShaderFacetMixinInfo(
primaryBaseInfo.MidClassDecl,
facetField));
AddPrimaryBaseFacet(
info,
primaryBaseInfo,
(b, shaderObj) =>
b.GetArrow(shaderObj, facetField));
foreach (var bf in primaryBaseInfo.AllFacets)
{
var baseFacet = bf; // avoid capture
AddForwardingAccessors(
info.InterfaceClass,
baseFacet);
var baseClass = _mapShaderClassToInfo[baseFacet.OriginalClass];
ifaceClass.WrapperWriteLineProtected(
"{0}* _StaticCastImpl( {0}* ) {{ return {1}; }}",
baseClass.InterfaceClass.GetName(),
fieldName);
}
}
}
// Inherited facets:
foreach (var f in midPipeline.Facets)
{
// Clearly don't want to embed a facet for ourself...
if (f == midPipeline.DirectFacet)
{
continue;
}
// Primary classes will already be covered by
// the inheritance chain...
if (f.OriginalShaderClass.Decl.IsPrimary)
{
continue;
}
// We may have inherited an interface
// to this facet through our base...
if (primaryBaseFacet != null)
{
if (primaryBaseFacet.OriginalShaderClass.Decl.Facets.Any(
(otherF) => otherF.OriginalShaderClass.Decl == f.OriginalShaderClass.Decl))
{
continue;
}
}
// Otherwise we need a public field
// to expose the facet:
var facetClassDecl = f.OriginalShaderClass.Decl;
var facetClassInfo = _mapShaderClassToInfo[facetClassDecl];
// \todo: get pointer type... :(
var fieldType = facetClassInfo.InterfaceClass.Pointer();
var fieldName = string.Format(
"_Mixin_{0}",
f.OriginalShaderClass.Decl.Name.ToString());
var field = ifaceClass.AddPrivateField(fieldType, fieldName);
info.DirectFacet.Mixins.Add(
new ShaderFacetMixinInfo(
facetClassDecl,
field));
ifaceClass.WrapperWriteLineProtected(
"{0} _StaticCastImpl( {0} ) {{ return {1}; }}",
fieldType.ToString(),
fieldName);
AddBaseFacet(
info,
facetClassInfo.DirectFacet,
(b, shaderObj) => b.GetArrow(shaderObj, field));
AddForwardingAccessors(
info.InterfaceClass,
facetClassInfo.DirectFacet);
}
/*
*
*
*
* foreach (var a in constantElement.Attributes)
* {
* var attr = a; // Avoid capture.
*
* if (attr.Exp == null) continue;
*
* pipelineEnv.Insert(attr,
* (b) => EmitExp(attr.Exp, b, pipelineEnv));
* }
* foreach (var a in uniformElement.Attributes)
* {
* var attr = a; // Avoid capture.
*
* if (attr.Exp != null) continue;
*
* var attrType = EmitType(attr.Type, pipelineEnv);
* var attrName = attr.Name.ToString();
*
* var attrField = emitClass.AddPublicField(attrType, attrName);
*
* pipelineEnv.Insert(attr,
* (b) => b.GetArrow(
* b.Method.ThisParameter,
* attrField));
* }
*/
var sharedHLSL = new HLSL.SharedContextHLSL(Identifiers, Diagnostics);
var emitPass = new PassEmitContext()
{
EmitContext = this,
MidPass = midPipeline,
SharedHLSL = sharedHLSL,
EmitClass = ifaceClass,
ShaderClassEnv = pipelineEnv,
ShaderClassInfo = info,
};
// Now emit stage-specific code.
EmitStageInterface <D3D11VertexShader>(emitPass);
EmitStageInterface <D3D11HullShader>(emitPass);
EmitStageInterface <D3D11DomainShader>(emitPass);
EmitStageInterface <D3D11GeometryShader>(emitPass);
EmitStageInterface <D3D11PixelShader>(emitPass);
// IA last since it generates the call to Draw*()
EmitStageInterface <D3D11InputAssembler>(emitPass);
// Do this *after* emitting the per-stage interface,
// so that stages of the pipeline can bind attributes too.
foreach (var f in info.AllFacets)
{
foreach (var a in f.Attributes)
{
if (a == null)
{
continue;
}
var attr = a.AttributeDecl;
var accessor = a.Accessor;
pipelineEnv.Insert(
attr,
(b) => accessor(b, b.Method.ThisParameter));
}
}
ifaceClass.WrapperWriteLine("");
ifaceClass.WrapperWriteLine(
"// Statically cast shader to base/mixin class");
ifaceClass.WrapperWriteLine(
"template<typename TBase>");
ifaceClass.WrapperWriteLine(
"TBase* StaticCast() { return _StaticCastImpl(static_cast<TBase*>(nullptr)); }");
ifaceClass.WrapperWriteLine("");
ifaceClass.WrapperWriteLine(
"// Spark implementation details follow. Do not depend on these:");
ifaceClass.WrapperWriteLine("//");
// Janky RTTI-like system: use the name of the class
ifaceClass.WrapperWriteLine(
"static const char* StaticGetShaderClassName() {{ return \"{0}\"; }}",
className);
ifaceClass.Seal();
if (midPipeline.IsAbstract)
{
return;
}
var implBase = ifaceClass;
if (!midPipeline.IsPrimary)
{
implBase = primaryBaseClass;
if (implBase == null)
{
throw new NotImplementedException();
}
}
var implClass = emitModule.CreateClass(
className,
implBase,
implFlags);
ifaceClass.WrapperWriteLine(
"static const spark::ShaderClassDesc* GetShaderClassDesc();");
//
// The impl class needs a field to hold each of its mixin bases...
Dictionary <MidPipelineDecl, Func <IEmitBlock, IEmitVal> > getFacetPointerForBase = new Dictionary <MidPipelineDecl, Func <IEmitBlock, IEmitVal> >();
var facetInfoData = new List <IEmitVal>();
var facetInfoCount = 0;
foreach (var f in midPipeline.Facets)
{
// Clearly don't want to embed a facet for ourself...
var facetClassDecl = f.OriginalShaderClass.Decl;
if (facetClassDecl.IsPrimary)
{
// Primary classes will already be covered by
// the inheritance chain...
getFacetPointerForBase[facetClassDecl] = (b) => b.Method.ThisParameter;
facetInfoData.Add(emitModule.LiteralString(_mapShaderClassToInfo[facetClassDecl].InterfaceClass.GetName()));
facetInfoData.Add(Target.LiteralU32(0));
facetInfoCount++;
}
}
UInt32 facetOffset = ifaceClass.Size;
foreach (var f in midPipeline.Facets)
{
// Clearly don't want to embed a facet for ourself...
var facetClassDecl = f.OriginalShaderClass.Decl;
if (!facetClassDecl.IsPrimary)
{
// Mixin classes will be reflected as fields.
var facetClassInfo = _mapShaderClassToInfo[facetClassDecl];
var fieldType = facetClassInfo.InterfaceClass;
var fieldName = string.Format(
"_MixinImpl_{0}",
f.OriginalShaderClass.Decl.Name.ToString());
var field = implClass.AddPrivateField(fieldType, fieldName);
getFacetPointerForBase[facetClassDecl] = (b) => b.GetArrow(b.Method.ThisParameter, field).GetAddress();
facetInfoData.Add(emitModule.LiteralString(_mapShaderClassToInfo[facetClassDecl].InterfaceClass.GetName()));
facetInfoData.Add(Target.LiteralU32(facetOffset));
facetInfoCount++;
facetOffset += fieldType.Size;
}
}
var facetInfoVal = emitModule.EmitGlobalStruct(
null,
facetInfoData.ToArray()).GetAddress();
//
var deviceType = Target.GetOpaqueType("ID3D11Device*");
var contextType = Target.GetOpaqueType("ID3D11DeviceContext*");
// Create constructor
var ctor = implClass.CreateCtor();
var ctorDevice = ctor.AddParameter(
deviceType,
"device");
var facetInitBlock = ctor.EntryBlock.InsertBlock();
var cbInit = ctor.EntryBlock.InsertBlock();
// First things first: wire up all the various facets to
// the appropriate pointers:
Dictionary <MidPipelineDecl, IEmitVal> initFacetPointers = new Dictionary <MidPipelineDecl, IEmitVal>();
foreach (var p in getFacetPointerForBase)
{
var facet = p.Key;
var accessor = p.Value;
var val = accessor(facetInitBlock);
initFacetPointers[facet] = val;
}
foreach (var f in info.AllFacets)
{
var facetPointer = initFacetPointers[f.OriginalClass];
foreach (var m in f.Mixins)
{
var mixinPointer = initFacetPointers[m.OriginalClass];
facetInitBlock.SetArrow(
facetPointer,
m.MixinField,
facetInitBlock.CastRawPointer(
mixinPointer,
m.MixinField.Type));
}
}
// Create destructor
var dtor = implClass.CreateDtor();
var cbFinit = dtor.EntryBlock.InsertBlock();
// Create Submit() method
var submit = implClass.CreateMethod(
Target.VoidType,
"Submit");
var submitDevice = submit.AddParameter(
deviceType,
"device");
var submitContext = submit.AddParameter(
contextType,
"context");
var submitEnv = new EmitEnv(pipelineEnv);
var cbSubmit = submit.EntryBlock.InsertBlock();
var cbPointerType = Target.GetOpaqueType("ID3D11Buffer*");
var cbField = implClass.AddPrivateField(
cbPointerType,
"_cb");
emitPass = new PassEmitContext()
{
EmitContext = this,
MidPass = midPipeline,
SharedHLSL = sharedHLSL,
InitBlock = ctor.EntryBlock,
ExecBlock = submit.EntryBlock,
DtorBlock = dtor.EntryBlock,
EmitClass = implClass,
CtorDevice = ctorDevice,
SubmitContext = submitContext,
CtorThis = ctor.ThisParameter,
SubmitThis = submit.ThisParameter,
DtorThis = dtor.ThisParameter,
CBField = cbField,
SubmitEnv = submitEnv,
};
// Now emit stage-specific code.
var iaStage = new D3D11InputAssembler()
{
EmitPass = emitPass, Range = range
};
var vsStage = new D3D11VertexShader()
{
EmitPass = emitPass, Range = range
};
var hsStage = new D3D11HullShader()
{
EmitPass = emitPass, Range = range
};
var dsStage = new D3D11DomainShader()
{
EmitPass = emitPass, Range = range
};
var gsStage = new D3D11GeometryShader()
{
EmitPass = emitPass, Range = range
};
var psStage = new D3D11PixelShader()
{
EmitPass = emitPass, Range = range
};
vsStage.EmitImplSetup();
iaStage.EmitImplSetup(); // IA after VS for bytecode dependency
hsStage.EmitImplSetup();
dsStage.EmitImplSetup();
gsStage.EmitImplSetup();
psStage.EmitImplSetup();
psStage.EmitImplBindOM(); // OM first
iaStage.EmitImplBind(); // IA as early as possible
vsStage.EmitImplBind();
hsStage.EmitImplBind();
dsStage.EmitImplBind();
gsStage.EmitImplBind();
psStage.EmitImplBind();
iaStage.EmitImplDraw();
// Generate code to fill out CB after all the
// stage-specific shader stuff, since these are
// what compute the required @Uniform values.
var block = cbInit;
var cbDescVal = block.Temp(
"cbDesc",
block.Struct(
"D3D11_BUFFER_DESC",
block.LiteralU32((UInt32)sharedHLSL.ConstantBufferSize),
block.Enum32("D3D11_USAGE", "D3D11_USAGE_DYNAMIC", D3D11Stage.D3D11_USAGE.D3D11_USAGE_DYNAMIC),
block.LiteralU32((UInt32)D3D11Stage.D3D11_BIND_FLAG.D3D11_BIND_CONSTANT_BUFFER),
block.LiteralU32((UInt32)D3D11Stage.D3D11_CPU_ACCESS_FLAG.D3D11_CPU_ACCESS_WRITE),
block.LiteralU32(0),
block.LiteralU32(0)));
block.SetArrow(
ctor.ThisParameter,
cbField,
cbPointerType.Null());
block.CallCOM(
ctorDevice,
"ID3D11Device",
"CreateBuffer",
cbDescVal.GetAddress(),
Target.GetBuiltinType("D3D11_SUBRESOURCE_DATA").Pointer().Null(),
block.GetArrow(ctor.ThisParameter, cbField).GetAddress());
block = cbSubmit;
var mappedType = Target.GetBuiltinType("D3D11_MAPPED_SUBRESOURCE");
var cbMappedVal = block.Local("_cbMapped", mappedType);
block.CallCOM(
submitContext,
"ID3D11DeviceContext",
"Map",
block.GetArrow(submit.ThisParameter, cbField),
block.LiteralU32(0),
block.Enum32("D3D11_MAP", "D3D11_MAP_WRITE_DISCARD", D3D11Stage.D3D11_MAP.D3D11_MAP_WRITE_DISCARD),
block.LiteralU32(0),
cbMappedVal.GetAddress());
IEmitVal mappedData = block.Temp(
"cbMappedData",
block.CastRawPointer(
block.GetBuiltinField(cbMappedVal, "pData", Target.GetOpaqueType("void*"))));
foreach (var u in sharedHLSL.Uniforms)
{
var val = EmitExp(u.Val, block, pipelineEnv);
block.StoreRaw(
mappedData,
(UInt32)u.ByteOffset,
val);
}
block.CallCOM(
submitContext,
"ID3D11DeviceContext",
"Unmap",
block.GetArrow(submit.ThisParameter, cbField),
block.LiteralU32(0));
cbFinit.CallCOM(
cbFinit.GetArrow(dtor.ThisParameter, cbField),
"ID3D11Buffer",
"Release");
// Now generate calls to bind the depth-stencil and rasterizer states
var rsStateAttr = FindAttribute(midPipeline, "Uniform", "RS_State").First();
var rsStateVal = EmitAttributeRef(
rsStateAttr,
block,
pipelineEnv);
block.CallCOM(
submitContext,
"ID3D11DeviceContext",
"RSSetState",
rsStateVal);
var omDepthStencilStateAttr = FindAttribute(midPipeline, "Uniform", "OM_DepthStencilState").First();
var omDepthStencilStateVal = EmitAttributeRef(
omDepthStencilStateAttr,
block,
pipelineEnv);
var omStencilRefAttr = FindAttribute(midPipeline, "Uniform", "OM_StencilRef").First();
var omStencilRefVal = EmitAttributeRef(
omStencilRefAttr,
block,
pipelineEnv);
block.CallCOM(
submitContext,
"ID3D11DeviceContext",
"OMSetDepthStencilState",
omDepthStencilStateVal,
omStencilRefVal);
implClass.Seal();
// Now we need to constrct the class-info
// structure, that will be used as a kind of
// virtual function table at runtime.
var classInfoVal = emitModule.EmitGlobalStruct(
className,
new IEmitVal[] {
Target.LiteralU32(implClass.Size),
Target.LiteralU32((UInt32)facetInfoCount),
facetInfoVal,
emitModule.GetMethodPointer(ctor),
emitModule.GetMethodPointer(dtor),
emitModule.GetMethodPointer(submit),
});
if (emitModule is Emit.CPlusPlus.EmitModuleCPP)
{
var moduleCPP = (Emit.CPlusPlus.EmitModuleCPP)emitModule;
moduleCPP.SourceSpan.WriteLine(
"const spark::ShaderClassDesc* {0}::GetShaderClassDesc() {{ return reinterpret_cast<const spark::ShaderClassDesc*>(&({1})); }}",
ifaceClass,
classInfoVal);
}
}
public IEmitVal GetBuiltinField(
IEmitVal obj,
string fieldName,
IEmitType fieldType)
{
return new EmitValCPP(
Target,
string.Format("({0}.{1})", obj, fieldName),
fieldType);
}
public void SetArrow(IEmitVal obj, IEmitField field, IEmitVal val)
{
Defer((b) => { b.SetArrow(Un(obj), field, Un(val)); });
}
public void StoreRaw(
IEmitVal basePointer,
UInt32 offset,
IEmitVal val)
{
_span.WriteLine(
"*(({0}) (({1}) + ({2}))) = {3};",
val.Type.Pointer(),
basePointer,
offset,
val);
}
public void SetArrow(IEmitVal obj, IEmitField field, IEmitVal val)
{
Defer((b) => { b.SetArrow(Un(obj), field, Un(val)); });
}
public IEmitVal EmitGlobalStruct(
string name,
IEmitVal[] members )
{
var span = new Span();
name = string.Format(
"_spark_global_{0}{1}",
name ?? "",
_globalCounter++ );
span.WriteLine( "struct {" );
var typeSpan = span.IndentSpan();
for( int ii = 0; ii < members.Length; ++ii )
{
var memberType = (EmitTypeCPP) members[ii].Type;
typeSpan.WriteLine( "{0};", memberType.Declare( string.Format( "_m{0}", ii ) ) );
}
span.WriteLine( "}} {0} = {{", name);
for( int ii = 0; ii < members.Length; ++ii )
{
if( ii != 0 )
span.WriteLine( "," );
span.Write( members[ ii ].ToString() );
}
span.WriteLine( " };" );
_sourceSpan.Add( span );
return new EmitValCPP(
Target,
name,
Target.GetOpaqueType( "void" ) );
}
public IEmitVal GetArrow(IEmitVal obj, IEmitField field)
{
return Defer((b) => b.GetArrow(Un(obj), field));
}
public static IEmitVal CastRawPointer(
this IEmitBlock block,
IEmitVal val)
{
return(block.CastRawPointer(val, null));
}
public IEmitVal GetBuiltinField(IEmitVal obj, string fieldName, IEmitType fieldType)
{
return Defer((b) => b.GetBuiltinField(Un(obj), fieldName, Un(fieldType)));
}
