qt 6.5.1 original

tests/manual/qopenglwidget/openglwidget/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+#####################################################################
+## openglwidget Binary:
+#####################################################################
+
+qt_internal_add_manual_test(openglwidget
+    GUI
+    SOURCES
+        main.cpp
+        openglwidget.cpp openglwidget.h
+    LIBRARIES
+        Qt::CorePrivate
+        Qt::Gui
+        Qt::GuiPrivate
+        Qt::OpenGL
+        Qt::OpenGLWidgets
+        Qt::Widgets
+        Qt::WidgetsPrivate
+)

tests/manual/qopenglwidget/openglwidget/main.cpp

@@ -0,0 +1,210 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "openglwidget.h"
+#include <QApplication>
+#include <QPushButton>
+#include <QMdiArea>
+#include <QMdiSubWindow>
+#include <QMenu>
+#include <QMenuBar>
+#include <QMainWindow>
+#include <QLCDNumber>
+#include <QScrollArea>
+#include <QScrollBar>
+#include <QTabWidget>
+#include <QLabel>
+#include <QTimer>
+#include <QSurfaceFormat>
+#include <QDebug>
+#include <private/qwindow_p.h>
+
+class Tools : public QObject
+{
+    Q_OBJECT
+
+public:
+    Tools(QWidget *root, QWidget *widgetToTurn, const QWidgetList &glwidgets)
+        : m_root(root), m_widgetToTurn(widgetToTurn), m_glWidgets(glwidgets) { }
+    void dump();
+
+private slots:
+    void turnNative();
+    void hideShowAllGL();
+    void dumpCompositingStatus();
+
+signals:
+    void aboutToShowGLWidgets();
+
+private:
+    void dumpWidget(QWidget *w, int indent = 0);
+
+    QWidget *m_root;
+    QWidget *m_widgetToTurn;
+    QWidgetList m_glWidgets;
+};
+
+void Tools::turnNative()
+{
+    qDebug("Turning into native");
+    m_widgetToTurn->winId();
+    dump();
+}
+
+void Tools::hideShowAllGL()
+{
+    if (m_glWidgets[0]->isVisible()) {
+        qDebug("Hiding all render-to-texture widgets");
+        foreach (QWidget *w, m_glWidgets)
+            w->hide();
+    } else {
+        qDebug("Showing all render-to-texture widgets");
+        emit aboutToShowGLWidgets();
+        foreach (QWidget *w, m_glWidgets)
+            w->show();
+    }
+}
+
+void Tools::dump()
+{
+    qDebug() << "Widget hierarchy";
+    dumpWidget(m_root);
+    qDebug() << "========";
+}
+
+void Tools::dumpWidget(QWidget *w, int indent)
+{
+    QString indentStr;
+    indentStr.fill(' ', indent);
+    qDebug().noquote() << indentStr << w << "winId =" << w->internalWinId();
+    foreach (QObject *obj, w->children()) {
+        if (QWidget *cw = qobject_cast<QWidget *>(obj))
+            dumpWidget(cw, indent + 4);
+    }
+}
+
+void Tools::dumpCompositingStatus()
+{
+    QWindow *w = m_root->window()->windowHandle();
+    qDebug() << "Compositing status for" << w << m_root->window() << "is" << QWindowPrivate::get(w)->compositing;
+}
+
+class TabWidgetResetter : public QObject
+{
+    Q_OBJECT
+public:
+    TabWidgetResetter(QTabWidget *tw) : m_tw(tw) { }
+public slots:
+    void reset() { m_tw->setCurrentIndex(0); }
+private:
+    QTabWidget *m_tw;
+};
+
+int main(int argc, char *argv[])
+{
+    if (argc > 1 && !strcmp(argv[1], "--sharecontext")) {
+        qDebug("Requesting all contexts to share");
+        QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
+    }
+
+    QApplication a(argc, argv);
+
+    QSurfaceFormat format;
+    if (QCoreApplication::arguments().contains(QLatin1String("--multisample")))
+        format.setSamples(4);
+    if (QCoreApplication::arguments().contains(QLatin1String("--coreprofile"))) {
+        format.setVersion(3, 2);
+        format.setProfile(QSurfaceFormat::CoreProfile);
+    }
+    qDebug() << "Requesting" << format;
+
+    QMainWindow wnd;
+    wnd.setObjectName("Main Window");
+    wnd.resize(1024, 768);
+
+    QMdiArea *w = new QMdiArea;
+    w->setObjectName("MDI area");
+    w->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+    wnd.setCentralWidget(w);
+
+    OpenGLWidget *glw = new OpenGLWidget(33, QVector3D(0, 0, 1));
+    glw->setObjectName("First GL Widget with 33 ms timer");
+    glw->setFormat(format);
+    glw->setMinimumSize(100, 100);
+    QMdiSubWindow *sw = w->addSubWindow(glw);
+    sw->setObjectName("First MDI Sub-Window");
+    sw->setWindowTitle("33 ms timer");
+
+    OpenGLWidget *glw2 = new OpenGLWidget(16);
+    glw2->setObjectName("Second GL Widget with 16 ms timer");
+    glw2->setFormat(format);
+    glw2->setMinimumSize(100, 100);
+    QOpenGLWidget *glw22 = new OpenGLWidget(16);
+    glw22->setObjectName("Second #2 GLWidget");
+    glw22->setParent(glw2);
+    glw22->resize(40, 40);
+    sw = w->addSubWindow(glw2);
+    sw->setObjectName("Second MDI Sub-Window");
+    sw->setWindowTitle("16 ms timer");
+
+    OpenGLWidget *glw3 = new OpenGLWidget(0); // trigger updates continuously, no timer
+    glw3->setObjectName("GL widget in scroll area (possibly native)");
+    glw3->setFormat(format);
+    glw3->setFixedSize(600, 600);
+    OpenGLWidget *glw3child = new OpenGLWidget(0);
+    const float glw3ClearColor[] = { 0.5f, 0.2f, 0.8f };
+    glw3child->setClearColor(glw3ClearColor);
+    glw3child->setObjectName("Child widget of GL Widget in scroll area");
+    glw3child->setFormat(format);
+    glw3child->setParent(glw3);
+    glw3child->setGeometry(500, 500, 100, 100); // lower right corner of parent
+    QScrollArea *sa = new QScrollArea;
+    sa->setWidget(glw3);
+    sa->setMinimumSize(100, 100);
+    sa->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+    sw = w->addSubWindow(sa);
+    sw->setObjectName("MDI Sub-Window for scroll area");
+    sw->setWindowTitle("Cont. update");
+    sw->resize(300, 300);
+    sa->verticalScrollBar()->setValue(300);
+
+    QLCDNumber *lcd = new QLCDNumber;
+    lcd->display(1337);
+    lcd->setMinimumSize(300, 100);
+    sw = w->addSubWindow(lcd);
+    sw->setObjectName("MDI Sub-Window for LCD widget");
+    sw->setWindowTitle("Ordinary widget");
+
+    QTabWidget *tw = new QTabWidget;
+    QOpenGLWidget *glw4 = new OpenGLWidget(16, QVector3D(1, 0, 0));
+    glw4->setObjectName("GL widget in tab widget");
+    tw->addTab(glw4, "OpenGL");
+    QLabel *label = new QLabel("Another tab");
+    tw->addTab(label, "Not OpenGL");
+    tw->setMinimumSize(100, 100);
+    sw = w->addSubWindow(tw);
+    sw->setObjectName("MDI Sub-Window for tab widget");
+    sw->setWindowTitle("Tabs");
+
+    TabWidgetResetter twr(tw);
+    Tools t(&wnd, glw3, QWidgetList { glw, glw2, glw3, glw4 });
+    QObject::connect(&t, SIGNAL(aboutToShowGLWidgets()), &twr, SLOT(reset()));
+    QMenu *toolsMenu = wnd.menuBar()->addMenu("&Tools");
+    toolsMenu->addAction("&Turn widgets (or some parent) into native", &t, SLOT(turnNative()));
+    toolsMenu->addAction("&Hide/show all OpenGL widgets", &t, SLOT(hideShowAllGL()));
+
+    QTimer compStatusDumpTimer;
+    QObject::connect(&compStatusDumpTimer, SIGNAL(timeout()), &t, SLOT(dumpCompositingStatus()));
+    compStatusDumpTimer.start(5000);
+
+    wnd.show();
+
+    if (glw->isValid())
+        qDebug() << "Got" << glw->format();
+
+    t.dump();
+
+    return a.exec();
+}
+
+#include "main.moc"

tests/manual/qopenglwidget/openglwidget/openglwidget.cpp

@@ -0,0 +1,176 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#define GL_GLEXT_PROTOTYPES
+
+#include "openglwidget.h"
+#include <QtWidgets/private/qwidget_p.h>
+#include <QOpenGLFramebufferObject>
+#include <QWindow>
+#include <qpa/qplatformwindow.h>
+#include <QDebug>
+#include <QTimer>
+
+#include <QtGui/QOpenGLFunctions>
+#include <QtGui/QGuiApplication>
+#include <QtGui/QMatrix4x4>
+#include <QOpenGLShaderProgram>
+#include <QtGui/QScreen>
+
+#include <QtCore/qmath.h>
+#include <qopengl.h>
+
+class OpenGLWidgetPrivate : protected QOpenGLFunctions
+{
+public:
+    OpenGLWidgetPrivate(QWidget *q)
+        : m_program(0), m_frame(0), q(q)
+    {
+
+    }
+
+    void initialize();
+    void render();
+
+
+    int width() {return w;}
+    int height() {return h;}
+
+    GLuint m_posAttr;
+    GLuint m_colAttr;
+    GLuint m_matrixUniform;
+
+    QOpenGLShaderProgram *m_program;
+    int m_frame;
+
+    int w,h;
+    QWidget *q;
+
+    int m_interval;
+    QVector3D m_rotAxis;
+
+    float clearColor[3];
+};
+
+
+OpenGLWidget::OpenGLWidget(int interval, const QVector3D &rotAxis, QWidget *parent)
+    : QOpenGLWidget(parent)
+{
+    d.reset(new OpenGLWidgetPrivate(this));
+    d->clearColor[0] = d->clearColor[1] = d->clearColor[2] = 0.0f;
+    d->m_interval = interval;
+    d->m_rotAxis = rotAxis;
+    if (interval > 0) {
+        QTimer *timer = new QTimer(this);
+        connect(timer, SIGNAL(timeout()), this, SLOT(update()));
+        timer->start(interval);
+    }
+}
+
+OpenGLWidget::~OpenGLWidget()
+{
+
+}
+
+void OpenGLWidget::initializeGL()
+{
+//    qDebug("*initializeGL*");
+    d->initialize();
+}
+
+void OpenGLWidget::resizeGL(int w, int h)
+{
+//    qDebug("*resizeGL*");
+    d->w = w;
+    d->h = h;
+}
+void OpenGLWidget::paintGL()
+{
+//    qDebug("*paintGL* %d", d->m_frame);
+    d->render();
+}
+
+
+static const char *vertexShaderSource =
+    "attribute highp vec4 posAttr;\n"
+    "attribute lowp vec4 colAttr;\n"
+    "varying lowp vec4 col;\n"
+    "uniform highp mat4 matrix;\n"
+    "void main() {\n"
+    "   col = colAttr;\n"
+    "   gl_Position = matrix * posAttr;\n"
+    "}\n";
+
+static const char *fragmentShaderSource =
+    "varying lowp vec4 col;\n"
+    "void main() {\n"
+    "   gl_FragColor = col;\n"
+    "}\n";
+
+void OpenGLWidgetPrivate::initialize()
+{
+    initializeOpenGLFunctions();
+    m_program = new QOpenGLShaderProgram;
+    m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource);
+    m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource);
+    m_program->link();
+    m_posAttr = m_program->attributeLocation("posAttr");
+    m_colAttr = m_program->attributeLocation("colAttr");
+    m_matrixUniform = m_program->uniformLocation("matrix");
+}
+
+void OpenGLWidgetPrivate::render()
+{
+    const qreal retinaScale = q->devicePixelRatio();
+    glViewport(0, 0, width() * retinaScale, height() * retinaScale);
+
+    glClearColor(clearColor[0], clearColor[1], clearColor[2], 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    m_program->bind();
+
+    QMatrix4x4 matrix;
+    matrix.perspective(60.0f, 4.0f/3.0f, 0.1f, 100.0f);
+    matrix.translate(0, 0, -2);
+    const qreal angle = 100.0f * m_frame / 30;
+    matrix.rotate(angle, m_rotAxis);
+
+    m_program->setUniformValue(m_matrixUniform, matrix);
+
+    GLfloat vertices[] = {
+        0.0f, 0.707f,
+        -0.5f, -0.5f,
+        0.5f, -0.5f
+    };
+
+    GLfloat colors[] = {
+        1.0f, 0.0f, 0.0f,
+        0.0f, 1.0f, 0.0f,
+        0.0f, 0.0f, 1.0f
+    };
+
+    glVertexAttribPointer(m_posAttr, 2, GL_FLOAT, GL_FALSE, 0, vertices);
+    glVertexAttribPointer(m_colAttr, 3, GL_FLOAT, GL_FALSE, 0, colors);
+
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    glDisableVertexAttribArray(1);
+    glDisableVertexAttribArray(0);
+
+    m_program->release();
+
+    ++m_frame;
+
+    if (m_interval <= 0)
+        q->update();
+}
+
+void OpenGLWidget::setClearColor(const float *c)
+{
+    d->clearColor[0] = c[0];
+    d->clearColor[1] = c[1];
+    d->clearColor[2] = c[2];
+}

tests/manual/qopenglwidget/openglwidget/openglwidget.h

@@ -0,0 +1,28 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef OPENGLWIDGET_H
+#define OPENGLWIDGET_H
+
+#include <QOpenGLWidget>
+#include <QtGui/QVector3D>
+
+class OpenGLWidgetPrivate;
+class OpenGLWidget : public QOpenGLWidget
+{
+    Q_OBJECT
+public:
+    OpenGLWidget(int interval = 30, const QVector3D &rotAxis = QVector3D(0, 1, 0), QWidget *parent = nullptr);
+    ~OpenGLWidget();
+
+    void initializeGL();
+    void resizeGL(int w, int h);
+    void paintGL();
+
+    void setClearColor(const float *c);
+
+private:
+    QScopedPointer<OpenGLWidgetPrivate> d;
+};
+
+#endif // OPENGLWIDGET_H

tests/manual/qopenglwidget/openglwidget/openglwidget.pro

@@ -0,0 +1,9 @@
+QT += widgets widgets-private gui-private core-private
+
+TARGET = openglwidget
+TEMPLATE = app
+
+SOURCES += main.cpp \
+        openglwidget.cpp
+
+HEADERS  += openglwidget.h