86876744f0
Revert surfacePixelSize() to be a getter only. With Metal this will mean returning the "live" layer size (and so not the layer.drawableSize), which is in line with what we expect with other backends. Instead, we leave it to the swapchain's buildOrResize() to "commit" the size by setting drawableSize on the layer. With typical application or Qt Quick logic this ensures that layer.drawableSize is set once and stays static until we get to process the next resize - on the rendering thread. This of course would still mean that there was a race when a client queries surfacePixelSize() to set the depth-stencil buffer size that is associated with a swapchain. (because that must happen before calling buildOrResize() according to the current semantics) That can however be solved in a quite elegant way, it turns out, because we already have a flag that indicates if a QRhiRenderBuffer is used in combination with (and only in combination with) a swapchain. If we simply say that setting the UsedWithSwapChainOnly flag provides automatic sizing as well (so no setPixelSize() call is needed), clients can simply get rid of the problematic surfacePixelSize() query and everything works. Task-number: QTBUG-78641 Change-Id: Ib1bfc9ef8531bcce033d1f1e5d4d5b4984d6d69f Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
641 lines
19 KiB
C++
641 lines
19 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2018 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the examples of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:BSD$
|
|
** 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:
|
|
**
|
|
** "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.
|
|
** * 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.
|
|
**
|
|
**
|
|
** 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 <QApplication>
|
|
#include <QWidget>
|
|
#include <QLabel>
|
|
#include <QPlainTextEdit>
|
|
#include <QPushButton>
|
|
#include <QCheckBox>
|
|
#include <QVBoxLayout>
|
|
|
|
#include <QCommandLineParser>
|
|
#include <QWindow>
|
|
#include <QPlatformSurfaceEvent>
|
|
#include <QElapsedTimer>
|
|
|
|
#include <QtGui/private/qshader_p.h>
|
|
#include <QFile>
|
|
|
|
#ifndef QT_NO_OPENGL
|
|
#include <QtGui/private/qrhigles2_p.h>
|
|
#include <QOffscreenSurface>
|
|
#endif
|
|
|
|
#if QT_CONFIG(vulkan)
|
|
#include <QLoggingCategory>
|
|
#include <QtGui/private/qrhivulkan_p.h>
|
|
#endif
|
|
|
|
#ifdef Q_OS_WIN
|
|
#include <QtGui/private/qrhid3d11_p.h>
|
|
#endif
|
|
|
|
#ifdef Q_OS_DARWIN
|
|
#include <QtGui/private/qrhimetal_p.h>
|
|
#endif
|
|
|
|
enum GraphicsApi
|
|
{
|
|
OpenGL,
|
|
Vulkan,
|
|
D3D11,
|
|
Metal
|
|
};
|
|
|
|
static GraphicsApi graphicsApi;
|
|
|
|
static QString graphicsApiName()
|
|
{
|
|
switch (graphicsApi) {
|
|
case OpenGL:
|
|
return QLatin1String("OpenGL 2.x");
|
|
case Vulkan:
|
|
return QLatin1String("Vulkan");
|
|
case D3D11:
|
|
return QLatin1String("Direct3D 11");
|
|
case Metal:
|
|
return QLatin1String("Metal");
|
|
default:
|
|
break;
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
static struct {
|
|
#if QT_CONFIG(vulkan)
|
|
QVulkanInstance *instance = nullptr;
|
|
#endif
|
|
QRhi *r = nullptr;
|
|
#ifndef QT_NO_OPENGL
|
|
QOffscreenSurface *fallbackSurface = nullptr;
|
|
#endif
|
|
} r;
|
|
|
|
void createRhi()
|
|
{
|
|
#ifndef QT_NO_OPENGL
|
|
if (graphicsApi == OpenGL) {
|
|
r.fallbackSurface = QRhiGles2InitParams::newFallbackSurface();
|
|
QRhiGles2InitParams params;
|
|
params.fallbackSurface = r.fallbackSurface;
|
|
//params.window = this;
|
|
r.r = QRhi::create(QRhi::OpenGLES2, ¶ms);
|
|
}
|
|
#endif
|
|
|
|
#if QT_CONFIG(vulkan)
|
|
if (graphicsApi == Vulkan) {
|
|
QRhiVulkanInitParams params;
|
|
params.inst = r.instance;
|
|
//params.window = this;
|
|
r.r = QRhi::create(QRhi::Vulkan, ¶ms);
|
|
}
|
|
#endif
|
|
|
|
#ifdef Q_OS_WIN
|
|
if (graphicsApi == D3D11) {
|
|
QRhiD3D11InitParams params;
|
|
params.enableDebugLayer = true;
|
|
r.r = QRhi::create(QRhi::D3D11, ¶ms);
|
|
}
|
|
#endif
|
|
|
|
#ifdef Q_OS_DARWIN
|
|
if (graphicsApi == Metal) {
|
|
QRhiMetalInitParams params;
|
|
r.r = QRhi::create(QRhi::Metal, ¶ms);
|
|
}
|
|
#endif
|
|
|
|
if (!r.r)
|
|
qFatal("Failed to create RHI backend");
|
|
}
|
|
|
|
void destroyRhi()
|
|
{
|
|
delete r.r;
|
|
|
|
#ifndef QT_NO_OPENGL
|
|
delete r.fallbackSurface;
|
|
#endif
|
|
}
|
|
|
|
struct {
|
|
QVector<QWindow *> windows;
|
|
|
|
QRhiBuffer *vbuf = nullptr;
|
|
QRhiBuffer *ubuf = nullptr;
|
|
QRhiShaderResourceBindings *srb = nullptr;
|
|
QRhiGraphicsPipeline *ps = nullptr;
|
|
QRhiResourceUpdateBatch *initialUpdates = nullptr;
|
|
} d;
|
|
|
|
static float vertexData[] = {
|
|
0.0f, 0.5f, 1.0f, 0.0f, 0.0f,
|
|
-0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
|
|
0.5f, -0.5f, 0.0f, 0.0f, 1.0f,
|
|
};
|
|
|
|
static QShader getShader(const QString &name)
|
|
{
|
|
QFile f(name);
|
|
if (f.open(QIODevice::ReadOnly))
|
|
return QShader::fromSerialized(f.readAll());
|
|
|
|
return QShader();
|
|
}
|
|
|
|
// can use just one rpd from whichever window comes first since they are
|
|
// actually compatible due to all windows using the same config (have
|
|
// depth-stencil, sample count 1, same format). this means the same pso can be
|
|
// reused too.
|
|
void ensureSharedResources(QRhiRenderPassDescriptor *rp)
|
|
{
|
|
if (!d.vbuf) {
|
|
d.vbuf = r.r->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(vertexData));
|
|
d.vbuf->build();
|
|
d.initialUpdates = r.r->nextResourceUpdateBatch();
|
|
d.initialUpdates->uploadStaticBuffer(d.vbuf, vertexData);
|
|
}
|
|
|
|
if (!d.ubuf) {
|
|
d.ubuf = r.r->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, 68);
|
|
d.ubuf->build();
|
|
}
|
|
|
|
if (!d.srb) {
|
|
d.srb = r.r->newShaderResourceBindings();
|
|
d.srb->setBindings({
|
|
QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage, d.ubuf)
|
|
});
|
|
d.srb->build();
|
|
}
|
|
|
|
if (!d.ps) {
|
|
d.ps = r.r->newGraphicsPipeline();
|
|
|
|
QRhiGraphicsPipeline::TargetBlend premulAlphaBlend;
|
|
premulAlphaBlend.enable = true;
|
|
d.ps->setTargetBlends({ premulAlphaBlend });
|
|
|
|
const QShader vs = getShader(QLatin1String(":/color.vert.qsb"));
|
|
if (!vs.isValid())
|
|
qFatal("Failed to load shader pack (vertex)");
|
|
const QShader fs = getShader(QLatin1String(":/color.frag.qsb"));
|
|
if (!fs.isValid())
|
|
qFatal("Failed to load shader pack (fragment)");
|
|
|
|
d.ps->setShaderStages({
|
|
{ QRhiShaderStage::Vertex, vs },
|
|
{ QRhiShaderStage::Fragment, fs }
|
|
});
|
|
|
|
QRhiVertexInputLayout inputLayout;
|
|
inputLayout.setBindings({
|
|
{ 5 * sizeof(float) }
|
|
});
|
|
inputLayout.setAttributes({
|
|
{ 0, 0, QRhiVertexInputAttribute::Float2, 0 },
|
|
{ 0, 1, QRhiVertexInputAttribute::Float3, 2 * sizeof(float) }
|
|
});
|
|
|
|
d.ps->setVertexInputLayout(inputLayout);
|
|
d.ps->setShaderResourceBindings(d.srb);
|
|
d.ps->setRenderPassDescriptor(rp);
|
|
|
|
d.ps->build();
|
|
}
|
|
}
|
|
|
|
void destroySharedResources()
|
|
{
|
|
delete d.ps;
|
|
d.ps = nullptr;
|
|
|
|
delete d.srb;
|
|
d.srb = nullptr;
|
|
|
|
delete d.vbuf;
|
|
d.vbuf = nullptr;
|
|
|
|
delete d.ubuf;
|
|
d.ubuf = nullptr;
|
|
}
|
|
|
|
class Window : public QWindow
|
|
{
|
|
public:
|
|
Window(const QString &title, const QColor &bgColor, int axis, bool noVSync);
|
|
~Window();
|
|
|
|
protected:
|
|
void init();
|
|
void releaseResources();
|
|
void resizeSwapChain();
|
|
void releaseSwapChain();
|
|
void render();
|
|
|
|
void exposeEvent(QExposeEvent *) override;
|
|
bool event(QEvent *) override;
|
|
|
|
QColor m_bgColor;
|
|
int m_rotationAxis;
|
|
bool m_noVSync;
|
|
|
|
bool m_running = false;
|
|
bool m_notExposed = false;
|
|
bool m_newlyExposed = false;
|
|
|
|
QMatrix4x4 m_proj;
|
|
QVector<QRhiResource *> m_releasePool;
|
|
|
|
bool m_hasSwapChain = false;
|
|
QRhiSwapChain *m_sc = nullptr;
|
|
QRhiRenderBuffer *m_ds = nullptr;
|
|
QRhiRenderPassDescriptor *m_rp = nullptr;
|
|
|
|
float m_rotation = 0;
|
|
float m_opacity = 1;
|
|
int m_opacityDir = -1;
|
|
};
|
|
|
|
Window::Window(const QString &title, const QColor &bgColor, int axis, bool noVSync)
|
|
: m_bgColor(bgColor),
|
|
m_rotationAxis(axis),
|
|
m_noVSync(noVSync)
|
|
{
|
|
switch (graphicsApi) {
|
|
case OpenGL:
|
|
{
|
|
#if QT_CONFIG(opengl)
|
|
setSurfaceType(OpenGLSurface);
|
|
QSurfaceFormat fmt = QRhiGles2InitParams::adjustedFormat(); // default + depth/stencil
|
|
fmt.setSwapInterval(noVSync ? 0 : 1); // + swap interval
|
|
setFormat(fmt);
|
|
#endif
|
|
}
|
|
break;
|
|
case Vulkan:
|
|
#if QT_CONFIG(vulkan)
|
|
setSurfaceType(VulkanSurface);
|
|
setVulkanInstance(r.instance);
|
|
#endif
|
|
break;
|
|
case D3D11:
|
|
setSurfaceType(OpenGLSurface); // not a typo
|
|
break;
|
|
case Metal:
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
|
|
setSurfaceType(MetalSurface);
|
|
#endif
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
resize(800, 600);
|
|
setTitle(title);
|
|
}
|
|
|
|
Window::~Window()
|
|
{
|
|
releaseResources();
|
|
}
|
|
|
|
void Window::exposeEvent(QExposeEvent *)
|
|
{
|
|
// initialize and start rendering when the window becomes usable for graphics purposes
|
|
if (isExposed() && !m_running) {
|
|
m_running = true;
|
|
init();
|
|
resizeSwapChain();
|
|
}
|
|
|
|
// stop pushing frames when not exposed (or size is 0)
|
|
if ((!isExposed() || (m_hasSwapChain && m_sc->surfacePixelSize().isEmpty())) && m_running)
|
|
m_notExposed = true;
|
|
|
|
// continue when exposed again and the surface has a valid size.
|
|
// note that the surface size can be (0, 0) even though size() reports a valid one...
|
|
if (isExposed() && m_running && m_notExposed && !m_sc->surfacePixelSize().isEmpty()) {
|
|
m_notExposed = false;
|
|
m_newlyExposed = true;
|
|
}
|
|
|
|
// always render a frame on exposeEvent() (when exposed) in order to update
|
|
// immediately on window resize.
|
|
if (isExposed() && !m_sc->surfacePixelSize().isEmpty())
|
|
render();
|
|
}
|
|
|
|
bool Window::event(QEvent *e)
|
|
{
|
|
switch (e->type()) {
|
|
case QEvent::UpdateRequest:
|
|
render();
|
|
break;
|
|
|
|
case QEvent::PlatformSurface:
|
|
// this is the proper time to tear down the swapchain (while the native window and surface are still around)
|
|
if (static_cast<QPlatformSurfaceEvent *>(e)->surfaceEventType() == QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed)
|
|
releaseSwapChain();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QWindow::event(e);
|
|
}
|
|
|
|
void Window::init()
|
|
{
|
|
m_sc = r.r->newSwapChain();
|
|
m_ds = r.r->newRenderBuffer(QRhiRenderBuffer::DepthStencil,
|
|
QSize(),
|
|
1,
|
|
QRhiRenderBuffer::UsedWithSwapChainOnly);
|
|
m_releasePool << m_ds;
|
|
m_sc->setWindow(this);
|
|
m_sc->setDepthStencil(m_ds);
|
|
if (m_noVSync)
|
|
m_sc->setFlags(QRhiSwapChain::NoVSync);
|
|
|
|
m_rp = m_sc->newCompatibleRenderPassDescriptor();
|
|
m_releasePool << m_rp;
|
|
m_sc->setRenderPassDescriptor(m_rp);
|
|
|
|
ensureSharedResources(m_rp);
|
|
}
|
|
|
|
void Window::releaseResources()
|
|
{
|
|
qDeleteAll(m_releasePool);
|
|
m_releasePool.clear();
|
|
|
|
delete m_sc;
|
|
m_sc = nullptr;
|
|
}
|
|
|
|
void Window::resizeSwapChain()
|
|
{
|
|
m_hasSwapChain = m_sc->buildOrResize();
|
|
|
|
const QSize outputSize = m_sc->currentPixelSize();
|
|
m_proj = r.r->clipSpaceCorrMatrix();
|
|
m_proj.perspective(45.0f, outputSize.width() / (float) outputSize.height(), 0.01f, 1000.0f);
|
|
m_proj.translate(0, 0, -4);
|
|
}
|
|
|
|
void Window::releaseSwapChain()
|
|
{
|
|
if (m_hasSwapChain) {
|
|
m_hasSwapChain = false;
|
|
m_sc->release();
|
|
}
|
|
}
|
|
|
|
void Window::render()
|
|
{
|
|
if (!m_hasSwapChain || m_notExposed)
|
|
return;
|
|
|
|
// If the window got resized or got newly exposed, resize the swapchain.
|
|
// (the newly-exposed case is not actually required by some
|
|
// platforms/backends, but f.ex. Vulkan on Windows seems to need it)
|
|
if (m_sc->currentPixelSize() != m_sc->surfacePixelSize() || m_newlyExposed) {
|
|
resizeSwapChain();
|
|
if (!m_hasSwapChain)
|
|
return;
|
|
m_newlyExposed = false;
|
|
}
|
|
|
|
QRhi::FrameOpResult result = r.r->beginFrame(m_sc);
|
|
if (result == QRhi::FrameOpSwapChainOutOfDate) {
|
|
resizeSwapChain();
|
|
if (!m_hasSwapChain)
|
|
return;
|
|
result = r.r->beginFrame(m_sc);
|
|
}
|
|
if (result != QRhi::FrameOpSuccess) {
|
|
requestUpdate();
|
|
return;
|
|
}
|
|
|
|
QRhiCommandBuffer *cb = m_sc->currentFrameCommandBuffer();
|
|
const QSize outputSizeInPixels = m_sc->currentPixelSize();
|
|
|
|
QRhiResourceUpdateBatch *u = r.r->nextResourceUpdateBatch();
|
|
if (d.initialUpdates) {
|
|
u->merge(d.initialUpdates);
|
|
d.initialUpdates->release();
|
|
d.initialUpdates = nullptr;
|
|
}
|
|
|
|
m_rotation += 1.0f;
|
|
QMatrix4x4 mvp = m_proj;
|
|
mvp.rotate(m_rotation, m_rotationAxis == 0 ? 1 : 0, m_rotationAxis == 1 ? 1 : 0, m_rotationAxis == 2 ? 1 : 0);
|
|
u->updateDynamicBuffer(d.ubuf, 0, 64, mvp.constData());
|
|
m_opacity += m_opacityDir * 0.005f;
|
|
if (m_opacity < 0.0f || m_opacity > 1.0f) {
|
|
m_opacityDir *= -1;
|
|
m_opacity = qBound(0.0f, m_opacity, 1.0f);
|
|
}
|
|
u->updateDynamicBuffer(d.ubuf, 64, 4, &m_opacity);
|
|
|
|
cb->beginPass(m_sc->currentFrameRenderTarget(),
|
|
QColor::fromRgbF(float(m_bgColor.redF()), float(m_bgColor.greenF()), float(m_bgColor.blueF()), 1.0f),
|
|
{ 1.0f, 0 },
|
|
u);
|
|
|
|
cb->setGraphicsPipeline(d.ps);
|
|
cb->setViewport({ 0, 0, float(outputSizeInPixels.width()), float(outputSizeInPixels.height()) });
|
|
cb->setShaderResources();
|
|
const QRhiCommandBuffer::VertexInput vbufBinding(d.vbuf, 0);
|
|
cb->setVertexInput(0, 1, &vbufBinding);
|
|
cb->draw(3);
|
|
|
|
cb->endPass();
|
|
|
|
r.r->endFrame(m_sc);
|
|
|
|
requestUpdate();
|
|
}
|
|
|
|
void createWindow(bool noVSync)
|
|
{
|
|
static QColor colors[] = { Qt::red, Qt::green, Qt::blue, Qt::yellow, Qt::cyan, Qt::gray };
|
|
const int n = d.windows.count();
|
|
d.windows.append(new Window(QString::asprintf("Window #%d%s", n, noVSync ? " (no vsync)" : ""), colors[n % 6], n % 3, noVSync));
|
|
d.windows.last()->show();
|
|
}
|
|
|
|
void closeWindow()
|
|
{
|
|
delete d.windows.takeLast();
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
|
|
QApplication app(argc, argv);
|
|
|
|
#if defined(Q_OS_WIN)
|
|
graphicsApi = D3D11;
|
|
#elif defined(Q_OS_DARWIN)
|
|
graphicsApi = Metal;
|
|
#elif QT_CONFIG(vulkan)
|
|
graphicsApi = Vulkan;
|
|
#else
|
|
graphicsApi = OpenGL;
|
|
#endif
|
|
|
|
QCommandLineParser cmdLineParser;
|
|
cmdLineParser.addHelpOption();
|
|
QCommandLineOption glOption({ "g", "opengl" }, QLatin1String("OpenGL (2.x)"));
|
|
cmdLineParser.addOption(glOption);
|
|
QCommandLineOption vkOption({ "v", "vulkan" }, QLatin1String("Vulkan"));
|
|
cmdLineParser.addOption(vkOption);
|
|
QCommandLineOption d3dOption({ "d", "d3d11" }, QLatin1String("Direct3D 11"));
|
|
cmdLineParser.addOption(d3dOption);
|
|
QCommandLineOption mtlOption({ "m", "metal" }, QLatin1String("Metal"));
|
|
cmdLineParser.addOption(mtlOption);
|
|
cmdLineParser.process(app);
|
|
if (cmdLineParser.isSet(glOption))
|
|
graphicsApi = OpenGL;
|
|
if (cmdLineParser.isSet(vkOption))
|
|
graphicsApi = Vulkan;
|
|
if (cmdLineParser.isSet(d3dOption))
|
|
graphicsApi = D3D11;
|
|
if (cmdLineParser.isSet(mtlOption))
|
|
graphicsApi = Metal;
|
|
|
|
qDebug("Selected graphics API is %s", qPrintable(graphicsApiName()));
|
|
qDebug("This is a multi-api example, use command line arguments to override:\n%s", qPrintable(cmdLineParser.helpText()));
|
|
|
|
#if QT_CONFIG(vulkan)
|
|
r.instance = new QVulkanInstance;
|
|
if (graphicsApi == Vulkan) {
|
|
#ifndef Q_OS_ANDROID
|
|
r.instance->setLayers({ "VK_LAYER_LUNARG_standard_validation" });
|
|
#else
|
|
r.instance->setLayers(QByteArrayList()
|
|
<< "VK_LAYER_GOOGLE_threading"
|
|
<< "VK_LAYER_LUNARG_parameter_validation"
|
|
<< "VK_LAYER_LUNARG_object_tracker"
|
|
<< "VK_LAYER_LUNARG_core_validation"
|
|
<< "VK_LAYER_LUNARG_image"
|
|
<< "VK_LAYER_LUNARG_swapchain"
|
|
<< "VK_LAYER_GOOGLE_unique_objects");
|
|
#endif
|
|
if (!r.instance->create()) {
|
|
qWarning("Failed to create Vulkan instance, switching to OpenGL");
|
|
graphicsApi = OpenGL;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
createRhi();
|
|
|
|
int winCount = 0;
|
|
QWidget w;
|
|
w.resize(800, 600);
|
|
w.setWindowTitle(QCoreApplication::applicationName() + QLatin1String(" - ") + graphicsApiName());
|
|
QVBoxLayout *layout = new QVBoxLayout(&w);
|
|
|
|
QPlainTextEdit *info = new QPlainTextEdit(
|
|
QLatin1String("This application tests rendering with the same QRhi instance (and so the same Vulkan/Metal/D3D device or OpenGL context) "
|
|
"to multiple windows via multiple QRhiSwapChain objects, from the same one thread. Some resources are shared across all windows.\n"
|
|
"\nNote that the behavior may differ depending on the underlying graphics API implementation and the number of windows. "
|
|
"One challenge here is the vsync throttling: with the default vsync/fifo presentation mode the behavior may differ between "
|
|
"platforms, drivers, and APIs as we present different swapchains' images in a row on the same thread. As a potential solution, "
|
|
"setting NoVSync on the second, third, and later window swapchains is offered as an option.\n"
|
|
"\n\nUsing API: ") + graphicsApiName());
|
|
info->setReadOnly(true);
|
|
layout->addWidget(info);
|
|
QLabel *label = new QLabel(QLatin1String("Window count: 0"));
|
|
layout->addWidget(label);
|
|
QCheckBox *vsCb = new QCheckBox(QLatin1String("Set NoVSync on all swapchains except the first"));
|
|
vsCb->setChecked(false);
|
|
layout->addWidget(vsCb);
|
|
QPushButton *btn = new QPushButton(QLatin1String("New window"));
|
|
QObject::connect(btn, &QPushButton::clicked, btn, [label, vsCb, &winCount] {
|
|
winCount += 1;
|
|
label->setText(QString::asprintf("Window count: %d", winCount));
|
|
const bool noVSync = vsCb->isChecked() && winCount > 1;
|
|
createWindow(noVSync);
|
|
});
|
|
layout->addWidget(btn);
|
|
btn = new QPushButton(QLatin1String("Close window"));
|
|
QObject::connect(btn, &QPushButton::clicked, btn, [label, &winCount] {
|
|
if (winCount > 0) {
|
|
winCount -= 1;
|
|
label->setText(QString::asprintf("Window count: %d", winCount));
|
|
closeWindow();
|
|
}
|
|
});
|
|
layout->addWidget(btn);
|
|
w.show();
|
|
|
|
int result = app.exec();
|
|
|
|
qDeleteAll(d.windows);
|
|
|
|
destroySharedResources();
|
|
destroyRhi();
|
|
|
|
#if QT_CONFIG(vulkan)
|
|
delete r.instance;
|
|
#endif
|
|
|
|
return result;
|
|
}
|