GCC, Stringifizierung und Inline-GLSL?

Ich möchte GLSL-Shader-Strings inline mit Makro-Stringifizierung deklarieren:

#define STRINGIFY(A)  #A
const GLchar* vert = STRINGIFY(
#version 120n
attribute vec2 position;
void main()
{
    gl_Position = vec4( position, 0.0, 1.0 );
}
);

Dies wird mit VS2010 erstellt und ausgeführt, kann jedoch nicht kompiliert werden gcc mit:

error: invalid preprocessing directive #version

Gibt es eine Möglichkeit, eine solche Stringifizierung portabel zu verwenden?

Ich versuche, zeilenweise Anführungszeichen zu vermeiden:

const GLchar* vert = 
"#version 120n"
"attribute vec2 position;"
"void main()"
"{"
"    gl_Position = vec4( position, 0.0, 1.0 );"
"}"
;

…und/oder Zeilenfortsetzung:

const GLchar* vert = "
#version 120n                                 
attribute vec2 position;                       
void main()                                    
{                                              
    gl_Position = vec4( position, 0.0, 1.0 );  
}                                              
";

Können Sie C++11 verwenden? Wenn ja, könnten Sie verwenden rohe Zeichenfolgenliterale:

const GLchar* vert = R"END(
#version 120
attribute vec2 position;
void main()
{
    gl_Position = vec4( position, 0.0, 1.0 );
}
)END";

Es sind keine Escapezeichen oder explizite Zeilenumbrüche erforderlich. Diese Zeichenfolgen beginnen mit einem R (oder r). Sie benötigen ein Trennzeichen (ich habe END gewählt) zwischen dem Anführungszeichen und der ersten Klammer, um der Klammer zu entkommen, die Sie im Code-Snippet haben.

Leider ist das Vorhandensein von Präprozessordirektiven im Argument eines Makros nicht definiert, sodass Sie dies nicht direkt tun können. Aber solange keiner Ihrer Shader andere Präprozessordirektiven benötigt als #version, könntest du so etwas tun:

#define GLSL(version, shader)  "#version " #version "n" #shader

const GLchar* vert = GLSL(120,
    attribute vec2 position;
    void main()
    {
        gl_Position = vec4( position, 0.0, 1.0 );
    }
);

Um diesen Zweck zu erreichen, habe ich sed verwendet. Ich habe separate Dateien mit GLSL, die ich bearbeite (mit richtiger Syntaxhervorhebung), und gleichzeitig ist GLSL in C++ eingebettet. Nicht sehr plattformübergreifend, aber mit msys funktioniert es unter Windows.

Im C++-Code:

const GLchar* vert = 
#include "shader_processed.vert"
;

Im Makefile:

shader_processed.vert: shader.vert
    sed -f shader.sed shader.vert > shader_processed.vert

programm: shader_processed.vert main.cpp
    g++ ...

shader.sed

s|\|\\|g
s|"|\"|g
s|$|\n"|g
s|^|"|g

Das Problem liegt an gcc-Vorverarbeitungsmakros, die für GLSL gedacht sind. Die Verwendung von Standard-Stringify- und Escaping-Präprozessordirektiven mit neuen Zeilen im GLSL-Code hat für mich funktioniert.

#define STRINGIFY(A)  #A

const GLchar* vert = STRINGIFY(

n#version 120n
n#define MY_MACRO 999n

attribute vec2 position;
void main()
{
    gl_Position = vec4( position, 0.0, 1.0 );
}
);

Ein alternativer Ansatz: Binden Sie eine Header-Datei ein, aber mit einer .glsl Verlängerung.

Zum Beispiel habe ich eine Datei namens bar.h.glsl. Es legt meinen Vertex- und Fragment-Shader-Code als Rohliterale offen:

#pragma once

namespace bar {

static const char vertex[] = R"(#version 410 core


// ----- vertex shader start -----
layout( location = 0 ) in vec4 vPosition;

uniform float Time;
uniform float Width;

void main()
{
    float x = vPosition.x;
    float y = vPosition.y * Width;
    float yOffset = mix(sin(Time), sin(Time * 0.75), x * 0.5 + 0.5);
    gl_Position = vec4(x, y + yOffset, vPosition.z, vPosition.w);
}
// ------ vertex shader end ------


)";
static const char fragment[] = R"(#version 410 core


// ----- fragment shader start ----
out vec4 fragColor;

void main()
{
    fragColor = vec4(1.0, 1.0, 1.0, 1.0);
}
// ------ fragment shader end -----


)";

}

Dann füge ich in meine Quelle einfach die Datei ein:

#include "bar.h.glsl"

und greifen Sie wie folgt auf die glsl-Strings zu:

bool success = barShader.Compile( bar::vertex, bar::fragment );

Obwohl ich in meinen glsl-Dateien ein wenig C-Code übersehen muss, erhalte ich auf diese Weise das Beste aus der glsl-Syntaxhervorhebung, ohne die Datei dynamisch laden zu müssen.