Sur cette page

QRhiGles2InitParams Struct

Paramètres d'initialisation spécifiques à OpenGL. En savoir plus...

En-tête : #include <rhi/qrhi.h>
CMake : find_package(Qt6 REQUIRED COMPONENTS GuiPrivate)
target_link_libraries(mytarget PRIVATE Qt6::GuiPrivate)
qmake : QT += gui-private
Depuis : Qt 6.6
Hérite de : QRhiInitParams

Fonctions publiques

Variables publiques

QSurface *fallbackSurface
QSurfaceFormat format
QOpenGLContext *shareContext
QWindow *window

Membres publics statiques

QOffscreenSurface *newFallbackSurface(const QSurfaceFormat &format = QSurfaceFormat::defaultFormat())

Description détaillée

Remarque : il s'agit d'une API RHI dont la compatibilité est garantie de manière limitée ; pour plus de détails, consultez QRhi.

Un « QRhi » basé sur OpenGL nécessite un « QSurface » déjà créé, pouvant être utilisé en combinaison avec « QOpenGLContext ». En pratique, il s’agit le plus souvent d’un « QOffscreenSurface ». De plus, bien que cela soit facultatif, il est recommandé de passer également l’« QWindow » que le premier « QRhiSwapChain » ciblera.

QOffscreenSurface *fallbackSurface = QRhiGles2InitParams::newFallbackSurface();
QRhiGles2InitParams params;
params.fallbackSurface = fallbackSurface;
params.window = window;
rhi = QRhi::create(QRhi::OpenGLES2, &params);

Par défaut, ` QRhi ` crée lui-même un ` QOpenGLContext `. Cette approche fonctionne bien dans la plupart des cas, y compris dans les scénarios multithread, où il existe un ` QRhi ` dédié pour chaque thread de rendu. Comme il y aura un ` QOpenGLContext ` pour chaque ` QRhi`, les exigences relatives au contexte OpenGL (un contexte ne peut être actif que sur un seul thread) sont respectées. Le contexte créé implicitement est détruit automatiquement en même temps que l’` QRhi`.

L'QSurfaceFormat e du contexte est spécifiée dans format. Le constructeur définit cette valeur sur QSurfaceFormat::defaultFormat(), de sorte que les applications qui appellent QSurfaceFormat::setDefaultFormat() avec les paramètres appropriés avant l'exécution du constructeur n'auront pas besoin de modifier la valeur de format.

Remarque : n’oubliez pas de définir les tailles des tampons de profondeur et de stencil sur 24 et 8 lorsque le moteur de rendu utilise des tests de profondeur ou de stencil, soit dans la valeur par défaut globale QSurfaceFormat, soit, à défaut, séparément dans toutes les instances QSurfaceFormat concernées : dans format, dans l’argument format passé à newFallbackSurface(), et sur tout QWindow utilisé avec QRhi.

Un QSurface doit être spécifié dans fallbackSurface. Afin d’éviter toute erreur dans les contextes multithread, celui-ci n’est jamais créé automatiquement par QRhi car, à l’instar de QWindow, les instances des sous-classes de QSurface ne peuvent souvent être créées que sur le thread principal de l’interface graphique.

Pour plus de commodité, les applications peuvent utiliser newFallbackSurface() qui crée et renvoie un QOffscreenSurface compatible avec l’ QOpenGLContext qui sera créé par la suite par QRhi. Notez que la propriété de l’ QOffscreenSurface renvoyé est transférée à l’appelant et que QRhi ne le détruira pas.

Remarque : avec le backend OpenGL, la fonction ` QRhiSwapChain ` ne peut cibler que des instances ` QWindow ` dont le type de surface est défini sur ` QSurface::OpenGLSurface`.

Remarque : ` window ` est facultatif. Il est recommandé de le spécifier dans la mesure du possible, afin d’éviter des problèmes sur les systèmes à plusieurs adaptateurs et à plusieurs écrans. Lorsque ` window ` n’est pas défini, le tout premier appel à ` QOpenGLContext::makeCurrent()` s’effectue avec ` fallbackSurface `, qui peut être une fenêtre invisible sur certaines plateformes (par exemple, Windows) et qui peut entraîner des problèmes inattendus dans certains cas.

Si l’on souhaite partager des ressources avec un contexte OpenGL existant ( QOpenGLContext ), shareContext peut être défini sur un contexte existant ( QOpenGLContext). Par ailleurs, Qt::AA_ShareOpenGLContexts est également pris en compte lorsqu’il est activé.

Utilisation de contextes OpenGL existants

Lors de l’interopérabilité avec un autre moteur graphique, il peut s’avérer nécessaire d’obtenir une instance d’ QRhi utilisant le même contexte OpenGL. Pour ce faire, il suffit de passer un pointeur vers un QRhiGles2NativeHandles à la fonction QRhi::create(). Le paramètre QRhiGles2NativeHandles::context doit alors être défini sur une valeur non nulle.

Une autre approche consiste à créer un ` QOpenGLContext ` qui effectue un ` shares resources ` avec le contexte de l’autre moteur, puis à transmettre ce contexte via ` QRhiGles2NativeHandles`.

L’ QRhi ne prend pas possession de l’ QOpenGLContext transmis via QRhiGles2NativeHandles.

Documentation des fonctions membres

QRhiGles2InitParams::QRhiGles2InitParams()

Crée un nouvel objet QRhiGles2InitParams.

format est défini sur ` QSurfaceFormat::defaultFormat()`.

[static] QOffscreenSurface *QRhiGles2InitParams::newFallbackSurface(const QSurfaceFormat &format = QSurfaceFormat::defaultFormat())

Renvoie un nouvel objet ` QOffscreenSurface ` pouvant être utilisé avec un ` QRhi ` en le transmettant via un ` QRhiGles2InitParams`.

Lorsque format n’est pas spécifié, sa valeur par défaut est le format global par défaut pouvant être défini via QSurfaceFormat::setDefaultFormat().

format est ajusté de manière appropriée afin d’éviter tout problème ultérieur dû à une incompatibilité entre le contexte et la surface.

Remarque : cette fonction ne doit être appelée que sur le thread principal de l’interface graphique ou si l’intégration de la plate-forme prend en charge les surfaces hors écran.

Remarque : il incombe à l’application de détruire l’ QOffscreenSurface renvoyée sur le thread GUI/principal une fois que l’ QRhi associée a été détruite. L’ QRhi ne détruira pas l’ QOffscreenSurface.

Documentation sur les variables membres

QSurface *QRhiGles2InitParams::fallbackSurface

Un objet de type ` QSurface ` compatible avec ` format`. Il s'agit généralement d'un ` QOffscreenSurface`. La fourniture de cet objet est obligatoire. Tenez compte des implications en matière de threads : un ` QOffscreenSurface`, tel que ` QWindow`, ne doit être créé et détruit que sur le thread principal (GUI), même si l'objet ` QRhi ` est créé et s'exécute sur un autre thread.

QSurfaceFormat QRhiGles2InitParams::format

L'QSurfaceFormat, initialisé par défaut à QSurfaceFormat::defaultFormat().

QOpenGLContext *QRhiGles2InitParams::shareContext

Facultatif : l'QOpenGLContext e avec lequel partager les ressources. La méthode ` QRhi ` crée son propre contexte ; si l'on attribue à ce membre une valeur valide de type ` QOpenGLContext `, cela entraîne l'appel de la méthode ` setShareContext()` avec ce contexte.

QWindow *QRhiGles2InitParams::window

Facultatif, mais il est recommandé de le configurer lorsque vous ciblez une instance « QWindow » avec l'QRhi.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.