KDAB at Qt World Summit 2017

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

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

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

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.

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.

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

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.

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.

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.

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.

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.

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.