QOpenGLContext Class

Documentation des fonctions membres

[explicit] QOpenGLContext::QOpenGLContext(QObject *parent = nullptr)

Crée une nouvelle instance de contexte OpenGL avec l'objet parent parent.

Avant de pouvoir l'utiliser, vous devez définir le format approprié et appeler create().

Voir aussi create() et makeCurrent().

[virtual noexcept] QOpenGLContext::~QOpenGLContext()

Détruit l'objet QOpenGLContext.

S'il s'agit du contexte actuel du thread, doneCurrent() est également appelé.

[signal] void QOpenGLContext::aboutToBeDestroyed()

Ce signal est émis avant que le contexte OpenGL natif sous-jacent ne soit détruit, afin que les utilisateurs puissent nettoyer les ressources OpenGL qui pourraient être laissées en suspens dans le cas de contextes OpenGL partagés.

Si vous souhaitez rendre le contexte actuel afin d'effectuer le nettoyage, assurez-vous de ne vous connecter au signal qu'en utilisant une connexion directe.

[static] bool QOpenGLContext::areSharing(QOpenGLContext *first, QOpenGLContext *second)

Renvoie true si les contextes first et second partagent des ressources OpenGL.

bool QOpenGLContext::create()

Tente de créer le contexte OpenGL avec la configuration actuelle.

La configuration actuelle comprend le format, le contexte de partage et l'écran.

Si l'implémentation OpenGL sur votre système ne supporte pas la version demandée du contexte OpenGL, alors QOpenGLContext essaiera de créer la version la plus proche. Les propriétés du contexte créé peuvent être interrogées à l'aide de la page QSurfaceFormat renvoyée par la fonction format(). Par exemple, si vous demandez un contexte qui supporte le profil OpenGL 4.3 Core mais que le pilote et/ou le matériel ne supporte que la version 3.2 Core, vous obtiendrez un contexte 3.2 Core.

Retourne true si le contexte natif a été créé avec succès et est prêt à être utilisé avec makeCurrent(), swapBuffers(), etc.

Voir aussi makeCurrent() et format().

[static] QOpenGLContext *QOpenGLContext::currentContext()

Renvoie le dernier contexte qui a appelé makeCurrent dans le thread en cours, ou nullptr, si aucun contexte n'est en cours.

GLuint QOpenGLContext::defaultFramebufferObject() const

Appeler cette fonction pour obtenir l'objet framebuffer par défaut pour la surface courante.

Sur certaines plateformes (par exemple, iOS), l'objet framebuffer par défaut dépend de la surface sur laquelle le rendu est effectué, et peut être différent de 0. Ainsi, au lieu d'appeler glBindFramebuffer(0), vous devriez appeler glBindFramebuffer(ctx->defaultFramebufferObject()) si vous voulez que votre application fonctionne sur différentes plateformes Qt.

Si vous utilisez glBindFramebuffer() dans QOpenGLFunctions, vous n'avez pas à vous en soucier, car il lie automatiquement le defaultFramebufferObject() du contexte actuel lorsque 0 est passé.

Voir également QOpenGLFramebufferObject.

void QOpenGLContext::doneCurrent()

Fonction de commodité pour appeler makeCurrent avec une surface 0.

Il en résulte qu'aucun contexte n'est courant dans le fil d'exécution actuel.

Voir aussi makeCurrent() et currentContext().

QSet<QByteArray> QOpenGLContext::extensions() const

Renvoie l'ensemble des extensions OpenGL supportées par ce contexte.

Le contexte ou un contexte de partage doit être courant.

Voir aussi hasExtension().

QOpenGLExtraFunctions *QOpenGLContext::extraFunctions() const

Obtenir l'instance QOpenGLExtraFunctions pour ce contexte.

QOpenGLContext offre un moyen pratique d'accéder à QOpenGLExtraFunctions sans avoir à le gérer manuellement.

Le contexte ou un contexte de partage doit être courant.

L'instance QOpenGLExtraFunctions renvoyée est prête à être utilisée et n'a pas besoin d'appeler initializeOpenGLFunctions().

Voir aussi QOpenGLFunctions et QOpenGLExtraFunctions.

QSurfaceFormat QOpenGLContext::format() const

Renvoie le format du contexte de la plate-forme sous-jacente, si create() a été appelé.

Sinon, il renvoie le format demandé.

Le format demandé et le format réel peuvent différer. Demander une version d'OpenGL donnée ne signifie pas que le contexte résultant ciblera exactement la version demandée. Il est seulement garanti que la combinaison version/profil/options pour le contexte créé est compatible avec la demande, tant que le pilote est capable de fournir un tel contexte.

Par exemple, la demande d'un contexte de profil de base OpenGL version 3.x peut résulter en un contexte de profil de base OpenGL 4.x. De même, une demande pour OpenGL 2.1 peut résulter en un contexte OpenGL 3.0 avec des fonctions dépréciées activées. Enfin, en fonction du pilote, les versions non supportées peuvent entraîner soit un échec de la création du contexte, soit un contexte pour la version supportée la plus élevée.

Des différences similaires sont possibles dans la taille des tampons, par exemple, le contexte résultant peut avoir un tampon de profondeur plus grand que celui demandé. C'est tout à fait normal.

Voir aussi setFormat().

QOpenGLFunctions *QOpenGLContext::functions() const

Obtenir l'instance QOpenGLFunctions pour ce contexte.

QOpenGLContext offre un moyen pratique d'accéder à QOpenGLFunctions sans avoir à le gérer manuellement.

Le contexte ou un contexte de partage doit être courant.

L'instance QOpenGLFunctions renvoyée est prête à être utilisée et ne nécessite pas l'appel de la fonction initializeOpenGLFunctions().

QFunctionPointer QOpenGLContext::getProcAddress(const QByteArray &procName) const

Résout le pointeur de fonction vers une fonction d'extension OpenGL, identifiée par procName

Retourne nullptr si aucune fonction de ce type ne peut être trouvée.

QFunctionPointer QOpenGLContext::getProcAddress(const char *procName) const

[static] QOpenGLContext *QOpenGLContext::globalShareContext()

Renvoie le contexte OpenGL partagé à l'échelle de l'application, s'il existe. Sinon, il renvoie nullptr.

Ceci est utile si vous devez télécharger des objets OpenGL (tampons, textures, etc.) avant de créer ou d'afficher une page QOpenGLWidget ou QQuickWidget.

Voir également Qt::AA_ShareOpenGLContexts, setShareContext() et makeCurrent().

bool QOpenGLContext::hasExtension(const QByteArray &extension) const

Retourne true si ce contexte OpenGL supporte l'OpenGL spécifié extension, false sinon.

Le contexte ou un contexte de partage doit être courant.

Voir aussi extensions().

bool QOpenGLContext::isOpenGLES() const

Retourne vrai si le contexte est un contexte OpenGL ES.

Si le contexte n'a pas encore été créé, le résultat est basé sur le format demandé via setFormat().

Voir aussi create(), format(), et setFormat().

bool QOpenGLContext::isValid() const

Retourne si ce contexte est valide, c'est-à-dire s'il a été créé avec succès.

Sur certaines plateformes, la valeur de retour de false pour un contexte qui a été créé avec succès précédemment indique que le contexte OpenGL a été perdu.

La façon typique de gérer les scénarios de perte de contexte dans les applications est de vérifier via cette fonction chaque fois que makeCurrent() échoue et renvoie false. Si cette fonction renvoie alors false, recréez le contexte OpenGL natif sous-jacent en appelant create(), appelez à nouveau makeCurrent() et réinitialisez toutes les ressources OpenGL.

Sur certaines plateformes, les situations de perte de contexte sont inévitables. Sur d'autres, en revanche, il peut être nécessaire de les accepter. Cela peut être fait en activant ResetNotification dans QSurfaceFormat. Cela conduira à configurer RESET_NOTIFICATION_STRATEGY_EXT à LOSE_CONTEXT_ON_RESET_EXT dans le contexte OpenGL natif sous-jacent. QOpenGLContext surveillera alors le statut via glGetGraphicsResetStatusEXT() dans chaque makeCurrent().

Voir aussi create().

bool QOpenGLContext::makeCurrent(QSurface *surface)

Rend le contexte actuel dans le thread actuel, par rapport à l'adresse surface. Renvoie true en cas de succès, sinon false. Ce dernier cas peut se produire si la surface n'est pas exposée ou si le matériel graphique n'est pas disponible parce que l'application est suspendue, par exemple.

Si surface est nullptr, cela équivaut à appeler doneCurrent().

Évitez d'appeler cette fonction à partir d'un thread différent de celui dans lequel se trouve l'instance QOpenGLContext. Si vous souhaitez utiliser QOpenGLContext à partir d'un autre thread, vous devez d'abord vous assurer qu'il n'est pas en cours dans le thread actuel, en appelant doneCurrent() si nécessaire. Ensuite, appelez moveToThread(otherThread) avant de l'utiliser dans l'autre thread.

Par défaut, Qt utilise une vérification qui applique la condition ci-dessus sur l'affinité des threads. Il est toujours possible de désactiver cette vérification en définissant l'attribut d'application Qt::AA_DontCheckOpenGLContextThreadAffinity. Assurez-vous de bien comprendre les conséquences de l'utilisation de QObjects en dehors du thread dans lequel ils vivent, comme expliqué dans la documentation QObject thread affinity.

Voir également functions(), doneCurrent() et Qt::AA_DontCheckOpenGLContextThreadAffinity.

template <typename QNativeInterface> QNativeInterface *QOpenGLContext::nativeInterface() const

Renvoie une interface native du type donné pour le contexte.

Cette fonction permet d'accéder aux fonctionnalités spécifiques à la plate-forme QOpenGLContext, telles que définies dans l'espace de noms QNativeInterface:

Si l'interface demandée n'est pas disponible, une adresse nullptr est renvoyée.

[static] QOpenGLContext::OpenGLModuleType QOpenGLContext::openGLModuleType()

Renvoie le type d'implémentation OpenGL sous-jacent.

Sur les plateformes où l'implémentation OpenGL n'est pas chargée dynamiquement, la valeur de retour est déterminée lors de la compilation et ne change jamais.

QScreen *QOpenGLContext::screen() const

Renvoie l'écran pour lequel le contexte a été créé.

Voir aussi setScreen().

void QOpenGLContext::setFormat(const QSurfaceFormat &format)

Définit le site format avec lequel le contexte OpenGL doit être compatible. Vous devez appeler create() avant que cette fonction ne prenne effet.

Lorsque le format n'est pas explicitement défini par cette fonction, le format retourné par QSurfaceFormat::defaultFormat() sera utilisé. Cela signifie qu'en cas de contextes multiples, les appels individuels à cette fonction peuvent être remplacés par un seul appel à QSurfaceFormat::setDefaultFormat() avant de créer le premier contexte.

Voir aussi format().

void QOpenGLContext::setScreen(QScreen *screen)

Définit l'adresse screen pour laquelle le contexte OpenGL doit être valide. Vous devez appeler create() avant qu'elle ne prenne effet.

Voir aussi screen().

void QOpenGLContext::setShareContext(QOpenGLContext *shareContext)

Fait partager à ce contexte les textures, les shaders et les autres ressources OpenGL avec shareContext. Vous devez appeler create() avant que cela ne prenne effet.

Voir aussi shareContext().

QOpenGLContext *QOpenGLContext::shareContext() const

Renvoie le contexte de partage avec lequel ce contexte a été créé.

Si la plate-forme sous-jacente n'est pas en mesure de prendre en charge le partage demandé, la valeur renvoyée est 0.

Voir aussi setShareContext().

QOpenGLContextGroup *QOpenGLContext::shareGroup() const

Renvoie le groupe de partage auquel ce contexte appartient.

[static] bool QOpenGLContext::supportsThreadedOpenGL()

Renvoie true si la plateforme supporte le rendu OpenGL en dehors du thread principal (gui).

La valeur est contrôlée par le plugin de plateforme utilisé et peut également dépendre des pilotes graphiques.

QSurface *QOpenGLContext::surface() const

Renvoie la surface avec laquelle le contexte a été rendu courant.

Il s'agit de la surface transmise en tant qu'argument à makeCurrent().

void QOpenGLContext::swapBuffers(QSurface *surface)

Intervertit les tampons avant et arrière de surface.

Appelez ceci pour terminer une image de rendu OpenGL, et assurez-vous d'appeler à nouveau makeCurrent() avant d'émettre d'autres commandes OpenGL, par exemple dans le cadre d'une nouvelle image.