What's new in this version: - When developing Qt 6, we had an in-depth look at some of Qt's most central parts to identify how we could improve them. We discovered a couple of core focus areas that we invested considerable time in improving. Those areas include: C++17: - With Qt 6 we now require a C++17 compatible compiler enabling the use more modern C++ language constructs when developing Qt and also allows for integration points on the API side. - Core libraries and APIs - Much work has gone into Qt Core, as it is the module that implements the most central parts of Qt. We've gone through many areas there and made improvements. To name some of the most central ones: - The new property and binding system: This system now brings the concept of bindings that made QML such a huge success in Qt 5 available from C++. - Strings and Unicode: With Qt 5, we started aligning Qt fully with Unicode, where we completed a lot of the work, but a few items remained that we now cleaned up for Qt 6. More details will come in a separate blog post later on. - QList has been a class that was often criticized in Qt 5, as it was heap allocating objects stored in there that were larger than a pointer, leading to pressure on heap allocation methods. In Qt 6, we changed this and unified QList and QVector into one class. See our blog post about QList in Qt 6 for details. - QMetaType and QVariant are fundamental to how our Qt’s meta-object system works. Signals and slots would not be possible without QMetaType and QVariant is required for dynamic invocations. Those two classes got an almost complete rewrite with Qt 6, and you can read about the details here. - Other parts of Qt that are not related to graphics have also seen large changes. For example, Qt Concurrent has undergone an almost complete rewrite and now makes development of multi-threaded applications more effortless than ever. Qt Network has seen lots of clean-up and improvements.
New graphics architecture: - The graphics architecture of Qt 5 was very much dependent on OpenGL as the underlying 3D graphics API. While this was the right approach in 2012 when we created Qt 5, the market around us has changed significantly over the last couple of years with the introduction of Metal and Vulkan. We now have a large set of different graphics APIs that are commonly being used on different platforms. For Qt as a cross-platform framework, this, of course, meant that we had to adjust to this and ensure our users can run Qt on all of them with maximum performance. - So while Qt 5 relied on OpenGL for hardware-accelerated graphics, the picture completely changes with Qt 6. All of our 3D graphics in Qt Quick is now built on top of a new abstraction layer for 3D graphics called RHI (Rendering Hardware Interface). RHI makes it possible for Qt to use the native 3D graphics API of the underlying OS/platform. So Qt Quick will now use Direct3D on Windows and Metal on macOS by default. For details, have a look at the blog post series about the RHI. - The OpenGL specific classes in Qt still exist, but are now moved out of QtGui in the QtOpenGL module. We also added a new module called QtShaderTools to deal with the different shading languages of those APIs in a cross-platform way.
Qt Quick 3D and Qt 3D: - Qt Quick 3D is a relatively new module. It seamlessly extends Qt Quick with 3D capabilities. With Qt Quick 3D, our focus was to create an API that is as easy to use as the existing parts of Qt Quick (for 2D user interfaces) while providing full support for creating complex 3D scenes. The main goal behind this effort has been to enable seamless integration between 2D and 3D content. - This module has seen significant improvements with Qt 6 that we wouldn’t have been able to do in the Qt 5 series. Most importantly it is now always using the RHI abstraction layer to make optimal use of the underlying graphics API and Hardware. Additionally, it now features a much deeper and more performant integration between 2D and 3D content, allowing you to place 2D items into a 3D scene. It also has vastly improved support for glTF2 and physics-based rendering, making it trivial to import assets created in other design tools. There are many other major improvements in the module, a more in-depth description can be found in a separate blog post. - Qt 3D is now also based on top of the RHI abstraction layer, has seen some performance improvements and cleanups. You can find more details in two blog posts by our partner KDAB (here and here).
Desktop styling for Qt Quick: - When we created the set of controls for Qt Quick, our focus was to make them lightweight and performant. For that reason, they did not support desktop styling in Qt 5. However, in Qt 6, we found a way to make them look & feel native on desktop operating systems. With 6.0, Qt Quick now supports native styling on both macOS and Windows. See this blog post for details. Native look & feel for Android and Linux already existed with the Material and Fusion styles in Qt 5. We are improving those for future Qt releases and are also planning to implement a native style for iOS. - Interfacing with platform specific functionality: - Even with Qt offering most functionality required to develop your application platform-independently, there is sometimes a need to interface with platform-specific functionality. In Qt 5, we provided a set of add-on modules (QtX11Extras, QtWinExtras, QtMacExtras) to help with this purpose. But this full separation from the rest of Qt has led to a couple of architectural issues, inconsistencies and code duplication within Qt. In Qt 6, we made an effort to clean this up and fold the functionality offered by those add-on modules into platform specific APIs offered directly in Qt. This will make interfacing with OS/platform-specific APIs much easier in Qt 6. Have a look here for more details.
Build system and Packaging: - We also made some considerable changes in how we build and distribute Qt. Worth mentioning is that Qt 6 itself is now built using CMake. This has also led to significant improvements for all our users that use CMake to build their projects. We will continue to support qmake for the lifetime of Qt 6, so there is no need to make any changes to your build system if you're using it, but we recommend to use CMake for all new projects. - Qt 6 also comes with a much smaller default package, and many of the add-ons are now distributed as separate packages through a package manager. This gives us more flexibility in adapting release schedules of add-ons to market requirements, allowing, for example, for more frequent feature releases as the core Qt packages or making them available for multiple Qt versions at the same time. In addition, we can use the package manager as a delivery channel for 3rd party content. And finally, it gives our users more flexibility as they can choose to download only what they really need. - Currently, we are using the existing Qt installer as the backend for the package manager, but are investigating alternatives for future releases. See the blog post here for more details.
Compatibility: - When making changes for Qt 6, we’ve tried to adjust our APIs to what we believe is required for the future while at the same time trying to break as little as possible for our existing users. While your code will need some adjustments to make the best possible use of Qt 6, we have tried to make porting to the new version as easy as possible - One of the first things we did was to clean up our codebase. During the lifetime of Qt 5, we deprecated quite a few APIs and even entire modules. The first thing we did was to remove those to get to a leaner Qt for the future and allow us to leave some things behind that do not make sense anymore today - However, we have taken care to mark as many of those APIs as possible as deprecated in Qt 5.15. Enabling deprecation warnings there and cleaning those up will bring you a long way towards making your codebase compatible with Qt 6 - Some of the most used APIs that have been removed in Qt 5 have been moved into a Qt5CoreCompat module. It contains a couple of widely used classes that have been removed from Qt 6, such as QRegExp, QTextCodec, the old SAX parser for XML, and a few other items. The intention of this module is meant as a porting help and will not receive bug fixes, apart from regressions against Qt 5 and security related problems. We recommend that you use it for porting but then incrementally remove your dependencies to the modules - If you want to start porting to Qt 6, we have a much more detailed porting guide in our documentation
Supported platforms: - Qt has always been a cross-platform, and that will continue in Qt 6. Qt 6.0 supports: - Windows 10 - macOS 10.14 and newer - Linux (Ubuntu 20.04, CentOS 8.1, OpenSuSE 15.1) - iOS 13 or newer - Android (API level 23 or newer) - On the embedded side, we support a wide range of embedded devices running Linux. Qt 6 does not yet support any of the embedded real-time operating systems supported in Qt 5. Both QNX and INTEGRITY have recently added support for C++17, and we plan to add support for them by the time we release Qt 6.2.
Outlook: - Qt 6.0 does not yet support many of the add-on modules that can be found in Qt 5.15. This was intentionally decided to free up time to ensure that we could complete all the changes we needed to make for the Qt framework's essential modules - We are now in the working on bringing most of those add-ons over to Qt 6. We have already done a lot of work, and we expect to have most add-ons supported again by the time we release Qt 6.2. Many add-ons already compile already against Qt 6, but they are not yet officially released as some cleanup work and refactoring remains to be done. We plan to have most of the important add-ons ported by the time we release Qt 6.2. Get a full overview of our add-on support in Qt 6.0 and beyond in the following blog post - Apart from porting the missing add-ons over to Qt 6, a lot of our Qt 6 related work in the next coming months will focus on the stability of the new releases and taking the new property system into more wide-spread use within Qt itself - We have adjusted our release timelines for Qt 6.1 and 6.2, and are planning to release Qt 6.1 already in April. After that, we plan to release our first long term supported version in the Qt 6 series, Qt 6.2 LTS, by the end of September - And we are not yet done for this year, and you can also expect a brand new version of Qt Creator and Qt Design Studio to be released before Christmas! Both will come with full support for Qt 6
Qt 6.0.0 相關參考資料
Getting Started with Qt | Qt 6.0 - Qt Documentation Snapshots
Qt Documentation Snapshots · Qt 6.0; Getting Started with Qt; Qt 6.0.0 ('dev' branch). Contents. Get and ...
https://doc-snapshots.qt.io
New Features in Qt 6.0 - Qt Wiki
2020年12月8日 — Qt 6.0, as a major release of Qt, provides a higher degree of freedom to implement new features, functionality, and better support today and ...
https://wiki.qt.io
Qt 6.0
6 天前 — Qt is a full development framework with tools designed to streamline the creation of applications and user interfaces for desktop, embedded, ...
https://doc-snapshots.qt.io
Qt 6.0 - Qt Documentation Snapshots
Qt is a full development framework with tools designed to streamline the creation of applications and user interfaces for desktop, embedded, and mobile ...
https://doc-snapshots.qt.io
Qt 6.0 Beta Released
2020年10月20日 — I am pleased to announce that we released the first beta of Qt 6.0 today. We have provided multiple pre-release snapshots of Qt 6.0 during the ...
https://www.qt.io
Qt 6.0 Feature Freeze Milestone Reached
2020年9月1日 — December 2020: Qt 6.0.0 Release. With the feature freeze milestone now reached, next milestone is the Alpha release. This is still quite a lot ...
https://www.qt.io
Qt 6.0 Release - Qt Wiki
Branch 6.0.0 from 6.0, Before RC, 20.11.2020. Beta4 release, 11.11.2020, 10.11.2020. Beta5 release, 16.11.2020. Release Candidate, 17.11.2020, 24.11.2020 ...
https://wiki.qt.io
Qt GUI 6.0.0
The Qt GUI module provides classes for windowing system integration, event handling, OpenGL and OpenGL ES integration, 2D graphics, basic imaging, fonts ...
https://doc-snapshots.qt.io
Qt QML 6.0.0
Using the Module. QML API. The QML types in Qt QML are available through the QtQml import. To use the types, add the following import ...
https://doc-snapshots.qt.io
Qt Quick 3D 6.0.0
Qt Documentation Snapshots · Qt 6.0; Qt Quick 3D; Qt 6.0.0 ('dev' branch). Contents. Prerequisites; Building From Source; Module Evolution; License and ...
https://doc-snapshots.qt.io
|