XShaderCompiler

XShaderCompiler ("Compilador Cross Shader")

Características

• Compilação cruzada do código de shader HLSL (Shader Model 4 e 5) em GLSL
• Simples de integrar em outros projetos
• Tradução de baixa sobrecarga (ou seja, evitar funções desnecessárias de wrapper)
• Remoção de código morto
• Reflexão de código
• Saída de relatório significativa
• Preservação de comentários
• Escrito em C++ 11

Ligações de linguagem

• Invólucro C (ISO C99)
• Invólucro C#

Licença

Licença BSD de 3 cláusulas

Documentação

• Introdução ao XShaderCompiler (PDF)
• Manual de referência do XShaderCompiler (PDF)

Progresso

Versão: 0.11 Alpha ( Não use em código de produção! )

Consulte o arquivo TODO.md para obter mais informações.

Recurso	Progresso	Observações
Sombreador de vértice	~80%	Ainda restam poucos recursos de idioma
Shader de controle de mosaico	~20%	Tradução de InputPatch e patch-constant-function em andamento
Shader de avaliação de mosaico	~20%	Tradução do OutputPatch em andamento
Sombreador de geometria	~60%	A geração do código está incompleta
Sombreador de Fragmento	~80%	Ainda restam poucos recursos de idioma
Sombreador de computação	~80%	Ainda restam poucos recursos de idioma

Compilador off-line

A linha de comando a seguir traduz o arquivo "Example.hlsl" com o ponto de entrada do sombreador de vértice "VS" e o ponto de entrada do sombreador de fragmento "PS":

 xsc -E VS -T vert Example.hlsl -E PS -T frag Example.hlsl

O resultado são dois arquivos de shader GLSL: "Example.VS.vert" e "Example.PS.frag".

Uso da biblioteca (C++)

# include < Xsc/Xsc.h >
# include < fstream >
# include < iostream >

int main ()
{
    // Input file stream (use std::stringstream for in-code shaders).
    auto inputStream = std::make_shared<std::ifstream>( " Example.hlsl " );

    // Output file stream (GLSL vertex shader)
    std::ofstream outputStream ( " Example.VS.vert " );

    // Fill the shader input descriptor structure
    Xsc::ShaderInput inputDesc;
    inputDesc. sourceCode     = inputStream;
    inputDesc. shaderVersion  = Xsc::InputShaderVersion::HLSL5;
    inputDesc. entryPoint     = " VS " ;
    inputDesc. shaderTarget   = Xsc::ShaderTarget::VertexShader;

    // Fill the shader output descriptor structure
    // Use outputDesc.options, outputDesc.formatting, and outputDesc.nameMangling for more settings
    Xsc::ShaderOutput outputDesc;
    outputDesc. sourceCode = &outputStream;

    // Optional output log (can also be a custom class)
    Xsc::StdLog log ;

    // Optional shader reflection data (for shader code feedback)
    Xsc::Reflection::ReflectionData reflectData;

    // Translate HLSL code into GLSL
    try
    {
        bool result = Xsc::CompileShader (inputDesc, outputDesc, & log , &reflectData);
    }
    catch ( const std:: exception & e)
    {
        std::cerr << e. what () << std::endl;
    }

    return 0 ;
}

Uso da biblioteca (C#)

 using System ;
using System . IO ;

namespace Example
{
    class Program
    {
        static void Main ( )
        {
            // Create instance of the XShaderCompiler
            var compiler = new XscCompiler ( ) ;

            // Fill the shader input descriptor structure
            var inputDesc = new XscCompiler . ShaderInput ( ) ;
            inputDesc . SourceCode     = File . ReadAllText ( "Example.hlsl" ) ;
            inputDesc . ShaderVersion  = XscCompiler . InputShaderVersion . HLSL5 ;
            inputDesc . EntryPoint     = "VS" ;
            inputDesc . Target         = XscCompiler . ShaderTarget . VertexShader ;

            // Fill the shader output descriptor structure
            // Use outputDesc.Options, outputDesc.Formatting, and outputDesc.MameMangling for more settings
            var outputDesc = new XscCompiler . ShaderOutput ( ) ;

            // Optional output log (can also be a custom class)
            var log = compiler . StandardLog ;

            // Optional shader reflection data (for shader code feedback)
            var reflectData = new XscCompiler . ReflectionData ( ) ;

            // Translate HLSL code into GLSL
            try
            {
                bool result = compiler . CompileShader ( inputDesc , outputDesc , log , reflectData ) ;

                if ( result )
                {
                    // Write output shader code
                    File . WriteAllText ( "Example.VS.vert" , outputDesc . SourceCode ) ;
                }
            }
            catch ( Exception e )
            {
                Console . WriteLine ( e ) ;
            }
        }
    }
} 

Depurador em tempo real

É fornecido um depurador em tempo real com UI. Embora este depurador seja usado principalmente para o desenvolvimento do próprio compilador, ele também pode ser usado para uma rápida visão geral da tradução, para ver como as construções da linguagem estão sendo compiladas cruzadamente.

Exemplo de depurador em tempo real (requer wxWidgets 3.1.0 ou posterior):

Diferenças de idioma

Aqui está um breve resumo das diferenças de alto nível entre HLSL e GLSL, que o XShaderCompiler é capaz de traduzir corretamente:

Recurso	HLSL	GLSL
Separação de Texturas e Samplers	Sim	Somente para Vulkan
Herança de Estrutura	Sim	Não
Estruturas aninhadas	Sim	Não
Estruturas anônimas	Sim	Não
Funções de membro da estrutura	Sim	Não
Parâmetros padrão	Sim	Não
Intrínsecos Orientados a Objetos	Sim	Não
Vários pontos de entrada	Sim	Não
Alias ​​de tipo	Sim	Não
Valores L da semântica de entrada	Sim	Não
Conversão de tipo implícita	Extenso	Restrito