QOpenGLContext Class

Documentation des fonctions membres

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

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

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

Voir également create() et makeCurrent().

[virtual noexcept] QOpenGLContext::~QOpenGLContext()

Détruit l'objet ` QOpenGLContext `.

S'il s'agit du contexte actuel du thread, la méthode ` doneCurrent()` est également appelée.

[signal] void QOpenGLContext::aboutToBeDestroyed()

Ce signal est émis avant la destruction du contexte OpenGL natif sous-jacent, afin de permettre aux utilisateurs de libérer les ressources OpenGL qui, sans cela, risqueraient de rester en suspens dans le cas de contextes OpenGL partagés.

Si vous souhaitez rendre le contexte actif afin de procéder à ce nettoyage, veillez à ne vous connecter au signal qu’à l’aide d’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 de votre système ne prend pas en charge la version demandée du contexte OpenGL, alors ` QOpenGLContext ` tentera de créer la version la plus proche. Les propriétés réelles du contexte créé peuvent être consultées à l’aide de l’ QSurfaceFormat renvoyé par la fonction format(). Par exemple, si vous demandez un contexte prenant en charge le profil Core d’OpenGL 4.3, mais que le pilote et/ou le matériel ne prennent en charge que les contextes du profil Core de la version 3.2, vous obtiendrez alors un contexte du profil Core 3.2.

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

Voir également makeCurrent() et format().

[static] QOpenGLContext *QOpenGLContext::currentContext()

Renvoie le dernier contexte ayant appelé la fonction ` makeCurrent ` dans le thread actuel, ou ` nullptr` si aucun contexte n'est actif.

GLuint QOpenGLContext::defaultFramebufferObject() const

Appelez cette fonction pour obtenir l'objet framebuffer par défaut de la surface actuelle.

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. Par conséquent, au lieu d'appeler glBindFramebuffer(0), vous devriez appeler glBindFramebuffer(ctx->defaultFramebufferObject()) si vous souhaitez que votre application fonctionne sur différentes plateformes Qt.

Si vous utilisez la fonction glBindFramebuffer() de la classe QOpenGLFunctions, vous n’avez pas à vous soucier de cela, car elle lie automatiquement le defaultFramebufferObject() du contexte actuel lorsque la valeur 0 est transmise.

Voir également QOpenGLFramebufferObject.

void QOpenGLContext::doneCurrent()

Fonction pratique permettant d'appeler ` makeCurrent ` avec une surface égale à 0.

Cela a pour conséquence qu'aucun contexte n'est actif dans le thread actuel.

Voir également makeCurrent() et currentContext().

QSet<QByteArray> QOpenGLContext::extensions() const

Renvoie l'ensemble des extensions OpenGL prises en charge par ce contexte.

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

Voir également hasExtension().

QOpenGLExtraFunctions *QOpenGLContext::extraFunctions() const

Récupérer l'instance « QOpenGLExtraFunctions » pour ce contexte.

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

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

L’instance QOpenGLExtraFunctions renvoyée est prête à l’emploi et ne nécessite pas l’appel de la fonction initializeOpenGLFunctions().

Voir également QOpenGLFunctions et QOpenGLExtraFunctions.

QSurfaceFormat QOpenGLContext::format() const

Renvoie le format du contexte de la plateforme sous-jacente, si la fonction ` create()` a été appelée.

Sinon, renvoie le format demandé.

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

Par exemple, la demande d’un contexte au profil de base OpenGL version 3.x peut aboutir à un contexte au profil de base OpenGL 4.x. De même, une demande d’OpenGL 2.1 peut aboutir à un contexte OpenGL 3.0 avec des fonctions obsolètes activées. Enfin, selon le pilote, les versions non prises en charge peuvent entraîner soit un échec de la création du contexte, soit la création d’un contexte correspondant à la version la plus élevée prise en charge.

Des différences similaires sont possibles au niveau de la taille des tampons ; par exemple, le contexte obtenu peut disposer d’un tampon de profondeur plus grand que celui demandé. Ceci est tout à fait normal.

Voir également setFormat().

QOpenGLFunctions *QOpenGLContext::functions() const

Récupérer l'instance « QOpenGLFunctions » pour ce contexte.

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

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

L'instance ` QOpenGLFunctions ` renvoyée est prête à l'emploi 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.

Utilisez cette fonction pour accéder aux fonctions d’extension OpenGL ou aux fonctions de base qui ne sont pas nécessairement disponibles sous forme de symboles liés sur toutes les plateformes.

Le pointeur renvoyé peut dépendre de la plateforme. Certains systèmes peuvent renvoyer un pointeur qui n’est pas nullptr, même si la fonction n’est pas valide ou prise en charge.

Pour vérifier de manière fiable la disponibilité d’une fonction, testez la prise en charge de l’extension en appelant ` QOpenGLContext::hasExtension()` (). Pour les fonctions de base, vérifiez la version du contexte actuel via ` version()` dans l’ QSurfaceFormat e renvoyée par ` QOpenGLContext::format()` ().

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, renvoie ` nullptr`.

Cette fonction est utile si vous devez charger des objets OpenGL (tampons, textures, etc.) avant de créer ou d’afficher une surface « QOpenGLWidget » ou une surface « QQuickWidget ».

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

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

Renvoie « true » si ce contexte OpenGL prend en charge l’ extension OpenGL spécifiée ; sinon, renvoie « false ».

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

Voir également extensions().

bool QOpenGLContext::isOpenGLES() const

Renvoie « true » si le contexte est un contexte OpenGL ES.

Si le contexte n'a pas encore été créé, le résultat dépend du format demandé via la fonction setFormat().

Voir également create(), format() et setFormat().

bool QOpenGLContext::isValid() const

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

Sur certaines plateformes, la valeur renvoyée par ` false ` pour un contexte créé précédemment avec succès indique que le contexte OpenGL a été perdu.

La méthode classique pour gérer les scénarios de perte de contexte dans les applications consiste à 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()`, puis 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 activer explicitement. Pour ce faire, activez l’option « ResetNotification » dans ` QSurfaceFormat`. Cela entraînera la définition de ` RESET_NOTIFICATION_STRATEGY_EXT ` sur ` LOSE_CONTEXT_ON_RESET_EXT ` dans le contexte OpenGL natif sous-jacent. ` QOpenGLContext ` surveillera alors l’état via ` glGetGraphicsResetStatusEXT() ` à chaque appel de ` makeCurrent()`.

Voir également create().

bool QOpenGLContext::makeCurrent(QSurface *surface)

Définit le contexte actif dans le thread courant, en fonction de l'surface fournie. Renvoie true en cas de succès ; sinon, renvoie 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, par exemple parce que l'application est en suspension.

Si ` surface ` est ` nullptr `, cela revient à appeler ` doneCurrent()`.

Évitez d’appeler cette fonction depuis un thread différent de celui dans lequel réside l’instance de ` QOpenGLContext `. Si vous souhaitez utiliser ` QOpenGLContext ` depuis un autre thread, vous devez d’abord vous assurer qu’elle n’est pas active dans le thread actuel, en appelant ` doneCurrent()` si nécessaire. Appelez ensuite `moveToThread(otherThread)` avant de l’utiliser dans l’autre thread.

Par défaut, Qt effectue une vérification qui impose la condition ci-dessus concernant l’affinité de thread. Il est toutefois 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 résident, comme expliqué dans la documentation relative à 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 plateforme de ` QOpenGLContext`, telles que définies dans l'espace de noms ` QNativeInterface ` :

Si l'interface demandée n'est pas disponible, un objet ` nullptr ` est renvoyé.

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

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

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 l'format e avec laquelle le contexte OpenGL doit être compatible. Vous devez appeler la fonction ` create()` pour que cette configuration prenne effet.

Lorsque le format n’est pas explicitement défini via cette fonction, c’est le format renvoyé par QSurfaceFormat::defaultFormat() qui sera utilisé. Cela signifie que, en cas de contextes multiples, les appels individuels à cette fonction peuvent être remplacés par un seul appel à QSurfaceFormat::setDefaultFormat() avant la création du premier contexte.

Voir également format().

void QOpenGLContext::setScreen(QScreen *screen)

Définit l'screen e pour laquelle le contexte OpenGL doit être valide. Vous devez appeler la fonction ` create()` pour que cette modification prenne effet.

Voir également ` screen()`.

void QOpenGLContext::setShareContext(QOpenGLContext *shareContext)

Permet à ce contexte de partager des textures, des shaders et d'autres ressources OpenGL avec shareContext. Vous devez appeler create() pour que cela prenne effet.

Voir également shareContext().

QOpenGLContext *QOpenGLContext::shareContext() const

Renvoie le contexte de partage utilisé pour créer ce contexte.

Si la plateforme sous-jacente n'a pas pu prendre en charge le partage demandé, cette fonction renvoie 0.

Voir également setShareContext().

QOpenGLContextGroup *QOpenGLContext::shareGroup() const

Renvoie le groupe de partages auquel appartient ce contexte.

[static] bool QOpenGLContext::supportsThreadedOpenGL()

Renvoie « true » si la plateforme prend en charge le rendu OpenGL en dehors du thread principal (GUI).

Cette valeur est gérée par le plugin de la plateforme utilisé et peut également dépendre des pilotes graphiques.

QSurface *QOpenGLContext::surface() const

Renvoie la surface qui a été définie comme surface active dans le contexte.

Il s'agit de la surface transmise en argument à la fonction ` makeCurrent()`.

void QOpenGLContext::swapBuffers(QSurface *surface)

Permutez les tampons avant et arrière de la fonction ` surface`.

Appelez cette fonction pour terminer une image de rendu OpenGL, et veillez à appeler à nouveau makeCurrent() avant d’émettre d’autres commandes OpenGL, par exemple dans le cadre d’une nouvelle image.