engine_shaders.hpp

#ifndef ENGINE_SHADERS_HPP
#define ENGINE_SHADERS_HPP
#include <glm/glm.hpp>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <GL/gl.h>

#include <thread>
#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>

/*GL SPECIFIC DEBUG START*/
void PrintGLError(GLenum error){
    switch(error){
    case GL_NO_ERROR:
        break;

    case GL_INVALID_ENUM:
        std::cout << "GL_INVALID_ENUM \n";
        break;

    case GL_INVALID_OPERATION:
        std::cout << "GL_INVALID_OPERATION \n";
        break;

    case GL_INVALID_FRAMEBUFFER_OPERATION:
        std::cout << "GL_INVALID_FRAMEBUFFER_OPERATION \n";
        break;

    case GL_OUT_OF_MEMORY:
        std::cout << "GL_OUT_OF_MEMORY \n";
        break;

    case GL_STACK_UNDERFLOW:
        std::cout << "GL_STACK_UNDERFLOW \n";
        break;

    case GL_STACK_OVERFLOW:
        std::cout << "GL_STACK_OVERFLOW \n";
        break;

    case GL_INVALID_VALUE:
        std::cout << "GL_INVALID_VALUE:" << error << "\n";
        break;

    default:
        std::cout << "UNKOWN ERROR CODE: " << error << "\n";
        break;
    }
}

void CheckForGLErrors(std::string function, int line){
    GLenum error = glGetError();
    if(error != GL_NO_ERROR ){

        //Go through all the errors:
        std::cout << "OpenGL error in " << function
                << " (at line "<< line << ")" << ": \n";

        PrintGLError(error);

        error= glGetError();
    }
}
/*GL SPECIFIC DEBUG END*/

GLuint CreateShader(GLenum shadertype, const std::string shaderfile){
    GLuint shader = glCreateShader(shadertype);
    std::string filedata;
    std::string line;
    const char* shaderdata;

    std::ifstream file (shaderfile);

    //Load file into a string
    if(file.is_open()){
            while(getline(file, line)){
                filedata.append(line);
                filedata.append("\n");
            }
    }
    shaderdata = filedata.c_str();

    //Tell OpenGL where to find the shader data
    glShaderSource(shader, 1, &shaderdata, NULL);

    //Compile the shader
    glCompileShader(shader);

    //Check for errors
    GLint status;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    if( status == GL_FALSE){
        std::string type;
        switch(shadertype){
        case GL_VERTEX_SHADER: type = "vertex"; break;
        case GL_GEOMETRY_SHADER: type = "geometry"; break;
        case GL_FRAGMENT_SHADER: type = "fragment"; break;
        }

        std::cout << "OpenGL error in " << __func__
                << " (while compiling " << type << "shader):\n";
        PrintGLError(status);

        GLint errorlegnth;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &errorlegnth);
        GLchar programerror[errorlegnth + 1];
        glGetShaderInfoLog(shader, errorlegnth, NULL, programerror);
        std::cout << programerror;
    }
    return shader;
}

GLuint CreateProgram(const std::vector<GLuint> &ShaderList){
    GLuint program = glCreateProgram();

    //Attach all our shaders to the program
    for(size_t i = 0; i < ShaderList.size(); i++){
        glAttachShader(program, ShaderList[i]);
    }

    //Link them
    glLinkProgram(program);

    //Check for any problems
    GLint status;
    glGetProgramiv(program, GL_LINK_STATUS, &status);
    if( status == GL_FALSE){
        std::cout << "OpenGL error in " << __func__
                << " (at line " << __LINE__ << "):\n";
        PrintGLError(status);

        GLint errorlegnth;
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &errorlegnth);
        GLchar programerror[errorlegnth + 1];
        glGetProgramInfoLog(program, errorlegnth, NULL, programerror);
        std::cout << programerror;
    }

    //Detach all our shaders from the program
    for(size_t i = 0; i < ShaderList.size(); i++){
            glDetachShader(program, ShaderList[i]);
    }

    return program;
}

GLuint LoadShaders(std::string vertexshader, std::string fragmentshader){
    std::vector<GLuint> ShaderList;

    ShaderList.push_back(CreateShader(GL_VERTEX_SHADER, vertexshader));
    ShaderList.push_back(CreateShader(GL_FRAGMENT_SHADER, fragmentshader));

    GLuint Program = CreateProgram(ShaderList);

    for(uint i = 0; i < ShaderList.size(); ++i){
        glDeleteShader(ShaderList[i]);
    }

    return Program;
}

#endif