Add getBounds() method to IRenderedTarget

Author: adazem009

src/irenderedtarget.h

@@ -67,6 +67,8 @@ class IRenderedTarget : public QNanoQuickItem
         virtual qreal height() const = 0;
         virtual void setHeight(qreal width) = 0;
 
+        virtual libscratchcpp::Rect getBounds() const = 0;
+
         virtual QPointF mapFromScene(const QPointF &point) const = 0;
 
         virtual bool mirrorHorizontally() const = 0;

src/renderedtarget.cpp

@@ -2,6 +2,7 @@
 
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/rect.h>
 #include <QtSvg/QSvgRenderer>
 #include <qnanopainter.h>
 
@@ -17,6 +18,7 @@ using namespace scratchcpprender;
 using namespace libscratchcpp;
 
 static const double SVG_SCALE_LIMIT = 0.1; // the maximum viewport dimensions are multiplied by this
+static const double pi = std::acos(-1);    // TODO: Use std::numbers::pi in C++20
 
 RenderedTarget::RenderedTarget(QNanoQuickItem *parent) :
     IRenderedTarget(parent)
@@ -327,6 +329,43 @@ void RenderedTarget::setHeight(qreal height)
     QNanoQuickItem::setHeight(height);
 }
 
+Rect RenderedTarget::getBounds() const
+{
+    // https://github.com/scratchfoundation/scratch-render/blob/c3ede9c3d54769730c7b023021511e2aba167b1f/src/Rectangle.js#L33-L55
+    if (!m_costume || !m_skin || !m_texture.isValid())
+        return Rect(m_x, m_y, m_x, m_y);
+
+    const double width = m_texture.width() * m_size / scale() / m_costume->bitmapResolution();
+    const double height = m_texture.height() * m_size / scale() / m_costume->bitmapResolution();
+    const double originX = m_stageScale * m_costume->rotationCenterX() * m_size / scale() / m_costume->bitmapResolution() - width / 2;
+    const double originY = m_stageScale * -m_costume->rotationCenterY() * m_size / scale() / m_costume->bitmapResolution() + height / 2;
+    const double rot = -rotation() * pi / 180;
+    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();
+
+    for (const QPointF &point : m_hullPoints) {
+        QPointF transformed = transformPoint(point.x() - width / 2, height / 2 - point.y(), originX, originY, rot);
+        const double x = transformed.x() * scale() / m_stageScale * (m_mirrorHorizontally ? -1 : 1);
+        const double y = transformed.y() * scale() / m_stageScale;
+
+        if (x < left)
+            left = x;
+
+        if (x > right)
+            right = x;
+
+        if (y > top)
+            top = y;
+
+        if (y < bottom)
+            bottom = y;
+    }
+
+    return Rect(left + m_x, top + m_y, right + m_x, bottom + m_y);
+}
+
 QPointF RenderedTarget::mapFromScene(const QPointF &point) const
 {
     return QNanoQuickItem::mapFromScene(point);
@@ -537,6 +576,15 @@ void RenderedTarget::handleSceneMouseMove(qreal x, qreal y)
     }
 }
 
+QPointF RenderedTarget::transformPoint(double scratchX, double scratchY, double originX, double originY, double rot) const
+{
+    const double cosRot = std::cos(rot);
+    const double sinRot = std::sin(rot);
+    const double x = (scratchX - originX) * cosRot - (scratchY - originY) * sinRot;
+    const double y = (scratchX - originX) * sinRot + (scratchY - originY) * cosRot;
+    return QPointF(x, y);
+}
+
 bool RenderedTarget::mirrorHorizontally() const
 {
     return m_mirrorHorizontally;

src/renderedtarget.h

@@ -74,6 +74,8 @@ class RenderedTarget : public IRenderedTarget
         qreal height() const override;
         void setHeight(qreal height) override;
 
+        libscratchcpp::Rect getBounds() const override;
+
         QPointF mapFromScene(const QPointF &point) const override;
 
         bool mirrorHorizontally() const override;
@@ -104,6 +106,7 @@ class RenderedTarget : public IRenderedTarget
         void calculateRotation();
         void calculateSize();
         void handleSceneMouseMove(qreal x, qreal y);
+        QPointF transformPoint(double scratchX, double scratchY, double originX, double originY, double rot) const;
 
         libscratchcpp::IEngine *m_engine = nullptr;
         libscratchcpp::Costume *m_costume = nullptr;

test/mocks/renderedtargetmock.h

@@ -3,6 +3,7 @@
 #include <irenderedtarget.h>
 #include <texture.h>
 #include <qnanoquickitem.h>
+#include <scratchcpp/rect.h>
 #include <gmock/gmock.h>
 
 using namespace scratchcpprender;
@@ -54,6 +55,8 @@ class RenderedTargetMock : public IRenderedTarget
 
         MOCK_METHOD(QPointF, mapFromScene, (const QPointF &), (const, override));
 
+        MOCK_METHOD(libscratchcpp::Rect, getBounds, (), (const, override));
+
         MOCK_METHOD(bool, mirrorHorizontally, (), (const, override));
 
         MOCK_METHOD(Texture, texture, (), (const, override));

test/renderedtarget/renderedtarget_test.cpp

@@ -9,6 +9,7 @@
 #include <scratchcpp/stage.h>
 #include <scratchcpp/sprite.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/rect.h>
 #include <enginemock.h>
 
 #include "../common.h"
@@ -554,3 +555,75 @@ TEST_F(RenderedTargetTest, StageScale)
     target.setStageScale(6.4);
     ASSERT_EQ(target.stageScale(), 6.4);
 }
+
+TEST_F(RenderedTargetTest, GetBounds)
+{
+    QOpenGLContext context;
+    QOffscreenSurface surface;
+    createContextAndSurface(&context, &surface);
+    QOpenGLExtraFunctions glF(&context);
+    glF.initializeOpenGLFunctions();
+    RenderedTarget target;
+
+    Sprite sprite;
+    sprite.setX(75.64);
+    sprite.setY(-120.3);
+    sprite.setDirection(-46.37);
+    sprite.setSize(67.98);
+    SpriteModel spriteModel;
+    sprite.setInterface(&spriteModel);
+    target.setSpriteModel(&spriteModel);
+    EngineMock engine;
+    target.setEngine(&engine);
+    auto costume = std::make_shared<Costume>("", "", "png");
+    std::string costumeData = readFileStr("image.png");
+    costume->setData(costumeData.size(), static_cast<void *>(costumeData.data()));
+    costume->setRotationCenterX(-15);
+    costume->setRotationCenterY(48);
+    costume->setBitmapResolution(3.25);
+    sprite.addCostume(costume);
+
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    target.loadCostumes();
+    target.updateCostume(costume.get());
+    target.beforeRedraw();
+
+    Texture texture = target.texture();
+    QOpenGLFramebufferObjectFormat format;
+    format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
+
+    QOpenGLFramebufferObject fbo(texture.size(), format);
+    fbo.bind();
+    glF.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.handle(), 0);
+    target.updateHullPoints(&fbo);
+    fbo.release();
+
+    Rect bounds = target.getBounds();
+    ASSERT_EQ(std::round(bounds.left() * 100) / 100, 66.13);
+    ASSERT_EQ(std::round(bounds.top() * 100) / 100, -124.52);
+    ASSERT_EQ(std::round(bounds.right() * 100) / 100, 66.72);
+    ASSERT_EQ(std::round(bounds.bottom() * 100) / 100, -125.11);
+
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    target.updateRotationStyle(Sprite::RotationStyle::LeftRight);
+
+    bounds = target.getBounds();
+    ASSERT_EQ(std::round(bounds.left() * 100) / 100, 71.87);
+    ASSERT_EQ(std::round(bounds.top() * 100) / 100, -110.47);
+    ASSERT_EQ(std::round(bounds.right() * 100) / 100, 72.29);
+    ASSERT_EQ(std::round(bounds.bottom() * 100) / 100, -110.89);
+
+    EXPECT_CALL(engine, stageWidth()).WillOnce(Return(480));
+    EXPECT_CALL(engine, stageHeight()).WillOnce(Return(360));
+    target.setStageScale(20.75);
+
+    bounds = target.getBounds();
+    ASSERT_EQ(std::round(bounds.left() * 100) / 100, 71.87);
+    ASSERT_EQ(std::round(bounds.top() * 100) / 100, -110.47);
+    ASSERT_EQ(std::round(bounds.right() * 100) / 100, 72.29);
+    ASSERT_EQ(std::round(bounds.bottom() * 100) / 100, -110.89);
+
+    context.doneCurrent();
+}