OpenGL

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

void error_callback(int error, const char* desc) {

    std::cout << desc;

}

int main() {

    GLFWwindow* window;

    if (!glfwInit()) {

        return 1;

    }

    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    window = glfwCreateWindow(800, 640, "OpenGL Window", NULL, NULL);
    glfwMakeContextCurrent(window);

    glewExperimental = GL_TRUE;
    GLenum err = glewInit();

    if (GLEW_OK != err) {

        std::cout << "Failed to init.";
        return 1;

    }


    float points[] = {

       -0.5f,  0.5f, 0.0f, // top left      = 0
        0.5f,  0.5f, 0.0f, // top right     = 1
        0.5f, -0.5f, 0.0f, // bottom right  = 2
       -0.5f, -0.5f, 0.0f, // bottom left   = 3

    };

    GLuint elements[] = {

        0, 1, 2,
        2, 3, 0,
    };

    // generate vbo (point buffer)
    GLuint pb = 0;
    glGenBuffers(1, &pb);
    glBindBuffer(GL_ARRAY_BUFFER, pb);
    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

    // generate element buffer object (ibo/ebo)
    GLuint ebo = 0;
    glGenBuffers(1, &ebo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);

    // generate vao
    GLuint vao = 0;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);


    glBindBuffer(GL_ARRAY_BUFFER, pb);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);

    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);


    // only draw the outlines of the shapes
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);


    const char* vertex_shader =
        "#version 400\n"
        "layout(location = 0) in vec3 vp;"
        "void main () {"
        "  gl_Position = vec4 (vp, 1.0);"
        "}";

    const char* fragment_shader =
        "#version 400\n"
        "out vec4 frag_colour;"
        "void main () {"
        "  frag_colour = vec4 (1.0, 0.0, 0.0, 1.0);"
        "}";

    // create shader program and compile
    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vs, 1, &vertex_shader, NULL);
    glCompileShader(vs);
    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fs, 1, &fragment_shader, NULL);
    glCompileShader(fs);

    // attach the prorgram
    GLuint sp = glCreateProgram();
    glAttachShader(sp, fs);
    glAttachShader(sp, vs);
    glLinkProgram(sp);

    while (!glfwWindowShouldClose(window)) {

        glClear(GL_COLOR_BUFFER_BIT);
        glUseProgram(sp);
        glBindVertexArray(vao);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        glfwSwapBuffers(window);
        glfwPollEvents();

    }

    glfwTerminate();
    glfwDestroyWindow(window);

    return 0;

}