GLuint ShaderProgram(const std::string &vertex_shader_file, const std::string &fragment_shader_file) {
// Create shaders
auto vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
auto fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
auto result = GL_FALSE;
auto info_length = 0;
// Load shader code
std::ifstream vertex_shader_stream(vertex_shader_file);
std::string vertex_shader_code((std::istreambuf_iterator<char>(vertex_shader_stream)), std::istreambuf_iterator<char>());
std::ifstream fragment_shader_stream(fragment_shader_file);
std::string fragment_shader_code((std::istreambuf_iterator<char>(fragment_shader_stream)), std::istreambuf_iterator<char>());
// Compile vertex shader
std::cout << "Compiling Vertex Shader ..." << std::endl;
auto vertex_shader_code_ptr = vertex_shader_code.c_str();
glShaderSource(vertex_shader_id, 1, &vertex_shader_code_ptr, NULL);
glCompileShader(vertex_shader_id);
// Check vertex shader log
glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE) {
glGetShaderiv(vertex_shader_id, GL_INFO_LOG_LENGTH, &info_length);
std::string vertex_shader_log((unsigned int)info_length, ' ');
glGetShaderInfoLog(vertex_shader_id, info_length, NULL, &vertex_shader_log[0]);
std::cout << vertex_shader_log << std::endl;
}
// Compile fragment shader
std::cout << "Compiling Fragment Shader ..." << std::endl;
auto fragment_shader_code_ptr = fragment_shader_code.c_str();
glShaderSource(fragment_shader_id, 1, &fragment_shader_code_ptr, NULL);
glCompileShader(fragment_shader_id);
// Check fragment shader log
glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE) {
glGetShaderiv(fragment_shader_id, GL_INFO_LOG_LENGTH, &info_length);
std::string fragment_shader_log((unsigned long)info_length, ' ');
glGetShaderInfoLog(fragment_shader_id, info_length, NULL, &fragment_shader_log[0]);
std::cout << fragment_shader_log << std::endl;
}
// Create and link the program
std::cout << "Linking Shader Program ..." << std::endl;
auto program_id = glCreateProgram();
glAttachShader(program_id, vertex_shader_id);
glAttachShader(program_id, fragment_shader_id);
glBindFragDataLocation(program_id, 0, "FragmentColor");
glLinkProgram(program_id);
// Check program log
glGetProgramiv(program_id, GL_LINK_STATUS, &result);
if (result == GL_FALSE) {
glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &info_length);
std::string program_log((unsigned long)info_length, ' ');
glGetProgramInfoLog(program_id, info_length, NULL, &program_log[0]);
std::cout << program_log << std::endl;
}
glDeleteShader(vertex_shader_id);
glDeleteShader(fragment_shader_id);
return program_id;
}
GLuint GlModel::LoadShaders(std::string vertex_file_path, std::string fragment_file_path) {
// Create the shaders
GLuint vertex_shader_id = glCreateShader(GL_VERTEX_SHADER);
GLuint fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER);
// Read the Vertex Shader code from the file
std::string vertex_shader_code;
std::ifstream vertex_shader_stream(vertex_file_path, std::ios::in);
if(vertex_shader_stream.is_open()) {
std::string line = "";
while(getline(vertex_shader_stream, line))
vertex_shader_code += "\n" + line;
vertex_shader_stream.close();
} else {
printf("Impossible to open %s. Are you in the right directory?\n", vertex_file_path.c_str());
getchar();
return 0;
}
// Read the Fragment Shader code from the file
std::string fragment_shader_code;
std::ifstream fragment_shader_stream(fragment_file_path, std::ios::in);
if(fragment_shader_stream.is_open()) {
std::string line = "";
while(getline(fragment_shader_stream, line)) {
fragment_shader_code += "\n" + line;
}
fragment_shader_stream.close();
}
GLint result = GL_FALSE;
int info_log_length;
// Compile Vertex Shader
printf("Compiling shader : %s\n", vertex_file_path.c_str());
char const* vertex_source_pointer = vertex_shader_code.c_str();
glShaderSource(vertex_shader_id, 1, &vertex_source_pointer , NULL);
glCompileShader(vertex_shader_id);
// Check Vertex Shader
glGetShaderiv(vertex_shader_id, GL_COMPILE_STATUS, &result);
glGetShaderiv(vertex_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
if ( info_log_length > 0 ){
std::vector<char> vertex_shader_error_message(info_log_length+1);
glGetShaderInfoLog(vertex_shader_id, info_log_length, NULL, &vertex_shader_error_message[0]);
printf("%s\n", &vertex_shader_error_message[0]);
}
// Compile Fragment Shader
printf("Compiling shader : %s\n", fragment_file_path.c_str());
char const* FragmentSourcePointer = fragment_shader_code.c_str();
glShaderSource(fragment_shader_id, 1, &FragmentSourcePointer , NULL);
glCompileShader(fragment_shader_id);
// Check Fragment Shader
glGetShaderiv(fragment_shader_id, GL_COMPILE_STATUS, &result);
glGetShaderiv(fragment_shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
if ( info_log_length > 0 ){
std::vector<char> fragment_shader_error_message(info_log_length+1);
glGetShaderInfoLog(fragment_shader_id, info_log_length, NULL, &fragment_shader_error_message[0]);
printf("%s\n", &fragment_shader_error_message[0]);
}
// Link the program
printf("Linking program\n");
GLuint program_id = glCreateProgram();
glAttachShader(program_id, vertex_shader_id);
glAttachShader(program_id, fragment_shader_id);
glLinkProgram(program_id);
// Check the program
glGetProgramiv(program_id, GL_LINK_STATUS, &result);
glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &info_log_length);
if ( info_log_length > 0 ){
std::vector<char> program_error_message(info_log_length+1);
glGetProgramInfoLog(program_id, info_log_length, NULL, &program_error_message[0]);
printf("%s\n", &program_error_message[0]);
}
glDeleteShader(vertex_shader_id);
glDeleteShader(fragment_shader_id);
return program_id;
}
