ScreenManager Class Reference

Manages, updates and draws all Screens, Controllers, Menus and the Console. More...

#include <screen_manager.hpp>

List of all members.

Public Member Functions
	ScreenManager ()
	~ScreenManager ()
void	run (DrawingContext &context)
void	exit_screen (ScreenFade *fade=NULL)
void	quit (ScreenFade *fade=NULL)
void	set_speed (float speed)
float	get_speed () const
bool	has_no_pending_fadeout () const
void	take_screenshot ()
	requests that a screenshot be taken after the next frame has been rendered
void	push_screen (Screen *screen, ScreenFade *fade=NULL)
void	set_screen_fade (ScreenFade *fade)
Public Attributes
scripting::ThreadQueue	waiting_threads
	threads that wait for a screenswitch
Private Member Functions
void	draw_fps (DrawingContext &context, float fps)
void	draw (DrawingContext &context)
void	update_gamelogic (float elapsed_time)
void	process_events ()
void	handle_screen_switch ()
Private Attributes
bool	running
float	speed
bool	nextpop
bool	nextpush
float	fps
	measured fps
std::auto_ptr< Screen >	next_screen
std::auto_ptr< Screen >	current_screen
std::auto_ptr< Console >	console
std::auto_ptr< ScreenFade >	screen_fade
std::vector< Screen * >	screen_stack
bool	screenshot_requested
	true if a screenshot should be taken after the next frame has been rendered

---

Detailed Description

Manages, updates and draws all Screens, Controllers, Menus and the Console.

Definition at line 33 of file screen_manager.hpp.

---

Constructor & Destructor Documentation

ScreenManager::ScreenManager

(

)

Definition at line 43 of file screen_manager.cpp.

                             :
  waiting_threads(),
  running(),
  speed(1.0), 
  nextpop(false), 
  nextpush(false), 
  fps(0), 
  next_screen(),
  current_screen(),
  console(),
  screen_fade(),
  screen_stack(),
  screenshot_requested(false)
{
  using namespace scripting;
  TimeScheduler::instance = new TimeScheduler();
}

ScreenManager::~ScreenManager

(

)

Definition at line 61 of file screen_manager.cpp.

References screen_stack.

{
  using namespace scripting;
  delete TimeScheduler::instance;
  TimeScheduler::instance = NULL;

  for(std::vector<Screen*>::iterator i = screen_stack.begin();
      i != screen_stack.end(); ++i) {
    delete *i;
  }
}

---

Member Function Documentation

void ScreenManager::run

(

DrawingContext &

context

)

Definition at line 278 of file screen_manager.cpp.

References current_screen, draw(), g_game_speed, game_time, handle_screen_switch(), LOGICAL_FPS, process_events(), real_time, running, sound_manager, speed, TICKS_PER_FRAME, SoundManager::update(), and update_gamelogic().

Referenced by Main::run().

{
  Uint32 last_ticks = 0;
  Uint32 elapsed_ticks = 0;

  running = true;
  while(running) {

    handle_screen_switch();
    if(!running || current_screen.get() == NULL)
      break;

    Uint32 ticks = SDL_GetTicks();
    elapsed_ticks += ticks - last_ticks;
    last_ticks = ticks;

    Uint32 ticks_per_frame = (Uint32) (TICKS_PER_FRAME * g_game_speed);

    if (elapsed_ticks > ticks_per_frame*4) {
      // when the game loads up or levels are switched the
      // elapsed_ticks grows extremely large, so we just ignore those
      // large time jumps
      elapsed_ticks = 0;
    }

    if(elapsed_ticks < ticks_per_frame)
    {
      Uint32 delay_ticks = ticks_per_frame - elapsed_ticks;
      SDL_Delay(delay_ticks);
      last_ticks += delay_ticks;
      elapsed_ticks += delay_ticks;
    }

    int frames = 0;

    while(elapsed_ticks >= ticks_per_frame && frames < MAX_FRAME_SKIP) 
    {
      elapsed_ticks -= ticks_per_frame;
      float timestep = 1.0 / LOGICAL_FPS;
      real_time += timestep;
      timestep *= speed;
      game_time += timestep;

      process_events();
      update_gamelogic(timestep);
      frames += 1;
    }

    draw(context);

    sound_manager->update();
  }
}

void ScreenManager::exit_screen

(

ScreenFade *

fade = NULL

)

Definition at line 84 of file screen_manager.cpp.

References next_screen, nextpop, nextpush, and screen_fade.

Referenced by worldmap::WorldMap::change(), TextScroller::draw(), scripting::exit_screen(), GameSession::finish(), GameSession::process_menu(), quit(), GameSession::restart_level(), worldmap::WorldMap::update(), TextScroller::update(), and LevelIntro::update().

{
  next_screen.reset(NULL);
  this->screen_fade.reset(screen_fade);
  nextpop = true;
  nextpush = false;
}

void ScreenManager::quit

(

ScreenFade *

fade = NULL

)

Definition at line 99 of file screen_manager.cpp.

References exit_screen(), screen_fade, and screen_stack.

Referenced by MainMenu::check_menu(), process_events(), scripting::quit(), and Main::wait_for_event().

{
  for(std::vector<Screen*>::iterator i = screen_stack.begin();
      i != screen_stack.end(); ++i)
    delete *i;
  screen_stack.clear();

  exit_screen(screen_fade);
}

void ScreenManager::set_speed

(

float

speed

)

Definition at line 110 of file screen_manager.cpp.

Referenced by GameSession::start_sequence(), GameSession::toggle_pause(), TitleScreen::update(), and GameSession::update().

{
  this->speed = speed;
}

float ScreenManager::get_speed

(

)

const

Definition at line 116 of file screen_manager.cpp.

References speed.

Referenced by GameSession::GameSession(), EndSequenceWalkRight::starting(), EndSequenceWalkLeft::starting(), EndSequenceFireworks::starting(), and GameSession::toggle_pause().

{
  return speed;
}

bool ScreenManager::has_no_pending_fadeout

(

)

const

Definition at line 122 of file screen_manager.cpp.

References screen_fade.

Referenced by handle_screen_switch(), and TitleScreen::update().

{
  return screen_fade.get() == NULL || screen_fade->done();
}

void ScreenManager::take_screenshot

(

)

requests that a screenshot be taken after the next frame has been rendered

Definition at line 333 of file screen_manager.cpp.

References screenshot_requested.

Referenced by process_events().

{
  screenshot_requested = true;
}

void ScreenManager::push_screen	(	Screen *	screen,
		ScreenFade *	fade = NULL
	)

Definition at line 74 of file screen_manager.cpp.

References next_screen, nextpop, nextpush, screen_fade, and speed.

Referenced by worldmap::WorldMap::change(), MainMenu::check_menu(), ContribWorldMenu::check_menu(), scripting::display_text_file(), scripting::load_level(), scripting::load_worldmap(), World::run(), Main::run(), GameSession::setup(), and worldmap::WorldMap::update().

{
  this->next_screen.reset(screen);
  this->screen_fade.reset(screen_fade);
  nextpush = !nextpop;
  nextpop = false;
  speed = 1.0f;
}

void ScreenManager::set_screen_fade

(

ScreenFade *

fade

)

Definition at line 93 of file screen_manager.cpp.

References screen_fade.

Referenced by scripting::abort_screenfade(), scripting::fadeout_screen(), and scripting::shrink_screen().

{
  this->screen_fade.reset(screen_fade);
}

void ScreenManager::draw_fps	(	DrawingContext &	context,
		float	fps
	)			[private]

Definition at line 128 of file screen_manager.cpp.

References ALIGN_LEFT, ALIGN_RIGHT, BORDER_X, BORDER_Y, DrawingContext::draw_text(), LAYER_HUD, SCREEN_WIDTH, and Resources::small_font.

Referenced by draw().

{
  char str[60];
  snprintf(str, sizeof(str), "%3.1f", fps_fps);
  const char* fpstext = "FPS";
  context.draw_text(Resources::small_font, fpstext, 
                    Vector(SCREEN_WIDTH - Resources::small_font->get_text_width(fpstext) - Resources::small_font->get_text_width(" 99999") - BORDER_X, 
                           BORDER_Y + 20), ALIGN_LEFT, LAYER_HUD);
  context.draw_text(Resources::small_font, str, Vector(SCREEN_WIDTH - BORDER_X, BORDER_Y + 20), ALIGN_RIGHT, LAYER_HUD);
}

void ScreenManager::draw

(

DrawingContext &

context

)

[private]

Definition at line 140 of file screen_manager.cpp.

References MenuManager::current(), current_screen, DrawingContext::do_drawing(), Console::draw(), Menu::draw(), draw_fps(), fps, g_config, Console::instance, screen_fade, screenshot_requested, Config::show_fps, and DrawingContext::take_screenshot().

Referenced by run().

{
  static Uint32 fps_ticks = SDL_GetTicks();
  static int frame_count = 0;

  current_screen->draw(context);
  if(MenuManager::current() != NULL)
    MenuManager::current()->draw(context);
  if(screen_fade.get() != NULL)
    screen_fade->draw(context);
  Console::instance->draw(context);

  if(g_config->show_fps)
    draw_fps(context, fps);

  // if a screenshot was requested, pass request on to drawing_context
  if (screenshot_requested) {
    context.take_screenshot();
    screenshot_requested = false;
  }
  context.do_drawing();

  /* Calculate frames per second */
  if(g_config->show_fps)
  {
    ++frame_count;

    if(SDL_GetTicks() - fps_ticks >= 500)
    {
      fps = (float) frame_count / .5;
      frame_count = 0;
      fps_ticks = SDL_GetTicks();
    }
  }
}

void ScreenManager::update_gamelogic

(

float

elapsed_time

)

[private]

Definition at line 177 of file screen_manager.cpp.

References MenuManager::current(), current_screen, game_time, Console::instance, scripting::TimeScheduler::instance, screen_fade, Console::update(), Menu::update(), and scripting::update_debugger().

Referenced by run().

{
  scripting::update_debugger();
  scripting::TimeScheduler::instance->update(game_time);
  current_screen->update(elapsed_time);
  if (MenuManager::current() != NULL)
    MenuManager::current()->update();
  if(screen_fade.get() != NULL)
    screen_fade->update(elapsed_time);
  Console::instance->update(elapsed_time);
}

void ScreenManager::process_events

(

)

[private]

Definition at line 190 of file screen_manager.cpp.

References Renderer::apply_config(), Config::console_enabled, MenuManager::current(), Menu::event(), g_config, g_jk_controller, Console::instance, Renderer::instance(), JoystickKeyboardController::process_event(), quit(), MenuManager::recalc_pos(), Renderer::resize(), Config::save(), Config::show_fps, take_screenshot(), Console::toggle(), JoystickKeyboardController::update(), and Config::use_fullscreen.

Referenced by run().

{
  g_jk_controller->update();
  Uint8* keystate = SDL_GetKeyState(NULL);
  SDL_Event event;
  while(SDL_PollEvent(&event)) 
  {
    g_jk_controller->process_event(event);

    if(MenuManager::current() != NULL)
      MenuManager::current()->event(event);

    switch(event.type)
    {
      case SDL_QUIT:
        quit();
        break;
              
      case SDL_VIDEORESIZE:
        Renderer::instance()->resize(event.resize.w, event.resize.h);
        MenuManager::recalc_pos();
        break;
            
      case SDL_KEYDOWN:
        if (event.key.keysym.sym == SDLK_F10)
        {
          g_config->show_fps = !g_config->show_fps;
        }
        if (event.key.keysym.sym == SDLK_F11) 
        {
          g_config->use_fullscreen = !g_config->use_fullscreen;
          Renderer::instance()->apply_config();
          MenuManager::recalc_pos();
        }
        else if (event.key.keysym.sym == SDLK_PRINT ||
                 event.key.keysym.sym == SDLK_F12)
        {
          take_screenshot();
        }
        else if (event.key.keysym.sym == SDLK_F1 &&
                 (keystate[SDLK_LCTRL] || keystate[SDLK_RCTRL]) &&
                 keystate[SDLK_c])
        {
          Console::instance->toggle();
          g_config->console_enabled = true;
          g_config->save();
        }
        break;
    }
  }
}

void ScreenManager::handle_screen_switch

(

)

[private]

Definition at line 243 of file screen_manager.cpp.

References current_screen, has_no_pending_fadeout(), next_screen, nextpop, nextpush, running, screen_fade, screen_stack, Screen::setup(), speed, waiting_threads, and scripting::ThreadQueue::wakeup().

Referenced by run().

{
  while( (next_screen.get() != NULL || nextpop) &&
         has_no_pending_fadeout()) {
    if(current_screen.get() != NULL) {
      current_screen->leave();
    }

    if(nextpop) {
      if(screen_stack.empty()) {
        running = false;
        break;
      }
      next_screen.reset(screen_stack.back());
      screen_stack.pop_back();
    }
    if(nextpush && current_screen.get() != NULL) {
      screen_stack.push_back(current_screen.release());
    }

    nextpush = false;
    nextpop = false;
    speed = 1.0;
    Screen* next_screen_ptr = next_screen.release();
    next_screen.reset(0);
    if(next_screen_ptr)
      next_screen_ptr->setup();
    current_screen.reset(next_screen_ptr);
    screen_fade.reset(NULL);

    waiting_threads.wakeup();
  }
}

---

Member Data Documentation

scripting::ThreadQueue ScreenManager::waiting_threads

threads that wait for a screenswitch

Definition at line 56 of file screen_manager.hpp.

Referenced by handle_screen_switch(), and scripting::wait_for_screenswitch().

bool ScreenManager::running [private]

Definition at line 66 of file screen_manager.hpp.

Referenced by handle_screen_switch(), and run().

float ScreenManager::speed [private]

Definition at line 67 of file screen_manager.hpp.

Referenced by get_speed(), handle_screen_switch(), push_screen(), and run().

bool ScreenManager::nextpop [private]

Definition at line 68 of file screen_manager.hpp.

Referenced by exit_screen(), handle_screen_switch(), and push_screen().

bool ScreenManager::nextpush [private]

Definition at line 69 of file screen_manager.hpp.

Referenced by exit_screen(), handle_screen_switch(), and push_screen().

float ScreenManager::fps [private]

measured fps

Definition at line 71 of file screen_manager.hpp.

Referenced by draw().

std::auto_ptr<Screen> ScreenManager::next_screen [private]

Definition at line 72 of file screen_manager.hpp.

Referenced by exit_screen(), handle_screen_switch(), and push_screen().

std::auto_ptr<Screen> ScreenManager::current_screen [private]

Definition at line 73 of file screen_manager.hpp.

Referenced by draw(), handle_screen_switch(), run(), and update_gamelogic().

std::auto_ptr<Console> ScreenManager::console [private]

Definition at line 74 of file screen_manager.hpp.

std::auto_ptr<ScreenFade> ScreenManager::screen_fade [private]

Definition at line 75 of file screen_manager.hpp.

Referenced by draw(), exit_screen(), handle_screen_switch(), has_no_pending_fadeout(), push_screen(), quit(), set_screen_fade(), and update_gamelogic().

std::vector<Screen*> ScreenManager::screen_stack [private]

Definition at line 76 of file screen_manager.hpp.

Referenced by handle_screen_switch(), quit(), and ~ScreenManager().

bool ScreenManager::screenshot_requested [private]

true if a screenshot should be taken after the next frame has been rendered

Definition at line 77 of file screen_manager.hpp.

Referenced by draw(), and take_screenshot().

---

The documentation for this class was generated from the following files:

• src/supertux/screen_manager.hpp
• src/supertux/screen_manager.cpp

---