C++ - Qt Framework - Using OpenGL VAO and VBO to handle 2 different objects on the scene

VAO (Vertex Array Object) and VBO (Vertex Buffer Object) were introduced to help programmers since OpenGL 3.0.

So it’s not a recent features but if you just started learning OpenGL it could be very complex to understand.

Furthermore if you are learning OpenGL and want to use it with Qt together, it becomes a real nightmare.

So what are these vertex objects and how to use them to manage two different objects on the scene?

Let’s see that in this VAO and VBO tutorial for Qt.

First of all

We are going to use the QWindow class (to display a window) and the QOpenGLFunctions class (to retrieve the OpenGL classic functions).

The BadprogOpenGLWindow will inherit from these two classes.

So all the basics Qt and OpenGL mechanisms will be do in this class.

Then, in the BadprogDisplay class, we are going to use our famous VAO and VBO through only two methods:

• initialize();
• render().

The former will be called only once (it’s an "init" method).

The latter will be called for each new frame displayed (so all the time).

In the initialize() we’ll create:

• 1 program;
• 2 VAOs;
• 4 VBOs (2 for each VAO).

And we'll allocate the memory (in this method) for the VAO1's VBO1 and VBO2  and the VAO2's VBO1 only.

Indeed the VBO2 (of the VAO2) is the color array and we want to change this color each second, so it'll be allocated in the render() method.

So one of the most important thing to understand is that a VAO is a manager.

What does it mean?

It means that a VAO will take a global value and set it as the current value.

This is hidden to the user, don’t worry about that, OpenGL knows how it works.

But before that we have to create a program then 2 shaders.

These shaders are then linked by the program.

Once again don't worry about that it's the OpenGL intrinsec mechanism.

So after the program created, with the QOpenGLShaderProgram class and the shaders linked, we'll be ready to create our first VAO.

Using Qt classes with OpenGL is quite different from the classic OpenGL functions but the final is the same.

With Qt, a VAO is a QOpenGLVertexArrayObject class.

And to create it simply call the create() method like this :

• _vao1.create().

It’s also necessary to call the bind() one:

• _vao1.bind().

This bind() method is a way to say to OpenGL "Hey OpenGL, I’m a VAO and I’m taking the lead, so all the next VBOs will be mine".

It means that the VBOs, that we are setting just after the VAO1 binding, will be part of this VAO1.

Indeed we don’t need to specify for each VBO which VAO they belong to.

Why?

Because OpenGL works as a state machine, you can’t use several VAO a the same time, it’s only one by one.

So if you want ot use the VAO1, you have to bind it.

If you want ot use the VAO2 you’ll have to bind it (but at this moment VAO1 won't be available anymore).

To clarify this we use the release() method at the end of each VAO:

• _vao1.release().

But this release() method isn’t really necessary because each time we call a bind() the last bind() is automatically released.

It’s somehow clearer to use it.

Regarding shaders, we have a Vertex shader and a Fragment shader simpliest as we could do.

Nothing special about that.

Except maybe the size of the point that we set it to 40.

So what are the final display?

We should have a first object (our VAO1) represented by 3 points of 3 different colors on the left of the scene.

Then on the right a triangle with a changing color that will be our VAO2.

Note that VAO1 shows 3 points, it’s because we set the glDrawArrays() function to GL_POINTS.

Changing this parameter with GL_TRIANGLES will display a triangle instead.

Let’s code a bit.

BadprogOpenGLWithQt_1.pro

###############################################################################


QT       += core gui


greaterThan(QT_MAJOR_VERSION, 4): QT += widgets


# badprog.com


CONFIG += c++11


DEFINES += QT_DEPRECATED_WARNINGS


SOURCES += \

    badprogDisplay.cpp \

    badprogOpenGLWindow.cpp \

    main.cpp


HEADERS += \

    badprogDisplay.h \

    badprogOpenGLWindow.h


RESOURCES += \

    badprog.qrc

badprog.qrc

<!DOCTYPE RCC>

<RCC version="1.0">


<qresource>

    <file alias="shader_vertex">shader/vertex1.glsl</file>

    <file alias="shader_fragment">shader/fragment1.glsl</file>

</qresource>


</RCC>

badprogDisplay.cpp

badprogDisplay.h

badprogOpenGLWindow.cpp

badprogOpenGLWindow.h

main.cpp

For the shaders, just create a shader/ directory at the project root.

shader/fragment1.glsl

shader/vertex1.glsl

Conclusion

Setting up Qt, OpenGL, VAO, VBO and shaders wasn't an easy task.

You are now ready to create plenty of new objects on your scene.

Congratulations if you succeeded.