+// SDL internal variables
+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;
+static boolean limit_screen_updates = FALSE;
+
+
+// functions from SGE library
+void sge_Line(SDL_Surface *, Sint16, Sint16, Sint16, Sint16, Uint32);
+
+#if defined(USE_TOUCH_INPUT_OVERLAY)
+// functions to draw overlay graphics for touch device input
+static void DrawTouchInputOverlay(void);
+#endif
+
+void SDLLimitScreenUpdates(boolean enable)
+{
+ limit_screen_updates = enable;
+}
+
+static void FinalizeScreen(int draw_target)
+{
+ // copy global animations to render target buffer, if defined (below border)
+ if (gfx.draw_global_anim_function != NULL)
+ gfx.draw_global_anim_function(draw_target, DRAW_GLOBAL_ANIM_STAGE_1);
+
+ // copy global masked border to render target buffer, if defined
+ if (gfx.draw_global_border_function != NULL)
+ gfx.draw_global_border_function(draw_target);
+
+ // copy global animations to render target buffer, if defined (above border)
+ if (gfx.draw_global_anim_function != NULL)
+ gfx.draw_global_anim_function(draw_target, DRAW_GLOBAL_ANIM_STAGE_2);
+
+ // 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);
+}
+
+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)
+ SDL_Surface *screen = backbuffer->surface;
+
+ if (limit_screen_updates &&
+ !DelayReached(&update_screen_delay, update_screen_delay_value))
+ return;
+
+ LimitScreenUpdates(FALSE);
+
+#if 0
+ {
+ static int LastFrameCounter = 0;
+ boolean changed = (FrameCounter != LastFrameCounter);
+
+ printf("::: FrameCounter == %d [%s]\n", FrameCounter,
+ (changed ? "-" : "SAME FRAME UPDATED"));
+
+ LastFrameCounter = FrameCounter;
+
+ /*
+ if (FrameCounter % 2)
+ return;
+ */
+ }
+#endif
+
+ if (video.screen_rendering_mode == SPECIAL_RENDERING_BITMAP &&
+ gfx.final_screen_bitmap != NULL) // may not be initialized yet
+ {
+ // draw global animations using bitmaps instead of using textures
+ // to prevent texture scaling artefacts (this is potentially slower)
+
+ BlitBitmap(backbuffer, gfx.final_screen_bitmap, 0, 0,
+ gfx.win_xsize, gfx.win_ysize, 0, 0);
+
+ FinalizeScreen(DRAW_TO_SCREEN);
+
+ screen = gfx.final_screen_bitmap->surface;
+
+ // force full window redraw
+ rect = NULL;
+ }
+
+ SDL_Texture *sdl_texture = sdl_texture_stream;
+
+ // deactivate use of target texture if render targets are not supported
+ if ((video.screen_rendering_mode == SPECIAL_RENDERING_TARGET ||
+ video.screen_rendering_mode == SPECIAL_RENDERING_DOUBLE) &&
+ sdl_texture_target == NULL)
+ video.screen_rendering_mode = SPECIAL_RENDERING_OFF;
+
+ if (video.screen_rendering_mode == SPECIAL_RENDERING_TARGET)
+ sdl_texture = sdl_texture_target;
+
+ if (rect)
+ {
+ int bytes_x = screen->pitch / video.width;
+ int bytes_y = screen->pitch;
+
+ SDL_UpdateTexture(sdl_texture, rect,
+ screen->pixels + rect->x * bytes_x + rect->y * bytes_y,
+ screen->pitch);
+ }
+ else
+ {
+ SDL_UpdateTexture(sdl_texture, NULL, screen->pixels, screen->pitch);
+ }
+
+ int xoff = video.screen_xoffset;
+ int yoff = video.screen_yoffset;
+ SDL_Rect dst_rect_screen = { xoff, yoff, video.width, video.height };
+ SDL_Rect *src_rect1 = NULL, *dst_rect1 = NULL;
+ SDL_Rect *src_rect2 = NULL, *dst_rect2 = NULL;
+
+ if (video.screen_rendering_mode == SPECIAL_RENDERING_TARGET ||
+ video.screen_rendering_mode == SPECIAL_RENDERING_DOUBLE)
+ dst_rect2 = &dst_rect_screen;
+ else
+ dst_rect1 = &dst_rect_screen;
+
+#if defined(HAS_SCREEN_KEYBOARD)
+ if (video.shifted_up || video.shifted_up_delay)
+ {
+ 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))
+ {
+ int delay = time_current - video.shifted_up_delay;
+ int delay_value = video.shifted_up_delay_value;
+
+ pos = pos_last + (pos - pos_last) * delay / delay_value;
+ }
+ else
+ {
+ video.shifted_up_pos_last = pos;
+ video.shifted_up_delay = 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 };
+
+ if (video.screen_rendering_mode == SPECIAL_RENDERING_TARGET ||
+ video.screen_rendering_mode == SPECIAL_RENDERING_DOUBLE)
+ {
+ src_rect2 = &src_rect_up;
+ dst_rect2 = &dst_rect_up;
+ }
+ else
+ {
+ src_rect1 = &src_rect_up;
+ dst_rect1 = &dst_rect_up;
+ }
+ }
+#endif
+
+ // clear render target buffer
+ SDL_RenderClear(sdl_renderer);
+
+ // set renderer to use target texture for rendering
+ if (video.screen_rendering_mode == SPECIAL_RENDERING_TARGET ||
+ video.screen_rendering_mode == SPECIAL_RENDERING_DOUBLE)
+ SDL_SetRenderTarget(sdl_renderer, sdl_texture_target);
+
+ // copy backbuffer texture to render target buffer
+ if (video.screen_rendering_mode != SPECIAL_RENDERING_TARGET)
+ SDL_RenderCopy(sdl_renderer, sdl_texture_stream, src_rect1, dst_rect1);
+
+ if (video.screen_rendering_mode != SPECIAL_RENDERING_BITMAP)
+ FinalizeScreen(DRAW_TO_SCREEN);
+
+ // when using target texture, copy it to screen buffer
+ if (video.screen_rendering_mode == SPECIAL_RENDERING_TARGET ||
+ video.screen_rendering_mode == SPECIAL_RENDERING_DOUBLE)
+ {
+ SDL_SetRenderTarget(sdl_renderer, NULL);
+ SDL_RenderCopy(sdl_renderer, sdl_texture_target, src_rect2, dst_rect2);
+ }
+
+#if defined(USE_TOUCH_INPUT_OVERLAY)
+ // draw overlay graphics for touch device input, if needed
+ DrawTouchInputOverlay();
+#endif
+
+ // global synchronization point of the game to align video frame delay
+ if (with_frame_delay)
+ WaitUntilDelayReached(&video.frame_delay, video.frame_delay_value);
+
+ // show render target buffer on screen
+ SDL_RenderPresent(sdl_renderer);
+}
+
+static void UpdateScreen_WithFrameDelay(SDL_Rect *rect)
+{
+ UpdateScreenExt(rect, TRUE);
+}
+
+static void UpdateScreen_WithoutFrameDelay(SDL_Rect *rect)
+{
+ UpdateScreenExt(rect, FALSE);
+}
+
+void Delay_WithScreenUpdates(unsigned int delay)
+{
+ unsigned int time_current = SDL_GetTicks();
+ unsigned int time_delayed = time_current + delay;
+
+ while (time_current < time_delayed)
+ {
+ // updating the screen contains waiting for frame delay (non-busy)
+ UpdateScreen_WithFrameDelay(NULL);
+
+ time_current = SDL_GetTicks();
+ }
+}
+
+static void SDLSetWindowIcon(char *basename)
+{
+ // (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)
+ char *filename = getCustomImageFilename(basename);
+ SDL_Surface *surface;
+
+ if (filename == NULL)
+ {
+ Error(ERR_WARN, "SDLSetWindowIcon(): cannot find file '%s'", basename);
+
+ return;
+ }
+
+ if ((surface = IMG_Load(filename)) == NULL)
+ {
+ Error(ERR_WARN, "IMG_Load() failed: %s", SDL_GetError());
+
+ return;
+ }
+
+ // set transparent color
+ SDL_SetColorKey(surface, SET_TRANSPARENT_PIXEL,
+ SDL_MapRGB(surface->format, 0x00, 0x00, 0x00));
+
+ SDL_SetWindowIcon(sdl_window, surface);
+#endif
+}
+
+static boolean equalSDLPixelFormat(SDL_PixelFormat *format1,
+ SDL_PixelFormat *format2)
+{
+ return (format1->format == format2->format &&
+ format1->BitsPerPixel == format2->BitsPerPixel &&
+ format1->BytesPerPixel == format2->BytesPerPixel &&
+ format1->Rmask == format2->Rmask &&
+ format1->Gmask == format2->Gmask &&
+ format1->Bmask == format2->Bmask);
+}
+
+static Pixel SDLGetColorKey(SDL_Surface *surface)
+{
+ Pixel color_key;
+
+ if (SDL_GetColorKey(surface, &color_key) != 0)
+ return -1;
+
+ return color_key;
+}
+
+static boolean SDLHasColorKey(SDL_Surface *surface)
+{
+ return (SDLGetColorKey(surface) != -1);
+}
+
+static boolean SDLHasAlpha(SDL_Surface *surface)
+{
+ SDL_BlendMode blend_mode;
+
+ if (SDL_GetSurfaceBlendMode(surface, &blend_mode) != 0)
+ return FALSE;
+
+ return (blend_mode == SDL_BLENDMODE_BLEND);
+}
+
+static void SDLSetAlpha(SDL_Surface *surface, boolean set, int alpha)
+{
+ SDL_BlendMode blend_mode = (set ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE);
+
+ SDL_SetSurfaceBlendMode(surface, blend_mode);
+ SDL_SetSurfaceAlphaMod(surface, alpha);
+}
+
+SDL_Surface *SDLGetNativeSurface(SDL_Surface *surface)
+{
+ SDL_PixelFormat format;
+ SDL_Surface *new_surface;
+
+ if (surface == NULL)
+ return NULL;
+
+ if (backbuffer && backbuffer->surface)
+ {
+ format = *backbuffer->surface->format;
+ format.Amask = surface->format->Amask; // keep alpha channel
+ }
+ else
+ {
+ format = *surface->format;
+ }
+
+ new_surface = SDL_ConvertSurface(surface, &format, 0);
+
+ if (new_surface == NULL)
+ Error(ERR_EXIT, "SDL_ConvertSurface() failed: %s", SDL_GetError());
+
+ return new_surface;
+}
+
+boolean SDLSetNativeSurface(SDL_Surface **surface)
+{
+ SDL_Surface *new_surface;
+
+ if (surface == NULL ||
+ *surface == NULL ||
+ backbuffer == NULL ||
+ backbuffer->surface == NULL)
+ return FALSE;
+
+ // if pixel format already optimized for destination surface, do nothing
+ if (equalSDLPixelFormat((*surface)->format, backbuffer->surface->format))
+ return FALSE;
+
+ new_surface = SDLGetNativeSurface(*surface);
+
+ SDL_FreeSurface(*surface);
+
+ *surface = new_surface;
+
+ return TRUE;
+}
+
+static SDL_Texture *SDLCreateTextureFromSurface(SDL_Surface *surface)
+{
+ if (program.headless)
+ return NULL;
+
+ SDL_Texture *texture = SDL_CreateTextureFromSurface(sdl_renderer, surface);
+
+ if (texture == NULL)
+ Error(ERR_EXIT, "SDL_CreateTextureFromSurface() failed: %s",
+ SDL_GetError());
+
+ return texture;
+}
+
+void SDLCreateBitmapTextures(Bitmap *bitmap)
+{
+ if (bitmap == NULL)
+ return;
+
+ if (bitmap->texture)
+ SDL_DestroyTexture(bitmap->texture);
+ if (bitmap->texture_masked)
+ SDL_DestroyTexture(bitmap->texture_masked);
+
+ bitmap->texture = SDLCreateTextureFromSurface(bitmap->surface);
+ bitmap->texture_masked = SDLCreateTextureFromSurface(bitmap->surface_masked);
+}
+
+void SDLFreeBitmapTextures(Bitmap *bitmap)
+{
+ if (bitmap == NULL)
+ return;
+
+ if (bitmap->texture)
+ SDL_DestroyTexture(bitmap->texture);
+ if (bitmap->texture_masked)
+ SDL_DestroyTexture(bitmap->texture_masked);
+
+ bitmap->texture = NULL;
+ bitmap->texture_masked = NULL;
+}
+
+void SDLInitVideoDisplay(void)
+{
+ // initialize SDL video
+ if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
+ Error(ERR_EXIT, "SDL_InitSubSystem() failed: %s", SDL_GetError());
+
+ // set default SDL depth
+ video.default_depth = 32; // (how to determine video depth in SDL2?)
+ //
+ // Code used with SDL 1.2:
+ // video.default_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
+}
+
+static void SDLInitVideoBuffer_VideoBuffer(boolean fullscreen)
+{
+ if (program.headless)
+ return;
+
+ video.window_scaling_percent = setup.window_scaling_percent;
+ video.window_scaling_quality = setup.window_scaling_quality;
+
+ SDLSetScreenRenderingMode(setup.screen_rendering_mode);
+
+ // SDL 2.0: support for (desktop) fullscreen mode available
+ video.fullscreen_available = TRUE;
+
+ // open SDL video output device (window or fullscreen mode)
+ if (!SDLSetVideoMode(fullscreen))
+ Error(ERR_EXIT, "setting video mode failed");
+
+ // !!! SDL2 can only set the window icon if the window already exists !!!
+ // set window icon
+ SDLSetWindowIcon(program.icon_filename);
+
+ // set window and icon title
+ SDLSetWindowTitle();
+}
+
+static void SDLInitVideoBuffer_DrawBuffer(void)
+{
+ /* SDL cannot directly draw to the visible video framebuffer like X11,
+ but always uses a backbuffer, which is then blitted to the visible
+ video framebuffer with 'SDL_UpdateRect' (or replaced with the current
+ visible video framebuffer with 'SDL_Flip', if the hardware supports
+ this). Therefore do not use an additional backbuffer for drawing, but
+ use a symbolic buffer (distinguishable from the SDL backbuffer) called
+ 'window', which indicates that the SDL backbuffer should be updated to
+ the visible video framebuffer when attempting to blit to it.
+
+ For convenience, it seems to be a good idea to create this symbolic
+ buffer 'window' at the same size as the SDL backbuffer. Although it
+ should never be drawn to directly, it would do no harm nevertheless. */
+
+ // create additional (symbolic) buffer for double-buffering
+ ReCreateBitmap(&window, video.width, video.height);
+
+ // create dummy drawing buffer for headless mode, if needed
+ if (program.headless)
+ ReCreateBitmap(&backbuffer, video.width, video.height);
+}
+
+void SDLInitVideoBuffer(boolean fullscreen)
+{
+ SDLInitVideoBuffer_VideoBuffer(fullscreen);
+ SDLInitVideoBuffer_DrawBuffer();
+}
+
+static boolean SDLCreateScreen(boolean fullscreen)
+{
+ SDL_Surface *new_surface = NULL;
+
+ int surface_flags_window = SURFACE_FLAGS | SDL_WINDOW_RESIZABLE;
+ int surface_flags_fullscreen = SURFACE_FLAGS | SDL_WINDOW_FULLSCREEN_DESKTOP;
+
+#if 1
+ int renderer_flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE;
+#else
+ /* If SDL_CreateRenderer() is called from within a VirtualBox Windows VM
+ _without_ enabling 2D/3D acceleration and/or guest additions installed,
+ it will crash if flags are *not* set to SDL_RENDERER_SOFTWARE (because
+ it will try to use accelerated graphics and apparently fails miserably) */
+ int renderer_flags = SDL_RENDERER_SOFTWARE;