+// 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);
+static void DrawTouchGadgetsOverlay(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);
+
+ Debug("internal:frame", "FrameCounter == %d [%s]", 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();
+
+ // 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);
+
+ video.frame_counter++;
+
+ // show render target buffer on screen
+ SDL_RenderPresent(sdl_renderer);
+}
+
+static void UpdateScreen_WithFrameDelay(SDL_Rect *rect)
+{
+ PumpEvents(); // execute event filter actions while waiting
+
+ 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)
+ {
+ Warn("SDLSetWindowIcon(): cannot find file '%s'", basename);
+
+ return;
+ }
+
+ if ((surface = IMG_Load(filename)) == NULL)
+ {
+ Warn("IMG_Load('%s') failed: %s", basename, 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);
+}
+
+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;
+ 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)
+ 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))
+ SDL_SetColorKey(new_surface, SET_TRANSPARENT_PIXEL,
+ SDLGetColorKey(surface));
+
+ return new_surface;
+}
+
+boolean SDLSetNativeSurface(SDL_Surface **surface)