Merge pull request #38 from scratchcpp/engine_properties_api

Add engine properties API

Author: adazem009

README.md

@@ -124,7 +124,7 @@ Button {
 - [x] JPEG and PNG rendering
 - [x] Everything related to displaying sprites (position, rotation, size, etc.)
 - [ ] Loading projects in another thread
-- [ ] API for engine properties (FPS, turbo mode, etc.)
+- [x] API for engine properties (FPS, turbo mode, etc.)
 - [ ] Loading projects from URL
 - [ ] SVG rendering
 - [ ] Mouse position

ScratchCPPGui/ProjectPlayer.qml

@@ -5,17 +5,19 @@ import ScratchCPPGui
 
 ProjectScene {
     property string fileName
-    property int stageWidth: 480
-    property int stageHeight: 360
+    property alias fps: loader.fps
+    property alias turboMode: loader.turboMode
+	property alias cloneLimit: loader.cloneLimit
+	property alias spriteFencing: loader.spriteFencing
 
     id: root
-    width: stageWidth
-    height: stageHeight
-    clip: true
+	clip: true
 
     ProjectLoader {
         id: loader
         fileName: root.fileName
+		stageWidth: parent.width
+		stageHeight: parent.height
     }
 
     RenderedTarget {

ScratchCPPGui/projectloader.cpp

@@ -58,15 +58,31 @@ void ProjectLoader::setFileName(const QString &newFileName)
     m_project.setFileName(m_fileName.toStdString());
     m_loaded = m_project.load();
     m_engine = m_project.engine().get();
-    auto handler = std::bind(&ProjectLoader::emitTick, this);
-    m_engine->setRedrawHandler(std::function<void()>(handler));
 
     // Delete old sprites
     for (SpriteModel *sprite : m_sprites)
         sprite->deleteLater();
 
     m_sprites.clear();
 
+    if (!m_engine) {
+        emit fileNameChanged();
+        emit loadedChanged();
+        emit engineChanged();
+        emit spritesChanged();
+        return;
+    }
+
+    m_engine->setFps(m_fps);
+    m_engine->setTurboModeEnabled(m_turboMode);
+    m_engine->setStageWidth(m_stageWidth);
+    m_engine->setStageHeight(m_stageHeight);
+    m_engine->setCloneLimit(m_cloneLimit);
+    m_engine->setSpriteFencingEnabled(m_spriteFencing);
+
+    auto handler = std::bind(&ProjectLoader::emitTick, this);
+    m_engine->setRedrawHandler(std::function<void()>(handler));
+
     // Load targets
     const auto &targets = m_engine->targets();
 
@@ -160,3 +176,111 @@ void ProjectLoader::emitTick()
             renderedTarget->loadProperties();
     }
 }
+
+double ProjectLoader::fps() const
+{
+    return m_fps;
+}
+
+void ProjectLoader::setFps(double newFps)
+{
+    if (qFuzzyCompare(m_fps, newFps))
+        return;
+
+    m_fps = newFps;
+
+    if (m_engine)
+        m_engine->setFps(m_fps);
+
+    emit fpsChanged();
+}
+
+bool ProjectLoader::turboMode() const
+{
+    return m_turboMode;
+}
+
+void ProjectLoader::setTurboMode(bool newTurboMode)
+{
+    if (m_turboMode == newTurboMode)
+        return;
+
+    m_turboMode = newTurboMode;
+
+    if (m_engine)
+        m_engine->setTurboModeEnabled(m_turboMode);
+
+    emit turboModeChanged();
+}
+
+unsigned int ProjectLoader::stageWidth() const
+{
+    return m_stageWidth;
+}
+
+void ProjectLoader::setStageWidth(unsigned int newStageWidth)
+{
+    if (m_stageWidth == newStageWidth)
+        return;
+
+    m_stageWidth = newStageWidth;
+
+    if (m_engine)
+        m_engine->setStageWidth(m_stageWidth);
+
+    emit stageWidthChanged();
+}
+
+unsigned int ProjectLoader::stageHeight() const
+{
+    return m_stageHeight;
+}
+
+void ProjectLoader::setStageHeight(unsigned int newStageHeight)
+{
+    if (m_stageHeight == newStageHeight)
+        return;
+
+    m_stageHeight = newStageHeight;
+
+    if (m_engine)
+        m_engine->setStageHeight(m_stageHeight);
+
+    emit stageHeightChanged();
+}
+
+int ProjectLoader::cloneLimit() const
+{
+    return m_cloneLimit;
+}
+
+void ProjectLoader::setCloneLimit(int newCloneLimit)
+{
+    if (m_cloneLimit == newCloneLimit)
+        return;
+
+    m_cloneLimit = newCloneLimit;
+
+    if (m_engine)
+        m_engine->setCloneLimit(m_cloneLimit);
+
+    emit cloneLimitChanged();
+}
+
+bool ProjectLoader::spriteFencing() const
+{
+    return m_spriteFencing;
+}
+
+void ProjectLoader::setSpriteFencing(bool newSpriteFencing)
+{
+    if (m_spriteFencing == newSpriteFencing)
+        return;
+
+    m_spriteFencing = newSpriteFencing;
+
+    if (m_engine)
+        m_engine->setSpriteFencingEnabled(m_spriteFencing);
+
+    emit spriteFencingChanged();
+}

ScratchCPPGui/projectloader.h

@@ -23,6 +23,12 @@ 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(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)
+        Q_PROPERTY(unsigned int stageHeight READ stageHeight WRITE setStageHeight NOTIFY stageHeightChanged)
+        Q_PROPERTY(int cloneLimit READ cloneLimit WRITE setCloneLimit NOTIFY cloneLimitChanged)
+        Q_PROPERTY(bool spriteFencing READ spriteFencing WRITE setSpriteFencing NOTIFY spriteFencingChanged)
 
     public:
         explicit ProjectLoader(QObject *parent = nullptr);
@@ -45,12 +51,36 @@ class ProjectLoader : public QObject
         unsigned int frameFinished() const;
         void setFrameFinished(unsigned int newFrameFinished);
 
+        double fps() const;
+        void setFps(double newFps);
+
+        bool turboMode() const;
+        void setTurboMode(bool newTurboMode);
+
+        unsigned int stageWidth() const;
+        void setStageWidth(unsigned int newStageWidth);
+
+        unsigned int stageHeight() const;
+        void setStageHeight(unsigned int newStageHeight);
+
+        int cloneLimit() const;
+        void setCloneLimit(int newCloneLimit);
+
+        bool spriteFencing() const;
+        void setSpriteFencing(bool newSpriteFencing);
+
     signals:
         void fileNameChanged();
         void loadedChanged();
         void engineChanged();
         void stageChanged();
         void spritesChanged();
+        void fpsChanged();
+        void turboModeChanged();
+        void stageWidthChanged();
+        void stageHeightChanged();
+        void cloneLimitChanged();
+        void spriteFencingChanged();
 
     protected:
         void timerEvent(QTimerEvent *event) override;
@@ -67,6 +97,12 @@ class ProjectLoader : public QObject
         StageModel m_stage;
         QList<SpriteModel *> m_sprites;
         QFuture<void> m_eventLoop;
+        double m_fps = 30;
+        bool m_turboMode = false;
+        unsigned int m_stageWidth;
+        unsigned int m_stageHeight;
+        int m_cloneLimit;
+        bool m_spriteFencing;
 };
 
 } // namespace scratchcppgui