12 #include "../stdafx.h"
13 #include "../openttd.h"
14 #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"
27 #include <condition_variable>
29 #include "../safeguards.h"
33 static SDL_Surface *_sdl_surface;
34 static SDL_Surface *_sdl_realscreen;
35 static bool _all_modes;
47 #define MAX_DIRTY_RECTS 100
48 static SDL_Rect _dirty_rects[MAX_DIRTY_RECTS];
49 static int _num_dirty_rects;
50 static int _use_hwpalette;
51 static int _requested_hwpalette;
55 if (_num_dirty_rects < MAX_DIRTY_RECTS) {
56 _dirty_rects[_num_dirty_rects].x = left;
57 _dirty_rects[_num_dirty_rects].y = top;
58 _dirty_rects[_num_dirty_rects].w = width;
59 _dirty_rects[_num_dirty_rects].h = height;
64 static void UpdatePalette(
bool init =
false)
77 if (_sdl_surface != _sdl_realscreen && init) {
101 if (_sdl_surface != _sdl_realscreen && !init) {
112 SDL_BlitSurface(_sdl_surface,
nullptr, _sdl_realscreen,
nullptr);
113 SDL_UpdateRect(_sdl_realscreen, 0, 0, 0, 0);
117 static void InitPalette()
155 int n = _num_dirty_rects;
158 _num_dirty_rects = 0;
160 if (n > MAX_DIRTY_RECTS) {
161 if (_sdl_surface != _sdl_realscreen) {
162 SDL_BlitSurface(_sdl_surface,
nullptr, _sdl_realscreen,
nullptr);
165 SDL_UpdateRect(_sdl_realscreen, 0, 0, 0, 0);
167 if (_sdl_surface != _sdl_realscreen) {
168 for (
int i = 0; i < n; i++) {
169 SDL_BlitSurface(_sdl_surface, &_dirty_rects[i], _sdl_realscreen, &_dirty_rects[i]);
173 SDL_UpdateRects(_sdl_realscreen, n, _dirty_rects);
198 static const Dimension _default_resolutions[] = {
212 static void GetVideoModes()
214 SDL_Rect **modes = SDL_ListModes(
nullptr, SDL_SWSURFACE | SDL_FULLSCREEN);
215 if (modes ==
nullptr)
usererror(
"sdl: no modes available");
219 _all_modes = (SDL_ListModes(
nullptr, SDL_SWSURFACE | (_fullscreen ? SDL_FULLSCREEN : 0)) == (
void*)-1);
220 if (modes == (
void*)-1) {
221 for (uint i = 0; i <
lengthof(_default_resolutions); i++) {
222 if (SDL_VideoModeOK(_default_resolutions[i].width, _default_resolutions[i].height, 8, SDL_FULLSCREEN) != 0) {
227 for (
int i = 0; modes[i]; i++) {
228 uint w = modes[i]->w;
229 uint h = modes[i]->h;
230 if (w < 640 || h < 480)
continue;
239 static void GetAvailableVideoMode(uint *w, uint *h)
252 if (newdelta < delta) {
261 bool VideoDriver_SDL::CreateMainSurface(uint w, uint h)
263 SDL_Surface *newscreen, *icon;
268 GetAvailableVideoMode(&w, &h);
270 DEBUG(driver, 1,
"SDL: using mode %ux%ux%d", w, h, bpp);
272 if (bpp == 0)
usererror(
"Can't use a blitter that blits 0 bpp for normal visuals");
275 if (!icon_path.empty()) {
277 icon = SDL_LoadBMP(icon_path.c_str());
278 if (icon !=
nullptr) {
280 uint32 rgbmap = SDL_MapRGB(icon->format, 255, 0, 255);
282 SDL_SetColorKey(icon, SDL_SRCCOLORKEY, rgbmap);
283 SDL_WM_SetIcon(icon,
nullptr);
284 SDL_FreeSurface(icon);
288 if (_use_hwpalette == 2) {
310 want_hwpalette = bpp == 8 && _fullscreen && _support8bpp ==
S8BPP_HARDWARE;
313 want_hwpalette = _use_hwpalette;
316 if (want_hwpalette)
DEBUG(driver, 1,
"SDL: requesting hardware palette");
319 if (_sdl_surface !=
nullptr && _sdl_surface != _sdl_realscreen) SDL_FreeSurface(_sdl_surface);
321 if (_sdl_realscreen !=
nullptr) {
322 if (_requested_hwpalette != want_hwpalette) {
331 DEBUG(driver, 0,
"SDL: Restarting SDL video subsystem, to force hwpalette change");
332 SDL_QuitSubSystem(SDL_INIT_VIDEO);
333 SDL_InitSubSystem(SDL_INIT_VIDEO);
342 _requested_hwpalette = want_hwpalette;
345 newscreen = SDL_SetVideoMode(w, h, bpp, SDL_SWSURFACE | (want_hwpalette ? SDL_HWPALETTE : 0) | (_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE));
346 if (newscreen ==
nullptr) {
347 DEBUG(driver, 0,
"SDL: Couldn't allocate a window to draw on");
350 _sdl_realscreen = newscreen;
352 if (bpp == 8 && (_sdl_realscreen->flags & SDL_HWPALETTE) != SDL_HWPALETTE) {
371 DEBUG(driver, 1,
"SDL: using shadow surface");
372 newscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, bpp, 0, 0, 0, 0);
373 if (newscreen ==
nullptr) {
374 DEBUG(driver, 0,
"SDL: Couldn't allocate a shadow surface to draw on");
380 _num_dirty_rects = 0;
382 _screen.width = newscreen->w;
383 _screen.height = newscreen->h;
384 _screen.pitch = newscreen->pitch / (bpp / 8);
385 _screen.dst_ptr = newscreen->pixels;
386 _sdl_surface = newscreen;
391 if (_fullscreen) _cursor.
in_window =
true;
398 seprintf(caption,
lastof(caption),
"OpenTTD %s", _openttd_revision);
399 SDL_WM_SetCaption(caption, caption);
406 bool VideoDriver_SDL::ClaimMousePointer()
418 #define AS(x, z) {x, 0, z}
419 #define AM(x, y, z, w) {x, (byte)(y - x), z}
423 AM(SDLK_PAGEUP, SDLK_PAGEDOWN, WKC_PAGEUP, WKC_PAGEDOWN),
425 AS(SDLK_DOWN, WKC_DOWN),
426 AS(SDLK_LEFT, WKC_LEFT),
427 AS(SDLK_RIGHT, WKC_RIGHT),
429 AS(SDLK_HOME, WKC_HOME),
430 AS(SDLK_END, WKC_END),
432 AS(SDLK_INSERT, WKC_INSERT),
433 AS(SDLK_DELETE, WKC_DELETE),
436 AM(SDLK_a, SDLK_z,
'A',
'Z'),
437 AM(SDLK_0, SDLK_9,
'0',
'9'),
439 AS(SDLK_ESCAPE, WKC_ESC),
440 AS(SDLK_PAUSE, WKC_PAUSE),
441 AS(SDLK_BACKSPACE, WKC_BACKSPACE),
443 AS(SDLK_SPACE, WKC_SPACE),
444 AS(SDLK_RETURN, WKC_RETURN),
445 AS(SDLK_TAB, WKC_TAB),
448 AM(SDLK_F1, SDLK_F12, WKC_F1, WKC_F12),
451 AM(SDLK_KP0, SDLK_KP9,
'0',
'9'),
452 AS(SDLK_KP_DIVIDE, WKC_NUM_DIV),
453 AS(SDLK_KP_MULTIPLY, WKC_NUM_MUL),
454 AS(SDLK_KP_MINUS, WKC_NUM_MINUS),
455 AS(SDLK_KP_PLUS, WKC_NUM_PLUS),
456 AS(SDLK_KP_ENTER, WKC_NUM_ENTER),
457 AS(SDLK_KP_PERIOD, WKC_NUM_DECIMAL),
473 static uint ConvertSdlKeyIntoMy(SDL_keysym *sym,
WChar *character)
478 for (map = _vk_mapping; map !=
endof(_vk_mapping); ++map) {
479 if ((uint)(sym->sym - map->vk_from) <= map->vk_count) {
480 key = sym->sym - map->vk_from + map->map_to;
486 #if defined(_WIN32) || defined(__OS2__)
487 if (sym->scancode == 41) key = WKC_BACKQUOTE;
488 #elif defined(__APPLE__)
489 if (sym->scancode == 10) key = WKC_BACKQUOTE;
490 #elif defined(__SVR4) && defined(__sun)
491 if (sym->scancode == 60) key = WKC_BACKQUOTE;
492 if (sym->scancode == 49) key = WKC_BACKSPACE;
493 #elif defined(__sgi__)
494 if (sym->scancode == 22) key = WKC_BACKQUOTE;
496 if (sym->scancode == 49) key = WKC_BACKQUOTE;
500 if (sym->mod & KMOD_META) key |= WKC_META;
501 if (sym->mod & KMOD_SHIFT) key |= WKC_SHIFT;
502 if (sym->mod & KMOD_CTRL) key |= WKC_CTRL;
503 if (sym->mod & KMOD_ALT) key |= WKC_ALT;
505 *character = sym->unicode;
513 if (!SDL_PollEvent(&ev))
return false;
516 case SDL_MOUSEMOTION:
518 SDL_WarpMouse(_cursor.
pos.x, _cursor.
pos.y);
523 case SDL_MOUSEBUTTONDOWN:
525 ev.button.button = SDL_BUTTON_RIGHT;
528 switch (ev.button.button) {
529 case SDL_BUTTON_LEFT:
533 case SDL_BUTTON_RIGHT:
538 case SDL_BUTTON_WHEELUP: _cursor.
wheel--;
break;
539 case SDL_BUTTON_WHEELDOWN: _cursor.
wheel++;
break;
546 case SDL_MOUSEBUTTONUP:
551 }
else if (ev.button.button == SDL_BUTTON_LEFT) {
554 }
else if (ev.button.button == SDL_BUTTON_RIGHT) {
560 case SDL_ACTIVEEVENT:
561 if (!(ev.active.state & SDL_APPMOUSEFOCUS))
break;
563 if (ev.active.gain) {
572 HandleExitGameRequest();
576 if ((ev.key.keysym.mod & (KMOD_ALT | KMOD_META)) &&
577 (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_f)) {
578 ToggleFullScreen(!_fullscreen);
581 uint keycode = ConvertSdlKeyIntoMy(&ev.key.keysym, &character);
586 case SDL_VIDEORESIZE: {
587 int w = std::max(ev.resize.w, 64);
588 int h = std::max(ev.resize.h, 64);
589 CreateMainSurface(w, h);
592 case SDL_VIDEOEXPOSE: {
596 _num_dirty_rects = MAX_DIRTY_RECTS + 1;
613 if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
614 ret_code = SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE);
615 }
else if (SDL_WasInit(SDL_INIT_VIDEO) == 0) {
616 ret_code = SDL_InitSubSystem(SDL_INIT_VIDEO);
618 if (ret_code < 0)
return SDL_GetError();
624 return SDL_GetError();
627 SDL_VideoDriverName(buf,
sizeof buf);
628 DEBUG(driver, 1,
"SDL: using driver '%s'", buf);
638 void VideoDriver_SDL::SetupKeyboard()
640 SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
641 SDL_EnableUNICODE(1);
646 SDL_QuitSubSystem(SDL_INIT_VIDEO);
647 if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
654 uint32 mod = SDL_GetModState();
656 Uint8 *keys = SDL_GetKeyState(&numkeys);
673 (keys[SDLK_LEFT] ? 1 : 0) |
674 (keys[SDLK_UP] ? 2 : 0) |
675 (keys[SDLK_RIGHT] ? 4 : 0) |
676 (keys[SDLK_DOWN] ? 8 : 0);
683 std::thread draw_thread;
691 this->draw_lock = std::unique_lock<std::recursive_mutex>(*
_draw_mutex);
699 this->draw_lock.unlock();
700 this->draw_lock.release();
715 if (_exit_game)
break;
732 if (this->draw_lock.owns_lock()) this->draw_lock.unlock();
733 this->draw_lock.release();
746 std::unique_lock<std::recursive_mutex>
lock;
749 return CreateMainSurface(w, h);
754 std::unique_lock<std::recursive_mutex>
lock;
757 _fullscreen = fullscreen;
771 return CreateMainSurface(_screen.width, _screen.height);