Merge pull request #66 from scratchcpp/clones

Implement sprite cloning

Author: adazem009

src/ProjectPlayer.qml

@@ -36,6 +36,7 @@ ProjectScene {
         fileName: root.fileName
         stageWidth: root.stageWidth
         stageHeight: root.stageHeight
+
         onLoadingFinished: {
             priv.loading = false;
 
@@ -44,7 +45,25 @@ ProjectScene {
             else
                 failedToLoad();
         }
+
         onStageChanged: stage.loadCostume();
+
+        onCloneCreated: (cloneModel)=> clones.model.append({"spriteModel": cloneModel})
+
+        onCloneDeleted: (cloneModel)=> {
+            // TODO: Removing the clone from C++ would probably be faster
+            let i;
+
+            for(i = 0; i < clones.model.count; i++) {
+                if(clones.model.get(i).spriteModel === cloneModel)
+                    break;
+            }
+
+            if(i === clones.model.count)
+                console.error("error: deleted clone doesn't exist");
+            else
+                clones.model.remove(i);
+        }
     }
 
     function start() {
@@ -73,21 +92,34 @@ ProjectScene {
             onStageModelChanged: stageModel.renderedTarget = this
         }
 
-        Repeater {
-            id: sprites
-            model: loader.sprites
+        Component {
+            id: renderedSprite
 
             RenderedTarget {
                 id: target
-                engine: loader.engine
-                spriteModel: modelData
                 mouseArea: sceneMouseArea
                 stageScale: root.stageScale
                 transform: Scale { xScale: mirrorHorizontally ? -1 : 1 }
-                Component.onCompleted: modelData.renderedTarget = this
+                Component.onCompleted: {
+                    engine = loader.engine;
+                    spriteModel = modelData;
+                    spriteModel.renderedTarget = this;
+                }
             }
         }
 
+        Repeater {
+            id: sprites
+            model: loader.sprites
+            delegate: renderedSprite
+        }
+
+        Repeater {
+            id: clones
+            model: ListModel {}
+            delegate: renderedSprite
+        }
+
         Loader {
             anchors.fill: parent
             active: showLoadingProgress && loading
@@ -132,7 +164,7 @@ ProjectScene {
             id: sceneMouseArea
             anchors.fill: parent
             stage: stageTarget
-            spriteRepeater: sprites
+            projectLoader: loader
             onMouseMoved: (x, y)=> root.handleMouseMove(x, y)
             onMousePressed: root.handleMousePress()
             onMouseReleased: root.handleMouseRelease()

src/irenderedtarget.h

@@ -38,6 +38,8 @@ class IRenderedTarget : public QNanoQuickItem
 
         virtual void beforeRedraw() = 0;
 
+        virtual void deinitClone() = 0;
+
         virtual libscratchcpp::IEngine *engine() const = 0;
         virtual void setEngine(libscratchcpp::IEngine *newEngine) = 0;
 

src/mouseeventhandler.cpp

@@ -5,6 +5,8 @@
 
 #include "mouseeventhandler.h"
 #include "renderedtarget.h"
+#include "projectloader.h"
+#include "spritemodel.h"
 
 using namespace scratchcpprender;
 
@@ -23,14 +25,20 @@ void MouseEventHandler::setStage(IRenderedTarget *stage)
     m_stage = stage;
 }
 
-QQuickItem *MouseEventHandler::spriteRepeater() const
+ProjectLoader *MouseEventHandler::projectLoader() const
 {
-    return m_spriteRepeater;
+    return m_projectLoader;
 }
 
-void MouseEventHandler::setSpriteRepeater(QQuickItem *repeater)
+void MouseEventHandler::setProjectLoader(ProjectLoader *newProjectLoader)
 {
-    m_spriteRepeater = repeater;
+    m_projectLoader = newProjectLoader;
+
+    if (m_projectLoader) {
+        connect(m_projectLoader, &ProjectLoader::spritesChanged, this, &MouseEventHandler::getSprites);
+        connect(m_projectLoader, &ProjectLoader::cloneCreated, this, &MouseEventHandler::addClone);
+        connect(m_projectLoader, &ProjectLoader::cloneDeleted, this, &MouseEventHandler::removeClone);
+    }
 }
 
 bool MouseEventHandler::eventFilter(QObject *obj, QEvent *event)
@@ -76,34 +84,64 @@ bool MouseEventHandler::eventFilter(QObject *obj, QEvent *event)
     return QObject::eventFilter(obj, event);
 }
 
-void MouseEventHandler::forwardPointEvent(QSinglePointEvent *event, QQuickItem *oldClickedItem)
+void scratchcpprender::MouseEventHandler::getSprites()
 {
-    Q_ASSERT(m_spriteRepeater);
+    Q_ASSERT(m_projectLoader);
 
-    if (!m_spriteRepeater)
+    if (!m_projectLoader)
         return;
 
-    // Create list of sprites
-    std::vector<IRenderedTarget *> sprites;
-    int count = m_spriteRepeater->property("count").toInt();
-    sprites.reserve(count);
+    m_sprites.clear();
+    const auto &spriteModels = m_projectLoader->spriteList();
 
-    for (int i = 0; i < count; i++) {
-        QQuickItem *sprite = nullptr;
-        QMetaObject::invokeMethod(m_spriteRepeater, "itemAt", Qt::DirectConnection, Q_RETURN_ARG(QQuickItem *, sprite), Q_ARG(int, i));
+    for (SpriteModel *model : spriteModels) {
+        Q_ASSERT(model);
+        IRenderedTarget *sprite = model->renderedTarget();
         Q_ASSERT(sprite);
-        Q_ASSERT(dynamic_cast<IRenderedTarget *>(sprite));
-        Q_ASSERT(dynamic_cast<IRenderedTarget *>(sprite)->scratchTarget());
-        sprites.push_back(dynamic_cast<IRenderedTarget *>(sprite));
+        Q_ASSERT(sprite->scratchTarget());
+        m_sprites.push_back(sprite);
     }
+}
+
+void scratchcpprender::MouseEventHandler::addClone(SpriteModel *model)
+{
+    Q_ASSERT(model);
+    IRenderedTarget *sprite = model->renderedTarget();
+    Q_ASSERT(sprite);
+    Q_ASSERT(std::find_if(m_sprites.begin(), m_sprites.end(), [sprite](IRenderedTarget *renderedTarget) { return renderedTarget == sprite; }) == m_sprites.end());
+    m_sprites.push_back(sprite);
+}
+
+void scratchcpprender::MouseEventHandler::removeClone(SpriteModel *model)
+{
+    Q_ASSERT(model);
+    IRenderedTarget *sprite = model->renderedTarget();
+    Q_ASSERT(sprite);
+    m_sprites.erase(std::remove_if(m_sprites.begin(), m_sprites.end(), [sprite](IRenderedTarget *renderedTarget) { return renderedTarget == sprite; }), m_sprites.end());
+    Q_ASSERT(std::find_if(m_sprites.begin(), m_sprites.end(), [sprite](IRenderedTarget *renderedTarget) { return renderedTarget == sprite; }) == m_sprites.end());
+
+    // Make sure the pointer is never used again after it becomes "dangling"
+    if (m_clickedItem == sprite)
+        m_clickedItem = nullptr;
+
+    if (m_hoveredItem == sprite)
+        m_hoveredItem = nullptr;
+}
+
+void MouseEventHandler::forwardPointEvent(QSinglePointEvent *event, QQuickItem *oldClickedItem)
+{
+    Q_ASSERT(m_projectLoader);
+
+    if (!m_projectLoader)
+        return;
 
-    // Sort the list by layer order
-    std::sort(sprites.begin(), sprites.end(), [](IRenderedTarget *t1, IRenderedTarget *t2) { return t1->scratchTarget()->layerOrder() > t2->scratchTarget()->layerOrder(); });
+    // Sort sprite list by layer order
+    std::sort(m_sprites.begin(), m_sprites.end(), [](IRenderedTarget *t1, IRenderedTarget *t2) { return t1->scratchTarget()->layerOrder() > t2->scratchTarget()->layerOrder(); });
 
     // Find hovered sprite
     QQuickItem *hoveredItem = nullptr;
 
-    for (IRenderedTarget *sprite : sprites) {
+    for (IRenderedTarget *sprite : m_sprites) {
         // contains() expects position in the item's coordinate system
         QPointF localPos = sprite->mapFromScene(event->scenePosition());
 

src/mouseeventhandler.h

@@ -13,6 +13,8 @@ namespace scratchcpprender
 {
 
 class IRenderedTarget;
+class ProjectLoader;
+class SpriteModel;
 
 class MouseEventHandler : public QObject
 {
@@ -23,25 +25,29 @@ class MouseEventHandler : public QObject
         IRenderedTarget *stage() const;
         void setStage(IRenderedTarget *stage);
 
-        QQuickItem *spriteRepeater() const;
-        void setSpriteRepeater(QQuickItem *repeater);
-
         bool eventFilter(QObject *obj, QEvent *event) override;
 
+        ProjectLoader *projectLoader() const;
+        void setProjectLoader(ProjectLoader *newProjectLoader);
+
     signals:
         void mouseMoved(qreal x, qreal y);
         void mousePressed();
         void mouseReleased();
 
     private:
+        void getSprites();
+        void addClone(SpriteModel *model);
+        void removeClone(SpriteModel *model);
         void forwardPointEvent(QSinglePointEvent *event, QQuickItem *oldClickedItem = nullptr);
         void sendPointEventToItem(QSinglePointEvent *event, QQuickItem *item);
         void sendHoverEventToItem(QHoverEvent *originalEvent, QEvent::Type newType, QQuickItem *item);
 
         IRenderedTarget *m_stage = nullptr;
+        std::vector<IRenderedTarget *> m_sprites;
         QQuickItem *m_hoveredItem = nullptr;
         QQuickItem *m_clickedItem = nullptr;
-        QQuickItem *m_spriteRepeater = nullptr;
+        ProjectLoader *m_projectLoader = nullptr;
 };
 
 } // namespace scratchcpprender

src/projectloader.cpp

@@ -116,6 +116,16 @@ const QList<SpriteModel *> &ProjectLoader::spriteList() const
     return m_sprites;
 }
 
+QQmlListProperty<SpriteModel> ProjectLoader::clones()
+{
+    return QQmlListProperty<SpriteModel>(this, &m_clones);
+}
+
+const QList<SpriteModel *> &ProjectLoader::cloneList() const
+{
+    return m_clones;
+}
+
 void ProjectLoader::start()
 {
     if (m_loadThread.isRunning())
@@ -196,6 +206,7 @@ void ProjectLoader::load()
             SpriteModel *sprite = new SpriteModel;
             sprite->moveToThread(qApp->thread());
             dynamic_cast<Sprite *>(target.get())->setInterface(sprite);
+            connect(sprite, &SpriteModel::cloned, this, &ProjectLoader::addClone);
             m_sprites.push_back(sprite);
         }
     }
@@ -240,6 +251,31 @@ void ProjectLoader::redraw()
         if (renderedTarget)
             renderedTarget->beforeRedraw();
     }
+
+    for (auto sprite : m_clones) {
+        auto renderedTarget = sprite->renderedTarget();
+
+        if (renderedTarget)
+            renderedTarget->beforeRedraw();
+    }
+}
+
+void ProjectLoader::addClone(SpriteModel *model)
+{
+    connect(model, &SpriteModel::cloneDeleted, this, &ProjectLoader::deleteClone);
+    m_clones.push_back(model);
+    emit cloneCreated(model);
+    emit clonesChanged();
+}
+
+void ProjectLoader::deleteClone(SpriteModel *model)
+{
+    m_clones.removeAll(model);
+    emit cloneDeleted(model);
+    Q_ASSERT(model->renderedTarget());
+    model->renderedTarget()->deinitClone();
+    model->deleteLater();
+    emit clonesChanged();
 }
 
 double ProjectLoader::fps() const

src/projectloader.h

@@ -9,6 +9,8 @@
 
 #include "stagemodel.h"
 
+Q_MOC_INCLUDE("spritemodel.h");
+
 namespace scratchcpprender
 {
 
@@ -23,6 +25,7 @@ class ProjectLoader : public QObject
         Q_PROPERTY(libscratchcpp::IEngine *engine READ engine NOTIFY engineChanged)
         Q_PROPERTY(StageModel *stage READ stage NOTIFY stageChanged)
         Q_PROPERTY(QQmlListProperty<SpriteModel> sprites READ sprites NOTIFY spritesChanged)
+        Q_PROPERTY(QQmlListProperty<SpriteModel> clones READ clones NOTIFY clonesChanged)
         Q_PROPERTY(double fps READ fps WRITE setFps NOTIFY fpsChanged)
         Q_PROPERTY(bool turboMode READ turboMode WRITE setTurboMode NOTIFY turboModeChanged)
         Q_PROPERTY(unsigned int stageWidth READ stageWidth WRITE setStageWidth NOTIFY stageWidthChanged)
@@ -49,6 +52,9 @@ class ProjectLoader : public QObject
         QQmlListProperty<SpriteModel> sprites();
         const QList<SpriteModel *> &spriteList() const;
 
+        QQmlListProperty<SpriteModel> clones();
+        const QList<SpriteModel *> &cloneList() const;
+
         Q_INVOKABLE void start();
         Q_INVOKABLE void stop();
 
@@ -81,6 +87,7 @@ class ProjectLoader : public QObject
         void engineChanged();
         void stageChanged();
         void spritesChanged();
+        void clonesChanged();
         void fpsChanged();
         void turboModeChanged();
         void stageWidthChanged();
@@ -89,6 +96,8 @@ class ProjectLoader : public QObject
         void spriteFencingChanged();
         void downloadedAssetsChanged();
         void assetCountChanged();
+        void cloneCreated(SpriteModel *model);
+        void cloneDeleted(SpriteModel *model);
 
     protected:
         void timerEvent(QTimerEvent *event) override;
@@ -98,6 +107,8 @@ class ProjectLoader : public QObject
         void load();
         void initTimer();
         void redraw();
+        void addClone(SpriteModel *model);
+        void deleteClone(SpriteModel *model);
 
         int m_timerId = -1;
         QString m_fileName;
@@ -108,6 +119,7 @@ class ProjectLoader : public QObject
         bool m_loadStatus = false;
         StageModel m_stage;
         QList<SpriteModel *> m_sprites;
+        QList<SpriteModel *> m_clones;
         double m_fps = 30;
         bool m_turboMode = false;
         unsigned int m_stageWidth = 480;

src/renderedtarget.cpp

@@ -149,6 +149,16 @@ void RenderedTarget::beforeRedraw()
     setHeight(m_height);
 }
 
+void RenderedTarget::deinitClone()
+{
+    // Do not process mouse move events after the clone has been deleted
+    disconnect(m_mouseArea, &SceneMouseArea::mouseMoved, this, &RenderedTarget::handleSceneMouseMove);
+
+    // Release drag lock
+    if (m_mouseArea->draggedSprite() == this)
+        m_mouseArea->setDraggedSprite(nullptr);
+}
+
 IEngine *RenderedTarget::engine() const
 {
     return m_engine;

src/renderedtarget.h

@@ -43,6 +43,8 @@ class RenderedTarget : public IRenderedTarget
 
         void beforeRedraw() override;
 
+        void deinitClone() override;
+
         libscratchcpp::IEngine *engine() const override;
         void setEngine(libscratchcpp::IEngine *newEngine) override;