Fix WOutputLayer::PreserveColorContents invalid on software renderer

On the virtual machine, maybe compositor will fallback to use the
software renderer, and cursor layer is force enable, you will
see a black screen on the virtual machine's window.

This issue is testd on VirtualBox.

Author: zccrs

examples/tinywl/surfacewrapper.cpp

@@ -668,6 +668,11 @@ bool SurfaceWrapper::startStateChangeAnimation(State targetState, const QRectF &
 
 qreal SurfaceWrapper::radius() const
 {
+    // RoundedClipEffect is use ShaderEffectSource to clip, its only
+    // supports RHI backend.
+    if (window()->sceneGraphBackend() == "software")
+        return 0;
+
     return m_radius;
 }
 

src/server/qtquick/private/wbufferrenderer.cpp

@@ -16,6 +16,7 @@
 #include <qwrendererinterface.h>
 
 #include <QSGImageNode>
+#include <QSGSimpleRectNode>
 
 #define protected public
 #define private public
@@ -392,7 +393,19 @@ qw_buffer *WBufferRenderer::beginRender(const QSize &pixelSize, qreal devicePixe
 
     if (rtd->type == QQuickRenderTargetPrivate::Type::PaintDevice) {
         sgRT.paintDevice = rtd->u.paintDevice;
+
+        // // For software renderer, update the dirty parts relative to the last paint device.
+        PixmanRegion damage;
+        m_damageRing.get_buffer_damage(bufferAge, damage);
+        state.dirty = WTools::fromPixmanRegion(damage);
+
+        if (devicePixelRatio != 1.0) {
+            state.dirty = QTransform::fromScale(1.0 / devicePixelRatio,
+                                                1.0 / devicePixelRatio).map(state.dirty);
+        }
     } else {
+        state.dirty = QRegion();
+
         Q_ASSERT(rtd->type == QQuickRenderTargetPrivate::Type::RhiRenderTarget);
         sgRT.rt = rtd->u.rhiRt;
         sgRT.cb = wd->redirect.commandBuffer;
@@ -415,7 +428,6 @@ qw_buffer *WBufferRenderer::beginRender(const QSize &pixelSize, qreal devicePixe
     state.pixelSize = pixelSize;
     state.devicePixelRatio = devicePixelRatio;
     state.bufferAge = bufferAge;
-    state.lastRT = lastRT;
     state.buffer = buffer;
     state.renderTarget = rt;
     state.sgRenderTarget = sgRT;
@@ -470,6 +482,23 @@ void WBufferRenderer::render(int sourceIndex, const QMatrix4x4 &renderMatrix,
     auto softwareRenderer = dynamic_cast<QSGSoftwareRenderer*>(renderer);
     { // before render
         if (softwareRenderer) {
+            // Avoid do clear before paint, for the software renderer this
+            // work is expensive.
+            if (m_clearColor.alpha() == 0)
+                preserveColorContents = true;
+#if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
+            softwareRenderer->setClearColorEnabled(!preserveColorContents);
+#else
+            auto bn = softwareRenderer->renderableNode(softwareRenderer->m_background);
+            if (bn) {
+                bn->m_opacity = preserveColorContents ? 0 : 1;
+            }
+#endif
+            if (!state.dirty.isEmpty()) {
+                softwareRenderer->m_dirtyRegion += state.dirty;
+                state.dirty = QRegion();
+            }
+
             // because software renderer don't supports viewportRect,
             // so use transform to simulation.
             const auto mapTransform = inputMapToOutput(sourceRect, targetRect,
@@ -565,6 +594,8 @@ void WBufferRenderer::render(int sourceIndex, const QMatrix4x4 &renderMatrix,
             // drawing result is available for use.
             wd->rhi->finish();
         } else {
+            state.dirty = softwareRenderer->flushRegion();
+
             auto currentImage = getImageFrom(state.renderTarget);
             Q_ASSERT(currentImage && currentImage == softwareRenderer->m_rt.paintDevice);
             currentImage->setDevicePixelRatio(1.0);
@@ -591,28 +622,6 @@ void WBufferRenderer::render(int sourceIndex, const QMatrix4x4 &renderMatrix,
                             pa.fillRect(r, softwareRenderer->clearColor());
                     }
                 }
-
-                if (!damage.isEmpty() && state.lastRT.first != state.buffer && !state.lastRT.second.isNull()) {
-                    auto image = getImageFrom(state.lastRT.second);
-                    Q_ASSERT(image);
-                    Q_ASSERT(image->size() == state.pixelSize);
-
-                    // TODO: Don't use the previous render target, we can get the damage region of QtQuick
-                    // before QQuickRenderControl::render for qw_damage_ring, and add dirty region to
-                    // QSGAbstractSoftwareRenderer to force repaint the damage region of current render target.
-                    QPainter pa(currentImage);
-
-                    PixmanRegion remainderDamage;
-                    ok = pixman_region32_subtract(remainderDamage, damage, scaledFlushDamage);
-                    Q_ASSERT(ok);
-
-                    int count = 0;
-                    auto rects = pixman_region32_rectangles(remainderDamage, &count);
-                    for (int i = 0; i < count; ++i) {
-                        auto r = rects[i];
-                        pa.drawImage(r.x1, r.y1, *image, r.x1, r.y1, r.x2 - r.x1, r.y2 - r.y1);
-                    }
-                }
             }
 
             if (!isRootItem(source.source))
@@ -637,6 +646,7 @@ void WBufferRenderer::endRender()
     state.buffer = nullptr;
     state.renderer = nullptr;
     state.batchRenderer = nullptr;
+    state.dirty = QRegion();
 
     m_lastBuffer = buffer;
     m_damageRing.rotate();

src/server/qtquick/private/wbufferrenderer_p.h

@@ -142,10 +142,10 @@ class WAYLIB_SERVER_EXPORT WBufferRenderer : public QQuickItem
         QSize pixelSize;
         qreal devicePixelRatio;
         int bufferAge;
-        std::pair<QW_NAMESPACE::qw_buffer*, QQuickRenderTarget> lastRT;
         QW_NAMESPACE::qw_buffer *buffer = nullptr;
         QQuickRenderTarget renderTarget;
         QSGRenderTarget sgRenderTarget;
+        QRegion dirty;
     } state;
 
     QPointer<WOutput> m_output;

src/server/qtquick/woutputrenderwindow.cpp

@@ -950,9 +950,7 @@ WBufferRenderer *OutputHelper::compositeLayers(const QList<LayerData*> layers, b
 {
     Q_ASSERT(!layers.isEmpty());
 
-    const bool usingShadowRenderer = forceShadowRenderer
-                                     // TODO: Support preserveColorContents in Qt in QSGSoftwareRenderer
-                                     || dynamic_cast<QSGSoftwareRenderer*>(renderWindowD()->renderer);
+    const bool usingShadowRenderer = forceShadowRenderer;
 
     if (!m_layerPorxyContainer) {
         m_layerPorxyContainer = new QQuickItem(renderWindow()->contentItem());
@@ -981,6 +979,8 @@ WBufferRenderer *OutputHelper::compositeLayers(const QList<LayerData*> layers, b
         auto outputProxy = m_layerProxys.first();
         outputProxy->setRenderer(bufferRenderer());
         outputProxy->setSize(output->size());
+        outputProxy->setPosition({0, 0});
+        outputProxy->setZ(0);
     } else {
         output = m_output;
 

src/server/qtquick/wquicktextureproxy.cpp

@@ -238,6 +238,10 @@ QSGNode *WQuickTextureProxy::updatePaintNode(QSGNode *old, QQuickItem::UpdatePai
 
     const auto tp = d->sourceItem->textureProvider();
     if (Q_LIKELY(!tp || !tp->texture())) {
+        if (tp) {
+            connect(tp, &QSGTextureProvider::textureChanged,
+                    this, &WQuickTextureProxy::update, Qt::SingleShotConnection);
+        }
         delete old;
         return nullptr;
     }