OpenTTD Source: src/video/sdl2_v.cpp Source File

OpenTTD Source 15.0-beta1

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
38 void VideoDriver_SDL_Base::CheckPaletteAnim()
39{
40 if (!CopyPalette(this->local_palette)) return;
41 this->MakeDirty(0, 0, _screen.width, _screen.height);
42}
43
44static 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
58static 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::ranges::find(_resolutions, 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
81static 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::ranges::find(_resolutions, 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
103static 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
130 BlitterFactory::GetCurrentBlitter()->PostResize();
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
182bool 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
199bool 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
211 void VideoDriver_SDL_Base::EditBoxGainedFocus()
212{
213 if (!this->edit_box_focused) {
214 SDL_StartTextInput();
215 this->edit_box_focused = true;
216 }
217}
218
222 void VideoDriver_SDL_Base::EditBoxLostFocus()
223{
224 if (this->edit_box_focused) {
225 SDL_StopTextInput();
226 this->edit_box_focused = false;
227 }
228}
229
230std::vector<int> VideoDriver_SDL_Base::GetListOfMonitorRefreshRates()
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
260static 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
322static 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
380 bool VideoDriver_SDL_Base::PollEvent()
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 }
403 HandleMouseEvents();
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
414 /* Handle 2D scrolling. */
415 const float SCROLL_BUILTIN_MULTIPLIER = 14.0f;
416#if SDL_VERSION_ATLEAST(2, 18, 0)
417 _cursor.v_wheel -= ev.wheel.preciseY * SCROLL_BUILTIN_MULTIPLIER * _settings_client.gui.scrollwheel_multiplier;
418 _cursor.h_wheel += ev.wheel.preciseX * SCROLL_BUILTIN_MULTIPLIER * _settings_client.gui.scrollwheel_multiplier;
419#else
420 _cursor.v_wheel -= static_cast<float>(ev.wheel.y * SCROLL_BUILTIN_MULTIPLIER * _settings_client.gui.scrollwheel_multiplier);
421 _cursor.h_wheel += static_cast<float>(ev.wheel.x * SCROLL_BUILTIN_MULTIPLIER * _settings_client.gui.scrollwheel_multiplier);
422#endif
423 _cursor.wheel_moved = true;
424 break;
425 }
426
427 case SDL_MOUSEBUTTONDOWN:
428 if (_rightclick_emulate && SDL_GetModState() & KMOD_CTRL) {
429 ev.button.button = SDL_BUTTON_RIGHT;
430 }
431
432 switch (ev.button.button) {
433 case SDL_BUTTON_LEFT:
434 _left_button_down = true;
435 break;
436
437 case SDL_BUTTON_RIGHT:
438 _right_button_down = true;
439 _right_button_clicked = true;
440 break;
441
442 default: break;
443 }
444 HandleMouseEvents();
445 break;
446
447 case SDL_MOUSEBUTTONUP:
448 if (_rightclick_emulate) {
449 _right_button_down = false;
450 _left_button_down = false;
451 _left_button_clicked = false;
452 } else if (ev.button.button == SDL_BUTTON_LEFT) {
453 _left_button_down = false;
454 _left_button_clicked = false;
455 } else if (ev.button.button == SDL_BUTTON_RIGHT) {
456 _right_button_down = false;
457 }
458 HandleMouseEvents();
459 break;
460
461 case SDL_QUIT:
462 HandleExitGameRequest();
463 break;
464
465 case SDL_KEYDOWN: // Toggle full-screen on ALT + ENTER/F
466 if ((ev.key.keysym.mod & (KMOD_ALT | KMOD_GUI)) &&
467 (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_f)) {
468 if (ev.key.repeat == 0) ToggleFullScreen(!_fullscreen);
469 } else {
470 char32_t character;
471
472 uint keycode = ConvertSdlKeyIntoMy(&ev.key.keysym, &character);
473 // Only handle non-text keys here. Text is handled in
474 // SDL_TEXTINPUT below.
475 if (!this->edit_box_focused ||
476 keycode == WKC_DELETE ||
477 keycode == WKC_NUM_ENTER ||
478 keycode == WKC_LEFT ||
479 keycode == WKC_RIGHT ||
480 keycode == WKC_UP ||
481 keycode == WKC_DOWN ||
482 keycode == WKC_HOME ||
483 keycode == WKC_END ||
484 keycode & WKC_META ||
485 keycode & WKC_CTRL ||
486 keycode & WKC_ALT ||
487 (keycode >= WKC_F1 && keycode <= WKC_F12) ||
488 !IsValidChar(character, CS_ALPHANUMERAL)) {
489 HandleKeypress(keycode, character);
490 }
491 }
492 break;
493
494 case SDL_TEXTINPUT: {
495 if (!this->edit_box_focused) break;
496 SDL_Keycode kc = SDL_GetKeyFromName(ev.text.text);
497 uint keycode = ConvertSdlKeycodeIntoMy(kc);
498
499 if (keycode == WKC_BACKQUOTE && FocusedWindowIsConsole()) {
500 char32_t character;
501 Utf8Decode(&character, ev.text.text);
502 HandleKeypress(keycode, character);
503 } else {
504 HandleTextInput(ev.text.text);
505 }
506 break;
507 }
508 case SDL_WINDOWEVENT: {
509 if (ev.window.event == SDL_WINDOWEVENT_EXPOSED) {
510 // Force a redraw of the entire screen.
511 this->MakeDirty(0, 0, _screen.width, _screen.height);
512 } else if (ev.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
513 int w = std::max(ev.window.data1, 64);
514 int h = std::max(ev.window.data2, 64);
515 CreateMainSurface(w, h, w != ev.window.data1 || h != ev.window.data2);
516 } else if (ev.window.event == SDL_WINDOWEVENT_ENTER) {
517 // mouse entered the window, enable cursor
518 _cursor.in_window = true;
519 /* Ensure pointer lock will not occur. */
520 SDL_SetRelativeMouseMode(SDL_FALSE);
521 } else if (ev.window.event == SDL_WINDOWEVENT_LEAVE) {
522 // mouse left the window, undraw cursor
523 UndrawMouseCursor();
524 _cursor.in_window = false;
525 }
526 break;
527 }
528 }
529
530 return true;
531}
532
533static std::optional<std::string_view> InitializeSDL()
534{
535 /* Check if the video-driver is already initialized. */
536 if (SDL_WasInit(SDL_INIT_VIDEO) != 0) return std::nullopt;
537
538 if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) return SDL_GetError();
539 return std::nullopt;
540}
541
542std::optional<std::string_view> VideoDriver_SDL_Base::Initialize()
543{
544 this->UpdateAutoResolution();
545
546 auto error = InitializeSDL();
547 if (error) return error;
548
549 FindResolutions();
550 Debug(driver, 2, "Resolution for display: {}x{}", _cur_resolution.width, _cur_resolution.height);
551
552 return std::nullopt;
553}
554
555std::optional<std::string_view> VideoDriver_SDL_Base::Start(const StringList &param)
556{
557 if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() == 0) return "Only real blitters supported";
558
559 auto error = this->Initialize();
560 if (error) return error;
561
562#ifdef SDL_HINT_MOUSE_AUTO_CAPTURE
563 if (GetDriverParamBool(param, "no_mouse_capture")) {
564 /* By default SDL captures the mouse, while a button is pressed.
565 * This is annoying during debugging, when OpenTTD is suspended while the button was pressed.
566 */
567 if (!SDL_SetHint(SDL_HINT_MOUSE_AUTO_CAPTURE, "0")) return SDL_GetError();
568 }
569#endif
570
571#ifdef SDL_HINT_APP_NAME
572 SDL_SetHint(SDL_HINT_APP_NAME, "OpenTTD");
573#endif
574
575 this->startup_display = FindStartupDisplay(GetDriverParamInt(param, "display", -1));
576
577 if (!CreateMainSurface(_cur_resolution.width, _cur_resolution.height, false)) {
578 return SDL_GetError();
579 }
580
581 const char *dname = SDL_GetCurrentVideoDriver();
582 Debug(driver, 1, "SDL2: using driver '{}'", dname);
583
584 this->driver_info = this->GetName();
585 this->driver_info += " (";
586 this->driver_info += dname;
587 this->driver_info += ")";
588
589 MarkWholeScreenDirty();
590
591 SDL_StopTextInput();
592 this->edit_box_focused = false;
593
594#ifdef __EMSCRIPTEN__
595 this->is_game_threaded = false;
596#else
597 this->is_game_threaded = !GetDriverParamBool(param, "no_threads") && !GetDriverParamBool(param, "no_thread");
598#endif
599
600 return std::nullopt;
601}
602
603 void VideoDriver_SDL_Base::Stop()
604{
605 SDL_QuitSubSystem(SDL_INIT_VIDEO);
606 if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
607 SDL_Quit(); // If there's nothing left, quit SDL
608 }
609}
610
611 void VideoDriver_SDL_Base::InputLoop()
612{
613 uint32_t mod = SDL_GetModState();
614 const Uint8 *keys = SDL_GetKeyboardState(nullptr);
615
616 bool old_ctrl_pressed = _ctrl_pressed;
617
618 _ctrl_pressed = !!(mod & KMOD_CTRL);
619 _shift_pressed = !!(mod & KMOD_SHIFT);
620
621 /* Speedup when pressing tab, except when using ALT+TAB
622 * to switch to another application. */
623 this->fast_forward_key_pressed = keys[SDL_SCANCODE_TAB] && (mod & KMOD_ALT) == 0;
624
625 /* Determine which directional keys are down. */
626 _dirkeys =
627 (keys[SDL_SCANCODE_LEFT] ? 1 : 0) |
628 (keys[SDL_SCANCODE_UP] ? 2 : 0) |
629 (keys[SDL_SCANCODE_RIGHT] ? 4 : 0) |
630 (keys[SDL_SCANCODE_DOWN] ? 8 : 0);
631
632 if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged();
633}
634
635void VideoDriver_SDL_Base::LoopOnce()
636{
637 if (_exit_game) {
638#ifdef __EMSCRIPTEN__
639 /* Emscripten is event-driven, and as such the main loop is inside
640 * the browser. So if _exit_game goes true, the main loop ends (the
641 * cancel call), but we still have to call the cleanup that is
642 * normally done at the end of the main loop for non-Emscripten.
643 * After that, Emscripten just halts, and the HTML shows a nice
644 * "bye, see you next time" message. */
645 extern void PostMainLoop();
646 PostMainLoop();
647
648 emscripten_cancel_main_loop();
649 emscripten_exit_pointerlock();
650 /* In effect, the game ends here. As emscripten_set_main_loop() caused
651 * the stack to be unwound, the code after MainLoop() in
652 * openttd_main() is never executed. */
653 if (_game_mode == GM_BOOTSTRAP) {
654 EM_ASM(if (window["openttd_bootstrap_reload"]) openttd_bootstrap_reload());
655 } else {
656 EM_ASM(if (window["openttd_exit"]) openttd_exit());
657 }
658#endif
659 return;
660 }
661
662 this->Tick();
663
664/* Emscripten is running an event-based mainloop; there is already some
665 * downtime between each iteration, so no need to sleep. */
666#ifndef __EMSCRIPTEN__
667 this->SleepTillNextTick();
668#endif
669}
670
671 void VideoDriver_SDL_Base::MainLoop()
672{
673#ifdef __EMSCRIPTEN__
674 /* Run the main loop event-driven, based on RequestAnimationFrame. */
675 emscripten_set_main_loop_arg(&this->EmscriptenLoop, this, 0, 1);
676#else
677 this->StartGameThread();
678
679 while (!_exit_game) {
680 LoopOnce();
681 }
682
683 this->StopGameThread();
684#endif
685}
686
687 bool VideoDriver_SDL_Base::ChangeResolution(int w, int h)
688{
689 return CreateMainSurface(w, h, true);
690}
691
692 bool VideoDriver_SDL_Base::ToggleFullscreen(bool fullscreen)
693{
694 /* Remember current window size */
695 int w, h;
696 SDL_GetWindowSize(this->sdl_window, &w, &h);
697
698 if (fullscreen) {
699 /* Find fullscreen window size */
700 SDL_DisplayMode dm;
701 if (SDL_GetCurrentDisplayMode(SDL_GetWindowDisplayIndex(this->sdl_window), &dm) < 0) {
702 Debug(driver, 0, "SDL_GetCurrentDisplayMode() failed: {}", SDL_GetError());
703 } else {
704 SDL_SetWindowSize(this->sdl_window, dm.w, dm.h);
705 }
706 }
707
708 Debug(driver, 1, "SDL2: Setting {}", fullscreen ? "fullscreen" : "windowed");
709 int ret = SDL_SetWindowFullscreen(this->sdl_window, fullscreen ? SDL_WINDOW_FULLSCREEN : 0);
710 if (ret == 0) {
711 /* Switching resolution succeeded, set fullscreen value of window. */
712 _fullscreen = fullscreen;
713 if (!fullscreen) SDL_SetWindowSize(this->sdl_window, w, h);
714 } else {
715 Debug(driver, 0, "SDL_SetWindowFullscreen() failed: {}", SDL_GetError());
716 }
717
718 InvalidateWindowClassesData(WC_GAME_OPTIONS, 3);
719 return ret == 0;
720}
721
722 bool VideoDriver_SDL_Base::AfterBlitterChange()
723{
724 assert(BlitterFactory::GetCurrentBlitter()->GetScreenDepth() != 0);
725 int w, h;
726 SDL_GetWindowSize(this->sdl_window, &w, &h);
727 return CreateMainSurface(w, h, false);
728}
729
730 Dimension VideoDriver_SDL_Base::GetScreenSize() const
731{
732 SDL_DisplayMode mode;
733 if (SDL_GetCurrentDisplayMode(this->startup_display, &mode) != 0) return VideoDriver::GetScreenSize();
734
735 return { static_cast<uint>(mode.w), static_cast<uint>(mode.h) };
736}
737
738 bool VideoDriver_SDL_Base::LockVideoBuffer()
739{
740 if (this->buffer_locked) return false;
741 this->buffer_locked = true;
742
743 _screen.dst_ptr = this->GetVideoPointer();
744 assert(_screen.dst_ptr != nullptr);
745
746 return true;
747}
748
749 void VideoDriver_SDL_Base::UnlockVideoBuffer()
750{
751 if (_screen.dst_ptr != nullptr) {
752 /* Hand video buffer back to the drawing backend. */
753 this->ReleaseVideoPointer();
754 _screen.dst_ptr = nullptr;
755 }
756
757 this->buffer_locked = false;
758}
AS
#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.
Definition airport_defaults.h:389
BlitterFactory::GetCurrentBlitter
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
Definition factory.hpp:138
Blitter::PostResize
virtual void PostResize()
Post resize event.
Definition base.hpp:205
Driver::GetName
virtual std::string_view GetName() const =0
Get the name of this driver.
VideoDriver_SDL_Base::Start
std::optional< std::string_view > Start(const StringList &param) override
Start this driver.
Definition sdl2_v.cpp:555
VideoDriver_SDL_Base::buffer_locked
bool buffer_locked
Video buffer was locked by the main thread.
Definition sdl2_v.h:49
VideoDriver_SDL_Base::GetScreenSize
Dimension GetScreenSize() const override
Get the resolution of the main screen.
Definition sdl2_v.cpp:730
VideoDriver_SDL_Base::PollEvent
bool PollEvent() override
Process a single system event.
Definition sdl2_v.cpp:380
VideoDriver_SDL_Base::EditBoxLostFocus
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
VideoDriver_SDL_Base::ReleaseVideoPointer
virtual void ReleaseVideoPointer()=0
Hand video buffer back to the painting backend.
VideoDriver_SDL_Base::GetVideoPointer
virtual void * GetVideoPointer()=0
Get a pointer to the video buffer.
VideoDriver_SDL_Base::AfterBlitterChange
bool AfterBlitterChange() override
Callback invoked after the blitter was changed.
Definition sdl2_v.cpp:722
VideoDriver_SDL_Base::AllocateBackingStore
virtual bool AllocateBackingStore(int w, int h, bool force=false)=0
(Re-)create the backing store.
VideoDriver_SDL_Base::InputLoop
void InputLoop() override
Handle input logic, is CTRL pressed, should we fast-forward, etc.
Definition sdl2_v.cpp:611
VideoDriver_SDL_Base::local_palette
Palette local_palette
Current palette to use for drawing.
Definition sdl2_v.h:48
VideoDriver_SDL_Base::MainLoop
void MainLoop() override
Perform the actual drawing.
Definition sdl2_v.cpp:671
VideoDriver_SDL_Base::driver_info
std::string driver_info
Information string about selected driver.
Definition sdl2_v.h:51
VideoDriver_SDL_Base::UnlockVideoBuffer
void UnlockVideoBuffer() override
Unlock a previously locked video buffer.
Definition sdl2_v.cpp:749
VideoDriver_SDL_Base::ClientSizeChanged
void ClientSizeChanged(int w, int h, bool force)
Indicate to the driver the client-side might have changed.
Definition sdl2_v.cpp:124
VideoDriver_SDL_Base::MakeDirty
void MakeDirty(int left, int top, int width, int height) override
Mark a particular area dirty.
Definition sdl2_v.cpp:32
VideoDriver_SDL_Base::CreateMainWindow
virtual bool CreateMainWindow(uint w, uint h, uint flags=0)
Create the main window.
Definition sdl2_v.cpp:136
VideoDriver_SDL_Base::GetListOfMonitorRefreshRates
std::vector< int > GetListOfMonitorRefreshRates() override
Get a list of refresh rates of each available monitor.
Definition sdl2_v.cpp:230
VideoDriver_SDL_Base::edit_box_focused
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
VideoDriver_SDL_Base::ChangeResolution
bool ChangeResolution(int w, int h) override
Change the resolution of the window.
Definition sdl2_v.cpp:687
VideoDriver_SDL_Base::Stop
void Stop() override
Stop this driver.
Definition sdl2_v.cpp:603
VideoDriver_SDL_Base::LockVideoBuffer
bool LockVideoBuffer() override
Make sure the video buffer is ready for drawing.
Definition sdl2_v.cpp:738
VideoDriver_SDL_Base::EditBoxGainedFocus
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
VideoDriver_SDL_Base::dirty_rect
Rect dirty_rect
Rectangle encompassing the dirty area of the video buffer.
Definition sdl2_v.h:50
VideoDriver_SDL_Base::CheckPaletteAnim
void CheckPaletteAnim() override
Process any pending palette animation.
Definition sdl2_v.cpp:38
VideoDriver_SDL_Base::sdl_window
struct SDL_Window * sdl_window
Main SDL window.
Definition sdl2_v.h:47
VideoDriver_SDL_Base::ToggleFullscreen
bool ToggleFullscreen(bool fullscreen) override
Change the full screen setting.
Definition sdl2_v.cpp:692
VideoDriver::GetScreenSize
virtual Dimension GetScreenSize() const
Get the resolution of the main screen.
Definition video_driver.hpp:233
VideoDriver::fast_forward_key_pressed
bool fast_forward_key_pressed
The fast-forward key is being pressed.
Definition video_driver.hpp:357
VideoDriver::Tick
void Tick()
Give the video-driver a tick.
Definition video_driver.cpp:102
VideoDriver::SleepTillNextTick
void SleepTillNextTick()
Sleep till the next tick is about to happen.
Definition video_driver.cpp:171
VideoDriver::StartGameThread
void StartGameThread()
Start the loop for game-tick.
Definition video_driver.cpp:86
VideoDriver::GetCaption
static std::string GetCaption()
Get the caption to use for the game's title bar.
Definition video_driver.cpp:189
VideoDriver::StopGameThread
void StopGameThread()
Stop the loop for the game-tick.
Definition video_driver.cpp:95
VideoDriver::UpdateAutoResolution
void UpdateAutoResolution()
Apply resolution auto-detection and clamp to sensible defaults.
Definition video_driver.hpp:244
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition debug.h:37
GetDriverParamInt
int GetDriverParamInt(const StringList &parm, const char *name, int def)
Get an integer parameter the list of parameters.
Definition driver.cpp:76
_resolutions
std::vector< Dimension > _resolutions
List of resolutions.
Definition driver.cpp:25
_cur_resolution
Dimension _cur_resolution
The current resolution.
Definition driver.cpp:26
_rightclick_emulate
bool _rightclick_emulate
Whether right clicking is emulated.
Definition driver.cpp:27
GetDriverParamBool
bool GetDriverParamBool(const StringList &parm, const char *name)
Get a boolean parameter the list of parameters.
Definition driver.cpp:64
FioFindFullPath
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
@ BASESET_DIR
Subdirectory for all base data (base sets, intro game)
Definition fileio_type.h:123
BoundingRect
Rect BoundingRect(const Rect &r1, const Rect &r2)
Compute the bounding rectangle around two rectangles.
Definition geometry_func.cpp:36
_shift_pressed
bool _shift_pressed
Is Shift pressed?
Definition gfx.cpp:39
_left_button_down
bool _left_button_down
Is left mouse button pressed?
Definition gfx.cpp:41
_ctrl_pressed
bool _ctrl_pressed
Is Ctrl pressed?
Definition gfx.cpp:38
_dirkeys
uint8_t _dirkeys
1 = left, 2 = up, 4 = right, 8 = down
Definition gfx.cpp:34
_left_button_clicked
bool _left_button_clicked
Is left mouse button clicked?
Definition gfx.cpp:42
_right_button_clicked
bool _right_button_clicked
Is right mouse button clicked?
Definition gfx.cpp:44
_right_button_down
bool _right_button_down
Is right mouse button pressed?
Definition gfx.cpp:43
HandleCtrlChanged
void HandleCtrlChanged()
State of CONTROL key has changed.
Definition window.cpp:2625
GameSizeChanged
void GameSizeChanged()
Size of the application screen changed.
Definition main_gui.cpp:589
HandleMouseEvents
void HandleMouseEvents()
Handle a mouse event from the video driver.
Definition window.cpp:2885
HandleKeypress
void HandleKeypress(uint keycode, char32_t key)
Handle keyboard input.
Definition window.cpp:2569
HandleTextInput
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:2655
WKC_BACKSLASH
@ WKC_BACKSLASH
\ Backslash
Definition gfx_type.h:100
WKC_MINUS
@ WKC_MINUS
Definition gfx_type.h:105
WKC_COMMA
@ WKC_COMMA
, Comma
Definition gfx_type.h:103
WKC_PERIOD
@ WKC_PERIOD
. Period
Definition gfx_type.h:104
WKC_EQUALS
@ WKC_EQUALS
= Equals
Definition gfx_type.h:98
WKC_SLASH
@ WKC_SLASH
/ Forward slash
Definition gfx_type.h:96
WKC_SINGLEQUOTE
@ WKC_SINGLEQUOTE
' Single quote
Definition gfx_type.h:102
WKC_R_BRACKET
@ WKC_R_BRACKET
] Right square bracket
Definition gfx_type.h:101
WKC_L_BRACKET
@ WKC_L_BRACKET
[ Left square bracket
Definition gfx_type.h:99
WKC_SEMICOLON
@ WKC_SEMICOLON
; Semicolon
Definition gfx_type.h:97
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1529
IsInsideBS
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
Delta
constexpr T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
Definition math_func.hpp:234
CopyPalette
bool CopyPalette(Palette &local_palette, bool force_copy)
Copy the current palette if the palette was updated.
Definition palette.cpp:152
ConvertSdlKeycodeIntoMy
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
sdl2_v.h
Base of the SDL2 video driver.
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:56
IsValidChar
bool IsValidChar(char32_t key, CharSetFilter afilter)
Only allow certain keys.
Definition string.cpp:396
Utf8Decode
size_t Utf8Decode(char32_t *c, const char *s)
Decode and consume the next UTF-8 encoded character.
Definition string.cpp:419
CS_ALPHANUMERAL
@ CS_ALPHANUMERAL
Both numeric and alphabetic and spaces and stuff.
Definition string_type.h:25
StringList
std::vector< std::string > StringList
Type for a list of strings.
Definition string_type.h:60
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition settings_type.h:610
CursorVars::UpdateCursorPosition
bool UpdateCursorPosition(int x, int y)
Update cursor position on mouse movement.
Definition gfx.cpp:1728
CursorVars::fix_at
bool fix_at
mouse is moving, but cursor is not (used for scrolling)
Definition gfx_type.h:128
CursorVars::pos
Point pos
logical mouse position
Definition gfx_type.h:125
CursorVars::in_window
bool in_window
mouse inside this window, determines drawing logic
Definition gfx_type.h:147
CursorVars::wheel
int wheel
mouse wheel movement
Definition gfx_type.h:127
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition geometry_type.hpp:30
GUISettings::scrollwheel_multiplier
uint8_t scrollwheel_multiplier
how much 'wheel' per incoming event from the OS?
Definition settings_type.h:178
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition geometry_type.hpp:75
SDLVkMapping
Definition sdl2_v.cpp:242
FocusedWindowIsConsole
bool FocusedWindowIsConsole()
Check if a console is focused.
Definition window.cpp:462
InvalidateWindowClassesData
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:3236
WC_GAME_OPTIONS
@ WC_GAME_OPTIONS
Game options window; Window numbers:
Definition window_type.h:624