[Pingus-CVS] r3749 - in trunk/pingus/src: . screen

[grumbel at BerliOS]

Author: grumbel
Date: 2008-07-09 03:21:45 +0200 (Wed, 09 Jul 2008)
New Revision: 3749

Removed:
   trunk/pingus/src/delta_manager.hpp
Modified:
   trunk/pingus/src/globals.cpp
   trunk/pingus/src/pingus_main.cpp
   trunk/pingus/src/screen/screen_manager.cpp
   trunk/pingus/src/screen/screen_manager.hpp
Log:
Kind of bigish ScreenManager cleanup, might break some stuff, needs testing

Deleted: trunk/pingus/src/delta_manager.hpp
===================================================================
--- trunk/pingus/src/delta_manager.hpp  2008-07-08 23:42:42 UTC (rev 3748)
+++ trunk/pingus/src/delta_manager.hpp  2008-07-09 01:21:45 UTC (rev 3749)
@@ -1,84 +0,0 @@
-//  Pingus - A free Lemmings clone
-//  Copyright (C) 2000 Ingo Ruhnke <address@hidden>
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//  
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//  
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#ifndef HEADER_PINGUS_DELTA_MANAGER_HPP
-#define HEADER_PINGUS_DELTA_MANAGER_HPP
-
-#include "SDL.h"
-#include <assert.h>
-#include <iostream>
-#include "pingus.hpp"
-
-
-class DeltaManager
-{
-private:
-  unsigned int absolute_time; ///< time in milliseconds since the start of 
DeltaManager
-  unsigned int last_time; ///< number of ticks when we were last set
-public:
-  DeltaManager ()
-    : absolute_time(0),
-      last_time (SDL_GetTicks())
-  {}
-
-  /** @brief get the current delta and start a new one
-   * @return the current delta in seconds
-   */
-  float getset ()
-  {
-    float ret = get ();
-    set ();
-    return ret;
-  }
-
-  /** @brief set the start of the delta */
-  void set ()
-  {
-    unsigned int ticks = SDL_GetTicks();
-    absolute_time += ticks - last_time;
-    last_time = ticks;
-  }
-
-  /** @return the current delta in seconds */
-  float get () const
-  {
-    unsigned int t = SDL_GetTicks();
-    if (t < last_time)
-      { // catching time travel
-        std::cout << "Time Travel: first: " << last_time << " second: " << t 
<< std::endl;
-        return 0.0f;
-      }
-    else
-      {
-        return (SDL_GetTicks() - last_time) / 1000.0f;
-      }
-  }
-
-  /** @return time in miliseconds passed since the start of the DeltaManager */
-  unsigned int get_absolute() const
-  {
-    return absolute_time;
-  }
-
-private:
-  DeltaManager (const DeltaManager&);
-  DeltaManager& operator= (const DeltaManager&);
-};
-
-
-#endif
-
-/* EOF */

Modified: trunk/pingus/src/globals.cpp
===================================================================
--- trunk/pingus/src/globals.cpp        2008-07-08 23:42:42 UTC (rev 3748)
+++ trunk/pingus/src/globals.cpp        2008-07-09 01:21:45 UTC (rev 3749)
@@ -15,10 +15,9 @@
 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "globals.hpp"
-
-
+
 int         game_speed                      = 20;
-float         desired_fps                     = 40;
+float       desired_fps                     = 40;
 bool        print_fps                       = false;
 int         verbose                         = 0;
 bool        music_enabled                   = true;
@@ -46,5 +45,5 @@
 unsigned int pingus_debug_flags              = 0;
 
 bool        fullscreen_enabled              = false;
-
+
 /* EOF */

Modified: trunk/pingus/src/pingus_main.cpp
===================================================================
--- trunk/pingus/src/pingus_main.cpp    2008-07-08 23:42:42 UTC (rev 3748)
+++ trunk/pingus/src/pingus_main.cpp    2008-07-09 01:21:45 UTC (rev 3749)
@@ -741,7 +741,7 @@
 PingusMain::on_exit_press()
 {
   std::cout << "Exit pressed" << std::endl;
-  ScreenManager::instance()->clear();
+  ScreenManager::instance()->pop_all_screens();
 }
 
 void

Modified: trunk/pingus/src/screen/screen_manager.cpp
===================================================================
--- trunk/pingus/src/screen/screen_manager.cpp  2008-07-08 23:42:42 UTC (rev 
3748)
+++ trunk/pingus/src/screen/screen_manager.cpp  2008-07-09 01:21:45 UTC (rev 
3749)
@@ -16,7 +16,6 @@
 
 #include "SDL.h"
 #include <iostream>
-#include "../delta_manager.hpp"
 #include "../globals.hpp"
 #include "math/size.hpp"
 #include "pathname.hpp"
@@ -36,8 +35,7 @@
 {  
   assert(instance_ == 0);
   instance_ = this;
-  cached_action = CA_NONE;
-  
+    
   input_manager = std::auto_ptr<Input::Manager>(new Input::Manager());
 
   if (controller_file.empty())
@@ -51,7 +49,7 @@
   fps_counter = std::auto_ptr<FPSCounter>(new FPSCounter());
 }
 
-ScreenManager::~ScreenManager ()
+ScreenManager::~ScreenManager()
 {
   instance_ = 0;
 }
@@ -60,104 +58,83 @@
 ScreenManager::display()
 {
   show_swcursor(swcursor_enabled);
-  DeltaManager delta_manager;
+  
+  Uint32 last_ticks = SDL_GetTicks();
 
-  // Main loop for the menu
-  // and incidentally this is also the main loop for the whole game
   while (!screens.empty())
     {
-      // how long the previous frame (iteration) took (if any)
-      float time_delta = delta_manager.getset();
+      Uint32 ticks = SDL_GetTicks();
+      float delta  = float(ticks - last_ticks)/1000.0f;
 
       // previous frame took more than one second
-      if (time_delta > 1.0)
-       {
+      if (delta > 1.0)
+        {
           if (maintainer_mode)
-            std::cout << "ScreenManager: detected large delta (" << time_delta
+            std::cout << "ScreenManager: detected large delta (" << delta
                       << "), ignoring and doing frameskip" << std::endl;
-         continue; // skip this frame
-       }
+        }
+      else
+        {
+          if (swcursor_enabled)
+            cursor.update(delta);
+  
+          update(delta);
+      
+          // cap the framerate at the desired value
+          if (delta < 1.0f / desired_fps) {
+            // idle delay to make the frame take as long as we want it to
+            SDL_Delay(static_cast<Uint32>(1000 *((1.0f / desired_fps) - 
delta)));
+          }
+        }
 
-      last_screen = get_current_screen();
+      last_ticks   = ticks;
+    }
+}
+ 
+void
+ScreenManager::update(float delta)
+{
+  ScreenPtr last_screen = get_current_screen();
             
-      // update the input
-      input_manager->update(time_delta);
-      std::vector<Input::Event> events = input_controller->poll_events();
-      for(std::vector<Input::Event>::iterator i = events.begin(); 
-          i != events.end() && last_screen == get_current_screen(); 
-          ++i)
+  // update the input, break away as soon as the current screen changed
+  input_manager->update(delta);
+  std::vector<Input::Event> events = input_controller->poll_events();
+  for(std::vector<Input::Event>::iterator i = events.begin(); 
+      i != events.end();
+      ++i)
+    {
+      last_screen->update(*i);
+      if (last_screen != get_current_screen())
         {
-          get_current_screen()->update(*i);
+          fade_over(last_screen, get_current_screen());
+          return;
         }
-      get_current_screen()->update(time_delta);
+    }
 
-      if (swcursor_enabled)
-        cursor.update(time_delta);
+  last_screen->update(delta);
+  if (last_screen != get_current_screen())
+    {
+      fade_over(last_screen, get_current_screen());
+      return;
+    }
 
-      // Last screen has popped, so we are going to end here
-      if (screens.empty())
-       continue;
+  // Draw screen
+  if (get_current_screen()->draw(*display_gc))
+    {
+      display_gc->render(Display::get_screen(), Rect(Vector2i(0,0), 
Size(Display::get_width(),
+                                                                         
Display::get_height())));
 
-      while (cached_action != CA_NONE)
+      if (swcursor_enabled)
         {
-          switch (cached_action)
-            {
-            case CA_POP:
-              real_pop_screen();
-              break;
-            case CA_POP_ALL:
-              real_pop_all_screens();
-              break;
-            case CA_REPLACE:
-              real_replace_screen(replace_screen_arg);
-              break;
-            case CA_CLEAR:
-              real_clear();
-              break;
-            default:
-              break;
-            }
+          Vector2f mouse_pos = 
Input::Controller::current()->get_pointer(Input::STANDARD_POINTER)->get_pos();
+          cursor.draw(mouse_pos.x, mouse_pos.y, Display::get_screen());
         }
 
-      // FIXME: is there a more gentel way to do that instead of spreading the 
checks all around here?
-      // Last screen has poped, so we are going to end here
-      if (screens.empty())
-       continue;
+      if (print_fps)
+        fps_counter->draw();
 
-      // skip draw if the screen changed to avoid glitches
-      if (last_screen == get_current_screen())
-       {
-         if (get_current_screen()->draw(*display_gc))
-            {
-              display_gc->render(Display::get_screen(), Rect(Vector2i(0,0), 
Size(Display::get_width(),
-                                                                               
  Display::get_height())));
-
-              if (swcursor_enabled)
-                {
-                  Vector2f mouse_pos = 
Input::Controller::current()->get_pointer(Input::STANDARD_POINTER)->get_pos();
-                  cursor.draw(mouse_pos.x, mouse_pos.y, Display::get_screen());
-                }
-
-              if (print_fps)
-                fps_counter->draw();
-
-              Display::flip_display();
-              display_gc->clear();
-            }
-        }
-      else
-       {
-         //std::cout << "ScreenManager: fading screens" << std::endl;
-         //FIXME: this shouldn't be done in one iteration of this loop (one 
frame)
-         fade_over(last_screen, get_current_screen());
-       }
-
-      // save this value because it might change drastically within the if 
statement
-      // cap the framerate at the desired value
-      if (time_delta < 1 / desired_fps) {
-       // idle delay to make the frame take as long as we want it to
-       SDL_Delay(static_cast<Uint32>(1000 *((1 / desired_fps) - time_delta)));
-      }
+      Display::flip_display();
+      display_gc->clear();
     }
 }
 
@@ -165,70 +142,33 @@
 ScreenManager::get_current_screen()
 {
   assert(!screens.empty());
-  return screens.back ();
+  return screens.back();
 }
 
 ScreenManager*
-ScreenManager::instance ()
+ScreenManager::instance()
 {
   return instance_;
 }
 
 void
 ScreenManager::push_screen (Screen* screen)
-{
+{ 
   if (!screens.empty())
-    {
-      screens.back()->on_shutdown();
-    }
+    screens.back()->on_shutdown();
 
   screens.push_back(ScreenPtr(screen));
   screen->on_startup();
 }
 
 void
-ScreenManager::pop_screen ()
+ScreenManager::pop_screen()
 {
-  assert(cached_action == CA_NONE);
-  cached_action = CA_POP;
-}
-
-void
-ScreenManager::pop_all_screens()
-{
-  assert(cached_action == CA_NONE);
-  cached_action = CA_POP_ALL;
-}
-
-void
-ScreenManager::replace_screen (Screen* screen)
-{
-  assert(cached_action == CA_NONE);
-  cached_action = CA_REPLACE;
-  replace_screen_arg = ScreenPtr(screen);
-}
-
-void
-ScreenManager::real_replace_screen (ScreenPtr ptr)
-{
-  cached_action = CA_NONE;
-  screens.back()->on_shutdown ();
-  screens.back() = ptr;
-
-  if (screens.back()->get_size() != Display::get_size())
-    screens.back()->resize(Display::get_size());
-  screens.back()->on_startup();
-}
-
-void
-ScreenManager::real_pop_screen ()
-{
-  cached_action = CA_NONE;
-  ScreenPtr back = screens.back ();
+  ScreenPtr back = screens.back();
   screens.pop_back();
   back->on_shutdown();
 
-  if (!screens.empty ())
+  if (!screens.empty())
     {
       if (screens.back()->get_size() != Display::get_size())
         screens.back()->resize(Display::get_size());
@@ -237,9 +177,8 @@
 }
 
 void
-ScreenManager::real_pop_all_screens()
+ScreenManager::pop_all_screens()
 {
-  cached_action = CA_NONE;
   ScreenPtr back = screens.back();
   screens.pop_back();
   back->on_shutdown();
@@ -248,30 +187,24 @@
 }
 
 void
-ScreenManager::clear()
+ScreenManager::replace_screen (Screen* screen)
 {
-  cached_action = CA_CLEAR;
-}
+  screens.back()->on_shutdown();
+  screens.back() = ScreenPtr(screen);
 
-void
-ScreenManager::real_clear()
-{
-  cached_action = CA_NONE;
-  screens.clear();
-}
+  if (screens.back()->get_size() != Display::get_size())
+    screens.back()->resize(Display::get_size());
+  screens.back()->on_startup();
 
+}
+
 void
 ScreenManager::fade_over(ScreenPtr old_screen, ScreenPtr new_screen)
 {
-  DeltaManager delta_manager;
-  float passed_time = 0;
-
+  Uint32 last_ticks = SDL_GetTicks();
   float progress = 0.0f;
   while (progress <= 1.0f)
     {
-      float time_delta = delta_manager.getset ();
-      passed_time += time_delta;
-
       int border_x = int((Display::get_width()/2)  * (1.0f - progress));
       int border_y = int((Display::get_height()/2) * (1.0f - progress));
 
@@ -288,23 +221,24 @@
       display_gc->render(Display::get_screen(), Rect(Vector2i(0,0), 
Size(Display::get_width(),
                                                                          
Display::get_height())));
       display_gc->clear();
-
-      //GameDelta delta (time_delta, CL_System::get_time(), events);
-      // FIXME: Animation looks nifty but doesn't work all that good
-      //new_screen->update (delta);
-      //old_screen->update (delta);
       
       Display::pop_cliprect();
-      Display::flip_display ();
+      Display::flip_display();
       display_gc->clear();
       
-      progress = passed_time/1.0f;
+      progress = (SDL_GetTicks() - last_ticks)/1000.0f;
     }
 }
 
 void
-ScreenManager::resize(const Size& size)
+ScreenManager::resize(const Size& size_)
 {
+  Size size(size_);
+
+  // Limit Window size so some reasonable minimum
+  if (size.width  < 640) size.width  = 640;
+  if (size.height < 480) size.height = 480;
+
   display_gc->set_rect(Rect(Vector2i(0, 0), size));
 
   // FIXME: Calling this causes horrible flicker, since the screen

Modified: trunk/pingus/src/screen/screen_manager.hpp
===================================================================
--- trunk/pingus/src/screen/screen_manager.hpp  2008-07-08 23:42:42 UTC (rev 
3748)
+++ trunk/pingus/src/screen/screen_manager.hpp  2008-07-09 01:21:45 UTC (rev 
3749)
@@ -53,12 +53,6 @@
       or replaced) */
   std::vector<ScreenPtr> screens;
 
-  /** the screen that was used in the last update() */
-  ScreenPtr last_screen;
-
-  enum { CA_NONE, CA_POP, CA_POP_ALL, CA_REPLACE, CA_CLEAR } cached_action;
-  ScreenPtr replace_screen_arg;
-
 public:
   ScreenManager ();
   ~ScreenManager();
@@ -67,45 +61,33 @@
 
   /** Start the screen manager and let it take control, this will
       not return until the somebody signals a quit() */
-  void display ();
+  void display();
 
+  void update(float delta);
+
   /** Replace the current screen */
-  void replace_screen (Screen*);
+  void replace_screen(Screen*);
 
   /** Add a screen on top of another screen */
-  void push_screen (Screen*);
+  void push_screen(Screen*);
 
   /** Remove the current screen and fall back to the last one */
-  void pop_screen ();
+  void pop_screen();
 
   /** Remove all screens */
   void pop_all_screens();
 
-  /** Remove all screens from the stack */
-  void clear();
-
   /** @return a pointer to the current Screen */
   ScreenPtr get_current_screen();
 
   void show_swcursor(bool v);
   
 private:
-  void real_clear();
-
-  /** Replace the current screen */
-  void real_replace_screen (ScreenPtr);
-
-  /** Remove the current screen and fall back to the last one */
-  void real_pop_screen ();
-
-  /** Remove all screens */
-  void real_pop_all_screens();
-
   /** FadeOver test*/
-  void fade_over (ScreenPtr old_screen, ScreenPtr new_screen);
+  void fade_over(ScreenPtr old_screen, ScreenPtr new_screen);
 
 public:
-  static ScreenManager* instance ();
+  static ScreenManager* instance();
 
 private:
   ScreenManager (const ScreenManager&);