Skip to content

KDAB at Qt World Summit 2017

Qt World Summit, organized by The Qt Company, is the premier Qt event of the year. It follows on from Qt Developer Days, a Qt Community event that was organized by KDAB from 2012–2014. KDAB is a major contributor to the event and the main sponsor. Our experts give many of the in-depth technical presentations and we run the popular pre-conference trainings.

Berlin, October 2017

This year Qt World Summit was held once more at the Berlin Congress Centre, in central Berlin and had over 1000 attendees – clear testimony to the growth of the Qt Community, as Qt enables our interfaces with the world in multiple areas, from medical to automotive, from gaming to industrial machinery, on desktop, mobile and embedded. As the saying goes, “The future is written with Qt”.

KDAB once again hosted a pre-conference training day, this time attended by over 500 participants, and offering 11 sessions by KDAB as well as one each from Qt partners froglogic and ICS. The above image shows KDAB’s James Turner giving our Advanced QML class, which was attended by over 115 students.

As Diamond Sponsor, we also had the largest booth, where we were able to demonstrate a stunning array of demos.

The conference format included multiple Keynotes and an emphasis on customer showcases. One such was a penetrating talk by Michel Nederlof on new imaging techniques being used to solve cancer. KDAB is naturally proud of our work on this, making good use of Qt 3D, a project which KDAB leads and maintains for the Qt community. You can see more about QI Image Systems and this groundbreaking work here.

As well as the customary Qt roadmap from Lars Knoll, keynote highlights in 2017 included a nod to the importance of C++ with a talk from Herb Sutter and a delightful piece by children’s author Linda Liukas on bringing computing to young children and seeing it afresh through their eyes.

KDAB introduced 13 very well-attended technical talks to balance the mix at Qt World Summit. You can view them all and download the slides, below this.

KDAB Presentations at Qt World Summit, 2017

Marc

QStringViews, QStringViews Everywhere

by Marc Mutz

The upcoming Qt 5.10 release will see the biggest revolution in Qt string handling since Qt 2 added support for Unicode strings: QStringView. Deceptively simple, string views are a powerful abstraction of Unicode string data from the owning container. String views will permeate all of Qt’s APIs within the next few releases and into Qt 6, and release the developer from the requirement to create QStrings just to hand Unicode strings to Qt APIs.

This talk will introduce you to the new idioms forming around QStringView, enabling you to take full advantage of the Qt string APIs in 5.10 and beyond. We will also explore patterns useful for evolving your own APIs to embrace QStringView. Finally, we will take a look at QLatin1String/QStringView co-evolution and the proposed QUtf8String class. The talk assumes

View Slides View video
Sean

What’s New in Qt 3D?

by Sean Harmer

Qt 3D is a rapidly evolving module within Qt. There are lots of new features appearing with each new release to continue expanding what Qt 3D can do out of the box. Engineers from KDAB and The Qt Company have been hard at work over the last months (and will be for some time to come yet) adding in some of the most frequently requested features.

In this talk we will take a tour of some of the more prominent features added to Qt 3D and take a peek at what is coming in Qt 5.10 and beyond Qt 3D in Qt 5.8/5.9:

  • Embedding Qt Quick within Qt 3D to make overlays or interactive displays in your 3D worlds
  • Physically Based Rendering support for intuitive materials and realistic lighting
  • Key frame animation support to breathe life into your entities
  • Level of Detail (LoD) support for better performance
  • 2D and 3D text support directly in Qt 3D Qt 3D in Qt 5.10 and beyond
  • Skeletal animation support to animate parts of your entities in an intuitive way
  • Physics simulation and collision detection
  • Graph based shader generation for dynamic material shaders
  • Virtual Reality support
View Slides View video
Christoph

QML-driven HMI Architectures for Rolling Embedded Devices

by Christoph Sterz

While QML offers a fast-paced developer experience on embedded devices ‘by design’, many high-level decisions need to be made to form the software architectures for highly complex car interfaces we know today. In this talk, I will briefly present how modern automotive software relates to classical embedded device software, and which early decisions in the architecture need to be made differently, or exactly the same, to avoid painstaking complexity in QML code.

The presentation will cover best practices in multi-process architectures, global styling choices, and performance considerations for limited hardware resources.

View Slides View video

Using Virtual Keyboards on Qt Embedded Devices

by Jan Arne Petersen

There is an increasing need to support text input via virtual keyboards not only on Mobile phones but also on embedded devices and in in-vehicle infotainment systems. Qt provides an input method API to provide exactly that support. We will look at the Qt API and show how it can be used from applications and how it can be integrated in different embedded device use cases with either single process fullscreen EGL or in a multi process Wayland compositor scenario. We will have a look at some virtual keyboards like the Qt Virtual Keyboard and other open source solutions.

We will look at some advanced features of virtual keyboards like support for different layouts, support for text correction and prediction, support for handwriting and support for multiple languages especially CJK languages.

View Slides View video
Peppe

Multithreading with Qt

by Giuseppe D’Angelo

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 successfully 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 Slides View video
Paul

Earth Rendering with Qt 3D

by Paul Lemire

Qt 3D is a rapidly evolving module within Qt. There are lots of new features appearing with each new release to continue expanding what Qt 3D can do out of the box. Engineers from KDAB and The Qt Company have been hard at work over the last months (and will be for some time to come yet) adding in some of the most frequently requested features.

In this talk we will take a tour of some of the more prominent features added to Qt 3D and take a peek at what is coming in Qt 5.10 and beyond. Qt 3D in Qt 5.8/5.9

  • Embedding Qt Quick within Qt 3D to make overlays or interactive displays in your 3D worlds
  • Physically Based Rendering support for intuitive materials and realistic lighting
  • Key frame animation support to breathe life into your entities
  • Level of Detail (LoD) support for better performance
  • 2D and 3D text support directly in Qt 3D Qt 3D in Qt 5.10 and beyond
  • Skeletal animation support to animate parts of your entities in an intuitive way
  • Physics simulation and collision detection • Graph based shader generation for dynamic material shaders
  • Virtual Reality support
View Slides View video
Volker

GammaRay – Taking a Deeper Look into Your Qt Application

by Volker Krause

GammaRay is a high-level introspection tool for Qt programs that enables you to visualize and manipulate application behavior at runtime. In this talk we will look at new capabilities and features GammaRay has gained since last year, and how those assist you in solving real-world debugging and profiling problems. When creating applications we strive to use higher-level frameworks in order to obtain results quickly and reduce development effort as well as long-term maintenance cost. This however provides a few challenges during debugging and profiling. With conventional instruction-level tools we need to have a reasonably deep understanding of the implementation of the frameworks, libraries and components we use, to interpret the results correctly. Tools with an understanding of the building blocks we use mitigate this problem. GammaRay is such a tool for Qt.

Following last year’s talk on the same subject, we’ll look at the most important changes in GammaRay in its recent releases, ranging from improvements in object tracking to new visual aids for layouting and debugging Qt Quick UIs. We will then see how to apply those to a number of debugging and profiling examples. 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 own Qt application.

View Slides View video
Mathias

QtBluetooth on Mobile Devices – A Dragon Guide

by Mathias Hasselmann

Connecting mobile phones to other gadgets and devices opens the door for a wide range of useful and innovative applications. Bluetooth as a well established technology seems like a natural choice for these applications. Still within our many projects we have encountered a wide range of problems and risks when using this technology. I will present the most common pitfalls and traps, tell how we avoided them, which tricks we used to work around them.

View Slides View video
Mike

QtIVI: Integrating and Testing Vehicle Functions with Qt Automotive Suite

by Mike Krus

QtIVI has been part of the Qt Automotive Suite since its initial release. It facilitates the creation of Qt based interfaces for vehicle functions such as climate control, media services, etc.

Taking native vehicle data APIs and bringing them into Qt is potentially cumbersome. Code has to be deriving from QObject, exposing properties, and mapping values and calls to the native APIs. Some vehicle data require custom data models and special handling of data updates.

Often the real vehicle is not available for application developers so it is useful to build versions of the API that simulated the vehicle data. Finally, testing and profiling tools for native APIs are usually cumbersome and do not integrate with Qt nicely.

The Qt Automotive Suite QtIVI module introduced a number of patterns to handle these issues including a base classes for basic scenarios, switchable plugins to selected between real or simulated backends, and tools in Gammaray to access and manipulate properties of objects at run time. While this was a big step forward, these still required work writing many objects and models, integrating the backend APIs and maintaining the required plugins.

In order to simplify this process further, Qt Automotive Suite 2.0, which will be launched at the end of the year, Introduces the IVIGenerator which is based on the QFace autogeneration framework. QFace is an open source framework where the vehicle interfaces are described in an IDL which supports familiar Qt constructs such as properties, operations, signals, models, etc. IVIGenerator then uses a template based code generator to produce code for the frontend Qt interface as well as for the backend.

The IDL supports additional concepts such as valid ranges, default values, etc. These are used in the simulator backend to support debugging. IVIGenerator can also generate backends to support unit testing based on the provided values.

In this talk we show how the code generator can be used to fully automate the generation of the frontend code while producing easily extendable stubbed backend code. We go on to show how the actual generation, by virtue of being templated, can be modified to include much of the back end integration code.

View Slides View video
Sean

Breathing Life into Your Applications: Animation with Qt 3D

by Sean Harmer

For a long time it has been possible to add some level of animation to your Qt applications by way of QPropertyAnimation, and then more recently with the Qt Quick Animation framework. You could even use these along with the object types within Qt 3D to animate your virtual worlds. However, we can go further both in terms of features and performance.

Qt has traditionally targeted developers. However, we see increasing demand for it to adapt and to also support the needs of content creators and artists. Animation is a prime example of this. It is no longer feasible to provide only support for creating animations programmatically. Artists want to be able to use their own familiar tools such as Blender or Maya to author animations and then be able to export them for consumption by applications. This meant adding support for key frame animations – something developers have also been asking for over the years. Qt 3D now offers the ability to consume key frame animations exported from external tools or to create your own key frame animations in code. In addition Qt 3D offers a collection of types to make it convenient to work with such animation data. In this talk we will take a deep dive into the new animation subsystem of Qt 3D.

We will cover:

  • How to create key frame animation data with tools or code.
  • How to play back the animation data and apply it to your own objects.
  • Skeletal animations.
  • Using Animation blend trees to combine animations.
  • Controlling time with animation clocks.
  • Orchestrating the transitions between animations.
  • Morph target animations.

In addition to seeing the new features of the animation framework, we will also take a behind the scenes look at how Qt 3D evaluates the animations. Qt 3D has a scalable architecture allowing for good performance whilst leaving the main thread free for your application logic. We will see how properties are updated on both the frontend and backend of Qt 3D allowing the other parts of your application to see the updates.

View Slides View video
Giulio

Integrating out of Process Graphical Content into a QtQuick Scene

by Giulio Camuffo

When rendering expensive content, such as a car navigation view, inside a bigger UI it may be useful to split it in a separate process to avoid blocking the main application, achieving also better isolation and stability. The resulting content from the helper process needs to be then composited into the main application scene to be integrated with the other elements of the UI.

If the helper renders using OpenGL however we don’t have a ready access to the pixels, and the naive approach of transferring them to CPU memory and sending them is very slow and not viable most of the times. This talk will present what are the approaches to achieve a fast, 0-copy transfer of the content from the helper process to the main one, using technologies such as Wayland and EGLStream, and how to integrate it in the QtQuick scene.

View Slides View video
Mike

Interacting with 3D Content

by Mike Krus

Qt 3D 2.0 has greatly facilitated adding 3D content to modern 2D and 3D applications, providing a robust and versatile toolkit for displaying custom domain data using complex rendering techniques. One of the key aspect of successful visualisation is making it easy to interact with the data. In this talk, we will review the various methods available to the developer and how to implement them with Qt 3D.

We will start with simple picking, or the ability to query which object is currently under the mouse pointer. We will also see how to handle low level device events (mouse, keyboards, other controllers) to give behaviour to objects. When using the QML API, this is done in a truly declarative manner which is easy to apprehend and implement.

Integrating 2D and 3D UIs has traditionally been very cumbersome. But using Qt 3D’s QML API, Qt Quick can easily be used to create traditional 2D user interfaces to manipulate the properties of rendered objects and control the scene. Furthermore, Qt 3D 5.9 introduces, as a tech preview, the ability to embed such Qt Quick 2D UIs directly in the 3D scenes while preserving a seamless interactivity.

Moving and resizing objects in 3D while interacting on a 2D screen can be difficult. We will show how embedding special controls in the scene can be used to facilitate the editing of 3D objects, just like sliders and dials provide useful helpers in the 2D case. Referred to a manipulators, with limited and predictable degrees of freedom, such controls can be very helpful for facilitation such interactions.

View Slides View video
Peppe

Integrating OpenGL with Qt Quick 2 applications

by Giuseppe D’Angelo

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.

View Slides View video

You can see the Keynotes and the rest of Qt World Summit presentations here.

By continuing to use the site, you agree to the use of cookies. More information

The cookie settings on this website are set to "allow cookies" to give you the best browsing experience possible. If you continue to use this website without changing your cookie settings or you click "Accept" below then you are consenting to this.

Close