QOpenGLContext Class

Dokumentation der Mitgliedsfunktionen

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

Erstellt eine neue OpenGL-Kontextinstanz mit dem übergeordneten Objekt „ parent “.

Bevor sie verwendet werden kann, müssen Sie das richtige Format festlegen und ` create()` aufrufen.

Siehe auch ` create()` und ` makeCurrent()`.

[virtual noexcept] QOpenGLContext::~QOpenGLContext()

Löscht das Objekt „ QOpenGLContext “.

Wenn dies der aktuelle Kontext für den Thread ist, wird zusätzlich „ doneCurrent()“ aufgerufen.

[signal] void QOpenGLContext::aboutToBeDestroyed()

Dieses Signal wird ausgegeben, bevor der zugrunde liegende native OpenGL-Kontext zerstört wird, sodass Benutzer OpenGL-Ressourcen bereinigen können, die andernfalls bei gemeinsam genutzten OpenGL-Kontexten möglicherweise ungelöst bleiben würden.

Wenn Sie den Kontext für die Bereinigung als aktuellen Kontext festlegen möchten, stellen Sie sicher, dass Sie das Signal nur über eine direkte Verbindung abhören.

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

Gibt „ true “ zurück, wenn die Kontexte „ first “ und „ second “ sich OpenGL-Ressourcen teilen.

bool QOpenGLContext::create()

Es wird versucht, den OpenGL-Kontext mit der aktuellen Konfiguration zu erstellen.

Die aktuelle Konfiguration umfasst das Format, den Share-Kontext und den Bildschirm.

Falls die OpenGL-Implementierung auf Ihrem System die angeforderte Version des OpenGL-Kontexts nicht unterstützt, versucht „ QOpenGLContext “, die am besten passende Version zu erstellen. Die Eigenschaften des tatsächlich erstellten Kontexts können mithilfe des von der Funktion „ format()“ zurückgegebenen „ QSurfaceFormat “ abgefragt werden. Wenn Sie beispielsweise einen Kontext anfordern, der das OpenGL 4.3 Core-Profil unterstützt, der Treiber und/oder die Hardware jedoch nur Kontexte der Version 3.2 Core-Profil unterstützt, erhalten Sie einen Kontext der Version 3.2 Core-Profil.

Gibt „ true “ zurück, wenn der native Kontext erfolgreich erstellt wurde und für die Verwendung mit „ makeCurrent()“, „ swapBuffers()“ usw. bereit ist.

Siehe auch makeCurrent() und format().

[static] QOpenGLContext *QOpenGLContext::currentContext()

Gibt den letzten Kontext zurück, der im aktuellen Thread „ makeCurrent “ aufgerufen hat, oder „ nullptr “, falls kein Kontext aktiv ist.

GLuint QOpenGLContext::defaultFramebufferObject() const

Rufen Sie diese Funktion auf, um das Standard-Framebuffer-Objekt für die aktuelle Oberfläche abzurufen.

Auf einigen Plattformen (z. B. iOS) hängt das Standard-Framebuffer-Objekt von der Oberfläche ab, auf die gerendert wird, und kann daher von 0 abweichen. Anstatt also glBindFramebuffer(0) aufzurufen, sollten Sie glBindFramebuffer(ctx->defaultFramebufferObject()) aufrufen, wenn Ihre Anwendung auf verschiedenen Qt-Plattformen funktionieren soll.

Wenn Sie die Funktion `glBindFramebuffer()` in ` QOpenGLFunctions ` verwenden, müssen Sie sich darüber keine Gedanken machen, da diese automatisch das `defaultFramebufferObject()` des aktuellen Kontexts bindet, wenn der Wert 0 übergeben wird.

Siehe auch QOpenGLFramebufferObject.

void QOpenGLContext::doneCurrent()

Hilfsfunktion zum Aufruf von „ makeCurrent “ mit einer Oberfläche von 0.

Dies führt dazu, dass im aktuellen Thread kein Kontext vorhanden ist.

Siehe auch „ makeCurrent()“ und „ currentContext()“.

QSet<QByteArray> QOpenGLContext::extensions() const

Gibt die Menge der von diesem Kontext unterstützten OpenGL-Erweiterungen zurück.

Der Kontext oder ein Sharing-Kontext muss aktuell sein.

Siehe auch „ hasExtension()“.

QOpenGLExtraFunctions *QOpenGLContext::extraFunctions() const

Rufen Sie die „ QOpenGLExtraFunctions “-Instanz für diesen Kontext ab.

QOpenGLContext Dies bietet eine bequeme Möglichkeit, auf „ QOpenGLExtraFunctions “ zuzugreifen, ohne es manuell verwalten zu müssen.

Der Kontext oder ein Sharing-Kontext muss aktuell sein.

Die zurückgegebene „ QOpenGLExtraFunctions “-Instanz ist sofort einsatzbereit und erfordert keinen Aufruf von `initializeOpenGLFunctions()`.

Siehe auch „ QOpenGLFunctions “ und „ QOpenGLExtraFunctions “.

QSurfaceFormat QOpenGLContext::format() const

Gibt das Format des zugrunde liegenden Plattformkontexts zurück, sofern „ create()“ aufgerufen wurde.

Andernfalls wird das angeforderte Format zurückgegeben.

Das angeforderte und das tatsächliche Format können voneinander abweichen. Die Anforderung einer bestimmten OpenGL-Version bedeutet nicht, dass der resultierende Kontext genau auf die angeforderte Version ausgerichtet ist. Es wird lediglich garantiert, dass die Kombination aus Version, Profil und Optionen für den erstellten Kontext mit der Anforderung kompatibel ist, sofern der Treiber in der Lage ist, einen solchen Kontext bereitzustellen.

Beispielsweise kann die Anforderung eines OpenGL-Kontexts der Version 3.x mit Core-Profil zu einem OpenGL-Kontext der Version 4.x mit Core-Profil führen. Ebenso kann eine Anforderung von OpenGL 2.1 zu einem OpenGL-3.0-Kontext führen, bei dem veraltete Funktionen aktiviert sind. Schließlich kann es je nach Treiber bei nicht unterstützten Versionen entweder zu einem Fehler bei der Kontexterstellung oder zur Erstellung eines Kontexts für die höchste unterstützte Version kommen.

Ähnliche Unterschiede sind bei den Puffergrößen möglich; so kann der resultierende Kontext beispielsweise einen größeren Tiefenpuffer aufweisen als angefordert. Dies ist völlig normal.

Siehe auch ` setFormat()`.

QOpenGLFunctions *QOpenGLContext::functions() const

Rufen Sie die „ QOpenGLFunctions “-Instanz für diesen Kontext ab.

QOpenGLContext Dies bietet eine bequeme Möglichkeit, auf „ QOpenGLFunctions “ zuzugreifen, ohne es manuell verwalten zu müssen.

Der Kontext oder ein Sharing-Kontext muss aktiv sein.

Die zurückgegebene ` QOpenGLFunctions `-Instanz ist sofort einsatzbereit und erfordert keinen Aufruf von `initializeOpenGLFunctions()`.

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

Löst den Funktionszeiger in eine OpenGL-Erweiterungsfunktion auf, die durch „ procName “ identifiziert wird.

Verwenden Sie diese Funktion, um auf OpenGL-Erweiterungsfunktionen oder Kernfunktionen zuzugreifen, die möglicherweise nicht auf allen Plattformen als verknüpfte Symbole verfügbar sind.

Der zurückgegebene Zeiger kann plattformabhängig sein. Einige Systeme geben möglicherweise einen Zeiger zurück, der nicht auf ` nullptr ` verweist, selbst wenn die Funktion ungültig ist oder nicht unterstützt wird.

Um die Verfügbarkeit einer Funktion zuverlässig zu prüfen, testen Sie die Unterstützung der Erweiterung durch Aufruf von ` QOpenGLContext::hasExtension()`. Bei Kernfunktionen überprüfen Sie die Version des aktuellen Kontexts über ` version()` in der von ` QOpenGLContext::format()` zurückgegebenen ` QSurfaceFormat `.

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

[static] QOpenGLContext *QOpenGLContext::globalShareContext()

Gibt den anwendungsweit gemeinsam genutzten OpenGL-Kontext zurück, sofern vorhanden. Andernfalls wird „ nullptr “ zurückgegeben.

Dies ist nützlich, wenn Sie OpenGL-Objekte (Puffer, Texturen usw.) hochladen müssen, bevor Sie eine ` QOpenGLWidget ` oder ` QQuickWidget` erstellen oder anzeigen.

Siehe auch ` Qt::AA_ShareOpenGLContexts`, ` setShareContext()` und ` makeCurrent()`.

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

Gibt „ true “ zurück, wenn dieser OpenGL-Kontext die angegebene OpenGL- extension unterstützt, andernfalls „ false “.

Der Kontext oder ein Sharing-Kontext muss aktuell sein.

Siehe auch extensions().

bool QOpenGLContext::isOpenGLES() const

Gibt „true“ zurück, wenn es sich bei dem Kontext um einen OpenGL ES-Kontext handelt.

Wenn der Kontext noch nicht erstellt wurde, basiert das Ergebnis auf dem über ` setFormat()` angeforderten Format.

Siehe auch create(), format() und setFormat().

bool QOpenGLContext::isValid() const

Gibt zurück, ob dieser Kontext gültig ist, d. h. erfolgreich erstellt wurde.

Auf einigen Plattformen deutet der Rückgabewert von ` false ` für einen zuvor erfolgreich erstellten Kontext darauf hin, dass der OpenGL-Kontext verloren gegangen ist.

Die übliche Vorgehensweise bei Kontextverlusten in Anwendungen besteht darin, mithilfe dieser Funktion zu prüfen, ob ` makeCurrent()` fehlschlägt und ` false` zurückgibt. Wenn diese Funktion dann ` false` zurückgibt, erstellen Sie den zugrunde liegenden nativen OpenGL-Kontext neu, indem Sie ` create()` aufrufen, rufen Sie ` makeCurrent()` erneut auf und initialisieren Sie anschließend alle OpenGL-Ressourcen neu.

Auf einigen Plattformen lassen sich Situationen mit Kontextverlust nicht vermeiden. Auf anderen hingegen muss diese Option möglicherweise aktivieren werden. Dies kann durch Aktivieren von ` ResetNotification ` in ` QSurfaceFormat` erfolgen. Dies führt dazu, dass ` RESET_NOTIFICATION_STRATEGY_EXT ` im zugrunde liegenden nativen OpenGL-Kontext auf ` LOSE_CONTEXT_ON_RESET_EXT ` gesetzt wird. ` QOpenGLContext ` überwacht dann den Status über ` glGetGraphicsResetStatusEXT() ` bei jedem Aufruf von ` makeCurrent()`.

Siehe auch create().

bool QOpenGLContext::makeCurrent(QSurface *surface)

Macht den Kontext im aktuellen Thread anhand der angegebenen „ surface “ aktiv. Gibt bei Erfolg „ true “ zurück; andernfalls wird „ false “ zurückgegeben. Letzteres kann auftreten, wenn die Oberfläche nicht verfügbar ist oder die Grafikhardware nicht zur Verfügung steht, z. B. weil die Anwendung angehalten wurde.

Wenn ` surface ` ` nullptr ` ist, entspricht dies dem Aufruf von ` doneCurrent()`.

Vermeiden Sie es, diese Funktion aus einem anderen Thread aufzurufen als dem, in dem sich die Instanz von ` QOpenGLContext ` befindet. Wenn Sie ` QOpenGLContext ` aus einem anderen Thread verwenden möchten, sollten Sie zunächst sicherstellen, dass sie im aktuellen Thread nicht aktiv ist, indem Sie gegebenenfalls ` doneCurrent()` aufrufen. Rufen Sie dann `moveToThread(otherThread)` auf, bevor Sie sie im anderen Thread verwenden.

Standardmäßig führt Qt eine Überprüfung durch, die die oben genannte Bedingung hinsichtlich der Thread-Affinität durchsetzt. Es ist jedoch möglich, diese Überprüfung zu deaktivieren, indem das Anwendungsattribut ` Qt::AA_DontCheckOpenGLContextThreadAffinity ` gesetzt wird. Machen Sie sich unbedingt mit den Konsequenzen der Verwendung von `QObjects` außerhalb des Threads, in dem sie sich befinden, vertraut, wie in der Dokumentation zu ` QObject thread affinity ` erläutert.

Siehe auch „ functions()“, „ doneCurrent()“ und „ Qt::AA_DontCheckOpenGLContextThreadAffinity “.

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

Gibt eine native Schnittstelle des angegebenen Typs für den Kontext zurück.

Diese Funktion ermöglicht den Zugriff auf plattformspezifische Funktionen von „ QOpenGLContext “, wie sie im Namespace „ QNativeInterface “ definiert sind:

Ist die angeforderte Schnittstelle nicht verfügbar, wird ein ` nullptr ` zurückgegeben.

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

Gibt den zugrunde liegenden OpenGL-Implementierungstyp zurück.

Auf Plattformen, auf denen die OpenGL-Implementierung nicht dynamisch geladen wird, wird der Rückgabewert zur Kompilierungszeit festgelegt und ändert sich nie.

QScreen *QOpenGLContext::screen() const

Gibt den Bildschirm zurück, für den der Kontext erstellt wurde.

Siehe auch „ setScreen()“.

void QOpenGLContext::setFormat(const QSurfaceFormat &format)

Legt das „ format “ fest, mit dem der OpenGL-Kontext kompatibel sein soll. Damit die Änderung wirksam wird, müssen Sie zunächst die Funktion „ create()“ aufrufen.

Wenn das Format nicht explizit über diese Funktion festgelegt wird, wird das von ` QSurfaceFormat::defaultFormat()` zurückgegebene Format verwendet. Das bedeutet, dass bei mehreren Kontexten einzelne Aufrufe dieser Funktion durch einen einzigen Aufruf von ` QSurfaceFormat::setDefaultFormat()` vor der Erstellung des ersten Kontexts ersetzt werden können.

Siehe auch format().

void QOpenGLContext::setScreen(QScreen *screen)

Legt die „ screen “ fest, für die der OpenGL-Kontext gültig sein soll. Damit die Einstellung wirksam wird, müssen Sie „ create()“ aufrufen.

Siehe auch ` screen()`.

void QOpenGLContext::setShareContext(QOpenGLContext *shareContext)

Dadurch werden Texturen, Shader und andere OpenGL-Ressourcen in diesem Kontext gemeinsam mit shareContext genutzt. Damit dies wirksam wird, müssen Sie create() aufrufen.

Siehe auch ` shareContext()`.

QOpenGLContext *QOpenGLContext::shareContext() const

Gibt den Freigabekontext zurück, mit dem dieser Kontext erstellt wurde.

Wenn die zugrunde liegende Plattform die angeforderte Freigabe nicht unterstützen konnte, wird hier 0 zurückgegeben.

Siehe auch ` setShareContext()`.

QOpenGLContextGroup *QOpenGLContext::shareGroup() const

Gibt die Berechtigungsgruppe zurück, zu der dieser Kontext gehört.

[static] bool QOpenGLContext::supportsThreadedOpenGL()

Gibt „ true “ zurück, wenn die Plattform OpenGL-Rendering außerhalb des Haupt- (GUI-)Threads unterstützt.

Der Wert wird durch das verwendete Plattform-Plugin gesteuert und kann auch von den Grafiktreibern abhängen.

QSurface *QOpenGLContext::surface() const

Gibt die Oberfläche zurück, die im Kontext als aktuelle Oberfläche festgelegt wurde.

Dies ist die Oberfläche, die als Argument an ` makeCurrent()` übergeben wurde.

void QOpenGLContext::swapBuffers(QSurface *surface)

Tauschen Sie den hinteren und den vorderen Puffer von ` surface` aus.

Rufen Sie diese Funktion auf, um einen Frame der OpenGL-Rendering-Verarbeitung abzuschließen, und stellen Sie sicher, dass Sie makeCurrent() erneut aufrufen, bevor Sie weitere OpenGL-Befehle ausführen, beispielsweise als Teil eines neuen Frames.