About once a year, all of KDAB employees come together so we can get to know each other in a different way, and, among other things, introduce new members of the KDAB family, who are encouraged to give a ten-minute "newbie talk" on anything they are interested in. Last year Daniel Vrátil joined KDAB. We thought you'd enjoy his introductory talk.
Solving cancer requires understanding its complexity as multiple diseases with various aspects to uncover. Beyond sequencing the human genome (more a "parts list" than "blueprint"), we need to understand tissue architecture and tumor progression. QI (Quantitative Imaging Systems) images patient biopsies, labeling individual cells with 100+ biomarkers to understand tumor biology and find druggable targets to stop progression and metastasis.
When Competence Center ISOBUS (CCI) needed to modernize their agricultural terminal as part of their innovation strategy, they partnered with KDAB. The cab interface displays multiple applications controlling complex agricultural tools and reports while remaining easy to operate. KDAB developed new terminal software using QtQuick on Linux embedded for this critical agricultural technology.
QtQuick is a popular choice for creating HMIs for embedded devices. The hardware on these devices often is constrained and less performant than their desktop equivalents, this requires extra care from software developers in delivering a fluid user experience. KDAB is regularly involved with improving the performance of QtQuick HMIs on such devices for their customers.
3D scenes in applications are trending and will become more important with VR/AR growth. While Qt allowed OpenGL integration, managing rendering code remained challenging. Qt's new Qt 3D module addresses this with simple APIs for getting 3D content into applications. This short talk introduces Qt 3D's design ideas, use cases, and ease of implementation.
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.
This talk introduces you to the fundamentals of threading in Qt / qthread. 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.
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.
This talk introduces perf, the Linux performance analysis tool suite, specifically for Qt developers using Linux. It covers perf's broad capabilities and Qt-specific applications, teaching how to find CPU hotspots in code and profile wait times for lock contention and disk I/O issues, providing practical performance optimization techniques.
Qt Quick and QML enable rapid development of customized, reusable components, but complex components often suffer performance and maintainability issues, especially on embedded/mobile devices. Some specialized components can't be implemented by combining existing Qt Quick items. Qt Quick's C++ OpenGL scene graph API allows creating components aligned with underlying architecture for improved performance.
3D scenes in applications are becoming increasingly important with VR/AR growth. While Qt allowed OpenGL integration, managing rendering code remained challenging. Qt 5.7's new Qt 3D module eases 3D scene creation through its API, but functions as a complete simulation engine capable of much more than just 3D rendering.
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.
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 change.
This KDE community retrospective explores development culture from 20 years ago, emphasizing community spirit and fun facts. It shares initial KDE culture with current generations, including surprising development practices (pre-CVS version control) and highlights how architectural elements now considered fixed were once subject to greater creativity, potentially encouraging renewed innovation.
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.
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.
Why does a tipper truck need an app? F.X. Meiller is the leading manufacturer of tippers in Europe. KDAB software developers and UI/UX designers worked with Meiller to create a mobile app that interacts with embedded hardware on the truck, allowing drivers to diagnose and fix problems - even when on the road. KDAB shows us how technical excellence and stunning user experience go hand in hand.
Qt 3D demo using QML API creates high-quality animated 3D visualization with custom metal-roughness PBR shaders and realistic material textures. Features dynamic clip planes for inspecting hidden geometry and seamlessly mixes Qt Quick 2D UI with 3D content, allowing overlay interfaces without wasting screen space while expressing relationships between 2D UI and 3D content.
Qt 3D 2.0 introduces an Entity-Component-System architecture replacing traditional inheritance hierarchies. Features multi-threaded rendering with declarative frame graph configuration through QML, supporting advanced techniques like tessellation and deferred rendering. The extensible aspect system allows custom functionality integration while maintaining scalability across CPU cores.
This presentation will provide a short introduction into Qt Creator, demonstrate targeting different environments from within the IDE and will highlight new features found in Qt Creator 3.2
