Qt pour Windows - Accélération graphique

Pour Qt Quick fonctionner, un pilote graphique prenant en charge Direct3D 11, Direct3D 12, Vulkan 1.0 ou OpenGL 2.1 ou une version supérieure est nécessaire. À partir de Qt 6, la valeur par défaut de la variable d’environnement Qt Quick sous Windows est Direct3D 11. Cela diffère de Qt 5, où la valeur par défaut était OpenGL, soit directement, soit via ANGLE, un convertisseur OpenGL vers Direct3D. ANGLE n’est plus fourni avec Qt dans la version 6.

Pour forcer l’utilisation du rastériseur logiciel de Direct3D (WARP), définissez la variable d’environnement ` QSG_RHI_PREFER_SOFTWARE_RENDERER ` sur ` 1`. Dans certains cas, ` Qt Quick ` effectuera automatiquement ce repli afin de permettre l’exécution d’applications Qt sans configuration supplémentaire. Cela se produit lorsque les pilotes n’offrent pas un niveau suffisant de fonctionnalités D3D11, ce qui est généralement le cas dans les machines virtuelles ne disposant pas d’une accélération GPU et d’un passthrough correctement implémentés. En cas de doute sur le périphérique graphique utilisé, ou lors du dépannage ou du signalement de problèmes à Qt, exécutez l’application avec la variable d’environnement QSG_INFO=1 définie et examinez les sorties de débogage. L'exécution de l'outil ` qtdiag ` peut également fournir des informations utiles, car il répertorie 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, 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 la valeur par défaut pour Qt Quick, OpenGL reste couramment utilisé dans de nombreuses applications Qt, par exemple dans les applications basées sur QWidget et s'appuyant sur QOpenGLWindow ou QOpenGLWidget. Les sections suivantes abordent certaines spécificités d'OpenGL dans le cadre d'une compilation Qt.

Chargement dynamique d’OpenGL

Qt prend en charge la sélection 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 l’option ` -opengl dynamic ` au script `configure`.

configure -opengl dynamic

Cette configuration est la plus flexible, car aucune dépendance ni hypothèse concernant l’implémentation OpenGL n’est codée en dur lors de la compilation. Elle permet un déploiement robuste de l’application. Lorsqu’un environnement donné ne fournit pas d’implémentation OpenGL 2.0 appropriée, le système se rabat automatiquement sur une alternative à ` opengl32.dll`, dont le nom par défaut est ` opengl32sw.dll`. Les paquets Qt précompilés fournissent 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 compilées à l’aide de ` qmake ` ou ` CMake ` ne se lieront à `opengl32.lib`. À la place, la bibliothèque est choisie et chargée au moment de l’exécution. Par défaut, Qt détermine si le fichier opengl32.dll du système fournit des fonctions OpenGL 2. Si c’est le cas, 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 Cela revient à définir QT_OPENGL sur desktop.
• Qt::AA_UseOpenGLES N'a aucun effet dans Qt 6.
• Qt::AA_UseSoftwareOpenGL Équivaut à définir QT_OPENGL sur software.

Lorsqu’une configuration spécifique est demandée explicitement, aucune vérification n’est effectuée au démarrage de l’application ; en d’autres termes, le fichier opengl32.dll fourni par le système ne sera pas examiné.

Le chargement dynamique a un impact significatif sur les applications contenant des appels OpenGL natifs : elles peuvent échouer lors de la liaison, car opengl32.lib n’est pas automatiquement spécifié au lieur. Les applications sont plutôt censées utiliser les fonctions OpenGL via la classe ` QOpenGLFunctions `. Ainsi, la dépendance directe à la bibliothèque OpenGL est supprimée et tous les appels seront acheminés, lors de l’exécution, vers l’implémentation choisie par Qt. Les applications sont toutefois libres d'effectuer 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). Du point de vue de l’application, le résultat est équivalent à la configuration de compilation « -opengl desktop » de Qt.

Qt::AA_UseSoftwareOpenGL est particulier dans la mesure où il tentera de charger une implémentation OpenGL portant un nom non standard. Le nom par défaut est opengl32sw.dll. Cela permet de fournir une implémentation OpenGL purement logicielle, par exemple une version de Mesa avec llvmpipe, sous ce nom. Si nécessaire, le nom de fichier peut être redéfini en définissant la variable d’environnement QT_OPENGL_DLL.

Il est possible de fournir un fichier de configuration au format JSON précisant quelle implémentation OpenGL utiliser en fonction de la carte graphique et de la version du pilote. L’emplacement est indiqué par la variable d’environnement QT_OPENGL_BUGLIST. Les chemins relatifs sont résolus à l’aide de QLibraryInfo::SettingsPath ou QStandardPaths::ConfigLocation. Le fichier utilise le format de la liste des bogues des pilotes utilisé dans les projets Chromium. Il se compose d’une liste d’entrées, chacune spécifiant un ensemble de conditions et une liste de mots-clés de fonctionnalités. En général, l’identifiant du périphérique (device id) et l’identifiant du fabricant (vendor id) sont utilisés pour identifier une carte graphique spécifique. Ils figurent dans la sortie de l’outil qtdiag6 ou dxdiag.

Les mots-clés de fonctionnalités suivants sont pertinents pour le choix de l’implémentation OpenGL :

• disable_desktopgl - Désactive OpenGL. Cela garantit que Qt ne tente pas d’utiliser OpenGL standard (opengl32.dll) et qu’il démarre immédiatement avec ANGLE. Cette option est utile pour empêcher des pilotes OpenGL défectueux de provoquer le plantage de l’application.
• disable_rotation - Force l’application à s’exécuter systématiquement en mode paysage. Cela n’a aucun effet en cas d’utilisation d’une implémentation logicielle d’OpenGL. Cette option est destinée aux pilotes présentant des problèmes de rotation.
• disable_program_cache - Désactive l'enregistrement des binaires des programmes de shaders sur le disque.

Voici à quoi ressemble un fichier d’exemple :

{
"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"
  ]
},
...

Lorsque l’option ` QT_OPENGL_BUGLIST ` n’est pas spécifiée, une liste intégrée est utilisée. Celle-ci inclut généralement certaines cartes graphiques plus anciennes et moins performantes pour lesquelles l’option ` disable_desktopgl ` est activée, afin d’empêcher Qt d’utiliser leurs implémentations OpenGL de bureau instables et de se rabattre immédiatement sur la bibliothèque logicielle alternative.

En pratique, les combinaisons les plus courantes devraient être les suivantes :

• disable_desktopgl - Lorsque le système prend en charge OpenGL 2.0 ou une version plus récente, mais que le pilote est connu pour être instable et sujet aux plantages.
• disable_desktopgl, disable_angle - Lorsqu’aucun chemin accéléré n’est souhaité. Cela garantit que la seule option que Qt essaie est le rastériseur logiciel (opengl32sw.dll). Cela peut s’avérer utile dans les machines virtuelles et les applications déployées sur un large éventail de systèmes anciens.

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 - Fournisseur à partir de l'identifiant de l'adaptateur
• device_id - Liste des identifiants de périphériques PCI.
• driver_version - Version du pilote à partir de l'identifiant de la carte
• driver_description - Correspond lorsque la valeur est une sous-chaîne de la description du pilote issue de l'identifiant de la carte
• gl_vendor - Correspondance lorsque la valeur est une sous-chaîne de la chaîne « GL_VENDOR »

Pour désactiver toutes les listes noires, définissez la variable d’environnement QT_NO_OPENGL_BUGLIST sur n’importe quelle valeur. Cela évitera la lecture des fichiers de configuration et supposera qu’aucune fonctionnalité n’est désactivée, quels que soient le pilote ou le système d’exploitation.

Dépendance directe à opengl32.dll

Une alternative aux versions OpenGL par défaut d’ dynamic consiste à dépendre directement de opengl32.dll. Pour ce mode, transmettez les options de ligne de commande -opengl desktop au script configure.

configure -opengl desktop

Dans ces versions de Qt, de nombreuses bibliothèques partagées Qt, ainsi que les applications Qt, dépendront d’opengl32.dll ; il n’est donc pas possible d’utiliser une bibliothèque alternative.