Merge pull request #44 from scratchcpp/svg

Add SVG support

Author: adazem009

README.md

@@ -125,8 +125,8 @@ Button {
 - [x] Everything related to displaying sprites (position, rotation, size, etc.)
 - [x] Loading projects in another thread
 - [x] API for engine properties (FPS, turbo mode, etc.)
-- [ ] Loading projects from URL
-- [ ] SVG rendering
+- [x] Loading projects from URL
+- [x] SVG rendering
 - [ ] Mouse position
 - [ ] Key press events
 - [ ] Mouse press events

ScratchCPPGui/irenderedtarget.h

@@ -5,6 +5,7 @@
 #include <qnanoquickitem.h>
 
 class QBuffer;
+class QNanoPainter;
 
 namespace libscratchcpp
 {
@@ -52,20 +53,16 @@ class IRenderedTarget : public QNanoQuickItem
         virtual qreal height() const = 0;
         virtual void setHeight(qreal width) = 0;
 
-        virtual double costumeWidth() const = 0;
-        virtual void setCostumeWidth(double width) = 0;
-
-        virtual double costumeHeight() const = 0;
-        virtual void setCostumeHeight(double width) = 0;
-
-        virtual unsigned char *svgBitmap() const = 0;
         virtual QBuffer *bitmapBuffer() = 0;
         virtual const QString &bitmapUniqueKey() const = 0;
 
         virtual void lockCostume() = 0;
         virtual void unlockCostume() = 0;
 
         virtual bool mirrorHorizontally() const = 0;
+
+        virtual bool isSvg() const = 0;
+        virtual void paintSvg(QNanoPainter *painter) = 0;
 };
 
 } // namespace scratchcppgui

ScratchCPPGui/renderedtarget.cpp

@@ -2,6 +2,8 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/costume.h>
+#include <QtSvg/QSvgRenderer>
+#include <qnanopainter.h>
 
 #include "renderedtarget.h"
 #include "targetpainter.h"
@@ -16,12 +18,6 @@ RenderedTarget::RenderedTarget(QNanoQuickItem *parent) :
 {
 }
 
-RenderedTarget::~RenderedTarget()
-{
-    if (m_svgBitmap)
-        free(m_svgBitmap);
-}
-
 void RenderedTarget::loadProperties()
 {
     Q_ASSERT(!(m_spriteModel && m_stageModel));
@@ -59,21 +55,21 @@ void RenderedTarget::loadProperties()
 
             // Coordinates
             double size = sprite->size() / 100;
-            m_x = static_cast<double>(m_engine->stageWidth()) / 2 + sprite->x() - m_costume->rotationCenterX() * size / 2 * (m_newMirrorHorizontally ? -1 : 1);
-            m_y = static_cast<double>(m_engine->stageHeight()) / 2 - sprite->y() - m_costume->rotationCenterY() * size / 2;
-            m_originX = m_costume->rotationCenterX() * size / 2.0;
-            m_originY = m_costume->rotationCenterY() * size / 2.0;
+            m_x = static_cast<double>(m_engine->stageWidth()) / 2 + sprite->x() - m_costume->rotationCenterX() * size / m_costume->bitmapResolution() * (m_newMirrorHorizontally ? -1 : 1);
+            m_y = static_cast<double>(m_engine->stageHeight()) / 2 - sprite->y() - m_costume->rotationCenterY() * size / m_costume->bitmapResolution();
+            m_originX = m_costume->rotationCenterX() * size / m_costume->bitmapResolution();
+            m_originY = m_costume->rotationCenterY() * size / m_costume->bitmapResolution();
 
             // Layer
             m_z = sprite->layerOrder();
         }
 
         mutex.unlock();
     } else if (m_stageModel) {
-        m_x = static_cast<double>(m_engine->stageWidth()) / 2 - m_costume->rotationCenterX() / 2.0;
-        m_y = static_cast<double>(m_engine->stageHeight()) / 2 - m_costume->rotationCenterY() / 2.0;
-        m_originX = m_costume->rotationCenterX() / 2.0;
-        m_originY = m_costume->rotationCenterY() / 2.0;
+        m_x = static_cast<double>(m_engine->stageWidth()) / 2 - m_costume->rotationCenterX() / m_costume->bitmapResolution();
+        m_y = static_cast<double>(m_engine->stageHeight()) / 2 - m_costume->rotationCenterY() / m_costume->bitmapResolution();
+        m_originX = m_costume->rotationCenterX() / m_costume->bitmapResolution();
+        m_originY = m_costume->rotationCenterY() / m_costume->bitmapResolution();
     }
 }
 
@@ -83,30 +79,14 @@ void RenderedTarget::loadCostume(Costume *costume)
         return;
 
     m_costumeMutex.lock();
-    Target *target = scratchTarget();
-    m_costume = costume;
     m_imageChanged = true;
 
     if (costume->dataFormat() == "svg") {
-        // TODO: Load SVG here
-        // In case of rasterizing, write the bitmap to m_svgBitmap
-    } else {
-        if (m_svgBitmap) {
-            free(m_svgBitmap);
-            m_svgBitmap = nullptr;
-        }
-
-        m_bitmapBuffer.open(QBuffer::WriteOnly);
-        m_bitmapBuffer.write(static_cast<const char *>(costume->data()), costume->dataSize());
-        m_bitmapBuffer.close();
-        m_bitmapUniqueKey = QString::fromStdString(costume->id());
-
-        QImageReader reader(&m_bitmapBuffer);
-        QSize size = reader.size();
-        calculateSize(target, size.width(), size.height());
-        m_bitmapBuffer.close();
+        if (costume != m_costume)
+            m_svgRenderer.load(QByteArray::fromRawData(static_cast<const char *>(costume->data()), costume->dataSize()));
     }
 
+    m_costume = costume;
     m_costumeMutex.unlock();
 }
 
@@ -116,8 +96,12 @@ void RenderedTarget::updateProperties()
     setVisible(m_visible);
 
     if (m_visible) {
-        setWidth(m_width);
-        setHeight(m_height);
+        if (m_imageChanged) {
+            doLoadCostume();
+            update();
+            m_imageChanged = false;
+        }
+
         setX(m_x);
         setY(m_y);
         setZ(m_z);
@@ -128,11 +112,6 @@ void RenderedTarget::updateProperties()
             m_mirrorHorizontally = m_newMirrorHorizontally;
             emit mirrorHorizontallyChanged();
         }
-
-        if (m_imageChanged) {
-            update();
-            m_imageChanged = false;
-        }
     }
 
     mutex.unlock();
@@ -210,38 +189,73 @@ void RenderedTarget::setHeight(qreal height)
     QNanoQuickItem::setHeight(height);
 }
 
-double RenderedTarget::costumeWidth() const
+QNanoQuickItemPainter *RenderedTarget::createItemPainter() const
 {
-    return m_width;
+    return new TargetPainter();
 }
 
-void RenderedTarget::setCostumeWidth(double width)
+void RenderedTarget::doLoadCostume()
 {
-    mutex.lock();
-    m_width = width;
-    mutex.unlock();
-}
+    m_costumeMutex.lock();
 
-double RenderedTarget::costumeHeight() const
-{
-    return m_height;
-}
+    if (!m_costume) {
+        m_costumeMutex.unlock();
+        return;
+    }
 
-void RenderedTarget::setCostumeHeight(double height)
-{
-    mutex.lock();
-    m_height = height;
-    mutex.unlock();
-}
+    Target *target = scratchTarget();
 
-unsigned char *RenderedTarget::svgBitmap() const
-{
-    return m_svgBitmap;
+    if (m_costume->dataFormat() == "svg") {
+        QRectF rect = m_svgRenderer.viewBoxF();
+        calculateSize(target, rect.width(), rect.height());
+    } else {
+        m_bitmapBuffer.open(QBuffer::WriteOnly);
+        m_bitmapBuffer.write(static_cast<const char *>(m_costume->data()), m_costume->dataSize());
+        m_bitmapBuffer.close();
+        m_bitmapUniqueKey = QString::fromStdString(m_costume->id());
+
+        QImageReader reader(&m_bitmapBuffer);
+        QSize size = reader.size();
+        calculateSize(target, size.width(), size.height());
+        m_bitmapBuffer.close();
+    }
+
+    m_costumeMutex.unlock();
 }
 
-QNanoQuickItemPainter *RenderedTarget::createItemPainter() const
+void RenderedTarget::paintSvg(QNanoPainter *painter)
 {
-    return new TargetPainter();
+    Q_ASSERT(painter);
+    QOpenGLContext *context = QOpenGLContext::currentContext();
+    Q_ASSERT(context);
+
+    if (!context)
+        return;
+
+    QOffscreenSurface surface;
+    surface.setFormat(context->format());
+    surface.create();
+    Q_ASSERT(surface.isValid());
+
+    QSurface *oldSurface = context->surface();
+    context->makeCurrent(&surface);
+
+    const QRectF drawRect(0, 0, width(), height());
+    const QSize drawRectSize = drawRect.size().toSize();
+
+    /*QOpenGLFramebufferObjectFormat fboFormat;
+    fboFormat.setSamples(16);
+    fboFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);*/
+
+    QOpenGLPaintDevice device(drawRectSize);
+    QPainter qPainter;
+    qPainter.begin(&device);
+    qPainter.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
+    m_svgRenderer.render(&qPainter, drawRect);
+    qPainter.end();
+
+    context->doneCurrent();
+    context->makeCurrent(oldSurface);
 }
 
 void RenderedTarget::calculateSize(Target *target, double costumeWidth, double costumeHeight)
@@ -252,11 +266,11 @@ void RenderedTarget::calculateSize(Target *target, double costumeWidth, double c
 
         if (sprite) {
             double size = sprite->size();
-            m_width = costumeWidth * size / 100 / bitmapRes;
-            m_height = costumeHeight * size / 100 / bitmapRes;
+            setWidth(costumeWidth * size / 100 / bitmapRes);
+            setHeight(costumeHeight * size / 100 / bitmapRes);
         } else {
-            m_width = costumeWidth / bitmapRes;
-            m_height = costumeHeight / bitmapRes;
+            setWidth(costumeWidth / bitmapRes);
+            setHeight(costumeHeight / bitmapRes);
         }
     }
 }
@@ -285,3 +299,11 @@ bool RenderedTarget::mirrorHorizontally() const
 {
     return m_mirrorHorizontally;
 }
+
+bool RenderedTarget::isSvg() const
+{
+    if (!m_costume)
+        return false;
+
+    return (m_costume->dataFormat() == "svg");
+}

ScratchCPPGui/renderedtarget.h

@@ -5,6 +5,7 @@
 #include <qnanoquickitem.h>
 #include <QBuffer>
 #include <QMutex>
+#include <QtSvg/QSvgRenderer>
 
 #include "irenderedtarget.h"
 
@@ -25,7 +26,6 @@ class RenderedTarget : public IRenderedTarget
 
     public:
         RenderedTarget(QNanoQuickItem *parent = nullptr);
-        ~RenderedTarget();
 
         Q_INVOKABLE void loadProperties() override;
         void loadCostume(libscratchcpp::Costume *costume) override;
@@ -48,13 +48,6 @@ class RenderedTarget : public IRenderedTarget
         qreal height() const override;
         void setHeight(qreal height) override;
 
-        double costumeWidth() const override;
-        void setCostumeWidth(double width) override;
-
-        double costumeHeight() const override;
-        void setCostumeHeight(double height) override;
-
-        unsigned char *svgBitmap() const override;
         QBuffer *bitmapBuffer() override;
         const QString &bitmapUniqueKey() const override;
 
@@ -63,6 +56,9 @@ class RenderedTarget : public IRenderedTarget
 
         bool mirrorHorizontally() const override;
 
+        bool isSvg() const override;
+        void paintSvg(QNanoPainter *painter) override;
+
     signals:
         void engineChanged();
         void stageModelChanged();
@@ -74,21 +70,20 @@ class RenderedTarget : public IRenderedTarget
         QNanoQuickItemPainter *createItemPainter() const override;
 
     private:
+        void doLoadCostume();
         void calculateSize(libscratchcpp::Target *target, double costumeWidth, double costumeHeight);
 
         libscratchcpp::IEngine *m_engine = nullptr;
         libscratchcpp::Costume *m_costume = nullptr;
         StageModel *m_stageModel = nullptr;
         SpriteModel *m_spriteModel = nullptr;
-        unsigned char *m_svgBitmap = nullptr;
+        QSvgRenderer m_svgRenderer;
         QBuffer m_bitmapBuffer;
         QString m_bitmapUniqueKey;
         QMutex m_costumeMutex;
         QMutex mutex;
         bool m_imageChanged = false;
         bool m_visible = true;
-        double m_width = 0;
-        double m_height = 0;
         double m_x = 0;
         double m_y = 0;
         double m_z = 0;

ScratchCPPGui/targetpainter.cpp

@@ -20,27 +20,12 @@ TargetPainter::~TargetPainter()
 void TargetPainter::paint(QNanoPainter *painter)
 {
     m_target->lockCostume();
-    unsigned char *svgBitmap = m_target->svgBitmap();
     double width = m_target->width();
     double height = m_target->height();
 
-    if (svgBitmap) {
-        // TODO: Paint shapes from SVG directly instead of painting rasterized SVG
-        for (int i = 0; i < width * height; ++i) {
-            int pixelIndex = i * 4; // Each pixel has four values (R, G, B, A)
-
-            uchar red = svgBitmap[pixelIndex];
-            uchar green = svgBitmap[pixelIndex + 1];
-            uchar blue = svgBitmap[pixelIndex + 2];
-            uchar alpha = svgBitmap[pixelIndex + 3];
-
-            int x = i % static_cast<int>(width);
-            int y = i / static_cast<int>(width);
-
-            painter->setFillStyle(QNanoColor(red, green, blue, alpha));
-            painter->fillRect(x, y, 1, 1);
-        }
-    } else {
+    if (m_target->isSvg())
+        m_target->paintSvg(painter);
+    else {
         QNanoImage image = QNanoImage::fromCache(painter, m_target->bitmapBuffer(), m_target->bitmapUniqueKey());
         painter->drawImage(image, 0, 0, width, height);
     }

build/FindQt.cmake

@@ -1,5 +1,5 @@
-find_package(Qt6 6.6 COMPONENTS Gui Qml Quick REQUIRED)
-set(QT_LIBS Qt6::Gui Qt6::Qml Qt6::Quick)
+find_package(Qt6 6.6 COMPONENTS Gui Qml Quick Svg REQUIRED)
+set(QT_LIBS Qt6::Gui Qt6::Qml Qt6::Quick Qt6::Svg)
 
 if (SCRATCHCPPGUI_BUILD_UNIT_TESTS)
     find_package(Qt6 6.6 COMPONENTS Test REQUIRED)