OpenGL. Frame not in module | Access violation reading location 0x00000000

Я пытаюсь создать прототип игры Pong для практики OpenGL. Программа разделена на модули.

Pong Game.cpp — основной модуль с функцией main. Инициалиpирует SDL, шейдеры (shaders.h), потом рисует «ракетку» (класс Paddle, модуль shapes.h).

Проблема в том, что после того, как я пытаюсь нарисовать «ракетку», у меня ничего не работает и выскакивает эта ошибка.

Pong Game.cpp

#include <iostream>

#define SDL_MAIN_HANDLED
#include <SDL.h>

#define GLEW_STATIC
#include <GL/glew.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include "shaders.h"
#include "shapes.h"

#define WINDOW_WIDTH 640
#define WINDOW_HEIGHT 360

using namespace std;

int main()
{
    SDL_Init(SDL_INIT_EVERYTHING);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
    SDL_Window* window = SDL_CreateWindow("Pong Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL);
    SDL_GLContext context = SDL_GL_CreateContext(window);

    glewExperimental = GL_TRUE;
    glewInit() != GLEW_OK;
    
    LoadShader();
    UseShader();
    /*
    GLuint vbo;
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    float vertices[] =
    {
        -0.5, -0.5,
        0.0, 0.5,
        0.5, -0.5
    };
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);

    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
    glEnableVertexAttribArray(0);
    */
    glClearColor(0, 0, 0, 1);
    glClear(GL_COLOR_BUFFER_BIT);
    PrepareShapes();
    Paddle pad;
    pad.Draw();
    //glDrawArrays(GL_TRIANGLES, 0, 3);
    SDL_GL_SwapWindow(window);

    SDL_Delay(5000);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

shapes.h

#pragma once

#include <GL/glew.h>

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include "shaders.h"

void PrepareShapes();

struct Shape
{
    virtual void Draw() = 0;
};

class Paddle : Shape
{
public:
    Paddle();
    virtual void Draw();
protected:
    GLuint vbo;
    glm::mat4 model;
};

shapes.cpp

#include "shapes.h"

const float paddleVertices[] =
{
    -0.25, 1,
    0.25, 1,
    0.25, -1,
    -0.25, -1
};

const float ballVertices[] =
{
    -0.25, 0.25,
    0.25, 0.25,
    0.25, -0.25,
    -0.25, -0.25
};

unsigned int indices[] =
{
    0, 1, 2,
    0, 2, 3
};

GLuint vao;
GLuint ebo;

void PrepareShapes()
{
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, (void*)0);
    glEnableVertexAttribArray(0);

    glGenBuffers(1, &ebo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), &indices, GL_STATIC_DRAW);
}

Paddle::Paddle()
{
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(paddleVertices), &paddleVertices, GL_STATIC_DRAW);
    model = glm::mat4(1.0);
}

void Paddle::Draw()
{
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glUniformMatrix4fv(glGetUniformLocation(GetShader(), "model"), 1, GL_FALSE, &model[0][0]);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}

shaders.h

#pragma once

#include <GL/glew.h>

void LoadShader();
void UseShader();
GLuint GetShader();

shaders.cpp

#include "shaders.h"

GLuint shader;

void LoadShader()
{
    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
    const char* vsSource = R"glsl(
        #version 150
        layout(location=0) in vec2 position;
        uniform mat4 model;
        void main()
        {
            gl_Position = model * vec4(position, 0.0, 1.0);
        }
    )glsl";
    glShaderSource(vs, 1, &vsSource, nullptr);
    glCompileShader(vs);

    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
    const char* fsSource = R"glsl(
        #version 150
        void main()
        {
            gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
        }
    )glsl";
    glShaderSource(fs, 1, &fsSource, nullptr);
    glCompileShader(fs);

    shader = glCreateProgram();
    glAttachShader(shader, vs);
    glAttachShader(shader, fs);
    glLinkProgram(shader);
}

void UseShader()
{
    glUseProgram(shader);
}

GLuint GetShader()
{
    return shader;
}

P.S. Я заметил, что ошибка возникает после вызова glEnableVertexAttribArray(0) в методе PrepareShapes