Add BitmapSkin class

Author: adazem009

src/CMakeLists.txt

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

src/bitmapskin.cpp

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include <scratchcpp/costume.h>
+
+#include "bitmapskin.h"
+
+using namespace scratchcpprender;
+
+BitmapSkin::BitmapSkin(libscratchcpp::Costume *costume) :
+    Skin(costume)
+{
+    if (!costume)
+        return;
+
+    // Read image data
+    QBuffer buffer;
+    buffer.open(QBuffer::WriteOnly);
+    buffer.write(static_cast<const char *>(costume->data()), costume->dataSize());
+    buffer.close();
+    const char *format;
+
+    {
+        QImageReader reader(&buffer);
+        format = reader.format();
+    }
+
+    buffer.close();
+    m_image.load(&buffer, format);
+
+    // Paint the image into a texture
+    m_texture = createAndPaintTexture(m_image.width(), m_image.height(), false);
+    m_textureSize.setWidth(m_image.width());
+    m_textureSize.setHeight(m_image.height());
+    Q_ASSERT(m_texture.isValid());
+}
+
+BitmapSkin::~BitmapSkin()
+{
+    m_texture.release();
+}
+
+Texture BitmapSkin::getTexture(double scale) const
+{
+    return m_texture;
+}
+
+double BitmapSkin::getTextureScale(const Texture &texture) const
+{
+    return 1;
+}
+
+void BitmapSkin::paint(QPainter *painter)
+{
+    painter->drawImage(m_image.rect(), m_image, m_image.rect());
+}

src/bitmapskin.h

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include "skin.h"
+#include "texture.h"
+
+namespace scratchcpprender
+{
+
+class BitmapSkin : public Skin
+{
+    public:
+        BitmapSkin(libscratchcpp::Costume *costume);
+        ~BitmapSkin();
+
+        Texture getTexture(double scale) const override;
+        double getTextureScale(const Texture &texture) const override;
+
+    protected:
+        void paint(QPainter *painter) override;
+
+    private:
+        Texture m_texture;
+        QSize m_textureSize;
+        QImage m_image;
+};
+
+} // namespace scratchcpprender

test/CMakeLists.txt

@@ -30,3 +30,4 @@ add_subdirectory(mouseeventhandler)
 add_subdirectory(scenemousearea)
 add_subdirectory(monitor_models)
 add_subdirectory(texture)
+add_subdirectory(skins)

test/jpeg_result.png

@@ -0,0 +1,14 @@
+add_executable(
+  bitmapskin_test
+  bitmapskin_test.cpp
+)
+
+target_link_libraries(
+  bitmapskin_test
+  GTest::gtest_main
+  scratchcpp-render
+  ${QT_LIBS}
+)
+
+add_test(bitmapskin_test)
+gtest_discover_tests(bitmapskin_test)

test/png_result.png

@@ -0,0 +1,74 @@
+#include <scratchcpp/costume.h>
+#include <bitmapskin.h>
+
+#include "../common.h"
+
+using namespace scratchcpprender;
+using namespace libscratchcpp;
+
+class BitmapSkinTest : 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 jpegCostume("", "", "");
+            std::string costumeData = readFileStr("image.jpg");
+            jpegCostume.setData(costumeData.size(), costumeData.data());
+            m_jpegSkin = std::make_unique<BitmapSkin>(&jpegCostume);
+
+            Costume pngCostume("", "", "");
+            costumeData = readFileStr("image.png");
+            pngCostume.setData(costumeData.size(), costumeData.data());
+            m_pngSkin = std::make_unique<BitmapSkin>(&pngCostume);
+        }
+
+        void TearDown() override
+        {
+            ASSERT_EQ(m_context.surface(), &m_surface);
+            m_context.doneCurrent();
+        }
+
+        QOpenGLContext m_context;
+        QOffscreenSurface m_surface;
+        std::unique_ptr<Skin> m_jpegSkin;
+        std::unique_ptr<Skin> m_pngSkin;
+};
+
+TEST_F(BitmapSkinTest, GetTexture)
+{
+    Texture texture = m_jpegSkin->getTexture(1);
+    ASSERT_EQ(texture.width(), 4);
+    ASSERT_EQ(texture.height(), 6);
+
+    QBuffer jpegBuffer;
+    texture.toImage().save(&jpegBuffer, "png");
+    QFile jpegRef("jpeg_result.png");
+    jpegRef.open(QFile::ReadOnly);
+    jpegBuffer.open(QBuffer::ReadOnly);
+    ASSERT_EQ(jpegBuffer.readAll(), jpegRef.readAll());
+
+    texture = m_pngSkin->getTexture(1);
+    ASSERT_EQ(texture.width(), 4);
+    ASSERT_EQ(texture.height(), 6);
+
+    QBuffer pngBuffer;
+    texture.toImage().save(&pngBuffer, "png");
+    QFile pngRef("png_result.png");
+    pngRef.open(QFile::ReadOnly);
+    pngBuffer.open(QBuffer::ReadOnly);
+    ASSERT_EQ(pngBuffer.readAll(), pngRef.readAll());
+}
+
+TEST_F(BitmapSkinTest, GetTextureScale)
+{
+    ASSERT_EQ(m_jpegSkin->getTextureScale(Texture()), 1);
+    ASSERT_EQ(m_pngSkin->getTextureScale(Texture()), 1);
+}