Modifications apportées à Qt Quick

Qt 6 sont le fruit d'un effort délibéré visant à rendre le framework plus efficace et plus facile à utiliser.

Nous nous efforçons de maintenir la compatibilité binaire et source pour toutes les API publiques à chaque version. Cependant, certaines modifications étaient inévitables afin d’améliorer le framework Qt.

Dans cette rubrique, nous résumons ces modifications dans Qt Quick et fournissons des conseils pour les prendre en compte.

Modifications apportées aux types QML d'Qt Quick

Modification du type « font.weight »

Le type de ` font.weight ` a été remplacé par ` int`. Les classes de graisse prédéfinies existent toujours, mais il est désormais possible d’utiliser des entiers arbitraires pour sélectionner des polices qui ne correspondent à aucune de ces classes de graisse. Cela garantit la parité avec l’API C++, où il a toujours été possible d’exprimer la graisse d’une police sous la forme d’un entier arbitraire.

La plupart des codes ne seront pas affectés par ce changement, sauf dans le cas où une conversion implicite d’une chaîne de caractères en valeur d’énumération était utilisée.

font.weight: "Bold"

Ce code ne sera plus interprété correctement et devra être remplacé par la valeur d’énumération équivalente, comme illustré ci-dessous.

font.weight: Font.Bold

FontLoader.name est désormais une propriété en lecture seule

Dans Qt 5, la propriété ` name ` de ` FontLoader ` était modifiable et remplaçait la propriété `source` de l’élément lorsqu’elle était définie. Cela a semé une certaine confusion quant à son utilité et pouvait entraîner un comportement indéterminé en cas de condition de concurrence entre les accesseurs des propriétés en conflit.

Cela signifie qu’un code tel que celui-ci ne fonctionnera plus.

FontLoader {
    id: fontLoader
    name: "Helvetica"
}

Text {
    font.family: fontLoader.name
    text: "Foobar"
}

Utilisez plutôt une propriété personnalisée pour stocker les noms de familles de polices.

property string fontName: "Helvetica"

Text {
    font.family: fontName
    text: "Foobar"
}

Le type QML OpenGLInfo est supprimé

Dans Qt 5.8, OpenGLInfo a été déprécié et est supprimé dans Qt 6. Veuillez utiliser GraphicsInfo à la place.

ShaderEffect ne prend plus en charge les chaînes de shaders GLSL en ligne

Tout comme avec ` custom materials`, les effets ne sont plus spécifiés sous forme de chaînes de shaders GLSL. Les shaders doivent désormais être prétraités par les outils du module Qt Shader Tools, tels que l’outil en ligne de commande qsb, ce qui garantit que les ressources de shaders sont utilisables quelle que soit l’API graphique (Vulkan, Metal, OpenGL ou Direct 3D) utilisée lors de l’exécution. Les éléments « ShaderEffect » doivent faire référence aux fichiers « .qsb » ainsi générés.

Les propriétés « Source » de ShaderEffect sont désormais des URL

Les propriétés ShaderEffect vertexShader et fragmentShader ont désormais toutes deux le type QUrl, au lieu de QByteArray. Leur comportement est donc identique à celui d’autres propriétés similaires, telles que Image.source. Le code existant qui fait référence à des fichiers via les schémas file ou qrc continuera de fonctionner tel quel. De plus, cette modification permet de faire référence à des fichiers avec un chemin relatif à l’emplacement du composant (le fichier .qml). La spécification du schéma file: est donc désormais facultative.

Modifications apportées aux API C++ d’ Qt Quick

Modifications apportées à QQuickItem

QQuickItemLa fonction geometryChanged() a été renommée geometryChange().

Modifications apportées aux API QQuick*

• Les applications souhaitant intégrer leur propre ensemble de commandes de rendu Vulkan, Metal ou Direct3D doivent prendre en compte les nouveaux signaux d’ QQuickWindow, en plus de QQuickWindow::beforeRendering() et afterRendering(). Le modèle existant de Qt 5, qui consiste à se connecter uniquement à `beforeRendering` ou `afterRendering`, n’est souvent plus suffisant à lui seul et devra probablement être complété par la connexion à des signaux supplémentaires, tels que ` beforeRenderPassRecording()` ou ` afterRenderPassRecording()`.
• Les applications qui s’appuient sur les signaux ` QQuickWindow::beforeRendering()` ou `afterRendering()` pour émettre leur propre ensemble de commandes de rendu OpenGL doivent appeler ` QQuickWindow::beginExternalCommands()` avant, et ` QQuickWindow::endExternalCommands()` après, les appels OpenGL. Cela garantit que les modifications d’état effectuées par le code de l’application n’entraînent pas de confusion par rapport à l’état mis en cache par le moteur de rendu du graphe de scène. Notez toutefois que, tout comme dans Qt 5, la modification d’un état OpenGL 3.x ou 4.x non utilisé par le moteur de rendu « Qt Quick » peut toujours entraîner des problèmes inattendus ; il est donc conseillé aux applications de réinitialiser tout état OpenGL de ce type à sa valeur par défaut avant de quitter les slots ou les lambdas associés à ces signaux.
• Les surcharges existantes de la fonction ` QQuickWindow::setRenderTarget()` et les getters associés ont été supprimés et remplacés par une nouvelle fonction prenant un argument ` QQuickRenderTarget`. Les applications effectuant un rendu redirigé en combinaison avec ` QQuickRenderControl ` doivent désormais utiliser cette nouvelle fonction pour spécifier la cible de rendu d’une manière qui ne soit pas liée à OpenGL.
• La surcharge de la fonction ` QQuickWindow::setSceneGraphBackend()` prenant un argument ` QSGRendererInterface::GraphicsApi ` a été renommée ` setGraphicsApi()`.
• Les fonctions ` QQuickWindow ` `setPersistentOpenGLContext` et `isPersistentOpenGLContext` ont été renommées et s’appellent désormais respectivement ` QQuickWindow::setPersistentGraphics()` et ` QQuickWindow::isPersistentGraphics()`.
• Les fonctions setClearBeforeRendering() et clearBeforeRendering() ont été supprimées de l’ QQuickWindow. Il n’existe aucune option permettant d’ignorer l’effacement du tampon de couleur dans Qt 6. L’appel de setClearBeforeRendering() était souvent nécessaire dans Qt 5 en combinaison avec des sous-couches, afin d’empêcher Qt Quick d’effacer le contenu rendu dans le tampon de couleur. Dans Qt 6, il existe une approche plus robuste : se connecter au signal « beforeRenderPassRecording() », qui est émis après l’effacement, mais avant le rendu du contenu de Qt Quick.
• La fonction QQuickWindow::openglContext() a été supprimée. Une fois que l’application s’est assurée que le graphe de scène utilise OpenGL pour le rendu, elle peut interroger QOpenGLContext à partir de QSGRendererInterface::getResource().
• Le signal QQuickWindow::openglContextCreated() a été supprimé.
• La fonction obsolète QQuickWindow::createTextureFromId() a été supprimée. Utilisez à la place la fonction fromNative() de QPlatformInterface::QSGOpenGLTexture, QPlatformInterface::QSGVulkanTexture, QPlatformInterface::QSGD3D11Texture ou QPlatformInterface::QSGMetalTexture.
• La classe ` QQuickFramebufferObject ` est disponible avec une API inchangée, mais ne fonctionne que lorsque le graphe de scène est rendu avec OpenGL. Elle ne fonctionnera pas si vous utilisez une autre API graphique, telle que Vulkan ou Metal. Les applications s'appuyant sur ` QQuickFramebufferObject ` doivent forcer l'utilisation d'OpenGL en appelant ` QQuickWindow::setGraphicsApi(QSGRendererInterface::OpenGL) ` dans leur fonction `main()`.
• QQuickRenderControl L’API a subi de légères modifications : la fonction `grab()` a été supprimée ; utilisez à la place ` QQuickWindow::grabWindow()`, le cas échéant. La fonction `initialize()` ne prend plus en paramètre de ` QOpenGLContext`. Les applications doivent désormais également appeler ` QQuickRenderControl::beginFrame()` et ` QQuickRenderControl::endFrame()` selon les besoins. Lorsque le multisampling est souhaité, la nouvelle fonction ` QQuickRenderControl::setSamples()` doit être appelée pour indiquer le nombre d’échantillons.
• Les applications souhaitant effectuer un rendu « Qt Quick » en combinaison avec un périphérique graphique natif ou un objet de contexte existant doivent utiliser la nouvelle fonction QQuickWindow::setGraphicsDevice(), car QQuickRenderControl ne fournit plus la fonction initialize(QOpenGLContext*).
• La configuration de QQuickPaintedItem et Context2D en mode Framebuffer n’a aucun effet. Le comportement sera identique à celui du mode Image par défaut.
• La variable d’environnement QSG_NO_DEPTH_BUFFER est toujours prise en charge dans Qt 6.0, mais il est recommandé de remplacer son utilisation par l’appel à setDepthBufferFor2D() sur un QQuickGraphicsConfiguration qui est ensuite associé à QQuickWindow.

Modifications apportées aux API QSG*

• QSGMaterialShader L’interface a été modifiée. Les implémentations ne doivent plus s’appuyer sur OpenGL et ne peuvent plus partir du principe que des fonctions, telles que `updateState()` désormais supprimée, sont appelées avec un ` QOpenGLContext ` actif. Dans la nouvelle interface orientée données, `updateState()` est remplacée par ` updateUniformData()`, ` updateSampledImage()` et ` updateGraphicsPipelineState()`. Au lieu d’un code de shader GLSL fourni sous forme de chaînes de caractères, les shaders doivent désormais être prétraités par les outils du module Qt Shader Tools, tels que l’outil en ligne de commande qsb, garantissant ainsi que les ressources de shader sont utilisables quelle que soit l’API graphique (Vulkan, Metal, OpenGL ou Direct 3D) utilisée lors de l’exécution.
• QSGEngine a été supprimé. Dans le cas improbable où une application utiliserait cette classe, il est recommandé de migrer vers l’utilisation d’ QQuickRenderControl.
• QSGAbstractRenderer n’est plus publique. L’utilisation de cette classe n’avait de sens qu’en combinaison avec QSGEngine, et cette dernière ayant été supprimée, QSGAbstractRenderer a été replacée en mode privé.
• La classe de commodité QSGSimpleMaterial a été supprimée. Les applications doivent désormais utiliser les API révisées et indépendantes d’OpenGL d’ QSGMaterial.
• Pour accéder à l’objet texture natif sous-jacent d’un QSGTexture, la méthode textureId() n’est plus disponible. À la place, utilisez `QSGTexture::platformInterface()` avec `QPlatformInterface::QSGOpenGLTexture`, `QPlatformInterface::QSGVulkanTexture`, `QPlatformInterface::QSGD3D11Texture` ou `QPlatformInterface::QSGMetalTexture`.
• Les sous-classes de ` QSGImageNode ` doivent désormais redéfinir de nouvelles fonctions virtuelles supplémentaires, telles que `setAnisotropyLevel()` et `anisotropyLevel()`.
• Les sous-classes de ` QSGTexture ` devront probablement être repensées. Certaines fonctions virtuelles spécifiques à OpenGL, telles que `bind()` ou `updateBindOptions()`, n’existent plus, tandis que de nouvelles fonctions virtuelles doivent impérativement être implémentées, comme ` comparisonKey()`.

Modifications concernant l’utilisation d’OpenGL dans Qt Quick

Bien que cela n’entraîne aucune rupture pour de nombreuses applications, les développeurs doivent savoir qu’OpenGL n’est plus toujours le choix par défaut pour le rendu d Qt Quick s dans Qt 6. À moins d’utiliser le backend software, une application Qt Quick peut utiliser OpenGL, Vulkan, Metal ou Direct3D 11 lors de l’exécution. En l’absence de demande explicite, que ce soit via la variable d’environnement ` QSG_RHI_BACKEND ` ou la fonction ` QQuickWindow::setSceneGraphBackend()`, une valeur par défaut spécifique à la plateforme est choisie par ` Qt Quick`.

Pour plus d’informations, consultez les pages « Graphique de scène » surQt Quick et « Rendu par défaut du graphe de scène » sur Qt Quick .