Merge remote-tracking branch 'origin/wip/qt6' into wip/cmake

Change-Id: I2963c1209316fb6755f572969f368970450d7991

1 files changed, 322 insertions, 39 deletions

diff --git a/src/quick/items/qquickwindow.cpp b/src/quick/items/qquickwindow.cpp
index 24a17ce80f..30738b3db6 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>
@@ -75,7 +76,6 @@
 
 #include <QtQuick/private/qquickpixmapcache_p.h>
 
-#include <private/qqmlmemoryprofiler_p.h>
 #include <private/qqmldebugserviceinterfaces_p.h>
 #include <private/qqmldebugconnector_p.h>
 #if QT_CONFIG(opengl)
@@ -86,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")
@@ -420,7 +422,6 @@ void forceUpdate(QQuickItem *item)
 
 void QQuickWindowPrivate::syncSceneGraph()
 {
-    QML_MEMORY_SCOPE_STRING("SceneGraph");
     Q_Q(QQuickWindow);
 
     animationController->beforeNodeSync();
@@ -453,13 +454,40 @@ 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)
 {
-    QML_MEMORY_SCOPE_STRING("SceneGraph");
     Q_Q(QQuickWindow);
     if (!renderer)
         return;
 
+    if (rhi) {
+        // ### no offscreen ("renderTargetId") support yet
+        context->beginNextRhiFrame(renderer,
+                                   swapchain->currentFrameRenderTarget(),
+                                   rpDescForSwapchain,
+                                   swapchain->currentFrameCommandBuffer(),
+                                   emitBeforeRenderPassRecording,
+                                   emitAfterRenderPassRecording,
+                                   q);
+    } else {
+        context->beginNextFrame(renderer,
+                                emitBeforeRenderPassRecording,
+                                emitAfterRenderPassRecording,
+                                q);
+    }
+
     animationController->advance();
     emit q->beforeRendering();
     runAndClearJobs(&beforeRenderingJobs);
@@ -472,24 +500,42 @@ 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->endNextRhiFrame(renderer);
+    else
+        context->endNextFrame(renderer);
 }
 
 QQuickWindowPrivate::QQuickWindowPrivate()
@@ -525,6 +571,9 @@ QQuickWindowPrivate::QQuickWindowPrivate()
     , renderTargetId(0)
     , vaoHelper(nullptr)
     , incubationController(nullptr)
+    , hasActiveSwapchain(false)
+    , hasRenderableSwapchain(false)
+    , swapchainJustBecameRenderable(false)
 {
 #if QT_CONFIG(quick_draganddrop)
     dragGrabber = new QQuickDragGrabber;
@@ -542,6 +591,7 @@ void QQuickWindowPrivate::init(QQuickWindow *c, QQuickRenderControl *control)
 {
     q_ptr = c;
 
+
     Q_Q(QQuickWindow);
 
     contentItem = new QQuickRootItem;
@@ -579,6 +629,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);
 
@@ -699,7 +753,7 @@ bool QQuickWindowPrivate::deliverTouchAsMouse(QQuickItem *item, QQuickPointerEve
             if (!item->contains(pos))
                 break;
 
-            qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << hex << p.id() << "->" << item;
+            qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << Qt::hex << p.id() << "->" << item;
             QScopedPointer<QMouseEvent> mousePress(touchToMouseEvent(QEvent::MouseButtonPress, p, event.data(), item, false));
 
             // Send a single press and see if that's accepted
@@ -741,7 +795,7 @@ bool QQuickWindowPrivate::deliverTouchAsMouse(QQuickItem *item, QQuickPointerEve
                     QCoreApplication::sendEvent(item, me.data());
                     event->setAccepted(me->isAccepted());
                     if (me->isAccepted()) {
-                        qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << hex << p.id() << "->" << mouseGrabberItem;
+                        qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << Qt::hex << p.id() << "->" << mouseGrabberItem;
                     }
                     return event->isAccepted();
                 } else {
@@ -1580,6 +1634,7 @@ bool QQuickWindowPrivate::clearHover(ulong timestamp)
     bool accepted = false;
     for (QQuickItem* item : qAsConst(hoverItems)) {
         accepted = sendHoverEvent(QEvent::HoverLeave, item, pos, pos, QGuiApplication::keyboardModifiers(), timestamp, true) || accepted;
+#if QT_CONFIG(cursor)
         QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
         if (itemPrivate->hasPointerHandlers()) {
             pos = q->mapFromGlobal(QCursor::pos());
@@ -1591,6 +1646,7 @@ bool QQuickWindowPrivate::clearHover(ulong timestamp)
                 if (QQuickHoverHandler *hh = qmlobject_cast<QQuickHoverHandler *>(h))
                     hh->handlePointerEvent(pointerEvent);
         }
+#endif
     }
     hoverItems.clear();
     return accepted;
@@ -1629,7 +1685,9 @@ bool QQuickWindow::event(QEvent *e)
             QGuiApplication::keyboardModifiers(), 0L, accepted);
         d->lastMousePosition = enter->windowPos();
         enter->setAccepted(accepted);
+#if QT_CONFIG(cursor)
         d->updateCursor(mapFromGlobal(QCursor::pos()));
+#endif
         return delivered;
     }
         break;
@@ -2468,7 +2526,7 @@ void QQuickWindowPrivate::deliverTouchEvent(QQuickPointerTouchEvent *event)
         QQuickEventPoint *point = event->point(i);
         if (point->state() == QQuickEventPoint::Released) {
             int id = point->pointId();
-            qCDebug(DBG_TOUCH_TARGET) << "TP" << hex << id << "released";
+            qCDebug(DBG_TOUCH_TARGET) << "TP" << Qt::hex << id << "released";
             point->setGrabberItem(nullptr);
             if (id == touchMouseId)
                 cancelTouchMouseSynthesis();
@@ -2565,7 +2623,7 @@ bool QQuickWindowPrivate::deliverPressOrReleaseEvent(QQuickPointerEvent *event,
             if (point->grabberPointerHandler())
                 cancelTouchMouseSynthesis();
         } else {
-            qCWarning(DBG_TOUCH_TARGET) << "during delivery of touch press, synth-mouse ID" << hex << touchMouseId << "is missing from" << event;
+            qCWarning(DBG_TOUCH_TARGET) << "during delivery of touch press, synth-mouse ID" << Qt::hex << touchMouseId << "is missing from" << event;
         }
     }
     for (int i = 0; i < pointCount; ++i) {
@@ -2707,7 +2765,7 @@ void QQuickWindowPrivate::deliverMatchingPointsToItem(QQuickItem *item, QQuickPo
             if (point.state() == Qt::TouchPointPressed) {
                 if (auto *tp = ptEvent->pointById(point.id())) {
                     if (tp->exclusiveGrabber() == item) {
-                        qCDebug(DBG_TOUCH_TARGET) << "TP" << hex << point.id() << "disassociated";
+                        qCDebug(DBG_TOUCH_TARGET) << "TP" << Qt::hex << point.id() << "disassociated";
                         tp->setGrabberItem(nullptr);
                     }
                 }
@@ -2986,7 +3044,7 @@ bool QQuickWindowPrivate::sendFilteredPointerEventImpl(QQuickPointerEvent *event
                                     qCDebug(DBG_TOUCH) << "touch event intercepted as synth mouse event by childMouseEventFilter of " << filteringParent;
                                     skipDelivery.append(filteringParent);
                                     if (t != QEvent::MouseButtonRelease) {
-                                        qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << hex << tp.id() << "->" << filteringParent;
+                                        qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << Qt::hex << tp.id() << "->" << filteringParent;
                                         pointerEventInstance(dev)->pointById(tp.id())->setGrabberItem(filteringParent);
                                         touchMouseUnset = false; // We want to leave touchMouseId and touchMouseDevice set
                                         if (mouseEvent->isAccepted())
@@ -3627,24 +3685,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
@@ -3777,6 +3831,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.
@@ -3785,6 +3841,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;
@@ -3866,9 +3925,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
 {
@@ -3894,12 +3955,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()) {
@@ -3912,7 +3984,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();
@@ -3927,8 +4001,9 @@ QImage QQuickWindow::grabWindow()
 
             return image;
         }
-    }
 #endif
+    }
+
     if (d->renderControl)
         return d->renderControl->grab();
     else if (d->windowManager)
@@ -4066,6 +4141,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).
@@ -4087,6 +4173,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).
@@ -4099,14 +4194,78 @@ 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.
+
+    When not running with the RHI (and using OpenGL directly), the signal is
+    emitted after the renderer has cleared the render target. This makes it
+    possible to create appliations that function identically both with and
+    without the RHI.
+
+    \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.
+
+    When not running with the RHI (and using OpenGL directly), the signal is
+    emitted after the renderer has finished its rendering, but before
+    afterRendering(). This makes it possible to create appliations that
+    function identically both with and without the RHI.
+
+    \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
  */
@@ -4166,7 +4325,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)
@@ -4270,12 +4437,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);
@@ -4378,15 +4548,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();
 
@@ -4433,6 +4607,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
 
@@ -5018,6 +5297,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
 }
 
 /*!