Add CpuTextureManager class

Author: adazem009

src/CMakeLists.txt

@@ -70,6 +70,8 @@ qt_add_qml_module(scratchcpp-render
 	textbubbleshape.h
 	textbubblepainter.cpp
 	textbubblepainter.h
+    cputexturemanager.cpp
+    cputexturemanager.h
 	blocks/penextension.cpp
 	blocks/penextension.h
 	blocks/penblocks.cpp

src/cputexturemanager.cpp

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "cputexturemanager.h"
+#include "texture.h"
+
+using namespace scratchcpprender;
+
+CpuTextureManager::CpuTextureManager()
+{
+}
+
+CpuTextureManager::~CpuTextureManager()
+{
+    for (const auto &[handle, data] : m_textureData)
+        delete[] data;
+}
+
+GLubyte *CpuTextureManager::getTextureData(const Texture &texture)
+{
+    if (!texture.isValid())
+        return nullptr;
+
+    const GLuint handle = texture.handle();
+    auto it = m_textureData.find(handle);
+
+    if (it == m_textureData.cend()) {
+        if (addTexture(texture))
+            return m_textureData[handle];
+        else
+            return nullptr;
+    } else
+        return it->second;
+}
+
+const std::vector<QPoint> &CpuTextureManager::getTextureConvexHullPoints(const Texture &texture)
+{
+    static const std::vector<QPoint> empty;
+
+    if (!texture.isValid())
+        return empty;
+
+    const GLuint handle = texture.handle();
+    auto it = m_convexHullPoints.find(handle);
+
+    if (it == m_convexHullPoints.cend()) {
+        if (addTexture(texture))
+            return m_convexHullPoints[handle];
+        else
+            return empty;
+    } else
+        return it->second;
+}
+
+bool CpuTextureManager::addTexture(const Texture &texture)
+{
+    if (!texture.isValid())
+        return false;
+
+    const GLuint handle = texture.handle();
+    const int width = texture.width();
+    const int height = texture.height();
+
+    QOpenGLFunctions glF;
+    glF.initializeOpenGLFunctions();
+
+    // Create a FBO for the texture
+    unsigned int fbo;
+    glF.glGenFramebuffers(1, &fbo);
+    glF.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    glF.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, handle, 0);
+
+    if (glF.glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
+        qWarning() << "error: framebuffer incomplete (CpuTextureManager)";
+        glF.glDeleteFramebuffers(1, &fbo);
+        return false;
+    }
+
+    // Read pixels
+    GLubyte *pixels = new GLubyte[width * height * 4]; // 4 channels (RGBA)
+    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+
+    // Flip vertically
+    int rowSize = width * 4;
+    GLubyte *tempRow = new GLubyte[rowSize];
+
+    for (size_t i = 0; i < height / 2; ++i) {
+        size_t topRowIndex = i * rowSize;
+        size_t bottomRowIndex = (height - 1 - i) * rowSize;
+
+        // Swap rows
+        memcpy(tempRow, &pixels[topRowIndex], rowSize);
+        memcpy(&pixels[topRowIndex], &pixels[bottomRowIndex], rowSize);
+        memcpy(&pixels[bottomRowIndex], tempRow, rowSize);
+    }
+
+    delete[] tempRow;
+
+    m_textureData[handle] = pixels;
+    m_convexHullPoints[handle] = {};
+    std::vector<QPoint> &hullPoints = m_convexHullPoints[handle];
+
+    // Get convex hull points
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            int index = (y * width + x) * 4; // 4 channels (RGBA)
+
+            // Check alpha channel
+            if (pixels[index + 3] > 0)
+                hullPoints.push_back(QPoint(x, y));
+        }
+    }
+
+    // Cleanup
+    glF.glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    glF.glDeleteFramebuffers(1, &fbo);
+
+    return true;
+}

src/cputexturemanager.h

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <QPoint>
+#include <QtOpenGL>
+#include <unordered_map>
+
+namespace scratchcpprender
+{
+
+class Texture;
+
+class CpuTextureManager
+{
+    public:
+        CpuTextureManager();
+        ~CpuTextureManager();
+
+        GLubyte *getTextureData(const Texture &texture);
+        const std::vector<QPoint> &getTextureConvexHullPoints(const Texture &texture);
+
+    private:
+        bool addTexture(const Texture &texture);
+
+        std::unordered_map<GLuint, GLubyte *> m_textureData;
+        std::unordered_map<GLuint, std::vector<QPoint>> m_convexHullPoints;
+};
+
+} // namespace scratchcpprender

test/texture/CMakeLists.txt

@@ -1,3 +1,4 @@
+# texture_test
 add_executable(
   texture_test
   texture_test.cpp
@@ -12,3 +13,19 @@ target_link_libraries(
 
 add_test(texture_test)
 gtest_discover_tests(texture_test)
+
+# cputexturemanager_test
+add_executable(
+  cputexturemanager_test
+  cputexturemanager_test.cpp
+)
+
+target_link_libraries(
+  cputexturemanager_test
+  GTest::gtest_main
+  scratchcpp-render
+  ${QT_LIBS}
+)
+
+add_test(cputexturemanager_test)
+gtest_discover_tests(cputexturemanager_test)

test/texture/cputexturemanager_test.cpp

@@ -0,0 +1,107 @@
+#include <cputexturemanager.h>
+#include <texture.h>
+#include <qnanopainter.h>
+
+#include "../common.h"
+
+using namespace scratchcpprender;
+
+class CpuTextureManagerTest : public testing::Test
+{
+    public:
+        void createContextAndSurface(QOpenGLContext *context, QOffscreenSurface *surface)
+        {
+            QSurfaceFormat surfaceFormat;
+            surfaceFormat.setMajorVersion(4);
+            surfaceFormat.setMinorVersion(3);
+
+            context->setFormat(surfaceFormat);
+            context->create();
+            ASSERT_TRUE(context->isValid());
+
+            surface->setFormat(surfaceFormat);
+            surface->create();
+            ASSERT_TRUE(surface->isValid());
+
+            context->makeCurrent(surface);
+            ASSERT_EQ(QOpenGLContext::currentContext(), context);
+        }
+};
+
+class ImagePainter
+{
+    public:
+        ImagePainter(QNanoPainter *painter, const QString &fileName)
+        {
+            QOpenGLFramebufferObjectFormat format;
+            format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+
+            // Begin painting
+            m_fbo = std::make_unique<QOpenGLFramebufferObject>(4, 6, format);
+            m_fbo->bind();
+            painter->beginFrame(m_fbo->width(), m_fbo->height());
+
+            // Paint
+            QNanoImage image = QNanoImage::fromCache(painter, fileName);
+            painter->drawImage(image, 0, 0);
+            painter->endFrame();
+        }
+
+        ~ImagePainter() { m_fbo->release(); }
+
+        QOpenGLFramebufferObject *fbo() const { return m_fbo.get(); };
+
+    private:
+        std::unique_ptr<QOpenGLFramebufferObject> m_fbo;
+};
+
+TEST_F(CpuTextureManagerTest, TextureDataAndHullPoints)
+{
+    static const GLubyte refData1[] = {
+        0, 0, 0, 0, 0,   0, 0,   0,   0,   0,   0,   0,   0,   0,   0, 0,   0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 255, 255, 255, 128, 128, 255, 0, 0, 0, 0, 0, 0, 128, 255, 0, 0, 0, 0, 87, 149, 87, 149,
+        0, 0, 0, 0, 128, 0, 128, 255, 128, 128, 255, 255, 128, 128, 0, 255, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0,   0,   0, 0, 0, 0, 0,  0,   0,  0
+    };
+
+    static const GLubyte refData2[] = {
+        0,  0, 57, 255, 10, 0, 50, 255, 43, 0, 35, 255, 60,  0,   28,  255, 0,  0, 55, 255, 39, 15, 73, 255, 137, 85,  133, 255, 207, 142, 182, 255,
+        10, 0, 50, 255, 23, 4, 50, 255, 4,  0, 7,  255, 204, 204, 196, 255, 11, 0, 35, 255, 59, 46, 76, 255, 135, 146, 140, 255, 99,  123, 99,  255,
+        4,  0, 12, 255, 1,  0, 7,  255, 0,  1, 0,  255, 0,   3,   0,   255, 0,  0, 0,  255, 0,  0,  0,  255, 0,   0,   0,   255, 0,   0,   0,   255
+    };
+
+    static const std::vector<QPoint> refHullPoints1 = { { 1, 1 }, { 2, 1 }, { 3, 1 }, { 1, 2 }, { 3, 2 }, { 1, 3 }, { 2, 3 }, { 3, 3 } };
+
+    static const std::vector<QPoint> refHullPoints2 = {
+        { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 3, 1 }, { 0, 2 }, { 1, 2 }, { 2, 2 }, { 3, 2 },
+        { 0, 3 }, { 1, 3 }, { 2, 3 }, { 3, 3 }, { 0, 4 }, { 1, 4 }, { 2, 4 }, { 3, 4 }, { 0, 5 }, { 1, 5 }, { 2, 5 }, { 3, 5 }
+    };
+
+    // Create OpenGL context
+    QOpenGLContext context;
+    QOffscreenSurface surface;
+    createContextAndSurface(&context, &surface);
+
+    // Paint images
+    QNanoPainter painter;
+    ImagePainter imgPainter1(&painter, "image.png");
+    ImagePainter imgPainter2(&painter, "image.jpg");
+
+    // Read texture data
+    CpuTextureManager manager;
+
+    for (int i = 0; i < 2; i++) {
+        Texture texture1(imgPainter1.fbo()->texture(), imgPainter1.fbo()->size());
+        GLubyte *data = manager.getTextureData(texture1);
+        ASSERT_EQ(memcmp(data, refData1, 96), 0);
+        const auto &hullPoints1 = manager.getTextureConvexHullPoints(texture1);
+        ASSERT_EQ(hullPoints1, refHullPoints1);
+
+        Texture texture2(imgPainter2.fbo()->texture(), imgPainter2.fbo()->size());
+        data = manager.getTextureData(texture2);
+        ASSERT_EQ(memcmp(data, refData2, 96), 0);
+        const auto &hullPoints2 = manager.getTextureConvexHullPoints(texture2);
+        ASSERT_EQ(hullPoints2, refHullPoints2);
+    }
+
+    // Cleanup
+    context.doneCurrent();
+}