Interactions between Onscreen and Offscreen rendering in Qt5 with QOpenGL\* classes

Question

Objective:

To make some onscreen and offscreen rendering via Qt5 OpenGL framework, such that the resources can be easily shared between both rendering parts. Specifically,

• the rendering work is done through the offscreen part (the framebuffer might be larger than the display screen);
• the results of the offscreen rendering can be displayed in multiple onscreen parts (say, QOpenGLWidgets) under different settings, e.g. different sizes, for simplicity;
• the results of the offscreen rendering can also be extracted from GPU and saved into a QImage or cv::Mat object;
• the above tasks can be executed asynchronously (doing the second offscreen rendering, while displaying or extracting the first offscreen result).

Current solution:

Since I don't know how to share resources between both parts, the actual rendering work are done redundantly in both parts in my current solution:

The onscreen part:

• A QMainWindow containing multiple QOpenGLWidget (subclass of QOpenGLWidget) objects;

The offscreen part:

• A custom class involving members of QOffscreenSurface, QOpenGLContext, and QOpenGLFramebufferObject pointers, as well as a QOpenGLFunctions pointer to invoke OpenGL functions do the actual rendering work, much similar to this link.

The actual renderer:

• As the reason above, the actual rendering work is extracted into a seperated class and both parts (onscreen and offscreen) have its handle.

Questions:

There are two QOpenGLContexts:

• When doing the offscreen work in a background thread (for asynchronously rendering), it says the QWindow-based QOffscreenSurface are not allowed to exist outside the gui thread;
• When doing this in the main (GUI) thread, it says the QOpenGLContext is invalid.

So my questions are:

• Should I do the offscreen and onscreen work in the same GUI thread or not?
• What is the best way of communicating and sharing resources between the offscreen and onscreen parts?

A brief actual code example doing a simple rendering work (say, draw a triangle via shading language) will be much appreciated.

Answer 1

Assuming that QOpenGLContext *main_ctx is the context that was created by QOpenGLWidget for actual rendering, you can create another context ctx in any thread and make it share textures and buffers with the first one:

ctx = std::make_unique<QOpenGLContext>();
ctx->setFormat(main_ctx->format());
ctx->setShareContext(main_ctx);
ctx->create();

I don't think that QOffscreenSurface must be a QWindow-based.

offscreen_surface = std::make_unique<QOffscreenSurface>();
offscreen_surface->setFormat(ctx->format());
offscreen_surface->create();
ctx->makeCurrent(offscreen_surface);

Then create a QOpenGLFramebufferObject and render into it from the second context (second thread).

Then use its texture in the main context: glBindTexture(GL_TEXTURE_2D, fbo->texture());. Maybe there is a need for some synchronization when doing this.