TextureComparer: multiple slots per WindowData

Signed-off-by: Xarblu <xarblu@protonmail.com>

Author: xarblu

src/blur_cache.cpp

@@ -7,7 +7,6 @@
 #include "texture_comparer.hpp"
 
 #include <epoxy/gl.h>
-#include <qloggingcategory.h>
 #include <scene/scene.h>
 #include <sys/types.h>
 
@@ -128,7 +127,7 @@ BBDX::BlurCacheEntry* BBDX::BlurCacheLRU::get() {
     return m_entry.get();
 }
 
-const BBDX::TextureComparer::WindowData* BBDX::BlurCacheLRU::textureCompareWindowData() {
+BBDX::TextureComparer::WindowData* BBDX::BlurCacheLRU::textureCompareWindowData() {
     // alloc only happens once per Window+RenderView combination
     if (!m_textureCompareWindowData) [[unlikely]] {
         m_textureCompareWindowData = TextureComparer::WindowData::create();
@@ -305,23 +304,25 @@ void BBDX::BlurCache::prepareCache(BBDX::BlurCacheLRU &cache) {
         return;
     }
 
-    const auto textureCompareWindowData = cache.textureCompareWindowData();
+    auto textureCompareWindowData = cache.textureCompareWindowData();
     if (!textureCompareWindowData) [[unlikely]] {
         // GL resource alloc failed
         return;
     }
 
+    const auto textureCompareWindowDataSlot = textureCompareWindowData->getSlot();
+
     const auto newTexture = m_paintData.blitFramebuffer->colorAttachment();
     const auto cachedTexture = cacheEntry->blitTexture.get();
 
-    m_textureComparer->compareAndUpdate(textureCompareWindowData,
+    m_textureComparer->compareAndUpdate(textureCompareWindowDataSlot,
                                         newTexture,
                                         cachedTexture,
                                         cacheEntry->localDirtyRegionGL(*m_paintData.dirtyRegion),
                                         m_paintData.window);
 
     // await the query from TextureComparer::compareAndUpdate()
-    glBeginConditionalRender(textureCompareWindowData->query, GL_QUERY_BY_REGION_WAIT);
+    glBeginConditionalRender(textureCompareWindowDataSlot.second, GL_QUERY_BY_REGION_WAIT);
     m_paintData.glBeginConditionalRenderCalled = true;
 
     // *if* the texture changed we need to ensure it's fully flushed

src/blur_cache.hpp

@@ -128,7 +128,7 @@ class BlurCacheLRU {
      * Return const pointer to the contained texture compare
      * region and lazily create it if needed
      */
-    const TextureComparer::WindowData* textureCompareWindowData();
+    TextureComparer::WindowData* textureCompareWindowData();
 
     /**
      * Add an entry to the cache, potentially removing the already existing entry.

src/texture_comparer.cpp

@@ -15,6 +15,7 @@
 
 #include <memory>
 #include <unordered_map>
+#include <array>
 
 Q_LOGGING_CATEGORY(BBDX_TEXTURE_COMPARER, "kwin_effect_better_blur_dx.texture_comparer", QtInfoMsg)
 
@@ -48,28 +49,34 @@ static inline const char* glslFormatString(GLenum internalFormat) {
 std::unique_ptr<BBDX::TextureComparer::WindowData> BBDX::TextureComparer::WindowData::create() {
     std::unique_ptr<WindowData> windowData{new WindowData{}};
 
-    glGenBuffers(1, &windowData->counterBuffer);
+    glGenBuffers(SLOTS, windowData->m_counterBuffers.data());
+    glGenQueries(SLOTS, windowData->m_queries.data());
 
     // allocate a single GLuint (the change counter)
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, windowData->counterBuffer);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint), nullptr, GL_DYNAMIC_DRAW);
+    for (const auto &buffer : windowData->m_counterBuffers) {
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
+        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GLuint), nullptr, GL_DYNAMIC_DRAW);
+    }
     glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
 
-    glGenQueries(1, &windowData->query);
-
     return windowData;
 }
 
 BBDX::TextureComparer::WindowData::~WindowData() {
-    if (counterBuffer > 0) {
-        glDeleteBuffers(1, &counterBuffer);
-    }
+    glDeleteBuffers(SLOTS, m_counterBuffers.data());
+    glDeleteQueries(SLOTS, m_queries.data());
+}
+
 
-    if (query > 0) {
-        glDeleteQueries(1, &query);
+std::pair<GLuint, GLuint> BBDX::TextureComparer::WindowData::getSlot() {
+    const int slot = m_nextSlot;
+
+    if (++m_nextSlot >= SLOTS) {
+        m_nextSlot = 0;
     }
-}
 
+    return {m_counterBuffers[slot], m_queries[slot]};
+}
 
 std::unique_ptr<BBDX::TextureComparer::ComputeShader> BBDX::TextureComparer::buildComputeShader(GLenum textureFormat) {
     qCDebug(BBDX_TEXTURE_COMPARER) << "Creating texture compare instance for" << glslFormatString(textureFormat);
@@ -180,11 +187,14 @@ std::unique_ptr<BBDX::TextureComparer> BBDX::TextureComparer::create() {
     return textureComparer;
 }
 
-void BBDX::TextureComparer::compareAndUpdate(const WindowData *windowData, KWin::GLTexture *freshBlit, KWin::GLTexture *cachedBlit, const KWin::Region &localDirtyRegionGL, const KWin::EffectWindow *window) {
+void BBDX::TextureComparer::compareAndUpdate(const std::pair<GLuint, GLuint> &windowDataSlot, KWin::GLTexture *freshBlit, KWin::GLTexture *cachedBlit, const KWin::Region &localDirtyRegionGL, const KWin::EffectWindow *window) {
 #if !defined(BBDX_DEBUG)
     Q_UNUSED(window);
 #endif
 
+    const GLuint counterBuffer{windowDataSlot.first};
+    const GLuint query{windowDataSlot.second};
+
     const auto textureFormat = freshBlit->internalFormat();
 
     // lazily create compute shader instances in case we need
@@ -212,10 +222,10 @@ void BBDX::TextureComparer::compareAndUpdate(const WindowData *windowData, KWin:
 
     // reset and bind counter
     const GLuint zero = 0;
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, windowData->counterBuffer);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, counterBuffer);
     glClearBufferSubData(GL_SHADER_STORAGE_BUFFER, GL_R32UI, 0, sizeof(GLuint), GL_RED_INTEGER, GL_UNSIGNED_INT, &zero);
     // slot 2 - matching compute shader
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, windowData->counterBuffer);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, counterBuffer);
 
     // prepare compute shader
     GLint prevProgram{};
@@ -262,7 +272,7 @@ void BBDX::TextureComparer::compareAndUpdate(const WindowData *windowData, KWin:
     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
     glDepthMask(GL_FALSE);
 
-    glBeginQuery(GL_ANY_SAMPLES_PASSED, windowData->query);
+    glBeginQuery(GL_ANY_SAMPLES_PASSED, query);
     glDrawArrays(GL_POINTS, 0, 1);
     glEndQuery(GL_ANY_SAMPLES_PASSED);
 

src/texture_comparer.hpp

@@ -11,6 +11,7 @@
 
 #include <memory>
 #include <unordered_map>
+#include <array>
 
 namespace BBDX {
 
@@ -19,20 +20,33 @@ class TextureComparer {
     /**
      * Per Window (BlurCacheLRU) data
      */
-    struct WindowData {
-    private:
+    class WindowData {
+        /**
+         * Amount of slots per window
+         */
+        static constexpr int SLOTS{3};
+
+        /**
+         * Next slot to return
+         */
+        int m_nextSlot{0};
+
+        /**
+         * SSBO counting changed blocks
+         */
+        std::array<GLuint, SLOTS> m_counterBuffers{};
+
+        /**
+         * GL query object used for conditional render
+         */
+        std::array<GLuint, SLOTS> m_queries{};
+
         /**
          * Use create()
          */
         WindowData() = default;
 
     public:
-        // SSBO counting changed blocks
-        GLuint counterBuffer{0};
-
-        // GL query object used for conditional render
-        GLuint query{0};
-
         /**
          * Create WindowData
          * nullptr on error
@@ -43,6 +57,11 @@ class TextureComparer {
          * Cleanup GL resources
          */
         ~WindowData();
+
+        /**
+         * Get a matching {counterBuffer, query} tuple
+         */
+        std::pair<GLuint, GLuint> getSlot();
     };
 
 private:
@@ -91,13 +110,15 @@ class TextureComparer {
      * Compare and update cachedBlit with freshBlit
      * within the localDirtyRegion (in GL coords)
      *
+     * windowDataSlot is a pair as returned by WindowData::getSlot()
+     *
      * The EffectWindow is optional and only used
      * for extra logging in the debug build (BBDX_DEBUG)
      *
      * The result of the comparison can be found using the
      * query object returned by queryObject()
      */
-    void compareAndUpdate(const WindowData *windowData, KWin::GLTexture *freshBlit, KWin::GLTexture *cachedBlit, const KWin::Region &localDirtyRegionGL, const KWin::EffectWindow *window = nullptr);
+    void compareAndUpdate(const std::pair<GLuint, GLuint> &windowDataSlot, KWin::GLTexture *freshBlit, KWin::GLTexture *cachedBlit, const KWin::Region &localDirtyRegionGL, const KWin::EffectWindow *window = nullptr);
 };
 
 }