Не рендерится координатная ось

решил код функции main "запихнуть" по классам, но рендеринг перестал работать. Если можете сказать в чем проблема, буду очень благодарен. Пытаюсь просто отрендерить две оси координат. Раньше инициализация всех буферов, массив с координатами располагался выше главного цикла приложения, не было класса Shaderи вся работа с шейдерам тоже была выше этого цикла, модельная матрица, которая передается в вертексный шейдер посредством uniform mat4 model - аналогично. Буду благодарен за любую помощь и комментарии. Заранее спасибо.

Object.hpp

#pragma once
class Object
{
public:
    virtual void        draw() = 0;
};

ModelTransform.hpp

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

struct ModelTransform
{
    glm::vec3           position;
    glm::vec3           rotation;
    glm::vec3           scale;
};

CoordAxis.hpp

#pragma once

#include "../Object/Object.hpp"
#include "../ModelTransform/ModelTransform.hpp"

class CoordAxis: public Object
{
    float*              coordAxisVertexes;
    const int           amountOfVertexes = 4;
    const int           amountOfPointsInOneVertex = 6;
    glm::mat4           modelMatrix;
    unsigned int        vertexBufferObject;
    unsigned int        vertexArrayObject;
    ModelTransform      transformMatrix;
public:
                        CoordAxis();
                        ~CoordAxis();
    void                draw()      override;
    glm::mat4&          getModelMatrix();
};

CoordAxis.cpp

#include <glad/glad.h>
#include "CoordAxis.h"

CoordAxis::CoordAxis()
{
    transformMatrix = {

        glm::vec3(0.0f, 0.0f, 0.0f),
        glm::vec3(0.0f, 0.0f, 0.0f),
        glm::vec3(1.0f, 1.0f, 1.0f)

    };

    modelMatrix = glm::mat4(1.0f);
    modelMatrix = glm::translate(modelMatrix, glm::vec3(transformMatrix.position));
    modelMatrix = glm::scale(modelMatrix, transformMatrix.scale);

    coordAxisVertexes = new float[amountOfVertexes * amountOfPointsInOneVertex] {
        //position          //color
        -1.0f, 0.0f,0.0f,   0.0f, 0.0f, 1.0f,
         1.0f, 0.0f,0.0f,   0.0f, 0.0f, 1.0f,
         0.0f, 1.0f,0.0f,   0.0f, 0.0f, 1.0f,
         0.0f,-1.0f,0.0f,   0.0f, 0.0f, 1.0f

    };

    glGenBuffers(1, &vertexBufferObject);
    glGenBuffers(1, &vertexArrayObject);
    glBindVertexArray(vertexArrayObject);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * amountOfPointsInOneVertex * amountOfVertexes, coordAxisVertexes, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, amountOfPointsInOneVertex * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, amountOfPointsInOneVertex * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);
}

CoordAxis::~CoordAxis()
{
    delete[] coordAxisVertexes;
}

void CoordAxis::draw()
{
    glBindVertexArray(vertexArrayObject);
    glDrawArrays(GL_LINES, 0, 4);
}

glm::mat4& CoordAxis::getModelMatrix()
{
    return modelMatrix;
}

Shader.h

#pragma once

#include <glad/glad.h>
#include <glm/glm.hpp>
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>

class Shader
{

    unsigned int    programID;
    void            checkCompileErrors(unsigned int shader, std::string type);

public:
                    Shader(const char* vertexPath, const char* fragmentPath);
                    ~Shader();
    void            use();
    void            setBool(const std::string& name, bool value) const;
    void            setInt(const std::string& name, int value) const;
    void            setFloat(const std::string& name, float value) const;
    void            setFloatVec(const std::string& name, float* vec, int vec_size) const;
    void            setVec3(const std::string& name, glm::vec3 vec) const;
    void            setVec4(const std::string& name, glm::vec4 vec) const;
    void            setMatrix4F(const std::string& name, glm::mat4& m);
    unsigned int    ID();
};

Shader.cpp

#include "Shader.h"
#include <glm/gtc/type_ptr.hpp>

unsigned int Shader::ID() {
    return programID;
}

Shader::Shader(const char* vertexPath, const char* fragmentPath) {
    const char* vShaderCode;
    const char* fShaderCode;

    std::string vTempString;
    std::string fTempString;

    std::ifstream vShaderFile;
    std::ifstream fShaderFile;

    vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);

    try {
        std::stringstream vShaderStream;
        vShaderFile.open(vertexPath);
        vShaderStream << vShaderFile.rdbuf();
        vShaderFile.close();
        vTempString = vShaderStream.str();
        vShaderCode = vTempString.c_str();

        std::stringstream fShaderStream;
        fShaderFile.open(fragmentPath);
        fShaderStream << fShaderFile.rdbuf();
        fShaderFile.close();
        fTempString = fShaderStream.str();
        fShaderCode = fTempString.c_str();
    }
    catch (std::ifstream::failure& e) {
        std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ\n" << std::endl;
        std::cout << e.what() << "\n";
    }

    unsigned int vertex;
    vertex = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex, 1, &vShaderCode, NULL); // Подключаем к шейдеру исходный код
    glCompileShader(vertex);
    checkCompileErrors(vertex, "VERTEX");

    unsigned int fragment;
    fragment = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment, 1, &fShaderCode, NULL);
    glCompileShader(fragment);
    checkCompileErrors(fragment, "FRAGMENT");

    programID = glCreateProgram();
    glAttachShader(programID, vertex); // Компилируем шейдеры
    glAttachShader(programID, fragment);
    glLinkProgram(programID);
    checkCompileErrors(programID, "PROGRAM");

    glDeleteShader(vertex);
    glDeleteShader(fragment);
}

Shader::~Shader() {
    glDeleteProgram(programID);
}

void Shader::use() {
    glUseProgram(programID);
}

void Shader::setBool(const std::string& name, bool value) const {
    glUniform1i(glGetUniformLocation(programID, name.c_str()), (int)value);
}

void Shader::setInt(const std::string& name, int value) const {
    glUniform1i(glGetUniformLocation(programID, name.c_str()), value);
}

void Shader::setFloat(const std::string& name, float value) const {
    glUniform1f(glGetUniformLocation(programID, name.c_str()), value);
}

void Shader::setFloatVec(const std::string& name, float* vec, int vec_size) const {
    switch (vec_size) {
    case 1: glUniform1f(glGetUniformLocation(programID, name.c_str()), vec[0]); break;
    case 2: glUniform2f(glGetUniformLocation(programID, name.c_str()), vec[0], vec[1]); break;
    case 3: glUniform3f(glGetUniformLocation(programID, name.c_str()), vec[0], vec[1], vec[2]); break;
    case 4: glUniform4f(glGetUniformLocation(programID, name.c_str()), vec[0], vec[1], vec[2], vec[3]); break;
    default:
        std::cout << "SHADEL FAIL! NO SUCH UNIFORM VECTOR SIZE!" << std::endl;
    }
}

void Shader::setVec3(const std::string& name, glm::vec3 vec) const
{
    glUniform3f(glGetUniformLocation(programID, name.c_str()), vec[0], vec[1], vec[2]);

}

void Shader::setVec4(const std::string& name, glm::vec4 vec) const
{
    glUniform4f(glGetUniformLocation(programID, name.c_str()), vec[0], vec[1], vec[2], vec[3]);
}

void Shader::setMatrix4F(const std::string& name, glm::mat4& m) {
    glUniformMatrix4fv(glGetUniformLocation(programID, name.c_str()), 1, GL_FALSE, glm::value_ptr(m));
}

void Shader::checkCompileErrors(unsigned int shader, std::string type) {
    int success;
    char infoLog[1024];
    if (type != "PROGRAM") {
        glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(shader, 1024, NULL, infoLog);
            std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n";
        }
    }
    else {
        glGetProgramiv(shader, GL_LINK_STATUS, &success);
        if (!success) {
            glGetShaderInfoLog(shader, 1024, NULL, infoLog);
            std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n";
        }
    }
}

main.cpp

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include "CoordAxis/CoordAxis.h"
#include "Shader/Shader.h"
int main()
{
    setlocale(LC_ALL, "ru");

    #pragma region GLFW_INITIALIZE
    if (!glfwInit())
    {
        std::cout << "Ошибка при инициализации GLFW...\nВыход.\n";
        glfwTerminate();
        return -1;
    }
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#pragma endregion

    #pragma region CREATE_WINDOW
    GLFWwindow* window = glfwCreateWindow(800, 800, "The movement of the puck through the tunnel", nullptr, nullptr);
    if (window == nullptr)
    {
        std::cout << "Ошибка при создании окна...\nВыход.\n";
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
#pragma endregion

    #pragma region GLAD_INITIALIZE
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Ошибка при загрузке функций GLAD...\nВыход.\n";
        glfwTerminate();
        return -1;
    }
#pragma endregion

    glViewport(0, 0, 800, 800);

    CoordAxis axis;
    Shader* shader = new Shader("source\\shaders\\basic.vert", "source\\shaders\\basic.frag");

    while (!glfwWindowShouldClose(window))
    {

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        shader->use();

        shader->setMatrix4F("model", axis.getModelMatrix());

        axis.draw();

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}

Сами шейдеры: basic.vert

#version 330 core

layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 inColor;

out vec3 fragColor;
uniform mat4 model;

void main() 
{   gl_Position = model*vec4(aPos, 1.0f); 
    fragColor = inColor; 
}

basic.frag

#version 330 core

in vec3 fragColor;
out vec4 outColor;

void main() 
{
    outColor = vec4(fragColor, 1.0f);
}

Структура моего проекта: