Add OpenGL example

.gitignore

@@ -385,5 +385,5 @@ MigrationBackup/
 FodyWeavers.xsd
 / build
 /Settings.ini
-.vscode/settings.json
+.vscode/
 /.settings

examples/CMakeLists.txt

@@ -9,3 +9,4 @@ add_subdirectory(autohide)
 add_subdirectory(autohidedragndrop)
 add_subdirectory(emptydockarea)
 add_subdirectory(dockindock)
+add_subdirectory(openGL)

examples/examples.pro

@@ -5,6 +5,7 @@ SUBDIRS = \
 	autohidedragndrop \
     centralwidget \
 	simple \
+	openGL \
 	hideshow \
 	sidebar \
 	deleteonclose \

examples/openGL/CMakeLists.txt

@@ -0,0 +1,93 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(OpenGLExample VERSION ${VERSION_SHORT})
+
+find_package(
+  QT NAMES Qt6
+  COMPONENTS Core
+             Gui
+             Widgets
+             Charts
+             OpenGLWidgets
+             Quick
+             QuickWidgets
+  REQUIRED)
+find_package(
+  Qt${QT_VERSION_MAJOR}
+  COMPONENTS Core
+             Gui
+             Widgets
+             Charts
+             OpenGLWidgets
+             Quick
+             QuickWidgets
+  REQUIRED)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+add_executable(
+  ${PROJECT_NAME} WIN32
+  main.cpp
+  mainwindow.cpp
+  mainwindow.h
+  glwindow.cpp
+  glwindow.h
+  glwidget.h
+  glwidget.cpp
+  logo.cpp
+  logo.h)
+
+target_include_directories(${PROJECT_NAME}
+                           PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
+target_link_libraries(${PROJECT_NAME}
+                      PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
+
+# Resources:
+set(esource_files "qtlogo.png")
+
+qt_add_resources(${PROJECT_NAME} "OpenGLExample" PREFIX "/" FILES
+                 ${esource_files})
+
+target_link_libraries(
+  ${PROJECT_NAME}
+  PUBLIC Qt${QT_VERSION_MAJOR}::Core
+         Qt${QT_VERSION_MAJOR}::Gui
+         Qt${QT_VERSION_MAJOR}::Widgets
+         Qt${QT_VERSION_MAJOR}::Charts
+         Qt${QT_VERSION_MAJOR}::OpenGLWidgets
+         Qt${QT_VERSION_MAJOR}::Quick
+         Qt${QT_VERSION_MAJOR}::QuickWidgets)
+
+set_target_properties(
+  ${PROJECT_NAME}
+  PROPERTIES AUTOMOC ON
+             AUTORCC ON
+             AUTOUIC ON
+             CXX_STANDARD 14
+             CXX_STANDARD_REQUIRED ON
+             CXX_EXTENSIONS OFF
+             VERSION ${VERSION_SHORT}
+             EXPORT_NAME "Qt Advanced Docking System OpenGL Example"
+             ARCHIVE_OUTPUT_DIRECTORY
+             "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/lib"
+             LIBRARY_OUTPUT_DIRECTORY
+             "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/lib"
+             RUNTIME_OUTPUT_DIRECTORY
+             "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/bin")
+
+# Define include directories
+target_include_directories(
+  ${PROJECT_NAME}
+  PRIVATE $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
+          $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/examples/openGL>
+          $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${INSTALL_NAME}>)
+
+install(
+  TARGETS ${PROJECT_NAME}
+  BUNDLE DESTINATION .
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+qt_generate_deploy_app_script(TARGET ${PROJECT_NAME} OUTPUT_SCRIPT
+                              deploy_script NO_UNSUPPORTED_PLATFORM_ERROR)
+install(SCRIPT ${deploy_script})

examples/openGL/glwidget.cpp

@@ -0,0 +1,261 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include "glwidget.h"
+#include <QMouseEvent>
+#include <QOpenGLShaderProgram>
+#include <QCoreApplication>
+#include <math.h>
+
+bool GLWidget::m_transparent = false;
+
+GLWidget::GLWidget(QWidget *parent)
+    : QOpenGLWidget(parent)
+{
+    m_core = QSurfaceFormat::defaultFormat().profile() == QSurfaceFormat::CoreProfile;
+    // --transparent causes the clear color to be transparent. Therefore, on systems that
+    // support it, the widget will become transparent apart from the logo.
+    if (m_transparent) {
+        QSurfaceFormat fmt = format();
+        fmt.setAlphaBufferSize(8);
+        setFormat(fmt);
+    }
+
+    // Force the display of OpenGL 
+    setAttribute(Qt::WA_AlwaysStackOnTop);
+}
+
+GLWidget::~GLWidget()
+{
+    cleanup();
+}
+
+QSize GLWidget::minimumSizeHint() const
+{
+    return QSize(50, 50);
+}
+
+QSize GLWidget::sizeHint() const
+{
+    return QSize(400, 400);
+}
+
+static void qNormalizeAngle(int &angle)
+{
+    while (angle < 0)
+        angle += 360 * 16;
+    while (angle > 360 * 16)
+        angle -= 360 * 16;
+}
+
+void GLWidget::setXRotation(int angle)
+{
+    qNormalizeAngle(angle);
+    if (angle != m_xRot) {
+        m_xRot = angle;
+        emit xRotationChanged(angle);
+        update();
+    }
+}
+
+void GLWidget::setYRotation(int angle)
+{
+    qNormalizeAngle(angle);
+    if (angle != m_yRot) {
+        m_yRot = angle;
+        emit yRotationChanged(angle);
+        update();
+    }
+}
+
+void GLWidget::setZRotation(int angle)
+{
+    qNormalizeAngle(angle);
+    if (angle != m_zRot) {
+        m_zRot = angle;
+        emit zRotationChanged(angle);
+        update();
+    }
+}
+
+void GLWidget::cleanup()
+{
+    if (m_program == nullptr){
+        return;
+    }
+    makeCurrent();
+    m_logoVbo.destroy();
+    delete m_program;
+    m_program = nullptr;
+    doneCurrent();
+    QObject::disconnect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWidget::cleanup);
+}
+
+static const char *vertexShaderSourceCore =
+    "#version 150\n"
+    "in vec4 vertex;\n"
+    "in vec3 normal;\n"
+    "out vec3 vert;\n"
+    "out vec3 vertNormal;\n"
+    "uniform mat4 projMatrix;\n"
+    "uniform mat4 mvMatrix;\n"
+    "uniform mat3 normalMatrix;\n"
+    "void main() {\n"
+    "   vert = vertex.xyz;\n"
+    "   vertNormal = normalMatrix * normal;\n"
+    "   gl_Position = projMatrix * mvMatrix * vertex;\n"
+    "}\n";
+
+static const char *fragmentShaderSourceCore =
+    "#version 150\n"
+    "in highp vec3 vert;\n"
+    "in highp vec3 vertNormal;\n"
+    "out highp vec4 fragColor;\n"
+    "uniform highp vec3 lightPos;\n"
+    "void main() {\n"
+    "   highp vec3 L = normalize(lightPos - vert);\n"
+    "   highp float NL = max(dot(normalize(vertNormal), L), 0.0);\n"
+    "   highp vec3 color = vec3(0.39, 1.0, 0.0);\n"
+    "   highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0);\n"
+    "   fragColor = vec4(col, 1.0);\n"
+    "}\n";
+
+static const char *vertexShaderSource =
+    "attribute vec4 vertex;\n"
+    "attribute vec3 normal;\n"
+    "varying vec3 vert;\n"
+    "varying vec3 vertNormal;\n"
+    "uniform mat4 projMatrix;\n"
+    "uniform mat4 mvMatrix;\n"
+    "uniform mat3 normalMatrix;\n"
+    "void main() {\n"
+    "   vert = vertex.xyz;\n"
+    "   vertNormal = normalMatrix * normal;\n"
+    "   gl_Position = projMatrix * mvMatrix * vertex;\n"
+    "}\n";
+
+static const char *fragmentShaderSource =
+    "varying highp vec3 vert;\n"
+    "varying highp vec3 vertNormal;\n"
+    "uniform highp vec3 lightPos;\n"
+    "void main() {\n"
+    "   highp vec3 L = normalize(lightPos - vert);\n"
+    "   highp float NL = max(dot(normalize(vertNormal), L), 0.0);\n"
+    "   highp vec3 color = vec3(0.39, 1.0, 0.0);\n"
+    "   highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0);\n"
+    "   gl_FragColor = vec4(col, 1.0);\n"
+    "}\n";
+
+void GLWidget::initializeGL()
+{
+    // In this example the widget's corresponding top-level window can change
+    // several times during the widget's lifetime. Whenever this happens, the
+    // QOpenGLWidget's associated context is destroyed and a new one is created.
+    // Therefore we have to be prepared to clean up the resources on the
+    // aboutToBeDestroyed() signal, instead of the destructor. The emission of
+    // the signal will be followed by an invocation of initializeGL() where we
+    // can recreate all resources.
+    connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWidget::cleanup, Qt::UniqueConnection);
+
+    initializeOpenGLFunctions();
+    glClearColor(0, 0, 0, m_transparent ? 0 : 1);
+
+    m_program = new QOpenGLShaderProgram;
+    m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, m_core ? vertexShaderSourceCore : vertexShaderSource);
+    m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, m_core ? fragmentShaderSourceCore : fragmentShaderSource);
+    m_program->bindAttributeLocation("vertex", 0);
+    m_program->bindAttributeLocation("normal", 1);
+    m_program->link();
+
+    m_program->bind();
+    m_projMatrixLoc = m_program->uniformLocation("projMatrix");
+    m_mvMatrixLoc = m_program->uniformLocation("mvMatrix");
+    m_normalMatrixLoc = m_program->uniformLocation("normalMatrix");
+    m_lightPosLoc = m_program->uniformLocation("lightPos");
+
+    // Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
+    // implementations this is optional and support may not be present
+    // at all. Nonetheless the below code works in all cases and makes
+    // sure there is a VAO when one is needed.
+    m_vao.create();
+    QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
+
+    // Setup our vertex buffer object.
+    m_logoVbo.create();
+    m_logoVbo.bind();
+    m_logoVbo.allocate(m_logo.constData(), m_logo.count() * sizeof(GLfloat));
+
+    // Store the vertex attribute bindings for the program.
+    setupVertexAttribs();
+
+    // Our camera never changes in this example.
+    m_camera.setToIdentity();
+    m_camera.translate(0, 0, -1);
+
+    // Light position is fixed.
+    m_program->setUniformValue(m_lightPosLoc, QVector3D(0, 0, 70));
+
+    m_program->release();
+}
+
+void GLWidget::setupVertexAttribs()
+{
+    m_logoVbo.bind();
+    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+    f->glEnableVertexAttribArray(0);
+    f->glEnableVertexAttribArray(1);
+    f->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat),
+                             nullptr);
+    f->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat),
+                             reinterpret_cast<void *>(3 * sizeof(GLfloat)));
+    m_logoVbo.release();
+}
+
+void GLWidget::paintGL()
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+
+    m_world.setToIdentity();
+    m_world.rotate(180.0f - (m_xRot / 16.0f), 1, 0, 0);
+    m_world.rotate(m_yRot / 16.0f, 0, 1, 0);
+    m_world.rotate(m_zRot / 16.0f, 0, 0, 1);
+
+    QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
+    m_program->bind();
+    m_program->setUniformValue(m_projMatrixLoc, m_proj);
+    m_program->setUniformValue(m_mvMatrixLoc, m_camera * m_world);
+    QMatrix3x3 normalMatrix = m_world.normalMatrix();
+    m_program->setUniformValue(m_normalMatrixLoc, normalMatrix);
+
+    glDrawArrays(GL_TRIANGLES, 0, m_logo.vertexCount());
+
+    m_program->release();
+}
+
+void GLWidget::resizeGL(int w, int h)
+{
+    m_proj.setToIdentity();
+    m_proj.perspective(45.0f, GLfloat(w) / h, 0.01f, 100.0f);
+}
+
+void GLWidget::mousePressEvent(QMouseEvent *event)
+{
+    m_lastPos = event->position().toPoint();
+}
+
+void GLWidget::mouseMoveEvent(QMouseEvent *event)
+{
+    int dx = event->position().toPoint().x() - m_lastPos.x();
+    int dy = event->position().toPoint().y() - m_lastPos.y();
+
+    if (event->buttons() & Qt::LeftButton) {
+        setXRotation(m_xRot + 8 * dy);
+        setYRotation(m_yRot + 8 * dx);
+    } else if (event->buttons() & Qt::RightButton) {
+        setXRotation(m_xRot + 8 * dy);
+        setZRotation(m_zRot + 8 * dx);
+    }
+    m_lastPos = event->position().toPoint();
+}

examples/openGL/glwidget.h

@@ -0,0 +1,67 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#pragma once
+
+#include <QOpenGLWidget>
+#include <QOpenGLFunctions>
+#include <QOpenGLVertexArrayObject>
+#include <QOpenGLBuffer>
+#include <QMatrix4x4>
+#include "logo.h"
+
+QT_FORWARD_DECLARE_CLASS(QOpenGLShaderProgram)
+
+class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions
+{
+    Q_OBJECT
+
+public:
+    GLWidget(QWidget *parent = nullptr);
+    ~GLWidget();
+
+    static bool isTransparent() { return m_transparent; }
+    static void setTransparent(bool t) { m_transparent = t; }
+
+    QSize minimumSizeHint() const override;
+    QSize sizeHint() const override;
+
+public slots:
+    void setXRotation(int angle);
+    void setYRotation(int angle);
+    void setZRotation(int angle);
+    void cleanup();
+
+signals:
+    void xRotationChanged(int angle);
+    void yRotationChanged(int angle);
+    void zRotationChanged(int angle);
+
+protected:
+    void initializeGL() override;
+    void paintGL() override;
+    void resizeGL(int width, int height) override;
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
+
+private:
+    void setupVertexAttribs();
+
+    bool m_core;
+    int m_xRot = 0;
+    int m_yRot = 0;
+    int m_zRot = 0;
+    QPoint m_lastPos;
+    Logo m_logo;
+    QOpenGLVertexArrayObject m_vao;
+    QOpenGLBuffer m_logoVbo;
+    QOpenGLShaderProgram *m_program = nullptr;
+    int m_projMatrixLoc = 0;
+    int m_mvMatrixLoc = 0;
+    int m_normalMatrixLoc = 0;
+    int m_lightPosLoc = 0;
+    QMatrix4x4 m_proj;
+    QMatrix4x4 m_camera;
+    QMatrix4x4 m_world;
+    static bool m_transparent;
+};

examples/openGL/glwindow.cpp

@@ -0,0 +1,238 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include "glwindow.h"
+#include <QImage>
+#include <QOpenGLTexture>
+#include <QOpenGLShaderProgram>
+#include <QOpenGLBuffer>
+#include <QOpenGLContext>
+#include <QOpenGLVertexArrayObject>
+#include <QOpenGLExtraFunctions>
+#include <QPropertyAnimation>
+#include <QSequentialAnimationGroup>
+#include <QTimer>
+
+GLWindow::GLWindow()
+{
+    m_world.setToIdentity();
+    m_world.translate(0, 0, -1);
+    m_world.rotate(180, 1, 0, 0);
+
+    QSequentialAnimationGroup *animGroup = new QSequentialAnimationGroup(this);
+    animGroup->setLoopCount(-1);
+    QPropertyAnimation *zAnim0 = new QPropertyAnimation(this, QByteArrayLiteral("z"));
+    zAnim0->setStartValue(1.5f);
+    zAnim0->setEndValue(10.0f);
+    zAnim0->setDuration(2000);
+    animGroup->addAnimation(zAnim0);
+    QPropertyAnimation *zAnim1 = new QPropertyAnimation(this, QByteArrayLiteral("z"));
+    zAnim1->setStartValue(10.0f);
+    zAnim1->setEndValue(50.0f);
+    zAnim1->setDuration(4000);
+    zAnim1->setEasingCurve(QEasingCurve::OutElastic);
+    animGroup->addAnimation(zAnim1);
+    QPropertyAnimation *zAnim2 = new QPropertyAnimation(this, QByteArrayLiteral("z"));
+    zAnim2->setStartValue(50.0f);
+    zAnim2->setEndValue(1.5f);
+    zAnim2->setDuration(2000);
+    animGroup->addAnimation(zAnim2);
+    animGroup->start();
+
+    QPropertyAnimation* rAnim = new QPropertyAnimation(this, QByteArrayLiteral("r"));
+    rAnim->setStartValue(0.0f);
+    rAnim->setEndValue(360.0f);
+    rAnim->setDuration(2000);
+    rAnim->setLoopCount(-1);
+    rAnim->start();
+
+    QTimer::singleShot(4000, this, &GLWindow::startSecondStage);
+}
+
+GLWindow::~GLWindow()
+{
+    cleanup();
+}
+
+void GLWindow::startSecondStage()
+{
+    QPropertyAnimation* r2Anim = new QPropertyAnimation(this, QByteArrayLiteral("r2"));
+    r2Anim->setStartValue(0.0f);
+    r2Anim->setEndValue(360.0f);
+    r2Anim->setDuration(20000);
+    r2Anim->setLoopCount(-1);
+    r2Anim->start();
+}
+
+void GLWindow::setZ(float v)
+{
+    m_eye.setZ(v);
+    m_uniformsDirty = true;
+    update();
+}
+
+void GLWindow::setR(float v)
+{
+    m_r = v;
+    m_uniformsDirty = true;
+    update();
+}
+
+void GLWindow::setR2(float v)
+{
+    m_r2 = v;
+    m_uniformsDirty = true;
+    update();
+}
+
+static const char *vertexShaderSource =
+    "layout(location = 0) in vec4 vertex;\n"
+    "layout(location = 1) in vec3 normal;\n"
+    "out vec3 vert;\n"
+    "out vec3 vertNormal;\n"
+    "out vec3 color;\n"
+    "uniform mat4 projMatrix;\n"
+    "uniform mat4 camMatrix;\n"
+    "uniform mat4 worldMatrix;\n"
+    "uniform mat4 myMatrix;\n"
+    "uniform sampler2D sampler;\n"
+    "void main() {\n"
+    "   ivec2 pos = ivec2(gl_InstanceID % 32, gl_InstanceID / 32);\n"
+    "   vec2 t = vec2(float(-16 + pos.x) * 0.8, float(-18 + pos.y) * 0.6);\n"
+    "   float val = 2.0 * length(texelFetch(sampler, pos, 0).rgb);\n"
+    "   mat4 wm = myMatrix * mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, t.x, t.y, val, 1) * worldMatrix;\n"
+    "   color = texelFetch(sampler, pos, 0).rgb * vec3(0.4, 1.0, 0.0);\n"
+    "   vert = vec3(wm * vertex);\n"
+    "   vertNormal = mat3(transpose(inverse(wm))) * normal;\n"
+    "   gl_Position = projMatrix * camMatrix * wm * vertex;\n"
+    "}\n";
+
+static const char *fragmentShaderSource =
+    "in highp vec3 vert;\n"
+    "in highp vec3 vertNormal;\n"
+    "in highp vec3 color;\n"
+    "out highp vec4 fragColor;\n"
+    "uniform highp vec3 lightPos;\n"
+    "void main() {\n"
+    "   highp vec3 L = normalize(lightPos - vert);\n"
+    "   highp float NL = max(dot(normalize(vertNormal), L), 0.0);\n"
+    "   highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0);\n"
+    "   fragColor = vec4(col, 1.0);\n"
+    "}\n";
+
+QByteArray versionedShaderCode(const char *src)
+{
+    QByteArray versionedSrc;
+
+    if (QOpenGLContext::currentContext()->isOpenGLES())
+        versionedSrc.append(QByteArrayLiteral("#version 300 es\n"));
+    else
+        versionedSrc.append(QByteArrayLiteral("#version 330\n"));
+
+    versionedSrc.append(src);
+    return versionedSrc;
+}
+
+void GLWindow::initializeGL()
+{
+    connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWindow::cleanup, Qt::UniqueConnection);
+
+    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+
+    QImage img(":/qtlogo.png");
+    Q_ASSERT(!img.isNull());
+    delete m_texture;
+    m_texture = new QOpenGLTexture(img.scaled(32, 36).mirrored());
+
+    delete m_program;
+    m_program = new QOpenGLShaderProgram;
+    // Prepend the correct version directive to the sources. The rest is the
+    // same, thanks to the common GLSL syntax.
+    m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, versionedShaderCode(vertexShaderSource));
+    m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, versionedShaderCode(fragmentShaderSource));
+    m_program->link();
+
+    m_projMatrixLoc = m_program->uniformLocation("projMatrix");
+    m_camMatrixLoc = m_program->uniformLocation("camMatrix");
+    m_worldMatrixLoc = m_program->uniformLocation("worldMatrix");
+    m_myMatrixLoc = m_program->uniformLocation("myMatrix");
+    m_lightPosLoc = m_program->uniformLocation("lightPos");
+
+    // Create a VAO. Not strictly required for ES 3, but it is for plain OpenGL.
+    delete m_vao;
+    m_vao = new QOpenGLVertexArrayObject;
+    if (m_vao->create())
+        m_vao->bind();
+
+    m_program->bind();
+    delete m_vbo;
+    m_vbo = new QOpenGLBuffer;
+    m_vbo->create();
+    m_vbo->bind();
+    m_vbo->allocate(m_logo.constData(), m_logo.count() * sizeof(GLfloat));
+    f->glEnableVertexAttribArray(0);
+    f->glEnableVertexAttribArray(1);
+    f->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat),
+                             nullptr);
+    f->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat),
+                             reinterpret_cast<void *>(3 * sizeof(GLfloat)));
+    m_vbo->release();
+
+    f->glEnable(GL_DEPTH_TEST);
+    f->glEnable(GL_CULL_FACE);
+}
+
+void GLWindow::resizeGL(int w, int h)
+{
+    m_proj.setToIdentity();
+    m_proj.perspective(45.0f, GLfloat(w) / h, 0.01f, 100.0f);
+    m_uniformsDirty = true;
+}
+
+void GLWindow::paintGL()
+{
+    // Now use QOpenGLExtraFunctions instead of QOpenGLFunctions as we want to
+    // do more than what GL(ES) 2.0 offers.
+    QOpenGLExtraFunctions *f = QOpenGLContext::currentContext()->extraFunctions();
+
+    f->glClearColor(0, 0, 0, 1);
+    f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    m_program->bind();
+    m_texture->bind();
+
+    if (m_uniformsDirty) {
+        m_uniformsDirty = false;
+        QMatrix4x4 camera;
+        camera.lookAt(m_eye, m_eye + m_target, QVector3D(0, 1, 0));
+        m_program->setUniformValue(m_projMatrixLoc, m_proj);
+        m_program->setUniformValue(m_camMatrixLoc, camera);
+        QMatrix4x4 wm = m_world;
+        wm.rotate(m_r, 1, 1, 0);
+        m_program->setUniformValue(m_worldMatrixLoc, wm);
+        QMatrix4x4 mm;
+        mm.setToIdentity();
+        mm.rotate(-m_r2, 1, 0, 0);
+        m_program->setUniformValue(m_myMatrixLoc, mm);
+        m_program->setUniformValue(m_lightPosLoc, QVector3D(0, 0, 70));
+    }
+
+    // Now call a function introduced in OpenGL 3.1 / OpenGL ES 3.0. We
+    // requested a 3.3 or ES 3.0 context, so we know this will work.
+    f->glDrawArraysInstanced(GL_TRIANGLES, 0, m_logo.vertexCount(), 32 * 36);
+}
+
+void GLWindow::cleanup()
+{
+    makeCurrent();
+    delete m_texture;
+    delete m_program;
+    delete m_vbo;
+    delete m_vao;
+    m_texture = nullptr;
+    m_program = nullptr;
+    m_vbo = nullptr;
+    m_vao = nullptr;
+    doneCurrent();
+    QObject::disconnect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWindow::cleanup);
+}

examples/openGL/glwindow.h

@@ -0,0 +1,62 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#pragma once
+
+#include <QOpenGLWindow>
+#include <QMatrix4x4>
+#include <QVector3D>
+#include "logo.h"
+
+QT_FORWARD_DECLARE_CLASS(QOpenGLTexture)
+QT_FORWARD_DECLARE_CLASS(QOpenGLShaderProgram)
+QT_FORWARD_DECLARE_CLASS(QOpenGLBuffer)
+QT_FORWARD_DECLARE_CLASS(QOpenGLVertexArrayObject)
+
+class GLWindow : public QOpenGLWindow
+{
+    Q_OBJECT
+    Q_PROPERTY(float z READ z WRITE setZ)
+    Q_PROPERTY(float r READ r WRITE setR)
+    Q_PROPERTY(float r2 READ r2 WRITE setR2)
+
+public:
+    GLWindow();
+    ~GLWindow();
+
+    void initializeGL();
+    void resizeGL(int w, int h);
+    void paintGL();
+
+    float z() const { return m_eye.z(); }
+    void setZ(float v);
+
+    float r() const { return m_r; }
+    void setR(float v);
+    float r2() const { return m_r2; }
+    void setR2(float v);
+public slots:
+    void cleanup();
+
+private slots:
+    void startSecondStage();
+
+private:
+    QOpenGLTexture *m_texture = nullptr;
+    QOpenGLShaderProgram *m_program = nullptr;
+    QOpenGLBuffer *m_vbo = nullptr;
+    QOpenGLVertexArrayObject *m_vao = nullptr;
+    Logo m_logo;
+    int m_projMatrixLoc = 0;
+    int m_camMatrixLoc = 0;
+    int m_worldMatrixLoc = 0;
+    int m_myMatrixLoc = 0;
+    int m_lightPosLoc = 0;
+    QMatrix4x4 m_proj;
+    QMatrix4x4 m_world;
+    QVector3D m_eye;
+    QVector3D m_target = {0, 0, -1};
+    bool m_uniformsDirty = true;
+    float m_r = 0;
+    float m_r2 = 0;
+};

examples/openGL/logo.cpp

@@ -0,0 +1,103 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include "logo.h"
+#include <qmath.h>
+
+Logo::Logo()
+{
+    m_data.resize(2500 * 6);
+
+    const GLfloat x1 = +0.06f;
+    const GLfloat y1 = -0.14f;
+    const GLfloat x2 = +0.14f;
+    const GLfloat y2 = -0.06f;
+    const GLfloat x3 = +0.08f;
+    const GLfloat y3 = +0.00f;
+    const GLfloat x4 = +0.30f;
+    const GLfloat y4 = +0.22f;
+
+    quad(x1, y1, x2, y2, y2, x2, y1, x1);
+    quad(x3, y3, x4, y4, y4, x4, y3, x3);
+
+    extrude(x1, y1, x2, y2);
+    extrude(x2, y2, y2, x2);
+    extrude(y2, x2, y1, x1);
+    extrude(y1, x1, x1, y1);
+    extrude(x3, y3, x4, y4);
+    extrude(x4, y4, y4, x4);
+    extrude(y4, x4, y3, x3);
+
+    const int NumSectors = 100;
+
+    for (int i = 0; i < NumSectors; ++i) {
+        GLfloat angle = (i * 2 * M_PI) / NumSectors;
+        GLfloat angleSin = qSin(angle);
+        GLfloat angleCos = qCos(angle);
+        const GLfloat x5 = 0.30f * angleSin;
+        const GLfloat y5 = 0.30f * angleCos;
+        const GLfloat x6 = 0.20f * angleSin;
+        const GLfloat y6 = 0.20f * angleCos;
+
+        angle = ((i + 1) * 2 * M_PI) / NumSectors;
+        angleSin = qSin(angle);
+        angleCos = qCos(angle);
+        const GLfloat x7 = 0.20f * angleSin;
+        const GLfloat y7 = 0.20f * angleCos;
+        const GLfloat x8 = 0.30f * angleSin;
+        const GLfloat y8 = 0.30f * angleCos;
+
+        quad(x5, y5, x6, y6, x7, y7, x8, y8);
+
+        extrude(x6, y6, x7, y7);
+        extrude(x8, y8, x5, y5);
+    }
+}
+
+void Logo::add(const QVector3D &v, const QVector3D &n)
+{
+    GLfloat *p = m_data.data() + m_count;
+    *p++ = v.x();
+    *p++ = v.y();
+    *p++ = v.z();
+    *p++ = n.x();
+    *p++ = n.y();
+    *p++ = n.z();
+    m_count += 6;
+}
+
+void Logo::quad(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2, GLfloat x3, GLfloat y3, GLfloat x4, GLfloat y4)
+{
+    QVector3D n = QVector3D::normal(QVector3D(x4 - x1, y4 - y1, 0.0f), QVector3D(x2 - x1, y2 - y1, 0.0f));
+
+    add(QVector3D(x1, y1, -0.05f), n);
+    add(QVector3D(x4, y4, -0.05f), n);
+    add(QVector3D(x2, y2, -0.05f), n);
+
+    add(QVector3D(x3, y3, -0.05f), n);
+    add(QVector3D(x2, y2, -0.05f), n);
+    add(QVector3D(x4, y4, -0.05f), n);
+
+    n = QVector3D::normal(QVector3D(x1 - x4, y1 - y4, 0.0f), QVector3D(x2 - x4, y2 - y4, 0.0f));
+
+    add(QVector3D(x4, y4, 0.05f), n);
+    add(QVector3D(x1, y1, 0.05f), n);
+    add(QVector3D(x2, y2, 0.05f), n);
+
+    add(QVector3D(x2, y2, 0.05f), n);
+    add(QVector3D(x3, y3, 0.05f), n);
+    add(QVector3D(x4, y4, 0.05f), n);
+}
+
+void Logo::extrude(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+    QVector3D n = QVector3D::normal(QVector3D(0.0f, 0.0f, -0.1f), QVector3D(x2 - x1, y2 - y1, 0.0f));
+
+    add(QVector3D(x1, y1, +0.05f), n);
+    add(QVector3D(x1, y1, -0.05f), n);
+    add(QVector3D(x2, y2, +0.05f), n);
+
+    add(QVector3D(x2, y2, -0.05f), n);
+    add(QVector3D(x2, y2, +0.05f), n);
+    add(QVector3D(x1, y1, -0.05f), n);
+}

examples/openGL/logo.h

@@ -0,0 +1,28 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#ifndef LOGO_H
+#define LOGO_H
+
+#include <qopengl.h>
+#include <QList>
+#include <QVector3D>
+
+class Logo
+{
+public:
+    Logo();
+    const GLfloat *constData() const { return m_data.constData(); }
+    int count() const { return m_count; }
+    int vertexCount() const { return m_count / 6; }
+
+private:
+    void quad(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2, GLfloat x3, GLfloat y3, GLfloat x4, GLfloat y4);
+    void extrude(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+    void add(const QVector3D &v, const QVector3D &n);
+
+    QList<GLfloat> m_data;
+    int m_count = 0;
+};
+
+#endif // LOGO_H

examples/openGL/main.cpp

@@ -0,0 +1,22 @@
+#include <QApplication>
+#include <QCommandLineOption>
+#include <QCommandLineParser>
+#include <QGuiApplication>
+#include <QOpenGLContext>
+#include <QScreen>
+#include <QSurfaceFormat>
+
+#include <glwindow.h>
+#include <mainwindow.h>
+
+int main(int argc, char* argv[])
+{
+    ads::CDockManager::setAutoHideConfigFlags(ads::CDockManager::DefaultAutoHideConfig);
+    QApplication a(argc, argv);
+
+    MainWindow* w = new MainWindow();
+    w->setAttribute(Qt::WA_DeleteOnClose);
+    w->show();
+
+    return a.exec();
+}

examples/openGL/mainwindow.cpp

@@ -0,0 +1,127 @@
+#include "mainwindow.h"
+
+#include <QApplication>
+#include <QChart>
+#include <QChartView>
+#include <QComboBox>
+#include <QLabel>
+#include <QLineSeries>
+#include <QOpenGLWidget>
+#include <QPushButton>
+#include <QQuickWidget>
+#include <QTimer>
+#include <QVBoxLayout>
+
+#include <glwidget.h>
+#include <glwindow.h>
+
+class OpenGLChartWidget : public QWidget
+{
+public:
+    OpenGLChartWidget(QWidget* parent) : QWidget(parent)
+    {
+        // Create example chart using OpenGL
+        QVBoxLayout* layout = new QVBoxLayout(this);
+        QChartView* chart_view = new QChartView(this);
+        QLineSeries* series = new QLineSeries(this);
+
+        QList<QPointF> points = {{0, 0}, {2, 0},  {2, 5},
+                                 {4, 5}, {4, -2}, {6, -2}};
+        series->setUseOpenGL(true);
+        series->replace(points);
+        chart_view->chart()->addSeries(series);
+        chart_view->chart()->createDefaultAxes();
+        chart_view->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+        layout->addWidget(chart_view);
+    }
+    ~OpenGLChartWidget() {}
+};
+
+class ChartWidget : public QWidget
+{
+public:
+    ChartWidget(QWidget* parent) : QWidget(parent)
+    {
+        // Create example chart using OpenGL
+        QVBoxLayout* layout = new QVBoxLayout(this);
+        QChartView* chart_view = new QChartView(this);
+        QLineSeries* series = new QLineSeries(this);
+
+        QList<QPointF> points = {{0, 0},  {2, 0}, {2, -5},
+                                 {4, -5}, {4, 2}, {6, 2}};
+        series->replace(points);
+        chart_view->chart()->addSeries(series);
+        chart_view->chart()->createDefaultAxes();
+        chart_view->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+        layout->addWidget(chart_view);
+    }
+    ~ChartWidget() {}
+};
+
+class OpenGLWidgetContainer : public QWidget
+{
+public:
+    OpenGLWidgetContainer(QWidget* parent = nullptr) : QWidget(parent)
+    {
+        setAttribute(Qt::WA_NativeWindow, true);
+
+        QVBoxLayout* layout = new QVBoxLayout(this);
+        layout->setContentsMargins(0, 0, 0, 0);
+
+        QWidget* widget = QWidget::createWindowContainer(new GLWindow, parent);
+        layout->addWidget(widget);
+    }
+
+    ~OpenGLWidgetContainer() {}
+};
+
+MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent)
+{
+    resize(900, 600);
+
+    // Create the dock manager. Because the parent parameter is a QMainWindow
+    // the dock manager registers itself as the central widget.
+    _dock_manager = new ads::CDockManager(this);
+
+    OpenGLChartWidget* openGL_chart = new OpenGLChartWidget(this);
+    OpenGLWidgetContainer* openGL_container = new OpenGLWidgetContainer(this);
+    GLWidget* gl_widget = new GLWidget(this);
+    GLWidget* gl_widget_2 = new GLWidget(this);
+
+    // Create a dock widget with the title "Chart with OpenGL" and set the created
+    // chart as the dock widget content
+    ads::CDockWidget* opengl_chart_dock_widget =
+        new ads::CDockWidget("Chart with OpenGL");
+    opengl_chart_dock_widget->setWidget(openGL_chart);
+    auto* area = _dock_manager->addDockWidget(ads::CenterDockWidgetArea,
+                                              opengl_chart_dock_widget);
+
+    ads::CDockWidget* chart_dock_widget = new ads::CDockWidget("Simple Chart");
+    chart_dock_widget->setWidget(new ChartWidget(this));
+    _dock_manager->addDockWidgetTabToArea(chart_dock_widget, area);
+
+    ads::CDockWidget* openGL_window_dock_widget =
+        new ads::CDockWidget("OpenGL window");
+    openGL_window_dock_widget->setWidget(openGL_container);
+    _dock_manager->addDockWidgetTabToArea(openGL_window_dock_widget, area);
+
+    ads::CDockWidget* openGL_widget_dock_widget =
+        new ads::CDockWidget("OpenGL widget");
+    openGL_widget_dock_widget->setWidget(gl_widget);
+    _dock_manager->addDockWidgetTabToArea(openGL_widget_dock_widget, area);
+
+    ads::CDockWidget* openGL_widget_dock_widget_2 =
+        new ads::CDockWidget("OpenGL widget 2");
+    openGL_widget_dock_widget_2->setWidget(gl_widget_2);
+    _dock_manager->addDockWidgetTabToArea(openGL_widget_dock_widget_2, area);
+
+    ads::CDockWidget* label_dock_widget = new ads::CDockWidget("Label");
+
+    QLabel* l = new QLabel();
+    l->setWordWrap(true);
+    l->setAlignment(Qt::AlignTop | Qt::AlignLeft);
+    l->setText("Lorem ipsum dolor sit amet, consectetuer adipiscing elit. ");
+
+    label_dock_widget->setWidget(l);
+    _dock_manager->addDockWidgetTabToArea(label_dock_widget, area);
+}

examples/openGL/mainwindow.h

@@ -0,0 +1,20 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+
+#include <DockManager.h>
+
+class MainWindow : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    explicit MainWindow(QWidget* parent = 0);
+    ~MainWindow() = default;
+
+private:
+    ads::CDockManager* _dock_manager;
+};
+
+#endif  // MAINWINDOW_H

examples/openGL/openGL.pro

@@ -0,0 +1,36 @@
+ADS_OUT_ROOT = $${OUT_PWD}/../..
+
+QT += core gui widgets charts opengl quick quickwidgets
+
+TARGET = OpenGLExample
+DESTDIR = $${ADS_OUT_ROOT}/lib
+TEMPLATE = app
+CONFIG += c++14
+CONFIG += debug
+adsBuildStatic {
+    DEFINES += ADS_STATIC
+}
+
+DEFINES += QT_DEPRECATED_WARNINGS
+DEFINES += QT_DEBUG_PLUGINS
+
+SOURCES += \
+        glwidget.cpp \
+        main.cpp \
+        mainwindow.cpp \
+        logo.cpp \
+        glwindow.cpp
+
+HEADERS += \
+        mainwindow.h \
+        glwidget.h \
+        logo.h \
+        glwindow.h
+
+RESOURCES += openGL.qrc
+
+LIBS += -L$${ADS_OUT_ROOT}/lib
+include(../../ads.pri)
+INCLUDEPATH += ../../src
+DEPENDPATH += ../../src    
+

examples/openGL/openGL.qrc

@@ -0,0 +1,5 @@
+<RCC>
+  <qresource>
+    <file>qtlogo.png</file>
+  </qresource>
+</RCC>

vcpkg-configuration.json

@@ -0,0 +1,9 @@
+{
+    "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg-configuration.schema.json",
+    "default-registry": {
+        "kind": "git",
+        "baseline": "2f210a9c13fcf2b0c36b1f2187366feec37e3390",
+        "reference": "master",
+        "repository": "https://github.com/microsoft/vcpkg"
+    }
+}

vcpkg.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": [
+    "qtcharts",
+    "qttranslations",
+    "qtdeclarative",
+    "qtbase"
+  ]
+}