5

I'm working on a project that uses OpenGL 4.0 shaders.

I have to supply the call to glShaderSource() with an array of char arrays, which represents the source of the shader.

The shader compilation is failing, with the following errors:

(0) : error C0206: invalid token "<null atom>" in version line (0) : error C0000: syntax error, unexpected $end at token "<EOF>"

Here's my (hello world) shader - straight from OpenGL 4.0 shading language cookbook

#version 400 in vec3 VertexPosition; in vec3 VertexColor; out vec3 Color; void main() { Color = VertexColor; gl_Position = vec4( VertexColor, 1.0 ); }

And here's my code to read the shader file into my C++ code, and compile the shader at runtime:

const int nMaxLineSize = 1024; char sLineBuffer[nMaxLineSize]; ifstream stream; vector<string> vsLines; GLchar** ppSrc; GLint* pnSrcLineLen; int nNumLines; stream.open( m_sShaderFile.c_str(), std::ios::in ); while( (stream.good()) && (stream.getline(sLineBuffer, nMaxLineSize)) ) { if( strlen(sLineBuffer) > 0 ) vsLines.push_back( string(sLineBuffer) ); } stream.close(); nNumLines = vsLines.size(); pnSrcLineLen = new GLint[nNumLines]; ppSrc = new GLchar*[nNumLines]; for( int n = 0; n < nNumLines; n ++ ) { string & sLine = vsLines.at(n); int nLineLen = sLine.length(); char * pNext = new char[nLineLen+1]; memcpy( (void*)pNext, sLine.c_str(), nLineLen ); pNext[nLineLen] = '\0'; ppSrc[n] = pNext; pnSrcLineLen[n] = nLineLen+1; } vsLines.clear(); // just for debugging purposes (lines print out just fine..) for( int n = 0; n < nNumLines; n ++ ) ATLTRACE( "line %d: %s\r\n", n, ppSrc[n] ); // Create the shader m_nShaderId = glCreateShader( m_nShaderType ); // Compile the shader glShaderSource( m_nShaderId, nNumLines, (const GLchar**)ppSrc, (GLint*) pnSrcLineLen ); glCompileShader( m_nShaderId ); // Determine compile status GLint nResult = GL_FALSE; glGetShaderiv( m_nShaderId, GL_COMPILE_STATUS, &nResult );

The C++ code executes as expected, but the shader compilation fails. Can anyone spot what I might be doing wrong?

I have a feeling that this may be to do with end of line characters somehow, but as this is my first attempt at shader compilation, I'm stuck!

I've read other SO answers on shader compilation, but they seem specific to Java / other languages, not C++. If it helps, I'm on the win32 platform.

Improve this question
4
  • Does the shader work if you include it in the source as a literal? Commented Nov 6, 2011 at 0:54
  • I'm not sure I follow. The shader file has to be compiled by glsl during the execution of my program. But I don't think the shader is at fault. The shader is a simple hello world, taken from a book. I think the problem may be to do with newline chars. Commented Nov 6, 2011 at 0:57
  • Not that this is an error but why is vertexcolor used in the position? Commented Nov 6, 2011 at 1:02
  • It's just an example taken from a book. The shader code isn't the issue here, I think the issue may be to do with either the way it's supplied to the glShaderSource() call, or a line parsing problem. Commented Nov 6, 2011 at 1:04

3 Answers 3

Reset to default
15

You have made a mistake that others have made. This is the definition of glShaderSource:

void glShaderSource(GLuint shader, GLsizei count, const GLchar **string, const GLint *length);

The string is an array of strings. It is not intended to be an array of lines in your shader. The way the compiler will interpret this array of strings is by concatenating them together, one after another. Without newlines.

Since stream.getline will not put the \n character in the string, each of the shader strings you generate will not have a newline at the end. Therefore, when glShaderSource goes to compile them, your shader will look like this:

#version 400in vec3 VertexPosition;in vec3 VertexColor;out vec3 Color;...

That's not legal GLSL.

The proper way to do this is to load the file as a string.

std::ifstream shaderFile(m_sShaderFile.c_str()); if(!shaderFile) //Error out here. std::stringstream shaderData; shaderData << shaderFile.rdbuf(); //Loads the entire string into a string stream. shaderFile.close(); const std::string &shaderString = shaderData.str(); //Get the string stream as a std::string.

Then you can just pass that along to glShaderSource easily enough:

m_nShaderId = glCreateShader( m_nShaderType ); const char *strShaderVar = shaderString.c_str(); GLint iShaderLen = shaderString.size(); glShaderSource( m_nShaderId, 1, (const GLchar**)&strShaderVar, (GLint*)&iShaderLen ); glCompileShader( m_nShaderId );

If you copied this loading code from somewhere, then I strongly suggest you find a different place to learn about OpenGL. Because that's terrible coding.

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

1 Comment

thanks for the useful information about where to learn about opengl. I wrote the code you refer to as terrible. But then I come from a windows programming background, where everyone uses CString. So I'm just learning about strings and streams with the standard library. My approach does work (after I put a \n \0 at the end of each line), although I agree, after seeing your approach with stringstreams, it's much more elegant. Thanks for the tip.
3

glShaderSource( m_nShaderId, nNumLines, (const GLchar**)ppSrc, (GLint*) pnSrcLineLen );

I know the signature of glShaderSource looks tempting to send each line of the shader separately. But that's now what it's meant for. The point of being able to send is multiple arrays is so that one can mix multiple primitive shader sources into a single shader, kind of like include files. Understanding this, makes it much simpler to read in a shader file – and avoids such nasty bugs.

Using C++ you can do it much nicer and cleaner. I already wrote the follwing in Getting garbage chars when reading GLSL files

You're using C++, so I suggest you leverage that. Instead of reading into a self allocated char array I suggest you read into a std::string:

#include <string> #include <fstream> std::string loadFileToString(char const * const fname) { std::ifstream ifile(fname); std::string filetext; while( ifile.good() ) { std::string line; std::getline(ifile, line); filetext.append(line + "\n"); } return filetext; }

That automatically takes care of all memory allocation and proper delimiting -- the keyword is RAII: Resource Allocation Is Initialization. Later on you can upload the shader source with something like

void glcppShaderSource(GLuint shader, std::string const &shader_string) { GLchar const *shader_source = shader_string.c_str(); GLint const shader_length = shader_string.size(); glShaderSource(shader, 1, &shader_source, &shader_length); }

You can use those two functions together like this: 

void load_shader(GLuint shaderobject, char * const shadersourcefilename) { glcppShaderSource(shaderobject, loadFileToString(shadersourcefilename)); }
Improve this answer

Comments

2

Just a quick hunch:

Have you tried calling glShaderSource with NULL as length parameter? In that case OpenGL will assume your code to be null-terminated.

(Edited because of stupidity)

Improve this answer

6 Comments

c arrays are 0 based, so my array arithmetic is correct, but your answer pointed me in the right direction. I've used NULL for the last parameter, and now I'm getting completely new errors!
Ah, yea, right, sorry for that... gosh, that's embarrassing, but it's in the middle of the night here :D
Solved. awarding answer, thanks for that. The docs I'd seen on glShaderSource were very terse, they didn't explain that last arg at all. Very useful, thanks again!
@freefallr: Please do not use any code that loads each line into glShaderSource as a separate string. Just don't do it.
@freefallr It seems you just accepted the wrong answer. And no, this is not a subjective dicision (and neither should it be a random one).
|