BlurCache: don't rebuild the cache when dirtyRegion is empty

When KWin paints the window with damage that doesn't intersect
backgroundRect (e.g. shadow-only damage on focus changes) the
dirtyRegion is empty: nothing behind the window was repainted, so
there are no fresh pixels to compare against and prepareCache()
bails before setting up the conditional render.

Previously this caused an *ungated* re-blur: all blur passes ran
and drawToCache() overwrote the cached texture - the only place
the cache was rewritten outside the conditional render. Besides
wasting GPU time on every such paint, this rebuilt the cache from
the reference blit alone, which can contain never-initialized
regions, and re-applied the noise and rounded corner passes to it.

Track this case as useCachedOnly in the paint data and skip the
scene blit, all blur passes and the cache writes, only drawing the
existing cached texture. If no cache entry exists yet there is
nothing valid to build one from - bail entirely; the on-screen
draw is clipped to the deviceRegion anyway.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Mathias

src/blur.cpp

@@ -1021,12 +1021,23 @@ void BlurEffect::blur(const RenderTarget &renderTarget, const RenderViewport &vi
 #else
     m_blurCache->preparePaintData(m_currentView, w, &dirtyRegion, renderInfo.framebuffers[0].get(), &backgroundRect, &scaledBackgroundRect, renderInfo.cache);
 
+    // BBDX: If the dirtyRegion doesn't intersect backgroundRect nothing behind the
+    //       window was repainted this frame - the renderTarget only holds stale data
+    //       there. Without a cache entry to fall back on there is nothing valid to
+    //       draw or build a cache entry from, so bail. The on-screen draw would be
+    //       clipped to the deviceRegion anyway.
+    if (dirtyRegion.isEmpty() && !renderInfo.cache.get()) {
+        return;
+    }
+
+    if (!m_blurCache->useCachedOnly()) {
     // BBDX: Always blit the entire backgroundRect to avoid subtle rounding errors on scaled RenderViews.
     //       It took me way too many hours to figure out that this is what's causing sporadic
     //       pixel mismatches during textureCompare...
     //       Note that this does not give us more usable data (everything outside the dirtyRegion is garbage
     //       not part of this paint), it just makes sure that the data we do get is properly aligned.
     renderInfo.framebuffers[0]->blitFromRenderTarget(renderTarget, viewport, backgroundRect, backgroundRect.translated(-backgroundRect.topLeft()));
+    } // indent intentional for KWin diff
 #endif
 
     // Upload the geometry: the first 6 vertices are used when downsampling and upsampling offscreen,
@@ -1143,6 +1154,16 @@ void BlurEffect::blur(const RenderTarget &renderTarget, const RenderViewport &vi
         return;
     }
 
+#if KWIN_VERSION < KWIN_VERSION_CODE(6, 6, 90)
+    const QMatrix4x4 &colorMatrix = blurInfo.colorMatrix ? *blurInfo.colorMatrix : m_colorMatrix;
+#else
+    const QMatrix4x4 &colorMatrix = m_colorMatrix;
+#endif
+    const float modulation = opacity * opacity;
+
+    // BBDX: without fresh data there is nothing to rebuild the cache from -
+    //       skip all blur passes and only draw the cached texture below
+    if (!m_blurCache->useCachedOnly()) {
     // The downsample pass of the dual Kawase algorithm: the background will be scaled down 50% every iteration.
     {
         ShaderManager::instance()->pushShader(m_downsamplePass.shader.get());
@@ -1204,13 +1225,6 @@ void BlurEffect::blur(const RenderTarget &renderTarget, const RenderViewport &vi
         ShaderManager::instance()->popShader();
     }
 
-#if KWIN_VERSION < KWIN_VERSION_CODE(6, 6, 90)
-    const QMatrix4x4 &colorMatrix = blurInfo.colorMatrix ? *blurInfo.colorMatrix : m_colorMatrix;
-#else
-    const QMatrix4x4 &colorMatrix = m_colorMatrix;
-#endif
-    const float modulation = opacity * opacity;
-
 #if BETTERBLUR_NOT_NEEDED
     if (const BorderRadius cornerRadius = w->window()->borderRadius(); !cornerRadius.isNull()) {
         ShaderManager::instance()->pushShader(m_roundedOnscreenPass.shader.get());
@@ -1345,6 +1359,7 @@ void BlurEffect::blur(const RenderTarget &renderTarget, const RenderViewport &vi
     if (const BorderRadius cornerRadius = m_windowManager->getEffectiveBorderRadius(w); !cornerRadius.isNull()) {
         m_roundedCornersPass->apply(cornerRadius, viewport, scaledBackgroundRect, renderInfo, w, data, vbo, m_blurCache.get());
     }
+    } // indent intentional for KWin diff
 
     // BBDX:
     m_blurCache->drawCached(viewport, renderInfo, vbo, vertexCount, modulation);

src/blur_cache.cpp

@@ -192,6 +192,8 @@ void BBDX::BlurCache::preparePaintData(const KWin::RenderView *view,
     }
     m_paintData.textureCompareVertexCount = m_paintData.textureCompareRegion.rects().size() * 6;
 
+    m_paintData.useCachedOnly = cache.get() && m_paintData.textureCompareRegion.isEmpty();
+
     // the cache entry needs to stay in sync
     // so BlurCacheEntry::localDirtyRegion() returns
     // correct info
@@ -330,10 +332,11 @@ void BBDX::BlurCache::prepareCache(BBDX::BlurCacheLRU &cache,
         return;
     }
 
-    // Somehow we can end up here with an empty textureCompareRegion
-    // which would mean there was no dirtyRegion and thus no blitted data.
-    //
-    // TODO: currently this just causes re-blur 
+    // We can end up here with an empty textureCompareRegion when KWin
+    // paints the window with damage that doesn't intersect backgroundRect
+    // (e.g. shadow-only damage on focus change) - there is no blitted data.
+    // BlurEffect::blur() skips the blur passes via useCachedOnly() and
+    // only draws the cached texture.
     if (m_paintData.textureCompareRegion.isEmpty()) {
         return;
     }

src/blur_cache.hpp

@@ -192,6 +192,11 @@ class BlurCache {
         // on first paint before we have a usuable cache entry
         // we won't call glBeginConditionalRender
         bool glBeginConditionalRenderCalled{false};
+
+        // nothing inside backgroundRect is repainted this paint
+        // but we have a valid cache entry - there is no fresh data
+        // to compare against or blur so just draw the cached texture
+        bool useCachedOnly{false};
     } m_paintData;
 
 public:
@@ -216,6 +221,19 @@ class BlurCache {
                           const KWin::Rect *scaledBackgroundRect,
                           BlurCacheLRU &cache);
 
+    /**
+     * Whether this paint should skip the blit and blur passes
+     * and only draw the existing cached texture.
+     *
+     * True when the dirtyRegion doesn't intersect backgroundRect
+     * while a valid cache entry exists. Without fresh pixels there
+     * is nothing to compare against or blur - rebuilding anyway would
+     * recreate the cache from stale data.
+     *
+     * Only valid after preparePaintData() was called.
+     */
+    bool useCachedOnly() const { return m_paintData.useCachedOnly; }
+
     /**
      * Injects the geometry used for the cache, in logical pixels
      * but scaled to what would be drawn on the device.