XShaderCompiler

XSaderCompiler ("Compilador de sombreadores cruzados")

Características

• Cross compila el código de sombreador HLSL (Shader Model 4 y 5) en GLSL
• Fácil de integrar en otros proyectos.
• Traducción de bajo costo (es decir, evitar funciones de contenedor innecesarias)
• Eliminación de código muerto
• Reflexión de código
• Salida de informe significativa
• Preservación del comentario
• Escrito en C++11

Enlaces de idiomas

• Envoltura C (ISO C99)
• Envoltorio C#

Licencia

Licencia BSD de 3 cláusulas

Documentación

• Introducción a XShaderCompiler (PDF)
• Manual de referencia de XSaderCompiler (PDF)

Progreso

Versión: 0.11 Alpha ( ¡No usar en código de producción! )

Consulte el archivo TODO.md para obtener más información.

Característica	Progreso	Observaciones
Sombreador de vértices	~80%	Aún quedan pocas características del idioma.
Sombreador de control de teselación	~20%	Traducción de InputPatch y función constante de parche en progreso
Sombreador de evaluación de teselación	~20%	Traducción de OutputPatch en progreso
Sombreador de geometría	~60%	La generación de código está incompleta
Sombreador de fragmentos	~80%	Aún quedan pocas características del idioma.
Sombreador de cálculo	~80%	Aún quedan pocas características del idioma.

Compilador sin conexión

La siguiente línea de comando traduce el archivo "Example.hlsl" con el punto de entrada del sombreador de vértices "VS" y el punto de entrada del sombreador de fragmentos "PS":

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

El resultado son dos archivos de sombreado GLSL: "Example.VS.vert" y "Example.PS.frag".

Uso de la 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 de la 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 en tiempo real

Se proporciona un depurador en tiempo real con interfaz de usuario. Aunque este depurador se utiliza principalmente para el desarrollo del compilador en sí, también se puede utilizar para obtener una descripción general rápida de la traducción y ver cómo se compilan de forma cruzada las construcciones del lenguaje.

Ejemplo del depurador en tiempo real (requiere wxWidgets 3.1.0 o posterior):

Diferencias de idioma

Aquí hay un breve resumen de las diferencias de alto nivel entre HLSL y GLSL, que XShaderCompiler puede traducir correctamente:

Característica	HLSL	GLSL
Separación de texturas y samplers	Sí	Sólo para Vulkan
Herencia de estructura	Sí	No
Estructuras anidadas	Sí	No
Estructuras anónimas	Sí	No
Funciones de miembros de estructura	Sí	No
Parámetros predeterminados	Sí	No
Intrínsecos orientados a objetos	Sí	No
Múltiples puntos de entrada	Sí	No
Tipo de alias	Sí	No
Valores L de la semántica de entrada	Sí	No
Conversión de tipo implícita	Extenso	Restringido