Add PenLayer and PenLayerPainter classes

Author: adazem009

src/CMakeLists.txt

@@ -49,6 +49,11 @@ qt_add_qml_module(scratchcpp-render
 	mouseeventhandler.h
 	keyeventhandler.cpp
 	keyeventhandler.h
+	ipenlayer.h
+	penlayer.cpp
+	penlayer.h
+	penlayerpainter.cpp
+	penlayerpainter.h
 	penattributes.h
 )
 

src/ipenlayer.h

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <qnanoquickitem.h>
+
+namespace libscratchcpp
+{
+
+class IEngine;
+
+}
+
+namespace scratchcpprender
+{
+
+struct PenAttributes;
+
+class IPenLayer : public QNanoQuickItem
+{
+    public:
+        IPenLayer(QNanoQuickItem *parent = nullptr) :
+            QNanoQuickItem(parent)
+        {
+        }
+
+        virtual ~IPenLayer() { }
+
+        virtual libscratchcpp::IEngine *engine() const = 0;
+        virtual void setEngine(libscratchcpp::IEngine *newEngine) = 0;
+
+        virtual void clear() = 0;
+        virtual void drawPoint(const PenAttributes &penAttributes, double x, double y) = 0;
+        virtual void drawLine(const PenAttributes &penAttributes, double x0, double y0, double x1, double y1) = 0;
+
+        virtual QOpenGLFramebufferObject *framebufferObject() const = 0;
+};
+
+} // namespace scratchcpprender

src/penlayer.cpp

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "penlayer.h"
+#include "penlayerpainter.h"
+#include "penattributes.h"
+
+using namespace scratchcpprender;
+
+std::unordered_map<libscratchcpp::IEngine *, IPenLayer *> PenLayer::m_projectPenLayers;
+
+PenLayer::PenLayer(QNanoQuickItem *parent) :
+    IPenLayer(parent)
+{
+    m_fboFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+    m_fboFormat.setSamples(4);
+}
+
+PenLayer::~PenLayer()
+{
+    if (m_engine)
+        m_projectPenLayers.erase(m_engine);
+
+    if (m_painter && m_painter->isActive())
+        m_painter->end();
+}
+
+libscratchcpp::IEngine *PenLayer::engine() const
+{
+    return m_engine;
+}
+
+void PenLayer::setEngine(libscratchcpp::IEngine *newEngine)
+{
+    if (m_engine == newEngine)
+        return;
+
+    if (m_engine)
+        m_projectPenLayers.erase(m_engine);
+
+    m_engine = newEngine;
+
+    if (m_engine) {
+        m_projectPenLayers[m_engine] = this;
+        m_fbo = std::make_unique<QOpenGLFramebufferObject>(m_engine->stageWidth(), m_engine->stageHeight(), m_fboFormat);
+        Q_ASSERT(m_fbo->isValid());
+
+        if (m_painter && m_painter->isActive())
+            m_painter->end();
+
+        m_paintDevice = std::make_unique<QOpenGLPaintDevice>(m_fbo->size());
+        m_painter = std::make_unique<QPainter>(m_paintDevice.get());
+        clear();
+    }
+
+    emit engineChanged();
+}
+
+void scratchcpprender::PenLayer::clear()
+{
+    if (!m_fbo)
+        return;
+
+    m_fbo->bind();
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    m_fbo->release();
+
+    update();
+}
+
+void scratchcpprender::PenLayer::drawPoint(const PenAttributes &penAttributes, double x, double y)
+{
+    drawLine(penAttributes, x, y, x, y);
+}
+
+void scratchcpprender::PenLayer::drawLine(const PenAttributes &penAttributes, double x0, double y0, double x1, double y1)
+{
+    if (!m_fbo || !m_painter || !m_engine)
+        return;
+
+    // Begin painting
+    m_fbo->bind();
+    m_painter->beginNativePainting();
+    m_painter->setRenderHint(QPainter::Antialiasing);
+    m_painter->setRenderHint(QPainter::SmoothPixmapTransform, false);
+
+    // Translate to Scratch coordinate system
+    double stageWidthHalf = m_engine->stageWidth() / 2;
+    double stageHeightHalf = m_engine->stageHeight() / 2;
+    x0 += stageWidthHalf;
+    y0 = stageHeightHalf - y0;
+    x1 += stageWidthHalf;
+    y1 = stageHeightHalf - y1;
+
+    // Set pen attributes
+    QPen pen(penAttributes.color);
+    pen.setWidthF(penAttributes.diameter);
+    pen.setCapStyle(Qt::RoundCap);
+    m_painter->setPen(pen);
+
+    // If the start and end coordinates are the same, draw a point, otherwise draw a line
+    if (x0 == x1 && y0 == y1)
+        m_painter->drawPoint(x0, y0);
+    else
+        m_painter->drawLine(x0, y0, x1, y1);
+
+    // End painting
+    m_painter->endNativePainting();
+    m_fbo->release();
+
+    update();
+}
+
+QOpenGLFramebufferObject *PenLayer::framebufferObject() const
+{
+    return m_fbo.get();
+}
+
+IPenLayer *PenLayer::getProjectPenLayer(libscratchcpp::IEngine *engine)
+{
+    auto it = m_projectPenLayers.find(engine);
+
+    if (it != m_projectPenLayers.cend())
+        return it->second;
+
+    return nullptr;
+}
+
+QNanoQuickItemPainter *PenLayer::createItemPainter() const
+{
+    return new PenLayerPainter;
+}

src/penlayer.h

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <ipenlayer.h>
+#include <QOpenGLFramebufferObject>
+#include <QOpenGLPaintDevice>
+#include <scratchcpp/iengine.h>
+
+namespace scratchcpprender
+{
+
+class PenLayer : public IPenLayer
+{
+        Q_OBJECT
+        QML_ELEMENT
+        Q_PROPERTY(libscratchcpp::IEngine *engine READ engine WRITE setEngine NOTIFY engineChanged)
+
+    public:
+        PenLayer(QNanoQuickItem *parent = nullptr);
+        ~PenLayer();
+
+        libscratchcpp::IEngine *engine() const override;
+        void setEngine(libscratchcpp::IEngine *newEngine) override;
+
+        void clear() override;
+        void drawPoint(const PenAttributes &penAttributes, double x, double y) override;
+        void drawLine(const PenAttributes &penAttributes, double x0, double y0, double x1, double y1) override;
+
+        QOpenGLFramebufferObject *framebufferObject() const override;
+
+        static IPenLayer *getProjectPenLayer(libscratchcpp::IEngine *engine);
+
+    signals:
+        void engineChanged();
+
+    protected:
+        QNanoQuickItemPainter *createItemPainter() const override;
+
+    private:
+        static std::unordered_map<libscratchcpp::IEngine *, IPenLayer *> m_projectPenLayers;
+        libscratchcpp::IEngine *m_engine = nullptr;
+        std::unique_ptr<QOpenGLFramebufferObject> m_fbo;
+        std::unique_ptr<QOpenGLPaintDevice> m_paintDevice;
+        std::unique_ptr<QPainter> m_painter;
+        QOpenGLFramebufferObjectFormat m_fboFormat;
+};
+
+} // namespace scratchcpprender

src/penlayerpainter.cpp

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "penlayerpainter.h"
+#include "penlayer.h"
+
+using namespace scratchcpprender;
+
+PenLayerPainter::PenLayerPainter(QOpenGLFramebufferObject *fbo)
+{
+    m_targetFbo = fbo;
+}
+
+void PenLayerPainter::paint(QNanoPainter *painter)
+{
+    if (QThread::currentThread() != qApp->thread()) {
+        qFatal("Error: Rendering must happen in the GUI thread to work correctly. Please disable threaded render loop using qputenv(\"QSG_RENDER_LOOP\", \"basic\") before constructing your "
+               "application object.");
+    }
+
+    QOpenGLContext *context = QOpenGLContext::currentContext();
+    Q_ASSERT(context);
+
+    if (!context || !m_fbo)
+        return;
+
+    // Custom FBO - only used for testing
+    QOpenGLFramebufferObject *targetFbo = m_targetFbo ? m_targetFbo : framebufferObject();
+
+    QOpenGLFramebufferObjectFormat format;
+    format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+
+    // Blit the FBO to a temporary FBO first (multisampled FBOs can only be blitted to FBOs with the same size)
+    QOpenGLFramebufferObject tmpFbo(m_fbo->size(), format);
+    QOpenGLFramebufferObject::blitFramebuffer(&tmpFbo, m_fbo);
+    QOpenGLFramebufferObject::blitFramebuffer(targetFbo, &tmpFbo);
+}
+
+void PenLayerPainter::synchronize(QNanoQuickItem *item)
+{
+    IPenLayer *penLayer = dynamic_cast<IPenLayer *>(item);
+    Q_ASSERT(penLayer);
+
+    if (penLayer)
+        m_fbo = penLayer->framebufferObject();
+}

src/penlayerpainter.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <qnanoquickitempainter.h>
+
+#include "texture.h"
+
+namespace scratchcpprender
+{
+
+class PenLayerPainter : public QNanoQuickItemPainter
+{
+    public:
+        PenLayerPainter(QOpenGLFramebufferObject *fbo = nullptr);
+
+        void paint(QNanoPainter *painter) override;
+        void synchronize(QNanoQuickItem *item) override;
+
+    private:
+        QOpenGLFramebufferObject *m_targetFbo = nullptr;
+        QOpenGLFramebufferObject *m_fbo = nullptr;
+};
+
+} // namespace scratchcpprender

test/CMakeLists.txt

@@ -32,3 +32,5 @@ add_subdirectory(monitor_models)
 add_subdirectory(texture)
 add_subdirectory(skins)
 add_subdirectory(penattributes)
+add_subdirectory(penlayer)
+add_subdirectory(penlayerpainter)

test/lines.png

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <ipenlayer.h>
+#include <qnanoquickitem.h>
+#include <gmock/gmock.h>
+
+using namespace scratchcpprender;
+
+namespace scratchcpprender
+{
+
+class PenLayerMock : public IPenLayer
+{
+    public:
+        MOCK_METHOD(libscratchcpp::IEngine *, engine, (), (const, override));
+        MOCK_METHOD(void, setEngine, (libscratchcpp::IEngine *), (override));
+
+        MOCK_METHOD(void, clear, (), (override));
+        MOCK_METHOD(void, drawPoint, (const PenAttributes &, double, double), (override));
+        MOCK_METHOD(void, drawLine, (const PenAttributes &, double, double, double, double), (override));
+
+        MOCK_METHOD(QOpenGLFramebufferObject *, framebufferObject, (), (const, override));
+
+        MOCK_METHOD(QNanoQuickItemPainter *, createItemPainter, (), (const, override));
+};
+
+} // namespace scratchcpprender

test/mocks/penlayermock.h

@@ -0,0 +1,16 @@
+add_executable(
+  penlayer_test
+  penlayer_test.cpp
+)
+
+target_link_libraries(
+  penlayer_test
+  GTest::gtest_main
+  GTest::gmock_main
+  scratchcpp-render
+  scratchcpprender_mocks
+  ${QT_LIBS}
+)
+
+add_test(penlayer_test)
+gtest_discover_tests(penlayer_test)