QOpenGLWidget Class

Detaillierte Beschreibung

QOpenGLWidget bietet Funktionalität zur Anzeige von OpenGL-Grafiken, die in eine Qt-Anwendung integriert sind. Es ist sehr einfach zu benutzen: Erben Sie Ihre Klasse davon und verwenden Sie die Unterklasse wie jede andere QWidget, mit der Ausnahme, dass Sie die Wahl zwischen der Verwendung von QPainter und Standard-OpenGL-Rendering-Befehlen haben.

QOpenGLWidget bietet drei bequeme virtuelle Funktionen, die Sie in Ihrer Unterklasse reimplementieren 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 das OpenGL-Ansichtsfenster, die Projektion, usw. ein. Wird aufgerufen, wenn die Größe des Widgets geändert wurde (und auch, wenn es zum ersten Mal angezeigt wird, da alle neu erstellten Widgets automatisch ein Größenänderungsereignis erhalten).
• initializeGL() - Richtet die OpenGL-Ressourcen und den Status ein. Wird einmal aufgerufen, bevor resizeGL() oder paintGL() zum ersten Mal aufgerufen wird.

Wenn Sie eine Neuzeichnung von anderen Stellen als 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 aktuell gemacht, wenn paintGL(), resizeGL() oder initializeGL() aufgerufen wird. Wenn Sie die Standard-OpenGL-API-Funktionen von anderen Stellen aus aufrufen müssen (z. B. im Konstruktor Ihres Widgets oder in Ihren eigenen Malfunktionen), müssen Sie zuerst makeCurrent() aufrufen.

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

QOpenGLWidget erlaubt die Verwendung verschiedener OpenGL-Versionen und Profile, wenn die Plattform dies unterstützt. Setzen Sie einfach das gewünschte Format über setFormat(). Beachten Sie jedoch, dass mehrere QOpenGLWidget Instanzen im gleichen Fenster erfordern, dass sie alle das gleiche Format verwenden, oder zumindest Formate, die die Kontexte nicht nicht-zerlegbar machen. Um dieses Problem zu umgehen, verwenden Sie lieber QSurfaceFormat::setDefaultFormat() als setFormat().

Maltechniken

Wie oben beschrieben, können Sie die Unterklasse QOpenGLWidget zum Rendern reiner 3D-Inhalte auf folgende Weise verwenden:

• Reimplementieren Sie die Funktionen initializeGL() und resizeGL(), um den OpenGL-Status einzurichten und eine perspektivische Transformation bereitzustellen.
• Reimplementieren Sie paintGL(), um die 3D-Szene zu zeichnen, wobei nur OpenGL-Funktionen aufgerufen werden.

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

• In paintGL(), anstatt OpenGL-Befehle auszugeben, konstruieren Sie ein QPainter Objekt zur Verwendung auf dem Widget.
• Zeichnen Sie Primitive mit den Memberfunktionen von QPainter.
• Direkte OpenGL-Befehle können weiterhin ausgegeben werden. Sie müssen jedoch sicherstellen, dass diese von einem Aufruf der beginNativePainting() und endNativePainting() des Painters eingeschlossen sind.

Wenn das Zeichnen nur mit QPainter durchgeführt wird, ist es auch möglich, das Malen wie bei normalen Widgets durchzuführen: durch Neuimplementierung von paintEvent().

• Reimplementieren Sie die Funktion paintEvent().
• Konstruieren 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 mit den Funktionen von QPainter.
• Nach Beendigung des Zeichnens wird die Instanz QPainter zerstört. Alternativ können Sie auch QPainter::end() explizit aufrufen.

OpenGL Funktionsaufrufe, Header und QOpenGLFunctions

Wenn Sie OpenGL-Funktionen aufrufen, wird dringend empfohlen, den direkten Aufruf der Funktionen zu vermeiden. Verwenden Sie stattdessen lieber QOpenGLFunctions (wenn Sie portable Anwendungen erstellen) oder die versionierten Varianten (z.B. QOpenGLFunctions_3_2_Core und ähnliche, wenn Sie auf modernes, reines Desktop-OpenGL abzielen). Auf diese Weise wird die Anwendung in allen Qt-Build-Konfigurationen korrekt funktionieren, einschließlich derjenigen, die ein dynamisches Laden der OpenGL-Implementierung durchführen, was bedeutet, dass Anwendungen nicht direkt mit einer GL-Implementierung verknüpft werden und daher direkte Funktionsaufrufe nicht möglich sind.

In paintGL() ist der aktuelle Kontext immer durch den Aufruf von QOpenGLContext::currentContext() zugänglich. Aus diesem Kontext kann eine bereits initialisierte, gebrauchsfertige QOpenGLFunctions Instanz durch den Aufruf von QOpenGLContext::functions() abgerufen werden. Eine Alternative zum Voranstellen jedes GL-Aufrufs besteht darin, von QOpenGLFunctions zu erben und QOpenGLFunctions::initializeOpenGLFunctions() in initializeGL() aufzurufen.

Was die OpenGL-Header betrifft, so ist zu beachten, dass in den meisten Fällen keine Notwendigkeit besteht, Header wie GL.h direkt einzubinden. Die OpenGL-bezogenen Qt-Header werden qopengl.h einbinden, das wiederum einen geeigneten Header für das System einbinden wird. Dies kann ein OpenGL ES 3.x oder 2.0 Header sein, die höchste verfügbare Version, oder ein vom System bereitgestelltes gl.h. Zusätzlich wird eine Kopie der Erweiterungsheader (auf einigen Systemen glext.h genannt) als Teil von Qt sowohl für OpenGL als auch für OpenGL ES bereitgestellt. Diese werden auf den Plattformen, wo dies möglich ist, automatisch eingebunden. Das bedeutet, dass Konstanten und Funktionszeiger-Typendefinitionen von ARB-, EXT- und OES-Erweiterungen automatisch verfügbar sind.

Code-Beispiele

Für den Anfang könnte die einfachste QOpenGLWidget Unterklasse 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 kann die Präfixierung jedes einzelnen OpenGL-Aufrufs vermieden werden, 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 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

In OpenGL 3.0+ Kontexten, wenn Portabilität nicht wichtig ist, bieten die versionierten QOpenGLFunctions Varianten einfachen Zugang zu allen 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 angeforderte Format global zu setzen, so dass es für alle Fenster und Kontexte während der Lebensdauer der Anwendung gilt. Nachfolgend ein Beispiel dafü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, setzen Sie die Anzahl der angeforderten Samples auf der QSurfaceFormat, die an setFormat() übergeben wird. Auf Systemen, die dies nicht unterstützen, kann die Anforderung ignoriert werden.

Multisampling-Unterstützung erfordert Unterstützung für Renderbuffer und Framebuffer-Blits mit mehreren Abtastungen. Auf OpenGL ES 2.0 Implementierungen ist es wahrscheinlich, dass diese nicht vorhanden sind. Dies bedeutet, dass Multisampling nicht verfügbar ist. Mit modernen OpenGL-Versionen und OpenGL ES 3.0 und höher ist dies normalerweise kein Problem mehr.

Threading

Das Durchführen von Offscreen-Rendering auf Worker-Threads, zum Beispiel um Texturen zu generieren, die dann im GUI/Haupt-Thread in paintGL() verwendet werden, wird unterstützt, indem die QOpenGLContext des Widgets offengelegt wird, so dass zusätzliche Kontexte, die sich mit ihm teilen, auf jedem Thread erstellt werden können.

Direktes Zeichnen auf den Framebuffer des QOpenGLWidgets außerhalb des GUI/Hauptthreads ist möglich, indem paintEvent() neu implementiert wird, um nichts zu tun. Die Thread-Affinität des Kontexts muss über QObject::moveToThread() geändert werden. Danach sind makeCurrent() und doneCurrent() auf dem Worker-Thread verwendbar. Achten Sie darauf, den Kontext anschließend wieder in den GUI/Hauptthread zu verschieben.

Das Auslösen eines Buffer Swaps nur für das QOpenGLWidget ist nicht möglich, da es keine echte, native Oberfläche auf dem Bildschirm dafür gibt. Es ist Aufgabe des Widget-Stacks, die Komposition und den Pufferwechsel im GUI-Thread zu verwalten. Wenn ein Thread mit der Aktualisierung des Framebuffers fertig ist, rufen Sie update() auf dem GUI/Haupt-Thread auf, um die Komposition zu planen.

Es muss besonders darauf geachtet werden, dass der Framebuffer nicht verwendet wird, wenn der GUI/Haupt-Thread das Compositing durchführt. Die Signale aboutToCompose() und frameSwapped() werden ausgegeben, wenn die Komposition beginnt und endet. Sie werden auf dem GUI/Haupt-Thread ausgegeben. Das bedeutet, dass aboutToCompose() durch die Verwendung einer direkten Verbindung den GUI/Haupt-Thread blockieren kann, bis der Worker-Thread sein Rendering beendet hat. Danach darf der Worker-Thread kein weiteres Rendering durchführen, bis das Signal frameSwapped() ausgegeben wird. Wenn dies nicht akzeptabel ist, muss der Worker-Thread einen doppelten Pufferungsmechanismus implementieren. Dies beinhaltet das Zeichnen unter Verwendung eines alternativen Rendering-Ziels, das vollständig durch den Thread kontrolliert wird, z.B. ein zusätzliches Framebuffer-Objekt, und das Blitten auf den Framebuffer des QOpenGLWidget zu einem geeigneten Zeitpunkt.

Gemeinsame Nutzung des Kontextes

Wenn mehrere QOpenGLWidgets als Kinder des gleichen Top-Level-Widgets hinzugefügt werden, teilen sich ihre Kontexte gegenseitig. Dies gilt nicht für QOpenGLWidget Instanzen, die zu verschiedenen 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 es besteht keine Notwendigkeit für einen extra "globalen Freigabe"-Kontext.

Um die gemeinsame Nutzung zwischen QOpenGLWidget Instanzen, die zu verschiedenen Fenstern gehören, einzurichten, setzen Sie das Qt::AA_ShareOpenGLContexts application Attribut bevor Sie QApplication instanzieren. Dies wird die Freigabe zwischen allen QOpenGLWidget Instanzen ohne weitere Schritte auslösen.

Das Erstellen von zusätzlichen QOpenGLContext Instanzen, die Ressourcen wie Texturen mit dem QOpenGLWidget Kontext teilen, ist ebenfalls möglich. Übergeben Sie 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 eine threaded Erzeugung von Texturen und asynchrone Textur-Uploads ermöglicht.

Beachten Sie, dass QOpenGLWidget eine standardkonforme Implementierung der gemeinsamen Nutzung von Ressourcen erwartet, wenn es um die zugrundeliegenden Grafiktreiber geht. Zum Beispiel haben einige Treiber, insbesondere für mobile und eingebettete Hardware, Probleme mit der Einrichtung der gemeinsamen Nutzung zwischen einem bestehenden Kontext und anderen, die später erstellt werden. Einige andere Treiber verhalten sich möglicherweise auf unerwartete Weise, wenn sie versuchen, gemeinsam genutzte Ressourcen zwischen verschiedenen Threads zu nutzen.

Initialisierung und Bereinigung von Ressourcen

Der zugehörige OpenGL-Kontext von QOpenGLWidget ist garantiert aktuell, wenn initializeGL() und paintGL() aufgerufen werden. Versuchen Sie nicht, OpenGL-Ressourcen zu erstellen, bevor initializeGL() aufgerufen wird. Zum Beispiel wird der Versuch, Shader zu kompilieren, Vertexpufferobjekte zu initialisieren oder Texturdaten hochzuladen, fehlschlagen, wenn dies im Konstruktor einer Unterklasse geschieht. Diese Operationen müssen auf initializeGL() verschoben werden. Einige der Qt OpenGL Hilfsklassen, wie QOpenGLBuffer oder QOpenGLVertexArrayObject, haben ein passendes aufgeschobenes Verhalten: sie können ohne Kontext instanziiert werden, aber alle Initialisierungen werden bis zu einem create() oder einem ähnlichen Aufruf aufgeschoben. Das bedeutet, dass sie als normale (Nicht-Pointer) Mitgliedsvariablen in einer QOpenGLWidget Unterklasse verwendet werden können, aber die create() oder ähnliche Funktion kann nur von initializeGL() aufgerufen werden. Seien Sie sich jedoch bewusst, dass nicht alle Klassen so gestaltet sind. Im Zweifelsfall machen Sie die Mitgliedsvariable zu einem Zeiger und erzeugen und zerstören die Instanz dynamisch in initializeGL() bzw. dem Destruktor.

Bei der Freigabe der Ressourcen muss auch der Kontext aktuell sein. Daher wird von Destruktoren, die solche Aufräumarbeiten durchführen, erwartet, dass sie makeCurrent() aufrufen, bevor sie mit der Zerstörung von OpenGL-Ressourcen oder Wrappern fortfahren. Vermeiden Sie aufgeschobenes Löschen über deleteLater() oder den Parenting-Mechanismus von QObject. Es gibt keine Garantie, dass der richtige Kontext zum Zeitpunkt der tatsächlichen Zerstörung der fraglichen Instanz aktuell ist.

Eine typische Unterklasse wird daher oft wie folgt aussehen, wenn es um die Initialisierung und Zerstörung von Ressourcen geht:

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 aber als generische Lösung nicht ganz ideal. Wenn das Widget reparented wird, so dass es in einem völlig anderen Top-Level-Fenster landet, wird etwas mehr benötigt: Durch die Verbindung mit dem aboutToBeDestroyed()-Signal von QOpenGLContext kann die Bereinigung immer dann durchgeführt werden, wenn der OpenGL-Kontext im Begriff ist, freigegeben zu werden.

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);
}

Korrektes Aufräumen ist wegen der gemeinsamen Nutzung von Kontexten besonders wichtig. Auch wenn der zugehörige QOpenGLWidget-Kontext zusammen mit dem QOpenGLWidget zerstört wird, bleiben die gemeinsam nutzbaren Ressourcen in diesem Kontext, wie z.B. Texturen, gültig, bis das Top-Level-Fenster, in dem das QOpenGLWidget lebte, zerstört wird. Zusätzlich können Einstellungen wie Qt::AA_ShareOpenGLContexts und einige Qt-Module einen noch größeren Bereich für die gemeinsame Nutzung von Kontexten auslösen, was dazu führen kann, dass die fraglichen Ressourcen für die gesamte Lebensdauer der Anwendung am Leben bleiben. Daher ist es am sichersten und robustesten, immer eine explizite Bereinigung für alle Ressourcen und Ressourcen-Wrapper durchzuführen, die im QOpenGLWidget verwendet werden.

Beschränkungen und andere Überlegungen

Andere Widgets darunter zu platzieren und das QOpenGLWidget transparent zu machen wird nicht zu den erwarteten Ergebnissen führen: Die Widgets darunter werden nicht sichtbar sein. Das liegt daran, dass in der Praxis das QOpenGLWidget vor allen anderen regulären, nicht-OpenGL Widgets gezeichnet wird, und daher sind durchsichtige Lösungen nicht möglich. Andere Arten von Layouts, wie z.B. Widgets über dem QOpenGLWidget, werden wie erwartet funktionieren.

Wenn es unbedingt notwendig ist, kann diese Einschränkung durch das Setzen des Qt::WA_AlwaysStackOnTop Attributs auf dem QOpenGLWidget überwunden werden. Seien Sie sich jedoch bewusst, dass dies die Stapelreihenfolge unterbricht, z.B. wird es nicht möglich sein, andere Widgets über dem QOpenGLWidget zu haben, so dass es nur in Situationen verwendet werden sollte, in denen ein halbtransparentes QOpenGLWidget mit anderen Widgets sichtbar darunter erforderlich ist.

Beachten Sie, dass dies nicht gilt, wenn es keine anderen Widgets darunter gibt und die Absicht ist, ein halbtransparentes Fenster zu haben. In diesem Fall ist der traditionelle Ansatz, Qt::WA_TranslucentBackground für das oberste Fenster zu setzen, ausreichend. Beachten Sie, dass wenn die transparenten Bereiche nur im QOpenGLWidget erwünscht sind, dann muss Qt::WA_NoSystemBackground nach der Aktivierung von Qt::WA_TranslucentBackground wieder auf false zurückgesetzt werden. Zusätzlich kann es, abhängig vom System, notwendig sein, einen Alphakanal für den QOpenGLWidget-Kontext über setFormat() anzufordern.

QOpenGLWidget unterstützt mehrere Update-Verhaltensweisen, genau wie QOpenGLWindow. Im konservierten Modus ist der gerenderte Inhalt des vorherigen paintGL()-Aufrufs im nächsten verfügbar, was inkrementelles Rendering ermöglicht. Im nicht-erhaltenen Modus geht der Inhalt verloren und von paintGL()-Implementierungen wird erwartet, dass sie alles in der Ansicht neu zeichnen.

Vor Qt 5.5 war das Standardverhalten von QOpenGLWidget, den gerenderten Inhalt zwischen paintGL() Aufrufen zu erhalten. Seit Qt 5.5 ist das Standardverhalten nicht-erhaltend, da dies eine bessere Leistung bietet und die Mehrheit der Anwendungen keinen Bedarf für den vorherigen Inhalt haben. Dies ähnelt auch der Semantik einer OpenGL-basierten QWindow und entspricht dem Standardverhalten von QOpenGLWindow, da die Farb- und Hilfspuffer für jedes Bild ungültig gemacht werden. Um das erhaltene Verhalten wiederherzustellen, rufen Sie setUpdateBehavior() mit PartialUpdate auf.

Sobald ein QOpenGLWidget zu einer Widget-Hierarchie hinzugefügt wird, wird der Inhalt des Fensters der obersten Ebene über OpenGL-basiertes Rendering gespült. Andere Widgets als das QOpenGLWidget zeichnen ihren Inhalt weiterhin mit einem softwarebasierten Painter, aber die endgültige Zusammensetzung erfolgt über die 3D-API.

Alternativen

Das Hinzufügen eines QOpenGLWidgets in ein Fenster schaltet OpenGL-basiertes Compositing für das gesamte Fenster ein. In einigen speziellen Fällen kann dies nicht ideal sein, und das alte QGLWidget-artige Verhalten mit einem separaten, nativen Kindfenster ist erwünscht. Desktop-Anwendungen, die die Grenzen dieses Ansatzes kennen (z. B. in Bezug auf Überlappungen, Transparenz, Scroll-Ansichten und MDI-Bereiche), können QOpenGLWindow mit QWidget::createWindowContainer() verwenden. Dies ist eine moderne Alternative zu QGLWidget und ist schneller als QOpenGLWidget, da der zusätzliche Kompositionsschritt entfällt. 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) Probleme auftreten können. Die stabile, plattformübergreifende Lösung ist immer QOpenGLWidget.

Stereoskopisches Rendering

Ab Version 6.5 bietet QOpenGLWidget Unterstützung für stereoskopisches Rendering. Um es zu aktivieren, setzen Sie das QSurfaceFormat::StereoBuffers Flag global, bevor das Fenster erstellt wird, mit QSurfaceFormat::SetDefaultFormat().

Dies wird dazu führen, dass paintGL() zweimal pro Frame aufgerufen wird, einmal für jedes QOpenGLWidget::TargetBuffer. Rufen Sie in paintGL() currentTargetBuffer() auf, um abzufragen, welches Bild gerade gezeichnet wird.

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