Add SVGSkin class

Author: adazem009

src/CMakeLists.txt

@@ -37,6 +37,8 @@ qt_add_qml_module(scratchcpp-render
 	skin.h
 	bitmapskin.cpp
 	bitmapskin.h
+	svgskin.cpp
+	svgskin.h
         renderedtarget.cpp
         renderedtarget.h
 	targetpainter.cpp

src/svgskin.cpp

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include <scratchcpp/costume.h>
+
+#include "svgskin.h"
+
+using namespace scratchcpprender;
+
+static const int MAX_TEXTURE_DIMENSION = 2048;
+static const int INDEX_OFFSET = 8;
+
+SVGSkin::SVGSkin(libscratchcpp::Costume *costume) :
+    Skin(costume)
+{
+    if (!costume)
+        return;
+
+    // Load SVG data
+    m_svgRen.load(QByteArray(static_cast<const char *>(costume->data()), costume->dataSize()));
+
+    // Calculate maximum index (larger images will only be scaled up)
+    const QRectF viewBox = m_svgRen.viewBox();
+
+    if (viewBox.width() == 0 || viewBox.height() == 0)
+        return;
+
+    const int i1 = std::log2(MAX_TEXTURE_DIMENSION / viewBox.width()) + INDEX_OFFSET;
+    const int i2 = std::log2(MAX_TEXTURE_DIMENSION / viewBox.height()) + INDEX_OFFSET;
+    m_maxIndex = std::min(i1, i2);
+
+    // Create all possible textures (the 1.0 scale is stored at INDEX_OFFSET)
+    // TODO: Is this necessary?
+    for (int i = 0; i <= m_maxIndex; i++)
+        createScaledTexture(i);
+}
+
+SVGSkin::~SVGSkin()
+{
+    for (const auto &[index, texture] : m_textures)
+        m_textureObjects[texture].release();
+}
+
+Texture SVGSkin::getTexture(double scale) const
+{
+    // https://github.com/scratchfoundation/scratch-render/blob/423bb700c36b8c1c0baae1e2413878a4f778849a/src/SVGSkin.js#L158-L176
+    int mipLevel = std::max(std::ceil(std::log2(scale)) + INDEX_OFFSET, 0.0);
+
+    // Limit to maximum index
+    mipLevel = std::min(mipLevel, m_maxIndex);
+
+    auto it = m_textures.find(mipLevel);
+
+    if (it == m_textures.cend())
+        return const_cast<SVGSkin *>(this)->createScaledTexture(mipLevel); // TODO: Remove that awful const_cast ;)
+    else
+        return m_textureObjects.at(it->second);
+}
+
+double SVGSkin::getTextureScale(const Texture &texture) const
+{
+    auto it = m_textureIndexes.find(texture.handle());
+
+    if (it != m_textureIndexes.cend())
+        return std::pow(2, it->second - INDEX_OFFSET);
+
+    return 1;
+}
+
+void SVGSkin::paint(QPainter *painter)
+{
+    const QPaintDevice *device = painter->device();
+    m_svgRen.render(painter, QRectF(0, 0, device->width(), device->height()));
+}
+
+Texture SVGSkin::createScaledTexture(int index)
+{
+    Q_ASSERT(m_textures.find(index) == m_textures.cend());
+    auto it = m_textures.find(index);
+
+    if (it != m_textures.cend())
+        return m_textureObjects[it->second];
+
+    const double scale = std::pow(2, index - INDEX_OFFSET);
+    const QRect viewBox = m_svgRen.viewBox();
+    const double width = viewBox.width() * scale;
+    const double height = viewBox.height() * scale;
+
+    if (width > MAX_TEXTURE_DIMENSION || height > MAX_TEXTURE_DIMENSION) {
+        Q_ASSERT(false); // this shouldn't happen because indexes are limited to the max index
+        return Texture();
+    }
+
+    const Texture texture = createAndPaintTexture(viewBox.width() * scale, viewBox.height() * scale, true);
+
+    if (texture.isValid()) {
+        m_textures[index] = texture.handle();
+        m_textureIndexes[texture.handle()] = index;
+        m_textureObjects[texture.handle()] = texture;
+    }
+
+    return texture;
+}

src/svgskin.h

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <QSvgRenderer>
+
+#include "skin.h"
+#include "texture.h"
+
+namespace scratchcpprender
+{
+
+class SVGSkin : public Skin
+{
+    public:
+        SVGSkin(libscratchcpp::Costume *costume);
+        ~SVGSkin();
+
+        Texture getTexture(double scale) const override;
+        double getTextureScale(const Texture &texture) const override;
+
+    protected:
+        void paint(QPainter *painter) override;
+
+    private:
+        Texture createScaledTexture(int index);
+
+        std::unordered_map<int, GLuint> m_textures;
+        std::unordered_map<GLuint, int> m_textureIndexes; // reverse map of m_textures
+        std::unordered_map<GLuint, Texture> m_textureObjects;
+        QSvgRenderer m_svgRen;
+        int m_maxIndex = 0;
+};
+
+} // namespace scratchcpprender

test/skins/CMakeLists.txt

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

test/skins/svgskin_test.cpp

@@ -0,0 +1,69 @@
+#include <scratchcpp/costume.h>
+#include <svgskin.h>
+
+#include "../common.h"
+
+using namespace scratchcpprender;
+using namespace libscratchcpp;
+
+class SVGSkinTest : public testing::Test
+{
+    public:
+        void SetUp() override
+        {
+            m_context.create();
+            ASSERT_TRUE(m_context.isValid());
+
+            m_surface.setFormat(m_context.format());
+            m_surface.create();
+            Q_ASSERT(m_surface.isValid());
+            m_context.makeCurrent(&m_surface);
+
+            Costume costume("", "", "");
+            std::string costumeData = readFileStr("image.svg");
+            costume.setData(costumeData.size(), costumeData.data());
+            m_skin = std::make_unique<SVGSkin>(&costume);
+        }
+
+        void TearDown() override
+        {
+            ASSERT_EQ(m_context.surface(), &m_surface);
+            m_context.doneCurrent();
+        }
+
+        QOpenGLContext m_context;
+        QOffscreenSurface m_surface;
+        std::unique_ptr<Skin> m_skin;
+};
+
+TEST_F(SVGSkinTest, Textures)
+{
+    static const int INDEX_OFFSET = 8;
+
+    for (int i = 0; i <= 18; i++) {
+        double scale = std::pow(2, i - INDEX_OFFSET);
+        Texture texture = m_skin->getTexture(scale);
+        int dimension = static_cast<int>(13 * scale);
+        ASSERT_TRUE(texture.isValid() || dimension == 0);
+
+        if (!texture.isValid())
+            continue;
+
+        if (i > 15) {
+            ASSERT_EQ(texture.width(), 1664);
+            ASSERT_EQ(texture.height(), 1664);
+            ASSERT_EQ(m_skin->getTextureScale(texture), 128);
+        } else {
+            ASSERT_EQ(texture.width(), dimension);
+            ASSERT_EQ(texture.height(), dimension);
+            ASSERT_EQ(m_skin->getTextureScale(texture), scale);
+        }
+
+        QBuffer buffer;
+        texture.toImage().save(&buffer, "png");
+        QFile ref("svg_texture_results/" + QString::number(std::min(i, 15)) + ".png");
+        ref.open(QFile::ReadOnly);
+        buffer.open(QBuffer::ReadOnly);
+        ASSERT_EQ(buffer.readAll(), ref.readAll());
+    }
+}