Revert "Improve state handling"

This commit is introducing to many regressions at this point,
so the best option is to revert it now and re-apply once the remaining
issue are resolved.

This reverts commit 55b43d3e1c3a100f4ad41d94c132afd2a0d029b3.

Change-Id: If2733c506aa64a242a4605d81d69f66e2f7aae41
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

5 files changed, 401 insertions, 380 deletions

diff --git a/src/runtime/q3dsanimationmanager.cpp b/src/runtime/q3dsanimationmanager.cpp
index 40d5fff..51a6c73 100644
--- a/src/runtime/q3dsanimationmanager.cpp
+++ b/src/runtime/q3dsanimationmanager.cpp
@@ -476,7 +476,7 @@ void Q3DSAnimationManager::clearAnimations(Q3DSSlide *slide)
         // Remove all other animatiors that was associated with this slide
         Q3DSSlideAttached *slideAttached = static_cast<Q3DSSlideAttached *>(slide->attached());
         for (auto animator : slideAttached->animators) {
-            animator->stop();
+            Q_ASSERT(!animator->isRunning());
             slideAttached->entity->removeComponent(animator);
             delete animator;
         }
diff --git a/src/runtime/q3dsslideplayer.cpp b/src/runtime/q3dsslideplayer.cpp
index f831db1..9c9b5bf 100644
--- a/src/runtime/q3dsslideplayer.cpp
+++ b/src/runtime/q3dsslideplayer.cpp
@@ -73,11 +73,7 @@ public:
         if (!slidePlayer)
             return;
 
-        slidePlayer->flushQueuedChanges();
-
-        const float newTime = newValue * 1000.0f;
-        slidePlayer->setSlideTime(static_cast<Q3DSSlide *>(m_slide->parent()), newTime);
-        slidePlayer->setSlideTime(m_slide, newTime);
+        slidePlayer->setSlideTime(m_slide, newValue * 1000.0f);
         m_previousValue = newValue;
     }
 
@@ -139,7 +135,7 @@ static void detatchPositionCallback(Q3DSSlide *slide)
     Q3DSSlideAttached *data = slide->attached<Q3DSSlideAttached>();
     auto animator = data->animator;
     if (animator) {
-        animator->stop();
+        Q_ASSERT(!animator->isRunning());
         slide->attached()->entity->removeComponent(animator);
         // TODO: Figure out why this is needed.
         data->animator = nullptr;
@@ -227,20 +223,6 @@ void Q3DSSlideUtils::getStartAndEndTime(Q3DSSlide *slide, qint32 *startTime, qin
         *endTime = layerEndTime != -1 ? layerEndTime : nodesEndtime;
 }
 
-// NOTE: This will skip components that are marked as disabled!!!
-static void forAllSlideComponents(Q3DSSlide *slide, std::function<void (Q3DSComponentNode *)> fn)
-{
-    if (slide) {
-        const auto &objects = slide->objects();
-        auto it = objects.cbegin();
-        while (it != objects.cend()) {
-            if ((*it)->type() == Q3DSGraphObject::Component && (*it)->state() == Q3DSGraphObject::Enabled)
-                fn(static_cast<Q3DSComponentNode *>(*it));
-            ++it;
-        }
-    }
-}
-
 static QByteArray getSlideId(Q3DSSlide *slide)
 {
     return slide ? slide->id() : QByteArrayLiteral("no-slide");
@@ -377,11 +359,37 @@ void Q3DSSlidePlayer::sceneReady()
     Q_ASSERT(currentSlide);
 
     const bool viewerMode = (m_mode == PlayerMode::Viewer);
-
-    if (viewerMode && m_type == PlayerType::Scene && (currentSlide->initialPlayState() == Q3DSSlide::Play))
+    if (viewerMode && (currentSlide->initialPlayState() == Q3DSSlide::Play))
         play();
     else
         pause();
+
+    // In viewer-mode we need to go through all components players as well
+    if (viewerMode) {
+        static const auto notifyComponentPlayers = [](Q3DSSlide *slide) {
+            if (!slide)
+                return;
+
+            const auto &objects = slide->objects();
+            std::find_if(objects.constBegin(), objects.constEnd(), [](Q3DSGraphObject *obj) {
+                if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
+                    Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
+                    Q3DSSlide *compSlide = comp->masterSlide();
+                    Q3DSSlidePlayer *player = compSlide->attached<Q3DSSlideAttached>()->slidePlayer;
+                    player->sceneReady();
+                }
+                return false;
+            });
+        };
+
+        Q3DSSlide *slide = m_data.slideDeck->masterSlide();
+        notifyComponentPlayers(slide);
+        slide = static_cast<Q3DSSlide *>(slide->firstChild());
+        while (slide) {
+            notifyComponentPlayers(slide);
+            slide = static_cast<Q3DSSlide *>(slide->nextSibling());
+        }
+    }
 }
 
 float Q3DSSlidePlayer::duration() const
@@ -403,18 +411,27 @@ void Q3DSSlidePlayer::setMode(Q3DSSlidePlayer::PlayerMode mode)
     if (!m_data.slideDeck)
         return;
 
+    const auto notifyComponentPlayers = [mode](Q3DSSlide *slide) {
+        if (!slide)
+            return;
 
-    const auto callSetMode = [mode](Q3DSComponentNode *comp) {
-        Q3DSSlide *compSlide = comp->masterSlide();
-        Q3DSSlidePlayer *player = compSlide->attached<Q3DSSlideAttached>()->slidePlayer;
-        player->setMode(mode);
+        const auto &objects = slide->objects();
+        std::find_if(objects.constBegin(), objects.constEnd(), [mode](Q3DSGraphObject *obj) {
+            if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
+                Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
+                Q3DSSlide *compSlide = comp->masterSlide();
+                Q3DSSlidePlayer *player = compSlide->attached<Q3DSSlideAttached>()->slidePlayer;
+                player->setMode(mode);
+            }
+            return false;
+        });
     };
 
     Q3DSSlide *slide = m_data.slideDeck->masterSlide();
-    forAllSlideComponents(slide, callSetMode);
+    notifyComponentPlayers(slide);
     slide = static_cast<Q3DSSlide *>(slide->firstChild());
     while (slide) {
-        forAllSlideComponents(slide, callSetMode);
+        notifyComponentPlayers(slide);
         slide = static_cast<Q3DSSlide *>(slide->nextSibling());
     }
 
@@ -426,7 +443,7 @@ void Q3DSSlidePlayer::play()
     if (m_data.state == PlayerState::Playing)
         return;
 
-    if (m_data.state == PlayerState::Idle && !m_data.slideDeck) {
+    if (m_data.state == PlayerState::Idle) {
         qCWarning(lcSlidePlayer) << "Play called in Idle state (no content)";
         return;
     }
@@ -446,7 +463,7 @@ void Q3DSSlidePlayer::play()
 
 void Q3DSSlidePlayer::stop()
 {
-    if (m_data.state == PlayerState::Idle && !m_data.slideDeck) {
+    if (m_data.state == PlayerState::Idle) {
         qCWarning(lcSlidePlayer) << "Stop called in Idle state (no content)";
         return;
     }
@@ -462,6 +479,10 @@ void Q3DSSlidePlayer::stop()
     }
 
     setInternalState(PlayerState::Stopped);
+    // NOTE: We force an update here to make sure we don't get stale updates from
+    // from Qt3D, this way we can properly rollback the animatables to their initial values.
+    updatePosition(currentSlide, 0.0f, duration());
+    handleCurrentSlideChanged(currentSlide, currentSlide, true);
 }
 
 void Q3DSSlidePlayer::pause()
@@ -469,7 +490,7 @@ void Q3DSSlidePlayer::pause()
     if (m_data.state == PlayerState::Paused)
         return;
 
-    if (m_data.state == PlayerState::Idle && !m_data.slideDeck) {
+    if (m_data.state == PlayerState::Idle) {
         qCWarning(lcSlidePlayer) << "Pause called in Idle state (no content)";
         return;
     }
@@ -576,6 +597,7 @@ void Q3DSSlidePlayer::setSlideDeck(Q3DSSlideDeck *slideDeck)
 
     forAllSlides(slideDeck);
 
+    setInternalState(PlayerState::Ready);
     Q_EMIT slideDeckChanged(m_data.slideDeck);
 }
 
@@ -622,7 +644,9 @@ void Q3DSSlidePlayer::precedingSlide()
 
 void Q3DSSlidePlayer::reload()
 {
-    setInternalState((m_mode == PlayerMode::Viewer) ? getInitialSlideState(m_data.slideDeck->currentSlide()) : PlayerState::Paused);
+    setInternalState(PlayerState::Stopped);
+    if (m_mode == PlayerMode::Viewer)
+        setInternalState(getInitialSlideState(m_data.slideDeck->currentSlide()));
 }
 
 Q3DSSlidePlayer::Q3DSSlidePlayer(QSharedPointer<Q3DSAnimationManager> animationManager,
@@ -660,23 +684,18 @@ void Q3DSSlidePlayer::setInternalState(Q3DSSlidePlayer::PlayerState state)
     Q3DSSlide *previousSlide = (m_type == PlayerType::Scene) ? m_sceneManager->currentSlide()
                                                              : m_component->currentSlide();
 
-    // When going from Idle to X there's no previous slide, so correct the
-    // findings above to reflect that...
-    if ((m_data.state == PlayerState::Idle) && (m_data.pendingState != PlayerState::Idle))
-        previousSlide = nullptr;
-
-    if (state == PlayerState::Idle) { // If the state is set to idle, we want to clean-up and leave
+    if (state == PlayerState::Idle) {
         handleCurrentSlideChanged(nullptr, previousSlide);
         if (m_data.slideDeck)
             delete m_data.slideDeck;
         m_data = Data();
-        Q_EMIT stateChanged(m_data.state);
         return;
     }
 
     const bool slideChanged = (previousSlide != currentSlide);
-    if (slideChanged || (m_data.state == PlayerState::Stopped && state != PlayerState::Stopped))
-        handleCurrentSlideChanged(currentSlide, previousSlide);
+    const bool forceUpdate = (!slideChanged && (state == PlayerState::Ready));
+    if (slideChanged || forceUpdate)
+        handleCurrentSlideChanged(currentSlide, previousSlide, forceUpdate);
 
     if (state == PlayerState::Playing) {
         const bool restart = (m_mode == PlayerMode::Viewer)
@@ -684,8 +703,7 @@ void Q3DSSlidePlayer::setInternalState(Q3DSSlidePlayer::PlayerState state)
                              && (m_data.state != PlayerState::Paused);
         updateAnimators(currentSlide, true, restart, m_data.playbackRate);
     } else if (state == PlayerState::Stopped) {
-        // Reset the slide, but avoid emitting slideChanged signal.
-        handleCurrentSlideChanged(currentSlide, currentSlide);
+        updateAnimators(currentSlide, false, false, m_data.playbackRate);
     } else if (state == PlayerState::Paused) {
         updateAnimators(currentSlide, false, false, m_data.playbackRate);
     }
@@ -696,116 +714,119 @@ void Q3DSSlidePlayer::setInternalState(Q3DSSlidePlayer::PlayerState state)
     }
 }
 
-void Q3DSSlidePlayer::handleCurrentSlideChanged(Q3DSSlide *slide, Q3DSSlide *previousSlide)
+void Q3DSSlidePlayer::handleCurrentSlideChanged(Q3DSSlide *slide,
+                                                Q3DSSlide *previousSlide,
+                                                bool forceUpdate)
 {
-    const bool parentChanged = (previousSlide && slide && previousSlide->parent() != slide->parent())
-                               || (!previousSlide && slide) || (previousSlide && !slide);
-
-    // Helper function to update all components on a slide
-    static const auto stopComponent = [](Q3DSComponentNode *comp) {
-        Q3DSSlide *compSlide = comp->currentSlide();
-        Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
-        data->slidePlayer->setInternalState(PlayerState::Stopped);
-    };
+    const bool slideDidChange = (previousSlide != slide) || forceUpdate;
+    const bool parentChanged = [previousSlide, slide, forceUpdate]() -> bool {
+        if (forceUpdate)
+            return true;
 
-    static const auto startComponent = [](Q3DSComponentNode *comp) {
-        Q3DSSlide *compSlide = comp->currentSlide();
-        Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
-        Q3DSSlidePlayer *player = data->slidePlayer;
-        const PlayerState state = (player->mode() == PlayerMode::Viewer) ? getInitialSlideState(compSlide) : PlayerState::Paused;
-        player->setInternalState(state);
-    };
-
-    const auto queueSlideEvent = [this](Q3DSSlide *slide, const QString &evName) {
-        Q3DSGraphObject *eventTarget = m_sceneManager->m_scene;
-        if (m_type != PlayerType::Scene)
-            eventTarget = m_component;
-
-        const QVariantList args {
-            QVariant::fromValue(slide),
-            m_data.slideDeck->indexOfSlide(slide->id())
-        };
-
-        const Q3DSGraphObject::Event ev(eventTarget, evName, { QVariant::fromValue(slide), m_data.slideDeck->indexOfSlide(slide->id())});
-        m_sceneManager->queueEvent(ev);
-    };
+        auto parent = slide ? slide->parent() : nullptr;
+        auto pparent = previousSlide ? previousSlide->parent() : nullptr;
+        return (parent != pparent);
+    }();
 
     qCDebug(lcSlidePlayer, "Handling current slide change: from slide \"%s\", to slide \"%s\"",
             getSlideId(previousSlide).constData(), getSlideId(slide).constData());
 
-    // --------------------------------------------------------------------------------------------
-
-    m_queuedChanges.clear();
-
-    // 1. Stop the previous slide, notify all its components to stop and hide associated objects.
-    if (previousSlide) {
-        forAllSlideComponents(previousSlide, stopComponent);
+    static const auto cleanUpComponentPlayers = [](Q3DSSlide *slide) {
+        if (!slide)
+            return;
 
+        const auto &objects = slide->objects();
+        std::find_if(objects.constBegin(), objects.constEnd(), [](Q3DSGraphObject *obj) {
+            if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
+                Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
+                Q3DSSlide *compSlide = comp->currentSlide();
+                Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
+                data->slidePlayer->handleCurrentSlideChanged(nullptr, compSlide);
+            }
+            return false;
+        });
+    };
+    if (previousSlide && slideDidChange) {
+        cleanUpComponentPlayers(previousSlide);
         Q3DSSlideAttached *data = previousSlide->attached<Q3DSSlideAttached>();
         if (data && data->animator) {
+            // TODO: We probably want to be a bit less brute.
+            if (slide) Q_ASSERT(previousSlide->parent() == slide->parent());
+            updateAnimators(previousSlide, false, false, 1.0f);
             detatchPositionCallback(previousSlide);
             m_animationManager->clearAnimations(previousSlide);
         }
+        if (parentChanged)
+            cleanUpComponentPlayers(static_cast<Q3DSSlide *>(previousSlide->parent()));
 
-        m_queuedChanges.push_back([this, previousSlide]() { setSlideTime(previousSlide, -1.0f, true); });
-
-        queueSlideEvent(previousSlide, Q3DSGraphObjectEvents::slideExitEvent());
+        setSlideTime(previousSlide, -1.0f, true);
     }
 
-    // 2. Apply properties for this slide (update eyeball values and keep values for dynamic kf. etc.).
-    if (slide) {
-        // A bit crude, but whatever
-        if (m_type == PlayerType::Scene)
-            m_sceneManager->m_currentSlide = slide;
-        else
-            m_component->setCurrentSlide(slide);
-
+    if (slide && slideDidChange && isSlideVisible(slide)) {
+        setSlideTime(slide, 0.0f, true);
         processPropertyChanges(slide, previousSlide);
-    }
+        attatchPositionCallback(slide);
+        m_animationManager->updateAnimations(slide, (m_mode == PlayerMode::Editor));
+
+        Q3DSGraphObject *eventTarget = m_sceneManager->m_scene;
+        if (m_type != PlayerType::Scene)
+            eventTarget = m_component;
 
-    // 3. If the parent Changed stop/start, and update components and objects ad needed
-    if (parentChanged) {
         if (previousSlide) {
-            Q3DSSlide *parent = static_cast<Q3DSSlide *>(previousSlide->parent());
-            forAllSlideComponents(parent, stopComponent);
-            m_queuedChanges.push_back([this, parent]() { setSlideTime(parent, -1.0f, true); });
+            const QVariantList args {
+                QVariant::fromValue(previousSlide),
+                m_data.slideDeck->indexOfSlide(previousSlide->id())
+            };
+            m_sceneManager->queueEvent(Q3DSGraphObject::Event(eventTarget,
+                                                              Q3DSGraphObjectEvents::slideExitEvent(),
+                                                              args));
         }
 
-        if (slide && (m_data.pendingState != PlayerState::Stopped)) {
-            Q3DSSlide *parent = static_cast<Q3DSSlide *>(slide->parent());
-            forAllSlideComponents(parent, startComponent);
-            if (m_data.pendingState != PlayerState::Playing)
-                m_queuedChanges.push_back([this, parent]() { setSlideTime(parent, 0.0f, true); });
+        if (slide) {
+            const QVariantList args {
+                QVariant::fromValue(slide),
+                m_data.slideDeck->indexOfSlide(slide->id())
+            };
+            m_sceneManager->queueEvent(Q3DSGraphObject::Event(eventTarget,
+                                                              Q3DSGraphObjectEvents::slideEnterEvent(),
+                                                              args));
         }
-    }
 
-    // 4. Now set-up the animations and notify
-    //    any components on this slide to do the same.
-    if (slide && (m_data.pendingState != PlayerState::Stopped)) {
-        attatchPositionCallback(slide);
-        m_animationManager->updateAnimations(slide, (m_mode == PlayerMode::Editor));
+        // A bit crude, but whatever
+        if (m_type == PlayerType::Scene)
+            m_sceneManager->m_currentSlide = slide;
+        else
+            m_component->setCurrentSlide(slide);
+
+        m_sceneManager->syncScene();
 
         qint32 startTime = 0;
         qint32 endTime = 0;
         Q3DSSlideUtils::getStartAndEndTime(slide, &startTime, &endTime);
         onDurationChanged(endTime - startTime);
 
-        queueSlideEvent(slide, Q3DSGraphObjectEvents::slideEnterEvent());
-
-        forAllSlideComponents(slide, startComponent);
-        if (m_data.pendingState != PlayerState::Playing)
-            m_queuedChanges.push_back([this, slide]() { setSlideTime(slide, 0.0f, true); });
-    }
-
-    // If the player isn't playing then make the time updates valid now.
-    // If this is the top scene player also sync the scene.
-    if (m_data.pendingState != PlayerState::Playing) {
-        flushQueuedChanges();
-        if (m_type == PlayerType::Scene)
-            m_sceneManager->syncScene();
+        static const auto updateComponentSlides = [](Q3DSSlide *slide) {
+            if (!slide)
+                return;
+            const auto &objects = slide->objects();
+            std::find_if(objects.constBegin(), objects.constEnd(), [](Q3DSGraphObject *obj) {
+                if (obj->type() == Q3DSGraphObject::Component && obj->state() == Q3DSGraphObject::Enabled) {
+                    Q3DSComponentNode *comp = static_cast<Q3DSComponentNode *>(obj);
+                    Q3DSSlide *compSlide = comp->currentSlide();
+                    Q3DSSlideAttached *data = compSlide->attached<Q3DSSlideAttached>();
+                    data->slidePlayer->handleCurrentSlideChanged(compSlide, nullptr);
+                    if (data->slidePlayer->m_mode == PlayerMode::Viewer)
+                        data->slidePlayer->setInternalState(getInitialSlideState(compSlide));
+                }
+                return false;
+            });
+        };
+        if (parentChanged)
+            updateComponentSlides(static_cast<Q3DSSlide *>(slide->parent()));
+        updateComponentSlides(slide);
     }
 
-    if ((m_data.pendingState != PlayerState::Stopped) && (previousSlide != slide))
+    if (previousSlide != slide)
         Q_EMIT slideChanged(slide);
 }
 
@@ -835,20 +856,16 @@ void Q3DSSlidePlayer::setSlideTime(Q3DSSlide *slide, float time, bool forceUpdat
             parentVisible = (m_component->attached()->visibilityTag == Q3DSGraphObjectAttached::Visible);
     }
 
-    for (Q3DSGraphObject *obj : slide->objects())
-        setObjectVisibility(obj, parentVisible, forceUpdate, time);
+    const auto updateObjects = [=](Q3DSSlide *s) {
+        if (!s)
+            return;
 
-    forAllSlideComponents(slide, [forceUpdate](Q3DSComponentNode *component) {
-        Q3DSSlide *componentCurrentSlide = component->currentSlide();
-        Q3DSSlidePlayer *player = componentCurrentSlide->attached<Q3DSSlideAttached>()->slidePlayer;
-        // If the component is not playing it won't get time updates, so to ensure it correctly
-        // updates its visibility we tell it to update with time from its last time update.
-        if (player->state() != PlayerState::Idle && player->state() != PlayerState::Playing) {
-            const float lastTime = player->position();
-            player->setSlideTime(component->masterSlide(), lastTime, forceUpdate);
-            player->setSlideTime(component->currentSlide(), lastTime, forceUpdate);
-        }
-    });
+        for (Q3DSGraphObject *obj : s->objects())
+            setObjectVisibility(obj, parentVisible, forceUpdate, time);
+    };
+
+    updateObjects(static_cast<Q3DSSlide *>(slide->parent()));
+    updateObjects(slide);
 
     // This method is called for all slides, but we only want to update the
     // position for the associated slide player once
@@ -858,15 +875,6 @@ void Q3DSSlidePlayer::setSlideTime(Q3DSSlide *slide, float time, bool forceUpdat
     sendPositionChanged(slide, time);
 }
 
-void Q3DSSlidePlayer::flushQueuedChanges()
-{
-    if (!m_queuedChanges.isEmpty()) {
-        for (const auto &fn : qAsConst(m_queuedChanges))
-            fn();
-        m_queuedChanges.clear();
-    }
-}
-
 void Q3DSSlidePlayer::setObjectVisibility(Q3DSGraphObject *obj, bool parentVisible, bool forceUpdate, float time)
 {
     if (obj->state() != Q3DSGraphObject::Enabled)
@@ -896,6 +904,18 @@ void Q3DSSlidePlayer::setObjectVisibility(Q3DSGraphObject *obj, bool parentVisib
 
     if (forceUpdate || shouldBeVisible != objectHasVisibilityTag(obj))
         updateObjectVisibility(obj, shouldBeVisible, time);
+
+    if (obj->type() == Q3DSGraphObject::Component) {
+        Q3DSComponentNode *component = static_cast<Q3DSComponentNode *>(obj);
+        Q3DSSlide *componentCurrentSlide = component->currentSlide();
+        Q3DSSlidePlayer *player = componentCurrentSlide->attached<Q3DSSlideAttached>()->slidePlayer;
+        // If the component is not playing it won't get time updates, so to ensure it correctly
+        // updates its visibility we tell it to update with time from its last time update.
+        if (player->state() != PlayerState::Idle && player->state() != PlayerState::Playing) {
+            const float lastTime = player->position();
+            player->setSlideTime(componentCurrentSlide, lastTime, forceUpdate);
+        }
+    }
 }
 
 void Q3DSSlidePlayer::sendPositionChanged(Q3DSSlide *slide, float pos)
@@ -1041,14 +1061,14 @@ void Q3DSSlidePlayer::onSlideFinished(Q3DSSlide *slide)
 
     // We don't change slides automatically in Editor mode
     if (m_mode == PlayerMode::Editor) {
-        setInternalState(PlayerState::Paused);
+        setInternalState(PlayerState::Stopped);
         return;
     }
 
     // Get the slide's play mode
     const auto playMode = slide->playMode();
 
-    PlayerState state = PlayerState::Paused;
+    PlayerState state = PlayerState::Stopped;
 
     switch (playMode) {
     case Q3DSSlide::Looping:
@@ -1084,7 +1104,7 @@ void Q3DSSlidePlayer::onSlideFinished(Q3DSSlide *slide)
         } else {
             m_data.loopCount = 0;
             m_data.playbackRate = rate;
-            state = PlayerState::Paused;
+            state = PlayerState::Stopped;
         }
     }
         break;
@@ -1096,7 +1116,7 @@ void Q3DSSlidePlayer::onSlideFinished(Q3DSSlide *slide)
     }
         break;
     case Q3DSSlide::StopAtEnd:
-        state = PlayerState::Paused;
+        state = PlayerState::Stopped;
         break;
     }
 
diff --git a/src/runtime/q3dsslideplayer_p.h b/src/runtime/q3dsslideplayer_p.h
index 7886489..832fb84 100644
--- a/src/runtime/q3dsslideplayer_p.h
+++ b/src/runtime/q3dsslideplayer_p.h
@@ -69,9 +69,9 @@ public:
     {
         Idle,
         Ready,
-        Stopped, // Stopped means the player and it's slides are reset to the starting point.
+        Stopped,
         Playing,
-        Paused // Paused means the state it paused at time t, this is also true for "stopAtEnd" with t = duration
+        Paused
     };
     Q_ENUM(PlayerState)
 
@@ -141,10 +141,10 @@ private:
     void onDurationChanged(float duration);
     void onSlideFinished(Q3DSSlide *slide);
     void setSlideTime(Q3DSSlide *slide, float time, bool forceUpdate = false);
-    void flushQueuedChanges();
 
     void handleCurrentSlideChanged(Q3DSSlide *slide,
-                                   Q3DSSlide *previousSlide);
+                                   Q3DSSlide *previousSlide,
+                                   bool forceUpdate = false);
 
     // TODO: Move out to a "slide manager"?
     void sendPositionChanged(Q3DSSlide *slide, float pos);
@@ -170,8 +170,6 @@ private:
     PlayerMode m_mode = PlayerMode::Viewer;
     PlayerType m_type = PlayerType::Scene;
 
-    QVector<std::function<void()>> m_queuedChanges;
-
     // This class handles animation callback from animationmanager and calls setSlideTime
     friend class Q3DSSlidePositionCallback;
     friend class Q3DSSceneManager;
diff --git a/tests/auto/slideplayer/tst_q3dsslideplayer.cpp b/tests/auto/slideplayer/tst_q3dsslideplayer.cpp
index 4b494bb..96fa78b 100644
--- a/tests/auto/slideplayer/tst_q3dsslideplayer.cpp
+++ b/tests/auto/slideplayer/tst_q3dsslideplayer.cpp
@@ -188,9 +188,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
     QCOMPARE(player->duration(), 1000);
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
-    // Stopped -> playing -> paused
+    // Stopped -> playing -> stopped
     QCOMPARE(stateChangeSpy.count(), 2);
     // PlayToNext -> StopAtEnd
     QCOMPARE(slideChangedSpy.count(), 1);
@@ -207,11 +207,10 @@ void tst_Q3DSSlidePlayer::tst_playModes()
     QCOMPARE(player->duration(), 1000);
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
-    // Stopped -> playing -> paused
+    // Stopped -> playing -> stopped
     QCOMPARE(stateChangeSpy.count(), 2);
-    // StopAtEnd (which was the previous slide, so no changes expected)
     QCOMPARE(slideChangedSpy.count(), 0);
     QCOMPARE(player->slideDeck()->currentSlide(), m_stopAtEnd);
 
@@ -220,15 +219,19 @@ void tst_Q3DSSlidePlayer::tst_playModes()
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
     slideChangedSpy.clear();
-    stateChangeSpy.clear();
 
     player->slideDeck()->setCurrentSlide(int(Slide::PlayToPrevious));
     QCOMPARE(player->duration(), 1000);
+    player->stop();
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
+
+    stateChangeSpy.clear();
+
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
-    // Stopped -> playing -> paused
+    // Stopped -> playing -> stopped
     QCOMPARE(stateChangeSpy.count(), 2);
     // StopAtEnd -> PlayToPrevious -> StopAtEnd
     QCOMPARE(slideChangedSpy.count(), 2);
@@ -247,9 +250,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
 
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
-    // Stopped -> playing -> paused
+    // Stopped -> playing -> stopped
     QCOMPARE(stateChangeSpy.count(), 2);
     // StopAtEnd -> Ping
     QCOMPARE(slideChangedSpy.count(), 1);
@@ -317,9 +320,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
 
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
-    // Stopped -> playing -> paused
+    // Stopped -> playing -> stopped
     QCOMPARE(stateChangeSpy.count(), 2);
     // Looping -> PlayToSlide -> FinalSlide
     QCOMPARE(slideChangedSpy.count(), 2);
@@ -340,9 +343,9 @@ void tst_Q3DSSlidePlayer::tst_playModes()
 
     player->play();
     QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Playing);
-    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Paused);
+    QTRY_COMPARE(player->state(), Q3DSSlidePlayer::PlayerState::Stopped);
 
-    // Stopped -> playing -> paused
+    // Stopped -> playing -> stopped
     QCOMPARE(stateChangeSpy.count(), 2);
     // FinalSlide -> Dummy
     QCOMPARE(slideChangedSpy.count(), 1);
diff --git a/tests/auto/slides/tst_q3dsslides.cpp b/tests/auto/slides/tst_q3dsslides.cpp
index f48311f..59d8809 100644
--- a/tests/auto/slides/tst_q3dsslides.cpp
+++ b/tests/auto/slides/tst_q3dsslides.cpp
@@ -261,79 +261,79 @@ void tst_Q3DSSlides::setPresentationSlides()
     m_updateSpy.wait(30);
 
     Q3DSSlidePlayer *player = m_sceneManager->slidePlayer();
-    player->pause();
+    player->stop();
     QVERIFY(player);
 
     // Check starting state
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_masterCylinder));
     // "Slide 1 Rect" should be visible
-    QTRY_VERIFY(isNodeVisible(m_slide1Rect));
-    QTRY_VERIFY(!isNodeVisible(m_slide4Cone));
+    QVERIFY(isNodeVisible(m_slide1Rect));
+    QVERIFY(!isNodeVisible(m_slide4Cone));
 
     // Set second slide
     m_sceneManager->setCurrentSlide(m_presentationSlide2, true);
     // Verify second slide state
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_masterCylinder));
     // "Slide 2 Sphere" should be visible
-    QTRY_VERIFY(isNodeVisible(m_slide2Sphere));
+    QVERIFY(isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
+    QVERIFY(!isNodeVisible(m_slide1Rect));
 
     // Go back to first slide
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
     // Check first slide state
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_masterCylinder));
     // "Slide 1 Rect" should be visible
-    QTRY_VERIFY(isNodeVisible(m_slide1Rect));
-    QTRY_VERIFY(!isNodeVisible(m_slide4Cone));
+    QVERIFY(isNodeVisible(m_slide1Rect));
+    QVERIFY(!isNodeVisible(m_slide4Cone));
     // "Slide 2 Sphere" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
+    QVERIFY(!isNodeVisible(m_slide2Sphere));
 
     // Set 3rd Slide (with Component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
     QCOMPARE(player->duration(), 10000);
     // MasterCylinder should be visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_masterCylinder));
     // Component Should be visible
-    QTRY_VERIFY(isNodeVisible(m_slide3Component));
+    QVERIFY(isNodeVisible(m_slide3Component));
     // "Slide 2 Sphere" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
+    QVERIFY(!isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
+    QVERIFY(!isNodeVisible(m_slide1Rect));
 
     // Set 4th Slide (from Component)
     m_sceneManager->setCurrentSlide(m_presentationSlide4, true);
     QCOMPARE(player->duration(), 12028);
     // MasterCylinder should be visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_masterCylinder));
     // Component Should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
+    QVERIFY(!isNodeVisible(m_slide3Component));
     // "Slide 2 Sphere" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
+    QVERIFY(!isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
+    QVERIFY(!isNodeVisible(m_slide1Rect));
     // Slide 4 Cone should be visible
-    QTRY_VERIFY(isNodeVisible(m_slide4Cone));
+    QVERIFY(isNodeVisible(m_slide4Cone));
 
     // Set the same slide again
     m_sceneManager->setCurrentSlide(m_presentationSlide4, true);
     QCOMPARE(player->duration(), 12028);
     // MasterCylinder should be visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_masterCylinder));
     // Component Should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
+    QVERIFY(!isNodeVisible(m_slide3Component));
     // "Slide 2 Sphere" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide2Sphere));
+    QVERIFY(!isNodeVisible(m_slide2Sphere));
     // "Slide 1 Rect" should not be visible
-    QTRY_VERIFY(!isNodeVisible(m_slide1Rect));
+    QVERIFY(!isNodeVisible(m_slide1Rect));
     // Slide 4 Cone should be visible
-    QTRY_VERIFY(isNodeVisible(m_slide4Cone));
+    QVERIFY(isNodeVisible(m_slide4Cone));
 }
 
 void tst_Q3DSSlides::presentationRollback()
@@ -343,27 +343,27 @@ void tst_Q3DSSlides::presentationRollback()
 
     // DynamicSphere exists on the master slide (visible by default)
     // DynamicSphere has eyeball set to false on Slides 2 and 4
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
 
     // Go to Second Slide
     m_sceneManager->setCurrentSlide(m_presentationSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_dynamicSphere));
 
     // Go to Third Slide (requires rollback)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
 
     // Go to Forth Slide
     m_sceneManager->setCurrentSlide(m_presentationSlide4, true);
-    QTRY_VERIFY(!isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_dynamicSphere));
 
     // Go to another slide with eyeball false (no rollback)
     m_sceneManager->setCurrentSlide(m_presentationSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_dynamicSphere));
 
     // Make sure rollback still works
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
 
 }
 
@@ -371,64 +371,64 @@ void tst_Q3DSSlides::setComponentSlides()
 {
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_slide3Component));
+    QVERIFY(isNodeVisible(m_slide3Component));
 
     // Initial slide should be m_componentSlide1
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
 
     // Switch to Component Slide 2 (text)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
 
     // Switch back to Component Slide 1
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
 
     // Switch to Component Slide 3 (deep component)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(isNodeVisible(m_componentSlide3Component));
 
     // Switch to same slide
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(isNodeVisible(m_componentSlide3Component));
 }
 
 void tst_Q3DSSlides::componentRollback()
 {
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_slide3Component));
+    QVERIFY(isNodeVisible(m_slide3Component));
 
     // Set first slide which contains "Master Cube"
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
 
     // Second slide sets Master Cube eyeball to false
     m_sceneManager->setComponentCurrentSlide(m_componentSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
 
     // Switch back to first slide (requires rollback)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
 
     // Move to slide 3 (no change)
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
 }
 
 void tst_Q3DSSlides::setDeepComponentSlides()
@@ -437,33 +437,33 @@ void tst_Q3DSSlides::setDeepComponentSlides()
     // PresentationSlide3 -> ComponentSlide3 -> DeepComponentSlide[n]
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_slide3Component));
+    QVERIFY(isNodeVisible(m_slide3Component));
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
+    QVERIFY(isNodeVisible(m_componentSlide3Component));
 
     // At this point the first slide of deep component should be active
     QVERIFY(m_componentSlide3Component->currentSlide() == m_deepComponentSlide1);
-    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
 
     // Switch to second deep component slide
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(isNodeVisible(m_deepComponentSlide2Moon));
 
     // Switch back to deep component first slide
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
 
     // Set same slide again
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
 }
 
 void tst_Q3DSSlides::deepComponentRollback()
@@ -472,21 +472,21 @@ void tst_Q3DSSlides::deepComponentRollback()
     // PresentationSlide3 -> ComponentSlide3 -> DeepComponentSlide[n]
     // Set the presentation slide to Slide3 (contains component)
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_slide3Component));
+    QVERIFY(isNodeVisible(m_slide3Component));
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
+    QVERIFY(isNodeVisible(m_componentSlide3Component));
 
     // First slide has "master text" active
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(isNodeVisible(m_deepComponentMasterText));
 
     // Second slide has eyeball set to false for master text
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // Switch back to first slide to perform rollback
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QTRY_VERIFY(isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(isNodeVisible(m_deepComponentMasterText));
 }
 
 void tst_Q3DSSlides::setNonVisibleComponentSlides()
@@ -499,85 +499,85 @@ void tst_Q3DSSlides::setNonVisibleComponentSlides()
 
     // Select a presentation slide that does not have a component
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
-    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
+    QVERIFY(!isNodeVisible(m_slide3Component));
 
     // m_slide3Component is only visible on m_presentationSlide3
     // change m_slide3Component's slides and make sure the contents
     // do not become visible.
     m_sceneManager->setComponentCurrentSlide(m_componentSlide1, true);
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     m_sceneManager->setComponentCurrentSlide(m_componentSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     m_sceneManager->setComponentCurrentSlide(m_componentSlide3, true);
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // also change deep compoents slides (now active in component slide3)
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide1, true);
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     m_sceneManager->setComponentCurrentSlide(m_deepComponentSlide2, true);
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // Now make component visible by switching to slide 3
     m_sceneManager->setCurrentSlide(m_presentationSlide3, true);
-    QTRY_VERIFY(isNodeVisible(m_slide3Component));
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(isNodeVisible(m_deepComponentSlide2Moon));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(isNodeVisible(m_slide3Component));
+    QVERIFY(isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 
     // make sure that they go away again
     m_sceneManager->setCurrentSlide(m_presentationSlide1, true);
-    QTRY_VERIFY(!isNodeVisible(m_slide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCube));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide1Cone));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide2Text));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide3Component));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
-    QTRY_VERIFY(!isNodeVisible(m_deepComponentMasterText));
+    QVERIFY(!isNodeVisible(m_slide3Component));
+    QVERIFY(!isNodeVisible(m_componentMasterCube));
+    QVERIFY(!isNodeVisible(m_componentSlide1Cone));
+    QVERIFY(!isNodeVisible(m_componentSlide2Text));
+    QVERIFY(!isNodeVisible(m_componentSlide3Component));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide1Cylinder));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Sphere));
+    QVERIFY(!isNodeVisible(m_deepComponentSlide2Moon));
+    QVERIFY(!isNodeVisible(m_deepComponentMasterText));
 }
 
 void tst_Q3DSSlides::testTimeLineVisibility()
@@ -586,13 +586,13 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     // and endtimes than the slide they are on
     m_sceneManager->setCurrentSlide(m_presentationSlide5, true);
 
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_slide5Rect));
+    QVERIFY(isNodeVisible(m_slide5Sphere));
 
     Q3DSSlidePlayer *player = m_sceneManager->slidePlayer();
-    player->pause();
+    player->stop();
     QVERIFY(player);
 
     QSignalSpy updateSpy(m_engine, SIGNAL(nextFrameStarting()));
@@ -608,7 +608,7 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     m_sceneManager->setComponentCurrentSlide(m_componentSlide51);
     Q_ASSERT(m_componentSlide5MasterSlide == m_slide5Component->masterSlide());
     Q3DSSlidePlayer *compPlayer = m_componentSlide5MasterSlide->attached<Q3DSSlideAttached>()->slidePlayer;
-    compPlayer->pause();
+    compPlayer->stop();
     QVERIFY(compPlayer);
 
     QSignalSpy compPositionChangedSpy(compPlayer, &Q3DSSlidePlayer::positionChanged);
@@ -623,34 +623,34 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     seekAndWait(999);
 
     // Still invisible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_slide5Rect));
+    QVERIFY(isNodeVisible(m_slide5Sphere));
+    QVERIFY(!isNodeVisible(m_slide5Component));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(1000);
 
     // Slide 5 component becomes visible, but not components objects
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(isNodeVisible(m_slide5Rect));
+    QVERIFY(isNodeVisible(m_slide5Sphere));
+    QVERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(1500);
     // Sync up the comp player
     seekAndWaitForComp(1500);
 
     // Everything now visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(isNodeVisible(m_slide5Rect));
+    QVERIFY(isNodeVisible(m_slide5Sphere));
+    QVERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     // Verify a positionChanged signal coming from component slide player
     seekAndWaitForComp(1501);
@@ -660,36 +660,36 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     seekAndWaitForComp(2000);
 
     // Everything still visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(isNodeVisible(m_slide5Rect));
+    QVERIFY(isNodeVisible(m_slide5Sphere));
+    QVERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(2001);
     // Sync up the comp player
     seekAndWaitForComp(2001);
 
     // Neither rect nor sphere are visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_slide5Rect));
+    QVERIFY(!isNodeVisible(m_slide5Sphere));
+    QVERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWait(2885);
     // Sync up the comp player
     seekAndWaitForComp(2885);
 
     // Neither rect nor sphere are visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_slide5Rect));
+    QVERIFY(!isNodeVisible(m_slide5Sphere));
+    QVERIFY(!isNodeVisible(m_slide5Component));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 
     // Now test time lines that are out of sync
     // Start by a know state with all visible
@@ -698,67 +698,67 @@ void tst_Q3DSSlides::testTimeLineVisibility()
     seekAndWaitForComp(1500);
 
     // Everything now visible
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(isNodeVisible(m_slide5Rect));
+    QVERIFY(isNodeVisible(m_slide5Sphere));
+    QVERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
 
     seekAndWaitForComp(0);
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWaitForComp(1300);
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(3000);
-    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
+    QVERIFY(!isNodeVisible(m_slide5Component));
     // Component nodes should be hidden by parent.
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(1500);
-    QTRY_VERIFY(isNodeVisible(m_slide5Component));
+    QVERIFY(isNodeVisible(m_slide5Component));
     // Component nodes should be made visible by parent.
-    QTRY_VERIFY(isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(3000);
-    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
+    QVERIFY(!isNodeVisible(m_slide5Component));
     // Make the parent make the component nodes hidden again
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWaitForComp(1000);
     // Component should not make its nodes visible.
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWaitForComp(100);
     // Hidden by component
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(1500);
     // ... Now make sure the parent doesn't make the component nodes visible!
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
-    QTRY_VERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(!isNodeVisible(m_componentSlide5Slide1Cone));
 
     seekAndWait(0);
     // Sync up the comp player
     seekAndWaitForComp(0);
 
     // Back to the beginning
-    QTRY_VERIFY(isNodeVisible(m_masterCylinder));
-    QTRY_VERIFY(isNodeVisible(m_dynamicSphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Rect));
-    QTRY_VERIFY(isNodeVisible(m_slide5Sphere));
-    QTRY_VERIFY(!isNodeVisible(m_slide5Component));
-    QTRY_VERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
+    QVERIFY(isNodeVisible(m_masterCylinder));
+    QVERIFY(isNodeVisible(m_dynamicSphere));
+    QVERIFY(!isNodeVisible(m_slide5Rect));
+    QVERIFY(isNodeVisible(m_slide5Sphere));
+    QVERIFY(!isNodeVisible(m_slide5Component));
+    QVERIFY(!isNodeVisible(m_componentMasterCubeSlide5));
 }
 
 Q3DSModelNode *tst_Q3DSSlides::getModelWithName(const QString &name, Q3DSGraphObject *parent)