static public ShaderInfo FromFile (string path, Options options, IEffectCompilerOutput output)
{
var effectSource = File.ReadAllText (path);
if (options.Profile == ShaderProfile.PureGLSL)
return PureGLSLFromString (effectSource, path, options, output);
return null;
//return FromString(effectSource, path, options, output);
}
public void Write(BinaryWriter writer, Options options)
{
writer.Write(IsVertexShader);
writer.Write(ShaderCode.Length);
writer.Write(ShaderCode);
writer.Write((byte)_samplers.Length);
foreach (var sampler in _samplers)
{
writer.Write((byte)sampler.type);
writer.Write((byte)sampler.textureSlot);
writer.Write((byte)sampler.samplerSlot);
if (sampler.state != null)
{
writer.Write(true);
writer.Write((byte)sampler.state.AddressU);
writer.Write((byte)sampler.state.AddressV);
writer.Write((byte)sampler.state.AddressW);
writer.Write(sampler.state.BorderColor.R);
writer.Write(sampler.state.BorderColor.G);
writer.Write(sampler.state.BorderColor.B);
writer.Write(sampler.state.BorderColor.A);
writer.Write((byte)sampler.state.Filter);
writer.Write(sampler.state.MaxAnisotropy);
writer.Write(sampler.state.MaxMipLevel);
writer.Write(sampler.state.MipMapLevelOfDetailBias);
}
else
writer.Write(false);
if (options.Profile == ShaderProfile.OpenGL)
writer.Write(sampler.samplerName);
writer.Write((byte)sampler.parameter);
}
writer.Write((byte)_cbuffers.Length);
foreach (var cb in _cbuffers)
writer.Write((byte)cb);
if (options.Profile != ShaderProfile.OpenGL)
return;
// The rest of this is for GL only!
writer.Write((byte)_attributes.Length);
foreach (var attrib in _attributes)
{
writer.Write(attrib.name);
writer.Write((byte)attrib.usage);
writer.Write((byte)attrib.index);
writer.Write((short)0); // Unused
}
}
public void Write(BinaryWriter writer, Options options)
{
if (options.Profile == ShaderProfile.OpenGL)
writer.Write(Name);
writer.Write((ushort)Size);
writer.Write((byte)ParameterIndex.Count);
for (var i = 0; i < ParameterIndex.Count; i++)
{
writer.Write((byte)ParameterIndex[i]);
writer.Write((ushort)ParameterOffset[i]);
}
}
static public ShaderInfo PureGLSLFromString (string effectSource, string filePath, Options options, IEffectCompilerOutput output)
{
ShaderInfo shaderInfo = new ShaderInfo ();
shaderInfo.FilePath = options.SourceFile;
XmlDocument doc = new XmlDocument ();
doc.LoadXml (effectSource);
XmlElement effectElement;
XmlNode current = doc.FirstChild;
while (current != null && current.NodeType != XmlNodeType.Element) {
current = current.NextSibling;
}
effectElement = (XmlElement)current;
shaderInfo.Techniques = new List<TechniqueInfo> ();
foreach (XmlElement technique in effectElement.ChildNodes.OfType<XmlElement>()) {
TechniqueInfo info = new TechniqueInfo ();
info.name = technique.GetAttribute ("name");
info.Passes = new List<PassInfo> ();
foreach (XmlElement pass in technique.ChildNodes.OfType<XmlElement>()) {
PassInfo pi = new PassInfo ();
pi.name = pass.GetAttribute ("name");
foreach (XmlElement sh in pass.ChildNodes) {
if (sh.Name == "Shader") {
if (sh.GetAttribute ("type") == "PixelShader") {
pi.psFileName = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(shaderInfo.FilePath),sh.GetAttribute ("filename"));
shaderInfo.Dependencies.Add (pi.psFileName);
pi.psShaderXML = sh.OuterXml;
} else if (sh.GetAttribute ("type") == "VertexShader") {
pi.vsFilename = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(shaderInfo.FilePath),sh.GetAttribute ("filename"));
shaderInfo.Dependencies.Add (pi.vsFilename);
pi.vsShaderXML = sh.OuterXml;
} else {
throw new PipelineException ("Unsupported Shader type detected");
}
} else if (sh.Name == "BlendState") {
pi.blendState = ParseBlendState (sh);
} else if (sh.Name == "DepthStencilState") {
pi.depthStencilState = ParseDepthStencilState (sh);
} else if (sh.Name == "RasterizerState") {
pi.rasterizerState = ParseRasterizerState (sh);
} else {
throw new PipelineException ("'" + sh.Name + "' element not recognized");
}
}
info.Passes.Add (pi);
}
shaderInfo.Techniques.Add (info);
}
shaderInfo.Profile = options.Profile;
shaderInfo.Debug = options.Debug;
shaderInfo.OutputFilePath = options.OutputFile;
return shaderInfo;
}
/// <summary>
/// Writes the effect for loading later.
/// </summary>
public void Write(BinaryWriter writer, Options options)
{
// Write a very simple header for identification and versioning.
writer.Write(Header.ToCharArray());
writer.Write((byte)Version);
// Write an simple identifier for DX11 vs GLSL
// so we can easily detect the correct shader type.
var profile = (byte)options.Profile;
if (options.Profile == ShaderProfile.PureGLSL)
{
options.Profile = ShaderProfile.OpenGL;
profile = (byte)ShaderProfile.OpenGL;
}
writer.Write(profile);
// Write the rest to a memory stream.
using (MemoryStream memStream = new MemoryStream())
using (BinaryWriter memWriter = new BinaryWriter(memStream))
{
// Write all the constant buffers.
memWriter.Write((byte)ConstantBuffers.Count);
foreach (var cbuffer in ConstantBuffers)
cbuffer.Write(memWriter, options);
// Write all the shaders.
memWriter.Write((byte)Shaders.Count);
foreach (var shader in Shaders)
shader.Write(memWriter, options);
// Write the parameters.
WriteParameters(memWriter, Parameters, Parameters.Length);
// Write the techniques.
memWriter.Write((byte)Techniques.Length);
foreach (var technique in Techniques)
{
memWriter.Write(technique.name);
WriteAnnotations(memWriter, technique.annotation_handles);
// Write the passes.
memWriter.Write((byte)technique.pass_count);
for (var p = 0; p < technique.pass_count; p++)
{
var pass = technique.pass_handles[p];
memWriter.Write(pass.name);
WriteAnnotations(memWriter, pass.annotation_handles);
// Write the index for the vertex and pixel shaders.
var vertexShader = GetShaderIndex(STATE_CLASS.VERTEXSHADER, pass.states);
var pixelShader = GetShaderIndex(STATE_CLASS.PIXELSHADER, pass.states);
memWriter.Write((byte)vertexShader);
memWriter.Write((byte)pixelShader);
// Write the state objects too!
if (pass.blendState != null)
{
memWriter.Write(true);
memWriter.Write((byte)pass.blendState.AlphaBlendFunction);
memWriter.Write((byte)pass.blendState.AlphaDestinationBlend);
memWriter.Write((byte)pass.blendState.AlphaSourceBlend);
memWriter.Write(pass.blendState.BlendFactor.R);
memWriter.Write(pass.blendState.BlendFactor.G);
memWriter.Write(pass.blendState.BlendFactor.B);
memWriter.Write(pass.blendState.BlendFactor.A);
memWriter.Write((byte)pass.blendState.ColorBlendFunction);
memWriter.Write((byte)pass.blendState.ColorDestinationBlend);
memWriter.Write((byte)pass.blendState.ColorSourceBlend);
memWriter.Write((byte)pass.blendState.ColorWriteChannels);
memWriter.Write((byte)pass.blendState.ColorWriteChannels1);
memWriter.Write((byte)pass.blendState.ColorWriteChannels2);
memWriter.Write((byte)pass.blendState.ColorWriteChannels3);
memWriter.Write(pass.blendState.MultiSampleMask);
}
else
memWriter.Write(false);
if (pass.depthStencilState != null)
{
memWriter.Write(true);
memWriter.Write((byte)pass.depthStencilState.CounterClockwiseStencilDepthBufferFail);
memWriter.Write((byte)pass.depthStencilState.CounterClockwiseStencilFail);
memWriter.Write((byte)pass.depthStencilState.CounterClockwiseStencilFunction);
memWriter.Write((byte)pass.depthStencilState.CounterClockwiseStencilPass);
memWriter.Write(pass.depthStencilState.DepthBufferEnable);
memWriter.Write((byte)pass.depthStencilState.DepthBufferFunction);
memWriter.Write(pass.depthStencilState.DepthBufferWriteEnable);
memWriter.Write(pass.depthStencilState.ReferenceStencil);
memWriter.Write((byte)pass.depthStencilState.StencilDepthBufferFail);
memWriter.Write(pass.depthStencilState.StencilEnable);
memWriter.Write((byte)pass.depthStencilState.StencilFail);
memWriter.Write((byte)pass.depthStencilState.StencilFunction);
memWriter.Write(pass.depthStencilState.StencilMask);
memWriter.Write((byte)pass.depthStencilState.StencilPass);
memWriter.Write(pass.depthStencilState.StencilWriteMask);
memWriter.Write(pass.depthStencilState.TwoSidedStencilMode);
}
else
memWriter.Write(false);
if (pass.rasterizerState != null)
{
memWriter.Write(true);
memWriter.Write((byte)pass.rasterizerState.CullMode);
memWriter.Write(pass.rasterizerState.DepthBias);
memWriter.Write((byte)pass.rasterizerState.FillMode);
memWriter.Write(pass.rasterizerState.MultiSampleAntiAlias);
memWriter.Write(pass.rasterizerState.ScissorTestEnable);
memWriter.Write(pass.rasterizerState.SlopeScaleDepthBias);
}
else
memWriter.Write(false);
}
}
// Calculate a hash code from memory stream
// and write it to the header.
var effectKey = Utilities.ComputeHash(memStream);
writer.Write((Int32)effectKey);
//write content from memory stream to final stream.
memStream.WriteTo(writer.BaseStream);
}
}