Changements apportés à Qt Quick

Qt 6 est le résultat d'un effort conscient pour rendre le cadre plus efficace et plus facile à utiliser.

Nous essayons de maintenir la compatibilité binaire et source pour toutes les API publiques dans chaque version. Mais certains changements étaient inévitables dans un effort pour faire de Qt un meilleur framework.

Dans cette rubrique, nous résumons ces changements dans Qt Quick, et fournissons des conseils pour les gérer.

Changements apportés à Qt Quick Types QML

Modification du type de font.weight

Le type de font.weight a été modifié en int. Les classes de poids prédéfinies existent toujours, mais il est désormais possible d'utiliser des nombres entiers arbitraires pour sélectionner des polices qui ne correspondent à aucune de ces classes de poids. Cela garantit la parité avec l'API C++, où il a toujours été possible d'exprimer le poids de la 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 a été utilisée.

font.weight: "Bold"

Ce code ne sera plus analysé correctement et devra être remplacé par sa valeur enum équivalente, comme démontré ci-dessous.

font.weight: Font.Bold

FontLoader.name est maintenant une propriété en lecture seule

Dans Qt 5, la propriété name de FontLoader était accessible en écriture et remplaçait la propriété source de l'élément lorsqu'elle était définie. Cela a entraîné une certaine confusion quant à son objectif et a pu provoquer un comportement indéterminé s'il y avait une condition de course entre les fixateurs pour les propriétés conflictuelles.

Cela signifie que le code suivant 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 des familles de polices.

property string fontName: "Helvetica"

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

Le type QML OpenGLInfo est supprimé

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

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

Tout comme pour custom materials, les effets ne sont plus spécifiés sous la forme de chaînes de shaders GLSL. Au lieu de cela, les shaders sont censés ê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 actifs de shaders sont utilisables quelle que soit l'API graphique (Vulkan, Metal, OpenGL ou Direct 3D) utilisée au moment de l'exécution. Les éléments ShaderEffect sont censés référencer les fichiers .qsb qui en résultent.

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

Les propriétés ShaderEffect, vertexShader et fragmentShader ont toutes deux un 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 le schéma file ou qrc continuera à fonctionner tel quel. En outre, 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++ de Qt Quick

Modifications apportées à la fonction geometryChanged() de QQuickItem

QQuickItemLa fonction geometryChanged() de QQuickItem 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 être conscientes des nouveaux signaux QQuickWindow en plus de QQuickWindow::beforeRendering() et afterRendering(). Le schéma existant de Qt 5 consistant à se connecter à juste beforeRendering ou afterRendering n'est souvent plus suffisant à lui seul, et devra probablement être complété par une connexion à des signaux supplémentaires, tels que beforeRenderPassRecording() ou afterRenderPassRecording().
• Les applications qui s'appuient sur les signaux QQuickWindow::beforeRendering() ou afterRendering() pour émettre leurs propres commandes de rendu OpenGL devraient appeler QQuickWindow::beginExternalCommands() avant, et QQuickWindow::endExternalCommands() après, les appels OpenGL. Cela permet de s'assurer que les changements d'état effectués par le code de l'application n'entraînent pas de confusion en ce qui concerne l'état mis en cache du moteur de rendu du graphe de scène. Notez cependant que, tout comme dans Qt OpenGL 5, changer l'état d'OpenGL 3.x ou 4.x qui n'est pas utilisé par le moteur de rendu Qt Quick peut toujours conduire à des problèmes inattendus, il est donc conseillé aux applications de réinitialiser un tel état OpenGL à la valeur par défaut avant de revenir des slots ou lambdas connectés à ces signaux.
• Les surcharges QQuickWindow::setRenderTarget() existantes, et les getters associés, sont supprimés et remplacés par une nouvelle fonction prenant un QQuickRenderTarget. Les applications effectuant un rendu redirigé en combinaison avec QQuickRenderControl sont maintenant censées utiliser cette nouvelle fonction pour spécifier la cible de rendu d'une manière qui n'est pas liée à OpenGL.
• La surcharge QQuickWindow::setSceneGraphBackend() prenant un argument QSGRendererInterface::GraphicsApi a été renommée setGraphicsApi().
• Les fonctions QQuickWindow setPersistentOpenGLContext et isPersistentOpenGLContext ont été renommées, et sont maintenant QQuickWindow::setPersistentGraphics() et QQuickWindow::isPersistentGraphics().
• setClearBeforeRendering() et clearBeforeRendering() ont été supprimées de QQuickWindow. Il n'y a pas d'option pour sauter le nettoyage du tampon de couleur dans Qt 6. L'appel à setClearBeforeRendering() était souvent nécessaire dans Qt 5 en combinaison avec des sous-couches, pour empêcher Qt Quick d'effacer le contenu rendu dans le tampon de couleur. Dans Qt 6, il existe une approche plus robuste : la connexion 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. Lorsque 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 QQuickWindow::createTextureFromId() a été supprimée. A la place, utilisez la fonction fromNative() de QPlatformInterface::QSGOpenGLTexture, QPlatformInterface::QSGVulkanTexture, QPlatformInterface::QSGD3D11Texture, ou QPlatformInterface::QSGMetalTexture.
• La classe QQuickFramebufferObject est disponible avec une API inchangée, mais n'est fonctionnelle que lorsque le rendu de la scène est effectué avec OpenGL. Elle ne sera pas fonctionnelle lors de l'utilisation d'une autre API graphique, telle que Vulkan ou Metal. Les applications qui s'appuient sur QQuickFramebufferObject doivent forcer l'utilisation d'OpenGL en appelant QQuickWindow::setGraphicsApi(QSGRendererInterface::OpenGL) dans leur fonction main().
• QQuickRenderControl a une API légèrement modifiée : grab() est maintenant supprimé, utilisez QQuickWindow::grabWindow() à la place, le cas échéant. La fonction initialize() ne prend plus de QOpenGLContext. Les applications doivent également appeler QQuickRenderControl::beginFrame() et QQuickRenderControl::endFrame(), le cas échéant. Lorsque le multi-échantillonnage est souhaité, la nouvelle fonction QQuickRenderControl::setSamples() doit être appelée pour indiquer le nombre d'échantillons.
• Les applications qui souhaitent effectuer le rendu Qt Quick en combinaison avec un périphérique graphique natif existant ou un objet contextuel doivent utiliser la nouvelle fonction QQuickWindow::setGraphicsDevice(), car QQuickRenderControl ne fournit plus la fonction initialize(QOpenGLContext*).
• Le fait de mettre QQuickPaintedItem et Context2D en mode Framebuffer n'a aucun effet. Il se comportera comme si le mode était défini sur le 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 la remplacer par l'appel à setDepthBufferFor2D() sur un QQuickGraphicsConfiguration qui est ensuite associé au QQuickWindow.

Changements apportés aux API de QSG

• QSGMaterialShader a une interface modifiée. Les implémentations ne doivent plus s'appuyer sur OpenGL et ne peuvent plus supposer que les fonctions, telles que la désormais supprimée updateState(), sont appelées avec un courant QOpenGLContext. Dans la nouvelle interface orientée données, updateState() est remplacée par updateUniformData(), updateSampledImage() et updateGraphicsPipelineState(). Au lieu du code de shader GLSL fourni sous forme de chaînes de caractères, on s'attend désormais à ce que les shaders soient prétraités par les outils du module Qt Shader Tools, tels que l'outil en ligne de commande qsb, garantissant ainsi que les actifs de shaders sont utilisables quelle que soit l'API graphique (Vulkan, Metal, OpenGL ou Direct 3D) utilisée au moment de l'exécution.
• QSGEngine a été supprimé. Dans le cas peu probable où une application utiliserait cette classe, il est recommandé d'utiliser QQuickRenderControl à la place.
• QSGAbstractRenderer n'est plus public. L'utilisation de cette classe n'avait de sens qu'en combinaison avec QSGEngine, et avec la suppression de cette classe, QSGAbstractRenderer est redevenu privé.
• La classe de commodité QSGSimpleMaterial a été supprimée. Les applications sont censées utiliser les API révisées et indépendantes d'OpenGL QSGMaterial à la place.
• Pour accéder à l'objet de texture natif sous-jacent pour une QSGTexture, textureId() n'est plus disponible. A la place, utilisez QSGTexture::platformInterface() avec QPlatformInterface::QSGOpenGLTexture, QPlatformInterface::QSGVulkanTexture, QPlatformInterface::QSGD3D11Texture, ou QPlatformInterface::QSGMetalTexture.
• Les sous-classes de QSGImageNode doivent désormais surcharger de nouvelles virtualités supplémentaires, telles que setAnisotropyLevel() et anisotropyLevel().
• Les sous-classes de QSGTexture devront probablement être redessinées. Certaines fonctions virtuelles spécifiques à OpenGL, telles que bind() ou updateBindOptions(), ne sont plus présentes, tandis que de nouvelles fonctions virtuelles doivent obligatoirement être implémentées, telles que comparisonKey().

Changements dans l'utilisation d'OpenGL Qt Quick

Bien que cela ne présente aucune rupture pour de nombreuses applications, les développeurs d'applications doivent être conscients que, OpenGL n'est plus toujours le choix par défaut pour le rendu Qt Quick dans Qt 6. À moins que le backend software ne soit utilisé, une application Qt Quick peut utiliser OpenGL, Vulkan, Metal ou Direct3D 11 au moment de l'exécution. Lorsqu'aucune demande explicite n'est faite, 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 Qt Quick Scene Graph et Qt Quick Scene Graph Default Renderer.