14 #include "../stdafx.h" 
   15 #include "../openttd.h" 
   16 #include "../gfx_func.h" 
   19 #include "../blitter/factory.hpp" 
   20 #include "../network/network.h" 
   21 #include "../thread/thread.h" 
   22 #include "../progress.h" 
   23 #include "../core/random_func.hpp" 
   24 #include "../core/math_func.hpp" 
   25 #include "../fileio_func.h" 
   29 #include "../safeguards.h" 
   33 static SDL_Surface *_sdl_screen;
 
   34 static SDL_Surface *_sdl_realscreen;
 
   35 static bool _all_modes;
 
   47 #define MAX_DIRTY_RECTS 100 
   48 static SDL_Rect _dirty_rects[MAX_DIRTY_RECTS];
 
   49 static int _num_dirty_rects;
 
   50 static int _use_hwpalette;
 
   51 static int _requested_hwpalette; 
 
   55   if (_num_dirty_rects < MAX_DIRTY_RECTS) {
 
   56     _dirty_rects[_num_dirty_rects].x = left;
 
   57     _dirty_rects[_num_dirty_rects].y = top;
 
   58     _dirty_rects[_num_dirty_rects].w = width;
 
   59     _dirty_rects[_num_dirty_rects].h = height;
 
   64 static void UpdatePalette(
bool init = 
false)
 
   68   for (
int i = 0; i != _local_palette.
count_dirty; i++) {
 
   77   if (_sdl_screen != _sdl_realscreen && init) {
 
  101   if (_sdl_screen != _sdl_realscreen && !init) {
 
  112     SDL_CALL SDL_BlitSurface(_sdl_screen, NULL, _sdl_realscreen, NULL);
 
  113     SDL_CALL SDL_UpdateRect(_sdl_realscreen, 0, 0, 0, 0);
 
  117 static void InitPalette()
 
  125 static void CheckPaletteAnim()
 
  149 static void DrawSurfaceToScreen()
 
  151   int n = _num_dirty_rects;
 
  154   _num_dirty_rects = 0;
 
  155   if (n > MAX_DIRTY_RECTS) {
 
  156     if (_sdl_screen != _sdl_realscreen) {
 
  157       SDL_CALL SDL_BlitSurface(_sdl_screen, NULL, _sdl_realscreen, NULL);
 
  159     SDL_CALL SDL_UpdateRect(_sdl_realscreen, 0, 0, 0, 0);
 
  161     if (_sdl_screen != _sdl_realscreen) {
 
  162       for (
int i = 0; i < n; i++) {
 
  163         SDL_CALL SDL_BlitSurface(_sdl_screen, &_dirty_rects[i], _sdl_realscreen, &_dirty_rects[i]);
 
  166     SDL_CALL SDL_UpdateRects(_sdl_realscreen, n, _dirty_rects);
 
  170 static void DrawSurfaceToScreenThread(
void *)
 
  182     DrawSurfaceToScreen();
 
  187   _draw_thread->
Exit();
 
  190 static const Dimension _default_resolutions[] = {
 
  204 static void GetVideoModes()
 
  206   SDL_Rect **modes = SDL_CALL SDL_ListModes(NULL, SDL_SWSURFACE | SDL_FULLSCREEN);
 
  207   if (modes == NULL) 
usererror(
"sdl: no modes available");
 
  209   _all_modes = (SDL_CALL SDL_ListModes(NULL, SDL_SWSURFACE | (_fullscreen ? SDL_FULLSCREEN : 0)) == (
void*)-1);
 
  210   if (modes == (
void*)-1) {
 
  212     for (uint i = 0; i < 
lengthof(_default_resolutions); i++) {
 
  213       if (SDL_CALL SDL_VideoModeOK(_default_resolutions[i].width, _default_resolutions[i].height, 8, SDL_FULLSCREEN) != 0) {
 
  221     for (
int i = 0; modes[i]; i++) {
 
  222       uint w = modes[i]->w;
 
  223       uint h = modes[i]->h;
 
  225       for (j = 0; j < n; j++) {
 
  240 static void GetAvailableVideoMode(uint *w, uint *h)
 
  255     if (newdelta < delta) {
 
  268 #define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_CALL SDL_RWFromFile(file, "rb"), 1) 
  271 bool VideoDriver_SDL::CreateMainSurface(uint w, uint h)
 
  273   SDL_Surface *newscreen, *icon;
 
  278   GetAvailableVideoMode(&w, &h);
 
  280   DEBUG(driver, 1, 
"SDL: using mode %ux%ux%d", w, h, bpp);
 
  282   if (bpp == 0) 
usererror(
"Can't use a blitter that blits 0 bpp for normal visuals");
 
  284   char icon_path[MAX_PATH];
 
  287     icon = SDL_CALL SDL_LoadBMP(icon_path);
 
  290       uint32 rgbmap = SDL_CALL SDL_MapRGB(icon->format, 255, 0, 255);
 
  292       SDL_CALL SDL_SetColorKey(icon, SDL_SRCCOLORKEY, rgbmap);
 
  293       SDL_CALL SDL_WM_SetIcon(icon, NULL);
 
  294       SDL_CALL SDL_FreeSurface(icon);
 
  298   if (_use_hwpalette == 2) {
 
  320     want_hwpalette = bpp == 8 && _fullscreen && _support8bpp == 
S8BPP_HARDWARE;
 
  323     want_hwpalette = _use_hwpalette;
 
  326   if (want_hwpalette) 
DEBUG(driver, 1, 
"SDL: requesting hardware palete");
 
  329   if (_sdl_screen != NULL && _sdl_screen != _sdl_realscreen) SDL_CALL SDL_FreeSurface(_sdl_screen);
 
  331   if (_sdl_realscreen != NULL) {
 
  332     if (_requested_hwpalette != want_hwpalette) {
 
  341       DEBUG(driver, 0, 
"SDL: Restarting SDL video subsystem, to force hwpalette change");
 
  342       SDL_CALL SDL_QuitSubSystem(SDL_INIT_VIDEO);
 
  343       SDL_CALL SDL_InitSubSystem(SDL_INIT_VIDEO);
 
  352   _requested_hwpalette = want_hwpalette;
 
  355   newscreen = SDL_CALL SDL_SetVideoMode(w, h, bpp, SDL_SWSURFACE | (want_hwpalette ? SDL_HWPALETTE : 0) | (_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE));
 
  356   if (newscreen == NULL) {
 
  357     DEBUG(driver, 0, 
"SDL: Couldn't allocate a window to draw on");
 
  360   _sdl_realscreen = newscreen;
 
  362   if (bpp == 8 && (_sdl_realscreen->flags & SDL_HWPALETTE) != SDL_HWPALETTE) {
 
  381     DEBUG(driver, 1, 
"SDL: using shadow surface");
 
  382     newscreen = SDL_CALL SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, bpp, 0, 0, 0, 0);
 
  383     if (newscreen == NULL) {
 
  384       DEBUG(driver, 0, 
"SDL: Couldn't allocate a shadow surface to draw on");
 
  390   _num_dirty_rects = 0;
 
  392   _screen.width = newscreen->w;
 
  393   _screen.height = newscreen->h;
 
  394   _screen.pitch = newscreen->pitch / (bpp / 8);
 
  395   _screen.dst_ptr = newscreen->pixels;
 
  396   _sdl_screen = newscreen;
 
  401   if (_fullscreen) _cursor.
in_window = 
true;
 
  421   seprintf(caption, 
lastof(caption), 
"OpenTTD %s", _openttd_revision);
 
  422   SDL_CALL SDL_WM_SetCaption(caption, caption);
 
  429 bool VideoDriver_SDL::ClaimMousePointer()
 
  431   SDL_CALL SDL_ShowCursor(0);
 
  436 #if SDL_VERSION_ATLEAST(1, 3, 0) 
  445 #define AS(x, z) {x, 0, z} 
  446 #define AM(x, y, z, w) {x, (byte)(y - x), z} 
  450   AM(SDLK_PAGEUP, SDLK_PAGEDOWN, WKC_PAGEUP, WKC_PAGEDOWN),
 
  452   AS(SDLK_DOWN,   WKC_DOWN),
 
  453   AS(SDLK_LEFT,   WKC_LEFT),
 
  454   AS(SDLK_RIGHT,  WKC_RIGHT),
 
  456   AS(SDLK_HOME,   WKC_HOME),
 
  457   AS(SDLK_END,    WKC_END),
 
  459   AS(SDLK_INSERT, WKC_INSERT),
 
  460   AS(SDLK_DELETE, WKC_DELETE),
 
  463   AM(SDLK_a, SDLK_z, 
'A', 
'Z'),
 
  464   AM(SDLK_0, SDLK_9, 
'0', 
'9'),
 
  466   AS(SDLK_ESCAPE,    WKC_ESC),
 
  467   AS(SDLK_PAUSE,     WKC_PAUSE),
 
  468   AS(SDLK_BACKSPACE, WKC_BACKSPACE),
 
  470   AS(SDLK_SPACE,     WKC_SPACE),
 
  471   AS(SDLK_RETURN,    WKC_RETURN),
 
  472   AS(SDLK_TAB,       WKC_TAB),
 
  475   AM(SDLK_F1, SDLK_F12, WKC_F1, WKC_F12),
 
  478   AM(SDLK_KP0, SDLK_KP9, 
'0', 
'9'),
 
  479   AS(SDLK_KP_DIVIDE,   WKC_NUM_DIV),
 
  480   AS(SDLK_KP_MULTIPLY, WKC_NUM_MUL),
 
  481   AS(SDLK_KP_MINUS,    WKC_NUM_MINUS),
 
  482   AS(SDLK_KP_PLUS,     WKC_NUM_PLUS),
 
  483   AS(SDLK_KP_ENTER,    WKC_NUM_ENTER),
 
  484   AS(SDLK_KP_PERIOD,   WKC_NUM_DECIMAL),
 
  500 static uint ConvertSdlKeyIntoMy(SDL_keysym *sym, 
WChar *character)
 
  505   for (map = _vk_mapping; map != 
endof(_vk_mapping); ++map) {
 
  506     if ((uint)(sym->sym - map->vk_from) <= map->vk_count) {
 
  507       key = sym->sym - map->vk_from + map->map_to;
 
  513 #if defined(WIN32) || defined(__OS2__) 
  514   if (sym->scancode == 41) key = WKC_BACKQUOTE;
 
  515 #elif defined(__APPLE__) 
  516   if (sym->scancode == 10) key = WKC_BACKQUOTE;
 
  517 #elif defined(__MORPHOS__) 
  518   if (sym->scancode == 0)  key = WKC_BACKQUOTE;  
 
  519 #elif defined(__BEOS__) 
  520   if (sym->scancode == 17) key = WKC_BACKQUOTE;
 
  521 #elif defined(__SVR4) && defined(__sun) 
  522   if (sym->scancode == 60) key = WKC_BACKQUOTE;
 
  523   if (sym->scancode == 49) key = WKC_BACKSPACE;
 
  524 #elif defined(__sgi__) 
  525   if (sym->scancode == 22) key = WKC_BACKQUOTE;
 
  527   if (sym->scancode == 49) key = WKC_BACKQUOTE;
 
  531   if (sym->mod & KMOD_META)  key |= WKC_META;
 
  532   if (sym->mod & KMOD_SHIFT) key |= WKC_SHIFT;
 
  533   if (sym->mod & KMOD_CTRL)  key |= WKC_CTRL;
 
  534   if (sym->mod & KMOD_ALT)   key |= WKC_ALT;
 
  536   *character = sym->unicode;
 
  540 int VideoDriver_SDL::PollEvent()
 
  544   if (!SDL_CALL SDL_PollEvent(&ev)) 
return -2;
 
  547     case SDL_MOUSEMOTION:
 
  549         SDL_CALL SDL_WarpMouse(_cursor.
pos.x, _cursor.
pos.y);
 
  554     case SDL_MOUSEBUTTONDOWN:
 
  556         ev.button.button = SDL_BUTTON_RIGHT;
 
  559       switch (ev.button.button) {
 
  560         case SDL_BUTTON_LEFT:
 
  564         case SDL_BUTTON_RIGHT:
 
  569         case SDL_BUTTON_WHEELUP:   _cursor.
wheel--; 
break;
 
  570         case SDL_BUTTON_WHEELDOWN: _cursor.
wheel++; 
break;
 
  577     case SDL_MOUSEBUTTONUP:
 
  582       } 
else if (ev.button.button == SDL_BUTTON_LEFT) {
 
  585       } 
else if (ev.button.button == SDL_BUTTON_RIGHT) {
 
  591     case SDL_ACTIVEEVENT:
 
  592       if (!(ev.active.state & SDL_APPMOUSEFOCUS)) 
break;
 
  594       if (ev.active.gain) { 
 
  603       HandleExitGameRequest();
 
  607       if ((ev.key.keysym.mod & (KMOD_ALT | KMOD_META)) &&
 
  608           (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_f)) {
 
  609         ToggleFullScreen(!_fullscreen);
 
  612         uint keycode = ConvertSdlKeyIntoMy(&ev.key.keysym, &character);
 
  617     case SDL_VIDEORESIZE: {
 
  618       int w = 
max(ev.resize.w, 64);
 
  619       int h = 
max(ev.resize.h, 64);
 
  620       CreateMainSurface(w, h);
 
  623     case SDL_VIDEOEXPOSE: {
 
  627             _num_dirty_rects = MAX_DIRTY_RECTS + 1;
 
  639   const char *s = 
SdlOpen(SDL_INIT_VIDEO);
 
  640   if (s != NULL) 
return s;
 
  644     return SDL_CALL SDL_GetError();
 
  647   SDL_CALL SDL_VideoDriverName(buf, 
sizeof buf);
 
  648   DEBUG(driver, 1, 
"SDL: using driver '%s'", buf);
 
  658 void VideoDriver_SDL::SetupKeyboard()
 
  660   SDL_CALL SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
 
  661   SDL_CALL SDL_EnableUNICODE(1);
 
  671   uint32 cur_ticks = SDL_CALL SDL_GetTicks();
 
  672   uint32 last_cur_ticks = cur_ticks;
 
  684     if (_draw_mutex == NULL) {
 
  707     uint32 prev_cur_ticks = cur_ticks; 
 
  710     while (PollEvent() == -1) {}
 
  711     if (_exit_game) 
break;
 
  713     mod = SDL_CALL SDL_GetModState();
 
  714 #if SDL_VERSION_ATLEAST(1, 3, 0) 
  715     keys = SDL_CALL SDL_GetKeyboardState(&numkeys);
 
  717     keys = SDL_CALL SDL_GetKeyState(&numkeys);
 
  724 #if SDL_VERSION_ATLEAST(1, 3, 0) 
  725     if (keys[SDL_SCANCODE_TAB] && (mod & KMOD_ALT) == 0)
 
  727     if (keys[SDLK_TAB] && (mod & KMOD_ALT) == 0)
 
  731       if (!
_networking && _game_mode != GM_MENU) _fast_forward |= 2;
 
  732     } 
else if (_fast_forward & 2) {
 
  736     cur_ticks = SDL_CALL SDL_GetTicks();
 
  737     if (cur_ticks >= next_tick || (_fast_forward && !
_pause_mode) || cur_ticks < prev_cur_ticks) {
 
  739       last_cur_ticks = cur_ticks;
 
  749 #if SDL_VERSION_ATLEAST(1, 3, 0) 
  750         (keys[SDL_SCANCODE_LEFT]  ? 1 : 0) |
 
  751         (keys[SDL_SCANCODE_UP]    ? 2 : 0) |
 
  752         (keys[SDL_SCANCODE_RIGHT] ? 4 : 0) |
 
  753         (keys[SDL_SCANCODE_DOWN]  ? 8 : 0);
 
  755         (keys[SDLK_LEFT]  ? 1 : 0) |
 
  756         (keys[SDLK_UP]    ? 2 : 0) |
 
  757         (keys[SDLK_RIGHT] ? 4 : 0) |
 
  758         (keys[SDLK_DOWN]  ? 8 : 0);
 
  764       if (_draw_mutex != NULL) _draw_mutex->
EndCritical();
 
  774       if (_draw_mutex != NULL) _draw_mutex->
EndCritical();
 
  788       DrawSurfaceToScreen();
 
  792   if (_draw_mutex != NULL) {
 
  798     _draw_thread->
Join();
 
  811   bool ret = CreateMainSurface(w, h);
 
  812   if (_draw_mutex != NULL) _draw_mutex->
EndCritical(
true);
 
  819   _fullscreen = fullscreen;
 
  828   if (_draw_mutex != NULL) _draw_mutex->
EndCritical(
true);
 
  835   bool ret = CreateMainSurface(_screen.width, _screen.height);
 
  836   if (_draw_mutex != NULL) _draw_mutex->
EndCritical(
true);