Qt

3D Basics
CERN HSF Visualization workshop, 28/03/2017

Presented by Mike Krus - [email protected]

Material based on Qt 5.5, created on March 28, 2017

p.1
 Introducing Qt Quick What is Qt Quick?

A set of technologies including:

Declarative markup language: QML

Language runtime integrated with Qt

Qt Creator IDE support for the QML language

Graphical design tool

C++ API for integration with Qt applications

Introducing Qt Quick

Introducing Qt Quick p.2 Introducing Qt Quick p.3

Philosophy of Qt Quick Qt 3D Basics

Intuitive user interfaces

Design-oriented

Rapid prototyping and production

Easy deployment

Qt 3D Basics

Introducing Qt Quick p.4 Qt 3D Basics p.5

 Qt 3D Basics What is Qt 3D?

It is not about 3D!

Multi-purpose, not just a game engine

Soft real-time simulation engine

Designed to be scalable

Extensible and flexible

Feature Set

Feature Set p.6 Feature Set p.7

Simulation Engine Scalability

The core is not inherently about 3D Frontend / backend split

Frontend is lightweight and on the main thread
It can deal with several domains at once
Backend executed in a secondary thread
AI, logic, audio, etc.
Where the actual simulation runs
And of course it contains a 3D renderer too!
Non-blocking frontend / backend communication
All you need for a complex system simulation
Mechanical systems Backend maximizes throughput via a thread pool
Physics
... and also games

Feature Set p.8 Feature Set p.9

 Extensibility and Flexibility Qt 3D Basics

Domains can be added via independent aspects

... only if there's not something fitting your needs already

Provide both C++ and QML APIs

Integrates well with the rest of Qt

Pulling your simulation data from a database anyone?

Entity Component System is used to combine behavior in your own objects

No deep inheritance hierarchy

Entity Component System?

Feature Set p.10 Entity Component System? p.11

ECS: Definitions Composition vs Inheritance

ECS is an architectural pattern Let's analyse a familiar example: Space Invaders

Popular in game engines
Favors composition over inheritance

An entity is a general purpose object

An entity gets its behavior by combining data

Data comes from typed components

Entity Component System? p.12 Entity Component System? p.13

 Composition vs Inheritance cont'd Composition vs Inheritance cont'd

Typical inheritance hierarchy All fine until customer requires new feature:

Entity Component System? p.14 Entity Component System? p.15

Composition vs Inheritance cont'd Composition vs Inheritance cont'd

Typical solution: Add feature to base class Doesn't scale:

Entity Component System? p.16 Entity Component System? p.17

 Composition vs Inheritance cont'd Composition vs Inheritance cont'd

What about multiple inheritance? What about mix-in multiple inheritance?

Entity Component System? p.18 Entity Component System? p.19

Composition vs Inheritance cont'd Composition vs Inheritance cont'd

Does it scale? Is inheritance flexible enough?

Entity Component System? p.20 Entity Component System? p.21

 Composition vs Inheritance cont'd Entity Component System

Is traditional fixed composition the panacea? The Entity/Component data split gives flexibility to manage the API

The System separation moves the behavior away from data avoiding
dependencies between Components

Entity Component System? p.22 Entity Component System? p.23

Entity Component System Wrap-up Qt 3D Basics

Inheritance:
Relationships baked in at design time
Complex inheritance hierarchies: deep, wide, multiple inheritance
Features tend to migrate to base class

Fixed Composition
Relationships still baked in at design time
Fixed maximum feature scope
Lots of functional domain details in the scene object
If functional domain objects contain both data and behavior they will
have lots of inter-dependencies Hello Donut
Entity Component System
Allows changes at runtime
Avoids inheritance limitations
Has additional costs:
More QObjects
Different to most OOP developer's experience
We don't have to bake in assumptions to Qt 3D that we can't later
change when adding features.

Entity Component System? p.24 Hello Donut p.25

 Hello Donut (QML) C++ API vs QML API

Good practice having root QML API is a mirror of the C++ API
Entity to represent the
scene C++ class names like the rest of Qt

QML element names just don't have the Q in front

One Entity per "object" in
the scene Qt3DCore::QNode vs Node
Qt3DCore::QEntity vs Entity
Objects given behavior by
attaching component ...
subclasses

For an Entity to be drawn it

needs:
A mesh geometry
describing its shape
A material describing its
surface appearance

Demo qt3d/ex-hellodonut-qml

Hello Donut p.26 Hello Donut p.27

Qt 3D Basics Everything is a QNode

Qt3DCore::QNode is the base type for everything

It inherits from QObject and all its features
Internally implements the frontend/backend communication

Qt3DCore::QEntity
It inherits from Qt3DCore::QNode
It just aggregates Qt3DCore::QComponents

Qt3DCore::QComponent

Qt 3D ECS Explained
It inherits from Qt3DCore::QNode
Actual data is provided by its subclasses
Qt3DCore::QTransform
Qt3DRender::QMesh
Qt3DRender::QMaterial
...

Qt 3D ECS Explained p.28 Qt 3D ECS Explained p.29

 Everything is a QNode cont'd You Still Need a System

The simulation is executed by Qt3DCore::QAspectEngine

Qt3DCore::QAbstractAspect subclass instances are registered on the

engine
Behavior comes from the aspects processing component data
Aspects control the domains manipulated by your simulation

Qt 3D provides
Qt3DRender::QRenderAspect
Qt3DInput::QInputAspect
Qt3DLogic::QLogicAspect

Note that aspects have no API of their own

It is all provided by Qt3DCore::QComponent subclasses

Qt 3D ECS Explained p.30 Qt 3D ECS Explained p.31

Qt 3D Basics The Scene Graph

The scene graph provides the spatial representation of the simulation

Qt3DCore::QEntity: what takes part in the simulation
Qt3DCore::QTransform: where it is, what scale it is, what orientation it
has

Hierarchical transforms are controlled by the parent/child relationship

Similar to QWidget, QQuickItem, etc.

If the scene is rendered, we need a point of view on it

This is provided by Qt3DRender::QCamera

The Scene Graph

The Scene Graph p.32 The Scene Graph p.33

 Qt3DCore::QTransform Transforms cont'd

1 import Qt3D.Core 2.0

Inherits from Qt3DCore::QComponent
2
3 Entity {
Represents an affine transformation 4 components: [
5 Transform {
Three ways of using it: 6 scale3D: Qt.vector3d(1, 2, 1.5)
7 translation: Qt.vector3d(0, 0, -1)
Through properties: scale3D, rotation, translation
8 }
Through helper functions: rotateAround() 9 ]
10
Through the matrix property 11 Entity {
12 components: [
Transformations are applied: 13 Transform { translation: Qt.vector3d(0, 1, 0) }
to objects in Scale/Rotation/Translation order 14 ]
15 }
to coordinate systems in Translation/Rotation/Scale order 16 }

Transformations are multiplied along the parent/child relationship

The Scene Graph p.34 The Scene Graph p.35

Geometries Making your Own Geometries

Qt3DRender::QRenderAspect draws Using Qt3DRender::QBuffer we can create our own vertices

Qt3DCore::QEntitys with a shape
GeometryRenderer controls how buffers are combined and parsed
Qt3DRender::QGeometryRenderer's
geometry property specifies the shape Useful to make you own geometries programmatically:
From a function
Qt 3D provides convenience From data sets
subclasses of
From user interaction
Qt3DRender::QGeometryRenderer:
Qt3DExtras::QSphereMesh
Qt3DExtras::QCuboidMesh Demo qt3d/ex-surface-function
Qt3DExtras::QPlaneMesh
Qt3DExtras::QTorusMesh
Qt3DExtras::QConeMesh
Qt3DExtras::QCylinderMesh

Qt Demo examples/qt3d/basicshapes-cpp

The Scene Graph p.36 The Scene Graph p.37

 Materials Lights

If a Qt3DCore::QEntity only has a Even with shapes and materials we would see nothing
shape it will appear black
We need some lights
The Qt3DRender::QMaterial ... luckily Qt 3D sets a default one for us if none is provided
component provides a surface
appearance In general we want some control of the scene lighting

Qt 3D provides convenience subclasses Qt 3D provides the following light types:

of Qt3DRender::QMaterial: DirectionalLight
Qt3DExtras::QPhongMaterial PointLight
Qt3DExtras::QPhongAlphaMaterial SpotLight
Qt3DExtras::QDiffuseMapMaterial
Qt3DExtras::QDiffuseSpecularMapMaterial
Lab qt3d/ex-lights-qml
Qt3DExtras::QGoochMaterial
...

Demo qt3d/sol-textured-scene

The Scene Graph p.38 The Scene Graph p.39

Custom Material example Texture Composition and Filtering

1 import Qt3D.Render 2.0 Possible to sample several textures in a single material

2 ...
3
Material {
Also easy to reuse stock lighting model
4
5 parameters: Parameter { name: "colorTint"; value: "yellow" }
6 effect: Effect { Then you can blend as you see fit in the shader
7 techniques: [
8 Technique {
9 filterKeys: FilterKey { name: "renderingStyle"; value: "forward" }
10 Demo qt3d/sol-earth
11 graphicsApiFilter {
12 api: GraphicsApiFilter.OpenGL
13 majorVersion: 3
14 minorVersion: 2
15 profile: GraphicsApiFilter.CoreProfile
16 }
17
18 renderPasses: RenderPass {
19 shaderProgram: ShaderProgram {
20 vertexShaderCode: loadSource("qrc:/customshader.vert")
21 fragmentShaderCode: loadSource("qrc:/customshader.frag")
22 }
23 }
24 }
25 ]
26 }
27 }

Demo qt3d/ex-glsl

The Scene Graph p.40 The Scene Graph p.41

 Qt 3D Basics Picking

High level picking provided by Qt3DRender::QObjectPicker component

Implicitly associated with mouse device
Uses ray-cast based picking

Qt3DRender::QObjectPicker emits signals for you to handle:

pressed(pick), released(pick), clicked(pick)
moved(pick) - only when dragEnabled is true
entered(), exited() - only when hoverEnabled is true

The containsMouse property provides a more declarative alternative to

Interacting with the scene entered(), exited()

The pick parameter of the signals is a Qt3DRender::QPickEvent

position in screen space
localIntersection in model space
worldIntersection in world space

Demo qt3d/ex-object-picker

Demo qt3d/ex-object-picker-qml

Interacting with the scene p.42 Interacting with the scene p.43

Physical Devices Physical Devices vs Logical Devices

To handle input we first need to generate input events Physical devices provide only discrete events

Subclasses of Qt3DInput::QAbstractPhysicalDevice represent input Hard to use them to control a value over time
devices
Logical device provides a way to:
Qt3DInput::QKeyboardDevice
Have an analog view on a physical device
Qt3DInput::QMouseDevice Aggregate several physical devices in a
Others can be added later unified device
On it's own a device doesn't do much Combined with input handler
Input handlers expose signals emitted in response to events
Demo qt3d/ex-mouse-handler-qml

Interacting with the scene p.44 Interacting with the scene p.45
 Putting it All Together: Moving Boxes Integrating with QtQuick using Scene3D

Focus managed using tab Provided by the QtQuick.Scene3D module

Focused box appears bigger Takes an Entity as child which will be your whole scene
The arrows move the box on the plane Loaded aspects are controlled with the aspects property
Page up/down rotate the box on its Y axis Hover events are only accepted if the hoverEnabled property is true
Boxes light up when on mouse hover

Clicking on a box gives it the focus Demo qt3d/ex-controls-overlay

Boxes can be moved around with the mouse

In 5.9, Scene2D, fully interactive Qt Quick UI mapped onto 3D geometry

Demo qt3d/sol-moving-boxes-qml-step3

Interacting with the scene p.46 Interacting with the scene p.47

Qt 3D Basics What is the Frame Graph For?

With what we have seen so far, we can:

Draw geometry loaded from disk or generated dynamically
Use custom materials with shaders to change surface appearance
Make use of textures to increase surface details

What about shadows?

What about transparency?

What about post processing effects?

The Qt 3D Frame Graph All these and others require control over how we render the Scene Graph

The Frame Graph describes the rendering algorithm

The Qt 3D Frame Graph p.48 The Qt 3D Frame Graph p.49

 Structure and Behavior The Simplest Frame Graph

The nodes of the Frame Graph form a tree It is important to structure your Frame Graph properly for performance
reasons
The entities of the Scene Graph form a tree
Might lead to deep and narrow trees
The Frame Graph and Scene Graph are linearized into render commands
Simplest case being a one pass forward renderer

The Qt 3D Frame Graph p.50 The Qt 3D Frame Graph p.51

Several Points of View on a Scene Showing Different Scenes in Viewports

Camera describes a point of view on a Our Viewports all display the same scene...
scene
But they can display different subsets of the
Viewport allows to split the render surface scene using layers
in several areas
Attach each entity to a Layer
They can be nested for further splitting
Have each Viewport display a subset of the
CameraSelector allows to select a camera
entities using LayerFilter
to render in a Viewport

ClearBuffers decribes which buffers are

cleared during the rendering Demo qt3d/ex-viewports-and-layers
Generally necessary to get anything on
screen
Also an easy way to control background
color

To avoid a branch to trigger a rendering

give it a NoDraw element as leaf

Demo qt3d/ex-viewports

The Qt 3D Frame Graph p.52 The Qt 3D Frame Graph p.53

 Image-Base Techniques Qt 3D Basics

Rendering to a texture, support for

framebuffers

Multiple passes

Post-Processing Effects

Demo qt3d/ex-gaussian-blur

Demo qt3d/ex-multiple-effects

Beyond the Tip of the Iceberg

The Qt 3D Frame Graph p.54 Beyond the Tip of the Iceberg p.55

And more... Qt 3D Basics

Texture mipmaps

Cube Maps

Portability of your code accross several OpenGL versions

Complete control over the rendering algorithm

Loading complete objects or scenes from files (3ds, collada, qml...)

Post-processing effects (single or multi-pass)

Instanced rendering

etc.
The Future of Qt 3D

Demo qt3d/sol-asteroids

Demo qt3d/ex-instanced-geometry

Beyond the Tip of the Iceberg p.56 The Future of Qt 3D p.57

 What does the future hold for Qt 3D? What does the future hold for Qt 3D?

Qt 3D Core New aspects:

Efficiency improvemments Collision Detection Aspect
Backend threadpool and job handling improvements - jobs spawning Allows to detect when entities collide or enter/exit volumes in space
jobs Animation Aspect
Qt 3D Render Keyframe animation (5.9 TP)
Use Qt Quick or QPainter to render into a texture Skeletal animation
Embed Qt Quick into Qt 3D including input handling (5.9) Morph target animation
Level of Detail (LOD) support for meshes (5.9) Removes animation workload from main thread
Billboards - camera facing entities Physics Aspect
Text support - 2D and 3D (5.9) Rigid body and soft body physics simulation
Additional materials such as Physics Based Rendering (PBR) materials AI Aspect, 3D Positional Audio Aspect ...
Particle systems Tooling:
Qt 3D Input Design time tooling - scene editor
Axis inputs that apply cumulative axis values as position, velocity or Qt 3D Studio
acceleration Build time tooling - asset conditioners for meshes, textures etc.
Additional input device support
3D mouse controllers, game controllers
Enumerated inputs such as 8-way buttons, hat switches or dials

The Future of Qt 3D p.58 The Future of Qt 3D p.59

What does the future hold for Qt 3D?

Qt 3D and the rest of Qt:

DataVis, Mapping are likely to be based on Qt 3D
Work on unifying rendering toolset
Single renderer, Vulkan, D12, Metal backends

The Future of Qt 3D p.60