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));
}
public void SetTechnique(ShaderCollection shaderCollection, string techniqueKey)
{
this.shaderCollection = shaderCollection;
Content.Store(shaderCollection.Name, shaderCollection);
cShader = new ShaderComponent {
AssetName = shaderCollection.Name, Key = techniqueKey
};
vsFlags = shaderCollection[techniqueKey].Key.VertexShader;
}
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;
}
public static ModelOperation DetectModelRequirements(VertexShaderFlags flags)
{
switch (flags)
{
case vsBarycentric:
return(ModelOperation.CalculateBarycentricCoordinatesAndExcludeEdges);
case vsDefault:
default:
return(ModelOperation.None);
}
}
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));
}
private static VertexElement[] CreateElement(VertexShaderFlags flag)
{
switch (flag)
{
case VertexShaderFlags.Position:
return(new[] { VertexElement.Position(Format.R32G32B32_Float) });
case VertexShaderFlags.Normal:
return(new[] { VertexElement.Normal(Format.R32G32B32_Float) });
case VertexShaderFlags.TextureUV:
return(new[] { VertexElement.TextureCoordinate(Format.R32G32_Float) });
case VertexShaderFlags.TextureUVW:
return(new[] { VertexElement.TextureCoordinate(Format.R32G32B32_Float) });
case VertexShaderFlags.Color:
return(new[] { VertexElement.Color(Format.R32G32B32A32_Float) });
case VertexShaderFlags.Tangent:
return(new[] { VertexElement.Tangent(Format.R32G32B32A32_Float) });
case VertexShaderFlags.Barycentric:
return(new[] { new VertexElement("BARYCENTRIC", Format.R32G32B32_Float) });
case VertexShaderFlags.InstanceWorld:
return(new[]
{
new VertexElement("INSTANCEWORLD", 0, Format.R32G32B32A32_Float),
new VertexElement("INSTANCEWORLD", 1, Format.R32G32B32A32_Float),
new VertexElement("INSTANCEWORLD", 2, Format.R32G32B32A32_Float),
new VertexElement("INSTANCEWORLD", 3, Format.R32G32B32A32_Float),
});
default:
throw new ArgumentOutOfRangeException(string.Format("[{0}]: VertexShaderFlag not valid", flag));
}
}
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 VertexInputLayout GenerateVertexInputLayout()
{
VertexShaderFlags vsFlags = Key.VertexShader;
return(VertexInputLayout.New(0, vsFlags.GetUniqueFlags().Cast <VertexShaderFlags>().SelectMany(CreateElement).ToArray()));
}
public bool GetFeatureStatus(VertexShaderFlags feature)
{
return(Mapping.Key.Supports(feature));
}
public bool Supports(VertexShaderFlags feature)
{
return((VertexShader & feature) == feature);
}
public VertexShaderAttribute(VertexShaderFlags vsFeatures)
{
Features = vsFeatures;
}