glapp/main.cpp

#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include <string>
#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;
#define vaoNum 1
GLuint  rederingProgram;
GLuint vao[vaoNum];

void printShaderLog(GLuint shader){
    int len = 0;
    int chWrittn = 0;
    char* log;
    glGetShaderiv(shader,GL_INFO_LOG_LENGTH,&len);
    if(len>0){
        log = (char*)malloc(len);
        glGetShaderInfoLog(shader,len,&chWrittn,log);
        cout<<"Shader Info Log:"<<log<<endl;
        free(log);
    }
}

bool checkOpenGLError(){
    bool foundError = false;
    int glErr = glGetError();
    while (glErr !=GL_NO_ERROR){
        cout<<"glError: "<<glErr<<endl;
        foundError = true;
        glErr = glGetError();
    }
    return foundError;
}

string readfile(char *filename) {
    fstream fs(filename);
    stringstream buffer;
    buffer << fs.rdbuf();
    return buffer.str();
}

GLuint prepareShader(int shaderTYPE, char* filename){
    GLint shaderCompliled;
    string shaderStr = readfile(filename);
    const char* shaderSrc = shaderStr.c_str();
    GLuint shaderRef = glCreateShader(shaderTYPE);
    glShaderSource(shaderRef,1,&shaderSrc,NULL);
    glCompileShader(shaderRef);
    checkOpenGLError();
    glGetShaderiv(shaderRef,GL_COMPILE_STATUS,&shaderCompliled);
    if(shaderCompliled !=1){
        cout<<"shader compilation error."<<endl;
        printShaderLog(shaderRef);
    }
    return shaderRef;
}

void printProgramLog(int prog){
    int len = 0;
    int chWrittn = 0;
    char* log;
    glGetProgramiv(prog, GL_INFO_LOG_LENGTH,&len);
    if(len>0){
        log = (char*)malloc(len);
        glGetProgramInfoLog(prog,len,&chWrittn,log);
        cout<<"Prog Info Log: "<<log<<endl;
        free(log);
    }
}

int finalizeShaderProgram(GLuint sprogram){
    GLint linked;
    glLinkProgram(sprogram);
    checkOpenGLError();
    glGetProgramiv(sprogram,GL_LINK_STATUS,&linked);
    if(linked !=1){
        cout<<"linking failed"<<endl;
        printProgramLog(sprogram);
    }
    return sprogram;
}

GLuint createShaderProgram(char* vertex,char* fragment){
    GLuint vShader = prepareShader(GL_VERTEX_SHADER,vertex);
    GLuint fShader = prepareShader(GL_FRAGMENT_SHADER,fragment);
    GLuint vfprogram = glCreateProgram();
    glAttachShader(vfprogram,vShader);
    glAttachShader(vfprogram,fShader);
    finalizeShaderProgram(vfprogram);
    return  vfprogram;
}

void window_size_callback(GLFWwindow* win, int newWidth,int newHeight){
    glViewport(0,0,newWidth,newHeight);
}

void display(GLFWwindow* window){
    glClear(GL_DEPTH_BUFFER_BIT);
    glClearColor(0.1,0.2,0.3,0.4);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(rederingProgram);
    glDrawArrays(GL_TRIANGLES,0,3);
}

void init(GLFWwindow* window){
    rederingProgram = createShaderProgram("../vertex.glsl","../fragment.glsl");
    int width,height;
    glfwGetFramebufferSize(window,&width,&height);
    double aspect = (float)width/(float)height;
    glGenVertexArrays(1,vao);
    glBindVertexArray(vao[0]);
}

int main() {

    if(!glfwInit()){exit(EXIT_FAILURE);}
    std::cout<<__LINE__<<std::endl;
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,3);
    GLFWwindow *window  = glfwCreateWindow(600,400,"triangle", nullptr, nullptr);
    std::cout<<__LINE__<<std::endl;
    glfwMakeContextCurrent(window);
    std::cout<<__LINE__<<std::endl;
    if(glewInit() != GLEW_OK){exit(EXIT_FAILURE);}
    std::cout<<__LINE__<<std::endl;
    init(window);
    std::cout<<__LINE__<<std::endl;
    glfwSetWindowSizeCallback(window,window_size_callback);
    std::cout<<__LINE__<<std::endl;
    while(!glfwWindowShouldClose(window)){
        std::cout<<__LINE__<<std::endl;
        display(window);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    std::cout<<__LINE__<<std::endl;
    glfwDestroyWindow(window);
    glfwTerminate();


//    cout << readfile("../vertex.glsl") << endl;
    std::cout << "Hello, World!" << std::endl;
    exit(EXIT_SUCCESS);
    return 0;
}