/* Loads, compiles and activates vertex, geometry and fragment shaders */
GLuint load_shaders(const GLchar* vertex_file_path, const GLchar* fragment_file_path)
{
std::string vertex_source = read_shader_file(vertex_file_path);
std::string fragment_source = read_shader_file(fragment_file_path);
GLuint vertex = compile_shader((GLchar*) vertex_source.c_str(), GL_VERTEX_SHADER, vertex_file_path);
GLuint fragment = compile_shader((GLchar*) fragment_source.c_str(), GL_FRAGMENT_SHADER, fragment_file_path);
GLuint program = glCreateProgram();
glAttachShader(program, vertex);
glAttachShader(program, fragment);
glLinkProgram(program);
GLint success;
GLchar info_log[512];
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(program, 512, NULL, info_log);
Error::throw_error(Error::cant_load_shader, "Linking failed for "
+ std::string(vertex_file_path) + ": " + std::string(info_log));
}
glDeleteShader(vertex);
glDeleteShader(fragment);
glUseProgram(program);
return program;
}
void ShaderCreator::attach_shader(GLenum shader_type, const char *shader_filename, GLuint program) {
/* read in source and create shader object */
std::string shader_source {read_shader_file(shader_filename)};
GLuint shader = glCreateShader(shader_type);
/* attach source to shader and compile */
const GLchar *source {(const GLchar *)shader_source.c_str()};
glShaderSource(shader, 1, &source, nullptr);
glCompileShader(shader);
/* error check shader compilation */
GLint status;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (status != GL_TRUE)
throw std::runtime_error("Error in shader compilation.");
/* attach shaders to the program and link */
glAttachShader(program, shader);
glLinkProgram(program);
/* error check shader linking */
glGetProgramiv(shader, GL_LINK_STATUS, &status);
if (status != GL_TRUE)
throw std::runtime_error("Error in linking shader program.");
glDeleteShader(shader);
}
bool GLSLProgram::create_shader(const char *file_name, GLuint &shader, GLenum type)
{
char *shader_str;//read(file_name)
if (!read_shader_file(file_name, shader_str))
{
return false;
}
shader = glCreateShader(type);
glShaderSource(shader, 1, &shader_str, nullptr);
glCompileShader(shader);
int params = -1;
glGetShaderiv(shader, GL_COMPILE_STATUS, ¶ms);
if (params == GL_FALSE)
{
cout << "ERROR: GL shader " << file_name << " did not compile successfully!\n";
#ifdef _DEBUG
GLint infoLogLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
GLchar *infoLog = new GLchar[infoLogLength];
glGetShaderInfoLog(shader, infoLogLength, NULL, infoLog);
cout << "*************************************************************\n"
<< "* Link log *\n"
<< infoLog
<< "*************************************************************\n";
delete[] infoLog;
#endif
return false;
}
return true;
}
void create_shaders()
{
char *vdata;
char *fdata;
vert = glCreateShader(GL_VERTEX_SHADER);
frag = glCreateShader(GL_FRAGMENT_SHADER);
vdata = read_shader_file(VERT_SHADER_FILE);
fdata = read_shader_file(FRAG_SHADER_FILE);
compile_shader(vert, vdata);
compile_shader(frag, fdata);
free(vdata);
free(fdata);
}
GLuint create_shader(const char *filename, GLenum type)
{
GLuint shader = glCreateShader(type);
char *data;
data = read_shader_file(filename);
if (!data)
return 0;
if (!compile_shader(shader, data))
{
print_error(shader);
free(data);
glDeleteShader(shader);
return 0;
}
free(data);
return shader;
}
void shader_program::add_shader( GLenum shader_type, std::string& source_file_name ) {
if( linked ) {
throw shader_program_already_linked_exception();
}
switch( shader_type ) {
case GL_VERTEX_SHADER:
m_vert_shader_name = source_file_name;
break;
case GL_FRAGMENT_SHADER:
m_frag_shader_name = source_file_name;
break;
case GL_GEOMETRY_SHADER:
m_geom_shader_name = source_file_name;
break;
case GL_TESS_CONTROL_SHADER:
m_tesc_shader_name = source_file_name;
break;
case GL_TESS_EVALUATION_SHADER:
m_tese_shader_name = source_file_name;
break;
}
GLuint shader_name = glCreateShader( shader_type );
// Read in the shader source, getting uniforms
std::string shader_source = read_shader_file( source_file_name );
const char *shader_source_char = shader_source.c_str();
glShaderSource( shader_name, 1, &shader_source_char, NULL );
glCompileShader( shader_name );
if( !check_for_shader_errors( shader_name ) ) {
m_added_shaders.push_back( shader_name );
}
}
