Add texture data methods to PenLayer

Author: adazem009

src/ipenlayer.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <qnanoquickitem.h>
+#include <scratchcpp/rect.h>
 
 namespace libscratchcpp
 {
@@ -37,6 +38,9 @@ class IPenLayer : public QNanoQuickItem
         virtual void drawLine(const PenAttributes &penAttributes, double x0, double y0, double x1, double y1) = 0;
 
         virtual QOpenGLFramebufferObject *framebufferObject() const = 0;
+        virtual QRgb colorAtScratchPoint(double x, double y) const = 0;
+
+        virtual const libscratchcpp::Rect &getBounds() const = 0;
 };
 
 } // namespace scratchcpprender

src/penlayer.cpp

@@ -76,6 +76,8 @@ void scratchcpprender::PenLayer::clear()
     m_glF->glEnable(GL_SCISSOR_TEST);
     m_fbo->release();
 
+    m_textureDirty = true;
+    m_boundsDirty = true;
     update();
 }
 
@@ -121,6 +123,8 @@ void scratchcpprender::PenLayer::drawLine(const PenAttributes &penAttributes, do
     painter.end();
     m_fbo->release();
 
+    m_textureDirty = true;
+    m_boundsDirty = true;
     update();
 }
 
@@ -129,6 +133,84 @@ QOpenGLFramebufferObject *PenLayer::framebufferObject() const
     return m_fbo.get();
 }
 
+QRgb PenLayer::colorAtScratchPoint(double x, double y) const
+{
+    if (m_textureDirty)
+        const_cast<PenLayer *>(this)->updateTexture();
+
+    if (!m_texture.isValid())
+        return qRgba(0, 0, 0, 0);
+
+    const double width = m_texture.width();
+    const double height = m_texture.height();
+
+    // Translate the coordinates
+    // TODO: Apply scale
+    x = std::floor(x + width / 2.0);
+    y = std::floor(-y + height / 2.0);
+
+    // If the point is outside the texture, return fully transparent color
+    if ((x < 0 || x >= width) || (y < 0 || y >= height))
+        return qRgba(0, 0, 0, 0);
+
+    GLubyte *data = m_textureManager.getTextureData(m_texture);
+    const int index = (y * width + x) * 4; // RGBA channels
+    Q_ASSERT(index >= 0 && index < width * height * 4);
+    return qRgba(data[index], data[index + 1], data[index + 2], data[index + 3]);
+}
+
+const libscratchcpp::Rect &PenLayer::getBounds() const
+{
+    if (m_textureDirty)
+        const_cast<PenLayer *>(this)->updateTexture();
+
+    if (m_boundsDirty) {
+        if (!m_texture.isValid()) {
+            m_bounds = libscratchcpp::Rect();
+            return m_bounds;
+        }
+
+        m_boundsDirty = false;
+        double left = std::numeric_limits<double>::infinity();
+        double top = -std::numeric_limits<double>::infinity();
+        double right = -std::numeric_limits<double>::infinity();
+        double bottom = std::numeric_limits<double>::infinity();
+        const double width = m_texture.width();
+        const double height = m_texture.height();
+        const std::vector<QPoint> &points = m_textureManager.getTextureConvexHullPoints(m_texture);
+
+        if (points.empty()) {
+            m_bounds = libscratchcpp::Rect();
+            return m_bounds;
+        }
+
+        for (const QPointF &point : points) {
+            // TODO: Apply scale
+            double x = point.x() - width / 2;
+            double y = -point.y() + height / 2;
+
+            if (x < left)
+                left = x;
+
+            if (x > right)
+                right = x;
+
+            if (y > top)
+                top = y;
+
+            if (y < bottom)
+                bottom = y;
+        }
+
+        m_bounds.setLeft(left);
+        m_bounds.setTop(top);
+        m_bounds.setRight(right + 1);
+        m_bounds.setBottom(bottom - 1);
+    }
+
+    return m_bounds;
+}
+
 IPenLayer *PenLayer::getProjectPenLayer(libscratchcpp::IEngine *engine)
 {
     auto it = m_projectPenLayers.find(engine);
@@ -148,3 +230,21 @@ QNanoQuickItemPainter *PenLayer::createItemPainter() const
 {
     return new PenLayerPainter;
 }
+
+void PenLayer::updateTexture()
+{
+    if (!m_fbo)
+        return;
+
+    m_textureDirty = false;
+    m_textureManager.removeTexture(m_texture);
+
+    if (!m_resolvedFbo || m_resolvedFbo->size() != m_fbo->size()) {
+        QOpenGLFramebufferObjectFormat format;
+        format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+        m_resolvedFbo = std::make_unique<QOpenGLFramebufferObject>(m_fbo->size(), format);
+    }
+
+    QOpenGLFramebufferObject::blitFramebuffer(m_resolvedFbo.get(), m_fbo.get());
+    m_texture = Texture(m_resolvedFbo->texture(), m_resolvedFbo->size());
+}

src/penlayer.h

@@ -2,13 +2,16 @@
 
 #pragma once
 
-#include <ipenlayer.h>
 #include <QOpenGLFramebufferObject>
 #include <QOpenGLPaintDevice>
 #include <QOpenGLFunctions>
 #include <QPainter>
 #include <scratchcpp/iengine.h>
 
+#include "ipenlayer.h"
+#include "texture.h"
+#include "cputexturemanager.h"
+
 namespace scratchcpprender
 {
 
@@ -33,6 +36,9 @@ class PenLayer : public IPenLayer
         void drawLine(const PenAttributes &penAttributes, double x0, double y0, double x1, double y1) override;
 
         QOpenGLFramebufferObject *framebufferObject() const override;
+        QRgb colorAtScratchPoint(double x, double y) const override;
+
+        const libscratchcpp::Rect &getBounds() const override;
 
         static IPenLayer *getProjectPenLayer(libscratchcpp::IEngine *engine);
         static void addPenLayer(libscratchcpp::IEngine *engine, IPenLayer *penLayer); // for tests
@@ -44,13 +50,21 @@ class PenLayer : public IPenLayer
         QNanoQuickItemPainter *createItemPainter() const override;
 
     private:
+        void updateTexture();
+
         static std::unordered_map<libscratchcpp::IEngine *, IPenLayer *> m_projectPenLayers;
         bool m_antialiasingEnabled = true;
         libscratchcpp::IEngine *m_engine = nullptr;
         std::unique_ptr<QOpenGLFramebufferObject> m_fbo;
+        std::unique_ptr<QOpenGLFramebufferObject> m_resolvedFbo;
         std::unique_ptr<QOpenGLPaintDevice> m_paintDevice;
         QOpenGLFramebufferObjectFormat m_fboFormat;
         std::unique_ptr<QOpenGLFunctions> m_glF;
+        Texture m_texture;
+        bool m_textureDirty = true;
+        mutable CpuTextureManager m_textureManager;
+        mutable bool m_boundsDirty = true;
+        mutable libscratchcpp::Rect m_bounds;
 };
 
 } // namespace scratchcpprender

test/mocks/penlayermock.h

@@ -23,6 +23,9 @@ class PenLayerMock : public IPenLayer
         MOCK_METHOD(void, drawLine, (const PenAttributes &, double, double, double, double), (override));
 
         MOCK_METHOD(QOpenGLFramebufferObject *, framebufferObject, (), (const, override));
+        MOCK_METHOD(QRgb, colorAtScratchPoint, (double, double), (const, override));
+
+        MOCK_METHOD(const libscratchcpp::Rect &, getBounds, (), (const, override));
 
         MOCK_METHOD(QNanoQuickItemPainter *, createItemPainter, (), (const, override));
 };

test/penlayer/penlayer_test.cpp

@@ -257,3 +257,76 @@ TEST_F(PenLayerTest, DrawLine)
     buffer.open(QFile::ReadOnly);
     ASSERT_EQ(ref.readAll(), buffer.readAll());
 }
+
+TEST_F(PenLayerTest, TextureData)
+{
+    PenLayer penLayer;
+    penLayer.setAntialiasingEnabled(false);
+    EngineMock engine;
+    EXPECT_CALL(engine, stageWidth()).WillRepeatedly(Return(6));
+    EXPECT_CALL(engine, stageHeight()).WillRepeatedly(Return(4));
+    penLayer.setEngine(&engine);
+
+    PenAttributes attr;
+    attr.color = QColor(255, 0, 0);
+    attr.diameter = 1;
+    penLayer.drawLine(attr, -3, 2, 3, -2);
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-3, 2), qRgb(255, 0, 0));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(0, 2), qRgba(0, 0, 0, 0));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-1, 1), qRgb(255, 0, 0));
+
+    Rect bounds = penLayer.getBounds();
+    ASSERT_EQ(bounds.left(), -3);
+    ASSERT_EQ(bounds.top(), 2);
+    ASSERT_EQ(bounds.right(), 3);
+    ASSERT_EQ(bounds.bottom(), -2);
+
+    attr.color = QColor(0, 128, 0, 128);
+    attr.diameter = 2;
+    penLayer.drawLine(attr, -3, -2, 3, 2);
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-3, 2), qRgb(255, 0, 0));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(0, 2), qRgba(0, 64, 0, 128));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-1, 1), qRgb(127, 64, 0));
+
+    bounds = penLayer.getBounds();
+    ASSERT_EQ(bounds.left(), -3);
+    ASSERT_EQ(bounds.top(), 2);
+    ASSERT_EQ(bounds.right(), 3);
+    ASSERT_EQ(bounds.bottom(), -2);
+
+    penLayer.clear();
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-3, 2), 0);
+    ASSERT_EQ(penLayer.colorAtScratchPoint(0, 2), 0);
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-1, 1), 0);
+
+    bounds = penLayer.getBounds();
+    ASSERT_EQ(bounds.left(), 0);
+    ASSERT_EQ(bounds.top(), 0);
+    ASSERT_EQ(bounds.right(), 0);
+    ASSERT_EQ(bounds.bottom(), 0);
+
+    attr.color = QColor(0, 255, 0, 255);
+    attr.diameter = 1;
+    penLayer.drawLine(attr, 0, -1, 1, 1);
+    ASSERT_EQ(penLayer.colorAtScratchPoint(0, 1), qRgb(0, 255, 0));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(0, 0), qRgb(0, 255, 0));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-3, 1), qRgba(0, 0, 0, 0));
+
+    bounds = penLayer.getBounds();
+    ASSERT_EQ(bounds.left(), 0);
+    ASSERT_EQ(bounds.top(), 1);
+    ASSERT_EQ(bounds.right(), 1);
+    ASSERT_EQ(bounds.bottom(), -1);
+
+    attr.diameter = 2;
+    penLayer.drawPoint(attr, -2, 0);
+    ASSERT_EQ(penLayer.colorAtScratchPoint(0, 1), qRgb(0, 255, 0));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(0, 0), qRgb(0, 255, 0));
+    ASSERT_EQ(penLayer.colorAtScratchPoint(-3, 1), qRgb(0, 255, 0));
+
+    bounds = penLayer.getBounds();
+    ASSERT_EQ(bounds.left(), -3);
+    ASSERT_EQ(bounds.top(), 1);
+    ASSERT_EQ(bounds.right(), 1);
+    ASSERT_EQ(bounds.bottom(), -1);
+}