2014-06-20 09:58:34 +00:00
|
|
|
/****************************************************************************
|
|
|
|
|
**
|
2016-01-22 12:24:00 +00:00
|
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
|
|
|
** Contact: https://www.qt.io/licensing/
|
2014-06-20 09:58:34 +00:00
|
|
|
**
|
|
|
|
|
** This file is part of the examples of the Qt Toolkit.
|
|
|
|
|
**
|
|
|
|
|
** $QT_BEGIN_LICENSE:BSD$
|
2016-01-22 12:24:00 +00:00
|
|
|
** Commercial License Usage
|
|
|
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
|
|
|
** accordance with the commercial license agreement provided with the
|
|
|
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
|
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
|
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
|
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
|
|
|
**
|
|
|
|
|
** BSD License Usage
|
|
|
|
|
** Alternatively, you may use this file under the terms of the BSD license
|
|
|
|
|
** as follows:
|
2014-06-20 09:58:34 +00:00
|
|
|
**
|
|
|
|
|
** "Redistribution and use in source and binary forms, with or without
|
|
|
|
|
** modification, are permitted provided that the following conditions are
|
|
|
|
|
** met:
|
|
|
|
|
** * Redistributions of source code must retain the above copyright
|
|
|
|
|
** notice, this list of conditions and the following disclaimer.
|
|
|
|
|
** * Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
** notice, this list of conditions and the following disclaimer in
|
|
|
|
|
** the documentation and/or other materials provided with the
|
|
|
|
|
** distribution.
|
2015-02-13 11:15:33 +00:00
|
|
|
** * Neither the name of The Qt Company Ltd nor the names of its
|
|
|
|
|
** contributors may be used to endorse or promote products derived
|
|
|
|
|
** from this software without specific prior written permission.
|
2014-06-20 09:58:34 +00:00
|
|
|
**
|
|
|
|
|
**
|
|
|
|
|
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
|
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
|
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
|
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
|
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
|
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
|
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
|
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
|
|
|
|
|
**
|
|
|
|
|
** $QT_END_LICENSE$
|
|
|
|
|
**
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
|
|
#include "mainwindow.h"
|
|
|
|
|
|
|
|
|
|
#include <QApplication>
|
|
|
|
|
#include <QMenuBar>
|
|
|
|
|
#include <QGroupBox>
|
|
|
|
|
#include <QSlider>
|
|
|
|
|
#include <QLabel>
|
|
|
|
|
#include <QCheckBox>
|
2017-04-14 04:13:52 +00:00
|
|
|
#include <QRandomGenerator>
|
2014-06-20 09:58:34 +00:00
|
|
|
#include <QSpinBox>
|
2015-06-01 09:44:37 +00:00
|
|
|
#include <QScrollArea>
|
Compose render-to-texture widgets through QRhi
QPlatformTextureList holds a QRhiTexture instead of GLuint. A
QPlatformBackingStore now optionally can own a QRhi and a
QRhiSwapChain for the associated window. Non-GL rendering must use
this QRhi everywhere, whereas GL (QOpenGLWidget) can choose to still
rely on resource sharing between contexts. A widget tells that it
wants QRhi and the desired configuration in a new virtual function in
QWidgetPrivate returning a QPlatformBackingStoreRhiConfig. This is
evaluated (among a top-level's all children) upon create() before
creating the repaint manager and the QWidgetWindow.
In QOpenGLWidget what do request is obvious: it will request an
OpenGL-based QRhi. QQuickWidget (or a potential future QRhiWidget)
will be more interesting: it needs to honor the standard Qt Quick
env.vars. and QQuickWindow APIs (or, in whatever way the user
configured the QRhiWidget), and so will set up the config struct
accordingly.
In addition, the rhiconfig and surface type is (re)evaluated when
(re)parenting a widget to a new tlw. If needed, this will now trigger
a destroy - create on the tlw. This should be be safe to do in
setParent. When multiple child widgets report an enabled rhiconfig,
the first one (the first child encountered) wins. So e.g. attempting
to have a QOpenGLWidget and a Vulkan-based QQuickWidget in the same
top-level window will fail one of the widgets (it likely won't
render).
RasterGLSurface is no longer used by widgets. Rather, the appropriate
surface type is chosen.
The rhi support in the backingstore is usable without widgets as well.
To make rhiFlush() functional, one needs to call setRhiConfig() after
creating the QBackingStore. (like QWidget does to top-level windows)
Most of the QT_NO_OPENGL ifdefs are eliminated all over the place.
Everything with QRhi is unconditional code at compile time, except the
actual initialization.
Having to plumb the widget tlw's shareContext (or, now, the QRhi)
through QWindowPrivate is no longer needed. The old approach does not
scale: to implement composeAndFlush (now rhiFlush) we need more than
just a QRhi object, and this way we no longer pollute everything
starting from the widget level (QWidget's topextra -> QWidgetWindow ->
QWindowPrivate) just to send data around.
The BackingStoreOpenGLSupport interface and the QtGui - QtOpenGL split
is all gone. Instead, there is a QBackingStoreDefaultCompositor in
QtGui which is what the default implementations of composeAndFlush and
toTexture call. (overriding composeAndFlush and co. f.ex. in eglfs
should continue working mostly as-is, apart from adapting to the
texture list changes and getting the native OpenGL texture id out of
the QRhiTexture)
As QQuickWidget is way too complicated to just port as-is, an rhi
manual test (rhiwidget) is introduced as a first step, in ordewr to
exercise a simple, custom render-to-texture widget that does something
using a (not necessarily OpenGL-backed) QRhi and acts as fully
functional QWidget (modeled after QOpenGLWidget). This can also form
the foundation of a potential future QRhiWidget.
It is also possible to force the QRhi-based flushing always,
regardless of the presence of render-to-texture widgets. To exercise
this, set the env.var. QT_WIDGETS_RHI=1. This picks a
platform-specific default, and can be overridden with
QT_WIDGETS_RHI_BACKEND. (in sync with Qt Quick) This can eventually be
extended to query the platform plugin as well to check if the platform
plugin prefers to always do flushes with a 3D API.
QOpenGLWidget should work like before from the user's perspective, while
internally it has to do some things differently to play nice and prevent
regressions with the new rendering architecture. To exercise this
better, the qopenglwidget example gets a new tab-based view (that could
perhaps replace the example's main window later on?). The openglwidget
manual test is made compatible with Qt 6, and gets a counterpart in form
of the dockedopenglwidget manual test, which is a modified version of
the cube example that features dock widgets. This is relevant in
particular because render-to-texture widgets within a QDockWidget has
its own specific quirks, with logic taking this into account, hence
testing is essential.
For existing applications there are two important consequences with
this patch in place:
- Once the rhi-based composition is enabled, it stays active for the
lifetime of the top-level window.
- Dynamically creating and parenting the first render-to-texture
widget to an already created tlw will destroy and recreate the tlw
(and the underlying window). The visible effects of this depend on the
platform. (e.g. the window may disappear and reappear on some,
whereas with other windowing systems it is not noticeable at all -
this is not really different from similar situtions with reparenting
or when moving windows between screens, so should be acceptable in
practice)
- On iOS raster windows are flushed with Metal (and rhi) from now on
(previously this was through OpenGL by making flush() call
composeAndFlush().
Change-Id: Id05bd0f7a26fa845f8b7ad8eedda3b0e78ab7a4e
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2021-10-25 13:21:31 +00:00
|
|
|
#include <QTabWidget>
|
|
|
|
|
#include <QTabBar>
|
|
|
|
|
#include <QToolButton>
|
2014-06-20 09:58:34 +00:00
|
|
|
|
|
|
|
|
#include "glwidget.h"
|
|
|
|
|
|
|
|
|
|
MainWindow::MainWindow()
|
|
|
|
|
: m_nextX(1), m_nextY(1)
|
|
|
|
|
{
|
Compose render-to-texture widgets through QRhi
QPlatformTextureList holds a QRhiTexture instead of GLuint. A
QPlatformBackingStore now optionally can own a QRhi and a
QRhiSwapChain for the associated window. Non-GL rendering must use
this QRhi everywhere, whereas GL (QOpenGLWidget) can choose to still
rely on resource sharing between contexts. A widget tells that it
wants QRhi and the desired configuration in a new virtual function in
QWidgetPrivate returning a QPlatformBackingStoreRhiConfig. This is
evaluated (among a top-level's all children) upon create() before
creating the repaint manager and the QWidgetWindow.
In QOpenGLWidget what do request is obvious: it will request an
OpenGL-based QRhi. QQuickWidget (or a potential future QRhiWidget)
will be more interesting: it needs to honor the standard Qt Quick
env.vars. and QQuickWindow APIs (or, in whatever way the user
configured the QRhiWidget), and so will set up the config struct
accordingly.
In addition, the rhiconfig and surface type is (re)evaluated when
(re)parenting a widget to a new tlw. If needed, this will now trigger
a destroy - create on the tlw. This should be be safe to do in
setParent. When multiple child widgets report an enabled rhiconfig,
the first one (the first child encountered) wins. So e.g. attempting
to have a QOpenGLWidget and a Vulkan-based QQuickWidget in the same
top-level window will fail one of the widgets (it likely won't
render).
RasterGLSurface is no longer used by widgets. Rather, the appropriate
surface type is chosen.
The rhi support in the backingstore is usable without widgets as well.
To make rhiFlush() functional, one needs to call setRhiConfig() after
creating the QBackingStore. (like QWidget does to top-level windows)
Most of the QT_NO_OPENGL ifdefs are eliminated all over the place.
Everything with QRhi is unconditional code at compile time, except the
actual initialization.
Having to plumb the widget tlw's shareContext (or, now, the QRhi)
through QWindowPrivate is no longer needed. The old approach does not
scale: to implement composeAndFlush (now rhiFlush) we need more than
just a QRhi object, and this way we no longer pollute everything
starting from the widget level (QWidget's topextra -> QWidgetWindow ->
QWindowPrivate) just to send data around.
The BackingStoreOpenGLSupport interface and the QtGui - QtOpenGL split
is all gone. Instead, there is a QBackingStoreDefaultCompositor in
QtGui which is what the default implementations of composeAndFlush and
toTexture call. (overriding composeAndFlush and co. f.ex. in eglfs
should continue working mostly as-is, apart from adapting to the
texture list changes and getting the native OpenGL texture id out of
the QRhiTexture)
As QQuickWidget is way too complicated to just port as-is, an rhi
manual test (rhiwidget) is introduced as a first step, in ordewr to
exercise a simple, custom render-to-texture widget that does something
using a (not necessarily OpenGL-backed) QRhi and acts as fully
functional QWidget (modeled after QOpenGLWidget). This can also form
the foundation of a potential future QRhiWidget.
It is also possible to force the QRhi-based flushing always,
regardless of the presence of render-to-texture widgets. To exercise
this, set the env.var. QT_WIDGETS_RHI=1. This picks a
platform-specific default, and can be overridden with
QT_WIDGETS_RHI_BACKEND. (in sync with Qt Quick) This can eventually be
extended to query the platform plugin as well to check if the platform
plugin prefers to always do flushes with a 3D API.
QOpenGLWidget should work like before from the user's perspective, while
internally it has to do some things differently to play nice and prevent
regressions with the new rendering architecture. To exercise this
better, the qopenglwidget example gets a new tab-based view (that could
perhaps replace the example's main window later on?). The openglwidget
manual test is made compatible with Qt 6, and gets a counterpart in form
of the dockedopenglwidget manual test, which is a modified version of
the cube example that features dock widgets. This is relevant in
particular because render-to-texture widgets within a QDockWidget has
its own specific quirks, with logic taking this into account, hence
testing is essential.
For existing applications there are two important consequences with
this patch in place:
- Once the rhi-based composition is enabled, it stays active for the
lifetime of the top-level window.
- Dynamically creating and parenting the first render-to-texture
widget to an already created tlw will destroy and recreate the tlw
(and the underlying window). The visible effects of this depend on the
platform. (e.g. the window may disappear and reappear on some,
whereas with other windowing systems it is not noticeable at all -
this is not really different from similar situtions with reparenting
or when moving windows between screens, so should be acceptable in
practice)
- On iOS raster windows are flushed with Metal (and rhi) from now on
(previously this was through OpenGL by making flush() call
composeAndFlush().
Change-Id: Id05bd0f7a26fa845f8b7ad8eedda3b0e78ab7a4e
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2021-10-25 13:21:31 +00:00
|
|
|
GLWidget *glwidget = new GLWidget(this, qRgb(20, 20, 50));
|
2014-09-28 16:58:46 +00:00
|
|
|
m_glWidgets << glwidget;
|
2014-06-20 09:58:34 +00:00
|
|
|
QLabel *label = new QLabel(this);
|
|
|
|
|
m_timer = new QTimer(this);
|
|
|
|
|
QSlider *slider = new QSlider(this);
|
|
|
|
|
slider->setOrientation(Qt::Horizontal);
|
|
|
|
|
|
|
|
|
|
QLabel *updateLabel = new QLabel("Update interval");
|
|
|
|
|
QSpinBox *updateInterval = new QSpinBox(this);
|
|
|
|
|
updateInterval->setSuffix(" ms");
|
|
|
|
|
updateInterval->setValue(10);
|
|
|
|
|
updateInterval->setToolTip("Interval for the timer that calls update().\n"
|
|
|
|
|
"Note that on most systems the swap will block to wait for vsync\n"
|
|
|
|
|
"and therefore an interval < 16 ms will likely lead to a 60 FPS update rate.");
|
|
|
|
|
QGroupBox *updateGroupBox = new QGroupBox(this);
|
2014-09-28 16:58:46 +00:00
|
|
|
QCheckBox *timerBased = new QCheckBox("Use timer", this);
|
2015-06-01 09:44:37 +00:00
|
|
|
timerBased->setChecked(false);
|
2014-09-28 16:58:46 +00:00
|
|
|
timerBased->setToolTip("Toggles using a timer to trigger update().\n"
|
|
|
|
|
"When not set, each paintGL() schedules the next update immediately,\n"
|
|
|
|
|
"expecting the blocking swap to throttle the thread.\n"
|
|
|
|
|
"This shows how unnecessary the timer is in most cases.");
|
2014-06-20 09:58:34 +00:00
|
|
|
QCheckBox *transparent = new QCheckBox("Transparent background", this);
|
|
|
|
|
transparent->setToolTip("Toggles Qt::WA_AlwaysStackOnTop and transparent clear color for glClear().\n"
|
|
|
|
|
"Note how the button on top stacks incorrectly when enabling this.");
|
|
|
|
|
QHBoxLayout *updateLayout = new QHBoxLayout;
|
|
|
|
|
updateLayout->addWidget(updateLabel);
|
|
|
|
|
updateLayout->addWidget(updateInterval);
|
2014-09-28 16:58:46 +00:00
|
|
|
updateLayout->addWidget(timerBased);
|
2014-06-20 09:58:34 +00:00
|
|
|
updateLayout->addWidget(transparent);
|
|
|
|
|
updateGroupBox->setLayout(updateLayout);
|
|
|
|
|
|
|
|
|
|
slider->setRange(0, 50);
|
|
|
|
|
slider->setSliderPosition(30);
|
|
|
|
|
m_timer->setInterval(10);
|
2015-06-01 09:44:37 +00:00
|
|
|
label->setText("A scrollable QOpenGLWidget");
|
2014-06-20 09:58:34 +00:00
|
|
|
label->setAlignment(Qt::AlignHCenter);
|
|
|
|
|
|
|
|
|
|
QGroupBox * groupBox = new QGroupBox(this);
|
|
|
|
|
setCentralWidget(groupBox);
|
|
|
|
|
groupBox->setTitle("QOpenGLWidget Example");
|
|
|
|
|
|
|
|
|
|
m_layout = new QGridLayout(groupBox);
|
|
|
|
|
|
2015-06-01 09:44:37 +00:00
|
|
|
QScrollArea *scrollArea = new QScrollArea;
|
|
|
|
|
scrollArea->setWidget(glwidget);
|
|
|
|
|
|
|
|
|
|
m_layout->addWidget(scrollArea,1,0,8,1);
|
2014-06-20 09:58:34 +00:00
|
|
|
m_layout->addWidget(label,9,0,1,1);
|
|
|
|
|
m_layout->addWidget(updateGroupBox, 10, 0, 1, 1);
|
|
|
|
|
m_layout->addWidget(slider, 11,0,1,1);
|
|
|
|
|
|
|
|
|
|
groupBox->setLayout(m_layout);
|
|
|
|
|
|
2015-08-28 13:16:57 +00:00
|
|
|
|
2014-08-22 14:45:59 +00:00
|
|
|
QMenu *fileMenu = menuBar()->addMenu("&File");
|
2015-08-28 13:16:57 +00:00
|
|
|
fileMenu->addAction("E&xit", this, &QWidget::close);
|
2014-08-22 14:45:59 +00:00
|
|
|
QMenu *showMenu = menuBar()->addMenu("&Show");
|
2015-08-28 13:16:57 +00:00
|
|
|
showMenu->addAction("Show 3D Logo", glwidget, &GLWidget::setLogo);
|
|
|
|
|
showMenu->addAction("Show 2D Texture", glwidget, &GLWidget::setTexture);
|
|
|
|
|
QAction *showBubbles = showMenu->addAction("Show bubbles", glwidget, &GLWidget::setShowBubbles);
|
2014-06-20 09:58:34 +00:00
|
|
|
showBubbles->setCheckable(true);
|
|
|
|
|
showBubbles->setChecked(true);
|
Compose render-to-texture widgets through QRhi
QPlatformTextureList holds a QRhiTexture instead of GLuint. A
QPlatformBackingStore now optionally can own a QRhi and a
QRhiSwapChain for the associated window. Non-GL rendering must use
this QRhi everywhere, whereas GL (QOpenGLWidget) can choose to still
rely on resource sharing between contexts. A widget tells that it
wants QRhi and the desired configuration in a new virtual function in
QWidgetPrivate returning a QPlatformBackingStoreRhiConfig. This is
evaluated (among a top-level's all children) upon create() before
creating the repaint manager and the QWidgetWindow.
In QOpenGLWidget what do request is obvious: it will request an
OpenGL-based QRhi. QQuickWidget (or a potential future QRhiWidget)
will be more interesting: it needs to honor the standard Qt Quick
env.vars. and QQuickWindow APIs (or, in whatever way the user
configured the QRhiWidget), and so will set up the config struct
accordingly.
In addition, the rhiconfig and surface type is (re)evaluated when
(re)parenting a widget to a new tlw. If needed, this will now trigger
a destroy - create on the tlw. This should be be safe to do in
setParent. When multiple child widgets report an enabled rhiconfig,
the first one (the first child encountered) wins. So e.g. attempting
to have a QOpenGLWidget and a Vulkan-based QQuickWidget in the same
top-level window will fail one of the widgets (it likely won't
render).
RasterGLSurface is no longer used by widgets. Rather, the appropriate
surface type is chosen.
The rhi support in the backingstore is usable without widgets as well.
To make rhiFlush() functional, one needs to call setRhiConfig() after
creating the QBackingStore. (like QWidget does to top-level windows)
Most of the QT_NO_OPENGL ifdefs are eliminated all over the place.
Everything with QRhi is unconditional code at compile time, except the
actual initialization.
Having to plumb the widget tlw's shareContext (or, now, the QRhi)
through QWindowPrivate is no longer needed. The old approach does not
scale: to implement composeAndFlush (now rhiFlush) we need more than
just a QRhi object, and this way we no longer pollute everything
starting from the widget level (QWidget's topextra -> QWidgetWindow ->
QWindowPrivate) just to send data around.
The BackingStoreOpenGLSupport interface and the QtGui - QtOpenGL split
is all gone. Instead, there is a QBackingStoreDefaultCompositor in
QtGui which is what the default implementations of composeAndFlush and
toTexture call. (overriding composeAndFlush and co. f.ex. in eglfs
should continue working mostly as-is, apart from adapting to the
texture list changes and getting the native OpenGL texture id out of
the QRhiTexture)
As QQuickWidget is way too complicated to just port as-is, an rhi
manual test (rhiwidget) is introduced as a first step, in ordewr to
exercise a simple, custom render-to-texture widget that does something
using a (not necessarily OpenGL-backed) QRhi and acts as fully
functional QWidget (modeled after QOpenGLWidget). This can also form
the foundation of a potential future QRhiWidget.
It is also possible to force the QRhi-based flushing always,
regardless of the presence of render-to-texture widgets. To exercise
this, set the env.var. QT_WIDGETS_RHI=1. This picks a
platform-specific default, and can be overridden with
QT_WIDGETS_RHI_BACKEND. (in sync with Qt Quick) This can eventually be
extended to query the platform plugin as well to check if the platform
plugin prefers to always do flushes with a 3D API.
QOpenGLWidget should work like before from the user's perspective, while
internally it has to do some things differently to play nice and prevent
regressions with the new rendering architecture. To exercise this
better, the qopenglwidget example gets a new tab-based view (that could
perhaps replace the example's main window later on?). The openglwidget
manual test is made compatible with Qt 6, and gets a counterpart in form
of the dockedopenglwidget manual test, which is a modified version of
the cube example that features dock widgets. This is relevant in
particular because render-to-texture widgets within a QDockWidget has
its own specific quirks, with logic taking this into account, hence
testing is essential.
For existing applications there are two important consequences with
this patch in place:
- Once the rhi-based composition is enabled, it stays active for the
lifetime of the top-level window.
- Dynamically creating and parenting the first render-to-texture
widget to an already created tlw will destroy and recreate the tlw
(and the underlying window). The visible effects of this depend on the
platform. (e.g. the window may disappear and reappear on some,
whereas with other windowing systems it is not noticeable at all -
this is not really different from similar situtions with reparenting
or when moving windows between screens, so should be acceptable in
practice)
- On iOS raster windows are flushed with Metal (and rhi) from now on
(previously this was through OpenGL by making flush() call
composeAndFlush().
Change-Id: Id05bd0f7a26fa845f8b7ad8eedda3b0e78ab7a4e
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2021-10-25 13:21:31 +00:00
|
|
|
showMenu->addAction("Open tab window", this, &MainWindow::showNewWindow);
|
2015-08-28 13:16:57 +00:00
|
|
|
QMenu *helpMenu = menuBar()->addMenu("&Help");
|
|
|
|
|
helpMenu->addAction("About Qt", qApp, &QApplication::aboutQt);
|
2014-06-20 09:58:34 +00:00
|
|
|
|
2016-12-20 18:37:37 +00:00
|
|
|
connect(m_timer, &QTimer::timeout, glwidget, QOverload<>::of(&QWidget::update));
|
2014-06-20 09:58:34 +00:00
|
|
|
|
2015-08-28 13:16:57 +00:00
|
|
|
connect(slider, &QAbstractSlider::valueChanged, glwidget, &GLWidget::setScaling);
|
2014-06-20 09:58:34 +00:00
|
|
|
connect(transparent, &QCheckBox::toggled, glwidget, &GLWidget::setTransparent);
|
2020-02-07 08:36:54 +00:00
|
|
|
connect(updateInterval, &QSpinBox::valueChanged,
|
2015-08-28 13:16:57 +00:00
|
|
|
this, &MainWindow::updateIntervalChanged);
|
2014-09-28 16:58:46 +00:00
|
|
|
connect(timerBased, &QCheckBox::toggled, this, &MainWindow::timerUsageChanged);
|
|
|
|
|
connect(timerBased, &QCheckBox::toggled, updateInterval, &QWidget::setEnabled);
|
2014-06-20 09:58:34 +00:00
|
|
|
|
2015-06-01 09:44:37 +00:00
|
|
|
if (timerBased->isChecked())
|
|
|
|
|
m_timer->start();
|
|
|
|
|
else
|
|
|
|
|
updateInterval->setEnabled(false);
|
2014-06-20 09:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MainWindow::updateIntervalChanged(int value)
|
|
|
|
|
{
|
|
|
|
|
m_timer->setInterval(value);
|
2014-09-28 16:58:46 +00:00
|
|
|
if (m_timer->isActive())
|
|
|
|
|
m_timer->start();
|
2014-06-20 09:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void MainWindow::addNew()
|
|
|
|
|
{
|
|
|
|
|
if (m_nextY == 4)
|
|
|
|
|
return;
|
Compose render-to-texture widgets through QRhi
QPlatformTextureList holds a QRhiTexture instead of GLuint. A
QPlatformBackingStore now optionally can own a QRhi and a
QRhiSwapChain for the associated window. Non-GL rendering must use
this QRhi everywhere, whereas GL (QOpenGLWidget) can choose to still
rely on resource sharing between contexts. A widget tells that it
wants QRhi and the desired configuration in a new virtual function in
QWidgetPrivate returning a QPlatformBackingStoreRhiConfig. This is
evaluated (among a top-level's all children) upon create() before
creating the repaint manager and the QWidgetWindow.
In QOpenGLWidget what do request is obvious: it will request an
OpenGL-based QRhi. QQuickWidget (or a potential future QRhiWidget)
will be more interesting: it needs to honor the standard Qt Quick
env.vars. and QQuickWindow APIs (or, in whatever way the user
configured the QRhiWidget), and so will set up the config struct
accordingly.
In addition, the rhiconfig and surface type is (re)evaluated when
(re)parenting a widget to a new tlw. If needed, this will now trigger
a destroy - create on the tlw. This should be be safe to do in
setParent. When multiple child widgets report an enabled rhiconfig,
the first one (the first child encountered) wins. So e.g. attempting
to have a QOpenGLWidget and a Vulkan-based QQuickWidget in the same
top-level window will fail one of the widgets (it likely won't
render).
RasterGLSurface is no longer used by widgets. Rather, the appropriate
surface type is chosen.
The rhi support in the backingstore is usable without widgets as well.
To make rhiFlush() functional, one needs to call setRhiConfig() after
creating the QBackingStore. (like QWidget does to top-level windows)
Most of the QT_NO_OPENGL ifdefs are eliminated all over the place.
Everything with QRhi is unconditional code at compile time, except the
actual initialization.
Having to plumb the widget tlw's shareContext (or, now, the QRhi)
through QWindowPrivate is no longer needed. The old approach does not
scale: to implement composeAndFlush (now rhiFlush) we need more than
just a QRhi object, and this way we no longer pollute everything
starting from the widget level (QWidget's topextra -> QWidgetWindow ->
QWindowPrivate) just to send data around.
The BackingStoreOpenGLSupport interface and the QtGui - QtOpenGL split
is all gone. Instead, there is a QBackingStoreDefaultCompositor in
QtGui which is what the default implementations of composeAndFlush and
toTexture call. (overriding composeAndFlush and co. f.ex. in eglfs
should continue working mostly as-is, apart from adapting to the
texture list changes and getting the native OpenGL texture id out of
the QRhiTexture)
As QQuickWidget is way too complicated to just port as-is, an rhi
manual test (rhiwidget) is introduced as a first step, in ordewr to
exercise a simple, custom render-to-texture widget that does something
using a (not necessarily OpenGL-backed) QRhi and acts as fully
functional QWidget (modeled after QOpenGLWidget). This can also form
the foundation of a potential future QRhiWidget.
It is also possible to force the QRhi-based flushing always,
regardless of the presence of render-to-texture widgets. To exercise
this, set the env.var. QT_WIDGETS_RHI=1. This picks a
platform-specific default, and can be overridden with
QT_WIDGETS_RHI_BACKEND. (in sync with Qt Quick) This can eventually be
extended to query the platform plugin as well to check if the platform
plugin prefers to always do flushes with a 3D API.
QOpenGLWidget should work like before from the user's perspective, while
internally it has to do some things differently to play nice and prevent
regressions with the new rendering architecture. To exercise this
better, the qopenglwidget example gets a new tab-based view (that could
perhaps replace the example's main window later on?). The openglwidget
manual test is made compatible with Qt 6, and gets a counterpart in form
of the dockedopenglwidget manual test, which is a modified version of
the cube example that features dock widgets. This is relevant in
particular because render-to-texture widgets within a QDockWidget has
its own specific quirks, with logic taking this into account, hence
testing is essential.
For existing applications there are two important consequences with
this patch in place:
- Once the rhi-based composition is enabled, it stays active for the
lifetime of the top-level window.
- Dynamically creating and parenting the first render-to-texture
widget to an already created tlw will destroy and recreate the tlw
(and the underlying window). The visible effects of this depend on the
platform. (e.g. the window may disappear and reappear on some,
whereas with other windowing systems it is not noticeable at all -
this is not really different from similar situtions with reparenting
or when moving windows between screens, so should be acceptable in
practice)
- On iOS raster windows are flushed with Metal (and rhi) from now on
(previously this was through OpenGL by making flush() call
composeAndFlush().
Change-Id: Id05bd0f7a26fa845f8b7ad8eedda3b0e78ab7a4e
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2021-10-25 13:21:31 +00:00
|
|
|
GLWidget *w = new GLWidget(nullptr, qRgb(QRandomGenerator::global()->bounded(256),
|
|
|
|
|
QRandomGenerator::global()->bounded(256),
|
|
|
|
|
QRandomGenerator::global()->bounded(256)));
|
2014-09-28 16:58:46 +00:00
|
|
|
m_glWidgets << w;
|
2016-12-20 18:37:37 +00:00
|
|
|
connect(m_timer, &QTimer::timeout, w, QOverload<>::of(&QWidget::update));
|
2014-06-20 09:58:34 +00:00
|
|
|
m_layout->addWidget(w, m_nextY, m_nextX, 1, 1);
|
|
|
|
|
if (m_nextX == 3) {
|
|
|
|
|
m_nextX = 1;
|
|
|
|
|
++m_nextY;
|
|
|
|
|
} else {
|
|
|
|
|
++m_nextX;
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-09-28 16:58:46 +00:00
|
|
|
|
|
|
|
|
void MainWindow::timerUsageChanged(bool enabled)
|
|
|
|
|
{
|
|
|
|
|
if (enabled) {
|
|
|
|
|
m_timer->start();
|
|
|
|
|
} else {
|
|
|
|
|
m_timer->stop();
|
2019-01-01 14:18:57 +00:00
|
|
|
for (QOpenGLWidget *w : qAsConst(m_glWidgets))
|
2014-09-28 16:58:46 +00:00
|
|
|
w->update();
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-06-01 09:44:37 +00:00
|
|
|
|
|
|
|
|
void MainWindow::resizeEvent(QResizeEvent *)
|
|
|
|
|
{
|
|
|
|
|
m_glWidgets[0]->setMinimumSize(size() + QSize(128, 128));
|
|
|
|
|
}
|
Compose render-to-texture widgets through QRhi
QPlatformTextureList holds a QRhiTexture instead of GLuint. A
QPlatformBackingStore now optionally can own a QRhi and a
QRhiSwapChain for the associated window. Non-GL rendering must use
this QRhi everywhere, whereas GL (QOpenGLWidget) can choose to still
rely on resource sharing between contexts. A widget tells that it
wants QRhi and the desired configuration in a new virtual function in
QWidgetPrivate returning a QPlatformBackingStoreRhiConfig. This is
evaluated (among a top-level's all children) upon create() before
creating the repaint manager and the QWidgetWindow.
In QOpenGLWidget what do request is obvious: it will request an
OpenGL-based QRhi. QQuickWidget (or a potential future QRhiWidget)
will be more interesting: it needs to honor the standard Qt Quick
env.vars. and QQuickWindow APIs (or, in whatever way the user
configured the QRhiWidget), and so will set up the config struct
accordingly.
In addition, the rhiconfig and surface type is (re)evaluated when
(re)parenting a widget to a new tlw. If needed, this will now trigger
a destroy - create on the tlw. This should be be safe to do in
setParent. When multiple child widgets report an enabled rhiconfig,
the first one (the first child encountered) wins. So e.g. attempting
to have a QOpenGLWidget and a Vulkan-based QQuickWidget in the same
top-level window will fail one of the widgets (it likely won't
render).
RasterGLSurface is no longer used by widgets. Rather, the appropriate
surface type is chosen.
The rhi support in the backingstore is usable without widgets as well.
To make rhiFlush() functional, one needs to call setRhiConfig() after
creating the QBackingStore. (like QWidget does to top-level windows)
Most of the QT_NO_OPENGL ifdefs are eliminated all over the place.
Everything with QRhi is unconditional code at compile time, except the
actual initialization.
Having to plumb the widget tlw's shareContext (or, now, the QRhi)
through QWindowPrivate is no longer needed. The old approach does not
scale: to implement composeAndFlush (now rhiFlush) we need more than
just a QRhi object, and this way we no longer pollute everything
starting from the widget level (QWidget's topextra -> QWidgetWindow ->
QWindowPrivate) just to send data around.
The BackingStoreOpenGLSupport interface and the QtGui - QtOpenGL split
is all gone. Instead, there is a QBackingStoreDefaultCompositor in
QtGui which is what the default implementations of composeAndFlush and
toTexture call. (overriding composeAndFlush and co. f.ex. in eglfs
should continue working mostly as-is, apart from adapting to the
texture list changes and getting the native OpenGL texture id out of
the QRhiTexture)
As QQuickWidget is way too complicated to just port as-is, an rhi
manual test (rhiwidget) is introduced as a first step, in ordewr to
exercise a simple, custom render-to-texture widget that does something
using a (not necessarily OpenGL-backed) QRhi and acts as fully
functional QWidget (modeled after QOpenGLWidget). This can also form
the foundation of a potential future QRhiWidget.
It is also possible to force the QRhi-based flushing always,
regardless of the presence of render-to-texture widgets. To exercise
this, set the env.var. QT_WIDGETS_RHI=1. This picks a
platform-specific default, and can be overridden with
QT_WIDGETS_RHI_BACKEND. (in sync with Qt Quick) This can eventually be
extended to query the platform plugin as well to check if the platform
plugin prefers to always do flushes with a 3D API.
QOpenGLWidget should work like before from the user's perspective, while
internally it has to do some things differently to play nice and prevent
regressions with the new rendering architecture. To exercise this
better, the qopenglwidget example gets a new tab-based view (that could
perhaps replace the example's main window later on?). The openglwidget
manual test is made compatible with Qt 6, and gets a counterpart in form
of the dockedopenglwidget manual test, which is a modified version of
the cube example that features dock widgets. This is relevant in
particular because render-to-texture widgets within a QDockWidget has
its own specific quirks, with logic taking this into account, hence
testing is essential.
For existing applications there are two important consequences with
this patch in place:
- Once the rhi-based composition is enabled, it stays active for the
lifetime of the top-level window.
- Dynamically creating and parenting the first render-to-texture
widget to an already created tlw will destroy and recreate the tlw
(and the underlying window). The visible effects of this depend on the
platform. (e.g. the window may disappear and reappear on some,
whereas with other windowing systems it is not noticeable at all -
this is not really different from similar situtions with reparenting
or when moving windows between screens, so should be acceptable in
practice)
- On iOS raster windows are flushed with Metal (and rhi) from now on
(previously this was through OpenGL by making flush() call
composeAndFlush().
Change-Id: Id05bd0f7a26fa845f8b7ad8eedda3b0e78ab7a4e
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2021-10-25 13:21:31 +00:00
|
|
|
|
|
|
|
|
void MainWindow::showNewWindow()
|
|
|
|
|
{
|
|
|
|
|
QTabWidget *tabs = new QTabWidget;
|
|
|
|
|
tabs->resize(800, 600);
|
|
|
|
|
|
|
|
|
|
QToolButton *tb = new QToolButton;
|
|
|
|
|
tb->setText(QLatin1String("+"));
|
|
|
|
|
tabs->addTab(new QLabel(QLatin1String("Add OpenGL widgets with +")), QString());
|
|
|
|
|
tabs->setTabEnabled(0, false);
|
|
|
|
|
tabs->tabBar()->setTabButton(0, QTabBar::RightSide, tb);
|
|
|
|
|
tabs->tabBar()->setTabsClosable(true);
|
|
|
|
|
QObject::connect(tabs->tabBar(), &QTabBar::tabCloseRequested, tabs, [tabs](int index) {
|
|
|
|
|
tabs->widget(index)->deleteLater();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
const QString msgToTopLevel = QLatin1String("Break out to top-level window");
|
|
|
|
|
const QString msgFromTopLevel = QLatin1String("Move back under tab widget");
|
|
|
|
|
|
|
|
|
|
QObject::connect(tb, &QAbstractButton::clicked, tabs, [=] {
|
|
|
|
|
GLWidget *glwidget = new GLWidget(nullptr, Qt::blue);
|
|
|
|
|
glwidget->resize(tabs->size());
|
|
|
|
|
glwidget->setWindowTitle(QString::asprintf("QOpenGLWidget %p", glwidget));
|
|
|
|
|
|
|
|
|
|
QPushButton *btn = new QPushButton(msgToTopLevel, glwidget);
|
|
|
|
|
connect(btn, &QPushButton::clicked, glwidget, [=] {
|
|
|
|
|
if (glwidget->parent()) {
|
|
|
|
|
glwidget->setAttribute(Qt::WA_DeleteOnClose, true);
|
|
|
|
|
glwidget->setParent(nullptr);
|
|
|
|
|
glwidget->show();
|
|
|
|
|
btn->setText(msgFromTopLevel);
|
|
|
|
|
} else {
|
|
|
|
|
glwidget->setAttribute(Qt::WA_DeleteOnClose, false);
|
|
|
|
|
tabs->addTab(glwidget, glwidget->windowTitle());
|
|
|
|
|
btn->setText(msgToTopLevel);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
tabs->setCurrentIndex(tabs->addTab(glwidget, glwidget->windowTitle()));
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
tabs->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
|
tabs->show();
|
|
|
|
|
}
|
