예제 #1
0
        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);
        }
예제 #2
0
        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);
        }