std::vector<glm::vec3> vertices;
    std::vector<glm::vec2> uvs;
    std::vector<glm::vec3> normals;

    model::loadOBJ("models/cube.obj", vertices, uvs, normals);

    glGenBuffers(1, &vertexBufferObject);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    /* glGenBuffers(1, &colorBufferObject);
    glBindBuffer(GL_ARRAY_BUFFER, colorBufferObject);
    glBufferData(GL_ARRAY_BUFFER, sizeof(pyramidColorBufferData), pyramidColorBufferData, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0); */

    GLuint progID;
    shaders::genShaders("shaders/test.vs", "shaders/test.fs", &progID);

    ShaderInfo *sInfo = shaders::getShaderInfo(progID);

    printf(sInfo->getVertexShaderPath().c_str());
    printf("\t");
    printf(sInfo->getFragmentShaderPath().c_str());
    printf("\n");

    // Compute matrix
    // Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
    glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
    // Camera matrix
    glm::mat4 View       = glm::lookAt(
        glm::vec3(4.0f, 4.0f, 4.0f), // Camera is at (4,3,3), in World Space
        glm::vec3(0.0f, 0.0f, 0.0f), // and looks at the origin
        glm::vec3(0.0f, 1.0f, 0.0f)  // Head is up (set to 0,-1,0 to look upside-down)
    );
    // Model matrix : an identity matrix (model will be at the origin)
    glm::mat4 Model      = glm::mat4(1.0f);  // Changes for each model !

    float scaleFactor = 0.4f;
    View = glm::scale(View, glm::vec3(scaleFactor, scaleFactor, scaleFactor));

    // Our ModelViewProjection : multiplication of our 3 matrices
    glm::mat4 MVP        = Projection * View * Model; // Remember, matrix multiplication is the other way around

    // Get a handle for our "MVP" uniform.
    // Only at initialisation time.
    GLuint MatrixID = glGetUniformLocation(progID, "MVP");

    do {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Apply matrix

        Model = glm::rotate(Model, yTheta, glm::vec3(0.0f, 0.0f, 1.0f));

        MVP = Projection * View * Model;

        // Send our transformation to the currently bound shader,
        // in the "MVP" uniform
        // For each model you render, since the MVP will be different (at least the M part)
        MVP = MVP;
        glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);

        glUseProgram(progID);

        glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);

        // std::cout << "Enabled VertexAttribArray 0" << std::endl;
        glEnableVertexAttribArray(0);
        // std::cout << "Enabled VertexAttribArray 1" << std::endl;
        glEnableVertexAttribArray(1);
        // glEnableVertexAttribArray(1);

        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
        // glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (void*) 48); // 48 = 4(size of float) * 4(vec4) * 3(amount vec4's in position data)
        // glBindBuffer(GL_ARRAY_BUFFER, colorBufferObject);
        // glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);

        glDrawArrays(GL_TRIANGLES, 0, vertices.size());

        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);