Qt 3D Technology Preview Released with Qt 5.5.0

Sean Harmer

1 July 2015

Tags

KDAB is pleased to announce that the Qt 5.5.0 release includes a Technology Preview of the Qt3D module. Qt3D provides a high-level framework to allow developers to easily add 3D content to Qt applications using either QML or C++ APIs. The Qt3D module is released with the Technology Preview status. This means that Qt3D will continue to see improvements across the API design, supported features and performance before release. It is provided to start collecting feedback from users and to give a taste of what is coming with Qt3D in the future. Please grab a copy of the Qt 5.5.0 release and give Qt3D a test drive and report bugs and feature requests.

Qt3D provides a lot of functionality needed for modern 3D rendering backed by the performance of OpenGL across the platforms supported by Qt with the exception of iOS. There is work under way to support Qt3D on iOS and we expect this to be available very shortly. Qt3D allows developers to not only show 3D content easily but also to totally customise the appearance of objects by using the built-in materials or by providing custom GLSL shaders. Moreover, Qt3D allows control over how the scene is rendered in a data-driven manner. This allows rapid prototyping of new or custom rendering algorithms. Integration of Qt3D and Qt Quick 2 content is enabled by the Scene3D Qt Quick item. Features currently supported by the Qt3D Technology Preview are:

A flexible and extensible Entity Component System with a highly threaded and scalable architecture
Loading of custom geometry (using built in OBJ parser or assimp if available)
Comprehensive material, effect, render pass system to customise appearance
Data-driven renderer configuration - change how your scene is rendered without touching C++
Support for many rendering techniques - forward, deferred, early z-fill, shadow mapping etc.
Support for all GLSL shader stages (excluding compute at present)
Good support for textures and render targets including high-dynamic range
Support for uniform buffer objects where available
Out of the box support for simple geometric primitives and materials
Keyboard input and simple camera mouse control
Integration with Qt Quick 2 user interfaces

Beyond rendering, Qt3D also provides a framework for adding additional functionality in the future for areas such as:

Physics simulation
Skeletal and morph target animation
3D positional audio
Stereoscopic rendering
Artificial intelligence
Advanced input mechanisms

To learn more about the architecture and features of Qt3D, please read KDAB's series of blogs and the Qt3D documentation.

KDAB and The Qt Company will continue to improve Qt3D over the coming months to improve support for more platforms, input handling and picking, import of additional 3D formats, instanced rendering, more materials and better integration points to the rest of Qt. If you wish to contribute either with code, examples, documentation or time then please contact us on the #qt-3d channel on freenode IRC or via the mailing lists.

18 Comments

Is it necessary to implement just another x3d implementation using OpenGL? What about existing approaches like X3D. From my point of view it would made more sense to supportx3d/x3dom content, wouldn't it?

Qt3D is not just another X3D implementation using OpenGL.

"another 3d implementation" i meant. :) What are the advantages compared to x3d?

Well for a start we're not defining a 3D interchange format. Qt3D is a framework to easily allow 3D content to be added to a Qt application in any way that you see fit. If you want to try out a new order independent transparency rendering technique, then you can do so without having to wait years for it to be added to the X3D specification and then more time for implementations to appear that support this.

Of course, X3D is much more mature as Qt3D is a new endeavour but you do also get all the other nice features in Qt along with it.

Does current angle back end renderer is considered as stable in now?

Depends upon the quality of the drivers but it provides a decent OpenGL ES 2 implementation.

You mentioned iOS support will be released soon, but I read in QT doc - will be released in 5.6. What's right ?

The patches will land on the 5.5 branch and so will be available as part of Qt 5.5.1 but also Qt 5.6 when they are released.

Is this qt3d supposed to be the same as or compatible to the "old" standalone module existing before (e.g. with Qt 5.2) or a complete new module with accidently the same name? I am confused here as the API are so different from what I know and used before. If yes, how can I get my "old" 5.x programs compiled which use header like QGLView, QGLSceneNode, QGLAbstractScene, etc. ? Is there a "compatibility switch" or do I have to recode everything I did before? When using the installer and marking the Qt3D module for installation I don't get anything compiled. This starts already with the .pro file where I have to remove the QT += 3d entry. Any compatible replacement here? I am lost...

The Qt3D Technology Preview released with Qt 5.5.0 is a complete rewrite. We reviewed the old Qt3D 1 API and decided it was not flexible enough for the directions we wanted to take Qt3D in.

There has never been an official release of Qt3D alongside Qt 5 although I am aware there were some packages made available that wrapped up Qt3D 1 with Qt 5 and labelled as Qt3D 2 but that was not ever official to my knowledge.

You will need to port your application from Qt3D 1 to Qt 3D 2 as we did not keep any of the old API.

I was talking about the offical qt3d. No wrapper called qt3d2.0. So, to be honest, Qt3d 2 is yet another 3d API with a different philosophy, architecture etc. to Qt3D 1. My enthusiasm is very restricted. But thanks for the clarification. I am sure others will face this issue too.

Fair enough. We took the view that pursuing a modern framework within the constraints of a API that would not have allowed us to grow was not a good investment. This led to the decision to re-architect the solution.

Hi, Thank you for releasing Qt3D in the current version of Qt5.5! I have been waiting for a method to remove the amount of libraries I must use in my code for a while and this seems to be the best solution!

I am trying to use Qt3D to load files in place of Assimp. I would like to retrieve vertex and mesh data ultimately, but cannot seem to find a way to do it using Qt 5.5 yet. I know the code below is sloppy, but it compiles and crashes (maybe from the file not loading? When does the file load?). Due to the lack of examples, I have tried to figure stuff out on my own to get a QMeshData from any Qt3D object that I can (and from there the vertex data). Could anyone please let me know what I am doing wrong?

Qt3D::QMesh mesh;
mesh.setSource(QUrl::fromLocalFile("file.b3d"));
Qt3D::QAbstractMeshFunctor *func = mesh.meshFunctor().data();
Qt3D::QMeshDataPtr ptr = func->operator ()();

As an aside, The Qt3D documentation mentions(http://doc.qt.io/qt-5/qt3d.html)) that I can use AssimpParser to load models... but I cannot find the include file for this.

Thanks! -Jim

With the old qt3d it was possible to easily render 2d content within the 3d scene by using QGLPainter. After having played around with qt3d 2.0 for a while, I can't find a similar solution. I managed to paint all kind of stuff over my 3d scene, but not into it. Since the official documentation on the qt homepage is still ... premature, I'm kind of lost. Is there a nice way to do this like in the old qt3d and I'm just missing the obvious? Where can I get more information?

I'm wondering the same thing. I would like to paint 2D content in my 3D scene

Hi,

We're developing an Game Engine based on Qt called Cute3D...

It' under advance stage, but when you released the Qt3D we start thinking using some of it.

To take this direction I need to know some information that I did not found about the rendering pipeline.

How does it work about the order of the rendering?

It render solid meshes first, and later render the transparent ones, using an sort algorithm to render from back to front?

There are other stuffs that I did not find informations. I saw that Qt3D uses Job likes Cute3D, but It seens to update the scene transformation using only one thread... Is that correct? If so, what about the animation transform, is it using jobs?? Because it can make the FPS goes down to quickly, if you're working with big scenes...

Other question is about performance.... Does you have make some performance test using big scenes and lot os animation objects??

For exemple: Cute3D runs almost at the same FPS as Unity3D, approximately 5% low the Unity3D.

These information is import for us decide change some code to use Qt3D.

Best, Renato Dias Viana Sunland Entertainment Studios

The order of the rendering is totally under your control by way of the framegraph. Take a look at http://www.kdab.com/qt3d-2-0-framegraph/ for more details.

The transformation and bounding volume hierarchy is updated on the backend using jobs. At present this is still a single job doing all but we plan to split this shortly for better performance.

We've not yet benchmarked this against the likes of Unity. We are aware of many areas that could be optimised but before we get on to that we want to finish off the last few bits of API needed for the initial release. Of course if you wish to help, that would be awesome and very much appreciated.

Hello. Thank you for your great blog. I have watched the video "Introducing Qt3D 2.0 (3D rendering & visualisation)" that you have on youtube. In one of the introductory slides it is said that one of the reasons for Qt3d is to avoid using VTK, OpenSceneGraph and such. I'm currently working on a desktop application which uses Qt+OpenSceneGraph, and so very interested in Qt3D so that to reduce the dependency. My application is a small scale CAD-like system, however it is supposed to produce large scenes with multiple views on the scene. So, when I render the scene, I do it on demand (no timer is used). My question is: is rendering on demand possible in Qt3d?

Sean Harmer

Managing Director KDAB UK

Dr Sean Harmer is a senior software engineer at KDAB where he heads up our UK office and also leads the 3D R&D team. He has been developing with C++ and Qt since 1998 and is Qt 3D Maintainer and lead developer in the Qt Project. Sean has broad experience and a keen interest in scientific visualization and animation in OpenGL and Qt. He holds a PhD in Astrophysics along with a Masters in Mathematics and Astrophysics.

Qt 3D Technology Preview Released with Qt 5.5.0

18 Comments

Related Content

OpenGL in Qt 5.1 - Part 1

OpenGL in Qt 5.1 – Part 2

OpenGL in Qt 5.1 – Part 3

Join KDAB Training Day 2025 in Munich

Sign up for the KDAB Newsletter