QOpenGLWindow Class
Die Klasse „QOpenGLWindow“ ist eine Hilfsunterklasse von „ QWindow “, die zum Zeichnen mit OpenGL dient. Mehr...
| Header: | #include <QOpenGLWindow> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS OpenGL) target_link_libraries(mytarget PRIVATE Qt6::OpenGL) |
| qmake: | QT += opengl |
| Erbt von: | QPaintDeviceWindow |
Öffentliche Typen
| enum | UpdateBehavior { NoPartialUpdate, PartialUpdateBlit, PartialUpdateBlend } |
Öffentliche Funktionen
| QOpenGLWindow(QOpenGLWindow::UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = nullptr) | |
| QOpenGLWindow(QOpenGLContext *shareContext, QOpenGLWindow::UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = nullptr) | |
| virtual | ~QOpenGLWindow() |
| QOpenGLContext * | context() const |
| GLuint | defaultFramebufferObject() const |
| void | doneCurrent() |
| QImage | grabFramebuffer() |
| bool | isValid() const |
| void | makeCurrent() |
| QOpenGLContext * | shareContext() const |
| QOpenGLWindow::UpdateBehavior | updateBehavior() const |
Signale
| void | frameSwapped() |
Geschützte Funktionen
| virtual void | initializeGL() |
| virtual void | paintGL() |
| virtual void | paintOverGL() |
| virtual void | paintUnderGL() |
| virtual void | resizeGL(int w, int h) |
Neu implementierte geschützte Funktionen
| virtual void | paintEvent(QPaintEvent *event) override |
| virtual void | resizeEvent(QResizeEvent *event) override |
Ausführliche Beschreibung
QOpenGLWindow ist eine erweiterte Version von ` QWindow `, die das einfache Erstellen von Fenstern ermöglicht, die OpenGL-Rendering mithilfe einer API durchführen, die mit ` QOpenGLWidget ` kompatibel ist. Im Gegensatz zu ` QOpenGLWidget` ist `QOpenGLWindow` nicht vom Widgets-Modul abhängig und bietet eine bessere Leistung.
Eine typische Anwendung wird eine Unterklasse von QOpenGLWindow erstellen und die folgenden virtuellen Funktionen neu implementieren:
- initializeGL() zur Initialisierung der OpenGL-Ressourcen
- resizeGL() zum Einrichten der Transformationsmatrizen und anderer von der Fenstergröße abhängiger Ressourcen
- paintGL() zum Ausgeben von OpenGL-Befehlen oder zum Zeichnen mithilfe von QPainter
Um eine Neuzeichnung zu planen, rufen Sie die Funktion ` update()` auf. Beachten Sie, dass dies nicht sofort zu einem Aufruf von ` paintGL()` führt. Ein mehrfacher Aufruf von ` update()` hintereinander ändert das Verhalten in keiner Weise.
Da es sich um einen Slot handelt, kann er mit einem „ QChronoTimer::timeout()“-Signal verbunden werden, um Animationen auszuführen. Beachten Sie jedoch, dass es in der modernen OpenGL-Welt weitaus besser ist, sich auf die Synchronisation mit der vertikalen Bildwiederholfrequenz des Bildschirms zu verlassen. Eine Beschreibung des Swap-Intervalls finden Sie unter „ setSwapInterval()“. Bei einem Swap-Intervall von 1, was auf den meisten Systemen standardmäßig der Fall ist, wird der Aufruf von ` swapBuffers()`, der intern von `QOpenGLWindow` nach jedem Repaint ausgeführt wird, blockiert und auf `vsync` warten. Das bedeutet, dass nach jedem Swap eine Aktualisierung durch den Aufruf von ` update()` erneut geplant werden kann, ohne auf Timer angewiesen zu sein.
Um eine bestimmte Konfiguration für den Kontext anzufordern, verwenden Sie ` setFormat()` wie bei jedem anderen ` QWindow`. Dies ermöglicht unter anderem die Anforderung einer bestimmten OpenGL-Version und eines bestimmten Profils oder die Aktivierung von Tiefen- und Stencil-Puffern.
Hinweis: Es obliegt der Anwendung, sicherzustellen, dass Tiefen- und Stencil-Puffer über die zugrunde liegende Fenster-Systemschnittstelle angefordert werden. Ohne die Angabe einer Tiefenpuffergröße ungleich Null gibt es keine Garantie dafür, dass ein Tiefenpuffer verfügbar ist, und infolgedessen funktionieren OpenGL-Operationen im Zusammenhang mit Tiefenprüfungen möglicherweise nicht wie erwartet.
Häufig verwendete Anforderungen für die Größe von Tiefen- und Stencil-Puffern sind 24 bzw. 8. Eine Unterklasse von `QOpenGLWindow` könnte dies beispielsweise in ihrem Konstruktor tun:
QSurfaceFormat format;
format.setDepthBufferSize(24);
format.setStencilBufferSize(8);
setFormat(format);Im Gegensatz zu ` QWindow` erlaubt `QOpenGLWindow` das Öffnen eines Painters auf sich selbst und das Zeichnen auf Basis von ` QPainter`.
QOpenGLWindow unterstützt mehrere Aktualisierungsmodi. Der Standardmodus „ NoPartialUpdate “ entspricht einem regulären, OpenGL-basierten „ QWindow “. Im Gegensatz dazu entsprechen „ PartialUpdateBlit “ und „ PartialUpdateBlend “ eher der Funktionsweise von „ QOpenGLWidget “, bei der stets ein zusätzliches, dediziertes Framebuffer-Objekt vorhanden ist. Diese Modi ermöglichen es, auf Kosten einer gewissen Leistung bei jedem Zeichnungsvorgang nur einen kleineren Bereich neu zu zeichnen und den Rest des Inhalts aus dem vorherigen Frame beizubehalten. Dies ist nützlich für Anwendungen, die inkrementell mit QPainter rendern, da sie auf diese Weise nicht bei jedem Aufruf von paintGL() den gesamten Fensterinhalt neu zeichnen müssen.
Ähnlich wie bei ` QOpenGLWidget` unterstützt `QOpenGLWindow` das Attribut ` Qt::AA_ShareOpenGLContexts `. Wenn dieses aktiviert ist, werden die OpenGL-Kontexte aller `QOpenGLWindow`-Instanzen miteinander geteilt. Dies ermöglicht den Zugriff auf die gemeinsam nutzbaren OpenGL-Ressourcen der anderen Instanzen.
Weitere Informationen zur Grafik in Qt finden Sie unter „Grafik“.
Dokumentation zu Mitgliedstypen
enum QOpenGLWindow::UpdateBehavior
Diese Enumeration beschreibt die Aktualisierungsstrategie des „ QOpenGLWindow “.
| Konstante | Wert | Beschreibung |
|---|---|---|
QOpenGLWindow::NoPartialUpdate | 0 | Gibt an, dass bei jeder Aktualisierung die gesamte Fensterfläche neu gezeichnet wird und daher keine zusätzlichen Framebuffer benötigt werden. Dies ist die in den meisten Fällen verwendete Einstellung und entspricht der Funktionsweise einer direkten Zeichnung über ` QWindow `. |
QOpenGLWindow::PartialUpdateBlit | 1 | Gibt an, dass das in ` paintGL()` durchgeführte Zeichnen nicht das gesamte Fenster abdeckt. In diesem Fall wird im Hintergrund ein zusätzliches Framebuffer-Objekt erstellt, und das in ` paintGL()` durchgeführte Rendering zielt auf diesen Framebuffer ab. Dieser Framebuffer wird dann nach jedem Zeichendurchlauf auf den Standard-Framebuffer der Fensteroberfläche geblitzt. Dies ermöglicht es, in ` paintGL()` Zeichencode auf Basis von ` QPainter` zu verwenden, der jeweils nur einen kleineren Bereich neu zeichnet, da im Gegensatz zu `NoPartialUpdate` der vorherige Inhalt beibehalten wird. |
QOpenGLWindow::PartialUpdateBlend | 2 | Ähnlich wie bei „PartialUpdateBlit“, jedoch wird der Inhalt des zusätzlichen Framebuffers nicht per Framebuffer-Blit übertragen, sondern durch das Zeichnen eines texturierten Quadrats mit aktivierter Überblendung gerendert. Dies ermöglicht im Gegensatz zu „PartialUpdateBlit“ Inhalte mit Alpha-Überblendung und funktioniert auch dann, wenn „glBlitFramebuffer“ nicht verfügbar ist. In Bezug auf die Leistung ist diese Einstellung wahrscheinlich etwas langsamer als „PartialUpdateBlit“. |
Dokumentation der Member-Funktionen
[explicit] QOpenGLWindow::QOpenGLWindow(QOpenGLWindow::UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = nullptr)
Erstellt ein neues `QOpenGLWindow` mit den angegebenen ` parent ` und ` updateBehavior`.
Siehe auch QOpenGLWindow::UpdateBehavior.
[explicit] QOpenGLWindow::QOpenGLWindow(QOpenGLContext *shareContext, QOpenGLWindow::UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = nullptr)
Erstellt ein neues `QOpenGLWindow` mit den angegebenen Werten für ` parent ` und ` updateBehavior`. Der Kontext des `QOpenGLWindow` wird gemeinsam mit ` shareContext` genutzt.
Siehe auch QOpenGLWindow::UpdateBehavior und shareContext.
[virtual noexcept] QOpenGLWindow::~QOpenGLWindow()
Zerstört die „ QOpenGLWindow “-Instanz und gibt deren Ressourcen frei.
Der Kontext des `OpenGLWindow` wird im Destruktor als aktuell gesetzt, wodurch eine sichere Zerstörung aller untergeordneten Objekte ermöglicht wird, die möglicherweise OpenGL-Ressourcen freigeben müssen, die zu dem von diesem Fenster bereitgestellten Kontext gehören.
Warnung: Wenn Sie Objekte haben, die OpenGL-Ressourcen (wie z. B. ` QOpenGLBuffer`, ` QOpenGLShaderProgram` usw.) als Mitglieder einer Unterklasse von ` QOpenGLWindow ` umschließen, müssen Sie möglicherweise auch im Destruktor dieser Unterklasse einen Aufruf von ` makeCurrent()` hinzufügen. Aufgrund der Regeln zur Objektzerstörung in C++ werden diese Objekte vor dem Aufruf dieser Funktion zerstört (jedoch nachdem der Destruktor der Unterklasse bereits ausgeführt wurde); daher erfolgt die Aktivierung des OpenGL-Kontexts in dieser Funktion zu spät, um eine sichere Entsorgung dieser Objekte zu gewährleisten.
Siehe auch makeCurrent.
QOpenGLContext *QOpenGLWindow::context() const
Gibt den von diesem Fenster verwendeten ` QOpenGLContext ` zurück oder ` 0 `, falls dieser noch nicht initialisiert wurde.
GLuint QOpenGLWindow::defaultFramebufferObject() const
Das von diesem Fenster verwendete Framebuffer-Objekt-Handle.
Wenn das Aktualisierungsverhalten auf „ NoPartialUpdate “ gesetzt ist, gibt es kein separates Framebuffer-Objekt. In diesem Fall ist der zurückgegebene Wert die ID des Standard-Framebuffers.
Andernfalls ist der Wert die ID des Framebuffer-Objekts oder „ 0 “, falls dieses noch nicht initialisiert wurde.
void QOpenGLWindow::doneCurrent()
Gibt den Kontext frei.
In den meisten Fällen ist es nicht notwendig, diese Funktion aufzurufen, da das Widget beim Aufruf von ` paintGL()` dafür sorgt, dass der Kontext ordnungsgemäß gebunden und freigegeben wird.
Siehe auch ` makeCurrent()`.
[signal] void QOpenGLWindow::frameSwapped()
Dieses Signal wird ausgegeben, nachdem die möglicherweise blockierende Funktion „ buffer swap “ ausgeführt wurde. Anwendungen, die eine kontinuierliche Neuzeichnung synchron zur vertikalen Bildwiederholfrequenz wünschen, sollten bei Erhalt dieses Signals die Funktion „ update()“ aufrufen. Dies ermöglicht ein deutlich flüssigeres Erlebnis im Vergleich zur herkömmlichen Verwendung von Timern.
QImage QOpenGLWindow::grabFramebuffer()
Gibt eine Kopie des Framebuffers zurück.
Hinweis: Dies ist ein potenziell rechenintensiver Vorgang, da er auf glReadPixels() zurückgreift, um die Pixel auszulesen. Dies kann langsam sein und die GPU-Pipeline blockieren.
Hinweis: Bei Verwendung in Verbindung mit dem Aktualisierungsverhalten „ NoPartialUpdate “ enthält das zurückgegebene Bild möglicherweise nicht den gewünschten Inhalt, wenn die Funktion aufgerufen wird, nachdem der vordere und der hintere Puffer vertauscht wurden (es sei denn, „Preserved Swap“ ist in der zugrunde liegenden Fenstersystem-Schnittstelle aktiviert). In diesem Modus liest die Funktion aus dem Back-Buffer, dessen Inhalt möglicherweise nicht mit dem Inhalt auf dem Bildschirm (dem Front-Buffer) übereinstimmt. In diesem Fall kann diese Funktion nur an den Stellen sicher verwendet werden, an denen „ paintGL()“ oder „ paintOverGL()“ aufgerufen werden.
[virtual protected] void QOpenGLWindow::initializeGL()
Diese virtuelle Funktion wird einmal vor dem ersten Aufruf von ` paintGL()` oder ` resizeGL()` aufgerufen. Implementieren Sie sie in einer Unterklasse neu.
Diese Funktion sollte alle erforderlichen OpenGL-Ressourcen und den entsprechenden Status einrichten.
Es ist nicht erforderlich, ` makeCurrent()` aufzurufen, da dies bereits beim Aufruf dieser Funktion geschehen ist. Beachten Sie jedoch, dass der Framebuffer – falls der Teilaktualisierungsmodus verwendet wird – zu diesem Zeitpunkt noch nicht verfügbar ist; vermeiden Sie daher, von hier aus Zeichenaufrufe auszuführen. Verschieben Sie solche Aufrufe stattdessen auf ` paintGL()`.
Siehe auch paintGL() und resizeGL().
bool QOpenGLWindow::isValid() const
Gibt „ true “ zurück, wenn die OpenGL-Ressourcen des Fensters, wie beispielsweise der Kontext, erfolgreich initialisiert wurden. Beachten Sie, dass der Rückgabewert immer „ false “ lautet, bis das Fenster sichtbar wird (angezeigt wird).
void QOpenGLWindow::makeCurrent()
Bereitet die Darstellung von OpenGL-Inhalten für dieses Fenster vor, indem der entsprechende Kontext als aktueller Kontext festgelegt und das Framebuffer-Objekt – sofern vorhanden – in diesem Kontext gebunden wird.
In den meisten Fällen ist es nicht erforderlich, diese Funktion aufzurufen, da sie automatisch vor dem Aufruf von ` paintGL()` aufgerufen wird. Sie wird dennoch bereitgestellt, um fortgeschrittene Multithreading-Szenarien zu unterstützen, in denen ein anderer Thread als der GUI- oder Haupt-Thread die Oberfläche oder den Inhalt des Framebuffers aktualisieren möchte. Weitere Informationen zu Themen rund um Threading finden Sie unter QOpenGLContext.
Diese Funktion kann auch dann aufgerufen werden, wenn das zugrunde liegende Plattformfenster bereits zerstört wurde. Das bedeutet, dass es sicher ist, diese Funktion aus dem Destruktor einer Unterklasse von ` QOpenGLWindow ` aufzurufen. Wenn kein natives Fenster mehr vorhanden ist, wird stattdessen eine Offscreen-Oberfläche verwendet. Dies stellt sicher, dass die Bereinigungsvorgänge für OpenGL-Ressourcen im Destruktor immer funktionieren, solange diese Funktion zuerst aufgerufen wird.
Siehe auch „ QOpenGLContext“ , „ context()“, „ paintGL()“ und „ doneCurrent()“.
[override virtual protected] void QOpenGLWindow::paintEvent(QPaintEvent *event)
Umsetzt: ` QPaintDeviceWindow::paintEvent` (`QPaintEvent *event`).
Zeichnet den Handler „ event “. Ruft „ paintGL()“ auf.
Siehe auch paintGL().
[virtual protected] void QOpenGLWindow::paintGL()
Diese virtuelle Funktion wird immer dann aufgerufen, wenn der Fensterinhalt neu gezeichnet werden muss. Implementieren Sie sie in einer Unterklasse neu.
Es ist nicht erforderlich, ` makeCurrent()` aufzurufen, da dies bereits beim Aufruf dieser Funktion geschehen ist.
Vor dem Aufruf dieser Funktion werden der Kontext und der Framebuffer (falls vorhanden) gebunden, und der Viewport wird durch einen Aufruf von `glViewport()` eingerichtet. Es wird kein weiterer Status gesetzt, und das Framework führt weder ein Löschen noch ein Zeichnen durch.
Hinweis: Bei Verwendung eines partiellen Aktualisierungsverhaltens, wie z. B. ` PartialUpdateBlend`, bleibt die Ausgabe des vorherigen `paintGL()`-Aufrufs erhalten, und nach dem zusätzlichen Zeichnen, das beim aktuellen Aufruf der Funktion durchgeführt wird, wird der Inhalt über den direkt in ` paintUnderGL()` ins Fenster gezeichneten Inhalt geblitzt oder gemischt.
Siehe auch initializeGL(), resizeGL(), paintUnderGL(), paintOverGL() und UpdateBehavior.
[virtual protected] void QOpenGLWindow::paintOverGL()
Diese virtuelle Funktion wird nach jedem Aufruf von ` paintGL()` aufgerufen.
Wenn der Aktualisierungsmodus auf ` NoPartialUpdate` gesetzt ist, gibt es keinen Unterschied zwischen dieser Funktion und ` paintGL()`; das Rendern in beiden Fällen führt zum gleichen Ergebnis.
Wie bei ` paintUnderGL()` erfolgt das Rendern in dieser Funktion unabhängig vom Aktualisierungsverhalten auf den Standard-Framebuffer des Fensters. Sie wird aufgerufen, nachdem ` paintGL()` zurückgegeben wurde und das Blit (PartialUpdateBlit) oder das Zeichnen von Quads (PartialUpdateBlend) abgeschlossen ist.
Siehe auch paintGL(), paintUnderGL() und UpdateBehavior.
[virtual protected] void QOpenGLWindow::paintUnderGL()
Die virtuelle Funktion wird vor jedem Aufruf von ` paintGL()` aufgerufen.
Wenn der Aktualisierungsmodus auf „ NoPartialUpdate “ gesetzt ist, gibt es keinen Unterschied zwischen dieser Funktion und „ paintGL()“; das Rendern in beiden Fällen führt zum gleichen Ergebnis.
Der Unterschied wird deutlich, wenn „ PartialUpdateBlend “ verwendet wird, da dabei ein zusätzliches Framebuffer-Objekt zum Einsatz kommt. In diesem Fall zielt „ paintGL()“ auf dieses zusätzliche Framebuffer-Objekt ab, wodurch dessen Inhalt erhalten bleibt, während „paintUnderGL()“ und „ paintOverGL()“ auf den Standard-Framebuffer abzielen, d. h. direkt auf die Fensteroberfläche, deren Inhalt nach jedem angezeigten Frame verloren geht.
Hinweis: Vermeiden Sie es, sich auf diese Funktion zu verlassen, wenn das Aktualisierungsverhalten auf „ PartialUpdateBlit “ eingestellt ist. In diesem Modus wird der von ` paintGL()` verwendete zusätzliche Framebuffer nach jedem Aufruf von ` paintGL()` auf den Standard-Framebuffer kopiert, wodurch alle in dieser Funktion erzeugten Zeichnungen überschrieben werden.
Siehe auch paintGL(), paintOverGL() und UpdateBehavior.
[override virtual protected] void QOpenGLWindow::resizeEvent(QResizeEvent *event)
Implementiert: QWindow::resizeEvent(QResizeEvent *ev).
Handler für die Größenänderung von „ event “. Ruft „ resizeGL()“ auf.
Siehe auch „ resizeGL()“.
[virtual protected] void QOpenGLWindow::resizeGL(int w, int h)
Diese virtuelle Funktion wird immer dann aufgerufen, wenn die Größe des Widgets geändert wurde. Implementieren Sie sie in einer Unterklasse neu. Die neue Größe wird über die Parameter „ w “ und „ h “ übergeben.
Hinweis: Hierbei handelt es sich lediglich um eine Hilfsfunktion, um eine API bereitzustellen, die mit QOpenGLWidget kompatibel ist. Anders als bei QOpenGLWidget steht es abgeleiteten Klassen frei, anstelle dieser Funktion resizeEvent() zu überschreiben.
Hinweis: Vermeiden Sie es, OpenGL-Befehle über diese Funktion auszuführen, da zum Zeitpunkt des Aufrufs möglicherweise kein Kontext aktiv ist. Falls dies nicht vermeidbar ist, rufen Sie makeCurrent() auf.
Hinweis: Die Planung von Aktualisierungen von hier aus ist nicht erforderlich. Die Fenstersysteme senden „Expose“-Ereignisse, die automatisch eine Aktualisierung auslösen.
Siehe auch ` initializeGL()` und ` paintGL()`.
QOpenGLContext *QOpenGLWindow::shareContext() const
Gibt die „ QOpenGLContext “ zurück, deren Freigabe für die „ QOpenGLContext “ dieses Fensters angefordert wurde.
QOpenGLWindow::UpdateBehavior QOpenGLWindow::updateBehavior() const
Gibt das Aktualisierungsverhalten für diese „ QOpenGLWindow “ zurück.
© 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.