glVertexAttribFormat crashes

I’m trying to create a model class for my project and use one vaos with several vbos to save resources, but I encountered a crash when using the function. Don’t pay attention to the offset values and others mistakes, since I’m just figuring out how to work with them. Just tell me what could be the reason for the crash. VS output this error:

An exception was thrown at address 0x0000000000000000 in gl.exe: 0xC0000005: Execution access violation at address 0x00000000000000000.


Model::Model(const std::string& mtl, const std::string& obj){
    std::ifstream mtlFile;
    std::ifstream objFile;
    catch (std::ifstream::failure& e)
        std::cout << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ: " << e.what() << std::endl;
    materialReader(Materials, mtlFile);
    for (int i = 0; i < Materials.size(); i++)

        Materials[i].diffuse_texture_ID = loadTexture(Materials[i].diffuse_texture.c_str());
        Materials[i].specular_texture_ID = loadTexture(Materials[i].specular_texture.c_str());
    meshReader(Vertices, objFile, Materials);

    glGenVertexArrays(1, &VAO1);
    glGenBuffers(1, &VBO_array[0]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO_array[0]);
    glBufferData(GL_ARRAY_BUFFER, Vertices[0].size() * sizeof(float), &Vertices[0][0], GL_DYNAMIC_DRAW);

    glGenBuffers(1, &VBO_array[1]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO_array[1]);
    glBufferData(GL_ARRAY_BUFFER, Vertices[1].size() * sizeof(float), &Vertices[1][0], GL_DYNAMIC_DRAW);

    glGenBuffers(1, &VBO_array[2]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO_array[2]);
    glBufferData(GL_ARRAY_BUFFER, Vertices[2].size() * sizeof(float), &Vertices[2][0], GL_DYNAMIC_DRAW);
    glVertexAttribFormat(0, 3, GL_FLOAT, GL_FALSE, 0);
    glVertexAttribBinding(0, 0);
    glVertexAttribFormat(1, 3, GL_FLOAT, GL_FALSE, 0);
    glVertexAttribBinding(1, 0);
    glVertexAttribFormat(2, 3, GL_FLOAT, GL_FALSE, 0);
    glVertexAttribBinding(2, 0);

    glDeleteVertexArrays(1, &VAO1);
    for (auto i : VBO_array) { glDeleteBuffers(1, &i); }

void Model::Draw(Shader shader, glm::vec3 cam_position, glm::mat4 matrix)

    shader.setVec3("viewPos", cam_position[0], cam_position[1], cam_position[2]);
    shader.setMat4("matrix", matrix);

    shader.setVec3("light.position", 1.2f, 1.0f, 2.0f);
    shader.setVec3("light.ambient", 0.5f, 0.5f, 0.5f);
    shader.setVec3("light.diffuse", 0.5f, 0.5f, 0.5f);
    shader.setVec3("light.specular", 0.5f, 0.5f, 0.5f);
    shader.setFloat("material.shininess", Materials[0].shininess);


    glBindTexture(GL_TEXTURE_2D, Materials[0].diffuse_texture_ID);
    glBindTexture(GL_TEXTURE_2D, Materials[0].diffuse_texture_ID);

    glBindVertexBuffer(0, VBO_array[0], 0, 3 * sizeof(float));
    glDrawArrays(GL_TRIANGLES, 0, Vertices[0].size());



#ifndef MODEL_H
#define MODEL_H

struct Material {
    std::string materialName;
    std::string diffuse_texture = "C:\\Users\\Gigabyte\\source\\repos\\gl\\textures\\grass.jpg";
    float diffuse_color[3] = { 1.0, 1.0, 1.0 };
    unsigned int diffuse_texture_ID;
    std::string specular_texture = "C:\\Users\\Gigabyte\\source\\repos\\gl\\textures\\grass.jpg";
    float specular_color[3] = { 1.0, 1.0, 1.0 };
    unsigned int specular_texture_ID;
    float shininess = 1.0;

void pathCorrector(std::string& path);

std::vector<std::string> split(std::string& string, char splitter);

unsigned int loadTexture(char const* path);

void materialReader(std::vector<Material>& Materials, std::ifstream& mtlFile);

void meshReader(std::vector<std::vector<float>>& vertices, std::ifstream& in, std::vector<Material>& Materials);

class Model {

    std::vector<Material> Materials;
    std::vector<std::vector<float>> Vertices;
    std::vector<unsigned int>  VBO_array;
    unsigned int VAO1;

    Model(const std::string& mtl, const std::string& obj);


    void Draw(Shader shader, glm::vec3 cam_position, glm::mat4 matrix);

there could be many reasons for this, i would first of all try go through a debugger and see the values of all your buffers and memory to make sure none of them are null. secondly you are using glVertexAttribBinding however you haven’t attached any of the vertex buffers using glBindVertexBuffer() or glVertexArrayVertexBuffer() (dsa version) this means that you are setting up a vertex attrib binding without a valid vertex buffer attached to any of the binding index’s. which means that its trying to access null and hence you get a access violation at null.

This implies that you’re calling a function via a null function pointer (i.e. jumping to address zero in the code segment).

glVertexAttribFormat requires OpenGL 4.3 or the ARB_vertex_attrib_binding extension. Have you checked that the implementation supports it? If it doesn’t, the function pointer will typically be null (at least on Windows; on Unix/X11, you’ll typically get a non-null pointer to a stub function which fails when you call it).