public static TechniqueKey GenerateKeyPart(Shader shader)
{
VertexShaderFlags vsFlags = VertexShaderFlags.None;
PixelShaderFlags psFlags = PixelShaderFlags.None;
ShaderModel model = FromFeatureLevel(shader.FeatureLevel);
foreach (var property in shader.Result.DescendantNodes
.Select(node => node.GetType()
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.PropertyType == typeof(INode))).SelectMany(properties => properties))
{
switch (shader.Type)
{
case ShaderType.Vertex:
vsFlags = property.GetCustomAttributes(true)
.OfType <VertexShaderAttribute>()
.Aggregate(vsFlags, (current, vsAttribute) => current | vsAttribute.Features);
break;
case ShaderType.Pixel:
psFlags = property.GetCustomAttributes(true).OfType <PixelShaderAttribute>()
.Aggregate(psFlags, (current, psAttribute) => current | psAttribute.Features);
break;
}
}
return(new TechniqueKey(vsFlags, psFlags, sm: model));
}
private static void Render(ISrvBindable depthRead, MyBucketBatches bucketBatches, bool oit)
{
if (!MyRender11.DebugOverrides.BillboardsDynamic && !MyRender11.DebugOverrides.BillboardsStatic)
{
return;
}
if (m_batches.Count == 0)
{
return;
}
MyRender11.GetRenderProfiler().StartProfilingBlock("Draw");
RC.PixelShader.SetSrv(1, depthRead);
BindResourcesCommon();
PixelShaderFlags basePsFlags = (MyRender11.Settings.DisplayTransparencyHeatMap ? PixelShaderFlags.DEBUG_UNIFORM_ACCUM : 0) |
((MyRender11.DebugOverrides.OIT && oit) ? PixelShaderFlags.OIT : 0) |
(depthRead != null ? PixelShaderFlags.SOFT_PARTICLE : 0);
for (int i = bucketBatches.StartIndex; i < bucketBatches.StartIndex + bucketBatches.Count; i++)
{
var ps = m_psBundle[(int)(basePsFlags |
(m_batches[i].Lit ? PixelShaderFlags.LIT_PARTICLE : 0) |
(m_batches[i].AlphaCutout ? PixelShaderFlags.ALPHA_CUTOUT : 0))];
RC.VertexShader.Set(m_batches[i].Lit ? m_vsLit : m_vs);
RC.PixelShader.Set(ps);
ISrvBindable texture = m_batches[i].Texture;
RC.PixelShader.SetSrv(0, texture);
if (!MyStereoRender.Enable)
{
RC.DrawIndexed(m_batches[i].Num * 6, m_batches[i].Offset * 6, 0);
}
else
{
MyStereoRender.DrawIndexedBillboards(RC, m_batches[i].Num * 6, m_batches[i].Offset * 6, 0);
}
IBorrowedRtvTexture borrowedTexture = texture as IBorrowedRtvTexture;
if (borrowedTexture != null)
{
borrowedTexture.Release();
}
MyStatsUpdater.Passes.DrawBillboards++;
}
m_stats.Billboards += m_billboardCountSafe;
RC.SetRasterizerState(null);
MyRender11.GatherPassStats(1298737, "Billboards", m_stats);
MyRender11.GetRenderProfiler().EndProfilingBlock();
}
public TechniqueKey(VertexShaderFlags vs = VertexShaderFlags.None, PixelShaderFlags ps = PixelShaderFlags.None, ShaderModel sm = ShaderModel.SM_4_0_Level_9_1,
PreferredRasterizerState rasterizerState = PreferredRasterizerState.CullBack, PreferredBlendState blendState = PreferredBlendState.Opaque, PreferredDepthStencilState depthStencilState = PreferredDepthStencilState.Enabled)
: this()
{
VertexShader = vs;
PixelShader = ps;
ShaderModel = sm;
RasterizerState = rasterizerState;
BlendState = blendState;
DepthStencilState = depthStencilState;
}
internal static TechniqueKey GenerateKeyPartRequirements(Shader shader)
{
var vsAttributes = shader.GetType().GetCustomAttributes <VertexShaderAttribute>();
var psAttributes = shader.GetType().GetCustomAttributes <PixelShaderAttribute>();
VertexShaderFlags vsFlags = VertexShaderFlags.None;
PixelShaderFlags psFlags = PixelShaderFlags.None;
ShaderModel model = FromFeatureLevel(shader.FeatureLevel);
foreach (var vsAttribute in vsAttributes)
{
vsFlags |= vsAttribute.Features;
}
foreach (var psAttribute in psAttributes)
{
psFlags |= psAttribute.Features;
}
return(new TechniqueKey(vsFlags, psFlags, sm: model));
}
static TechniqueKey GenerateKey(IEnumerable <ShaderAttributeViewModel> data, ShaderModel selectedShaderModel,
PreferredRasterizerState rasterizerState, PreferredBlendState blendState, PreferredDepthStencilState depthStencilState)
{
Contract.Requires <ArgumentNullException>(data != null);
VertexShaderFlags vsFlags = Graphics.Effects.VertexShaderFlags.None;
PixelShaderFlags psFlags = Graphics.Effects.PixelShaderFlags.None;
foreach (var flagVM in data)
{
switch (flagVM.Type)
{
case ShaderType.Vertex:
vsFlags |= (VertexShaderFlags)Enum.Parse(typeof(VertexShaderFlags), flagVM.Name);
break;
case ShaderType.Pixel:
psFlags |= (PixelShaderFlags)Enum.Parse(typeof(PixelShaderFlags), flagVM.Name);
break;
}
}
return(new TechniqueKey(vsFlags, psFlags, selectedShaderModel, rasterizerState, blendState, depthStencilState));
}
public bool GetFeatureStatus(PixelShaderFlags feature)
{
return(Mapping.Key.Supports(feature));
}
public bool Supports(PixelShaderFlags feature)
{
return((PixelShader & feature) == feature);
}
