Qt pour Windows - Accélération graphique

Pour que Qt Quick fonctionne, un pilote graphique prenant en charge Direct 3D 11, Direct 3D 12, Vulkan 1.0 ou OpenGL 2.1 ou supérieur est nécessaire. À partir de Qt 6, la valeur par défaut pour Qt Quick sur Windows est Direct3D 11. Ceci est différent de Qt 5, où la valeur par défaut était OpenGL, soit directement, soit par l'intermédiaire d'ANGLE, un traducteur OpenGL vers Direct3D. ANGLE n'est plus fourni avec Qt dans Qt 6.

Pour forcer l'utilisation du rasterizer logiciel de Direct3D (WARP), définissez la variable d'environnement QSG_RHI_PREFER_SOFTWARE_RENDERER à 1. Dans certains cas, Qt Quick effectuera une telle substitution automatiquement, afin de permettre l'exécution d'applications Qt sans configuration supplémentaire. Cela se produit lorsque les pilotes ne fournissent pas un niveau suffisant de fonctionnalité D3D11, et se produit typiquement dans les machines virtuelles qui n'ont pas d'accélération GPU appropriée et de passthrough implémenté. En cas de doute sur le périphérique graphique utilisé, et lorsque vous dépannez ou signalez des problèmes à Qt XML, exécutez l'application avec la variable d'environnement QSG_INFO=1 définie et inspectez la sortie de débogage. L'exécution de l'outil qtdiag peut également fournir des informations utiles puisqu'il énumère toutes les API 3D disponibles.

Pour demander l'utilisation de Vulkan, OpenGL ou Direct 3D 12, définissez la variable d'environnement QSG_RHI_BACKEND sur vulkan ou opengl ou d3d12, ou utilisez l'équivalent C++ API dans main(). Notez que certaines de ces API 3D peuvent nécessiter l'installation des pilotes appropriés.

Bien qu'il ne s'agisse pas de l'API par défaut de Qt QuickOpenGL est encore couramment utilisé dans de nombreuses applications Qt, par exemple dans les applications basées sur QWidget et construites sur QOpenGLWindow ou QOpenGLWidget. Les sections suivantes couvrent certaines spécificités OpenGL d'une construction Qt.

Chargement dynamique d'OpenGL

Qt OpenGL supporte le choix et le chargement de l'implémentation OpenGL au moment de l'exécution. Ce mode est le mode par défaut, et peut être explicitement demandé en passant -opengl dynamic au script de configuration.

configure -opengl dynamic

Cette configuration est la plus flexible car aucune dépendance ou hypothèse n'est codée en dur à propos de l'implémentation OpenGL au moment de la compilation. Elle permet un déploiement robuste des applications. Lorsqu'un environnement donné ne parvient pas à fournir une implémentation OpenGL 2.0 appropriée, il se rabat automatiquement sur le chargement d'une alternative à opengl32.dll, dont le nom par défaut est opengl32sw.dll. Les paquets Qt pré-intégrés contiennent une version de Mesa llvmpipe, une implémentation logicielle de rasterisation d'OpenGL, sous ce nom.

Lorsqu'il est configuré avec -opengl dynamic, ni Qt ni les applications construites à l'aide de qmake ou CMake ne se lient à opengl32.lib. Au lieu de cela, la bibliothèque est choisie et chargée au moment de l'exécution. Par défaut, Qt détermine si la bibliothèque opengl32.dll du système fournit des fonctions OpenGL 2. Si elles sont présentes, opengl32.dll est utilisé, sinon il tente de charger opengl32sw.dll. Voir ci-dessous pour plus de détails.

Le mécanisme de chargement peut être configuré via la variable d'environnement QT_OPENGL et les attributs d'application suivants :

• Qt::AA_UseDesktopOpenGL Équivalent au réglage de QT_OPENGL sur desktop.
• Qt::AA_UseOpenGLES N'a pas d'effet dans Qt 6.
• Qt::AA_UseSoftwareOpenGL Équivalent à la configuration de QT_OPENGL en software.

Lorsqu'une certaine configuration est demandée explicitement, aucune vérification n'est effectuée au démarrage de l'application, c'est-à-dire que la dll opengl32.dll fournie par le système n'est pas examinée.

Le chargement dynamique a un impact significatif sur les applications qui contiennent des appels OpenGL natifs : elles peuvent échouer à lier puisque opengl32.lib n'est pas automatiquement spécifié à l'éditeur de liens. Au lieu de cela, les applications sont censées utiliser les fonctions OpenGL via la classe QOpenGLFunctions. Ainsi, la dépendance directe vis-à-vis de la bibliothèque OpenGL est supprimée et tous les appels seront acheminés pendant l'exécution vers l'implémentation choisie par Qt. Alternativement, les applications sont libres de faire des appels directs aux fonctions OpenGL si elles ajoutent opengl32.lib à leurs fichiers de projet .pro : LIBS += opengl32.lib (Visual Studio) ou LIBS += -lopengl32 (Mingw-w64). Le résultat est, du point de vue de l'application, équivalent à la configuration de construction -opengl desktop de Qt.

Qt::AA_UseSoftwareOpenGL est spécial dans le sens où il essaiera de charger une implémentation OpenGL avec un nom non-standard. Le nom par défaut est opengl32sw.dll. Cela permet d'envoyer une implémentation OpenGL uniquement logicielle, par exemple une version de Mesa avec llvmpipe, sous ce nom. Si nécessaire, le nom de fichier peut être remplacé par la variable d'environnement QT_OPENGL_DLL.

Il est possible de fournir un fichier de configuration au format JSON spécifiant l'implémentation OpenGL à utiliser en fonction de la carte graphique et de la version du pilote. L'emplacement est donné par la variable d'environnement QT_OPENGL_BUGLIST. Les chemins relatifs sont résolus en utilisant QLibraryInfo::SettingsPath ou QStandardPaths::ConfigLocation. Le fichier utilise le format de la liste de bogues des pilotes utilisée dans les projets Chromium. Il consiste en une liste d'entrées dont chacune spécifie un ensemble de conditions et une liste de mots-clés de caractéristiques. Généralement, l'identifiant du périphérique et l'identifiant du fournisseur sont utilisés pour faire correspondre une carte graphique spécifique. Ils peuvent être trouvés dans la sortie de l'outil qtdiag6 ou dxdiag.

Les mots-clés suivants sont importants pour le choix de l'implémentation OpenGL :

• disable_desktopgl - Désactive OpenGL. Cela garantit que Qt n'essaie pas d'utiliser OpenGL normal (opengl32.dll), et qu'il démarre immédiatement avec ANGLE. Ceci est utile pour éviter que de mauvais pilotes OpenGL ne fassent planter l'application.
• disable_rotation - Force l'application à fonctionner toujours en orientation paysage. Cette option n'a aucun effet sur l'utilisation d'une implémentation logicielle d'OpenGL. Ceci est destiné aux pilotes qui ont des problèmes avec la rotation.
• disable_program_cache - Désactive le stockage des binaires des programmes de shaders sur le disque.

Un exemple de fichier ressemble à ceci :

{
"entries": [
{
  "id": 1,
  "description": "Disable D3D11 on older nVidia drivers",
  "os": {
    "type": "win"
  },
  "vendor_id": "0x10de",
  "device_id": ["0x0DE9"],
  "driver_version": {
    "op": "<=",
    "value": "8.17.12.6973"
  },
  "features": [
    "disable_d3d11"
  ]
},
...

Si QT_OPENGL_BUGLIST n'est pas spécifié, une liste intégrée sera utilisée. Cela inclut généralement certaines cartes graphiques plus anciennes et moins performantes avec disable_desktopgl, afin d'empêcher Qt d'utiliser leurs implémentations instables d'OpenGL de bureau et d'essayer de charger immédiatement la bibliothèque alternative basée sur le logiciel.

Dans la pratique, les combinaisons les plus courantes devraient être les suivantes :

• disable_desktopgl - Dans le cas où le système fournit OpenGL 2.0 ou plus récent, mais que le pilote est connu pour être instable et susceptible de planter.
• disable_desktopgldisable_angle - Lorsqu'aucune trajectoire accélérée n'est souhaitée. Cela garantit que la seule option essayée par Qt est le rasterizer logiciel (opengl32sw.dll). Cela peut être utile dans les machines virtuelles et les applications qui sont déployées sur un large éventail d'anciens systèmes.

Les clés prises en charge pour faire correspondre une carte ou un pilote donné sont les suivantes. Notez que certaines d'entre elles sont spécifiques à Qt.

• os.type - Système d'exploitation : win, linux, macosx, android
• os.version - Version du noyau
• os.release - Spécifie une liste de versions du système d'exploitation sous Windows : xp, vista, 7, 8, 8.1, 10.
• vendor_id - Vendeur de l'identifiant de l'adaptateur
• device_id - Liste des identifiants des périphériques PCI.
• driver_version - Version du pilote à partir de l'identifiant de l'adaptateur
• driver_description - Correspond à une sous-chaîne de la description du pilote à partir de l'identificateur de l'adaptateur.
• gl_vendor - Correspond à la valeur lorsque celle-ci est une sous-chaîne de la chaîne GL_VENDOR.

Pour désactiver toute mise en liste noire, donnez une valeur quelconque à la variable d'environnement QT_NO_OPENGL_BUGLIST. Cela évitera de lire les fichiers de configuration et supposera que rien n'est désactivé, quel que soit le pilote ou le système d'exploitation.

Dépendance directe à opengl32.dll

Une alternative à la construction par défaut de dynamic OpenGL est de dépendre directement de opengl32.dll. Pour ce mode, passez les options de ligne de commande -opengl desktop au script de configuration.

configure -opengl desktop

Dans de telles versions de Qt, de nombreuses bibliothèques partagées de Qt, ainsi que des applications Qt, dépendent de opengl32.dll, et l'utilisation d'une bibliothèque alternative n'est donc pas possible.