public static ShaderData CreateGLSL(byte[] byteCode, bool isVertexShader, List <ConstantBufferData> cbuffers, int sharedIndex, Dictionary <string, SamplerStateInfo> samplerStates, bool debug)
{
var dxshader = new ShaderData(isVertexShader, sharedIndex, byteCode);
// Use MojoShader to convert the HLSL bytecode to GLSL.
var parseDataPtr = MojoShader.NativeMethods.MOJOSHADER_parse(
"glsl",
byteCode,
byteCode.Length,
IntPtr.Zero,
0,
IntPtr.Zero,
0,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero);
var parseData = MarshalHelper.Unmarshal <MojoShader.MOJOSHADER_parseData> (parseDataPtr);
if (parseData.error_count > 0)
{
var errors = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_error> (
parseData.errors,
parseData.error_count
);
throw new Exception(errors [0].error);
}
// Conver the attributes.
//
// TODO: Could this be done using DX shader reflection?
//
{
var attributes = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_attribute> (
parseData.attributes, parseData.attribute_count);
dxshader._attributes = new Attribute[attributes.Length];
for (var i = 0; i < attributes.Length; i++)
{
dxshader._attributes [i].name = attributes [i].name;
dxshader._attributes [i].index = attributes [i].index;
dxshader._attributes [i].usage = EffectObject.ToXNAVertexElementUsage(attributes [i].usage);
}
}
var symbols = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_symbol> (
parseData.symbols, parseData.symbol_count);
//try to put the symbols in the order they are eventually packed into the uniform arrays
//this /should/ be done by pulling the info from mojoshader
Array.Sort(symbols, delegate(MojoShader.MOJOSHADER_symbol a, MojoShader.MOJOSHADER_symbol b) {
uint va = a.register_index;
if (a.info.elements == 1)
{
va += 1024; //hax. mojoshader puts array objects first
}
uint vb = b.register_index;
if (b.info.elements == 1)
{
vb += 1024;
}
return(va.CompareTo(vb));
}
); //(a, b) => ((int)(a.info.elements > 1))a.register_index.CompareTo(b.register_index));
// NOTE: It seems the latest versions of MojoShader only
// output vec4 register sets. We leave the code below, but
// the runtime has been optimized for this case.
// For whatever reason the register indexing is
// incorrect from MojoShader.
{
uint bool_index = 0;
uint float4_index = 0;
uint int4_index = 0;
for (var i = 0; i < symbols.Length; i++)
{
switch (symbols [i].register_set)
{
case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_BOOL:
symbols [i].register_index = bool_index;
bool_index += symbols [i].register_count;
break;
case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_FLOAT4:
symbols [i].register_index = float4_index;
float4_index += symbols[i].register_count;
break;
case MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_INT4:
symbols [i].register_index = int4_index;
int4_index += symbols [i].register_count;
break;
}
}
}
// Get the samplers.
var samplers = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_sampler> (
parseData.samplers, parseData.sampler_count);
dxshader._samplers = new Sampler[samplers.Length];
for (var i = 0; i < samplers.Length; i++)
{
// We need the original sampler name... look for that in the symbols.
var originalSamplerName =
symbols.First(e => e.register_set == MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_SAMPLER &&
e.register_index == samplers[i].index
).name;
var sampler = new Sampler
{
//sampler mapping to parameter is unknown atm
parameter = -1,
// GLSL needs the MojoShader mangled sampler name.
samplerName = samplers[i].name,
// By default use the original sampler name for the parameter name.
parameterName = originalSamplerName,
textureSlot = samplers[i].index,
samplerSlot = samplers[i].index,
type = samplers[i].type,
};
SamplerStateInfo state;
if (samplerStates.TryGetValue(originalSamplerName, out state))
{
sampler.state = state.State;
sampler.parameterName = state.TextureName ?? originalSamplerName;
}
// Store the sampler.
dxshader._samplers[i] = sampler;
}
// Gather all the parameters used by this shader.
var symbol_types = new [] {
new { name = dxshader.IsVertexShader ? "vs_uniforms_bool" : "ps_uniforms_bool", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_BOOL, },
new { name = dxshader.IsVertexShader ? "vs_uniforms_ivec4" : "ps_uniforms_ivec4", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_INT4, },
new { name = dxshader.IsVertexShader ? "vs_uniforms_vec4" : "ps_uniforms_vec4", set = MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_FLOAT4, },
};
var cbuffer_index = new List <int> ();
for (var i = 0; i < symbol_types.Length; i++)
{
var cbuffer = new ConstantBufferData(symbol_types [i].name,
symbol_types [i].set,
symbols);
if (cbuffer.Size == 0)
{
continue;
}
var match = cbuffers.FindIndex(e => e.SameAs(cbuffer));
if (match == -1)
{
cbuffer_index.Add(cbuffers.Count);
cbuffers.Add(cbuffer);
}
else
{
cbuffer_index.Add(match);
}
}
dxshader._cbuffers = cbuffer_index.ToArray();
var glslCode = parseData.output;
// TODO: This sort of sucks... why does MojoShader not produce
// code valid for GLES out of the box?
// GLES platforms do not like this.
glslCode = glslCode.Replace("#version 110", "");
// Add the required precision specifiers for GLES.
var floatPrecision = dxshader.IsVertexShader ? "precision highp float;\r\n" : "precision mediump float;\r\n";
glslCode = "#ifdef GL_ES\r\n" +
floatPrecision +
"precision mediump int;\r\n" +
"#endif\r\n" +
glslCode;
// Store the code for serialization.
dxshader.ShaderCode = Encoding.ASCII.GetBytes(glslCode);
return(dxshader);
}
private static EffectObject.d3dx_parameter GetParameterFromSymbol(MojoShader.MOJOSHADER_symbol symbol)
{
var param = new EffectObject.d3dx_parameter();
param.rows = symbol.info.rows;
param.columns = symbol.info.columns;
param.name = symbol.name ?? string.Empty;
param.semantic = string.Empty; // TODO: How do i do this with only MojoShader?
var registerSize = (symbol.register_set == MojoShader.MOJOSHADER_symbolRegisterSet.MOJOSHADER_SYMREGSET_BOOL ? 1 : 4) * 4;
var offset = (int)symbol.register_index * registerSize;
param.bufferOffset = offset;
switch (symbol.info.parameter_class)
{
case MojoShader.MOJOSHADER_symbolClass.MOJOSHADER_SYMCLASS_SCALAR:
param.class_ = EffectObject.D3DXPARAMETER_CLASS.SCALAR;
break;
case MojoShader.MOJOSHADER_symbolClass.MOJOSHADER_SYMCLASS_VECTOR:
param.class_ = EffectObject.D3DXPARAMETER_CLASS.VECTOR;
break;
case MojoShader.MOJOSHADER_symbolClass.MOJOSHADER_SYMCLASS_MATRIX_COLUMNS:
param.class_ = EffectObject.D3DXPARAMETER_CLASS.MATRIX_COLUMNS;
break;
default:
throw new Exception("Unsupported parameter class!");
}
switch (symbol.info.parameter_type)
{
case MojoShader.MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_BOOL:
param.type = EffectObject.D3DXPARAMETER_TYPE.BOOL;
break;
case MojoShader.MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_FLOAT:
param.type = EffectObject.D3DXPARAMETER_TYPE.FLOAT;
break;
case MojoShader.MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_INT:
param.type = EffectObject.D3DXPARAMETER_TYPE.INT;
break;
default:
throw new Exception("Unsupported parameter type!");
}
// HACK: We don't have real default parameters from mojoshader!
param.data = new byte[param.rows * param.columns * 4];
param.member_count = symbol.info.member_count;
param.element_count = symbol.info.elements > 1 ? symbol.info.elements : 0;
if (param.member_count > 0)
{
param.member_handles = new EffectObject.d3dx_parameter[param.member_count];
var members = MarshalHelper.UnmarshalArray <MojoShader.MOJOSHADER_symbol>(
symbol.info.members, (int)symbol.info.member_count);
for (var i = 0; i < param.member_count; i++)
{
var mparam = GetParameterFromSymbol(members[i]);
param.member_handles[i] = mparam;
}
}
else
{
param.member_handles = new EffectObject.d3dx_parameter[param.element_count];
for (var i = 0; i < param.element_count; i++)
{
var mparam = new EffectObject.d3dx_parameter();
mparam.name = string.Empty;
mparam.semantic = string.Empty;
mparam.type = param.type;
mparam.class_ = param.class_;
mparam.rows = param.rows;
mparam.columns = param.columns;
mparam.data = new byte[param.columns * param.rows * 4];
param.member_handles[i] = mparam;
}
}
return(param);
}