Почему освещение не работает (ничего не рисуется)?

У меня был жёлтый 2D треугольник. Я захотел применить обычное освещение к этому треугольнику (без «сильных» бликов). Руководство: https://learnopengl.com/Lighting/Basic-Lighting

• В вершинный буфер я добавил данные нормали, а также изменил VAO
• Рисование происходит методом glDrawArrays; EBO не используется
• Также я отдельно добавил матрицу модели в качестве переменной uniform в шейдеры

Я проверил результат компиляции шейдеров методом glGetError.

После всего, на экране ничего не стало отображаться. Подскажите, как это исправить.

#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>

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600

GLuint shaderProgram;

void draw()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glm::mat4 Projection = glm::perspective(glm::radians(45.0f), (float)WINDOW_WIDTH / (float)WINDOW_HEIGHT, 0.1f, 100.0f);
    glm::mat4 View = glm::lookAt(
        glm::vec3(0, 0, 4),
        glm::vec3(0, 0, 0),
        glm::vec3(0, 1, 0)
    );
    glm::mat4 Model = glm::mat4(1.0f);
    GLuint mvpId = glGetUniformLocation(shaderProgram, "mvp");
    glm::mat4 mvp = Projection * View * Model;
    glUniformMatrix4fv(mvpId, 1, GL_FALSE, &mvp[0][0]);
    GLuint modelId = glGetUniformLocation(shaderProgram, "model");
    glUniformMatrix4fv(modelId, 1, GL_FALSE, &Model[0][0]);

    glEnable(GL_DEPTH_TEST);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glDisable(GL_DEPTH_TEST);
}

int main()
{
    SDL_Init(SDL_INIT_VIDEO);
    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("OpenGL Draw", 100, 100, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL);

    SDL_GLContext context = SDL_GL_CreateContext(window);

    glewExperimental = GL_TRUE;
    glewInit();

    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    float vertices[] =
    {   // position | color | normal
        -0.5f, -0.5f, 0.0f, 1, 1, 0, 0.0f, 0.0f, -1.0f,
        0.0f, 0.5f, 0.0f, 1, 1, 0, 0.0f, 0.0f, -1.0f,
        0.5f, -0.5f, 0.0f, 1, 1, 0, 0.0f, 0.0f, -1.0f,
    };
    GLuint vbo;
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // НЕ ИСПОЛЬЗУЕТСЯ. Применяется метод glDrawArrays
    unsigned int indices[] =
    {
        0, 1, 2,
        2, 3, 0
    };
    GLuint ebo;
    glGenBuffers(1, &ebo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    const char* vertexSource = R"glsl(
        #version 330 core
        in vec3 position;
        in vec3 color;
        in vec3 normal;
        out vec3 Color;
        out vec3 Normal;
        out vec3 FragPos;
        uniform mat4 model;
        uniform mat4 mvp;
        void main()
        {
            Color = color;
            Normal = mat3(transpose(inverse(model))) * normal;
            FragPos = vec3(model * vec4(position, 1.0));
            gl_Position = mvp * vec4(position, 1.0);
        }
    )glsl";
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexSource, NULL);
    glCompileShader(vertexShader);

    const char* fragmentSource = R"glsl(
        #version 330 core
        in vec3 Color;
        in vec3 Normal;
        in vec3 FargPos;
        out vec4 outColor;
        uniform vec3 lightPos;
        void main()
        {
            vec3 lightColor = vec3(1.0, 1.0, 1.0);
            float ambientStrength = 0.1;
            vec3 ambient = ambientStrength * lightColor;
            vec3 norm = normalize(Normal);
            vec3 lightDir = normalize(lightPos - FragPos);
            vec3 diff = max(dot(norm, lightDir), 0.0);
            vec3 diffuse = diff * lightColor;
            vec3 result = (ambient + diffuse) * Color;
            outColor = vec4(result, 1.0);
        }
    )glsl";
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
    glCompileShader(fragmentShader);

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

    GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
    glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(GL_FLOAT), 0);
    glEnableVertexAttribArray(posAttrib);
    GLint colorAttrib = glGetAttribLocation(shaderProgram, "color");
    glVertexAttribPointer(colorAttrib, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(GL_FLOAT), (void*)(3 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(colorAttrib);
    GLint normalAttrib = glGetAttribLocation(shaderProgram, "normal");
    glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 9 * sizeof(GL_FLOAT), (void*)(6 * sizeof(GL_FLOAT)));
    glEnableVertexAttribArray(normalAttrib);

    SDL_Event windowEvent;
    while (true)
    {
        if (SDL_PollEvent(&windowEvent))
        {
            if (windowEvent.type == SDL_QUIT) break;
        }
        else
        {
            draw();
            SDL_GL_SwapWindow(window);
        }
    }
    SDL_GL_DeleteContext(context);
    SDL_Quit();
    return 0;
}