Что я делаю не так?

#include <GL\glew.h>
#include <GLFW\glfw3.h>
#include <glm\glm.hpp>
#include <glm\gtx\transform.hpp>
#include <iostream>
#include <stdexcept>
 
const int FRAME_RATE = 30;
const int WINDOW_WIDTH = 800;
const int WINDOW_HEIGHT = 600;
const char* WINDOW_TITLE = "Cube";
 
int main()
{
    if(!glfwInit())
        throw std::runtime_error("GLFW initialization failed");
 
    GLFWwindow* window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE, NULL, NULL);
 
    if (!window)
        throw std::runtime_error("GLFWwindow set up failed");
 
    glfwMakeContextCurrent(window);
 
    if(glewInit())
        throw std::runtime_error("GLEW initialization failed");
 
    GLuint vertexArrayID;
    GLuint vertexBufferID;
    GLuint indicesBufferID;
 
    GLfloat vertices[] = {
        -1.0, 1.0, -1.0,
        -1.0, -1.0, -1.0,
        1.0, -1.0, -1.0,
        1.0, 1.0, -1.0,
        -1.0, 1.0, 1.0,
        -1.0, -1.0, 1.0,
        1.0, -1.0, 1.0,
        1.0, 1.0, 1.0
    };
 
    GLuint indices[] = {
        0, 1, 2, 0, 2, 3,
        4, 5, 6, 4, 6, 7,
        3, 2, 6, 3, 6, 7,
        4, 5, 1, 4, 1, 0,
        1, 5, 6, 1, 6, 2,
        4, 0, 3, 4, 3, 7
    };
 
    glGenVertexArrays(1, &vertexArrayID);
    glBindVertexArray(vertexArrayID);
    
    glGenBuffers(1, &vertexBufferID);
    glBindBuffer(GL_ARRAY_BUFFER, vertexArrayID);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 
    glGenVertexArrays(1, &indicesBufferID);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indicesBufferID);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
 
    GLuint vertexShaderID;
    GLuint fragmentShaderID;
 
    const GLchar* vertexShaderSource =
    {
        "#version 330 core\n"
        "layout (location = 0) in vec3 position;\n"
        "uniform mat4 mvp;\n"
        "void main(){\n"
        "gl_Position = vec4(position, 1.0) * mvp;\n"
        "}\n"
    };
 
    const GLchar* fragmentShaderSource =
    {
        "#version 330 core\n"
        "out vec4 color;\n"
        "void main(){\n"
        "color = vec4(1.0, 1.0, 1.0, 1.0);\n"
        "}\n"
    };
 
    vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShaderID, 1, &vertexShaderSource, NULL);
    
    fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShaderID, 1, &fragmentShaderSource, NULL);
 
    GLint status;
    GLchar log[512];
 
    glCompileShader(vertexShaderID);
    
    glGetShaderiv(vertexShaderID, GL_COMPILE_STATUS, &status);
    if (!status)
    {
        glGetShaderInfoLog(vertexShaderID, 512, NULL, log);
        std::cout << log;
    }
 
    glCompileShader(fragmentShaderID);
 
    glGetShaderiv(fragmentShaderID, GL_COMPILE_STATUS, &status);
    if (!status)
    {
        glGetShaderInfoLog(fragmentShaderID, 512, NULL, log);
        std::cout << log;
    }
 
    GLuint programID;
 
    programID = glCreateProgram();
    glAttachShader(programID, vertexShaderID);
    glAttachShader(programID, fragmentShaderID);
 
    glLinkProgram(programID);
    
    glGetProgramiv(programID, GL_LINK_STATUS, &status);
    if (!status)
    {
        glGetProgramInfoLog(programID, 512, NULL, log);
        std::cout << log;
    }
 
    glUseProgram(programID);
 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
 
    GLuint mvpUniform = glGetUniformLocation(programID, "mvp");
 
    glm::mat4 sizeMatrix = glm::scale(glm::vec3(1.0, 1.0, 1.0));
    glm::mat4 rotationMatrix = glm::rotate(45.0f, glm::vec3(0.0f, 1.0f, 0.0f));
    glm::mat4 translationMatrix = glm::translate(glm::vec3(0.0f, 0.0f, 0.0f));
    glm::mat4 modelMatrix = translationMatrix * rotationMatrix * sizeMatrix;
    glm::mat4 viewMatrix = glm::lookAt(glm::vec3(0.0f, 0.0f, 4.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
    glm::mat4 projectionMatrix = glm::perspective(45.0f, (float)(WINDOW_WIDTH / WINDOW_HEIGHT), 0.1f, 5.0f);
    glm::mat4 mvpMatrix = projectionMatrix * viewMatrix * modelMatrix;
 
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glEnable(GL_DEPTH_TEST);
 
    bool isRunning = true;
 
    double lastTime = 0.0;
    double currentTime;
    double deltaTime;
 
    const double framePeriod = 1.0 / FRAME_RATE;
    double frameTime = framePeriod;
 
    double frameCounter = 0.0;
    int frames = 0;
 
    while (isRunning)
    {
        currentTime = glfwGetTime();
        deltaTime = currentTime - lastTime;
        lastTime = currentTime;
 
        frameTime += deltaTime;
        frameCounter += deltaTime;
 
        if (glfwWindowShouldClose(window))
            isRunning = false;
        
        if (frameTime > framePeriod)
        {
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            
            glUniformMatrix4fv(mvpUniform, 1, GL_FALSE, &mvpMatrix[0][0]);
 
            glBindVertexArray(vertexArrayID);
            glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, NULL);
 
            glfwPollEvents();
            glfwSwapBuffers(window);
            
            frameTime = 0.0;
            frames++;
        }
 
        if (frameCounter > 1.0)
        {
            std::cout << frames << std::endl;
            frames = 0;
            frameCounter = 0.0;
        }
    }
}