public static ShaderData CreatePureGLSL(byte[] byteCode, string filename, bool isVertexShader, List <ConstantBufferData> cbuffers, int sharedIndex, Dictionary <string, SamplerStateInfo> samplerStates, string shaderInfo, bool debug) { var dxshader = new ShaderData(); dxshader.SharedIndex = sharedIndex; dxshader.Bytecode = (byte[])byteCode.Clone(); // Use MojoShader to convert the HLSL bytecode to GLSL. string glsl = System.Text.Encoding.ASCII.GetString(byteCode); if (isVertexShader) { glsl = AddPosFixup(glsl); } Dictionary <string, MojoShader.MOJOSHADER_usage> usageMapping = new Dictionary <string, MojoShader.MOJOSHADER_usage> (); XmlDocument doc = new XmlDocument(); doc.LoadXml(shaderInfo); XmlElement shader = (XmlElement)doc.FirstChild; foreach (XmlElement attribute in shader.ChildNodes) { if (attribute.Name == "attribute") { usageMapping.Add(attribute.GetAttribute("name"), (MojoShader.MOJOSHADER_usage)Enum.Parse(typeof(MojoShader.MOJOSHADER_usage), "MOJOSHADER_USAGE_" + attribute.InnerText.ToUpper(), true)); } } Additional.GLSLShaderParser parser = new Additional.GLSLShaderParser(glsl, filename, isVertexShader, usageMapping); if (!parser.Parse()) { return(null); } dxshader.IsVertexShader = isVertexShader; dxshader._attributes = parser.Attributes.ToArray(); var symbols = parser.Symbols.ToArray(); //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 = parser.Samplers.ToArray(); 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(); //TODO: glslCode translator // TODO: This sort of sucks... why does MojoShader not produce // code valid for GLES out of the box? // GLES platforms do not like this. //glsl = glsl.Replace ("#version 110", ""); // Add the required precision specifiers for GLES. AddPrecisions(glsl, dxshader.IsVertexShader, debug); // Store the code for serialization. dxshader.ShaderCode = Encoding.ASCII.GetBytes(glsl); return(dxshader); }
private d3dx_state CreateShader(ShaderInfo shaderInfo, string shaderFilename, string shaderXML, bool isVertexShader, ContentProcessorContext context) { // Compile the shader. byte[] bytecode; if (shaderInfo.Profile == ShaderProfile.DirectX_11 || shaderInfo.Profile == ShaderProfile.OpenGL) { throw new NotImplementedException("HLSL not implemented here"); } else if (shaderInfo.Profile == ShaderProfile.PureGLSL) { bytecode = CompileGLSL(shaderInfo, shaderFilename, shaderXML, context); } else { throw new NotSupportedException("Unknown shader profile!"); } // First look to see if we already created this same shader. ShaderData shaderData = null; foreach (var shader in Shaders) { if (bytecode.SequenceEqual(shader.Bytecode)) { shaderData = shader; break; } } // Create a new shader. if (shaderData == null) { if (shaderInfo.Profile == ShaderProfile.DirectX_11) { throw new NotImplementedException("HLSL not implemented");//shaderData = ShaderData.CreateHLSL(bytecode, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.SamplerStates, shaderInfo.Debug); } else if (shaderInfo.Profile == ShaderProfile.PureGLSL) { shaderData = ShaderData.CreatePureGLSL(bytecode, shaderFilename, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.SamplerStates, shaderXML, shaderInfo.Debug); } else { throw new NotSupportedException("Unknown shader profile!"); } Shaders.Add(shaderData); } var state = new d3dx_state(); state.index = 0; state.type = STATE_TYPE.CONSTANT; state.operation = isVertexShader ? (uint)146 : (uint)147; state.parameter = new d3dx_parameter(); state.parameter.name = string.Empty; state.parameter.semantic = string.Empty; state.parameter.class_ = D3DXPARAMETER_CLASS.OBJECT; state.parameter.type = isVertexShader ? D3DXPARAMETER_TYPE.VERTEXSHADER : D3DXPARAMETER_TYPE.PIXELSHADER; state.parameter.rows = 0; state.parameter.columns = 0; state.parameter.data = shaderData.SharedIndex; return(state); }