Add text bubble shape component

Author: adazem009

src/CMakeLists.txt

@@ -62,6 +62,10 @@ qt_add_qml_module(scratchcpp-render
 	shadermanager.h
 	graphicseffect.cpp
 	graphicseffect.h
+	textbubbleshape.cpp
+	textbubbleshape.h
+	textbubblepainter.cpp
+	textbubblepainter.h
 	blocks/penextension.cpp
 	blocks/penextension.h
 	blocks/penblocks.cpp

src/textbubblepainter.cpp

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "textbubblepainter.h"
+#include "textbubbleshape.h"
+
+using namespace scratchcpprender;
+
+// https://github.com/scratchfoundation/scratch-render/blob/ac935423afe3ba79235750eecb1e443474c6eb09/src/TextBubbleSkin.js#L7-L26
+static const int STROKE_WIDTH = 4;
+static const int CORNER_RADIUS = 16;
+static const int TAIL_HEIGHT = 12;
+static const QNanoColor BUBBLE_FILL_COLOR = QNanoColor(255, 255, 255);
+static const QNanoColor BUBBLE_STROKE_COLOR = QNanoColor(0, 0, 0, 38);
+
+static const double pi = std::acos(-1); // TODO: Use std::numbers::pi in C++20
+
+void TextBubblePainter::paint(QNanoPainter *painter)
+{
+    // https://github.com/scratchfoundation/scratch-render/blob/ac935423afe3ba79235750eecb1e443474c6eb09/src/TextBubbleSkin.js#L149-L242
+    if (!m_item)
+        return;
+
+    const double scale = m_item->stageScale();
+    const double width = m_item->nativeWidth() - STROKE_WIDTH;
+    const double height = m_item->nativeHeight() - STROKE_WIDTH - TAIL_HEIGHT;
+
+    painter->resetTransform();
+    painter->scale(scale, scale);
+    painter->translate(STROKE_WIDTH * 0.5, STROKE_WIDTH * 0.5);
+
+    // If the text bubble points leftward, flip the canvas
+    painter->save();
+
+    if (m_item->onSpriteRight()) {
+        painter->scale(-1, 1);
+        painter->translate(-width, 0);
+    }
+
+    // Draw the bubble's rounded borders
+    painter->beginPath();
+    painter->moveTo(CORNER_RADIUS, height);
+    painter->arcTo(0, height, 0, height - CORNER_RADIUS, CORNER_RADIUS);
+    painter->arcTo(0, 0, width, 0, CORNER_RADIUS);
+    painter->arcTo(width, 0, width, height, CORNER_RADIUS);
+    painter->arcTo(width, height, width - CORNER_RADIUS, height, CORNER_RADIUS);
+
+    // Translate the canvas so we don't have to do a bunch of width/height arithmetic
+    painter->save();
+    painter->translate(width - CORNER_RADIUS, height);
+
+    // Draw the bubble's "tail"
+    if (m_item->type() == TextBubbleShape::Type::Say) {
+        // For a speech bubble, draw one swoopy thing
+        painter->bezierTo(0, 4, 4, 8, 4, 10);
+        painter->arcTo(4, 12, 2, 12, 2);
+        painter->bezierTo(-1, 12, -11, 8, -16, 0);
+
+        painter->closePath();
+    } else {
+        // For a thinking bubble, draw a partial circle attached to the bubble...
+        painter->arc(-16, 0, 4, 0, pi);
+
+        painter->closePath();
+
+        // and two circles detached from it
+        painter->moveTo(-7, 7.25);
+        painter->arc(-9.25, 7.25, 2.25, 0, pi * 2);
+
+        painter->moveTo(0, 9.5);
+        painter->arc(-1.5, 9.5, 1.5, 0, pi * 2);
+    }
+
+    // Un-translate the canvas and fill + stroke the text bubble
+    painter->restore();
+
+    painter->setFillStyle(BUBBLE_FILL_COLOR);
+    painter->setStrokeStyle(BUBBLE_STROKE_COLOR);
+    painter->setLineWidth(STROKE_WIDTH);
+
+    painter->stroke();
+    painter->fill();
+}
+
+void TextBubblePainter::synchronize(QNanoQuickItem *item)
+{
+    Q_ASSERT(item);
+    m_item = static_cast<TextBubbleShape *>(item);
+}

src/textbubblepainter.h

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <qnanoquickitempainter.h>
+
+namespace scratchcpprender
+{
+
+class TextBubbleShape;
+
+class TextBubblePainter : public QNanoQuickItemPainter
+{
+    public:
+        void paint(QNanoPainter *painter) override;
+        void synchronize(QNanoQuickItem *item) override;
+
+    private:
+        TextBubbleShape *m_item = nullptr;
+};
+
+} // namespace scratchcpprender

src/textbubbleshape.cpp

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#include "textbubbleshape.h"
+#include "textbubblepainter.h"
+
+using namespace scratchcpprender;
+
+TextBubbleShape::TextBubbleShape(QQuickItem *parent) :
+    QNanoQuickItem(parent)
+{
+}
+
+QNanoQuickItemPainter *TextBubbleShape::createItemPainter() const
+{
+    return new TextBubblePainter;
+}
+
+TextBubbleShape::Type TextBubbleShape::type() const
+{
+    return m_type;
+}
+
+void TextBubbleShape::setType(Type newType)
+{
+    if (m_type == newType)
+        return;
+
+    m_type = newType;
+    update();
+    emit typeChanged();
+}
+
+bool TextBubbleShape::onSpriteRight() const
+{
+    return m_onSpriteRight;
+}
+
+void TextBubbleShape::setOnSpriteRight(bool newOnSpriteRight)
+{
+    if (m_onSpriteRight == newOnSpriteRight)
+        return;
+
+    m_onSpriteRight = newOnSpriteRight;
+    update();
+    emit onSpriteRightChanged();
+}
+
+double TextBubbleShape::stageScale() const
+{
+    return m_stageScale;
+}
+
+void TextBubbleShape::setStageScale(double newStageScale)
+{
+    if (qFuzzyCompare(m_stageScale, newStageScale))
+        return;
+
+    m_stageScale = newStageScale;
+    setWidth(m_nativeWidth * m_stageScale);
+    setHeight(m_nativeHeight * m_stageScale);
+    emit stageScaleChanged();
+}
+
+double TextBubbleShape::nativeWidth() const
+{
+    return m_nativeWidth;
+}
+
+void TextBubbleShape::setNativeWidth(double newNativeWidth)
+{
+    if (qFuzzyCompare(m_nativeWidth, newNativeWidth))
+        return;
+
+    m_nativeWidth = newNativeWidth;
+    setWidth(m_nativeWidth * m_stageScale);
+    emit nativeWidthChanged();
+}
+
+double TextBubbleShape::nativeHeight() const
+{
+    return m_nativeHeight;
+}
+
+void TextBubbleShape::setNativeHeight(double newNativeHeight)
+{
+    if (qFuzzyCompare(m_nativeHeight, newNativeHeight))
+        return;
+
+    m_nativeHeight = newNativeHeight;
+    setHeight(m_nativeHeight * m_stageScale);
+    emit nativeHeightChanged();
+}

src/textbubbleshape.h

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+#pragma once
+
+#include <qnanoquickitem.h>
+
+namespace scratchcpprender
+{
+
+class TextBubbleShape : public QNanoQuickItem
+{
+        Q_OBJECT
+        QML_ELEMENT
+        Q_PROPERTY(Type type READ type WRITE setType NOTIFY typeChanged)
+        Q_PROPERTY(bool onSpriteRight READ onSpriteRight WRITE setOnSpriteRight NOTIFY onSpriteRightChanged)
+        Q_PROPERTY(double stageScale READ stageScale WRITE setStageScale NOTIFY stageScaleChanged)
+        Q_PROPERTY(double nativeWidth READ nativeWidth WRITE setNativeWidth NOTIFY nativeWidthChanged)
+        Q_PROPERTY(double nativeHeight READ nativeHeight WRITE setNativeHeight NOTIFY nativeHeightChanged)
+
+    public:
+        enum class Type
+        {
+            Say,
+            Think
+        };
+
+        Q_ENUM(Type)
+
+        TextBubbleShape(QQuickItem *parent = nullptr);
+
+        Type type() const;
+        void setType(Type newType);
+
+        bool onSpriteRight() const;
+        void setOnSpriteRight(bool newOnSpriteRight);
+
+        double stageScale() const;
+        void setStageScale(double newStageScale);
+
+        double nativeWidth() const;
+        void setNativeWidth(double newNativeWidth);
+
+        double nativeHeight() const;
+        void setNativeHeight(double newNativeHeight);
+
+    signals:
+        void typeChanged();
+        void onSpriteRightChanged();
+        void stageScaleChanged();
+        void nativeWidthChanged();
+        void nativeHeightChanged();
+
+    protected:
+        QNanoQuickItemPainter *createItemPainter() const override;
+
+    private:
+        Type m_type = Type::Say;
+        bool m_onSpriteRight = true;
+        double m_stageScale = 1;
+        double m_nativeWidth = 0;
+        double m_nativeHeight = 0;
+};
+
+} // namespace scratchcpprender

test/CMakeLists.txt

@@ -38,3 +38,5 @@ add_subdirectory(penlayerpainter)
 add_subdirectory(blocks)
 add_subdirectory(graphicseffect)
 add_subdirectory(shadermanager)
+add_subdirectory(textbubbleshape)
+add_subdirectory(textbubblepainter)

test/say_bubble.png

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