glFuckColors

#include <GL/glew.h>
#include <GL/gl.h>
#include <GL/freeglut.h>

#include <iostream>
#include <vector>
#include <functional>

// shaders
GLchar vertShader[] = "#version 330\n"
    "layout(location = 0) in vec4 vPosition;\n"
        "void main() {\n"
        "gl_Position = vPosition;\n"
    "}\n";

GLchar fragShader[] = "#version 330\n"
    "out vec4 fColor;\n"
    "void main() {\n"
        "fColor = vec4(1.0, 0.0, 1.0, 1.0);\n"
    "}\n";

// vertex array
GLuint vertArray;
GLuint program;


// display function
void display() {
    glClearColor(0.3f, 0.3f, 0.3f, 1);
    glClear(GL_COLOR_BUFFER_BIT);

    glBindVertexArray(vertArray);
    glDrawArrays(GL_TRIANGLES, 0, 3);

    glFlush();
    // wait for gl ready
    glFinish();
}


void compilerLog(GLuint shader) {
    GLint blen = 0;
    GLsizei slen = 0;

    glGetShaderiv(shader, GL_INFO_LOG_LENGTH , &blen);
    if (blen > 1)
    {
        GLchar* compiler_log = (GLchar*)malloc(blen);
        glGetInfoLogARB(shader, blen, &slen, compiler_log);
        std::cout << "compiler_log for" << shader << "\n" << compiler_log;
        free (compiler_log);
    }
}

// init function
void init() {
    glGenVertexArrays(1, &vertArray);

    glBindVertexArray(vertArray);
    GLfloat vertices[3][2] = {
        {0, 1},
        {1, 1},
        {0, 0}
    };

    GLuint buffer;
    glGenBuffers(1, &buffer);
    glBindBuffer(GL_ARRAY_BUFFER, buffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);

    const GLchar *vertShaderChar = vertShader;
    const GLint vertShaderSize = sizeof(vertShader);
    const GLchar *fragShaderChar = fragShader;
    const GLint fragShaderSize = sizeof(fragShader);

    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(vertexShader, 1, &vertShaderChar, &vertShaderSize);
    glShaderSource(fragmentShader, 1, &fragShaderChar, &fragShaderSize);
    glCompileShaderARB(vertexShader);
    glCompileShaderARB(fragmentShader);

    GLint compiled;
    glGetObjectParameterivARB(vertexShader, GL_COMPILE_STATUS, &compiled);
    if (compiled) {
        std::cout << "Vertex shader compiled" << std::endl;
    }

    glGetObjectParameterivARB(fragmentShader, GL_COMPILE_STATUS, &compiled);
    if (compiled) {
        std::cout << "Fragment shader compiled" << std::endl;
    }

    compilerLog(vertexShader);
    compilerLog(fragmentShader);

    program = glCreateProgram();
    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);
    glLinkProgram(program);
    glUseProgram(program);

    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, ((void *) 0));
    glEnableVertexAttribArray(vertArray);
}


// core
int main(int argc, char **argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA);
    glutInitWindowSize(512, 512);
    glutInitContextVersion(3, 0);
    glutInitContextProfile(GLUT_CORE_PROFILE);
    glutCreateWindow("OpenGL");

    if (glewInit()) {
        std::cerr << "Unable to init glew" << std::endl;
        exit(EXIT_FAILURE);
    }

    init();
    glutDisplayFunc(display);

    glutMainLoop();
}