XShaderCompiler

XShaderCompiler ("Compilateur Cross Shader")

Caractéristiques

• Cross compile le code du shader HLSL (Shader Model 4 et 5) en GLSL
• Simple à intégrer dans d’autres projets
• Faible surcharge de traduction (c'est-à-dire évitement des fonctions wrapper inutiles)
• Suppression du code mort
• Réflexion du code
• Sortie de rapport significative
• Préservation des commentaires
• Écrit en C++11

Liaisons linguistiques

• Enveloppeuse C (ISO C99)
• Encapsuleur C#

Licence

Licence BSD à 3 clauses

Documentation

• Premiers pas avec XShaderCompiler (PDF)
• Manuel de référence de XShaderCompiler (PDF)

Progrès

Version : 0.11 Alpha ( Ne pas utiliser dans le code de production ! )

Consultez le fichier TODO.md pour plus d’informations.

Fonctionnalité	Progrès	Remarques
Shader de sommet	~80%	Il reste encore peu de fonctionnalités linguistiques
Shader de contrôle de tessellation	~20%	Traduction d'InputPatch et de patch-constant-function en cours
Shader d'évaluation de tessellation	~20%	Traduction d'OutputPatch en cours
Shader de géométrie	~60%	La génération du code est incomplète
Shader de fragments	~80%	Il reste encore peu de fonctionnalités linguistiques
Calculer le shader	~80%	Il reste encore peu de fonctionnalités linguistiques

Compilateur hors ligne

La ligne de commande suivante traduit le fichier « Example.hlsl » avec le point d'entrée du vertex shader « VS » et le point d'entrée du fragment shader « PS » :

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

Le résultat est deux fichiers de shader GLSL : "Example.VS.vert" et "Example.PS.frag".

Utilisation de la bibliothèque (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 ;
}

Utilisation de la bibliothèque (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 ) ;
            }
        }
    }
} 

Débogueur en temps réel

Un débogueur en temps réel avec interface utilisateur est fourni. Bien que ce débogueur soit principalement utilisé pour le développement du compilateur lui-même, il peut également être utilisé pour un aperçu rapide de la traduction, afin de voir comment les constructions du langage sont compilées de manière croisée.

Exemple de débogueur en temps réel (nécessite wxWidgets 3.1.0 ou version ultérieure) :

Différences linguistiques

Voici un bref aperçu des différences de haut niveau entre HLSL et GLSL, que XShaderCompiler est capable de traduire correctement :

Fonctionnalité	HLSL	GLSL
Séparation des textures et des samplers	Oui	Uniquement pour Vulkan
Héritage de structures	Oui	Non
Structures imbriquées	Oui	Non
Structures anonymes	Oui	Non
Fonctions des membres de la structure	Oui	Non
Paramètres par défaut	Oui	Non
Intrinsèques orientés objet	Oui	Non
Points d'entrée multiples	Oui	Non
Alias ​​de type	Oui	Non
Valeurs L de la sémantique d'entrée	Oui	Non
Conversion de type implicite	Extensif	Limité