OpenTTD Source  20241108-master-g80f628063a
sdl_v.cpp
Go to the documentation of this file.
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 
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++) {
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 {
110  UpdatePalette(true);
111 }
112 
114 {
115  if (!CopyPalette(_local_palette)) return;
116 
118 
119  switch (blitter->UsePaletteAnimation()) {
121  UpdatePalette();
122  break;
123 
125  blitter->PaletteAnimate(_local_palette);
126  break;
127 
129  break;
130 
131  default:
132  NOT_REACHED();
133  }
134 }
135 
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;
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 
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 
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  }
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  }
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  }
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 
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 
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 
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 
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 
673 {
674  return CreateMainSurface(w, h);
675 }
676 
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 
689  return ret;
690 }
691 
693 {
694  return CreateMainSurface(_screen.width, _screen.height);
695 }
696 
697 #endif /* WITH_SDL */
#define AS(ap_name, size_x, size_y, min_year, max_year, catchment, noise, maint_cost, ttdpatch_type, class_id, name, preview)
AirportSpec definition for airports with at least one depot.
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition: factory.hpp:138
How all blitters should look like.
Definition: base.hpp:29
virtual uint8_t GetScreenDepth()=0
Get the screen depth this blitter works for.
virtual Blitter::PaletteAnimation UsePaletteAnimation()=0
Check if the blitter uses palette animation at all.
@ PALETTE_ANIMATION_NONE
No palette animation.
Definition: base.hpp:51
@ PALETTE_ANIMATION_VIDEO_BACKEND
Palette animation should be done by video backend (8bpp only!)
Definition: base.hpp:52
@ PALETTE_ANIMATION_BLITTER
The blitter takes care of the palette animation.
Definition: base.hpp:53
virtual void PaletteAnimate(const Palette &palette)=0
Called when the 8bpp palette is changed; you should redraw all pixels on the screen that are equal to...
virtual void PostResize()
Post resize event.
Definition: base.hpp:205
Factory for the SDL video driver.
Definition: sdl_v.h:48
RAII class for measuring simple elements of performance.
void MainLoop() override
Perform the actual drawing.
Definition: sdl_v.cpp:658
void CheckPaletteAnim() override
Process any pending palette animation.
Definition: sdl_v.cpp:113
void Paint() override
Paint the window.
Definition: sdl_v.cpp:136
void Stop() override
Stop this driver.
Definition: sdl_v.cpp:625
bool AfterBlitterChange() override
Callback invoked after the blitter was changed.
Definition: sdl_v.cpp:692
std::optional< std::string_view > Start(const StringList &param) override
Start this driver.
Definition: sdl_v.cpp:585
bool ChangeResolution(int w, int h) override
Change the resolution of the window.
Definition: sdl_v.cpp:672
void InputLoop() override
Handle input logic, is CTRL pressed, should we fast-forward, etc.
Definition: sdl_v.cpp:633
bool PollEvent() override
Process a single system event.
Definition: sdl_v.cpp:477
void MakeDirty(int left, int top, int width, int height) override
Mark a particular area dirty.
Definition: sdl_v.cpp:43
bool ToggleFullscreen(bool fullscreen) override
Change the full screen setting.
Definition: sdl_v.cpp:677
bool fast_forward_key_pressed
The fast-forward key is being pressed.
void Tick()
Give the video-driver a tick.
void SleepTillNextTick()
Sleep till the next tick is about to happen.
void StartGameThread()
Start the loop for game-tick.
static std::string GetCaption()
Get the caption to use for the game's title bar.
void StopGameThread()
Stop the loop for the game-tick.
void UpdateAutoResolution()
Apply resolution auto-detection and clamp to sensible defaults.
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
int GetDriverParamInt(const StringList &parm, const char *name, int def)
Get an integer parameter the list of parameters.
Definition: driver.cpp:76
std::vector< Dimension > _resolutions
List of resolutions.
Definition: driver.cpp:25
Dimension _cur_resolution
The current resolution.
Definition: driver.cpp:26
bool _rightclick_emulate
Whether right clicking is emulated.
Definition: driver.cpp:27
bool GetDriverParamBool(const StringList &parm, const char *name)
Get a boolean parameter the list of parameters.
Definition: driver.cpp:64
std::string FioFindFullPath(Subdirectory subdir, const std::string &filename)
Find a path to the filename in one of the search directories.
Definition: fileio.cpp:144
@ BASESET_DIR
Subdirectory for all base data (base sets, intro game)
Definition: fileio_type.h:123
@ PFE_VIDEO
Speed of painting drawn video buffer.
bool _shift_pressed
Is Shift pressed?
Definition: gfx.cpp:39
bool _left_button_down
Is left mouse button pressed?
Definition: gfx.cpp:41
bool _ctrl_pressed
Is Ctrl pressed?
Definition: gfx.cpp:38
uint8_t _dirkeys
1 = left, 2 = up, 4 = right, 8 = down
Definition: gfx.cpp:34
bool _left_button_clicked
Is left mouse button clicked?
Definition: gfx.cpp:42
bool _right_button_clicked
Is right mouse button clicked?
Definition: gfx.cpp:44
bool _right_button_down
Is right mouse button pressed?
Definition: gfx.cpp:43
void HandleCtrlChanged()
State of CONTROL key has changed.
Definition: window.cpp:2618
void GameSizeChanged()
Size of the application screen changed.
Definition: main_gui.cpp:589
void HandleMouseEvents()
Handle a mouse event from the video driver.
Definition: window.cpp:2877
void HandleKeypress(uint keycode, char32_t key)
Handle keyboard input.
Definition: window.cpp:2562
@ S8BPP_HARDWARE
Full 8bpp support by OS and hardware.
Definition: gfx_type.h:338
@ WKC_BACKSLASH
\ Backslash
Definition: gfx_type.h:100
@ WKC_MINUS
Definition: gfx_type.h:105
@ WKC_COMMA
, Comma
Definition: gfx_type.h:103
@ WKC_PERIOD
. Period
Definition: gfx_type.h:104
@ WKC_EQUALS
= Equals
Definition: gfx_type.h:98
@ WKC_SLASH
/ Forward slash
Definition: gfx_type.h:96
@ WKC_SINGLEQUOTE
' Single quote
Definition: gfx_type.h:102
@ WKC_R_BRACKET
] Right square bracket
Definition: gfx_type.h:101
@ WKC_L_BRACKET
[ Left square bracket
Definition: gfx_type.h:99
@ WKC_SEMICOLON
; Semicolon
Definition: gfx_type.h:97
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1529
constexpr bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
Definition: math_func.hpp:252
constexpr T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
Definition: math_func.hpp:234
bool CopyPalette(Palette &local_palette, bool force_copy)
Copy the current palette if the palette was updated.
Definition: palette.cpp:152
Base of the SDL video driver.
std::vector< std::string > StringList
Type for a list of strings.
Definition: string_type.h:60
bool UpdateCursorPosition(int x, int y)
Update cursor position on mouse movement.
Definition: gfx.cpp:1728
bool fix_at
mouse is moving, but cursor is not (used for scrolling)
Definition: gfx_type.h:128
Point pos
logical mouse position
Definition: gfx_type.h:125
bool in_window
mouse inside this window, determines drawing logic
Definition: gfx_type.h:147
int wheel
mouse wheel movement
Definition: gfx_type.h:127
Dimensions (a width and height) of a rectangle in 2D.
Information about the currently used palette.
Definition: gfx_type.h:328
int first_dirty
The first dirty element.
Definition: gfx_type.h:330
int count_dirty
The number of dirty elements.
Definition: gfx_type.h:331
Colour palette[256]
Current palette. Entry 0 has to be always fully transparent!
Definition: gfx_type.h:329
static Palette _local_palette
Current palette to use for drawing.
Definition: win32_v.cpp:50
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3228
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition: window_type.h:624