Resolving OpenGL functions using glew in QT - qt

Question

Its been 17 days I'm struggling to write a simple program in OpenGL using QT, but all tutorials searched on Google are failed.
I'v compiled my QT 5.0.1 with -opengl desktop using msvc2010 to make desktop opengl default.
I'v read tutorial by Sean Harmer, but it is depended on QT to resolve opengl functions.
According to some people, it is not possible to use glew in QT, as QT's built in libraries prevent glew from including its headers, but according to Sean Harmer HERE , it is possible (but it is not explained there how).
Even using QGLWidget I'm not able to use OpenGL extensions.
Now all I want is to use all OpenGL functions separate and all windowing functions from QT separate, i.e. no interference in OpenGL by QT.
If anybody explain me the procedure with simple triangle example and using any extension, I'l be so thankful..
I'v used glew library in my project and #included glew.h in very start of my program, but when compiled it gives error:
glwidget.obj:-1: error: LNK2001: unresolved external symbol imp__glewGenVertexArrays
My .pro file
QT += core gui opengl
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
TARGET = Trial
TEMPLATE = app
SOURCES += main.cpp\
mainwindow.cpp \
glwidget.cpp
HEADERS += mainwindow.h \
glwidget.h
FORMS += mainwindow.ui
RESOURCES += \
resources.qrc
win32: LIBS += -L$$PWD/../../../../../OpenGL/glew-1.9.0/lib/ -lglew32s
INCLUDEPATH += $$PWD/../../../../../OpenGL/glew-1.9.0/include
DEPENDPATH += $$PWD/../../../../../OpenGL/glew-1.9.0/include
win32: PRE_TARGETDEPS += $$PWD/../../../../../OpenGL/glew-1.9.0/lib/glew32s.lib
Output by glewInfo :
GLEW version 1.9.0
Reporting capabilities of pixelformat 1
Running on a GeForce GT 540M/PCIe/SSE2 from NVIDIA Corporation
OpenGL version 4.3.0 is supported
void GLWidget::initializeGL()
{
GLenum err = glewInit();
if(err != GLEW_OK)
{
printf("%s",glewGetErrorString(err));
}
glEnable(GL_DEPTH_TEST);
qglClearColor(QColor(Qt::red));
shaderProgram.addShaderFromSourceFile(QGLShader::Vertex, ":/vertexShader.vsh");
shaderProgram.addShaderFromSourceFile(QGLShader::Fragment, ":/fragmentShader.fsh");
shaderProgram.link();
shaderProgram.bind();
const GLubyte *oglVersion = glGetString(GL_VERSION);
printf( "%s\n",oglVersion );
GLfloat vertices[3][3] ={{ -0.5, -0.5, -1 },
{ 0, 0.5, -1},
{ 0.5, -0.5, -1}};
vertexArray.create();
vertexArray.setUsagePattern(QOpenGLBuffer::StaticDraw);
vertexArray.allocate( vertices, 3 * 3 * sizeof( GLfloat ) );
vertexArray.bind();
shaderProgram.setAttributeBuffer( "vVertex", GL_FLOAT, 0, 3 );
shaderProgram.enableAttributeArray( "vVertex" );
GLuint arr[5];
glGenBuffers(5,arr);
}

Answer 1

All problems solved now.
First problem was : QT 5.0.1 does not support opengl by default.
You have to compile it with -opengl desktop.
Here is tutorial on how to compile QT with vs2010.
Or you can download new opengl build from QT.
Second problem in adding glew libraries to project.
If you add glew32s.lib (static) then you have to add "#define GLEW_STATIC" before "#include "
It is advised to use glew32.lib (dynamic).
Third problem was segment fault on some opengl functions even if your GPU supports version 4.3.
GLEW obtains information on the supported extensions from the graphics driver. Experimental or pre-release drivers, however, might not report every available extension through the standard mechanism, in which case GLEW will report it unsupported. To circumvent this situation, the glewExperimental global switch can be turned on by setting it to GL_TRUE before calling glewInit(), which ensures that all extensions with valid entry points will be exposed.
Took 18 days to solve these problems, glad now can start actual programming.

Answer 2

Following code compiles just FINE on MSVC2008 express, qt 4.8.1 and glew version 1.7.0
main.cpp:
#include <GL/glew.h>
#include <QApplication>
#include <QGLWidget>
int main(int argc, char** argv){
glewInit();//<<-- glew function
QApplication app(argc, argv);
QGLWidget widget;
GLuint arr;
glGenVertexArrays(1, &arr);//<--no linker error (added just for testing, most likely won't gen arrays)
widget.show();
return app.exec();
}
gltest.pro:
TEMPLATE = app
TARGET =
DEPENDPATH += .
INCLUDEPATH += . d:/c++/libs/include
LIBS += -L"d:/c++/libs/lib" -lglew32
CONFIG += console
QT += opengl
# Input
SOURCES += main.cpp
I assume that with Qt 5 situation won't be any different.
Feel free to override QGLWidget's paintGL and draw whatever you want using extensions. I don't have a code snippet nearby for that.
Suggestions:
1. Use precompiled binaries.
2. It might make sense to use dynamically-linked version of glew.
3. Notice header inclusion order.
According to some people
People say many things, you don't need to believe all of them.

Answer 3

I would like to share my latest finding about how to make Qt and glew work together on the (currently) latest Windows environments (Qt 5.15.1 + QMake + MSVC 2019 + glew 2.1.0). Hope someone else an avoid spending countless hours on this like me. Here are what I did:
Copy glew32.dll and glew32.lib to somewhere in your project directory. Make sure to the bitness of glew matches with the bitness of the executable you told Qt to build. I did not use the static version of the library because I failed to make that work.
In your .pro (QMake) file, write something like this:
GLEW_INCLUDE_PATH = "$$PWD/ext/glew/include" # put glew headers here
GLEW_LIB_PATH = "$$PWD/ext/glew/x64" # put glew32.dll and glew32.lib here
LIBS += -L$$GLEW_LIB_PATH -lglew32 -lglu32 -lopengl32
DEPENDPATH += .
INCLUDEPATH += $$GLEW_INCLUDE_PATH
The only difference I made compared to the previous answers is that I added -lglu32 and -lopengl32 to the link arguments. It seems that they are mandatory on Windows, othewise MSVC will complain about some link errors with OpenGL API functions.
Additionally, try using QOpenGLWidget instead of QGLWidget. QGLWidget caused some weird OpenGL "Invalid Operation" errors when my program is exiting and trying to destroy OpenGL handles such as buffer and texture handles in destructors. glIntercept showed me that it is because wgl context was destroyed before the handles get released. Switching to QOpenGLWidget solved this problem completely.
Hope you can enjoy using glew with Qt now!