restore player pause and step

Source/Atomic/Engine/Engine.cpp

@@ -111,7 +111,11 @@ Engine::Engine(Context* context) :
     initialized_(false),
     exiting_(false),
     headless_(false),
-    audioPaused_(false)
+    audioPaused_(false),
+    // ATOMIC BEGIN    
+    paused_(false),
+    runNextPausedFrame_(false)
+    // ATOMIC END
 {
     // Register self as a subsystem
     context_->RegisterSubsystem(this);
@@ -150,6 +154,10 @@ Engine::Engine(Context* context) :
 #endif
 
     SubscribeToEvent(E_EXITREQUESTED, ATOMIC_HANDLER(Engine, HandleExitRequested));
+    // ATOMIC BEGIN    
+    SubscribeToEvent(E_PAUSERESUMEREQUESTED, ATOMIC_HANDLER(Engine, HandlePauseResumeRequested));
+    SubscribeToEvent(E_PAUSESTEPREQUESTED, ATOMIC_HANDLER(Engine, HandlePauseStepRequested));
+    // ATOMIC END
 }
 
 Engine::~Engine()
@@ -469,8 +477,10 @@ void Engine::RunFrame()
 
     time->BeginFrame(timeStep_);
 
-    // If pause when minimized -mode is in use, stop updates and audio as necessary
-    if (pauseMinimized_ && input->IsMinimized())
+// ATOMIC BEGIN
+    // If paused, or pause when minimized -mode is in use, stop updates and audio as necessary
+    if ((paused_ && !runNextPausedFrame_) ||
+        (pauseMinimized_ && input->IsMinimized()))
     {
         if (audio->IsPlaying())
         {
@@ -486,9 +496,15 @@ void Engine::RunFrame()
             audio->Play();
             audioPaused_ = false;
         }
+        
+        // Only run one frame when stepping
+        runNextPausedFrame_ = false;
 
         Update();
+
     }
+// ATOMIC END
+
 
     Render();
     ApplyFrameLimit();
@@ -982,6 +998,36 @@ void Engine::DoExit()
 
 // ATOMIC BEGIN
 
+void Engine::SetPaused(bool paused)
+{
+    paused_ = paused;
+
+    using namespace UpdatesPaused;
+
+    // Updates paused event
+    VariantMap& eventData = GetEventDataMap();
+    eventData[P_PAUSED] = paused_;
+    SendEvent(E_UPDATESPAUSEDRESUMED, eventData);
+}
+
+void Engine::SetRunNextPausedFrame(bool run)
+{
+    runNextPausedFrame_ = run;
+}
+
+void Engine::HandlePauseResumeRequested(StringHash eventType, VariantMap& eventData)
+{
+    SetPaused(!IsPaused());
+}
+
+void Engine::HandlePauseStepRequested(StringHash eventType, VariantMap& eventData)
+{
+    if (IsPaused())
+    {
+        SetRunNextPausedFrame(true);
+    }
+}
+
 bool Engine::GetDebugBuild() const
 {
 #ifdef ATOMIC_DEBUG

Source/Atomic/Engine/Engine.h

@@ -120,12 +120,29 @@ public:
 
 
     // ATOMIC BEGIN
+    /// Set whether the engine is paused.
+    void SetPaused(bool paused);
+    /// Set whether to run the next frame even if paused (for stepping frame by frame)
+    void SetRunNextPausedFrame(bool run);
+     /// Return whether the engine is paused.
+    bool IsPaused() const { return paused_; }
+    /// Return whether to run the next frame even if paused (for stepping frame by frame)
+    bool GetRunNextPausedFrame() const { return runNextPausedFrame_; }
+   
+    
     bool GetDebugBuild() const;
     // ATOMIC END
 
 private:
     /// Handle exit requested event. Auto-exit if enabled.
     void HandleExitRequested(StringHash eventType, VariantMap& eventData);
+    // ATOMIC BEGIN
+    /// Handle Pause or Resume requested event.
+    void HandlePauseResumeRequested(StringHash eventType, VariantMap& eventData);
+    /// Handle Single Step requested event.
+    void HandlePauseStepRequested(StringHash eventType, VariantMap& eventData);
+    // ATOMIC END
+
     /// Actually perform the exit actions.
     void DoExit();
 
@@ -159,6 +176,14 @@ private:
     bool headless_;
     /// Audio paused flag.
     bool audioPaused_;
+    
+    // ATOMIC BEGIN
+    /// Engine paused flag
+    bool paused_;
+    /// Whether to run the next frame even if paused (for stepping frame by frame)
+    bool runNextPausedFrame_;
+    // ATOMIC END
+   
 };
 
 }