OpenTTD Source  20241121-master-g67a0fccfad
sdl2_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 #include "../stdafx.h"
11 #include "../openttd.h"
12 #include "../gfx_func.h"
13 #include "../blitter/factory.hpp"
14 #include "../thread.h"
15 #include "../progress.h"
16 #include "../core/random_func.hpp"
17 #include "../core/math_func.hpp"
18 #include "../core/mem_func.hpp"
19 #include "../core/geometry_func.hpp"
20 #include "../fileio_func.h"
21 #include "../framerate_type.h"
22 #include "../window_func.h"
23 #include "sdl2_v.h"
24 #include <SDL.h>
25 #ifdef __EMSCRIPTEN__
26 # include <emscripten.h>
27 # include <emscripten/html5.h>
28 #endif
29 
30 #include "../safeguards.h"
31 
32 void VideoDriver_SDL_Base::MakeDirty(int left, int top, int width, int height)
33 {
34  Rect r = {left, top, left + width, top + height};
35  this->dirty_rect = BoundingRect(this->dirty_rect, r);
36 }
37 
39 {
40  if (!CopyPalette(this->local_palette)) return;
41  this->MakeDirty(0, 0, _screen.width, _screen.height);
42 }
43 
44 static const Dimension default_resolutions[] = {
45  { 640, 480 },
46  { 800, 600 },
47  { 1024, 768 },
48  { 1152, 864 },
49  { 1280, 800 },
50  { 1280, 960 },
51  { 1280, 1024 },
52  { 1400, 1050 },
53  { 1600, 1200 },
54  { 1680, 1050 },
55  { 1920, 1200 }
56 };
57 
58 static void FindResolutions()
59 {
60  _resolutions.clear();
61 
62  for (int display = 0; display < SDL_GetNumVideoDisplays(); display++) {
63  for (int i = 0; i < SDL_GetNumDisplayModes(display); i++) {
64  SDL_DisplayMode mode;
65  SDL_GetDisplayMode(display, i, &mode);
66 
67  if (mode.w < 640 || mode.h < 480) continue;
68  if (std::find(_resolutions.begin(), _resolutions.end(), Dimension(mode.w, mode.h)) != _resolutions.end()) continue;
69  _resolutions.emplace_back(mode.w, mode.h);
70  }
71  }
72 
73  /* We have found no resolutions, show the default list */
74  if (_resolutions.empty()) {
75  _resolutions.assign(std::begin(default_resolutions), std::end(default_resolutions));
76  }
77 
78  SortResolutions();
79 }
80 
81 static void GetAvailableVideoMode(uint *w, uint *h)
82 {
83  /* All modes available? */
84  if (!_fullscreen || _resolutions.empty()) return;
85 
86  /* Is the wanted mode among the available modes? */
87  if (std::find(_resolutions.begin(), _resolutions.end(), Dimension(*w, *h)) != _resolutions.end()) return;
88 
89  /* Use the closest possible resolution */
90  uint best = 0;
91  uint delta = Delta(_resolutions[0].width, *w) * Delta(_resolutions[0].height, *h);
92  for (uint i = 1; i != _resolutions.size(); ++i) {
93  uint newdelta = Delta(_resolutions[i].width, *w) * Delta(_resolutions[i].height, *h);
94  if (newdelta < delta) {
95  best = i;
96  delta = newdelta;
97  }
98  }
99  *w = _resolutions[best].width;
100  *h = _resolutions[best].height;
101 }
102 
103 static uint FindStartupDisplay(uint startup_display)
104 {
105  int num_displays = SDL_GetNumVideoDisplays();
106 
107  /* If the user indicated a valid monitor, use that. */
108  if (IsInsideBS(startup_display, 0, num_displays)) return startup_display;
109 
110  /* Mouse position decides which display to use. */
111  int mx, my;
112  SDL_GetGlobalMouseState(&mx, &my);
113  for (int display = 0; display < num_displays; ++display) {
114  SDL_Rect r;
115  if (SDL_GetDisplayBounds(display, &r) == 0 && IsInsideBS(mx, r.x, r.w) && IsInsideBS(my, r.y, r.h)) {
116  Debug(driver, 1, "SDL2: Mouse is at ({}, {}), use display {} ({}, {}, {}, {})", mx, my, display, r.x, r.y, r.w, r.h);
117  return display;
118  }
119  }
120 
121  return 0;
122 }
123 
124 void VideoDriver_SDL_Base::ClientSizeChanged(int w, int h, bool force)
125 {
126  /* Allocate backing store of the new size. */
127  if (this->AllocateBackingStore(w, h, force)) {
128  CopyPalette(this->local_palette, true);
129 
131 
132  GameSizeChanged();
133  }
134 }
135 
136 bool VideoDriver_SDL_Base::CreateMainWindow(uint w, uint h, uint flags)
137 {
138  if (this->sdl_window != nullptr) return true;
139 
140  flags |= SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE;
141 
142  if (_fullscreen) {
143  flags |= SDL_WINDOW_FULLSCREEN;
144  }
145 
146  int x = SDL_WINDOWPOS_UNDEFINED, y = SDL_WINDOWPOS_UNDEFINED;
147  SDL_Rect r;
148  if (SDL_GetDisplayBounds(this->startup_display, &r) == 0) {
149  x = r.x + std::max(0, r.w - static_cast<int>(w)) / 2;
150  y = r.y + std::max(0, r.h - static_cast<int>(h)) / 4; // decent desktops have taskbars at the bottom
151  }
152 
153  std::string caption = VideoDriver::GetCaption();
154  this->sdl_window = SDL_CreateWindow(
155  caption.c_str(),
156  x, y,
157  w, h,
158  flags);
159 
160  if (this->sdl_window == nullptr) {
161  Debug(driver, 0, "SDL2: Couldn't allocate a window to draw on: {}", SDL_GetError());
162  return false;
163  }
164 
165  std::string icon_path = FioFindFullPath(BASESET_DIR, "openttd.32.bmp");
166  if (!icon_path.empty()) {
167  /* Give the application an icon */
168  SDL_Surface *icon = SDL_LoadBMP(icon_path.c_str());
169  if (icon != nullptr) {
170  /* Get the colourkey, which will be magenta */
171  uint32_t rgbmap = SDL_MapRGB(icon->format, 255, 0, 255);
172 
173  SDL_SetColorKey(icon, SDL_TRUE, rgbmap);
174  SDL_SetWindowIcon(this->sdl_window, icon);
175  SDL_FreeSurface(icon);
176  }
177  }
178 
179  return true;
180 }
181 
182 bool VideoDriver_SDL_Base::CreateMainSurface(uint w, uint h, bool resize)
183 {
184  GetAvailableVideoMode(&w, &h);
185  Debug(driver, 1, "SDL2: using mode {}x{}", w, h);
186 
187  if (!this->CreateMainWindow(w, h)) return false;
188  if (resize) SDL_SetWindowSize(this->sdl_window, w, h);
189  this->ClientSizeChanged(w, h, true);
190 
191  /* When in full screen, we will always have the mouse cursor
192  * within the window, even though SDL does not give us the
193  * appropriate event to know this. */
194  if (_fullscreen) _cursor.in_window = true;
195 
196  return true;
197 }
198 
199 bool VideoDriver_SDL_Base::ClaimMousePointer()
200 {
201  /* Emscripten never claims the pointer, so we do not need to change the cursor visibility. */
202 #ifndef __EMSCRIPTEN__
203  SDL_ShowCursor(0);
204 #endif
205  return true;
206 }
207 
212 {
213  if (!this->edit_box_focused) {
214  SDL_StartTextInput();
215  this->edit_box_focused = true;
216  }
217 }
218 
223 {
224  if (this->edit_box_focused) {
225  SDL_StopTextInput();
226  this->edit_box_focused = false;
227  }
228 }
229 
231 {
232  std::vector<int> rates = {};
233  for (int i = 0; i < SDL_GetNumVideoDisplays(); i++) {
234  SDL_DisplayMode mode = {};
235  if (SDL_GetDisplayMode(i, 0, &mode) != 0) continue;
236  if (mode.refresh_rate != 0) rates.push_back(mode.refresh_rate);
237  }
238  return rates;
239 }
240 
241 
242 struct SDLVkMapping {
243  const SDL_Keycode vk_from;
244  const uint8_t vk_count;
245  const uint8_t map_to;
246  const bool unprintable;
247 
248  constexpr SDLVkMapping(SDL_Keycode vk_first, SDL_Keycode vk_last, uint8_t map_first, [[maybe_unused]] uint8_t map_last, bool unprintable)
249  : vk_from(vk_first), vk_count(vk_last - vk_first + 1), map_to(map_first), unprintable(unprintable)
250  {
251  assert((vk_last - vk_first) == (map_last - map_first));
252  }
253 };
254 
255 #define AS(x, z) {x, x, z, z, false}
256 #define AM(x, y, z, w) {x, y, z, w, false}
257 #define AS_UP(x, z) {x, x, z, z, true}
258 #define AM_UP(x, y, z, w) {x, y, z, w, true}
259 
260 static constexpr SDLVkMapping _vk_mapping[] = {
261  /* Pageup stuff + up/down */
262  AS_UP(SDLK_PAGEUP, WKC_PAGEUP),
263  AS_UP(SDLK_PAGEDOWN, WKC_PAGEDOWN),
264  AS_UP(SDLK_UP, WKC_UP),
265  AS_UP(SDLK_DOWN, WKC_DOWN),
266  AS_UP(SDLK_LEFT, WKC_LEFT),
267  AS_UP(SDLK_RIGHT, WKC_RIGHT),
268 
269  AS_UP(SDLK_HOME, WKC_HOME),
270  AS_UP(SDLK_END, WKC_END),
271 
272  AS_UP(SDLK_INSERT, WKC_INSERT),
273  AS_UP(SDLK_DELETE, WKC_DELETE),
274 
275  /* Map letters & digits */
276  AM(SDLK_a, SDLK_z, 'A', 'Z'),
277  AM(SDLK_0, SDLK_9, '0', '9'),
278 
279  AS_UP(SDLK_ESCAPE, WKC_ESC),
280  AS_UP(SDLK_PAUSE, WKC_PAUSE),
281  AS_UP(SDLK_BACKSPACE, WKC_BACKSPACE),
282 
283  AS(SDLK_SPACE, WKC_SPACE),
284  AS(SDLK_RETURN, WKC_RETURN),
285  AS(SDLK_TAB, WKC_TAB),
286 
287  /* Function keys */
288  AM_UP(SDLK_F1, SDLK_F12, WKC_F1, WKC_F12),
289 
290  /* Numeric part. */
291  AS(SDLK_KP_1, '1'),
292  AS(SDLK_KP_2, '2'),
293  AS(SDLK_KP_3, '3'),
294  AS(SDLK_KP_4, '4'),
295  AS(SDLK_KP_5, '5'),
296  AS(SDLK_KP_6, '6'),
297  AS(SDLK_KP_7, '7'),
298  AS(SDLK_KP_8, '8'),
299  AS(SDLK_KP_9, '9'),
300  AS(SDLK_KP_0, '0'),
301  AS(SDLK_KP_DIVIDE, WKC_NUM_DIV),
302  AS(SDLK_KP_MULTIPLY, WKC_NUM_MUL),
303  AS(SDLK_KP_MINUS, WKC_NUM_MINUS),
304  AS(SDLK_KP_PLUS, WKC_NUM_PLUS),
305  AS(SDLK_KP_ENTER, WKC_NUM_ENTER),
306  AS(SDLK_KP_PERIOD, WKC_NUM_DECIMAL),
307 
308  /* Other non-letter keys */
309  AS(SDLK_SLASH, WKC_SLASH),
310  AS(SDLK_SEMICOLON, WKC_SEMICOLON),
311  AS(SDLK_EQUALS, WKC_EQUALS),
312  AS(SDLK_LEFTBRACKET, WKC_L_BRACKET),
313  AS(SDLK_BACKSLASH, WKC_BACKSLASH),
314  AS(SDLK_RIGHTBRACKET, WKC_R_BRACKET),
315 
316  AS(SDLK_QUOTE, WKC_SINGLEQUOTE),
317  AS(SDLK_COMMA, WKC_COMMA),
318  AS(SDLK_MINUS, WKC_MINUS),
319  AS(SDLK_PERIOD, WKC_PERIOD)
320 };
321 
322 static uint ConvertSdlKeyIntoMy(SDL_Keysym *sym, char32_t *character)
323 {
324  uint key = 0;
325  bool unprintable = false;
326 
327  for (const auto &map : _vk_mapping) {
328  if (IsInsideBS(sym->sym, map.vk_from, map.vk_count)) {
329  key = sym->sym - map.vk_from + map.map_to;
330  unprintable = map.unprintable;
331  break;
332  }
333  }
334 
335  /* check scancode for BACKQUOTE key, because we want the key left of "1", not anything else (on non-US keyboards) */
336  if (sym->scancode == SDL_SCANCODE_GRAVE) key = WKC_BACKQUOTE;
337 
338  /* META are the command keys on mac */
339  if (sym->mod & KMOD_GUI) key |= WKC_META;
340  if (sym->mod & KMOD_SHIFT) key |= WKC_SHIFT;
341  if (sym->mod & KMOD_CTRL) key |= WKC_CTRL;
342  if (sym->mod & KMOD_ALT) key |= WKC_ALT;
343 
344  /* The mod keys have no character. Prevent '?' */
345  if (sym->mod & KMOD_GUI ||
346  sym->mod & KMOD_CTRL ||
347  sym->mod & KMOD_ALT ||
348  unprintable) {
349  *character = WKC_NONE;
350  } else {
351  *character = sym->sym;
352  }
353 
354  return key;
355 }
356 
361 static uint ConvertSdlKeycodeIntoMy(SDL_Keycode kc)
362 {
363  uint key = 0;
364 
365  for (const auto &map : _vk_mapping) {
366  if (IsInsideBS(kc, map.vk_from, map.vk_count)) {
367  key = kc - map.vk_from + map.map_to;
368  break;
369  }
370  }
371 
372  /* check scancode for BACKQUOTE key, because we want the key left
373  * of "1", not anything else (on non-US keyboards) */
374  SDL_Scancode sc = SDL_GetScancodeFromKey(kc);
375  if (sc == SDL_SCANCODE_GRAVE) key = WKC_BACKQUOTE;
376 
377  return key;
378 }
379 
381 {
382  SDL_Event ev;
383 
384  if (!SDL_PollEvent(&ev)) return false;
385 
386  switch (ev.type) {
387  case SDL_MOUSEMOTION: {
388  int32_t x = ev.motion.x;
389  int32_t y = ev.motion.y;
390 
391  if (_cursor.fix_at) {
392  /* Get all queued mouse events now in case we have to warp the cursor. In the
393  * end, we only care about the current mouse position and not bygone events. */
394  while (SDL_PeepEvents(&ev, 1, SDL_GETEVENT, SDL_MOUSEMOTION, SDL_MOUSEMOTION)) {
395  x = ev.motion.x;
396  y = ev.motion.y;
397  }
398  }
399 
400  if (_cursor.UpdateCursorPosition(x, y)) {
401  SDL_WarpMouseInWindow(this->sdl_window, _cursor.pos.x, _cursor.pos.y);
402  }
404  break;
405  }
406 
407  case SDL_MOUSEWHEEL:
408  if (ev.wheel.y > 0) {
409  _cursor.wheel--;
410  } else if (ev.wheel.y < 0) {
411  _cursor.wheel++;
412  }
413  break;
414 
415  case SDL_MOUSEBUTTONDOWN:
416  if (_rightclick_emulate && SDL_GetModState() & KMOD_CTRL) {
417  ev.button.button = SDL_BUTTON_RIGHT;
418  }
419 
420  switch (ev.button.button) {
421  case SDL_BUTTON_LEFT:
422  _left_button_down = true;
423  break;
424 
425  case SDL_BUTTON_RIGHT:
426  _right_button_down = true;
427  _right_button_clicked = true;
428  break;
429 
430  default: break;
431  }
433  break;
434 
435  case SDL_MOUSEBUTTONUP:
436  if (_rightclick_emulate) {
437  _right_button_down = false;
438  _left_button_down = false;
439  _left_button_clicked = false;
440  } else if (ev.button.button == SDL_BUTTON_LEFT) {
441  _left_button_down = false;
442  _left_button_clicked = false;
443  } else if (ev.button.button == SDL_BUTTON_RIGHT) {
444  _right_button_down = false;
445  }
447  break;
448 
449  case SDL_QUIT:
450  HandleExitGameRequest();
451  break;
452 
453  case SDL_KEYDOWN: // Toggle full-screen on ALT + ENTER/F
454  if ((ev.key.keysym.mod & (KMOD_ALT | KMOD_GUI)) &&
455  (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_f)) {
456  if (ev.key.repeat == 0) ToggleFullScreen(!_fullscreen);
457  } else {
458  char32_t character;
459 
460  uint keycode = ConvertSdlKeyIntoMy(&ev.key.keysym, &character);
461  // Only handle non-text keys here. Text is handled in
462  // SDL_TEXTINPUT below.
463  if (!this->edit_box_focused ||
464  keycode == WKC_DELETE ||
465  keycode == WKC_NUM_ENTER ||
466  keycode == WKC_LEFT ||
467  keycode == WKC_RIGHT ||
468  keycode == WKC_UP ||
469  keycode == WKC_DOWN ||
470  keycode == WKC_HOME ||
471  keycode == WKC_END ||
472  keycode & WKC_META ||
473  keycode & WKC_CTRL ||
474  keycode & WKC_ALT ||
475  (keycode >= WKC_F1 && keycode <= WKC_F12) ||
476  !IsValidChar(character, CS_ALPHANUMERAL)) {
477  HandleKeypress(keycode, character);
478  }
479  }
480  break;
481 
482  case SDL_TEXTINPUT: {
483  if (!this->edit_box_focused) break;
484  SDL_Keycode kc = SDL_GetKeyFromName(ev.text.text);
485  uint keycode = ConvertSdlKeycodeIntoMy(kc);
486 
487  if (keycode == WKC_BACKQUOTE && FocusedWindowIsConsole()) {
488  char32_t character;
489  Utf8Decode(&character, ev.text.text);
490  HandleKeypress(keycode, character);
491  } else {
492  HandleTextInput(ev.text.text);
493  }
494  break;
495  }
496  case SDL_WINDOWEVENT: {
497  if (ev.window.event == SDL_WINDOWEVENT_EXPOSED) {
498  // Force a redraw of the entire screen.
499  this->MakeDirty(0, 0, _screen.width, _screen.height);
500  } else if (ev.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
501  int w = std::max(ev.window.data1, 64);
502  int h = std::max(ev.window.data2, 64);
503  CreateMainSurface(w, h, w != ev.window.data1 || h != ev.window.data2);
504  } else if (ev.window.event == SDL_WINDOWEVENT_ENTER) {
505  // mouse entered the window, enable cursor
506  _cursor.in_window = true;
507  /* Ensure pointer lock will not occur. */
508  SDL_SetRelativeMouseMode(SDL_FALSE);
509  } else if (ev.window.event == SDL_WINDOWEVENT_LEAVE) {
510  // mouse left the window, undraw cursor
511  UndrawMouseCursor();
512  _cursor.in_window = false;
513  }
514  break;
515  }
516  }
517 
518  return true;
519 }
520 
521 static std::optional<std::string_view> InitializeSDL()
522 {
523  /* Check if the video-driver is already initialized. */
524  if (SDL_WasInit(SDL_INIT_VIDEO) != 0) return std::nullopt;
525 
526  if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) return SDL_GetError();
527  return std::nullopt;
528 }
529 
530 std::optional<std::string_view> VideoDriver_SDL_Base::Initialize()
531 {
532  this->UpdateAutoResolution();
533 
534  auto error = InitializeSDL();
535  if (error) return error;
536 
537  FindResolutions();
538  Debug(driver, 2, "Resolution for display: {}x{}", _cur_resolution.width, _cur_resolution.height);
539 
540  return std::nullopt;
541 }
542 
543 std::optional<std::string_view> VideoDriver_SDL_Base::Start(const StringList &param)
544 {
545  if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 0) return "Only real blitters supported";
546 
547  auto error = this->Initialize();
548  if (error) return error;
549 
550 #ifdef SDL_HINT_MOUSE_AUTO_CAPTURE
551  if (GetDriverParamBool(param, "no_mouse_capture")) {
552  /* By default SDL captures the mouse, while a button is pressed.
553  * This is annoying during debugging, when OpenTTD is suspended while the button was pressed.
554  */
555  if (!SDL_SetHint(SDL_HINT_MOUSE_AUTO_CAPTURE, "0")) return SDL_GetError();
556  }
557 #endif
558 
559 #ifdef SDL_HINT_APP_NAME
560  SDL_SetHint(SDL_HINT_APP_NAME, "OpenTTD");
561 #endif
562 
563  this->startup_display = FindStartupDisplay(GetDriverParamInt(param, "display", -1));
564 
565  if (!CreateMainSurface(_cur_resolution.width, _cur_resolution.height, false)) {
566  return SDL_GetError();
567  }
568 
569  const char *dname = SDL_GetCurrentVideoDriver();
570  Debug(driver, 1, "SDL2: using driver '{}'", dname);
571 
572  this->driver_info = this->GetName();
573  this->driver_info += " (";
574  this->driver_info += dname;
575  this->driver_info += ")";
576 
578 
579  SDL_StopTextInput();
580  this->edit_box_focused = false;
581 
582 #ifdef __EMSCRIPTEN__
583  this->is_game_threaded = false;
584 #else
585  this->is_game_threaded = !GetDriverParamBool(param, "no_threads") && !GetDriverParamBool(param, "no_thread");
586 #endif
587 
588  return std::nullopt;
589 }
590 
592 {
593  SDL_QuitSubSystem(SDL_INIT_VIDEO);
594  if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
595  SDL_Quit(); // If there's nothing left, quit SDL
596  }
597 }
598 
600 {
601  uint32_t mod = SDL_GetModState();
602  const Uint8 *keys = SDL_GetKeyboardState(nullptr);
603 
604  bool old_ctrl_pressed = _ctrl_pressed;
605 
606  _ctrl_pressed = !!(mod & KMOD_CTRL);
607  _shift_pressed = !!(mod & KMOD_SHIFT);
608 
609  /* Speedup when pressing tab, except when using ALT+TAB
610  * to switch to another application. */
611  this->fast_forward_key_pressed = keys[SDL_SCANCODE_TAB] && (mod & KMOD_ALT) == 0;
612 
613  /* Determine which directional keys are down. */
614  _dirkeys =
615  (keys[SDL_SCANCODE_LEFT] ? 1 : 0) |
616  (keys[SDL_SCANCODE_UP] ? 2 : 0) |
617  (keys[SDL_SCANCODE_RIGHT] ? 4 : 0) |
618  (keys[SDL_SCANCODE_DOWN] ? 8 : 0);
619 
620  if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
621 }
622 
623 void VideoDriver_SDL_Base::LoopOnce()
624 {
625  if (_exit_game) {
626 #ifdef __EMSCRIPTEN__
627  /* Emscripten is event-driven, and as such the main loop is inside
628  * the browser. So if _exit_game goes true, the main loop ends (the
629  * cancel call), but we still have to call the cleanup that is
630  * normally done at the end of the main loop for non-Emscripten.
631  * After that, Emscripten just halts, and the HTML shows a nice
632  * "bye, see you next time" message. */
633  extern void PostMainLoop();
634  PostMainLoop();
635 
636  emscripten_cancel_main_loop();
637  emscripten_exit_pointerlock();
638  /* In effect, the game ends here. As emscripten_set_main_loop() caused
639  * the stack to be unwound, the code after MainLoop() in
640  * openttd_main() is never executed. */
641  if (_game_mode == GM_BOOTSTRAP) {
642  EM_ASM(if (window["openttd_bootstrap_reload"]) openttd_bootstrap_reload());
643  } else {
644  EM_ASM(if (window["openttd_exit"]) openttd_exit());
645  }
646 #endif
647  return;
648  }
649 
650  this->Tick();
651 
652 /* Emscripten is running an event-based mainloop; there is already some
653  * downtime between each iteration, so no need to sleep. */
654 #ifndef __EMSCRIPTEN__
655  this->SleepTillNextTick();
656 #endif
657 }
658 
660 {
661 #ifdef __EMSCRIPTEN__
662  /* Run the main loop event-driven, based on RequestAnimationFrame. */
663  emscripten_set_main_loop_arg(&this->EmscriptenLoop, this, 0, 1);
664 #else
665  this->StartGameThread();
666 
667  while (!_exit_game) {
668  LoopOnce();
669  }
670 
671  this->StopGameThread();
672 #endif
673 }
674 
676 {
677  return CreateMainSurface(w, h, true);
678 }
679 
681 {
682  /* Remember current window size */
683  int w, h;
684  SDL_GetWindowSize(this->sdl_window, &w, &h);
685 
686  if (fullscreen) {
687  /* Find fullscreen window size */
688  SDL_DisplayMode dm;
689  if (SDL_GetCurrentDisplayMode(SDL_GetWindowDisplayIndex(this->sdl_window), &dm) < 0) {
690  Debug(driver, 0, "SDL_GetCurrentDisplayMode() failed: {}", SDL_GetError());
691  } else {
692  SDL_SetWindowSize(this->sdl_window, dm.w, dm.h);
693  }
694  }
695 
696  Debug(driver, 1, "SDL2: Setting {}", fullscreen ? "fullscreen" : "windowed");
697  int ret = SDL_SetWindowFullscreen(this->sdl_window, fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
698  if (ret == 0) {
699  /* Switching resolution succeeded, set fullscreen value of window. */
700  _fullscreen = fullscreen;
701  if (!fullscreen) SDL_SetWindowSize(this->sdl_window, w, h);
702  } else {
703  Debug(driver, 0, "SDL_SetWindowFullscreen() failed: {}", SDL_GetError());
704  }
705 
707  return ret == 0;
708 }
709 
711 {
712  assert(BlitterFactory::GetCurrentBlitter()->GetScreenDepth() != 0);
713  int w, h;
714  SDL_GetWindowSize(this->sdl_window, &w, &h);
715  return CreateMainSurface(w, h, false);
716 }
717 
719 {
720  SDL_DisplayMode mode;
721  if (SDL_GetCurrentDisplayMode(this->startup_display, &mode) != 0) return VideoDriver::GetScreenSize();
722 
723  return { static_cast<uint>(mode.w), static_cast<uint>(mode.h) };
724 }
725 
727 {
728  if (this->buffer_locked) return false;
729  this->buffer_locked = true;
730 
731  _screen.dst_ptr = this->GetVideoPointer();
732  assert(_screen.dst_ptr != nullptr);
733 
734  return true;
735 }
736 
738 {
739  if (_screen.dst_ptr != nullptr) {
740  /* Hand video buffer back to the drawing backend. */
741  this->ReleaseVideoPointer();
742  _screen.dst_ptr = nullptr;
743  }
744 
745  this->buffer_locked = false;
746 }
#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
virtual void PostResize()
Post resize event.
Definition: base.hpp:205
virtual std::string_view GetName() const =0
Get the name of this driver.
std::optional< std::string_view > Start(const StringList &param) override
Start this driver.
Definition: sdl2_v.cpp:543
bool buffer_locked
Video buffer was locked by the main thread.
Definition: sdl2_v.h:49
Dimension GetScreenSize() const override
Get the resolution of the main screen.
Definition: sdl2_v.cpp:718
bool PollEvent() override
Process a single system event.
Definition: sdl2_v.cpp:380
void EditBoxLostFocus() override
This is called to indicate that an edit box has lost focus, text input mode should be disabled.
Definition: sdl2_v.cpp:222
virtual void ReleaseVideoPointer()=0
Hand video buffer back to the painting backend.
bool AfterBlitterChange() override
Callback invoked after the blitter was changed.
Definition: sdl2_v.cpp:710
virtual bool AllocateBackingStore(int w, int h, bool force=false)=0
(Re-)create the backing store.
void InputLoop() override
Handle input logic, is CTRL pressed, should we fast-forward, etc.
Definition: sdl2_v.cpp:599
Palette local_palette
Current palette to use for drawing.
Definition: sdl2_v.h:48
void MainLoop() override
Perform the actual drawing.
Definition: sdl2_v.cpp:659
std::string driver_info
Information string about selected driver.
Definition: sdl2_v.h:51
void UnlockVideoBuffer() override
Unlock a previously locked video buffer.
Definition: sdl2_v.cpp:737
void ClientSizeChanged(int w, int h, bool force)
Indicate to the driver the client-side might have changed.
Definition: sdl2_v.cpp:124
void MakeDirty(int left, int top, int width, int height) override
Mark a particular area dirty.
Definition: sdl2_v.cpp:32
virtual bool CreateMainWindow(uint w, uint h, uint flags=0)
Create the main window.
Definition: sdl2_v.cpp:136
std::vector< int > GetListOfMonitorRefreshRates() override
Get a list of refresh rates of each available monitor.
Definition: sdl2_v.cpp:230
bool edit_box_focused
This is true to indicate that keyboard input is in text input mode, and SDL_TEXTINPUT events are enab...
Definition: sdl2_v.h:86
bool ChangeResolution(int w, int h) override
Change the resolution of the window.
Definition: sdl2_v.cpp:675
void Stop() override
Stop this driver.
Definition: sdl2_v.cpp:591
bool LockVideoBuffer() override
Make sure the video buffer is ready for drawing.
Definition: sdl2_v.cpp:726
void EditBoxGainedFocus() override
This is called to indicate that an edit box has gained focus, text input mode should be enabled.
Definition: sdl2_v.cpp:211
Rect dirty_rect
Rectangle encompassing the dirty area of the video buffer.
Definition: sdl2_v.h:50
void CheckPaletteAnim() override
Process any pending palette animation.
Definition: sdl2_v.cpp:38
virtual void * GetVideoPointer()=0
Get a pointer to the video buffer.
struct SDL_Window * sdl_window
Main SDL window.
Definition: sdl2_v.h:47
bool ToggleFullscreen(bool fullscreen) override
Change the full screen setting.
Definition: sdl2_v.cpp:680
virtual Dimension GetScreenSize() const
Get the resolution of the main screen.
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
Rect BoundingRect(const Rect &r1, const Rect &r2)
Compute the bounding rectangle around two rectangles.
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
void HandleTextInput(const char *str, bool marked=false, const char *caret=nullptr, const char *insert_location=nullptr, const char *replacement_end=nullptr)
Handle text input.
Definition: window.cpp:2648
@ 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
static uint ConvertSdlKeycodeIntoMy(SDL_Keycode kc)
Like ConvertSdlKeyIntoMy(), but takes an SDL_Keycode as input instead of an SDL_Keysym.
Definition: sdl2_v.cpp:361
Base of the SDL2 video driver.
bool IsValidChar(char32_t key, CharSetFilter afilter)
Only allow certain keys.
Definition: string.cpp:396
size_t Utf8Decode(char32_t *c, const char *s)
Decode and consume the next UTF-8 encoded character.
Definition: string.cpp:419
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition: string_type.h:25
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.
Specification of a rectangle with absolute coordinates of all edges.
bool FocusedWindowIsConsole()
Check if a console is focused.
Definition: window.cpp:462
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