OpenGL in Qt 5.1 – Part 3

This article continues our series on what is new in Qt 5.1 with respect to OpenGL. If you haven’t already seen them, you may be interested in reading Part 1 and Part 2.

Timer Queries

OpenGL on the desktop exposes a very useful tool in the shape of timer query objects. These can be used to record the amount of time taken by the GPU to process sequences of commands. If we couple this with the usual CPU profiling techniques then we can get a very complete understanding of the bottlenecks in our rendering code.

One obvious place that could take advantage of this is the Qt Quick 2 renderer. Although the Qt Quick 2 renderer does have options to enable timings of various stages of rendering, this only tells us half of the story. Namely, the CPU half. Using OpenGL timer queries would allow us to fill in the gap and gain an understanding of how the GPU is performing.

Another common use for OpenGL timer queries is to provide feedback to adaptive rendering routines in order to maintain more consistent frame rates. For example, if we instrument our rendering function and find at runtime that our application is rendering too slowly, we can perhaps increase the frame rate by using less complex shaders or by using lower resolution meshes etc. Conversely, if we find that we have GPU cycles to spare then we could improve rendering quality by perhaps using higher levels of tessellation.

Qt 5.1 will make such tasks much easier with the introduction of two new classes developed by KDAB engineers: QOpenGLTimerQuery and QOpenGLTimeMonitor. The QOpenGLTimerQuery class is a simple wrapper around a single OpenGL timer query object and can be used if you wish to have total control. It is expected that QOpenGLTimeMonitor will be the more commonly used class as this is a wrapper around a sequence of timer query objects and makes it trivial to measure the GPU time of the various stages of our rendering functions:

So here we see in this trivial example (which just draws a single large triangle) that the GPU is using only a fraction of a millisecond. This means that we could easily ask the GPU to do more work per-frame (as we would certainly hope!).

There is much more to say about the nuances of using timer queries but we’ll leave that to a future more in-depth article.

About KDAB

KDAB believes that it is critical for our business to invest into Qt3D and Qt, in general, to keep pushing the technology forward and to ensure it remains competitive. Unlike The Qt Company, we are solely focused on consultancy and training and do not sell licenses.

10 thoughts on “OpenGL in Qt 5.1 – Part 3”

One thing that is sorely needed in the Qt5 OpenGL world is a good set of compilable examples. The existing ones appear to be ports of the Qt4 OGL ones and don’t illustrate the use of the new stuff. I know it’s all documented but having something you can step through with a debugger is a much easier way to learn and/or build upon.

Another thing that might be worth mentioning is the usage of QWidget::createWindowContainer in order to create something analogous to QGLWidget from a GL backed QWindow. It took me many hours or googling and some IRCing to figure this out. Granted it is a very new feature so won’t have percolated up to the surface yet, but being able to have a GL “subwindow” seems like such a fundamental feature I’m surprised its usage hasn’t been made more obvious or documented.

Anyway, it looks like you’ve been doing a great job making OpenGL less of a pain with Qt5; long may it continue!

How about examples of how to initialize and use OpenGL with Qt/QtQuick? In your talk you show how to use it as an underlay but you also mention that it can be used as overlay, inside of QML element, etc.