//IDEA: change this to also create the program and return it as the return value
static inline void link_program(GLuint program, GLuint *shaders, int nshaders){
int i, status;
//the compiler should be able to unroll this loop
for(i=0;i<nshaders;i++){
glAttachShader(program, shaders[i]);
}
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &status);
if(!status){
print_program_info_log(program, "Error when linking program.\n");
exit(EXIT_FAILURE);
}
IF_DEBUG(print_program_info_log(program, "");)
bool check_program_errors (GLuint program) {
GLint params = -1;
glGetProgramiv (program, GL_LINK_STATUS, ¶ms);
if (GL_TRUE != params) {
fprintf (stderr, "ERROR: program %u did not link\n", program);
print_program_info_log (program);
return false;
}
return true;
}
int init_shaders(Shader *shader,
const char *vertex_shader_loc,
const char *fragment_shader_loc)
{
int params = -1;
int length;
char vertex_shader_source[1024 * 256];
char fragment_shader_source[1024 * 256];
const GLchar *p;
parse_file_into_str(vertex_shader_loc, vertex_shader_source, 1024 * 256);
shader->vertexShader = glCreateShader(GL_VERTEX_SHADER);
p = (const GLchar *)vertex_shader_source;
glShaderSource(shader->vertexShader, 1, &p, NULL);
glCompileShader(shader->vertexShader);
glGetShaderiv(shader->vertexShader, GL_COMPILE_STATUS, ¶ms);
if (GL_TRUE != params) {
fprintf(stderr, "ERROR: GL shader index %i did not compile\n", shader->vertexShader);
print_shader_info_log(shader->vertexShader);
return 1;
}
parse_file_into_str(fragment_shader_loc, fragment_shader_source, 1024 * 256);
shader->fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
p = (const GLchar *)fragment_shader_source;
glShaderSource(shader->fragmentShader, 1, &p, NULL);
glCompileShader(shader->fragmentShader);
glGetShaderiv(shader->fragmentShader, GL_COMPILE_STATUS, ¶ms);
if (GL_TRUE != params) {
fprintf(stderr, "ERROR: GL shader index %i did not compile\n", shader->fragmentShader);
print_shader_info_log(shader->fragmentShader);
return 1;
}
shader->program = glCreateProgram();
glAttachShader(shader->program, shader->fragmentShader);
glAttachShader(shader->program, shader->vertexShader);
glLinkProgram(shader->program);
glGetProgramiv(shader->program, GL_LINK_STATUS, ¶ms);
if (GL_TRUE != params) {
fprintf(stderr, "ERROR: could not link shader programme GL index %i\n",shader->program);
print_program_info_log(shader->program);
return 1;
}
shader->projection_matrix_location = glGetUniformLocation(shader->program, "projection");
shader->view_matrix_location = glGetUniformLocation(shader->program, "view");
return 0;
}
/*****************************************************************************\
* read_shader *
\*****************************************************************************/
GLuint read_shader(const std::string &vertex_filename,
const std::string &fragment_filename)
{
GLint status;
std::string source;
const char *cstring;
GLuint program;
if(access(vertex_filename.data(),F_OK) == -1)
{
std::cerr<<"Cannot load shader file "<<vertex_filename<<std::endl;
std::cerr<<"Wrong path ?"<<std::endl;
abort();
}
if(access(fragment_filename.data(),F_OK) == -1)
{
std::cerr<<"Cannot load shader file "<<vertex_filename<<std::endl;
std::cerr<<"Wrong path ?"<<std::endl;
abort();
}
program = glCreateProgram(); PRINT_OPENGL_ERROR();
// Create the vertex shader.
if (vertex_filename != "")
{
GLuint handle = glCreateShader(GL_VERTEX_SHADER); PRINT_OPENGL_ERROR();
source = get_file_content(vertex_filename);
cstring = source.c_str();
glShaderSource(handle, 1, &cstring, NULL); PRINT_OPENGL_ERROR();
// Compile the vertex shader, and print out the compiler log file.
glCompileShader(handle); PRINT_OPENGL_ERROR();
glGetShaderiv(handle, GL_COMPILE_STATUS, &status); PRINT_OPENGL_ERROR();
print_shader_info_log(handle);
glAttachShader(program, handle); PRINT_OPENGL_ERROR();
if (!status) return 0;
}
// Create the fragment shader
if (fragment_filename != "")
{
GLuint handle = glCreateShader(GL_FRAGMENT_SHADER); PRINT_OPENGL_ERROR();
source = get_file_content(fragment_filename);
cstring = source.c_str();
glShaderSource(handle, 1, &cstring, NULL); PRINT_OPENGL_ERROR();
// Compile the fragment shader, and print out the compiler log file.
glCompileShader(handle); PRINT_OPENGL_ERROR();
glGetShaderiv(handle, GL_COMPILE_STATUS, &status); PRINT_OPENGL_ERROR();
print_shader_info_log(handle);
glAttachShader(program, handle); PRINT_OPENGL_ERROR();
if (!status) return 0;
}
// Link the program object and print out the info log.
glLinkProgram(program); PRINT_OPENGL_ERROR();
glGetProgramiv(program, GL_LINK_STATUS, &status); PRINT_OPENGL_ERROR();
print_program_info_log(program);
if (!status) return 0;
// Install program object as part of current state.
glUseProgram(program); PRINT_OPENGL_ERROR();
return program;
}
GLuint shaderSetup( const char *vert, const char *frag ) {
GLchar *vsrc = NULL, *fsrc = NULL;
GLuint vs, fs, prog;
GLint flag;
// Assume that everything will work
shaderErrorCode = E_NO_ERROR;
// Create the shader handles
vs = glCreateShader( GL_VERTEX_SHADER );
fs = glCreateShader( GL_FRAGMENT_SHADER );
// Read in shader source
vsrc = read_text_file( vert );
if( vsrc == NULL ) {
fprintf( stderr, "Error reading vertex shader file %s\n",
vert);
shaderErrorCode = E_VS_LOAD;
return( 0 );
}
fsrc = read_text_file( frag );
if( fsrc == NULL ) {
fprintf( stderr, "Error reading fragment shader file %s\n",
frag);
shaderErrorCode = E_FS_LOAD;
#ifdef __cplusplus
delete [] vsrc;
#else
free( vsrc );
#endif
return( 0 );
}
// Attach the source to the shaders
glShaderSource( vs, 1, (const GLchar **) &vsrc, NULL );
glShaderSource( fs, 1, (const GLchar **) &fsrc, NULL );
// We're done with the source code now
#ifdef __cplusplus
delete [] vsrc;
delete [] fsrc;
#else
free(vsrc);
free(fsrc);
#endif
// Compile the shaders, and print any relevant message logs
glCompileShader( vs );
glGetShaderiv( vs, GL_COMPILE_STATUS, &flag );
print_shader_info_log( vs );
if( flag == GL_FALSE ) {
shaderErrorCode = E_VS_COMPILE;
return( 0 );
}
glCompileShader( fs );
glGetShaderiv( fs, GL_COMPILE_STATUS, &flag );
print_shader_info_log( fs );
if( flag == GL_FALSE ) {
shaderErrorCode = E_FS_COMPILE;
return( 0 );
}
// Create the program and attach the shaders
prog = glCreateProgram();
glAttachShader( prog, vs );
glAttachShader( prog, fs );
// Report any message log information
print_program_info_log( prog );
// Link the program, and print any message log information
glLinkProgram( prog );
glGetProgramiv( prog, GL_LINK_STATUS, &flag );
print_program_info_log( prog );
if( flag == GL_FALSE ) {
shaderErrorCode = E_SHADER_LINK;
return( 0 );
}
return( prog );
}
