QT Managing OpenGL context in a separate thread

Question

I have learned about setting up separate rendering thread for Qt QGLWidget here ,here and here . I also managed to get a kind of "working" setup: clearing color in the viewport.Seems to be ok.But I am getting the following warning:

QOpenGLContext::swapBuffers() called with non-exposed window, behavior is undefined

I first create a widget that inherits from QGLWidget.Where I also setup OpenGL Format:

In the Widget constructor:

  QGLFormat format;
  format.setProfile(QGLFormat::CompatibilityProfile);
  format.setVersion(4,3);
  format.setDoubleBuffer(true);
  format.setSwapInterval(1);

  setFormat(format);
  setAutoBufferSwap(false);

Then I init the rendering thread in the same Widget:

void GLThreadedWidget::initRenderThread(void){
   doneCurrent();
    context()->moveToThread(&m_renderThread);
    m_renderThread.start();
}

and from that point the whole rendering is done inside that thread:

RenderThread constructor:

RenderThread::RenderThread(GLThreadedWidget *parent)
    :QThread(),glWidget(parent)
{
    doRendering = true;
}

RenderThread run() method:

    void RenderThread::run(){
         glWidget->makeCurrent();

         GLenum err = glewInit();
         if (GLEW_OK != err) {
             printf("GLEW error: %s\n", glewGetErrorString(err));
         } else {
             printf("Glew loaded; using version %s\n", glewGetString(GLEW_VERSION));
         }
          glInit();
         while (doRendering){
             glWidget->makeCurrent();
             glClear(GL_COLOR_BUFFER_BIT );

             paintGL(); // render actual frame


            glWidget->swapBuffers();
            glWidget->doneCurrent();
            msleep(16);
        }

    }

Anyone can point out where is the issue?And if that message can be discarded? Also a straightforward and concise explanation on render thread setup in Qt would be extremely helpful.Using Qt 5.2 (Desktop OpenGL build)

Answer 1

A QOpenglWidget comes with its own context. If you want a background thread to do the rendering, you have to pass a shared context to the thread and do a few steps correct. Details in: https://stackoverflow.com/a/50368372/3082081

Answer 2

With what you've shown, it looks like that message handler warning you were getting was because you started triggering buffer swaps "too soon" in the window setup sequence, either directly through QGLContext::/QOpenGLContext::swapBuffers() or indirectly through a number of possible ways, none of which are really detectable outside of manual debugging. What I mean by too soon is before the widget's parent window was marked "exposed" (before it was being displayed by the windowing system).

As far as whether the message can be discarded, it can...but it's not safe to do, as in it's possible to get undefined behavior for the 1st few frames or so where you do it and the window's not ready (especially if you're immediately resizing to different extents at startup than your .ui file specifies). Qt documentation says that before your window's exposed, Qt has to basically tell OpenGL to paint according to what are effectively non-trustworthy extents. I'm not sure that's all that can happen though personally.

With the code you showed, there's an easy fix--avoid even starting your render logic until your window says it's exposed. Detecting exposure using QGLWidget isn't obvious though. Here's an example roughly like what I use, assuming your subclass from QGLWidget was something like 'OGLRocksWidget', it was a child of a central widget, and that central widget was a child of your implementation of QMainWindow (so that your widget would have to call parentWidget()->parentWidget() to get at its QMainWindow):

OGLRocksWidget::paintGL()
{
    QMainWindow *window_ptr = 
        dynamic_cast<QMainWindow *>(parentWidget() ? parentWidget()->parentWidget() : 0);
    QWindow *qwindow_ptr = (window_ptr ? window_ptr->windowHandle() : 0);

    if (qwindow_ptr && qwindow_ptr->isExposed())
    {
        // don't start rendering until you can get in here, just return...
        // probably even better to make sure QGLWidget::isVisible() too
    }
}

Of course you don't have to do this in your implementation of QGLWidget::paintGL(), but in your particular setup you're better off not even starting your render thread until your window tells you it's exposed.

It looks like you have might have slightly bigger problems than that though. You weren't hooking the right GL activity into the right places in your code vs QGLWidget's intent. I feel for the position you were in because the documentation on this is a little spotty and scattered. For that part, QGLWidget's detailed description down where it says "Here is a rough outline of how a QGLWidget subclass might look" is a good place to start getting the idea. You'll want to override any of the key virtuals in there that you have related code for and move them into those calls.

So for example, your widget's constructor is doing setup work that is probably safer to put in an initializeGL() override, since QGLWidget's intent is to signal you when it's safely time to do that through that call. What I mean by safer whenever I say that here is that you won't get seemingly random debug exceptions (that in release builds can silently wreak havok on your runtime stability).

Side advice: install Qt source, point your debugger at it, and watch your code run, including into Qt. Your setFormat() call, last time I watched it, actually deletes the current underlying QOpenGLContext. That's probably good to know because you'll want to create a new one soon after or at least test out your options.

The risk of instability is why I'm trying to put together at least some kind of answer here a year later. I just learned this through a lot (too much) debugging. I love what the Qt team's done with it, but Qt will be much better off when they finish migrating everything over to QOpenGL* calls (or wherever they see a final proper place for their OpenGL support including permanent considerations for it and windowing support together).