QOpenGLWidget Class

Ausführliche Beschreibung

Qt OpenGL Widget bietet Funktionen zur Darstellung von OpenGL-Grafiken, die in eine Qt-Anwendung integriert sind. Die Verwendung ist sehr einfach: Lassen Sie Ihre Klasse von dieser Klasse erben und verwenden Sie die Unterklasse wie jedes andere „ QWidget “, mit dem Unterschied, dass Sie die Wahl zwischen der Verwendung von „ QPainter “ und den Standard-OpenGL-Rendering-Befehlen haben.

QOpenGLWidget stellt drei praktische virtuelle Funktionen bereit, die Sie in Ihrer Unterklasse neu implementieren können, um die typischen OpenGL-Aufgaben auszuführen:

• paintGL() – Rendert die OpenGL-Szene. Wird immer dann aufgerufen, wenn das Widget aktualisiert werden muss.
• resizeGL() – Richtet den OpenGL-Viewport, die Projektion usw. ein. Wird aufgerufen, sobald die Größe des Widgets geändert wurde (und auch, wenn es zum ersten Mal angezeigt wird, da alle neu erstellten Widgets automatisch ein Resize-Ereignis erhalten).
• initializeGL() – Richtet die OpenGL-Ressourcen und den Status ein. Wird einmalig aufgerufen, bevor zum ersten Mal „ resizeGL()“ oder „ paintGL()“ aufgerufen wird.

Wenn Sie eine Neuzeichnung an anderen Stellen als in „ paintGL()“ auslösen müssen (ein typisches Beispiel ist die Verwendung von „ timers “ zur Animation von Szenen), sollten Sie die Funktion „ update()“ des Widgets aufrufen, um eine Aktualisierung zu planen.

Der OpenGL-Rendering-Kontext Ihres Widgets wird aktiv, wenn paintGL(), resizeGL() oder initializeGL() aufgerufen wird. Wenn Sie die Standardfunktionen der OpenGL-API an anderen Stellen aufrufen müssen (z. B. im Konstruktor Ihres Widgets oder in Ihren eigenen Zeichnungsfunktionen), müssen Sie zuvor makeCurrent() aufrufen.

Das gesamte Rendering erfolgt in einem OpenGL-Framebuffer-Objekt. ` makeCurrent()` stellt sicher, dass dieses im Kontext gebunden ist. Beachten Sie dies, wenn Sie im Rendering-Code in ` paintGL()` zusätzliche Framebuffer-Objekte erstellen und binden. Binden Sie den Framebuffer mit der ID 0 niemals erneut. Rufen Sie stattdessen ` defaultFramebufferObject()` auf, um die ID zu erhalten, die gebunden werden soll.

QOpenGLWidget ermöglicht die Verwendung verschiedener OpenGL-Versionen und -Profile, sofern die Plattform dies unterstützt. Legen Sie das gewünschte Format einfach über ` setFormat()` fest. Beachten Sie jedoch, dass bei mehreren `QOpenGLWidget`-Instanzen im selben Fenster alle dasselbe Format verwenden müssen oder zumindest Formate, die die Kontexte nicht unteilbar machen. Um dieses Problem zu umgehen, sollten Sie ` QSurfaceFormat::setDefaultFormat()` anstelle von ` setFormat()` verwenden.

Zeichentechniken

Wie oben beschrieben, erstellen Sie eine Unterklasse von `QOpenGLWidget`, um reine 3D-Inhalte wie folgt darzustellen:

• Implementieren Sie die Funktionen ` initializeGL()` und ` resizeGL()` neu, um den OpenGL-Status einzurichten und eine perspektivische Transformation bereitzustellen.
• Implementieren Sie ` paintGL()` neu, um die 3D-Szene zu zeichnen, wobei Sie ausschließlich OpenGL-Funktionen aufrufen.

Es ist auch möglich, 2D-Grafiken mithilfe von ` QPainter` auf eine Unterklasse von `QOpenGLWidget` zu zeichnen:

• Erstellen Sie in ` paintGL()` anstelle der Ausgabe von OpenGL-Befehlen ein ` QPainter `-Objekt zur Verwendung im Widget.
• Zeichnen Sie Primitive mithilfe der Memberfunktionen von ` QPainter`.
• Direkte OpenGL-Befehle können weiterhin ausgegeben werden. Sie müssen jedoch sicherstellen, dass diese durch einen Aufruf der Methoden `beginNativePainting()` und `endNativePainting()` des Painters umschlossen sind.

Wenn das Zeichnen ausschließlich über ` QPainter ` erfolgt, ist es auch möglich, das Zeichnen wie bei gewöhnlichen Widgets durchzuführen: durch Neaimplementierung von ` paintEvent()`.

• Implementieren Sie die Funktion ` paintEvent()` neu.
• Erstellen Sie ein ` QPainter `-Objekt, das auf das Widget abzielt. Übergeben Sie das Widget entweder an den Konstruktor oder an die Funktion ` QPainter::begin()`.
• Zeichnen Sie Primitive mithilfe der Member-Funktionen von ` QPainter`.
• Nach Abschluss des Zeichnungsvorgangs wird die ` QPainter `-Instanz zerstört. Alternativ können Sie ` QPainter::end()` explizit aufrufen.

OpenGL-Funktionsaufrufe, Header und QOpenGLFunctions

Bei OpenGL-Funktionsaufrufen wird dringend empfohlen, einen direkten Aufruf der Funktionen zu vermeiden. Verwenden Sie stattdessen vorzugsweise ` QOpenGLFunctions ` (bei der Erstellung portabler Anwendungen) oder die versionierten Varianten (z. B. ` QOpenGLFunctions_3_2_Core ` und ähnliche, wenn modernes, ausschließlich für den Desktop bestimmtes OpenGL angestrebt wird). Auf diese Weise funktioniert die Anwendung in allen Qt-Build-Konfigurationen korrekt, einschließlich derjenigen, die das dynamische Laden von OpenGL-Implementierungen durchführen. Das bedeutet, dass Anwendungen nicht direkt mit einer GL-Implementierung verknüpft sind und direkte Funktionsaufrufe daher nicht möglich sind.

In ` paintGL()` ist der aktuelle Kontext immer über den Aufruf von ` QOpenGLContext::currentContext()` zugänglich. Aus diesem Kontext heraus kann eine bereits initialisierte, einsatzbereite ` QOpenGLFunctions `-Instanz durch den Aufruf von ` QOpenGLContext::functions()` abgerufen werden. Eine Alternative zum Voranstellen eines Präfixes vor jeden GL-Aufruf besteht darin, von ` QOpenGLFunctions ` zu erben und ` QOpenGLFunctions::initializeOpenGLFunctions()` in ` initializeGL()` aufzurufen.

Was die OpenGL-Header betrifft, ist zu beachten, dass es in den meisten Fällen nicht erforderlich ist, Header wie GL.h direkt einzubinden. Die OpenGL-bezogenen Qt-Header binden qopengl.h ein, das wiederum einen für das jeweilige System geeigneten Header einbindet. Dies kann ein OpenGL ES 3.x- oder 2.0-Header sein, die höchste verfügbare Version oder eine vom System bereitgestellte `gl.h`. Darüber hinaus wird im Rahmen von Qt sowohl für OpenGL als auch für OpenGL ES eine Kopie der Erweiterungs-Header (auf einigen Systemen „glext.h“ genannt) bereitgestellt. Diese werden auf Plattformen, auf denen dies möglich ist, automatisch eingebunden. Das bedeutet, dass Konstanten und Typdefinitionen für Funktionszeiger aus den Erweiterungen ARB, EXT und OES automatisch verfügbar sind.

Code-Beispiele

Für den Einstieg könnte die einfachste Unterklasse von `QOpenGLWidget` wie folgt aussehen:

class MyGLWidget : public QOpenGLWidget
{
public:
    MyGLWidget(QWidget *parent) : QOpenGLWidget(parent) { }

protected:
    void initializeGL() override
    {
        // Set up the rendering context, load shaders and other resources, etc.:
        QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
        f->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        ...
    }

    void resizeGL(int w, int h) override
    {
        // Update projection matrix and other size related settings:
        m_projection.setToIdentity();
        m_projection.perspective(45.0f, w / float(h), 0.01f, 100.0f);
        ...
    }

    void paintGL() override
    {
        // Draw the scene:
        QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
        f->glClear(GL_COLOR_BUFFER_BIT);
        ...
    }

};

Alternativ lässt sich das Voranstellen des Präfixes bei jedem einzelnen OpenGL-Aufruf vermeiden, indem man stattdessen von ` QOpenGLFunctions ` ableitet:

class MyGLWidget : public QOpenGLWidget, protected QOpenGLFunctions
{
    ...
    void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(...);
        ...
    }
    ...
};

Um einen Kontext zu erhalten, der mit einer bestimmten OpenGL-Version oder einem bestimmten Profil kompatibel ist, oder um Tiefen- und Stencil-Puffer anzufordern, rufen Sie ` setFormat()` auf:

QOpenGLWidget *widget = new QOpenGLWidget(parent);
QSurfaceFormat format;
format.setDepthBufferSize(24);
format.setStencilBufferSize(8);
format.setVersion(3, 2);
format.setProfile(QSurfaceFormat::CoreProfile);
widget->setFormat(format); // must be called before the widget or its parent window gets shown

Bei OpenGL 3.0+-Kontexten, bei denen Portabilität keine Rolle spielt, bieten die versionierten Varianten von ` QOpenGLFunctions ` einfachen Zugriff auf alle modernen OpenGL-Funktionen, die in einer bestimmten Version verfügbar sind:

    ...
    void paintGL() override
    {
        QOpenGLFunctions_3_2_Core *f = QOpenGLContext::currentContext()->versionFunctions<QOpenGLFunctions_3_2_Core>();
        ...
        f->glDrawArraysInstanced(...);
        ...
    }
    ...

Wie oben beschrieben, ist es einfacher und robuster, das gewünschte Format global festzulegen, sodass es während der gesamten Laufzeit der Anwendung für alle Fenster und Kontexte gilt. Nachfolgend finden Sie ein Beispiel hierfür:

int main(int argc, char **argv)
{
    QApplication app(argc, argv);

    QSurfaceFormat format;
    format.setDepthBufferSize(24);
    format.setStencilBufferSize(8);
    format.setVersion(3, 2);
    format.setProfile(QSurfaceFormat::CoreProfile);
    QSurfaceFormat::setDefaultFormat(format);

    MyWidget widget;
    widget.show();

    return app.exec();
}

Multisampling

Um Multisampling zu aktivieren, legen Sie die Anzahl der angeforderten Samples im „ QSurfaceFormat “ fest, der an „ setFormat()“ übergeben wird. Auf Systemen, die dies nicht unterstützen, wird die Anforderung möglicherweise ignoriert.

Die Unterstützung von Multisampling setzt die Unterstützung von Multisampling-Renderbuffern und Framebuffer-Blits voraus. Bei OpenGL ES 2.0-Implementierungen ist es wahrscheinlich, dass diese Funktionen nicht vorhanden sind. Das bedeutet, dass Multisampling nicht verfügbar ist. Bei modernen OpenGL-Versionen sowie OpenGL ES 3.0 und höher stellt dies in der Regel kein Problem mehr dar.

Threading

Das Ausführen von Offscreen-Rendering in Worker-Threads, beispielsweise zur Erzeugung von Texturen, die anschließend im GUI-/Haupt-Thread in ` paintGL()` verwendet werden, wird unterstützt, indem die ` QOpenGLContext ` des Widgets freigegeben wird, sodass in jedem Thread zusätzliche Kontexte erstellt werden können, die diese gemeinsam nutzen.

Das direkte Zeichnen in den Framebuffer des QOpenGLWidget außerhalb des GUI-/Haupt-Threads ist möglich, indem ` paintEvent()` so neu implementiert wird, dass es nichts ausführt. Die Thread-Affinität des Kontexts muss über ` QObject::moveToThread()` geändert werden. Danach sind ` makeCurrent()` und ` doneCurrent()` im Worker-Thread nutzbar. Achten Sie darauf, den Kontext anschließend wieder in den GUI-/Haupt-Thread zu verschieben.

Das Auslösen eines Puffertauschs nur für das `QOpenGLWidget` ist nicht möglich, da es dafür keine echte, native Oberfläche auf dem Bildschirm gibt. Es obliegt dem Widget-Stack, die Komposition und Puffertauschvorgänge im GUI-Thread zu verwalten. Wenn ein Thread die Aktualisierung des Framebuffers abgeschlossen hat, rufen Sie ` update()` im GUI-/Hauptthread auf, um die Komposition zu planen.

Es ist besonders darauf zu achten, die Nutzung des Framebuffers zu vermeiden, während der GUI-/Haupt-Thread die Komposition durchführt. Die Signale ` aboutToCompose()` und ` frameSwapped()` werden beim Start und beim Ende der Komposition ausgesendet. Sie werden im GUI-/Haupt-Thread ausgesendet. Das bedeutet, dass bei Verwendung einer direkten Verbindung „ aboutToCompose()“ den GUI-/Haupt-Thread blockieren kann, bis der Worker-Thread sein Rendering abgeschlossen hat. Danach darf der Worker-Thread kein weiteres Rendering durchführen, bis das Signal „ frameSwapped()“ ausgelöst wird. Ist dies nicht akzeptabel, muss der Worker-Thread einen Doppelpufferungsmechanismus implementieren. Dies beinhaltet das Zeichnen unter Verwendung eines alternativen Renderziels, das vollständig vom Thread gesteuert wird, z. B. eines zusätzlichen Framebuffer-Objekts, sowie das Blitten in den Framebuffer des QOpenGLWidget zu einem geeigneten Zeitpunkt.

Kontext-Freigabe

Wenn mehrere `QOpenGLWidgets` als untergeordnete Elemente zum selben Widget der obersten Ebene hinzugefügt werden, teilen sich ihre Kontexte untereinander. Dies gilt nicht für `QOpenGLWidget`-Instanzen, die zu unterschiedlichen Fenstern gehören.

Das bedeutet, dass alle QOpenGLWidgets im selben Fenster auf die gemeinsam nutzbaren Ressourcen der anderen zugreifen können, wie z. B. Texturen, und dass kein zusätzlicher „global share“-Kontext erforderlich ist.

Um die gemeinsame Nutzung zwischen QOpenGLWidget-Instanzen einzurichten, die zu verschiedenen Fenstern gehören, setzen Sie das Anwendungsattribut ` Qt::AA_ShareOpenGLContexts `, bevor Sie ` QApplication` instanziieren. Dies löst die gemeinsame Nutzung zwischen allen QOpenGLWidget-Instanzen ohne weitere Schritte aus.

Es ist auch möglich, zusätzliche ` QOpenGLContext `-Instanzen zu erstellen, die Ressourcen wie Texturen mit dem Kontext des `QOpenGLWidget` gemeinsam nutzen. Übergeben Sie dazu einfach den von ` context()` zurückgegebenen Zeiger an ` QOpenGLContext::setShareContext()`, bevor Sie ` QOpenGLContext::create()` aufrufen. Der resultierende Kontext kann auch in einem anderen Thread verwendet werden, was die Thread-basierte Erzeugung von Texturen und asynchrone Textur-Uploads ermöglicht.

Beachten Sie, dass QOpenGLWidget eine standardkonforme Implementierung der Ressourcenfreigabe seitens der zugrunde liegenden Grafiktreiber erwartet. Beispielsweise haben einige Treiber, insbesondere für mobile und eingebettete Hardware, Probleme bei der Einrichtung der Freigabe zwischen einem bestehenden Kontext und anderen, die später erstellt werden. Andere Treiber verhalten sich möglicherweise unerwartet, wenn versucht wird, gemeinsam genutzte Ressourcen zwischen verschiedenen Threads zu nutzen.

Initialisierung und Bereinigung von Ressourcen

Der mit dem QOpenGLWidget verbundene OpenGL-Kontext ist garantiert aktuell, sobald „ initializeGL()“ und „ paintGL()“ aufgerufen werden. Versuchen Sie nicht, OpenGL-Ressourcen zu erstellen, bevor „ initializeGL()“ aufgerufen wurde. So schlägt beispielsweise der Versuch, Shader zu kompilieren, Vertex-Buffer-Objekte zu initialisieren oder Texturdaten hochzuladen, fehl, wenn dies im Konstruktor einer Unterklasse erfolgt. Diese Operationen müssen auf ` initializeGL()` verschoben werden. Einige der Qt OpenGL-Hilfsklassen, wie ` QOpenGLBuffer ` oder ` QOpenGLVertexArrayObject`, weisen ein entsprechendes verzögertes Verhalten auf: Sie können ohne Kontext instanziiert werden, doch die gesamte Initialisierung wird bis zum Aufruf von ` create()` oder einer ähnlichen Funktion verschoben. Das bedeutet, dass sie als normale (nicht auf Zeiger verweisende) Membervariablen in einer Unterklasse von `QOpenGLWidget` verwendet werden können, die Funktion ` create()` oder eine ähnliche Funktion jedoch nur von ` initializeGL()` aus aufgerufen werden kann. Beachten Sie jedoch, dass nicht alle Klassen auf diese Weise konzipiert sind. Im Zweifelsfall sollten Sie die Membervariable als Zeiger definieren und die Instanz dynamisch in ` initializeGL()` bzw. im Destruktor anlegen und löschen.

Um die Ressourcen freizugeben, muss zudem der Kontext aktuell sein. Daher wird erwartet, dass Destruktoren, die eine solche Bereinigung durchführen, zunächst ` makeCurrent()` aufrufen, bevor sie mit der Zerstörung von OpenGL-Ressourcen oder Wrappern fortfahren. Vermeiden Sie eine verzögerte Löschung über ` deleteLater()` oder den Eltern-Kind-Mechanismus von ` QObject`. Es gibt keine Garantie dafür, dass der richtige Kontext zum Zeitpunkt der tatsächlichen Zerstörung der betreffenden Instanz aktuell ist.

Eine typische Unterklasse sieht daher hinsichtlich der Initialisierung und Löschung von Ressourcen oft wie folgt aus:

class MyGLWidget : public QOpenGLWidget
{
    ...

private:
    QOpenGLVertexArrayObject m_vao;
    QOpenGLBuffer m_vbo;
    QOpenGLShaderProgram *m_program;
    QOpenGLShader *m_shader;
    QOpenGLTexture *m_texture;
};

MyGLWidget::MyGLWidget()
    : m_program(0), m_shader(0), m_texture(0)
{
    // No OpenGL resource initialization is done here.
}

MyGLWidget::~MyGLWidget()
{
    // Make sure the context is current and then explicitly
    // destroy all underlying OpenGL resources.
    makeCurrent();

    delete m_texture;
    delete m_shader;
    delete m_program;

    m_vbo.destroy();
    m_vao.destroy();

    doneCurrent();
}

void MyGLWidget::initializeGL()
{
    m_vao.create();
    if (m_vao.isCreated())
        m_vao.bind();

    m_vbo.create();
    m_vbo.bind();
    m_vbo.allocate(...);

    m_texture = new QOpenGLTexture(QImage(...));

    m_shader = new QOpenGLShader(...);
    m_program = new QOpenGLShaderProgram(...);

    ...
}

Dies funktioniert in den meisten Fällen, ist jedoch als generische Lösung nicht ganz ideal. Wenn das Widget einem neuen übergeordneten Element zugeordnet wird, sodass es in einem völlig anderen Fenster der obersten Ebene landet, ist eine zusätzliche Maßnahme erforderlich: Durch die Anbindung an das Signal „ aboutToBeDestroyed()“ von ` QOpenGLContext` kann die Bereinigung immer dann durchgeführt werden, wenn der OpenGL-Kontext freigegeben werden soll.

MyGLWidget::~MyGLWidget()
{
    cleanup();
}

void MyGLWidget::initializeGL()
{
    ...
    connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &MyGLWidget::cleanup);
}

void MyGLWidget::cleanup()
{
    makeCurrent();
    delete m_texture;
    m_texture = 0;
    ...
    doneCurrent();
    disconnect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &MyGLWidget::cleanup);
}

Eine ordnungsgemäße Bereinigung ist aufgrund der gemeinsamen Nutzung von Kontexten besonders wichtig. Auch wenn der mit jedem `QOpenGLWidget` verknüpfte Kontext zusammen mit dem `QOpenGLWidget` zerstört wird, bleiben die gemeinsam nutzbaren Ressourcen in diesem Kontext, wie z. B. Texturen, so lange gültig, bis das oberste Fenster, in dem sich das `QOpenGLWidget` befand, zerstört wird. Zudem können Einstellungen wie „ Qt::AA_ShareOpenGLContexts “ und einige Qt-Module einen noch größeren Umfang für die gemeinsame Nutzung von Kontexten auslösen, was möglicherweise dazu führt, dass die betreffenden Ressourcen während der gesamten Laufzeit der Anwendung erhalten bleiben. Daher ist es am sichersten und zuverlässigsten, stets eine explizite Bereinigung aller im QOpenGLWidget verwendeten Ressourcen und Ressourcen-Wrapper durchzuführen.

Einschränkungen und weitere Überlegungen

Das Platzieren anderer Widgets darunter und das transparent Machen des QOpenGLWidgets führt nicht zu den erwarteten Ergebnissen: Die darunter liegenden Widgets sind nicht sichtbar. Dies liegt daran, dass das QOpenGLWidget in der Praxis vor allen anderen regulären, nicht-OpenGL-basierten Widgets gezeichnet wird, sodass durchsichtige Lösungen nicht realisierbar sind. Andere Layout-Varianten, wie beispielsweise Widgets, die über dem QOpenGLWidget liegen, funktionieren wie erwartet.

Wenn es unbedingt erforderlich ist, lässt sich diese Einschränkung durch Setzen des Attributs „ Qt::WA_AlwaysStackOnTop “ am QOpenGLWidget umgehen. Beachten Sie jedoch, dass dies die Stapelreihenfolge aufhebt; so ist es beispielsweise nicht mehr möglich, andere Widgets über dem QOpenGLWidget anzuordnen. Daher sollte diese Option nur in Situationen verwendet werden, in denen ein halbtransparentes QOpenGLWidget erforderlich ist, unter dem andere Widgets sichtbar sind.

Beachten Sie, dass dies nicht gilt, wenn sich keine anderen Widgets darunter befinden und ein halbtransparentes Fenster gewünscht ist. In diesem Fall reicht der herkömmliche Ansatz aus, bei dem „ Qt::WA_TranslucentBackground “ für das oberste Fenster gesetzt wird. Beachten Sie, dass, wenn die transparenten Bereiche nur im `QOpenGLWidget` gewünscht sind, ` Qt::WA_NoSystemBackground ` nach dem Aktivieren von ` Qt::WA_TranslucentBackground` wieder auf ` false ` zurückgesetzt werden muss. Zusätzlich kann es je nach System erforderlich sein, über ` setFormat()` einen Alphakanal für den Kontext des `QOpenGLWidget` anzufordern.

QOpenGLWidget unterstützt mehrere Aktualisierungsmodi, genau wie QOpenGLWindow. Im „preserved“-Modus stehen die gerenderten Inhalte des vorherigen Aufrufs von paintGL() im nächsten Aufruf zur Verfügung, was ein inkrementelles Rendern ermöglicht. Im „non-preserved“-Modus gehen die Inhalte verloren, und von den Implementierungen von paintGL() wird erwartet, dass sie die gesamte Ansicht neu zeichnen.

Vor Qt 5.5 bestand das Standardverhalten von `QOpenGLWidget` darin, die gerenderten Inhalte zwischen den Aufrufen von ` paintGL()` beizubehalten. Seit Qt 5.5 ist das Standardverhalten der „Non-Preserved“-Modus, da dies eine bessere Leistung bietet und die meisten Anwendungen keinen Bedarf an den vorherigen Inhalten haben. Dies entspricht zudem der Semantik eines OpenGL-basierten „ QWindow “ und stimmt mit dem Standardverhalten von „ QOpenGLWindow “ überein, da die Farb- und Zusatzpuffer bei jedem Frame ungültig gemacht werden. Um das Verhalten mit Beibehaltung der Inhalte wiederherzustellen, rufen Sie „ setUpdateBehavior()“ mit „ PartialUpdate “ auf.

Sobald ein QOpenGLWidget zu einer Widget-Hierarchie hinzugefügt wird, wird der Inhalt des Top-Level-Fensters über OpenGL-basiertes Rendering ausgegeben. Andere Widgets als das QOpenGLWidget zeichnen ihren Inhalt weiterhin mit einem softwarebasierten Painter, doch die endgültige Komposition erfolgt über die 3D-API.

Alternativen

Das Hinzufügen eines QOpenGLWidget zu einem Fenster aktiviert das OpenGL-basierte Compositing für das gesamte Fenster. In einigen Sonderfällen ist dies möglicherweise nicht ideal, und das alte Verhalten im Stil von QGLWidget mit einem separaten, nativen untergeordneten Fenster ist wünschenswert. Desktop-Anwendungen, die die Einschränkungen dieses Ansatzes kennen (beispielsweise in Bezug auf Überlappungen, Transparenz, Scroll-Ansichten und MDI-Bereiche), können ` QOpenGLWindow ` in Verbindung mit ` QWidget::createWindowContainer()` verwenden. Dies ist eine moderne Alternative zu `QGLWidget` und aufgrund des Wegfalls des zusätzlichen Compositing-Schritts schneller als `QOpenGLWidget`. Es wird dringend empfohlen, die Verwendung dieses Ansatzes auf Fälle zu beschränken, in denen es keine andere Wahl gibt. Beachten Sie, dass diese Option für die meisten eingebetteten und mobilen Plattformen nicht geeignet ist und auch auf bestimmten Desktop-Plattformen (z. B. macOS) bekanntermaßen Probleme verursacht. Die stabile, plattformübergreifende Lösung ist immer QOpenGLWidget.

Stereoskopisches Rendering

Ab Version 6.5 unterstützt QOpenGLWidget das stereoskopische Rendering. Um es zu aktivieren, setzen Sie das Flag „ QSurfaceFormat::StereoBuffers “ global vor der Erstellung des Fensters mithilfe von `QSurfaceFormat::SetDefaultFormat()`.

Dadurch wird „ paintGL()“ in jedem Frame zweimal aufgerufen, einmal für jeden „ QOpenGLWidget::TargetBuffer “. Rufen Sie in „ paintGL()“ die Funktion „ currentTargetBuffer()“ auf, um abzufragen, in welchen Puffer gerade gezeichnet wird.

OpenGL ist eine Marke von Silicon Graphics, Inc. in den Vereinigten Staaten und anderen Ländern.