XShaderCompiler

XShaderCompiler („Cross Shader Compiler“)

Merkmale

• Cross kompiliert HLSL-Shader-Code (Shader-Modell 4 und 5) in GLSL
• Einfache Integration in andere Projekte
• Übersetzung mit geringem Overhead (d. h. Vermeidung unnötiger Wrapper-Funktionen)
• Entfernung von totem Code
• Codereflexion
• Aussagekräftige Berichtsausgabe
• Kommentarbewahrung
• Geschrieben in C++11

Sprachbindungen

• C-Wrapper (ISO C99)
• C#-Wrapper

Lizenz

3-Klausel-BSD-Lizenz

Dokumentation

• Erste Schritte mit XShaderCompiler (PDF)
• XShaderCompiler-Referenzhandbuch (PDF)

Fortschritt

Version: 0.11 Alpha ( Nicht im Produktionscode verwenden! )

Weitere Informationen finden Sie in der Datei TODO.md.

Besonderheit	Fortschritt	Bemerkungen
Vertex-Shader	~80 %	Es sind noch wenige Sprachfunktionen übrig
Tessellation Control Shader	~20 %	InputPatch- und Patch-Constant-Function-Übersetzung in Bearbeitung
Tessellation Evaluation Shader	~20 %	OutputPatch-Übersetzung läuft
Geometrie-Shader	~60 %	Die Codegenerierung ist unvollständig
Fragment-Shader	~80 %	Es sind noch wenige Sprachfunktionen übrig
Compute-Shader	~80 %	Es sind noch wenige Sprachfunktionen übrig

Offline-Compiler

Die folgende Befehlszeile übersetzt die Datei „Example.hlsl“ mit dem Vertex-Shader-Eintrittspunkt „VS“ und dem Fragment-Shader-Eintrittspunkt „PS“:

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

Das Ergebnis sind zwei GLSL-Shader-Dateien: „Example.VS.vert“ und „Example.PS.frag“.

Bibliotheksnutzung (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 ;
}

Bibliotheksnutzung (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 ) ;
            }
        }
    }
} 

Echtzeit-Debugger

Ein Echtzeit-Debugger mit Benutzeroberfläche wird bereitgestellt. Obwohl dieser Debugger hauptsächlich für die Entwicklung des Compilers selbst verwendet wird, kann er auch für einen schnellen Übersetzungsüberblick verwendet werden, um zu sehen, wie Sprachkonstrukte übergreifend kompiliert werden.

Beispiel für den Echtzeit-Debugger (erfordert wxWidgets 3.1.0 oder höher):

Sprachunterschiede

Hier ist ein kurzer Überblick über die High-Level-Unterschiede zwischen HLSL und GLSL, die XShaderCompiler richtig übersetzen kann:

Besonderheit	HLSL	GLSL
Trennung von Texturen und Samplern	Ja	Nur für Vulkan
Strukturvererbung	Ja	NEIN
Verschachtelte Strukturen	Ja	NEIN
Anonyme Strukturen	Ja	NEIN
Strukturelementfunktionen	Ja	NEIN
Standardparameter	Ja	NEIN
Objektorientierte Intrinsics	Ja	NEIN
Mehrere Einstiegspunkte	Ja	NEIN
Geben Sie Aliasing ein	Ja	NEIN
L-Werte der Eingabesemantik	Ja	NEIN
Implizite Typkonvertierung	Umfangreich	Eingeschränkt