Introduction

There are many situations when DirectX shaders authored in HLSL need to be converted to GLSL. Typical examples include porting existing application to OpenGL and cross-platform development. HLSL and GLSL share a lot in common, but sometimes differ substantially. Maintaining two versions of shaders is time-consuming and error-prone, and is thus not an option for most of the applications. One typical solution to the problem is using intermediate representation that translates to both languages, but it does not work when existing shaders are written in HLSL. Authoring shaders in HLSL also allows using HLSL shader development tools.

There exist several converters, but they provide limited functionality. For instance, this and this projects only support D3D9-style shaders. This online translator only supports vertex and fragment shaders.

Diligent Engine uses state-of-the art shader sonverter that allows transforming HLSL source into GLSL. The converter supports HLSL 5.0 and all shader types (vertex, pixel, geometry, hull, domain, and compute). 

The converter can be downloaded from this page.

Conversion Details

Basics

The converter supports HLSL5.0, all shader types (vertex, geometry, pixel, domain, hull, and compute) as well as most of the language constructs. There are however few special requirements that must be met in order for the HLSL source to be successfully converted to GLSL:

The code snippet below gives examples of supported shader declarations:

struct VSInput
{
    // It is recommended (though not required) to assign 
    //  ATTRIBn semantics to inputs from IA
    in float3 f3PosWS : ATTRIB0;
    in float2 f2UV  : ATTRIB1;
    uint VertexID : SV_VertexID;
};

struct VSOutput
{
    float2 UV : TEX_COORDINATES;
    float3 Normal : NORMAL;
    float4 f4PosPS : SV_Position;
};

VSOutput VertexShader ( in VSInput VSIn,
                        in float3 f3UV  : ATTRIB2,
                        uint InstID : SV_InstanceID,
                        out float3 f3Tangent : TANGENT )
{
    VSOutput VSOut;
    // Body elided
    f3Tangent = ...
    return VSOut;
}

float4 PixelShader ( // Pixel shader inputs must be declared in exact same order 
                     // as outputs of the vertex shader
                     VSOutput PSIn,
                     in float3 f3Tangent : TaNgEnT // Semantics are case-insensitive
                     out float3 Color2 : SV_Target2 ) :  SV_Target
{
    // Body elided
}

Textures and samplers

The following rules are used to convert HLSL texture declaration into GLSL sampler:

Texture2D g_ShadowMap;
SamplerComparisonState g_ShadowMap_sampler;

Texture2D g_Tex2D;
SamplerState g_Tex2D_sampler;

Texture3D g_Tex3D;

↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓    ↓

sampler2DShadow g_ShadowMap;
sampler2D g_Tex2D;
sampler3D g_Tex3D;

Please visit this page for the full list of supported features.

Important notes/known issues

DO NOT pass structs to functions, use only built-in types!

Limitations

Converter does not perform macros expansion, so usage of preprocessor directives is limited to text block that do not need to be converted. The following are some usage examples that are not supported:

Macros can be used within function bodies:

VSOut VSTes(...)
{
#ifdef SOME_MACRO
    // OK
#else
    // OK
#endif
}

Standalone Converter

Standalone HLSL2GLSLConverter allows off-line conversion of shaders authored in HLSL to GLSL. The command line options for the app are given below:

Command line example:

HLSL2GLSLConverter -i ConverterTest.fx -d .\testshaders -d .\ -t vs -e TestVS -c -o .\testshaders\ConvertedShader.txt

By default, the converter includes auxiliary GLSL definitions into the converter source. This can be disabled with -noglsldef command line option, but the definitions file GLSLDefinitions.h is required for the shader file to be compiled and must be included manually.

When compiling GLSL shader, Diligent Engine adds the following lines on top of the converted GLSL source.

For desktop GL:

#version 430 core
#define DESKTOP_GL 1
layout(std140) uniform;

For GLES:

#version 310 es

#ifndef GL_ES
#  define GL_ES 1
#endif

precision highp float;
precision highp int;
//"precision highp uint;  // This line causes shader compilation error on NVidia!

precision highp sampler2D;
precision highp sampler3D;
precision highp samplerCube;
precision highp samplerCubeArray;
precision highp samplerCubeShadow;
precision highp samplerCubeArrayShadow;
precision highp sampler2DShadow;
precision highp sampler2DArray;
precision highp sampler2DArrayShadow;
precision highp sampler2DMS;       // ES3.1

precision highp isampler2D;
precision highp isampler3D;
precision highp isamplerCube;
precision highp isamplerCubeArray;
precision highp isampler2DArray;
precision highp isampler2DMS;      // ES3.1

precision highp usampler2D;
precision highp usampler3D;
precision highp usamplerCube;
precision highp usamplerCubeArray;
precision highp usampler2DArray;
precision highp usampler2DMS;      // ES3.1

precision highp image2D;
precision highp image3D;
precision highp imageCube;
precision highp image2DArray;

precision highp iimage2D;
precision highp iimage3D;
precision highp iimageCube;
precision highp iimage2DArray;

precision highp uimage2D;
precision highp uimage3D;
precision highp uimageCube;
precision highp uimage2DArray;

layout(std140) uniform;

Also on Android, the engine defines the following extension when compiling geometry shader:

#extension GL_EXT_geometry_shader : enable

and the following extension when compiling tessellation control (hull) or tessellation evaluation (domain) shader:

#extension GL_EXT_tessellation_shader : enable

Besides that, the engine also defines one of the following macros depending on the type of the shader being compiled: VERTEX_SHADER, FRAGMENT_SHADER, GEOMETRY_SHADER, TESS_CONTROL_SHADER, TESS_EVALUATION_SHADER, COMPUTE_SHADER. If converted source is not handled by Diligent Engine, one of the macros above must always be defined before including GLSLDefinitions.h.

Downloading Converter

Download HLSL2GLSLConverter.

The archive contains two versions of converter app built for win32 and win64 platforms. testshaders folder contains some shader examples and .bat files conaining commands to perform conversion.