Add the graphics api independent scenegraph port

Opt in via environment variables:
QSG_RHI=1 -> enable using QRhi instead of GL
QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default
(the default is d3d11 on Windows, metal on Mac, gl elsewhere)

Or force a given rhi backend via the existing
QQuickWindow::setSceneGraphBackend().

Otherwise the default behavior is the same as before, the rhi code path
is never active by default.

-no-opengl builds are supported in the sense that they work and default
to the software backend. However, the rhi code path cannot currently be
used in such builds, even though QRhi from qtbase is fully functional
with Vulkan, D3D, or Metal even when qtbase was configured with
-no-opengl. This cannot be utilized by Quick atm due to OpenGL usage
being all over the place in the sources corresponding to the default
backend, and those host the rhi code path as well. This will be cleaned up
hopefully in Qt 6, with the removal all direct OpenGL usage.

Other env.vars.:
QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer
(assuming the system is set up for this)
QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect
QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too)
QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index
QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index
QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both
merged/unmerged, convert when needed - with some rhi backends this is
implicit)
QSG_RENDER_LOOP -> to override the render loop as usual. The default
with RHI is threaded for Metal, threaded for Vulkan on Windows, basic
for Vulkan on Linux and Android (to be checked later), while the existing
rules apply for OpenGL.

Not supported when running with QRhi:
  - particles
  - compressed atlases (though this is transparent to the apps)
  - QSGRenderNode
  - QQuickRenderControl
  - QQuickFramebufferObject
  - certain QQuickWindow functionality that depends directly on OpenGL
  - anisotropic filtering for textures
  - native text may lack some gamma correction
  - QSGEngine applicability unclear
  - some QML profiler logs may be incorrect or irrelevant

Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

18 files changed, 389 insertions, 53 deletions

diff --git a/src/quick/items/context2d/qquickcanvasitem.cpp b/src/quick/items/context2d/qquickcanvasitem.cpp
index 188e74cd89..ac4e86d8da 100644
--- a/src/quick/items/context2d/qquickcanvasitem.cpp
+++ b/src/quick/items/context2d/qquickcanvasitem.cpp
@@ -769,7 +769,8 @@ QSGNode *QQuickCanvasItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData
 
     QSGInternalImageNode *node = static_cast<QSGInternalImageNode *>(oldNode);
     if (!node) {
-        node = QQuickWindowPrivate::get(window())->context->sceneGraphContext()->createInternalImageNode();
+        QSGRenderContext *rc = QQuickWindowPrivate::get(window())->context;
+        node = rc->sceneGraphContext()->createInternalImageNode(rc);
         d->node = node;
     }
 
diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp
index 0f104a122f..48e5a4d4a2 100644
--- a/src/quick/items/context2d/qquickcontext2d.cpp
+++ b/src/quick/items/context2d/qquickcontext2d.cpp
@@ -4290,7 +4290,8 @@ void QQuickContext2D::init(QQuickCanvasItem *canvasItem, const QVariantMap &args
         m_renderTarget = QQuickCanvasItem::Image;
     }
 
-    // Disable Framebuffer Object based rendering when not running with OpenGL
+    // Disable Framebuffer Object based rendering when not running with OpenGL.
+    // Same goes for the RHI based code path (regardless of the backend in use).
     if (m_renderTarget == QQuickCanvasItem::FramebufferObject) {
         QSGRendererInterface *rif = canvasItem->window()->rendererInterface();
         if (rif && rif->graphicsApi() != QSGRendererInterface::OpenGL)
diff --git a/src/quick/items/context2d/qquickcontext2dtexture.cpp b/src/quick/items/context2d/qquickcontext2dtexture.cpp
index a97eab34d2..0ebd1a66c9 100644
--- a/src/quick/items/context2d/qquickcontext2dtexture.cpp
+++ b/src/quick/items/context2d/qquickcontext2dtexture.cpp
@@ -41,7 +41,7 @@
 #include "qquickcontext2dtile_p.h"
 #include "qquickcanvasitem_p.h"
 #include <private/qquickitem_p.h>
-#include <QtQuick/private/qsgtexture_p.h>
+#include <QtQuick/private/qsgplaintexture_p.h>
 #include "qquickcontext2dcommandbuffer_p.h"
 #include <QOpenGLPaintDevice>
 #if QT_CONFIG(opengl)
diff --git a/src/quick/items/qquickborderimage.cpp b/src/quick/items/qquickborderimage.cpp
index b840328184..c53a39ca09 100644
--- a/src/quick/items/qquickborderimage.cpp
+++ b/src/quick/items/qquickborderimage.cpp
@@ -647,7 +647,7 @@ QSGNode *QQuickBorderImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeDat
     bool updatePixmap = d->pixmapChanged;
     d->pixmapChanged = false;
     if (!node) {
-        node = d->sceneGraphContext()->createInternalImageNode();
+        node = d->sceneGraphContext()->createInternalImageNode(d->sceneGraphRenderContext());
         updatePixmap = true;
     }
 
diff --git a/src/quick/items/qquickgenericshadereffect.cpp b/src/quick/items/qquickgenericshadereffect.cpp
index 3e7eda28eb..1d71555849 100644
--- a/src/quick/items/qquickgenericshadereffect.cpp
+++ b/src/quick/items/qquickgenericshadereffect.cpp
@@ -44,11 +44,11 @@
 
 QT_BEGIN_NAMESPACE
 
-// The generic shader effect is used when the scenegraph backend indicates
-// SupportsShaderEffectNode. This, unlike the monolithic and interconnected (e.g.
-// with particles) OpenGL variant, passes most of the work to a scenegraph node
-// created via the adaptation layer, thus allowing different implementation in
-// the backends.
+// The generic shader effect is used whenever on the RHI code path, or when the
+// scenegraph backend indicates SupportsShaderEffectNode. This, unlike the
+// monolithic and interconnected (e.g. with particles) OpenGL variant, passes
+// most of the work to a scenegraph node created via the adaptation layer, thus
+// allowing different implementation in the backends.
 
 QQuickGenericShaderEffect::QQuickGenericShaderEffect(QQuickShaderEffect *item, QObject *parent)
     : QObject(parent)
@@ -254,6 +254,10 @@ QSGNode *QQuickGenericShaderEffect::handleUpdatePaintNode(QSGNode *oldNode, QQui
     if (!node) {
         QSGRenderContext *rc = QQuickWindowPrivate::get(m_item->window())->context;
         node = rc->sceneGraphContext()->createShaderEffectNode(rc, mgr);
+        if (!node) {
+            qWarning("No shader effect node");
+            return nullptr;
+        }
         m_dirty = QSGShaderEffectNode::DirtyShaderAll;
     }
 
@@ -445,7 +449,7 @@ bool QQuickGenericShaderEffect::updateShader(Shader shaderType, const QByteArray
             // provided and monitored like with an application-provided shader.
             QSGGuiThreadShaderEffectManager::ShaderInfo::Variable v;
             v.name = QByteArrayLiteral("source");
-            v.bindPoint = 0;
+            v.bindPoint = 0; // fake
             v.type = texturesSeparate ? QSGGuiThreadShaderEffectManager::ShaderInfo::Texture
                                       : QSGGuiThreadShaderEffectManager::ShaderInfo::Sampler;
             m_shaders[shaderType].shaderInfo.variables.append(v);
@@ -559,7 +563,7 @@ QT_WARNING_POP
         } else {
             // Do not warn for dynamic properties.
             if (!m_item->property(v.name.constData()).isValid())
-                qWarning("ShaderEffect: '%s' does not have a matching property!", v.name.constData());
+                qWarning("ShaderEffect: '%s' does not have a matching property", v.name.constData());
         }
 
         vd.value = m_item->property(v.name.constData());
diff --git a/src/quick/items/qquickgraphicsinfo.cpp b/src/quick/items/qquickgraphicsinfo.cpp
index cd1012c690..8f6f4386fb 100644
--- a/src/quick/items/qquickgraphicsinfo.cpp
+++ b/src/quick/items/qquickgraphicsinfo.cpp
@@ -96,6 +96,12 @@ QQuickGraphicsInfo *QQuickGraphicsInfo::qmlAttachedProperties(QObject *object)
     \li GraphicsInfo.Software - Qt Quick's software renderer based on QPainter with the raster paint engine
     \li GraphicsInfo.OpenGL - OpenGL or OpenGL ES
     \li GraphicsInfo.Direct3D12 - Direct3D 12
+    \li GraphicsInfo.OpenVG - OpenVG
+    \li GraphicsInfo.OpenGLRhi - OpenGL on top of QRhi, a graphics abstraction layer
+    \li GraphicsInfo.Direct3D11Rhi - Direct3D 11 on top of QRhi, a graphics abstraction layer
+    \li GraphicsInfo.VulkanRhi - Vulkan on top of QRhi, a graphics abstraction layer
+    \li GraphicsInfo.MetalRhi - Metal on top of QRhi, a graphics abstraction layer
+    \li GraphicsInfo.NullRhi - Null (no output) on top of QRhi, a graphics abstraction layer
     \endlist
  */
 
@@ -109,6 +115,7 @@ QQuickGraphicsInfo *QQuickGraphicsInfo::qmlAttachedProperties(QObject *object)
     \li GraphicsInfo.UnknownShadingLanguage - Not yet known due to no window and scenegraph associated
     \li GraphicsInfo.GLSL - GLSL or GLSL ES
     \li GraphicsInfo.HLSL - HLSL
+    \li GraphicsInfo.RhiShader - QShader
     \endlist
 
     \note The value is only up-to-date once the item is associated with a
diff --git a/src/quick/items/qquickgraphicsinfo_p.h b/src/quick/items/qquickgraphicsinfo_p.h
index 9ef7bacb3e..f0a18c29cc 100644
--- a/src/quick/items/qquickgraphicsinfo_p.h
+++ b/src/quick/items/qquickgraphicsinfo_p.h
@@ -80,14 +80,21 @@ public:
         Unknown = QSGRendererInterface::Unknown,
         Software = QSGRendererInterface::Software,
         OpenGL = QSGRendererInterface::OpenGL,
-        Direct3D12 = QSGRendererInterface::Direct3D12
+        Direct3D12 = QSGRendererInterface::Direct3D12,
+        OpenVG = QSGRendererInterface::OpenVG,
+        OpenGLRhi = QSGRendererInterface::OpenGLRhi,
+        Direct3D11Rhi = QSGRendererInterface::Direct3D11Rhi,
+        VulkanRhi = QSGRendererInterface::VulkanRhi,
+        MetalRhi = QSGRendererInterface::MetalRhi,
+        NullRhi = QSGRendererInterface::NullRhi
     };
     Q_ENUM(GraphicsApi)
 
     enum ShaderType {
         UnknownShadingLanguage = QSGRendererInterface::UnknownShadingLanguage,
         GLSL = QSGRendererInterface::GLSL,
-        HLSL = QSGRendererInterface::HLSL
+        HLSL = QSGRendererInterface::HLSL,
+        RhiShader = QSGRendererInterface::RhiShader
     };
     Q_ENUM(ShaderType)
 
diff --git a/src/quick/items/qquickimage.cpp b/src/quick/items/qquickimage.cpp
index 4a0936b4d5..dfbe271606 100644
--- a/src/quick/items/qquickimage.cpp
+++ b/src/quick/items/qquickimage.cpp
@@ -663,7 +663,7 @@ QSGNode *QQuickImage::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
     QSGInternalImageNode *node = static_cast<QSGInternalImageNode *>(oldNode);
     if (!node) {
         d->pixmapChanged = true;
-        node = d->sceneGraphContext()->createInternalImageNode();
+        node = d->sceneGraphContext()->createInternalImageNode(d->sceneGraphRenderContext());
     }
 
     QRectF targetRect;
diff --git a/src/quick/items/qquickopenglshadereffect.cpp b/src/quick/items/qquickopenglshadereffect.cpp
index bc1f787b81..0fd7df8938 100644
--- a/src/quick/items/qquickopenglshadereffect.cpp
+++ b/src/quick/items/qquickopenglshadereffect.cpp
@@ -57,6 +57,10 @@
 
 QT_BEGIN_NAMESPACE
 
+// Note: this legacy ShaderEffect implementation is used only when running
+// directly with OpenGL. This is going to go away in the future (Qt 6?), since
+// the RHI path uses QQuickGenericShaderEffect always.
+
 namespace {
 
     enum VariableQualifier {
diff --git a/src/quick/items/qquickopenglshadereffectnode.cpp b/src/quick/items/qquickopenglshadereffectnode.cpp
index 3ccd2a76f7..26ef59c20e 100644
--- a/src/quick/items/qquickopenglshadereffectnode.cpp
+++ b/src/quick/items/qquickopenglshadereffectnode.cpp
@@ -366,7 +366,6 @@ class QQuickOpenGLShaderEffectMaterialCache : public QObject
 public:
     static QQuickOpenGLShaderEffectMaterialCache *get(bool create = true) {
         QOpenGLContext *ctx = QOpenGLContext::currentContext();
-        Q_ASSERT(ctx);
         QQuickOpenGLShaderEffectMaterialCache *me = ctx->findChild<QQuickOpenGLShaderEffectMaterialCache *>(QStringLiteral("__qt_ShaderEffectCache"), Qt::FindDirectChildrenOnly);
         if (!me && create) {
             me = new QQuickOpenGLShaderEffectMaterialCache();
diff --git a/src/quick/items/qquickrendercontrol.cpp b/src/quick/items/qquickrendercontrol.cpp
index f6d4e7ed49..83b3372ed9 100644
--- a/src/quick/items/qquickrendercontrol.cpp
+++ b/src/quick/items/qquickrendercontrol.cpp
@@ -242,7 +242,18 @@ void QQuickRenderControl::initialize(QOpenGLContext *gl)
     // It cannot be done here since the surface to use may not be the
     // surface belonging to window. In fact window may not have a native
     // window/surface at all.
-    d->rc->initialize(gl);
+    QSGDefaultRenderContext *rc = qobject_cast<QSGDefaultRenderContext *>(d->rc);
+    if (rc) {
+        QSGDefaultRenderContext::InitParams params;
+        params.sampleCount = qMax(1, gl->format().samples());
+        params.openGLContext = gl;
+        params.initialSurfacePixelSize = d->window->size() * d->window->effectiveDevicePixelRatio();
+        params.maybeSurface = d->window;
+        rc->initialize(&params);
+    } else {
+        // can this happen?
+        d->rc->initialize(nullptr);
+    }
 #else
     Q_UNUSED(gl)
 #endif
diff --git a/src/quick/items/qquickshadereffect.cpp b/src/quick/items/qquickshadereffect.cpp
index eb5256fa4e..b3c8386fd9 100644
--- a/src/quick/items/qquickshadereffect.cpp
+++ b/src/quick/items/qquickshadereffect.cpp
@@ -44,6 +44,9 @@
 #include <private/qquickopenglshadereffect_p.h>
 #endif
 #include <private/qquickgenericshadereffect_p.h>
+#if QT_CONFIG(opengl) /* || QT_CONFIG(vulkan) || defined(Q_OS_WIN) || defined(Q_OS_DARWIN) */
+#include <private/qsgrhisupport_p.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -506,13 +509,20 @@ QQuickShaderEffect::QQuickShaderEffect(QQuickItem *parent)
 {
     setFlag(QQuickItem::ItemHasContents);
 
+#if QT_CONFIG(opengl) /* || QT_CONFIG(vulkan) || defined(Q_OS_WIN) || defined(Q_OS_DARWIN) */
+    if (QSGRhiSupport::instance()->isRhiEnabled()) {
+        m_impl = new QQuickGenericShaderEffect(this, this);
+    } else
+#endif
+    {
 #if QT_CONFIG(opengl)
-    if (!qsg_backend_flags().testFlag(QSGContextFactoryInterface::SupportsShaderEffectNode))
-        m_glImpl = new QQuickOpenGLShaderEffect(this, this);
+        if (!qsg_backend_flags().testFlag(QSGContextFactoryInterface::SupportsShaderEffectNode))
+            m_glImpl = new QQuickOpenGLShaderEffect(this, this);
 
-    if (!m_glImpl)
+        if (!m_glImpl)
 #endif
-        m_impl = new QQuickGenericShaderEffect(this, this);
+            m_impl = new QQuickGenericShaderEffect(this, this);
+    }
 }
 
 QQuickShaderEffect::~QQuickShaderEffect()
diff --git a/src/quick/items/qquickshadereffectsource.cpp b/src/quick/items/qquickshadereffectsource.cpp
index 505940e673..f9f3e5cfa3 100644
--- a/src/quick/items/qquickshadereffectsource.cpp
+++ b/src/quick/items/qquickshadereffectsource.cpp
@@ -750,7 +750,7 @@ QSGNode *QQuickShaderEffectSource::updatePaintNode(QSGNode *oldNode, UpdatePaint
 
     QSGInternalImageNode *node = static_cast<QSGInternalImageNode *>(oldNode);
     if (!node) {
-        node = d->sceneGraphContext()->createInternalImageNode();
+        node = d->sceneGraphContext()->createInternalImageNode(d->sceneGraphRenderContext());
         node->setFlag(QSGNode::UsePreprocess);
         node->setTexture(m_texture);
         QQuickShaderSourceAttachedNode *attached = new QQuickShaderSourceAttachedNode;
diff --git a/src/quick/items/qquicktextnode.cpp b/src/quick/items/qquicktextnode.cpp
index 0dd12207b7..9110a0664f 100644
--- a/src/quick/items/qquicktextnode.cpp
+++ b/src/quick/items/qquicktextnode.cpp
@@ -160,7 +160,7 @@ void QQuickTextNode::addRectangleNode(const QRectF &rect, const QColor &color)
 void QQuickTextNode::addImage(const QRectF &rect, const QImage &image)
 {
     QSGRenderContext *sg = QQuickItemPrivate::get(m_ownerElement)->sceneGraphRenderContext();
-    QSGInternalImageNode *node = sg->sceneGraphContext()->createInternalImageNode();
+    QSGInternalImageNode *node = sg->sceneGraphContext()->createInternalImageNode(sg);
     QSGTexture *texture = sg->createTexture(image);
     if (m_ownerElement->smooth())
         texture->setFiltering(QSGTexture::Linear);
diff --git a/src/quick/items/qquickwindow.cpp b/src/quick/items/qquickwindow.cpp
index 25bbc5da5a..0adfbdb922 100644
--- a/src/quick/items/qquickwindow.cpp
+++ b/src/quick/items/qquickwindow.cpp
@@ -52,8 +52,9 @@
 #include <private/qquickpointerhandler_p.h>
 
 #include <QtQuick/private/qsgrenderer_p.h>
-#include <QtQuick/private/qsgtexture_p.h>
+#include <QtQuick/private/qsgplaintexture_p.h>
 #include <private/qsgrenderloop_p.h>
+#include <private/qsgrhisupport_p.h>
 #include <private/qquickrendercontrol_p.h>
 #include <private/qquickanimatorcontroller_p.h>
 #include <private/qquickprofiler_p.h>
@@ -85,6 +86,8 @@
 #include <private/qdebug_p.h>
 #endif
 
+#include <QtGui/private/qrhi_p.h>
+
 QT_BEGIN_NAMESPACE
 
 Q_LOGGING_CATEGORY(DBG_TOUCH, "qt.quick.touch")
@@ -451,12 +454,35 @@ void QQuickWindowPrivate::syncSceneGraph()
     runAndClearJobs(&afterSynchronizingJobs);
 }
 
-void QQuickWindowPrivate::renderSceneGraph(const QSize &size)
+void QQuickWindowPrivate::emitBeforeRenderPassRecording(void *ud)
+{
+    QQuickWindow *w = reinterpret_cast<QQuickWindow *>(ud);
+    emit w->beforeRenderPassRecording();
+}
+
+void QQuickWindowPrivate::emitAfterRenderPassRecording(void *ud)
+{
+    QQuickWindow *w = reinterpret_cast<QQuickWindow *>(ud);
+    emit w->afterRenderPassRecording();
+}
+
+void QQuickWindowPrivate::renderSceneGraph(const QSize &size, const QSize &surfaceSize)
 {
     Q_Q(QQuickWindow);
     if (!renderer)
         return;
 
+    if (rhi) {
+        // ### no offscreen ("renderTargetId") support yet
+        context->beginRhiFrame(renderer,
+                               swapchain->currentFrameRenderTarget(),
+                               rpDescForSwapchain,
+                               swapchain->currentFrameCommandBuffer(),
+                               emitBeforeRenderPassRecording,
+                               emitAfterRenderPassRecording,
+                               q);
+    }
+
     animationController->advance();
     emit q->beforeRendering();
     runAndClearJobs(&beforeRenderingJobs);
@@ -469,24 +495,40 @@ void QQuickWindowPrivate::renderSceneGraph(const QSize &size)
             renderer->setDeviceRect(rect);
             renderer->setViewportRect(rect);
             if (QQuickRenderControl::renderWindowFor(q)) {
-                renderer->setProjectionMatrixToRect(QRect(QPoint(0, 0), size));
+                renderer->setProjectionMatrixToRect(QRect(QPoint(0, 0), size), false);
                 renderer->setDevicePixelRatio(devicePixelRatio);
             } else {
-                renderer->setProjectionMatrixToRect(QRect(QPoint(0, 0), rect.size()));
+                renderer->setProjectionMatrixToRect(QRect(QPoint(0, 0), rect.size()), false);
                 renderer->setDevicePixelRatio(1);
             }
         } else {
-            QRect rect(QPoint(0, 0), devicePixelRatio * size);
+            QSize pixelSize;
+            QSizeF logicalSize;
+            if (surfaceSize.isEmpty()) {
+                pixelSize = size * devicePixelRatio;
+                logicalSize = size;
+            } else {
+                pixelSize = surfaceSize;
+                logicalSize = QSizeF(surfaceSize) / devicePixelRatio;
+            }
+            QRect rect(QPoint(0, 0), pixelSize);
             renderer->setDeviceRect(rect);
             renderer->setViewportRect(rect);
-            renderer->setProjectionMatrixToRect(QRect(QPoint(0, 0), size));
+            const bool flipY = rhi ? !rhi->isYUpInNDC() : false;
+            renderer->setProjectionMatrixToRect(QRectF(QPoint(0, 0), logicalSize), flipY);
             renderer->setDevicePixelRatio(devicePixelRatio);
         }
 
-        context->renderNextFrame(renderer, fboId);
+        if (rhi)
+            context->renderNextRhiFrame(renderer);
+        else
+            context->renderNextFrame(renderer, fboId);
     }
     emit q->afterRendering();
     runAndClearJobs(&afterRenderingJobs);
+
+    if (rhi)
+        context->endRhiFrame(renderer);
 }
 
 QQuickWindowPrivate::QQuickWindowPrivate()
@@ -522,6 +564,9 @@ QQuickWindowPrivate::QQuickWindowPrivate()
     , renderTargetId(0)
     , vaoHelper(nullptr)
     , incubationController(nullptr)
+    , hasActiveSwapchain(false)
+    , hasRenderableSwapchain(false)
+    , swapchainJustBecameRenderable(false)
 {
 #if QT_CONFIG(quick_draganddrop)
     dragGrabber = new QQuickDragGrabber;
@@ -539,6 +584,7 @@ void QQuickWindowPrivate::init(QQuickWindow *c, QQuickRenderControl *control)
 {
     q_ptr = c;
 
+
     Q_Q(QQuickWindow);
 
     contentItem = new QQuickRootItem;
@@ -576,6 +622,10 @@ void QQuickWindowPrivate::init(QQuickWindow *c, QQuickRenderControl *control)
 
     q->setSurfaceType(windowManager ? windowManager->windowSurfaceType() : QSurface::OpenGLSurface);
     q->setFormat(sg->defaultSurfaceFormat());
+#if QT_CONFIG(vulkan)
+    if (q->surfaceType() == QSurface::VulkanSurface)
+        q->setVulkanInstance(QSGRhiSupport::vulkanInstance());
+#endif
 
     animationController = new QQuickAnimatorController(q);
 
@@ -3628,24 +3678,20 @@ void QQuickWindow::setTransientParent_helper(QQuickWindow *window)
 /*!
     Returns the OpenGL context used for rendering.
 
-    If the scene graph is not ready, or the scene graph is not using OpenGL,
-    this function will return null.
-
-    \note If using a scene graph adaptation other than OpenGL this
-    function will return nullptr.
+    \note If the scene graph is not ready, or the scene graph is not using
+    OpenGL (or RHI over OpenGL), this function will return null.
 
     \sa sceneGraphInitialized(), sceneGraphInvalidated()
  */
-
 QOpenGLContext *QQuickWindow::openglContext() const
 {
 #if QT_CONFIG(opengl)
     Q_D(const QQuickWindow);
     if (d->context && d->context->isValid()) {
         QSGRendererInterface *rif = d->context->sceneGraphContext()->rendererInterface(d->context);
-        if (rif && rif->graphicsApi() == QSGRendererInterface::OpenGL) {
-            auto openglRenderContext = static_cast<const QSGDefaultRenderContext *>(d->context);
-            return openglRenderContext->openglContext();
+        if (rif) {
+            return reinterpret_cast<QOpenGLContext *>(rif->getResource(const_cast<QQuickWindow *>(this),
+                                                                       QSGRendererInterface::OpenGLContextResource));
         }
     }
 #endif
@@ -3778,6 +3824,8 @@ bool QQuickWindow::isSceneGraphInitialized() const
     This function only has an effect when using the default OpenGL scene
     graph adaptation.
 
+    \note This function has no effect when running on the RHI graphics abstraction.
+
     \warning
     This function can only be called from the thread doing
     the rendering.
@@ -3786,6 +3834,9 @@ bool QQuickWindow::isSceneGraphInitialized() const
 void QQuickWindow::setRenderTarget(QOpenGLFramebufferObject *fbo)
 {
     Q_D(QQuickWindow);
+    if (d->rhi)
+        return;
+
     if (d->context && QThread::currentThread() != d->context->thread()) {
         qWarning("QQuickWindow::setRenderTarget: Cannot set render target from outside the rendering thread");
         return;
@@ -3867,9 +3918,11 @@ QSize QQuickWindow::renderTargetSize() const
     The default is to render to the surface of the window, in which
     case the render target is 0.
 
-    \note
-    This function will return nullptr when not using the OpenGL scene
+    \note This function will return nullptr when not using the OpenGL scene
     graph adaptation.
+
+    \note This function has no effect and returns nullptr when running on the
+    RHI graphics abstraction.
  */
 QOpenGLFramebufferObject *QQuickWindow::renderTarget() const
 {
@@ -3895,12 +3948,23 @@ QImage QQuickWindow::grabWindow()
     Q_D(QQuickWindow);
 
     if (!isVisible() && !d->renderControl) {
+        // backends like software and d3d12 can grab regardless of the window state
         if (d->windowManager && (d->windowManager->flags() & QSGRenderLoop::SupportsGrabWithoutExpose))
             return d->windowManager->grab(this);
     }
 
-#if QT_CONFIG(opengl)
     if (!isVisible() && !d->renderControl) {
+        if (d->rhi) {
+            // ### we may need a full offscreen round when non-exposed...
+
+            if (d->renderControl)
+                return d->renderControl->grab();
+            else if (d->windowManager)
+                return d->windowManager->grab(this);
+            return QImage();
+        }
+
+#if QT_CONFIG(opengl)
         auto openglRenderContext = static_cast<QSGDefaultRenderContext *>(d->context);
         if (!openglRenderContext->openglContext()) {
             if (!handle() || !size().isValid()) {
@@ -3913,7 +3977,9 @@ QImage QQuickWindow::grabWindow()
             context.setShareContext(qt_gl_global_share_context());
             context.create();
             context.makeCurrent(this);
-            d->context->initialize(&context);
+            QSGDefaultRenderContext::InitParams rcParams;
+            rcParams.openGLContext = &context;
+            d->context->initialize(&rcParams);
 
             d->polishItems();
             d->syncSceneGraph();
@@ -3928,8 +3994,9 @@ QImage QQuickWindow::grabWindow()
 
             return image;
         }
-    }
 #endif
+    }
+
     if (d->renderControl)
         return d->renderControl->grab();
     else if (d->windowManager)
@@ -4067,6 +4134,17 @@ QQmlIncubationController *QQuickWindow::incubationController() const
     The OpenGL context used for rendering the scene graph will be bound
     at this point.
 
+    When using the RHI and a graphics API other than OpenGL, the signal is
+    emitted after the preparations for the frame have been done, meaning there
+    is a command buffer in recording mode, where applicable. If desired, the
+    slot function connected to this signal can query native resources like the
+    command before via QSGRendererInterface. Note however that the recording of
+    the main render pass is not yet started at this point and it is not
+    possible to add commands within that pass. Instead, use
+    beforeRenderPassRecording() for that. However, connecting to this signal is
+    still important if the recording of copy type of commands is desired since
+    those cannot be enqueued within a render pass.
+
     \warning This signal is emitted from the scene graph rendering thread. If your
     slot function needs to finish before execution continues, you must make sure that
     the connection is direct (see Qt::ConnectionType).
@@ -4088,6 +4166,15 @@ QQmlIncubationController *QQuickWindow::incubationController() const
 
     The OpenGL context used for rendering the scene graph will be bound at this point.
 
+    When using the RHI and a graphics API other than OpenGL, the signal is
+    emitted after scene graph has added its commands to the command buffer,
+    which is not yet submitted to the graphics queue. If desired, the slot
+    function connected to this signal can query native resources, like the
+    command buffer, before via QSGRendererInterface. Note however that the
+    render pass (or passes) are already recorded at this point and it is not
+    possible to add more commands within the scenegraph's pass. Instead, use
+    afterRenderPassRecording() for that.
+
     \warning This signal is emitted from the scene graph rendering thread. If your
     slot function needs to finish before execution continues, you must make sure that
     the connection is direct (see Qt::ConnectionType).
@@ -4100,14 +4187,68 @@ QQmlIncubationController *QQuickWindow::incubationController() const
  */
 
 /*!
+    \fn void QQuickWindow::beforeRenderPassRecording()
+
+    This signal is emitted before the scenegraph starts recording commands for
+    the main render pass. (Layers have their own passes and are fully recorded
+    by the time this signal is emitted.) The render pass is already active on
+    the command buffer when the signal is emitted.
+
+    This signal is applicable when using the RHI graphics abstraction with the
+    scenegraph. It is emitted later than beforeRendering() and it guarantees
+    that not just the frame, but also the recording of the scenegraph's main
+    render pass is active. This allows inserting commands without having to
+    generate an entire, separate render pass (which would typically clear the
+    attached images). The native graphics objects can be queried via
+    QSGRendererInterface.
+
+    \note Resource updates (uploads, copies) typically cannot be enqueued from
+    within a render pass. Therefore, more complex user rendering will need to
+    connect to both the beforeRendering() and this signals.
+
+    \warning This signal is emitted from the scene graph rendering thread. If your
+    slot function needs to finish before execution continues, you must make sure that
+    the connection is direct (see Qt::ConnectionType).
+
+    \since 5.14
+*/
+
+/*!
+    \fn void QQuickWindow::afterRenderPassRecording()
+
+    This signal is emitted after the scenegraph has recorded the commands for
+    its main render pass, but the pass is not yet finalized on the command
+    buffer.
+
+    This signal is applicable when using the RHI graphics abstraction with the
+    scenegraph. It is emitted earlier than afterRendering() and it guarantees
+    that not just the frame, but also the recording of the scenegraph's main
+    render pass is still active. This allows inserting commands without having
+    to generate an entire, separate render pass (which would typically clear
+    the attached images). The native graphics objects can be queried via
+    QSGRendererInterface.
+
+    \note Resource updates (uploads, copies) typically cannot be enqueued from
+    within a render pass. Therefore, more complex user rendering will need to
+    connect to both the beforeRendering() and this signals.
+
+    \warning This signal is emitted from the scene graph rendering thread. If your
+    slot function needs to finish before execution continues, you must make sure that
+    the connection is direct (see Qt::ConnectionType).
+
+    \since 5.14
+*/
+
+/*!
     \fn void QQuickWindow::afterAnimating()
 
     This signal is emitted on the gui thread before requesting the render thread to
     perform the synchronization of the scene graph.
 
-    Unlike the other similar signals, this one is emitted on the gui thread instead
-    of the render thread. It can be used to synchronize external animation systems
-    with the QML content.
+    Unlike the other similar signals, this one is emitted on the gui thread
+    instead of the render thread. It can be used to synchronize external
+    animation systems with the QML content. At the same time this means that
+    this signal is not suitable for triggering graphics operations.
 
     \since 5.3
  */
@@ -4167,7 +4308,15 @@ QQmlIncubationController *QQuickWindow::incubationController() const
 
     The color buffer is cleared by default.
 
-    \sa beforeRendering()
+    \warning This flag is ignored completely when running with the RHI graphics
+    abstraction instead of using OpenGL directly. As explicit clear commands
+    simply do not exist in some modern APIs, the scene graph cannot offer this
+    flexibility anymore. The images associated with a render target will always
+    get cleared when a render pass starts. As a solution, an alternative to
+    disabling scene graph issued clears is provided in form of the
+    beforeRenderPassRecording() signal.
+
+    \sa beforeRendering(), beforeRenderPassRecording()
  */
 
 void QQuickWindow::setClearBeforeRendering(bool enabled)
@@ -4271,12 +4420,15 @@ QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image, CreateText
     \note This function only has an effect when using the default OpenGL scene graph
     adaptation.
 
+    \note This function has no effect when running on the RHI graphics abstraction.
+
     \sa sceneGraphInitialized(), QSGTexture
  */
 QSGTexture *QQuickWindow::createTextureFromId(uint id, const QSize &size, CreateTextureOptions options) const
 {
 #if QT_CONFIG(opengl)
-    if (openglContext()) {
+    Q_D(const QQuickWindow);
+    if (!d->rhi && openglContext()) {
         QSGPlainTexture *texture = new QSGPlainTexture();
         texture->setTextureId(id);
         texture->setHasAlphaChannel(options & TextureHasAlphaChannel);
@@ -4379,15 +4531,19 @@ void QQuickWindow::setDefaultAlphaBuffer(bool useAlpha)
     \note This function only has an effect when using the default OpenGL scene graph
     adaptation.
 
-    \sa QQuickWindow::beforeRendering()
+    \note This function has no effect when running on the RHI graphics
+    abstraction. With the RHI, the functions to call when enqueuing native
+    graphics commands are beginExternalCommands() and endExternalCommands().
+
+    \sa QQuickWindow::beforeRendering(), beginExternalCommands(), endExternalCommands()
  */
 void QQuickWindow::resetOpenGLState()
 {
-    if (!openglContext())
-        return;
-
     Q_D(QQuickWindow);
 
+    if (d->rhi || !openglContext())
+        return;
+
     QOpenGLContext *ctx = openglContext();
     QOpenGLFunctions *gl = ctx->functions();
 
@@ -4434,6 +4590,111 @@ void QQuickWindow::resetOpenGLState()
     QOpenGLFramebufferObject::bindDefault();
 }
 #endif
+
+/*!
+    \struct QQuickWindow::GraphicsStateInfo
+    \inmodule QtQuick
+    \since 5.14
+
+    \brief Describes some of the RHI's graphics state at the point of a
+    \l{QQuickWindow::beginExternalCommands()}{beginExternalCommands()} call.
+ */
+
+/*!
+    \return a pointer to a GraphicsStateInfo struct describing some of the
+    RHI's internal state, in particular, the double or tripple buffering status
+    of the backend (such as, the Vulkan or Metal integrations). This is
+    relevant when the underlying graphics APIs is Vulkan or Metal, and the
+    external rendering code wishes to perform double or tripple buffering of
+    its own often-changing resources, such as, uniform buffers, in order to
+    avoid stalling the pipeline.
+ */
+const QQuickWindow::GraphicsStateInfo *QQuickWindow::graphicsStateInfo()
+{
+    Q_D(QQuickWindow);
+    if (d->rhi) {
+        d->rhiStateInfo.currentFrameSlot = d->rhi->currentFrameSlot();
+        d->rhiStateInfo.framesInFlight = d->rhi->resourceLimit(QRhi::FramesInFlight);
+    }
+    return &d->rhiStateInfo;
+}
+
+/*!
+    When mixing raw graphics (OpenGL, Vulkan, Metal, etc.) commands with scene
+    graph rendering, it is necessary to call this function before recording
+    commands to the command buffer used by the scene graph to render its main
+    render pass. This is to avoid clobbering state.
+
+    In practice this function is often called from a slot connected to the
+    beforeRenderPassRecording() or afterRenderPassRecording() signals.
+
+    The function does not need to be called when recording commands to the
+    application's own command buffer (such as, a VkCommandBuffer or
+    MTLCommandBuffer + MTLRenderCommandEncoder created and managed by the
+    application, not retrieved from the scene graph). With graphics APIs where
+    no native command buffer concept is exposed (OpenGL, Direct 3D 11),
+    beginExternalCommands() and endExternalCommands() together provide a
+    replacement for resetOpenGLState().
+
+    \note This function has no effect when the scene graph is using OpenGL
+    directly and the RHI graphics abstraction layer is not in use. Refer to
+    resetOpenGLState() in that case.
+
+    \sa endExternalCommands()
+
+    \since 5.14
+ */
+void QQuickWindow::beginExternalCommands()
+{
+#if QT_CONFIG(opengl) /* || QT_CONFIG(vulkan) || defined(Q_OS_WIN) || defined(Q_OS_DARWIN) */
+    Q_D(QQuickWindow);
+    if (d->rhi && d->context && d->context->isValid()) {
+        QSGDefaultRenderContext *rc = static_cast<QSGDefaultRenderContext *>(d->context);
+        QRhiCommandBuffer *cb = rc->currentFrameCommandBuffer();
+        if (cb)
+            cb->beginExternal();
+    }
+#endif
+}
+
+/*!
+    When mixing raw graphics (OpenGL, Vulkan, Metal, etc.) commands with scene
+    graph rendering, it is necessary to call this function after recording
+    commands to the command buffer used by the scene graph to render its main
+    render pass. This is to avoid clobbering state.
+
+    In practice this function is often called from a slot connected to the
+    beforeRenderPassRecording() or afterRenderPassRecording() signals.
+
+    The function does not need to be called when recording commands to the
+    application's own command buffer (such as, a VkCommandBuffer or
+    MTLCommandBuffer + MTLRenderCommandEncoder created and managed by the
+    application, not retrieved from the scene graph). With graphics APIs where
+    no native command buffer concept is exposed (OpenGL, Direct 3D 11),
+    beginExternalCommands() and endExternalCommands() together provide a
+    replacement for resetOpenGLState().
+
+    \note This function has no effect when the scene graph is using OpenGL
+    directly and the RHI graphics abstraction layer is not in use. Refer to
+    resetOpenGLState() in that case.
+
+    \sa beginExternalCommands()
+
+    \since 5.14
+ */
+void QQuickWindow::endExternalCommands()
+{
+#if QT_CONFIG(opengl) /* || QT_CONFIG(vulkan) || defined(Q_OS_WIN) || defined(Q_OS_DARWIN) */
+    Q_D(QQuickWindow);
+    if (d->rhi && d->context && d->context->isValid()) {
+        QSGDefaultRenderContext *rc = static_cast<QSGDefaultRenderContext *>(d->context);
+        QRhiCommandBuffer *cb = rc->currentFrameCommandBuffer();
+        if (cb)
+            cb->endExternal();
+    }
+#endif
+}
+
 /*!
     \qmlproperty string Window::title
 
@@ -5019,6 +5280,10 @@ void QQuickWindow::setSceneGraphBackend(QSGRendererInterface::GraphicsApi api)
     default:
         break;
     }
+#if QT_CONFIG(opengl) /* || QT_CONFIG(vulkan) || defined(Q_OS_WIN) || defined(Q_OS_DARWIN) */
+    if (QSGRendererInterface::isApiRhiBased(api))
+        QSGRhiSupport::configure(api);
+#endif
 }
 
 /*!
diff --git a/src/quick/items/qquickwindow.h b/src/quick/items/qquickwindow.h
index 53fe0a4c4b..ab3046611f 100644
--- a/src/quick/items/qquickwindow.h
+++ b/src/quick/items/qquickwindow.h
@@ -66,6 +66,7 @@ class QQuickRenderControl;
 class QSGRectangleNode;
 class QSGImageNode;
 class QSGNinePatchNode;
+class QRhi;
 
 class Q_QUICK_EXPORT QQuickWindow : public QWindow
 {
@@ -135,6 +136,13 @@ public:
 #if QT_CONFIG(opengl)
     void resetOpenGLState();
 #endif
+    struct GraphicsStateInfo {
+        int currentFrameSlot = 0;
+        int framesInFlight = 0;
+    };
+    const GraphicsStateInfo *graphicsStateInfo();
+    void beginExternalCommands();
+    void endExternalCommands();
     QQmlIncubationController *incubationController() const;
 
 #if QT_CONFIG(accessibility)
@@ -198,6 +206,8 @@ Q_SIGNALS:
     Q_REVISION(1) void activeFocusItemChanged();
     Q_REVISION(2) void sceneGraphError(QQuickWindow::SceneGraphError error, const QString &message);
 
+    Q_REVISION(14) void beforeRenderPassRecording();
+    Q_REVISION(14) void afterRenderPassRecording();
 
 public Q_SLOTS:
     void update();
diff --git a/src/quick/items/qquickwindow_p.h b/src/quick/items/qquickwindow_p.h
index b4b456fbaa..becbae7fe3 100644
--- a/src/quick/items/qquickwindow_p.h
+++ b/src/quick/items/qquickwindow_p.h
@@ -82,6 +82,10 @@ class QQuickWindowPrivate;
 class QQuickWindowRenderLoop;
 class QSGRenderLoop;
 class QTouchEvent;
+class QRhi;
+class QRhiSwapChain;
+class QRhiRenderBuffer;
+class QRhiRenderPassDescriptor;
 
 //Make it easy to identify and customize the root item if needed
 class QQuickRootItem : public QQuickItem
@@ -215,7 +219,7 @@ public:
     void polishItems();
     void forcePolish();
     void syncSceneGraph();
-    void renderSceneGraph(const QSize &size);
+    void renderSceneGraph(const QSize &size, const QSize &surfaceSize = QSize());
 
     bool isRenderable() const;
 
@@ -317,6 +321,9 @@ public:
                                               QString *untranslatedMessage,
                                               bool isEs);
 
+    static void emitBeforeRenderPassRecording(void *ud);
+    static void emitAfterRenderPassRecording(void *ud);
+
     QMutex renderJobMutex;
     QList<QRunnable *> beforeSynchronizingJobs;
     QList<QRunnable *> afterSynchronizingJobs;
@@ -326,6 +333,15 @@ public:
 
     void runAndClearJobs(QList<QRunnable *> *jobs);
 
+    QQuickWindow::GraphicsStateInfo rhiStateInfo;
+    QRhi *rhi = nullptr;
+    QRhiSwapChain *swapchain = nullptr;
+    QRhiRenderBuffer *depthStencilForSwapchain = nullptr;
+    QRhiRenderPassDescriptor *rpDescForSwapchain = nullptr;
+    uint hasActiveSwapchain : 1;
+    uint hasRenderableSwapchain : 1;
+    uint swapchainJustBecameRenderable : 1;
+
 private:
     static void cleanupNodesOnShutdown(QQuickItem *);
 };
diff --git a/src/quick/items/qquickwindowmodule.cpp b/src/quick/items/qquickwindowmodule.cpp
index 2b109c0897..7b3874dbfe 100644
--- a/src/quick/items/qquickwindowmodule.cpp
+++ b/src/quick/items/qquickwindowmodule.cpp
@@ -214,6 +214,7 @@ void QQuickWindowModule::defineModule()
     qmlRegisterRevision<QWindow,13>(uri, 2, 13);
     qmlRegisterRevision<QQuickWindow,13>(uri, 2, 13);
     qmlRegisterType<QQuickWindowQmlImpl,13>(uri, 2, 13, "Window");
+    qmlRegisterRevision<QQuickWindow,14>(uri, 2, 14);
 }
 
 QT_END_NAMESPACE