Using GLEW with Qt 5.x - c++

Question

I am currently trying to get a Qt 5 window and QOpenGLContext working with GLEW. Yeah, I know Qt 5 provides its own function wrappings for OpenGL, but since my rendering engine relies on GLEW and supports other window libraries as well, Qt's built-in stuff is not an option.
Now, here is what I got up and running so far:
I sub-classed QWindow and equipped it with a QOpenGLContext. The context is initialized successfully.
After initializing QOpenGLContext, I (again successfully) call glewInit() to initialize GLEW.
I am now able to render geometry to the default framebuffer in the exact same way as I do it for other window frameworks (GLFW, to be more precise).
Here comes the tricky part: I am using one of OpenGL's uniform buffer objects to transfer light data to the GPU. As soon as I call glBufferData() to initially fill it, I get a segmentation fault. When using my GLFW-based implementation and context initialization, everything works fine. I know that this kind of behavior can be expected for insufficiently initialized OpenGL contexts, but again, setting up QOpenGLContext and calling glewInit() seems to work just fine.
Here is some code to show what I'm trying to do...
QtWindow::QtWindow(QWindow *parent)
: QWindow(parent) {
setSurfaceType(QWindow::OpenGLSurface);
QSurfaceFormat format;
format.setVersion(4,5);
format.setOption(QSurfaceFormat::DeprecatedFunctions);
format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
format.setProfile(QSurfaceFormat::CoreProfile);
setFormat(format);
}
This should be sufficient to later on get a context of the format I desire. Now, just before the first frame is rendered, I set up the context and GLEW...
void QtWindow::init_context() {
if (!initialized_) {
context_handler_.init(this);
initialized_ = true;
glewExperimental = GL_TRUE;
auto e = glewInit();
if (e != GLEW_OK) {
std::cout << "Failed to initialize glew: "
<< glewGetErrorString(e) << std::endl;
}
glGetError();
}
}
I use a small helper class for initializing QOpenGLContext as I need to prevent Qt from un-defining GLEW macros:
void QtContextHandler::init(QWindow* parent) {
if (!qt_context_) {
qt_context_ = new QOpenGLContext(parent);
qt_context_->setFormat(parent->requestedFormat());
if (qt_context_->create()) {
auto format(qt_context_->format());
std::cout << "Initialized Qt OpenGL context "
<< format.majorVersion() << "."
<< format.minorVersion() << " successfully."
<< std::endl;
qt_context_->makeCurrent(parent);
} else {
std::cout << "Failed to initialize Qt OpenGL context!"
<< std::endl;
}
}
}
Here is what I do for setting up the light UBO and what crashes when OpenGL is initialized as shown above. I am using oglplus as a GL wrapper, but since it wraps OpenGL's functions quite tightly, you should get the idea:
ubo_.Bind(ogl::Buffer::Target::Uniform);
oglplus::Buffer::Data(oglplus::Buffer::Target::Uniform, sizeof(data), &data, oglplus::BufferUsage::DynamicDraw);
Has anyone tried similar approaches and can share their experience? I would appreciate any help since I'm stuck trying to figure out what I am doing wrong. Again: The initialization seems to run smoothly and I am even able to create VBOs/VAOs/IBOs for rendering meshes! Only creating the UBO causes a segmentation fault.
EDIT:
Okay, here are some new insights. First of all, the segmentation fault only occurs if the uploaded data exceeds a certain size (~90 bytes). In other words, I can render a scene with the Qt-created context using exactly one custom light source. When querying GL_MAX_UNIFORM_BLOCK_SIZE though, the driver tells me that 64KB are available for uniform blocks (the same holds for GLFW-created contexts). Does anyone have an idea on what could possibly go wrong?

Answer 1

Okay, just in case anyone encounters similar difficulties: I managed to get it working by uploading the UBO data using glBufferStorage instead of glBufferData. The former is used for creating buffers of immutable size, which is sufficient for my purposes. Still, I don't know what went wrong with glBufferData and whether it is a bug in Qt or I initialized the context incorrectly.