// (c) 1995-2014 by Artsoft Entertainment
// Holger Schemel
// info@artsoft.org
-// http://www.artsoft.org/
+// https://www.artsoft.org/
// ----------------------------------------------------------------------------
// sdl.c
// ============================================================================
#include "joystick.h"
#include "misc.h"
#include "setup.h"
+#include "gadgets.h"
#define ENABLE_UNUSED_CODE 0 // currently unused functions
// ============================================================================
// SDL internal variables
-#if defined(TARGET_SDL2)
static SDL_Window *sdl_window = NULL;
static SDL_Renderer *sdl_renderer = NULL;
static SDL_Texture *sdl_texture_stream = NULL;
static SDL_Texture *sdl_texture_target = NULL;
static boolean fullscreen_enabled = FALSE;
-#endif
-
static boolean limit_screen_updates = FALSE;
#if defined(USE_TOUCH_INPUT_OVERLAY)
// functions to draw overlay graphics for touch device input
-static void DrawTouchInputOverlay();
+static void DrawTouchInputOverlay(void);
+static void DrawTouchGadgetsOverlay(void);
#endif
void SDLLimitScreenUpdates(boolean enable)
// copy tile selection cursor to render target buffer, if defined (above all)
if (gfx.draw_tile_cursor_function != NULL)
gfx.draw_tile_cursor_function(draw_target);
+
+ // copy global animations to render target buffer, if defined (mouse pointer)
+ if (gfx.draw_global_anim_function != NULL)
+ gfx.draw_global_anim_function(draw_target, DRAW_GLOBAL_ANIM_STAGE_3);
}
static void UpdateScreenExt(SDL_Rect *rect, boolean with_frame_delay)
{
- static unsigned int update_screen_delay = 0;
- unsigned int update_screen_delay_value = 50; // (milliseconds)
+ if (program.headless)
+ return;
+
+ static DelayCounter update_screen_delay = { 50 }; // (milliseconds)
SDL_Surface *screen = backbuffer->surface;
if (limit_screen_updates &&
- !DelayReached(&update_screen_delay, update_screen_delay_value))
+ !DelayReached(&update_screen_delay))
return;
LimitScreenUpdates(FALSE);
static int LastFrameCounter = 0;
boolean changed = (FrameCounter != LastFrameCounter);
- printf("::: FrameCounter == %d [%s]\n", FrameCounter,
- (changed ? "-" : "SAME FRAME UPDATED"));
+ Debug("internal:frame", "FrameCounter == %d [%s]", FrameCounter,
+ (changed ? "-" : "SAME FRAME UPDATED"));
LastFrameCounter = FrameCounter;
rect = NULL;
}
-#if defined(TARGET_SDL2)
SDL_Texture *sdl_texture = sdl_texture_stream;
// deactivate use of target texture if render targets are not supported
dst_rect1 = &dst_rect_screen;
#if defined(HAS_SCREEN_KEYBOARD)
- if (video.shifted_up || video.shifted_up_delay)
+ SDL_Rect src_rect_up = { 0, 0, video.width, video.height };
+ SDL_Rect dst_rect_up = dst_rect_screen;
+
+ if (video.shifted_up || video.shifted_up_delay.count)
{
int time_current = SDL_GetTicks();
int pos = video.shifted_up_pos;
int pos_last = video.shifted_up_pos_last;
- if (!DelayReachedExt(&video.shifted_up_delay, video.shifted_up_delay_value,
- time_current))
+ if (!DelayReachedExt(&video.shifted_up_delay, time_current))
{
- int delay = time_current - video.shifted_up_delay;
- int delay_value = video.shifted_up_delay_value;
+ int delay_count = time_current - video.shifted_up_delay.count;
+ int delay_value = video.shifted_up_delay.value;
- pos = pos_last + (pos - pos_last) * delay / delay_value;
+ pos = pos_last + (pos - pos_last) * delay_count / delay_value;
}
else
{
video.shifted_up_pos_last = pos;
- video.shifted_up_delay = 0;
+ video.shifted_up_delay.count = 0;
}
- SDL_Rect src_rect_up = { 0, pos, video.width, video.height - pos };
- SDL_Rect dst_rect_up = { xoff, yoff, video.width, video.height - pos };
+ src_rect_up.y = pos;
+ src_rect_up.h = video.height - pos;
+ dst_rect_up.h = video.height - pos;
if (video.screen_rendering_mode == SPECIAL_RENDERING_TARGET ||
video.screen_rendering_mode == SPECIAL_RENDERING_DOUBLE)
#if defined(USE_TOUCH_INPUT_OVERLAY)
// draw overlay graphics for touch device input, if needed
DrawTouchInputOverlay();
-#endif
+ // draw overlay gadgets for touch device input, if needed
+ DrawTouchGadgetsOverlay();
#endif
// global synchronization point of the game to align video frame delay
if (with_frame_delay)
- WaitUntilDelayReached(&video.frame_delay, video.frame_delay_value);
+ WaitUntilDelayReached(&video.frame_delay);
+
+ video.frame_counter++;
-#if defined(TARGET_SDL2)
- // show render target buffer on screen
+ // show render target buffer on screen
SDL_RenderPresent(sdl_renderer);
-#else // TARGET_SDL
- if (rect)
- SDL_UpdateRects(screen, 1, rect);
- else
- SDL_UpdateRect(screen, 0, 0, 0, 0);
-#endif
}
static void UpdateScreen_WithFrameDelay(SDL_Rect *rect)
{
+ PumpEvents(); // execute event filter actions while waiting
+
UpdateScreenExt(rect, TRUE);
}
// (setting the window icon on Mac OS X would replace the high-quality
// dock icon with the currently smaller (and uglier) icon from file)
-#if !defined(PLATFORM_MACOSX)
+#if !defined(PLATFORM_MAC)
char *filename = getCustomImageFilename(basename);
SDL_Surface *surface;
if (filename == NULL)
{
- Error(ERR_WARN, "SDLSetWindowIcon(): cannot find file '%s'", basename);
+ Warn("SDLSetWindowIcon(): cannot find file '%s'", basename);
return;
}
if ((surface = IMG_Load(filename)) == NULL)
{
- Error(ERR_WARN, "IMG_Load() failed: %s", SDL_GetError());
+ Warn("IMG_Load('%s') failed: %s", basename, SDL_GetError());
return;
}
SDL_SetColorKey(surface, SET_TRANSPARENT_PIXEL,
SDL_MapRGB(surface->format, 0x00, 0x00, 0x00));
-#if defined(TARGET_SDL2)
SDL_SetWindowIcon(sdl_window, surface);
-#else
- SDL_WM_SetIcon(surface, NULL);
-#endif
#endif
}
-#if defined(TARGET_SDL2)
-
static boolean equalSDLPixelFormat(SDL_PixelFormat *format1,
SDL_PixelFormat *format2)
{
format1->Bmask == format2->Bmask);
}
-static Pixel SDLGetColorKey(SDL_Surface *surface)
+static void SDLCopyColorKey(SDL_Surface *src_surface, SDL_Surface *dst_surface)
{
Pixel color_key;
+ Uint8 r, g, b;
+
+ // check if source surface has a color key
+ if (SDL_GetColorKey(src_surface, &color_key) == 0)
+ {
+ // get RGB values of color key of source surface
+ SDL_GetRGB(color_key, src_surface->format, &r, &g, &b);
- if (SDL_GetColorKey(surface, &color_key) != 0)
- return -1;
+ // get color key from RGB values in destination surface format
+ color_key = SDL_MapRGB(dst_surface->format, r, g, b);
- return color_key;
+ // set color key in destination surface
+ SDL_SetColorKey(dst_surface, SET_TRANSPARENT_PIXEL, color_key);
+ }
+ else
+ {
+ // unset color key in destination surface
+ SDL_SetColorKey(dst_surface, UNSET_TRANSPARENT_PIXEL, 0);
+ }
}
static boolean SDLHasColorKey(SDL_Surface *surface)
{
- return (SDLGetColorKey(surface) != -1);
+ Pixel color_key;
+
+ return (SDL_GetColorKey(surface, &color_key) == 0);
}
static boolean SDLHasAlpha(SDL_Surface *surface)
return (blend_mode == SDL_BLENDMODE_BLEND);
}
-static void SDLSetAlpha(SDL_Surface *surface, boolean set, int alpha)
+void SDLSetAlpha(SDL_Surface *surface, boolean set, int alpha)
{
SDL_BlendMode blend_mode = (set ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE);
SDL_SetSurfaceAlphaMod(surface, alpha);
}
+const char *SDLGetRendererName(void)
+{
+ static SDL_RendererInfo renderer_info;
+
+ SDL_GetRendererInfo(sdl_renderer, &renderer_info);
+
+ return renderer_info.name;
+}
+
SDL_Surface *SDLGetNativeSurface(SDL_Surface *surface)
{
SDL_PixelFormat format;
new_surface = SDL_ConvertSurface(surface, &format, 0);
if (new_surface == NULL)
- Error(ERR_EXIT, "SDL_ConvertSurface() failed: %s", SDL_GetError());
+ Fail("SDL_ConvertSurface() failed: %s", SDL_GetError());
+
+ // workaround for a bug in SDL 2.0.12 (which does not convert the color key)
+ if (SDLHasColorKey(surface) && !SDLHasColorKey(new_surface))
+ SDLCopyColorKey(surface, new_surface);
return new_surface;
}
return TRUE;
}
-#else
-
-static Pixel SDLGetColorKey(SDL_Surface *surface)
-{
- if ((surface->flags & SDL_SRCCOLORKEY) == 0)
- return -1;
-
- return surface->format->colorkey;
-}
-
-static boolean SDLHasColorKey(SDL_Surface *surface)
-{
- return (SDLGetColorKey(surface) != -1);
-}
-
-static boolean SDLHasAlpha(SDL_Surface *surface)
-{
- return ((surface->flags & SDL_SRCALPHA) != 0);
-}
-
-static void SDLSetAlpha(SDL_Surface *surface, boolean set, int alpha)
-{
- SDL_SetAlpha(surface, (set ? SDL_SRCALPHA : 0), alpha);
-}
-
-SDL_Surface *SDLGetNativeSurface(SDL_Surface *surface)
-{
- SDL_Surface *new_surface;
-
- if (surface == NULL)
- return NULL;
-
- if (!video.initialized)
- new_surface = SDL_ConvertSurface(surface, surface->format, SURFACE_FLAGS);
- else if (SDLHasAlpha(surface))
- new_surface = SDL_DisplayFormatAlpha(surface);
- else
- new_surface = SDL_DisplayFormat(surface);
-
- if (new_surface == NULL)
- Error(ERR_EXIT, "%s() failed: %s",
- (video.initialized ? "SDL_DisplayFormat" : "SDL_ConvertSurface"),
- SDL_GetError());
-
- return new_surface;
-}
-
-boolean SDLSetNativeSurface(SDL_Surface **surface)
-{
- SDL_Surface *new_surface;
-
- if (surface == NULL ||
- *surface == NULL ||
- !video.initialized)
- return FALSE;
-
- new_surface = SDLGetNativeSurface(*surface);
-
- SDL_FreeSurface(*surface);
-
- *surface = new_surface;
-
- return TRUE;
-}
-
-#endif
-
-#if defined(TARGET_SDL2)
static SDL_Texture *SDLCreateTextureFromSurface(SDL_Surface *surface)
{
if (program.headless)
SDL_Texture *texture = SDL_CreateTextureFromSurface(sdl_renderer, surface);
if (texture == NULL)
- Error(ERR_EXIT, "SDL_CreateTextureFromSurface() failed: %s",
- SDL_GetError());
+ Fail("SDL_CreateTextureFromSurface() failed: %s", SDL_GetError());
return texture;
}
-#endif
void SDLCreateBitmapTextures(Bitmap *bitmap)
{
-#if defined(TARGET_SDL2)
if (bitmap == NULL)
return;
bitmap->texture = SDLCreateTextureFromSurface(bitmap->surface);
bitmap->texture_masked = SDLCreateTextureFromSurface(bitmap->surface_masked);
-#endif
}
void SDLFreeBitmapTextures(Bitmap *bitmap)
{
-#if defined(TARGET_SDL2)
if (bitmap == NULL)
return;
bitmap->texture = NULL;
bitmap->texture_masked = NULL;
-#endif
}
void SDLInitVideoDisplay(void)
{
-#if !defined(TARGET_SDL2)
- if (!strEqual(setup.system.sdl_videodriver, ARG_DEFAULT))
- SDL_putenv(getStringCat2("SDL_VIDEODRIVER=", setup.system.sdl_videodriver));
-
- SDL_putenv("SDL_VIDEO_CENTERED=1");
-#endif
+ // set hint to select render driver as specified in setup config file
+ if (!strEqual(setup.system.sdl_renderdriver, ARG_DEFAULT))
+ SDL_SetHint(SDL_HINT_RENDER_DRIVER, setup.system.sdl_renderdriver);
// initialize SDL video
if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
- Error(ERR_EXIT, "SDL_InitSubSystem() failed: %s", SDL_GetError());
+ Fail("SDL_InitSubSystem() failed: %s", SDL_GetError());
// set default SDL depth
-#if !defined(TARGET_SDL2)
- video.default_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
-#else
video.default_depth = 32; // (how to determine video depth in SDL2?)
-#endif
+ //
+ // Code used with SDL 1.2:
+ // video.default_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
}
static void SDLInitVideoBuffer_VideoBuffer(boolean fullscreen)
SDLSetScreenRenderingMode(setup.screen_rendering_mode);
-#if defined(TARGET_SDL2)
// SDL 2.0: support for (desktop) fullscreen mode available
video.fullscreen_available = TRUE;
-#else
- // SDL 1.2: no support for fullscreen mode in R'n'D anymore
- video.fullscreen_available = FALSE;
-#endif
// open SDL video output device (window or fullscreen mode)
if (!SDLSetVideoMode(fullscreen))
- Error(ERR_EXIT, "setting video mode failed");
+ Fail("setting video mode failed");
// !!! SDL2 can only set the window icon if the window already exists !!!
// set window icon
{
SDL_Surface *new_surface = NULL;
-#if defined(TARGET_SDL2)
- int surface_flags_window = SURFACE_FLAGS | SDL_WINDOW_RESIZABLE;
- int surface_flags_fullscreen = SURFACE_FLAGS | SDL_WINDOW_FULLSCREEN_DESKTOP;
-#else
int surface_flags_window = SURFACE_FLAGS;
- int surface_flags_fullscreen = SURFACE_FLAGS; // (no fullscreen in SDL 1.2)
-#endif
+ int surface_flags_fullscreen = SURFACE_FLAGS | SDL_WINDOW_FULLSCREEN_DESKTOP;
-#if defined(TARGET_SDL2)
#if 1
int renderer_flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
+
+ video.vsync_mode = VSYNC_MODE_OFF;
+
+ if (!strEqual(setup.vsync_mode, STR_VSYNC_MODE_OFF))
+ {
+ renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
+ video.vsync_mode = VSYNC_MODE_NORMAL;
+ }
#else
/* If SDL_CreateRenderer() is called from within a VirtualBox Windows VM
_without_ enabling 2D/3D acceleration and/or guest additions installed,
int renderer_flags = SDL_RENDERER_SOFTWARE;
#endif
- SDLSetScreenSizeAndOffsets(video.width, video.height);
-#endif
-
int width = video.width;
int height = video.height;
int screen_width = video.screen_width;
int screen_height = video.screen_height;
int surface_flags = (fullscreen ? surface_flags_fullscreen :
surface_flags_window);
+ int display_nr = options.display_nr;
// default window size is unscaled
video.window_width = screen_width;
video.window_height = screen_height;
-#if defined(TARGET_SDL2)
-
// store if initial screen mode is fullscreen mode when changing screen size
video.fullscreen_initial = fullscreen;
if (sdl_window)
{
- SDL_DestroyWindow(sdl_window);
- sdl_window = NULL;
+ SDL_SetWindowSize(sdl_window, video.window_width, video.window_height);
}
}
if (sdl_window == NULL)
sdl_window = SDL_CreateWindow(program.window_title,
- SDL_WINDOWPOS_CENTERED,
- SDL_WINDOWPOS_CENTERED,
+ SDL_WINDOWPOS_CENTERED_DISPLAY(display_nr),
+ SDL_WINDOWPOS_CENTERED_DISPLAY(display_nr),
video.window_width,
video.window_height,
surface_flags);
if (sdl_renderer != NULL)
{
- SDL_RenderSetLogicalSize(sdl_renderer, screen_width, screen_height);
// SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, setup.window_scaling_quality);
+ // required for setting adaptive vsync when using OpenGL renderer
SDLSetScreenVsyncMode(setup.vsync_mode);
sdl_texture_stream = SDL_CreateTexture(sdl_renderer,
new_surface = SDL_CreateRGBSurface(0, width, height, 32, 0,0,0, 0);
if (new_surface == NULL)
- Error(ERR_WARN, "SDL_CreateRGBSurface() failed: %s", SDL_GetError());
+ Warn("SDL_CreateRGBSurface() failed: %s", SDL_GetError());
}
else
{
- Error(ERR_WARN, "SDL_CreateTexture() failed: %s", SDL_GetError());
+ Warn("SDL_CreateTexture() failed: %s", SDL_GetError());
}
}
else
{
- Error(ERR_WARN, "SDL_CreateRenderer() failed: %s", SDL_GetError());
+ Warn("SDL_CreateRenderer() failed: %s", SDL_GetError());
}
}
else
{
- Error(ERR_WARN, "SDL_CreateWindow() failed: %s", SDL_GetError());
+ Warn("SDL_CreateWindow() failed: %s", SDL_GetError());
}
-#else // TARGET_SDL
-
- if (gfx.final_screen_bitmap == NULL)
- gfx.final_screen_bitmap = CreateBitmapStruct();
-
- gfx.final_screen_bitmap->width = width;
- gfx.final_screen_bitmap->height = height;
-
- gfx.final_screen_bitmap->surface =
- SDL_SetVideoMode(width, height, video.depth, surface_flags);
-
- if (gfx.final_screen_bitmap->surface != NULL)
- {
- new_surface =
- SDL_CreateRGBSurface(surface_flags, width, height, video.depth, 0,0,0, 0);
-
- if (new_surface == NULL)
- Error(ERR_WARN, "SDL_CreateRGBSurface() failed: %s", SDL_GetError());
-
-#if 0
- new_surface = gfx.final_screen_bitmap->surface;
- gfx.final_screen_bitmap = NULL;
-#endif
-
- }
- else
- {
- Error(ERR_WARN, "SDL_SetVideoMode() failed: %s", SDL_GetError());
- }
-#endif
+ SDLSetScreenProperties();
-#if defined(TARGET_SDL2)
// store fullscreen state ("video.fullscreen_enabled" may not reflect this!)
if (new_surface != NULL)
fullscreen_enabled = fullscreen;
-#endif
if (backbuffer == NULL)
backbuffer = CreateBitmapStruct();
}
}
-#if defined(TARGET_SDL2)
SDLRedrawWindow(); // map window
-#endif
-
-#ifdef DEBUG
-#if defined(PLATFORM_WIN32)
- // experimental drag and drop code
-
- SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
-
- {
- SDL_SysWMinfo wminfo;
- HWND hwnd;
- boolean wminfo_success = FALSE;
-
- SDL_VERSION(&wminfo.version);
-#if defined(TARGET_SDL2)
- if (sdl_window)
- wminfo_success = SDL_GetWindowWMInfo(sdl_window, &wminfo);
-#else
- wminfo_success = (SDL_GetWMInfo(&wminfo) == 1);
-#endif
-
- if (wminfo_success)
- {
-#if defined(TARGET_SDL2)
- hwnd = wminfo.info.win.window;
-#else
- hwnd = wminfo.window;
-#endif
-
- DragAcceptFiles(hwnd, TRUE);
- }
- }
-#endif
-#endif
return success;
}
void SDLSetWindowTitle(void)
{
-#if defined(TARGET_SDL2)
if (sdl_window == NULL)
return;
SDL_SetWindowTitle(sdl_window, program.window_title);
-#else
- SDL_WM_SetCaption(program.window_title, program.window_title);
-#endif
}
-#if defined(TARGET_SDL2)
void SDLSetWindowScaling(int window_scaling_percent)
{
if (sdl_window == NULL)
{
SDLSetWindowScaling(setup.window_scaling_percent);
SDL_SetWindowPosition(sdl_window,
- SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+ SDL_WINDOWPOS_CENTERED_DISPLAY(options.display_nr),
+ SDL_WINDOWPOS_CENTERED_DISPLAY(options.display_nr));
video.fullscreen_initial = FALSE;
}
void SDLSetDisplaySize(void)
{
- SDL_Rect display_bounds;
+ if (sdl_renderer != NULL)
+ {
+ int w, h;
+
+ SDL_GetRendererOutputSize(sdl_renderer, &w, &h);
+
+ video.display_width = w;
+ video.display_height = h;
+
+#if 0
+ Debug("video", "SDL renderer size: %d x %d",
+ video.display_width, video.display_height);
+#endif
+ }
+ else
+ {
+ SDL_Rect display_bounds;
- SDL_GetDisplayBounds(0, &display_bounds);
+ SDL_GetDisplayBounds(0, &display_bounds);
- video.display_width = display_bounds.w;
- video.display_height = display_bounds.h;
+ video.display_width = display_bounds.w;
+ video.display_height = display_bounds.h;
#if 0
- Error(ERR_DEBUG, "SDL real screen size: %d x %d",
- video.display_width, video.display_height);
+ Debug("video", "SDL display size: %d x %d",
+ video.display_width, video.display_height);
#endif
+ }
}
void SDLSetScreenSizeAndOffsets(int width, int height)
video.screen_yoffset = (video.screen_height - height) / 2;
#if 0
- Error(ERR_DEBUG, "Changing screen from %dx%d to %dx%d (%.2f to %.2f)",
+ Debug("video", "Changing screen from %dx%d to %dx%d (%.2f to %.2f)",
width, height,
video.screen_width, video.screen_height,
ratio_video, ratio_display);
void SDLSetScreenProperties(void)
{
+ SDLSetDisplaySize();
SDLSetScreenSizeAndOffsets(video.width, video.height);
SDLSetScreenSizeForRenderer(video.screen_width, video.screen_height);
-}
-#endif
+ SetOverlayGridSizeAndButtons();
+}
void SDLSetScreenRenderingMode(char *screen_rendering_mode)
{
-#if defined(TARGET_SDL2)
video.screen_rendering_mode =
(strEqual(screen_rendering_mode, STR_SPECIAL_RENDERING_BITMAP) ?
SPECIAL_RENDERING_BITMAP :
SPECIAL_RENDERING_TARGET:
strEqual(screen_rendering_mode, STR_SPECIAL_RENDERING_DOUBLE) ?
SPECIAL_RENDERING_DOUBLE : SPECIAL_RENDERING_OFF);
-#else
- video.screen_rendering_mode = SPECIAL_RENDERING_BITMAP;
-#endif
}
void SDLSetScreenVsyncMode(char *vsync_mode)
{
-#if defined(TARGET_SDL2)
- int interval =
- (strEqual(vsync_mode, STR_VSYNC_MODE_NORMAL) ? VSYNC_MODE_NORMAL :
- strEqual(vsync_mode, STR_VSYNC_MODE_ADAPTIVE) ? VSYNC_MODE_ADAPTIVE :
- VSYNC_MODE_OFF);
+ // changing vsync mode without re-creating renderer only supported by OpenGL
+ if (!strPrefixLower((char *)SDLGetRendererName(), "opengl"))
+ return;
+
+ int interval = VSYNC_MODE_STR_TO_INT(vsync_mode);
int result = SDL_GL_SetSwapInterval(interval);
// if adaptive vsync requested, but not supported, retry with normal vsync
if (result == -1 && interval == VSYNC_MODE_ADAPTIVE)
- SDL_GL_SetSwapInterval(VSYNC_MODE_NORMAL);
-#endif
+ {
+ interval = VSYNC_MODE_NORMAL;
+
+ result = SDL_GL_SetSwapInterval(interval);
+ }
+
+ if (result == -1)
+ interval = VSYNC_MODE_OFF;
+
+ video.vsync_mode = interval;
}
void SDLRedrawWindow(void)
SDL_CreateRGBSurface(SURFACE_FLAGS, width, height, depth, 0,0,0, 0);
if (surface == NULL)
- Error(ERR_EXIT, "SDL_CreateRGBSurface() failed: %s", SDL_GetError());
+ Fail("SDL_CreateRGBSurface() failed: %s", SDL_GetError());
SDLSetNativeSurface(&surface);
bitmap->surface = NULL;
bitmap->surface_masked = NULL;
-#if defined(TARGET_SDL2)
if (bitmap->texture)
SDL_DestroyTexture(bitmap->texture);
if (bitmap->texture_masked)
bitmap->texture = NULL;
bitmap->texture_masked = NULL;
-#endif
}
void SDLCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
int src_x, int src_y, int width, int height,
int dst_x, int dst_y, int mask_mode)
{
-#if defined(TARGET_SDL2)
SDL_Texture *texture;
SDL_Rect src_rect;
SDL_Rect dst_rect;
dst_rect.h = height;
SDL_RenderCopy(sdl_renderer, texture, &src_rect, &dst_rect);
-#endif
}
void SDLFillRectangle(Bitmap *dst_bitmap, int x, int y, int width, int height,
time_current = SDL_GetTicks();
+ if (fade_delay <= 0)
+ {
+ // immediately draw final target frame without delay
+ fade_mode &= (FADE_MODE_FADE | FADE_MODE_TRANSFORM);
+ fade_delay = 1;
+ time_current -= 1;
+
+ // when fading without delay, also skip post delay
+ post_delay = 0;
+ }
+
if (fade_mode == FADE_MODE_MELT)
{
boolean done = FALSE;
draw_border_function();
UpdateScreen_WithFrameDelay(&dst_rect2);
+
+ if (PendingEscapeKeyEvent())
+ break;
}
}
}
// only update the region of the screen that is affected from fading
UpdateScreen_WithFrameDelay(&dst_rect2);
+
+ if (PendingEscapeKeyEvent())
+ break;
}
}
else // fading in, fading out or cross-fading
// only update the region of the screen that is affected from fading
UpdateScreen_WithFrameDelay(&dst_rect);
+
+ if (PendingEscapeKeyEvent())
+ break;
}
}
case 1:
{
// Assuming 8-bpp
- *((Uint8 *)surface->pixels + y*surface->pitch + x) = color;
+ *((Uint8 *)surface->pixels + y * surface->pitch + x) = color;
}
break;
case 2:
{
// Probably 15-bpp or 16-bpp
- *((Uint16 *)surface->pixels + y*surface->pitch/2 + x) = color;
+ *((Uint16 *)surface->pixels + y * surface->pitch / 2 + x) = color;
}
break;
int shift;
// Gack - slow, but endian correct
- pix = (Uint8 *)surface->pixels + y * surface->pitch + x*3;
+ pix = (Uint8 *)surface->pixels + y * surface->pitch + x * 3;
shift = surface->format->Rshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
shift = surface->format->Gshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
shift = surface->format->Bshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
}
break;
case 4:
{
// Probably 32-bpp
- *((Uint32 *)surface->pixels + y*surface->pitch/4 + x) = color;
+ *((Uint32 *)surface->pixels + y * surface->pitch / 4 + x) = color;
}
break;
}
static void _PutPixel8(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color)
{
- *((Uint8 *)surface->pixels + y*surface->pitch + x) = color;
+ *((Uint8 *)surface->pixels + y * surface->pitch + x) = color;
}
static void _PutPixel16(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color)
{
- *((Uint16 *)surface->pixels + y*surface->pitch/2 + x) = color;
+ *((Uint16 *)surface->pixels + y * surface->pitch / 2 + x) = color;
}
static void _PutPixel24(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color)
int shift;
// Gack - slow, but endian correct
- pix = (Uint8 *)surface->pixels + y * surface->pitch + x*3;
+ pix = (Uint8 *)surface->pixels + y * surface->pitch + x * 3;
shift = surface->format->Rshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
shift = surface->format->Gshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
shift = surface->format->Bshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
}
static void _PutPixel32(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color)
{
- *((Uint32 *)surface->pixels + y*surface->pitch/4 + x) = color;
+ *((Uint32 *)surface->pixels + y * surface->pitch / 4 + x) = color;
}
-static void _PutPixelX(SDL_Surface *dest,Sint16 x,Sint16 y,Uint32 color)
+static void _PutPixelX(SDL_Surface *dest, Sint16 x, Sint16 y, Uint32 color)
{
switch (dest->format->BytesPerPixel)
{
case 1:
- *((Uint8 *)dest->pixels + y*dest->pitch + x) = color;
+ *((Uint8 *)dest->pixels + y * dest->pitch + x) = color;
break;
case 2:
- *((Uint16 *)dest->pixels + y*dest->pitch/2 + x) = color;
+ *((Uint16 *)dest->pixels + y * dest->pitch / 2 + x) = color;
break;
case 3:
- _PutPixel24(dest,x,y,color);
+ _PutPixel24(dest, x, y, color);
break;
case 4:
- *((Uint32 *)dest->pixels + y*dest->pitch/4 + x) = color;
+ *((Uint32 *)dest->pixels + y * dest->pitch / 4 + x) = color;
break;
}
}
switch (dest->format->BytesPerPixel)
{
case 1:
- return y*dest->pitch;
+ return y * dest->pitch;
break;
case 2:
- return y*dest->pitch/2;
+ return y * dest->pitch / 2;
break;
case 3:
- return y*dest->pitch;
+ return y * dest->pitch;
break;
case 4:
- return y*dest->pitch/4;
+ return y * dest->pitch / 4;
break;
}
}
int shift;
// Gack - slow, but endian correct
- pix = (Uint8 *)surface->pixels + ypitch + x*3;
+ pix = (Uint8 *)surface->pixels + ypitch + x * 3;
shift = surface->format->Rshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
shift = surface->format->Gshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
shift = surface->format->Bshift;
- *(pix+shift/8) = color>>shift;
+ *(pix + shift / 8) = color>>shift;
}
break;
// quick (no, it's slow) and dirty hack to "invert" rectangle inside SDL surface
// ----------------------------------------------------------------------------
-void SDLInvertArea(Bitmap *bitmap, int src_x, int src_y,
- int width, int height, Uint32 color)
-{
- int x, y;
-
- for (y = src_y; y < src_y + height; y++)
- {
- for (x = src_x; x < src_x + width; x++)
- {
- Uint32 pixel = SDLGetPixel(bitmap, x, y);
-
- SDLPutPixel(bitmap, x, y, pixel == BLACK_PIXEL ? color : BLACK_PIXEL);
- }
- }
-}
-
void SDLCopyInverseMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
int src_x, int src_y, int width, int height,
int dst_x, int dst_y)
return NULL;
if ((new_surface = SDLGetNativeSurface(surface)) == NULL)
- Error(ERR_EXIT, "SDLGetNativeSurface() failed");
+ Fail("SDLGetNativeSurface() failed");
// remove alpha channel from native non-transparent surface, if defined
SDLSetAlpha(new_surface, FALSE, 0);
// set color key for zoomed surface from source surface, if defined
if (SDLHasColorKey(src_surface))
- SDL_SetColorKey(dst_surface, SET_TRANSPARENT_PIXEL,
- SDLGetColorKey(src_surface));
+ SDLCopyColorKey(src_surface, dst_surface);
// create native non-transparent surface for opaque blitting
dst_bitmap->surface = SDLGetOpaqueSurface(dst_surface);
// load image to temporary surface
if ((sdl_image_tmp = IMG_Load(filename)) == NULL)
- Error(ERR_EXIT, "IMG_Load() failed: %s", SDL_GetError());
+ Fail("IMG_Load('%s') failed: %s", getBaseNamePtr(filename), SDL_GetError());
print_timestamp_time("IMG_Load");
// create native non-transparent surface for current image
if ((new_bitmap->surface = SDLGetOpaqueSurface(sdl_image_tmp)) == NULL)
- Error(ERR_EXIT, "SDLGetOpaqueSurface() failed");
+ Fail("SDLGetOpaqueSurface() failed");
print_timestamp_time("SDLGetNativeSurface (opaque)");
// create native transparent surface for current image
if ((new_bitmap->surface_masked = SDLGetNativeSurface(sdl_image_tmp)) == NULL)
- Error(ERR_EXIT, "SDLGetNativeSurface() failed");
+ Fail("SDLGetNativeSurface() failed");
print_timestamp_time("SDLGetNativeSurface (masked)");
if (program.headless)
return;
-#if !defined(TARGET_SDL2)
- if (!strEqual(setup.system.sdl_audiodriver, ARG_DEFAULT))
- SDL_putenv(getStringCat2("SDL_AUDIODRIVER=", setup.system.sdl_audiodriver));
-#endif
-
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
{
- Error(ERR_WARN, "SDL_InitSubSystem() failed: %s", SDL_GetError());
+ Warn("SDL_InitSubSystem() failed: %s", SDL_GetError());
+
return;
}
AUDIO_NUM_CHANNELS_STEREO,
setup.system.audio_fragment_size) < 0)
{
- Error(ERR_WARN, "Mix_OpenAudio() failed: %s", SDL_GetError());
+ Warn("Mix_OpenAudio() failed: %s", SDL_GetError());
+
return;
}
SDL_WaitEvent(event);
}
-void SDLHandleWindowManagerEvent(Event *event)
+void SDLCorrectRawMousePosition(int *x, int *y)
{
-#ifdef DEBUG
-#if defined(PLATFORM_WIN32)
- // experimental drag and drop code
-
- SDL_SysWMEvent *syswmevent = (SDL_SysWMEvent *)event;
- SDL_SysWMmsg *syswmmsg = (SDL_SysWMmsg *)(syswmevent->msg);
-
-#if defined(TARGET_SDL2)
- if (syswmmsg->msg.win.msg == WM_DROPFILES)
-#else
- if (syswmmsg->msg == WM_DROPFILES)
-#endif
- {
-#if defined(TARGET_SDL2)
- HDROP hdrop = (HDROP)syswmmsg->msg.win.wParam;
-#else
- HDROP hdrop = (HDROP)syswmmsg->wParam;
-#endif
- int i, num_files;
-
- printf("::: SDL_SYSWMEVENT:\n");
+ if (sdl_renderer == NULL)
+ return;
- num_files = DragQueryFile(hdrop, 0xffffffff, NULL, 0);
+ // this corrects the raw mouse position for logical screen size within event
+ // filters (correction done later by SDL library when handling mouse events)
- for (i = 0; i < num_files; i++)
- {
- int buffer_len = DragQueryFile(hdrop, i, NULL, 0);
- char buffer[buffer_len + 1];
+ SDL_Rect viewport;
+ float scale_x, scale_y;
- DragQueryFile(hdrop, i, buffer, buffer_len + 1);
+ SDL_RenderGetViewport(sdl_renderer, &viewport);
+ SDL_RenderGetScale(sdl_renderer, &scale_x, &scale_y);
- printf("::: - '%s'\n", buffer);
- }
+ *x = (int)(*x / scale_x);
+ *y = (int)(*y / scale_y);
-#if defined(TARGET_SDL2)
- DragFinish((HDROP)syswmmsg->msg.win.wParam);
-#else
- DragFinish((HDROP)syswmmsg->wParam);
-#endif
- }
-#endif
-#endif
+ *x -= viewport.x;
+ *y -= viewport.y;
}
// joystick functions
// ============================================================================
-#if defined(TARGET_SDL2)
static void *sdl_joystick[MAX_PLAYERS]; // game controller or joystick
-#else
-static SDL_Joystick *sdl_joystick[MAX_PLAYERS]; // only joysticks supported
-#endif
static int sdl_js_axis_raw[MAX_PLAYERS][2];
static int sdl_js_axis[MAX_PLAYERS][2];
static int sdl_js_button[MAX_PLAYERS][2];
if (nr < 0 || nr >= MAX_PLAYERS)
return FALSE;
-#if defined(TARGET_SDL2)
sdl_is_controller[nr] = SDL_IsGameController(nr);
-#else
- sdl_is_controller[nr] = FALSE;
-#endif
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "opening joystick %d (%s)",
+ Debug("joystick", "opening joystick %d (%s)",
nr, (sdl_is_controller[nr] ? "game controller" : "joystick"));
#endif
-#if defined(TARGET_SDL2)
if (sdl_is_controller[nr])
sdl_joystick[nr] = SDL_GameControllerOpen(nr);
else
sdl_joystick[nr] = SDL_JoystickOpen(nr);
-#else
- sdl_joystick[nr] = SDL_JoystickOpen(nr);
-#endif
return (sdl_joystick[nr] != NULL);
}
return;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "closing joystick %d", nr);
+ Debug("joystick", "closing joystick %d", nr);
#endif
-#if defined(TARGET_SDL2)
if (sdl_is_controller[nr])
SDL_GameControllerClose(sdl_joystick[nr]);
else
SDL_JoystickClose(sdl_joystick[nr]);
-#else
- SDL_JoystickClose(sdl_joystick[nr]);
-#endif
sdl_joystick[nr] = NULL;
}
if (nr < 0 || nr >= MAX_PLAYERS)
return FALSE;
-#if defined(TARGET_SDL2)
return (sdl_joystick[nr] != NULL ? TRUE : FALSE);
-#else
- return (SDL_JoystickOpened(nr) ? TRUE : FALSE);
-#endif
}
static void setJoystickAxis(int nr, int axis_id_raw, int axis_value)
{
-#if defined(TARGET_SDL2)
int axis_id = (axis_id_raw == SDL_CONTROLLER_AXIS_LEFTX ||
axis_id_raw == SDL_CONTROLLER_AXIS_RIGHTX ? 0 :
axis_id_raw == SDL_CONTROLLER_AXIS_LEFTY ||
axis_id_raw == SDL_CONTROLLER_AXIS_RIGHTY ? 1 : -1);
-#else
- int axis_id = axis_id_raw % 2;
-#endif
if (nr < 0 || nr >= MAX_PLAYERS)
return;
static void setJoystickButton(int nr, int button_id_raw, int button_state)
{
-#if defined(TARGET_SDL2)
int button_id = (button_id_raw == SDL_CONTROLLER_BUTTON_A ||
button_id_raw == SDL_CONTROLLER_BUTTON_X ||
button_id_raw == SDL_CONTROLLER_BUTTON_LEFTSHOULDER ||
button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_UP ||
button_id_raw == SDL_CONTROLLER_BUTTON_DPAD_DOWN)
sdl_js_axis_raw[nr][0] = sdl_js_axis_raw[nr][1] = -1;
-#else
- int button_id = button_id_raw % 2;
-#endif
if (nr < 0 || nr >= MAX_PLAYERS)
return;
void HandleJoystickEvent(Event *event)
{
- switch(event->type)
+ // when using joystick, disable overlay touch buttons
+ runtime.uses_touch_device = FALSE;
+
+ switch (event->type)
{
-#if defined(TARGET_SDL2)
case SDL_CONTROLLERDEVICEADDED:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERDEVICEADDED: device %d added",
+ Debug("joystick", "SDL_CONTROLLERDEVICEADDED: device %d added",
event->cdevice.which);
#endif
InitJoysticks();
case SDL_CONTROLLERDEVICEREMOVED:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERDEVICEREMOVED: device %d removed",
+ Debug("joystick", "SDL_CONTROLLERDEVICEREMOVED: device %d removed",
event->cdevice.which);
#endif
InitJoysticks();
case SDL_CONTROLLERAXISMOTION:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERAXISMOTION: device %d, axis %d: %d",
+ Debug("joystick", "SDL_CONTROLLERAXISMOTION: device %d, axis %d: %d",
event->caxis.which, event->caxis.axis, event->caxis.value);
#endif
setJoystickAxis(event->caxis.which,
case SDL_CONTROLLERBUTTONDOWN:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERBUTTONDOWN: device %d, button %d",
+ Debug("joystick", "SDL_CONTROLLERBUTTONDOWN: device %d, button %d",
event->cbutton.which, event->cbutton.button);
#endif
setJoystickButton(event->cbutton.which,
case SDL_CONTROLLERBUTTONUP:
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_CONTROLLERBUTTONUP: device %d, button %d",
+ Debug("joystick", "SDL_CONTROLLERBUTTONUP: device %d, button %d",
event->cbutton.which, event->cbutton.button);
#endif
setJoystickButton(event->cbutton.which,
event->cbutton.button,
FALSE);
break;
-#endif
case SDL_JOYAXISMOTION:
if (sdl_is_controller[event->jaxis.which])
break;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_JOYAXISMOTION: device %d, axis %d: %d",
+ Debug("joystick", "SDL_JOYAXISMOTION: device %d, axis %d: %d",
event->jaxis.which, event->jaxis.axis, event->jaxis.value);
#endif
if (event->jaxis.axis < 4)
break;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_JOYBUTTONDOWN: device %d, button %d",
+ Debug("joystick", "SDL_JOYBUTTONDOWN: device %d, button %d",
event->jbutton.which, event->jbutton.button);
#endif
if (event->jbutton.button < 4)
break;
#if DEBUG_JOYSTICKS
- Error(ERR_DEBUG, "SDL_JOYBUTTONUP: device %d, button %d",
+ Debug("joystick", "SDL_JOYBUTTONUP: device %d, button %d",
event->jbutton.which, event->jbutton.button);
#endif
if (event->jbutton.button < 4)
{
static boolean sdl_joystick_subsystem_initialized = FALSE;
boolean print_warning = !sdl_joystick_subsystem_initialized;
-#if defined(TARGET_SDL2)
char *mappings_file_base = getPath2(options.conf_directory,
GAMECONTROLLER_BASENAME);
- char *mappings_file_user = getPath2(getUserGameDataDir(),
+ char *mappings_file_user = getPath2(getMainUserGameDataDir(),
GAMECONTROLLER_BASENAME);
int num_mappings;
-#endif
int i;
if (!sdl_joystick_subsystem_initialized)
{
sdl_joystick_subsystem_initialized = TRUE;
-#if defined(TARGET_SDL2)
SDL_SetHint(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, "0");
if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) < 0)
-#else
- if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) < 0)
-#endif
- {
- Error(ERR_EXIT, "SDL_Init() failed: %s", SDL_GetError());
- return;
- }
+ Fail("SDL_Init() failed: %s", SDL_GetError());
-#if defined(TARGET_SDL2)
num_mappings = SDL_GameControllerAddMappingsFromFile(mappings_file_base);
// the included game controller base mappings should always be found
if (num_mappings == -1)
- Error(ERR_WARN, "no game controller base mappings found");
+ Warn("no game controller base mappings found");
#if DEBUG_JOYSTICKS
else
- Error(ERR_INFO, "%d game controller base mapping(s) added", num_mappings);
+ Debug("joystick", "%d game controller base mapping(s) added",
+ num_mappings);
#endif
num_mappings = SDL_GameControllerAddMappingsFromFile(mappings_file_user);
#if DEBUG_JOYSTICKS
// the personal game controller user mappings may or may not be found
if (num_mappings == -1)
- Error(ERR_WARN, "no game controller user mappings found");
+ Warn("no game controller user mappings found");
else
- Error(ERR_INFO, "%d game controller user mapping(s) added", num_mappings);
+ Debug("joystick", , "%d game controller user mapping(s) added",
+ num_mappings);
- Error(ERR_INFO, "%d joystick(s) found:", SDL_NumJoysticks());
+ Debug("joystick", "%d joystick(s) found:", SDL_NumJoysticks());
#endif
checked_free(mappings_file_base);
type = "joystick";
}
- Error(ERR_INFO, "- joystick %d (%s): '%s'",
+ Debug("joystick", "- joystick %d (%s): '%s'",
i, type, (name ? name : "(Unknown)"));
}
-#endif
#endif
}
if (joystick_nr >= SDL_NumJoysticks())
{
if (setup.input[i].use_joystick && print_warning)
- Error(ERR_WARN, "cannot find joystick %d", joystick_nr);
+ Warn("cannot find joystick %d", joystick_nr);
joystick_nr = -1;
}
if (SDLOpenJoystick(i))
joystick.status = JOYSTICK_ACTIVATED;
else if (print_warning)
- Error(ERR_WARN, "cannot open joystick %d", i);
+ Warn("cannot open joystick %d", i);
}
SDLClearJoystickState();
continue;
if (grid_button == overlay.grid_button_highlight)
- alpha_draw = alpha_highlight;
+ {
+ draw_outlined = FALSE;
+ alpha_draw = MIN((float)alpha_highlight * 1.5, SDL_ALPHA_OPAQUE);
+ }
if (draw_pressed && overlay.grid_button_action & grid_button_action)
{
static void DrawTouchInputOverlay(void)
{
- static SDL_Texture *texture = NULL;
- static boolean initialized = FALSE;
static boolean deactivated = TRUE;
static boolean show_grid = FALSE;
- static int width = 0, height = 0;
- static int alpha_last = -1;
static int alpha = 0;
int alpha_max = ALPHA_FROM_TRANSPARENCY(setup.touch.transparency);
int alpha_step = ALPHA_FADING_STEPSIZE(alpha_max);
DrawTouchInputOverlay_ShowGrid(alpha);
DrawTouchInputOverlay_ShowGridButtons(alpha);
+}
- return;
-
-
- // !!! VIRTUAL BUTTONS FROM IMAGE FILE NOT USED ANYMORE !!!
-
- if (!initialized)
- {
- char *basename = "overlay/VirtualButtons.png";
- char *filename = getCustomImageFilename(basename);
-
- if (filename == NULL)
- Error(ERR_EXIT, "LoadCustomImage(): cannot find file '%s'", basename);
-
- SDL_Surface *surface;
-
- if ((surface = IMG_Load(filename)) == NULL)
- Error(ERR_EXIT, "IMG_Load() failed: %s", SDL_GetError());
-
- width = surface->w;
- height = surface->h;
-
- // set black pixel to transparent if no alpha channel / transparent color
- if (!SDLHasAlpha(surface) &&
- !SDLHasColorKey(surface))
- SDL_SetColorKey(surface, SET_TRANSPARENT_PIXEL,
- SDL_MapRGB(surface->format, 0x00, 0x00, 0x00));
-
- if ((texture = SDLCreateTextureFromSurface(surface)) == NULL)
- Error(ERR_EXIT, "SDLCreateTextureFromSurface() failed");
-
- SDL_FreeSurface(surface);
-
- SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
-
- initialized = TRUE;
- }
-
- if (alpha != alpha_last)
- SDL_SetTextureAlphaMod(texture, alpha);
-
- alpha_last = alpha;
-
- float ratio_overlay = (float) width / height;
- float ratio_screen = (float) video.screen_width / video.screen_height;
- int width_scaled, height_scaled;
- int xpos, ypos;
-
- if (ratio_overlay > ratio_screen)
- {
- width_scaled = video.screen_width;
- height_scaled = video.screen_height * ratio_screen / ratio_overlay;
- xpos = 0;
- ypos = video.screen_height - height_scaled;
- }
- else
- {
- width_scaled = video.screen_width * ratio_overlay / ratio_screen;
- height_scaled = video.screen_height;
- xpos = (video.screen_width - width_scaled) / 2;
- ypos = 0;
- }
-
- SDL_Rect src_rect = { 0, 0, width, height };
- SDL_Rect dst_rect = { xpos, ypos, width_scaled, height_scaled };
-
- SDL_RenderCopy(sdl_renderer, texture, &src_rect, &dst_rect);
+static void DrawTouchGadgetsOverlay(void)
+{
+ DrawGadgets_OverlayTouchButtons();
}
#endif