Berlin, 1-4 September 2016
Many KDABians attended and contributed to QtCon, the wholly new event we co-created along with Qt Contributors, KDE Akademy, VideoLan and FSFE this summer.
In contrast to Qt World Summit where the focus was more on inspiration, the emphasis at this event was on high quality technical content and support for developers.
KDAB’s commitment involved facilitating the organisation of the event (no mean feat when so many parties are involved!) and guaranteeing the venue in addition to our contribution as Gold sponsors, along with The Qt Company.
But our contributions to the program were the most notable. Not only did we contribute 11 talks, we also participated in the program committee, arranged the program and ran a pre-conference training day at a fraction of the usual cost, that showed our commitment to supporting not just Qt at the leading edge but also C++ and more.
The event itself, of course, was free, and enabled by a wide range of sponsors, headed by KDAB and The Qt Company at Gold and Google and bluesystems at Silver.
Old Qt friends and new made up the rest of the impressive sponsor list, which included basyskom, BMW Group, froglogic, Intel and e-Gits at Bronze and openSUSE, woboq, Pelagicore, openinventionnetwork and Ableton at Support level. We would like to take this opportunity to thank all our sponsors for making the event possible.
During QtCon many KDAB engineers gave in-depth technical talks about Qt, QML, Qt3D, OpenGL and the other technologies around Qt development. All the sessions were of the highest quality, as you may expect from KDAB speakers, and extremely well received by the audience.
In case you missed some, here’s a list of KDAB presentations videos:
Qt 3D and Physics Based Rendering
by Sean Harmer
Physics Based Rendering (PBR) is the latest and greatest trend in real-time rendering yielding much more visually believable images than the traditional Phong or ad-hoc lighting models. The underlying concept is that the shaders should use physical principles in the encoded models – chief of which are conservation of energy and the Fresnel effect.
PBR is used in many AAA game titles but here we will show how to make use of it with Qt 3D as it is widely applicable to many other types of 3D content such as for use within engineering and visualization. In this talk we will cover how to go take your raw 3D meshes, look at how to prepare textures suitable for use with a PBR-based workflow and how to feed these into a Qt 3D application. Along the way, we will explain how Physics Based Rendering works and how its formulation helps convince the brain of its realism without destroying performance. We will also take a look at some techniques that are often used in conjunction with PBR such as ambient occlusion and parallax mapping. Time permitting we will look briefly at how to add some post-processing effects to your Qt 3D renderer setup. Physics Based Rendering is a family of techniques for simulating how light interacts with surfaces. It can be applied in both offline renderers such as path tracers used in the production of television and film VFX, and more importantly for us, in real time rendering systems such as Qt 3D. There are two main groups of PBR techniques that fall under the Metal-Roughness and Specular-Glossiness workflows. This talk will concentrate on the Metal-Roughness workflow. We will show all the tooling required to take simple 3D meshes, uv-unwrap and export them for use in specialized texturing tools that can then be used to generate the images needed to feed into PBR GLSL shaders. In addition to the material textures, we will also show how to process HDR environment maps to allow high quality specular reflections to be calculated in real time. The talk will explain how all of these assets work together to produce convincing results. We will also provide tips on reducing the overall memory usage by using modern GPU facilities for managing textures.
All about Qt on Android
by BogDan Vatra
In this session we’ll see real life examples of using JNI on Android. We’ll start by checking the Qt 5.7 goodies which will make our lives easier, then we’ll see simple examples that you’ll need to use in almost any Qt on Android application, and we’ll end up with an Android Service made with Qt.
In this session we’ll see real life examples of using JNI on Android. We’ll start by checking the Qt 5.7 goodies which will make our lives easier, then we’ll see simple examples that you’ll need to use in almost any Qt on Android application. At the end, we’ll see how to create an Android Service made with Qt, and we’ll see how to use QtRemoteObjects to communicate with that service.
|View Video and Slides|
KDE development how it was done in the last century
by David Faure
A retrospective on the KDE community from 20 years ago and how things were done back then, with an emphasis on community spirit and fun facts.
Over time, the KDE community has seen many people join and leave, as with any opensource community, which means that very few people in the current community still know about the initial culture. Many of the mantras and jokes from the very old days didn’t make it to these days, and this presentation is an attempt at sharing more of the initial KDE culture to the current generation.
Beyond the possibly surprising way that development was done at the time (for instance, do you know what was used before subversion? CVS. And before CVS?), it is particularly interesting to realize that many of the things in the architecture that we consider fixed and unchanging now, were subject to a much greater amount creativity back then. Maybe this presentation will encourage the current community to be creative again in these areas?
Happy 20 years, KDE !
KDE PIM Status Report
by Daniel Vrátil
The past year was very important for the KDE PIM community. We released the first Qt5-based version, restructured our code base and set ourselves more ambitious goals. Let’s look a bit deeper into some of the important changes that have happened in KDE PIM in the past year, and peak a little into the future.
In this talk we will go over some of the most important changes that happened in KDE PIM in the past year. This includes discontinuing support for some components, switching over to a binary protocol, splitting of repositories and more. We will also look a bit into the future, talk about the current work in progress as well as our middle and long-term goals and tasks. Although sometimes slightly technical, this talk is aimed at everyone interested in KDE PIM software and community.
Refactor Your OpenGL Legacy With Style
by Kevin Ottens
Using OpenGL code with Qt is a long love story… long enough that there might be skeletons in the closet. Indeed, the OpenGL code of your Qt application could have been written before the modernization of the OpenGL API to exploit better GPUs. In this talk, we will walk through a technique to help refactor your old OpenGL code in the safest way possible and get it ready for the 21st century.
We can find plenty of existing OpenGL code in the wild, some of it is rather old. Unfortunately due to the radical changes in GPU architecture, OpenGL had to adapt as well, with more modern, better suited APIs. In turn, it pushed forward very different designs for rendering code.
Because of those technical changes, it can be very challenging to refactor legacy OpenGL code to prepare a port to Modern OpenGL APIs. In particular because such code tends to have close to no automated test coverage. What can we do with all that code? It could be tempting to start from scratch, but there is a clear chance to break the rendering in some subtle ways.
In this live coding session, we’ll see how we can start from an untested Qt and OpenGL legacy code base, add new features to it, and move it over Modern OpenGL in less than an hour.
It will be a good way to discover how refactoring and pin testing techniques can be used even for your purely graphics code. All of that in a suboptimal codebase and while doing the simplest things that will work.
This talk will be interesting to any developer having to deal with legacy untested OpenGL code or those wanting to modernise for performance or new features. But, if you are interested in testing techniques for rendering code in general or attended one of the previous GildedRose sessions held at Akademy or Qt Dev Days, there will be nice advice for you as well.
Qt 3D Basics
by Kevin Ottens
Having 3D scenes in your application is becoming a clear trend and is likely to become even more important in the future with the growth of Virtual Reality and Augmented Reality. So far Qt was allowing you to integrate with Open GL fairly easily, but managing the rendering code itself was still a very challenging task.
That’s why Qt 5.7 will provide a new module named Qt 3D. In this talk we will cover the basics of its API. In particular, we will highlight how it eases the creation of 3D scenes, but we’ll also point out that it is a full simulation engine and as such can do much more than 3D rendering.
Since writing 3D code from scratch can be very difficult and since getting the architecture of your rendering engine right is critical to your application, Qt 3D will offload those risks from you so that you can focus on your actual simulation and 3D scene content.
In this talk, we will cover the basics of Qt 3D’s API. In particular it is structured around an Entity Component System (ECS) architecture which will be introduced. We will also present how to add geometries and materials to your scene or how to deal with user’s input. If time permits, we will also cover the integration between Qt 3D and Qt Quick.
This talk will be interesting to any developer having to implement a 3D scene inside an application using Qt. No prior knowledge of Open GL or GPU programming is required for this talk.
|View Video and Slides|
Writing custom Qt Quick components using OpenGL
by Kevin Funk
Qt Quick and QML provide an easy way to rapidly develop customized, reusable components entirely within QML. As these components grow in complexity, performance and maintainability often suffer, a drawback that is especially noticeable on low-powered embedded and mobile devices. In addition, some specialized components simply cannot be implemented by combining existing Qt Quick items in QML. For these cases, Qt Quick provides access to its underlying OpenGL scene graph via a C++ API. Components created this way are more closely aligned to the underlying scene graph architecture allowing improved performance and a cleaner implementation.
Qt Quick provides a flexible and easy-to-use framework for developing a wide range of applications from automotive HMIs to interactive desktop applications. Under the hood, it uses an OpenGL scene graph for rendering, allowing advanced effects and fluid animations even on low-powered systems. Complex components written entirely in QML can cause noticeable performance problems especially on these low-powered systems. Qt Quick provides a C++ API to directly access its underlying scene graph for creating optimized components with better encapsulation. These components can then be reused from QML in the same way as the built-in Qt Quick items.
The focus of this talk will be describing the steps necessary to create a Qt Quick component using C++ and OpenGL. We will start with a custom component written entirely in QML and point out the performance and maintenance problems with this approach. We will then reimplement this component in C++ and OpenGL, step-by-step, so that by the end you’ll know enough to create your own C++ Qt Quick components. Finally we’ll compare the resulting component’s implementation and performance against the original to see the improvement. I will also briefly mention the QtQuickFrameBufferObject as an alternative and discuss when you would use it instead of the scene graph API.
The talk is aimed at developers with minimal OpenGL experience. It will briefly introduce enough of the basic OpenGL concepts to get you started writing a custom Qt Quick item.
|View Video and Slides|
Linux perf for Qt developers
by Milian Wolff
Are you a Qt developer and do you use Linux as your development platform of choice? Then this talk is for you:
I will introduce you to perf, the Linux tool suite for performance analysis. The talk will not only cover a broad part of what perf has to offer, it will also dive into details in how it is applicable to Qt developers in particular. Afterwards, you will know how to use perf to find CPU hotspots in your code as well as some tricks to profile wait times for lock contention issues or disk I/O.
Linux perf is a tremendously powerful tool suite for performance analysis: It can do basically everything, from CPU sampling profiling to tracing of syscalls or even dynamic tracepoints in your own code.
While perf is powerful, it is also quite complex and hard to master: Currently, it consists of more than twenty tools, most of which often require custom configuration to get conclusive results. Thus, newcomers have a hard time overcoming the steep learning curve.
This talk aims at shortcutting this process by lying the foundation for any user-space developer to get started with Linux perf. We will cover the basic ways to profile CPU hotspots and dive into some more involved tricks to investigate lock contention or latency issues. Finally, an introduction to custom profiling and data evaluation with Python scripting will be given.
While most parts of this talk will be interesting to any user-space developer on Linux, we will also cover some parts where Linux perf and Qt work particularly well together.
|View Video and Slides|
Integrating OpenGL with Qt Quick 2 applications
by Giuseppe D’Angelo
This talk will introduce you to various effective strategies of drawing raw OpenGL content inside a Qt Quick 2 scene. After a brief introduction to how the Qt Quick 2 renderer works, we will see the APIs in Qt 5.6 that allow us to integrate existing OpenGL code and QML.
One of the foundation pillars of Qt Quick 2 is its OpenGL-based rendering pipeline. By leveraging the GPU capabilities, we get 60 frames-per-second animated scenes, real time eye candy and special effects, particles, and so on. Moreover, the main programming language is QML, which is extremely popular amongst developers and designers — it allows them to quickly prototype and build user interfaces. For these reasons, Qt Quick is becoming the de-facto choice on mobile and embedded platforms.
However, can we integrate Qt Quick 2 with an existing OpenGL codebase? Would it be possible to reuse old, working, tested OpenGL code and give it a new look and feel by building a Qt Quick interface that uses it? How far can we go with that integration?
In this talk, I will show the technologies available in Qt 5.6 that allow deep integration of Qt Quick 2 scenes with custom drawn OpenGL content. We will discuss the possibility of simply providing a Qt Quick overlay for an OpenGL scene. The discussion will then proceed to the creation of custom Qt Quick Items drawn using raw OpenGL commands, which can then be used from QML. Finally, I will illustrate how to manually drive Qt Quick’s own rendering if we need to be in complete control of how and when the rendering happens.
The audience is expected to have familiarity with basic QtQuick and OpenGL concepts, but no in-depth knowledge of them is required.
Multithreading with Qt
by Giuseppe D’Angelo
This talk introduces you to the fundamentals of threading in Qt. We will discuss how threads, QObjects and events interact together; how a thread affinity of a QObject has a play in signals and slots connections; and how you can leverage the modern C++11 threading capabilities in your Qt application.
Cross-platform thread support was introduced in Qt 2.2, released in 2000, ages before it finally got standardized by C++11. This support has allowed developers using Qt to succesfully build countless multithreaded applications, running natively on many operating systems: Windows, Linux, OS X, QNX, iO S, Android, and so on.
Across the span of four major versions Qt’s threading facilities have been greatly expanded and improved. Following Qt’s evolution across the years, a number of “design patterns” have emerged, in order to allow developers to use these facilities to the maximum extent, and not fall into any of the countless traps of multithreaded programming.
In this talk I will discuss the basics of thread support in Qt, starting from QThread, the central class in Qt that manages a thread. I will then focus on the interactions between QObjects, QThreads and thread-local event loops, and how all of this plays a role into the cross-thread signals and slots. The most common pitfalls will be analyzed and discussed here.
I will then show how to “mix and match” Qt and C++11/14 threading and synchronization primitives, and what degree of support one can expect when moving away from Qt’s constructs in favour of the standard C++ ones.
|View Video and Slides|
GammaRay: Taking a deep look into your Qt application
by Volker Krause
GammaRay is a high-level runtime introspection tool for Qt applications. In this talk we will look at a number of real-world debugging and profiling problems and how the capabilities provided by GammaRay help you with those.
When creating applications we strive to use higher-level frameworks to obtain results quickly and reduce development effort and long-term maintenance cost. This however provides a few challenges during debugging and profiling. With conventional instruction-level tools we have to have a reasonable deep understanding on the implementation of the frameworks we use to interpret the results correctly. Tools with understanding of the frameworks we use mitigate this problem, GammaRay is such a tool for Qt.
After a brief introduction on how to use GammaRay we will look at a number of debugging and profiling examples covering a wide range of Qt features such as signals/slots, Qt Quick, widgets, state machines, model/view or Qt3D, and see how GammaRay can help in addressing these. All examples are based on real-world problems KDAB engineers encountered in their daily work, and aim at giving you an idea on how GammaRay can help with problems you might encounter in your Qt application.
|View Video and Slides|
For further information