Qt World Summit, organized by The Qt Company, is the premier Qt event of the year and follows on from Qt Developer Days that KDAB organized 2012–2014. KDAB has been a main contributor to the event as a major sponsor. Our experts give many of the in-depth technical presentations and we run the popular pre-conference trainings.
San Francisco, October 2016
Qt World Summit 2016 was held in Pier 27 in San Francisco – a spectacular location, that was blessed with gorgeous sunshine and close to 600 attendees, surely a record attendance for the US version of what used to be called Qt Developer Days.
KDAB had four very well-attended talks in the program, each reflecting a different area of our unique expertise – Qt 3D, Qt on Android, Qt on iOS and GammaRay, as well as contributing to panel discussions on the future of Qt and Qt Automotive Suite which we also helped to develop, along with The Qt Company and Pelagicore. Our contributions to Qt did not go unnoticed, and were brought out in the sponsored Live Theatre session we gave on the final afternoon.
On the pre-conference training day we contributed to, the highly appreciative attendees were also able to learn from the experts about What’s New in C++11-C++14, Debugging and Profiling for Qt Applications and Model/View Programming in Qt, in addition to the training on Qt 3D from its creator, Sean Harmer.
All in all the event was a great success at this distinctly American, California-style, event, right down to the delicious conference food, served from colorful food trucks on the waterfront. As the penny dropped about KDAB’s expertise, we got more and more enquiries at our booth which will surely help further consolidate our customer base in the USA in the years to come.
Integrating OpenGL with Qt Quick 2 applications
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 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.
Qt for iOS A to Z
Since version 5.2, Qt has been available on iOS. In this talk, we go through the process of building a simple QML application, run in the simulator, and deploy to a device. We first look at the creator project and settings that are specific to iOS such as targeted devices, SDKs, required capabilities, etc. We also look at Qt Creator tooling related to simulator and devices deployment. We will mention where Xcode still outperforms Creator, in particular when it comes to debugging and performance analysis.
After looking at a simple QML app, we investigate the coverage Qt relative to the native capabilities. In particular we’ll focus on text editing, keyboard customizing, keyboard avoidance, accessing the sensors (location, orientation, camera), support of different screen sizes and DPI, etc. Then we look at how integrating with the native toolkits for accessing feature not covered by the QML layer. Using Objective C++ and Qt’s iOS specific integration layer, we show how to access features from UIKit. Finally we will look at performance pitfalls that are common on iOS and how to detect and mitigate them using a variety of tools.
|View slides and Sample code|
All about Qt on Android: Say hello to Qt on Android
This session will introduce you to beautiful Qt on Android world. We’ll start with setting up the development environment, we’ll check the tools, then we’ll see how and what to setup on you Qt application to make it a real Android application and finally how to sign your application to prepare it for publishing on Google’s Play Market (or any other Android market’s out there).
Qt 3D and Physics Based Rendering
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.
GammaRay – Taking a deep look into your Qt application
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 a number of real-world debugging and profiling problems and how the capabilities provided by GammaRay help you to analyze and solve those. 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. After a brief introduction on how to use GammaRay for local and remote targets, 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 own Qt application. If you have ever spent hours or even days wondering why one of your signal/slot connections seemed to have a mind of its own, why a Qt Quick button was accepting clicks only when it felt like it, or why your QML HMI was rendering a bit slowly on your embedded target device, this talk is for you.
Pushing the Frontiers of Qt – taking your Qt development to the next level
Find out about the leading edge ways Qt and Qt 3D are being used, from precision engineering in industrial machines to running Android applications, to sophisticated user-interfaces that are revolutionizing the auto industry, including heavy industrial. Discover the Qt Automotive Suite, a one-stop-shop for Qt Automotive needs.
For more information