GCC, stringification, and inline GLSL?

Question

I'd like to declare GLSL shader strings inline using macro stringification:

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

This builds and runs fine using VS2010 but fails to compile on gcc with:

error: invalid preprocessing directive #version

Is there a way to use stringification like this in a portable manner?

I'm trying to avoid per-line quotes:

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

...and/or line continuation:

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

Does this answer your question? Stringification - how does it work? — user20972572
– user20972572, Commented Mar 5, 2024 at 14:38

Tommy · Accepted Answer · 2017-03-07 20:41:42Z

27

Can you use C++11? If so you could use raw string literals:

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

No need for escapes or explicit newlines. These strings start with an R (or r). You need a delimiter (I chose END) between the quote and the first parenthesis to escape parenthesis which you have in the code snippet.

edited Mar 7, 2017 at 20:41

Tommy

101k12 gold badges187 silver badges205 bronze badges

answered Dec 14, 2012 at 4:19

emsr

16.5k7 gold badges52 silver badges65 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

genpfault Over a year ago

This is mostly for streamlining SSCCE programs/examples here on SO so in the interests of portability I'd like to avoid C++11.

Christian Rau Over a year ago

Excellent suggestion. GLSL shaders and OpenCL kernels are one of the best use-cases for raw string literals. But note, that the delimiter is not strictly neccessary, it can just be empty, only the R"()" is mandatory.

emsr Over a year ago

@ChristianRau You're right. I only need the END to escape a literal )" not just ).

emsr Over a year ago

@genpfault Or just start out with const GLchar* vert = R"END(#version 120 without the newline. I just wrote my answer that way to make it look nicer. (To me).

Chris Dodd Over a year ago

@genpfault: Sounds like they're not following the spec closely, as it says: "The #version directive must occur in a shader before anything else, except for comments and white space.", and newlines are whitespace.

|

Chris Dodd · Accepted Answer · 2012-12-14 07:40:03Z

Unfortunately, having preprocessor directives in the argument of a macro is undefined, so you can't do this directly. But as long as none of your shaders need preprocessor directives other than #version, you could do something like:

#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 ); } );

Oleg Titov · Accepted Answer · 2012-12-14 07:38:06Z

To achieve this purpose I used sed. I have seperate files with GLSL which I edit (with proper syntax highlighting), and in the same time GLSL in inlined in C++. Not very cross platform, but with msys it works under windows.

In C++ code:

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

In 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

Alexey Podlasov · Accepted Answer · 2013-07-09 07:17:21Z

The problem is due to gcc preprocessing macros meant for GLSL. Using standard stringify and escaping preprocessor directives with new lines in GLSL code worked for me.

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

Mattijs · Accepted Answer · 2020-06-08 07:14:37Z

An alternative approach: include a header file, but with a .glsl extension.

For example, I have a file called bar.h.glsl. It exposes my vertex and fragment shader code as raw literals:

#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 ----- )"; }

Then in my source, I simply include the file:

#include "bar.h.glsl"

and access the glsl strings like so:

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

This way, although I need to overlook a bit of C code in my glsl files, I get the best of glsl syntax highlighting without having to dynamically load the file.

Collectives™ on Stack Overflow

GCC, stringification, and inline GLSL?

5 Answers 5

7 Comments

Comments

Comments

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

7 Comments

Comments

Comments

Comments

Comments

Linked

Related