Vertex array issue with classes

Question

I'm learning openGL programming from tutorials of Chernov @ sparky engine on youtube. currently I have a vertex & a fragment shader with required classes for window ,shader etc management. I can use single vertex array object to draw on screen but when the same is done by creating a vertexArray class , it fails. vertex array class :

#include"vertexArray.h"
 namespace graphics{
VertexArray::VertexArray(){
    glGenVertexArrays(1,&arrayID);

}
void VertexArray::addBuffer(Buffer* buffer, GLint index){
    bind();

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, arrayID);
    glEnableVertexAttribArray(index);
    glVertexAttribPointer(index, buffer->getComCount(), GL_FLOAT, GL_FALSE, 0, 0);


}
void VertexArray::bind() const{
    glBindVertexArray(arrayID);
}
void VertexArray::unbind() const{
    glBindVertexArray(0);
}
VertexArray::~VertexArray(){
}
}

my main.cpp file

    #include"graphics\window.h"
    #include"utils\reader.h"
    #include"graphics\shader.h"
    #include"math\vec.h"
    #include"math\mat4.h"
    #include"graphics\buffers\buffer.h"
    #include"graphics\buffers\indexbuffer.h"
    #include"graphics\buffers\vertexArray.h"
    using namespace graphics;
    using namespace utils;
    using namespace math;
    int main(){
        Window window;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glClearColor(0, 0, 0, 1);
        Reader read1("src/shaders/test.vert");
        Reader read2("src/shaders/test.frag");
        char * r1 = read1.getData();
        char * r2 = read2.getData();

        GLfloat vert[] = {
            0, 0, 0, 
            0, 3, 0, 
            8, 0, 0, 
            8, 3, 0, 
        };
        Buffer* vbo = new Buffer(vert,4*3,3);

        GLushort indices[] = { 
            0,1,2, 
            1,3,2
        };
        indexBuffer ibo(indices,6);

        Shader shader(r1, r2);
        shader.enable();
    #if 0
        GLuint sprite1;
        glGenVertexArrays(1, &sprite1);
        glBindVertexArray(sprite1);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sprite1);
        vbo->bind();
        glVertexAttribPointer(0, vbo->getComCount(), GL_FLOAT, 0, 0, 0);
        shader.setUniformMat4("pr_matrix", mat4::orthographic(0.0f, 16.0f, 0.0f, 9.0f, -1.0f, 1.0f));
        shader.setUniformMat4("ml_matrix", mat4::translation(vec3(0, 0, 0)));
        shader.setUniform2f("light_pos", vec2(8.0f, 4.5f));
        shader.setUniform4f("colour", vec4(0.2, 0.0, 0.4, 1));
        glEnableVertexAttribArray(0);
        glBindVertexArray(0);

        GLuint sprite2;
        glGenVertexArrays(1, &sprite2);
        glBindVertexArray(sprite2);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sprite2);
        vbo->bind();
        glVertexAttribPointer(5, vbo->getComCount(), GL_FLOAT, 0, 0, 0);
        shader.setUniformMat4("pr_matrix", mat4::orthographic(0.0f, 16.0f, 0.0f, 9.0f, -1.0f, 1.0f));
        shader.setUniformMat4("ml_matrix", mat4::translation(vec3(4, 3, 0)));
        shader.setUniform2f("light_pos", vec2(8.0f, 4.5f));
        shader.setUniform4f("colour", vec4(0.3, 0.0, 0.2, 1));
        glEnableVertexAttribArray(0);
        glBindVertexArray(0);
    #endif
        VertexArray vao;
        vao.addBuffer(vbo, 0);

        while (!window.closed()){

    #if 0 
            window.clear();

            glDrawArrays(GL_TRIANGLES, 0,6);
    #endif
            double x, y;
            x = window.getX();
            y = window.getY();

            vao.bind();
            ibo.bind();
            shader.setUniform2f("light_pos", vec2((float) (x*16.0f/960.0f)  , (float) (9- 9*y/540.0f)));

            glDrawElements(GL_TRIANGLES, ibo.getCount(), GL_UNSIGNED_SHORT, 0);
            window.update();

            vao.unbind();
            ibo.unbind();
        }
        return 0;
    }

Please note that Everything works if I just create a vertex array to an GLuint variable in the main & use it . I cant seem to find the issue here. Any help is highly appreciated ..

Answer 1

You have to bind the data to the buffer (See glBufferData).

Vertex attribute buffers can be created like this:

 GLfloat vert[] = {
    0, 0, 0, 
    0, 3, 0, 
    8, 0, 0, 
    8, 3, 0, 
};

GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*3*4, vert, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);

Element buffers can be created like this:

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

GLuint ibo;
glGenBuffers(1, &ibo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort)*3*2, indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

A Vertex Array Object and the vertex attribute pointers are specified like this:

GLuint attr_index = 0; // attribute index according to the shader program

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

glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(attr_index , 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(attr_index );

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

glBindVertexArray( 0 );
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

Note, a Vertex Array Object stores all the information which you specify about the vertex attributes (format, size, attribute index ...) and it refers to the element array buffer.

Finally you can draw the mesh like this:

glBindVertexArray( vao );
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
glBindVertexArray( 0 );