src/video/sdl_v.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD 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, version 2.
   4  * OpenTTD 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.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file sdl_v.cpp Implementation of the SDL video driver. */
   9
  10 #ifdef WITH_SDL
  11
  12 #include "../stdafx.h"
  13 #include "../openttd.h"
  14 #include "../error_func.h"
  15 #include "../gfx_func.h"
  16 #include "../blitter/factory.hpp"
  17 #include "../thread.h"
  18 #include "../progress.h"
  19 #include "../core/random_func.hpp"
  20 #include "../core/math_func.hpp"
  21 #include "../fileio_func.h"
  22 #include "../framerate_type.h"
  23 #include "../window_func.h"
  24 #include "sdl_v.h"
  25 #include <SDL.h>
  26
  27 #include "../safeguards.h"
  28
  29 static FVideoDriver_SDL iFVideoDriver_SDL;
  30
  31 static SDL_Surface *_sdl_surface;
  32 static SDL_Surface *_sdl_realscreen;
  33 static bool _all_modes;
  34
  35 static Palette _local_palette;
  36
  37 #define MAX_DIRTY_RECTS 100
  38 static SDL_Rect _dirty_rects[MAX_DIRTY_RECTS];
  39 static int _num_dirty_rects;
  40 static int _use_hwpalette;
  41 static int _requested_hwpalette; /* Did we request a HWPALETTE for the current video mode? */
  42
  43 void VideoDriver_SDL::MakeDirty(int left, int top, int width, int height)
  44 {
  45         if (_num_dirty_rects < MAX_DIRTY_RECTS) {
  46                 _dirty_rects[_num_dirty_rects].x = left;
  47                 _dirty_rects[_num_dirty_rects].y = top;
  48                 _dirty_rects[_num_dirty_rects].w = width;
  49                 _dirty_rects[_num_dirty_rects].h = height;
  50         }
  51         _num_dirty_rects++;
  52 }
  53
  54 static void UpdatePalette(bool init = false)
  55 {
  56         SDL_Color pal[256];
  57
  58         for (int i = 0; i != _local_palette.count_dirty; i++) {
  59                 pal[i].r = _local_palette.palette[_local_palette.first_dirty + i].r;
  60                 pal[i].g = _local_palette.palette[_local_palette.first_dirty + i].g;
  61                 pal[i].b = _local_palette.palette[_local_palette.first_dirty + i].b;
  62                 pal[i].unused = 0;
  63         }
  64
  65         SDL_SetColors(_sdl_surface, pal, _local_palette.first_dirty, _local_palette.count_dirty);
  66
  67         if (_sdl_surface != _sdl_realscreen && init) {
  68                 /* When using a shadow surface, also set our palette on the real screen. This lets SDL
  69                  * allocate as many colors (or approximations) as
  70                  * possible, instead of using only the default SDL
  71                  * palette. This allows us to get more colors exactly
  72                  * right and might allow using better approximations for
  73                  * other colors.
  74                  *
  75                  * Note that colors allocations are tried in-order, so
  76                  * this favors colors further up into the palette. Also
  77                  * note that if two colors from the same animation
  78                  * sequence are approximated using the same color, that
  79                  * animation will stop working.
  80                  *
  81                  * Since changing the system palette causes the colours
  82                  * to change right away, and allocations might
  83                  * drastically change, we can't use this for animation,
  84                  * since that could cause weird coloring between the
  85                  * palette change and the blitting below, so we only set
  86                  * the real palette during initialisation.
  87                  */
  88                 SDL_SetColors(_sdl_realscreen, pal, _local_palette.first_dirty, _local_palette.count_dirty);
  89         }
  90
  91         if (_sdl_surface != _sdl_realscreen && !init) {
  92                 /* We're not using real hardware palette, but are letting SDL
  93                  * approximate the palette during shadow -> screen copy. To
  94                  * change the palette, we need to recopy the entire screen.
  95                  *
  96                  * Note that this operation can slow down the rendering
  97                  * considerably, especially since changing the shadow
  98                  * palette will need the next blit to re-detect the
  99                  * best mapping of shadow palette colors to real palette
 100                  * colors from scratch.
 101                  */
 102                 SDL_BlitSurface(_sdl_surface, nullptr, _sdl_realscreen, nullptr);
 103                 SDL_UpdateRect(_sdl_realscreen, 0, 0, 0, 0);
 104         }
 105 }
 106
 107 static void InitPalette()
 108 {
 109         CopyPalette(_local_palette, true);
 110         UpdatePalette(true);
 111 }
 112
 113 void VideoDriver_SDL::CheckPaletteAnim()
 114 {
 115         if (!CopyPalette(_local_palette)) return;
 116
 117         Blitter *blitter = BlitterFactory::GetCurrentBlitter();
 118
 119         switch (blitter->UsePaletteAnimation()) {
 120                 case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:
 121                         UpdatePalette();
 122                         break;
 123
 124                 case Blitter::PALETTE_ANIMATION_BLITTER:
 125                         blitter->PaletteAnimate(_local_palette);
 126                         break;
 127
 128                 case Blitter::PALETTE_ANIMATION_NONE:
 129                         break;
 130
 131                 default:
 132                         NOT_REACHED();
 133         }
 134 }
 135
 136 void VideoDriver_SDL::Paint()
 137 {
 138         PerformanceMeasurer framerate(PFE_VIDEO);
 139
 140         int n = _num_dirty_rects;
 141         if (n == 0) return;
 142
 143         _num_dirty_rects = 0;
 144
 145         if (n > MAX_DIRTY_RECTS) {
 146                 if (_sdl_surface != _sdl_realscreen) {
 147                         SDL_BlitSurface(_sdl_surface, nullptr, _sdl_realscreen, nullptr);
 148                 }
 149
 150                 SDL_UpdateRect(_sdl_realscreen, 0, 0, 0, 0);
 151         } else {
 152                 if (_sdl_surface != _sdl_realscreen) {
 153                         for (int i = 0; i < n; i++) {
 154                                 SDL_BlitSurface(_sdl_surface, &_dirty_rects[i], _sdl_realscreen, &_dirty_rects[i]);
 155                         }
 156                 }
 157
 158                 SDL_UpdateRects(_sdl_realscreen, n, _dirty_rects);
 159         }
 160 }
 161
 162 static const Dimension _default_resolutions[] = {
 163         { 640,  480},
 164         { 800,  600},
 165         {1024,  768},
 166         {1152,  864},
 167         {1280,  800},
 168         {1280,  960},
 169         {1280, 1024},
 170         {1400, 1050},
 171         {1600, 1200},
 172         {1680, 1050},
 173         {1920, 1200}
 174 };
 175
 176 static void GetVideoModes()
 177 {
 178         SDL_Rect **modes = SDL_ListModes(nullptr, SDL_SWSURFACE | SDL_FULLSCREEN);
 179         if (modes == nullptr) UserError("sdl: no modes available");
 180
 181         _resolutions.clear();
 182
 183         _all_modes = (SDL_ListModes(nullptr, SDL_SWSURFACE | (_fullscreen ? SDL_FULLSCREEN : 0)) == (void*)-1);
 184         if (modes == (void*)-1) {
 185                 for (const auto &default_resolution : _default_resolutions) {
 186                         if (SDL_VideoModeOK(default_resolution.width, default_resolution.height, 8, SDL_FULLSCREEN) != 0) {
 187                                 _resolutions.push_back(default_resolution);
 188                         }
 189                 }
 190         } else {
 191                 for (int i = 0; modes[i]; i++) {
 192                         uint w = modes[i]->w;
 193                         uint h = modes[i]->h;
 194                         if (w < 640 || h < 480) continue; // reject too small resolutions
 195                         if (std::find(_resolutions.begin(), _resolutions.end(), Dimension(w, h)) != _resolutions.end()) continue;
 196                         _resolutions.emplace_back(w, h);
 197                 }
 198                 if (_resolutions.empty()) UserError("No usable screen resolutions found!\n");
 199                 SortResolutions();
 200         }
 201 }
 202
 203 static void GetAvailableVideoMode(uint *w, uint *h)
 204 {
 205         /* All modes available? */
 206         if (_all_modes || _resolutions.empty()) return;
 207
 208         /* Is the wanted mode among the available modes? */
 209         if (std::find(_resolutions.begin(), _resolutions.end(), Dimension(*w, *h)) != _resolutions.end()) return;
 210
 211         /* Use the closest possible resolution */
 212         uint best = 0;
 213         uint delta = Delta(_resolutions[0].width, *w) * Delta(_resolutions[0].height, *h);
 214         for (uint i = 1; i != _resolutions.size(); ++i) {
 215                 uint newdelta = Delta(_resolutions[i].width, *w) * Delta(_resolutions[i].height, *h);
 216                 if (newdelta < delta) {
 217                         best = i;
 218                         delta = newdelta;
 219                 }
 220         }
 221         *w = _resolutions[best].width;
 222         *h = _resolutions[best].height;
 223 }
 224
 225 bool VideoDriver_SDL::CreateMainSurface(uint w, uint h)
 226 {
 227         SDL_Surface *newscreen, *icon;
 228         int bpp = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
 229         bool want_hwpalette;
 230
 231         GetAvailableVideoMode(&w, &h);
 232
 233         Debug(driver, 1, "SDL: using mode {}x{}x{}", w, h, bpp);
 234
 235         if (bpp == 0) UserError("Can't use a blitter that blits 0 bpp for normal visuals");
 236
 237         std::string icon_path = FioFindFullPath(BASESET_DIR, "openttd.32.bmp");
 238         if (!icon_path.empty()) {
 239                 /* Give the application an icon */
 240                 icon = SDL_LoadBMP(icon_path.c_str());
 241                 if (icon != nullptr) {
 242                         /* Get the colourkey, which will be magenta */
 243                         uint32_t rgbmap = SDL_MapRGB(icon->format, 255, 0, 255);
 244
 245                         SDL_SetColorKey(icon, SDL_SRCCOLORKEY, rgbmap);
 246                         SDL_WM_SetIcon(icon, nullptr);
 247                         SDL_FreeSurface(icon);
 248                 }
 249         }
 250
 251         if (_use_hwpalette == 2) {
 252                 /* Default is to autodetect when to use SDL_HWPALETTE.
 253                  * In this case, SDL_HWPALETTE is only used for 8bpp
 254                  * blitters in fullscreen.
 255                  *
 256                  * When using an 8bpp blitter on a 8bpp system in
 257                  * windowed mode with SDL_HWPALETTE, OpenTTD will claim
 258                  * the system palette, making all other applications
 259                  * get the wrong colours. In this case, we're better of
 260                  * trying to approximate the colors we need using system
 261                  * colors, using a shadow surface (see below).
 262                  *
 263                  * On a 32bpp system, SDL_HWPALETTE is ignored, so it
 264                  * doesn't matter what we do.
 265                  *
 266                  * When using a 32bpp blitter on a 8bpp system, setting
 267                  * SDL_HWPALETTE messes up rendering (at least on X11),
 268                  * so we don't do that. In this case, SDL takes care of
 269                  * color approximation using its own shadow surface
 270                  * (which we can't force in 8bpp on 8bpp mode,
 271                  * unfortunately).
 272                  */
 273                 want_hwpalette = bpp == 8 && _fullscreen && _support8bpp == S8BPP_HARDWARE;
 274         } else {
 275                 /* User specified a value manually */
 276                 want_hwpalette = _use_hwpalette;
 277         }
 278
 279         if (want_hwpalette) Debug(driver, 1, "SDL: requesting hardware palette");
 280
 281         /* Free any previously allocated shadow surface */
 282         if (_sdl_surface != nullptr && _sdl_surface != _sdl_realscreen) SDL_FreeSurface(_sdl_surface);
 283
 284         if (_sdl_realscreen != nullptr) {
 285                 if (_requested_hwpalette != want_hwpalette) {
 286                         /* SDL (at least the X11 driver), reuses the
 287                          * same window and palette settings when the bpp
 288                          * (and a few flags) are the same. Since we need
 289                          * to hwpalette value to change (in particular
 290                          * when switching between fullscreen and
 291                          * windowed), we restart the entire video
 292                          * subsystem to force creating a new window.
 293                          */
 294                         Debug(driver, 0, "SDL: Restarting SDL video subsystem, to force hwpalette change");
 295                         SDL_QuitSubSystem(SDL_INIT_VIDEO);
 296                         SDL_InitSubSystem(SDL_INIT_VIDEO);
 297                         ClaimMousePointer();
 298                         SetupKeyboard();
 299                 }
 300         }
 301         /* Remember if we wanted a hwpalette. We can't reliably query
 302          * SDL for the SDL_HWPALETTE flag, since it might get set even
 303          * though we didn't ask for it (when SDL creates a shadow
 304          * surface, for example). */
 305         _requested_hwpalette = want_hwpalette;
 306
 307         /* DO NOT CHANGE TO HWSURFACE, IT DOES NOT WORK */
 308         newscreen = SDL_SetVideoMode(w, h, bpp, SDL_SWSURFACE | (want_hwpalette ? SDL_HWPALETTE : 0) | (_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE));
 309         if (newscreen == nullptr) {
 310                 Debug(driver, 0, "SDL: Couldn't allocate a window to draw on");
 311                 return false;
 312         }
 313         _sdl_realscreen = newscreen;
 314
 315         if (bpp == 8 && (_sdl_realscreen->flags & SDL_HWPALETTE) != SDL_HWPALETTE) {
 316                 /* Using an 8bpp blitter, if we didn't get a hardware
 317                  * palette (most likely because we didn't request one,
 318                  * see above), we'll have to set up a shadow surface to
 319                  * render on.
 320                  *
 321                  * Our palette will be applied to this shadow surface,
 322                  * while the real screen surface will use the shared
 323                  * system palette (which will partly contain our colors,
 324                  * but most likely will not have enough free color cells
 325                  * for all of our colors). SDL can use these two
 326                  * palettes at blit time to approximate colors used in
 327                  * the shadow surface using system colors automatically.
 328                  *
 329                  * Note that when using an 8bpp blitter on a 32bpp
 330                  * system, SDL will create an internal shadow surface.
 331                  * This shadow surface will have SDL_HWPALLETE set, so
 332                  * we won't create a second shadow surface in this case.
 333                  */
 334                 Debug(driver, 1, "SDL: using shadow surface");
 335                 newscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, bpp, 0, 0, 0, 0);
 336                 if (newscreen == nullptr) {
 337                         Debug(driver, 0, "SDL: Couldn't allocate a shadow surface to draw on");
 338                         return false;
 339                 }
 340         }
 341
 342         /* Delay drawing for this cycle; the next cycle will redraw the whole screen */
 343         _num_dirty_rects = 0;
 344
 345         _screen.width = newscreen->w;
 346         _screen.height = newscreen->h;
 347         _screen.pitch = newscreen->pitch / (bpp / 8);
 348         _screen.dst_ptr = newscreen->pixels;
 349         _sdl_surface = newscreen;
 350
 351         /* When in full screen, we will always have the mouse cursor
 352          * within the window, even though SDL does not give us the
 353          * appropriate event to know this. */
 354         if (_fullscreen) _cursor.in_window = true;
 355
 356         Blitter *blitter = BlitterFactory::GetCurrentBlitter();
 357         blitter->PostResize();
 358
 359         InitPalette();
 360
 361         std::string caption = VideoDriver::GetCaption();
 362         SDL_WM_SetCaption(caption.c_str(), caption.c_str());
 363
 364         GameSizeChanged();
 365
 366         return true;
 367 }
 368
 369 bool VideoDriver_SDL::ClaimMousePointer()
 370 {
 371         SDL_ShowCursor(0);
 372         return true;
 373 }
 374
 375 struct SDLVkMapping {
 376         const uint16_t vk_from;
 377         const uint8_t vk_count;
 378         const uint8_t map_to;
 379
 380         constexpr SDLVkMapping(SDLKey vk_first, SDLKey vk_last, uint8_t map_first, [[maybe_unused]] uint8_t map_last)
 381                 : vk_from(vk_first), vk_count(vk_last - vk_first + 1), map_to(map_first)
 382         {
 383                 assert((vk_last - vk_first) == (map_last - map_first));
 384         }
 385 };
 386
 387 #define AS(x, z) {x, x, z, z}
 388 #define AM(x, y, z, w) {x, y, z, w}
 389
 390 static constexpr SDLVkMapping _vk_mapping[] = {
 391         /* Pageup stuff + up/down */
 392         AM(SDLK_PAGEUP, SDLK_PAGEDOWN, WKC_PAGEUP, WKC_PAGEDOWN),
 393         AS(SDLK_UP,     WKC_UP),
 394         AS(SDLK_DOWN,   WKC_DOWN),
 395         AS(SDLK_LEFT,   WKC_LEFT),
 396         AS(SDLK_RIGHT,  WKC_RIGHT),
 397
 398         AS(SDLK_HOME,   WKC_HOME),
 399         AS(SDLK_END,    WKC_END),
 400
 401         AS(SDLK_INSERT, WKC_INSERT),
 402         AS(SDLK_DELETE, WKC_DELETE),
 403
 404         /* Map letters & digits */
 405         AM(SDLK_a, SDLK_z, 'A', 'Z'),
 406         AM(SDLK_0, SDLK_9, '0', '9'),
 407
 408         AS(SDLK_ESCAPE,    WKC_ESC),
 409         AS(SDLK_PAUSE,     WKC_PAUSE),
 410         AS(SDLK_BACKSPACE, WKC_BACKSPACE),
 411
 412         AS(SDLK_SPACE,     WKC_SPACE),
 413         AS(SDLK_RETURN,    WKC_RETURN),
 414         AS(SDLK_TAB,       WKC_TAB),
 415
 416         /* Function keys */
 417         AM(SDLK_F1, SDLK_F12, WKC_F1, WKC_F12),
 418
 419         /* Numeric part. */
 420         AM(SDLK_KP0, SDLK_KP9, '0', '9'),
 421         AS(SDLK_KP_DIVIDE,   WKC_NUM_DIV),
 422         AS(SDLK_KP_MULTIPLY, WKC_NUM_MUL),
 423         AS(SDLK_KP_MINUS,    WKC_NUM_MINUS),
 424         AS(SDLK_KP_PLUS,     WKC_NUM_PLUS),
 425         AS(SDLK_KP_ENTER,    WKC_NUM_ENTER),
 426         AS(SDLK_KP_PERIOD,   WKC_NUM_DECIMAL),
 427
 428         /* Other non-letter keys */
 429         AS(SDLK_SLASH,        WKC_SLASH),
 430         AS(SDLK_SEMICOLON,    WKC_SEMICOLON),
 431         AS(SDLK_EQUALS,       WKC_EQUALS),
 432         AS(SDLK_LEFTBRACKET,  WKC_L_BRACKET),
 433         AS(SDLK_BACKSLASH,    WKC_BACKSLASH),
 434         AS(SDLK_RIGHTBRACKET, WKC_R_BRACKET),
 435
 436         AS(SDLK_QUOTE,   WKC_SINGLEQUOTE),
 437         AS(SDLK_COMMA,   WKC_COMMA),
 438         AS(SDLK_MINUS,   WKC_MINUS),
 439         AS(SDLK_PERIOD,  WKC_PERIOD)
 440 };
 441
 442 static uint ConvertSdlKeyIntoMy(SDL_keysym *sym, char32_t *character)
 443 {
 444         uint key = 0;
 445
 446         for (const auto &map : _vk_mapping) {
 447                 if (IsInsideBS(sym->sym, map.vk_from, map.vk_count)) {
 448                         key = sym->sym - map.vk_from + map.map_to;
 449                         break;
 450                 }
 451         }
 452
 453         /* check scancode for BACKQUOTE key, because we want the key left of "1", not anything else (on non-US keyboards) */
 454 #if defined(_WIN32)
 455         if (sym->scancode == 41) key = WKC_BACKQUOTE;
 456 #elif defined(__APPLE__)
 457         if (sym->scancode == 10) key = WKC_BACKQUOTE;
 458 #elif defined(__SVR4) && defined(__sun)
 459         if (sym->scancode == 60) key = WKC_BACKQUOTE;
 460         if (sym->scancode == 49) key = WKC_BACKSPACE;
 461 #elif defined(__sgi__)
 462         if (sym->scancode == 22) key = WKC_BACKQUOTE;
 463 #else
 464         if (sym->scancode == 49) key = WKC_BACKQUOTE;
 465 #endif
 466
 467         /* META are the command keys on mac */
 468         if (sym->mod & KMOD_META)  key |= WKC_META;
 469         if (sym->mod & KMOD_SHIFT) key |= WKC_SHIFT;
 470         if (sym->mod & KMOD_CTRL)  key |= WKC_CTRL;
 471         if (sym->mod & KMOD_ALT)   key |= WKC_ALT;
 472
 473         *character = sym->unicode;
 474         return key;
 475 }
 476
 477 bool VideoDriver_SDL::PollEvent()
 478 {
 479         SDL_Event ev;
 480
 481         if (!SDL_PollEvent(&ev)) return false;
 482
 483         switch (ev.type) {
 484                 case SDL_MOUSEMOTION: {
 485                         int32_t x = ev.motion.x;
 486                         int32_t y = ev.motion.y;
 487
 488                         if (_cursor.fix_at) {
 489                                 /* Get all queued mouse events now in case we have to warp the cursor. In the
 490                                  * end, we only care about the current mouse position and not bygone events. */
 491                                 while (SDL_PeepEvents(&ev, 1, SDL_GETEVENT, SDL_MOUSEMOTION)) {
 492                                         x = ev.motion.x;
 493                                         y = ev.motion.y;
 494                                 }
 495                         }
 496
 497                         if (_cursor.UpdateCursorPosition(x, y)) {
 498                                 SDL_WarpMouse(_cursor.pos.x, _cursor.pos.y);
 499                         }
 500                         HandleMouseEvents();
 501                         break;
 502                 }
 503
 504                 case SDL_MOUSEBUTTONDOWN:
 505                         if (_rightclick_emulate && SDL_GetModState() & KMOD_CTRL) {
 506                                 ev.button.button = SDL_BUTTON_RIGHT;
 507                         }
 508
 509                         switch (ev.button.button) {
 510                                 case SDL_BUTTON_LEFT:
 511                                         _left_button_down = true;
 512                                         break;
 513
 514                                 case SDL_BUTTON_RIGHT:
 515                                         _right_button_down = true;
 516                                         _right_button_clicked = true;
 517                                         break;
 518
 519                                 case SDL_BUTTON_WHEELUP:   _cursor.wheel--; break;
 520                                 case SDL_BUTTON_WHEELDOWN: _cursor.wheel++; break;
 521
 522                                 default: break;
 523                         }
 524                         HandleMouseEvents();
 525                         break;
 526
 527                 case SDL_MOUSEBUTTONUP:
 528                         if (_rightclick_emulate) {
 529                                 _right_button_down = false;
 530                                 _left_button_down = false;
 531                                 _left_button_clicked = false;
 532                         } else if (ev.button.button == SDL_BUTTON_LEFT) {
 533                                 _left_button_down = false;
 534                                 _left_button_clicked = false;
 535                         } else if (ev.button.button == SDL_BUTTON_RIGHT) {
 536                                 _right_button_down = false;
 537                         }
 538                         HandleMouseEvents();
 539                         break;
 540
 541                 case SDL_ACTIVEEVENT:
 542                         if (!(ev.active.state & SDL_APPMOUSEFOCUS)) break;
 543
 544                         if (ev.active.gain) { // mouse entered the window, enable cursor
 545                                 _cursor.in_window = true;
 546                         } else {
 547                                 UndrawMouseCursor(); // mouse left the window, undraw cursor
 548                                 _cursor.in_window = false;
 549                         }
 550                         break;
 551
 552                 case SDL_QUIT:
 553                         HandleExitGameRequest();
 554                         break;
 555
 556                 case SDL_KEYDOWN: // Toggle full-screen on ALT + ENTER/F
 557                         if ((ev.key.keysym.mod & (KMOD_ALT | KMOD_META)) &&
 558                                         (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_f)) {
 559                                 ToggleFullScreen(!_fullscreen);
 560                         } else {
 561                                 char32_t character;
 562                                 uint keycode = ConvertSdlKeyIntoMy(&ev.key.keysym, &character);
 563                                 HandleKeypress(keycode, character);
 564                         }
 565                         break;
 566
 567                 case SDL_VIDEORESIZE: {
 568                         int w = std::max(ev.resize.w, 64);
 569                         int h = std::max(ev.resize.h, 64);
 570                         CreateMainSurface(w, h);
 571                         break;
 572                 }
 573                 case SDL_VIDEOEXPOSE: {
 574                         /* Force a redraw of the entire screen. Note
 575                          * that SDL 1.2 seems to do this automatically
 576                          * in most cases, but 1.3 / 2.0 does not. */
 577                         _num_dirty_rects = MAX_DIRTY_RECTS + 1;
 578                         break;
 579                 }
 580         }
 581
 582         return true;
 583 }
 584
 585 std::optional<std::string_view> VideoDriver_SDL::Start(const StringList &param)
 586 {
 587         char buf[30];
 588         _use_hwpalette = GetDriverParamInt(param, "hw_palette", 2);
 589
 590         /* Just on the offchance the audio subsystem started before the video system,
 591          * check whether any part of SDL has been initialised before getting here.
 592          * Slightly duplicated with sound/sdl_s.cpp */
 593         int ret_code = 0;
 594         if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
 595                 ret_code = SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE);
 596         } else if (SDL_WasInit(SDL_INIT_VIDEO) == 0) {
 597                 ret_code = SDL_InitSubSystem(SDL_INIT_VIDEO);
 598         }
 599         if (ret_code < 0) return SDL_GetError();
 600
 601         this->UpdateAutoResolution();
 602
 603         GetVideoModes();
 604         if (!CreateMainSurface(_cur_resolution.width, _cur_resolution.height)) {
 605                 return SDL_GetError();
 606         }
 607
 608         SDL_VideoDriverName(buf, sizeof buf);
 609         Debug(driver, 1, "SDL: using driver '{}'", buf);
 610
 611         MarkWholeScreenDirty();
 612         SetupKeyboard();
 613
 614         this->is_game_threaded = !GetDriverParamBool(param, "no_threads") && !GetDriverParamBool(param, "no_thread");
 615
 616         return std::nullopt;
 617 }
 618
 619 void VideoDriver_SDL::SetupKeyboard()
 620 {
 621         SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
 622         SDL_EnableUNICODE(1);
 623 }
 624
 625 void VideoDriver_SDL::Stop()
 626 {
 627         SDL_QuitSubSystem(SDL_INIT_VIDEO);
 628         if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
 629                 SDL_Quit(); // If there's nothing left, quit SDL
 630         }
 631 }
 632
 633 void VideoDriver_SDL::InputLoop()
 634 {
 635         uint32_t mod = SDL_GetModState();
 636         int numkeys;
 637         Uint8 *keys = SDL_GetKeyState(&numkeys);
 638
 639         bool old_ctrl_pressed = _ctrl_pressed;
 640
 641         _ctrl_pressed  = !!(mod & KMOD_CTRL);
 642         _shift_pressed = !!(mod & KMOD_SHIFT);
 643
 644         /* Speedup when pressing tab, except when using ALT+TAB
 645          * to switch to another application. */
 646         this->fast_forward_key_pressed = keys[SDLK_TAB] && (mod & KMOD_ALT) == 0;
 647
 648         /* Determine which directional keys are down. */
 649         _dirkeys =
 650                 (keys[SDLK_LEFT]  ? 1 : 0) |
 651                 (keys[SDLK_UP]    ? 2 : 0) |
 652                 (keys[SDLK_RIGHT] ? 4 : 0) |
 653                 (keys[SDLK_DOWN]  ? 8 : 0);
 654
 655         if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
 656 }
 657
 658 void VideoDriver_SDL::MainLoop()
 659 {
 660         this->StartGameThread();
 661
 662         for (;;) {
 663                 if (_exit_game) break;
 664
 665                 this->Tick();
 666                 this->SleepTillNextTick();
 667         }
 668
 669         this->StopGameThread();
 670 }
 671
 672 bool VideoDriver_SDL::ChangeResolution(int w, int h)
 673 {
 674         return CreateMainSurface(w, h);
 675 }
 676
 677 bool VideoDriver_SDL::ToggleFullscreen(bool fullscreen)
 678 {
 679         _fullscreen = fullscreen;
 680         GetVideoModes(); // get the list of available video modes
 681         bool ret = !_resolutions.empty() && CreateMainSurface(_cur_resolution.width, _cur_resolution.height);
 682
 683         if (!ret) {
 684                 /* switching resolution failed, put back full_screen to original status */
 685                 _fullscreen ^= true;
 686         }
 687
 688         InvalidateWindowClassesData(WC_GAME_OPTIONS, 3);
 689         return ret;
 690 }
 691
 692 bool VideoDriver_SDL::AfterBlitterChange()
 693 {
 694         return CreateMainSurface(_screen.width, _screen.height);
 695 }
 696
 697 #endif /* WITH_SDL */