X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Flibgame%2Fsdl.c;h=d431aacf29c96c34d73b2a4db489d075608a5640;hp=2217842e8c8b132e7e17193360b7dcd236de158a;hb=0a69f419ffadee5822bc103be9e85d378e0d0274;hpb=466733e5fd75e0d705bf80dddb48468c4c9885a7

diff --git a/src/libgame/sdl.c b/src/libgame/sdl.c
index 2217842e..d431aacf 100644
--- a/src/libgame/sdl.c
+++ b/src/libgame/sdl.c
@@ -27,6 +27,7 @@
 static SDL_Window *sdl_window = NULL;
 static SDL_Renderer *sdl_renderer = NULL;
 static SDL_Texture *sdl_texture = NULL;
+static boolean fullscreen_enabled = FALSE;
 
 #define USE_RENDERER	TRUE
 #endif
@@ -53,6 +54,7 @@ static void UpdateScreen(SDL_Rect *rect)
 {
   static unsigned int update_screen_delay = 0;
   unsigned int update_screen_delay_value = 20;		/* (milliseconds) */
+  SDL_Surface *screen = backbuffer->surface;
 
   if (limit_screen_updates &&
       !DelayReached(&update_screen_delay, update_screen_delay_value))
@@ -60,10 +62,46 @@ static void UpdateScreen(SDL_Rect *rect)
 
   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 USE_FINAL_SCREEN_BITMAP
+  if (gfx.final_screen_bitmap != NULL)	// may not be initialized yet
+  {
+    // !!! TEST !!!
+    // 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);
+
+    // copy global animations to render target buffer, if defined
+    if (gfx.draw_global_anim_function != NULL)
+      gfx.draw_global_anim_function();
+
+    screen = gfx.final_screen_bitmap->surface;
+
+    // force full window redraw
+    rect = NULL;
+  }
+#endif
+
 #if defined(TARGET_SDL2)
 #if USE_RENDERER
-  SDL_Surface *screen = backbuffer->surface;
-
   if (rect)
   {
     int bytes_x = screen->pitch / video.width;
@@ -80,10 +118,24 @@ static void UpdateScreen(SDL_Rect *rect)
   {
     SDL_UpdateTexture(sdl_texture, NULL, screen->pixels, screen->pitch);
   }
+
+  // clear render target buffer
   SDL_RenderClear(sdl_renderer);
+
+  // copy backbuffer to render target buffer
   SDL_RenderCopy(sdl_renderer, sdl_texture, NULL, NULL);
+
+#if !USE_FINAL_SCREEN_BITMAP
+  // copy global animations to render target buffer, if defined
+  if (gfx.draw_global_anim_function != NULL)
+    gfx.draw_global_anim_function();
+#endif
+
+  // show render target buffer on screen
   SDL_RenderPresent(sdl_renderer);
+
 #else
+
   if (rect)
     SDL_UpdateWindowSurfaceRects(sdl_window, rect, 1);
   else
@@ -92,9 +144,9 @@ static void UpdateScreen(SDL_Rect *rect)
 
 #else	// TARGET_SDL
   if (rect)
-    SDL_UpdateRects(backbuffer->surface, 1, rect);
+    SDL_UpdateRects(screen, 1, rect);
   else
-    SDL_UpdateRect(backbuffer->surface, 0, 0, 0, 0);
+    SDL_UpdateRect(screen, 0, 0, 0, 0);
 #endif
 }
 
@@ -198,6 +250,9 @@ boolean SDLSetNativeSurface(SDL_Surface **surface)
 
   new_surface = SDL_ConvertSurface(*surface, backbuffer->surface->format, 0);
 
+  if (new_surface == NULL)
+    Error(ERR_EXIT, "SDL_ConvertSurface() failed: %s", SDL_GetError());
+
   SDL_FreeSurface(*surface);
 
   *surface = new_surface;
@@ -207,22 +262,20 @@ boolean SDLSetNativeSurface(SDL_Surface **surface)
 
 SDL_Surface *SDLGetNativeSurface(SDL_Surface *surface)
 {
-  if (surface == NULL ||
-      backbuffer == NULL ||
-      backbuffer->surface == NULL)
+  SDL_Surface *new_surface;
+
+  if (surface == NULL)
     return NULL;
 
-  return SDL_ConvertSurface(surface, backbuffer->surface->format, 0);
-}
+  if (backbuffer && backbuffer->surface)
+    new_surface = SDL_ConvertSurface(surface, backbuffer->surface->format, 0);
+  else
+    new_surface = SDL_ConvertSurface(surface, surface->format, 0);
 
-SDL_Surface *SDL_DisplayFormat(SDL_Surface *surface)
-{
-  if (surface == NULL ||
-      backbuffer == NULL ||
-      backbuffer->surface == NULL)
-    return NULL;
+  if (new_surface == NULL)
+    Error(ERR_EXIT, "SDL_ConvertSurface() failed: %s", SDL_GetError());
 
-  return SDL_ConvertSurface(surface, backbuffer->surface->format, 0);
+  return new_surface;
 }
 
 #else
@@ -231,7 +284,9 @@ boolean SDLSetNativeSurface(SDL_Surface **surface)
 {
   SDL_Surface *new_surface;
 
-  if (surface == NULL)
+  if (surface == NULL ||
+      *surface == NULL ||
+      !video.initialized)
     return FALSE;
 
   new_surface = SDL_DisplayFormat(*surface);
@@ -248,16 +303,68 @@ boolean SDLSetNativeSurface(SDL_Surface **surface)
 
 SDL_Surface *SDLGetNativeSurface(SDL_Surface *surface)
 {
-  SDL_Surface *new_surface = SDL_DisplayFormat(surface);
+  SDL_Surface *new_surface;
+
+  if (video.initialized)
+    new_surface = SDL_DisplayFormat(surface);
+  else
+    new_surface = SDL_ConvertSurface(surface, surface->format, SURFACE_FLAGS);
 
   if (new_surface == NULL)
-    Error(ERR_EXIT, "SDL_DisplayFormat() failed: %s", SDL_GetError());
+    Error(ERR_EXIT, "%s() failed: %s",
+	  (video.initialized ? "SDL_DisplayFormat" : "SDL_ConvertSurface"),
+	  SDL_GetError());
 
   return new_surface;
 }
 
 #endif
 
+#if defined(TARGET_SDL2)
+static SDL_Texture *SDLCreateTextureFromSurface(SDL_Surface *surface)
+{
+  SDL_Texture *texture = SDL_CreateTextureFromSurface(sdl_renderer, surface);
+
+  if (texture == NULL)
+    Error(ERR_EXIT, "SDL_CreateTextureFromSurface() failed: %s",
+	  SDL_GetError());
+
+  return texture;
+}
+#endif
+
+void SDLCreateBitmapTextures(Bitmap *bitmap)
+{
+#if defined(TARGET_SDL2)
+  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);
+#endif
+}
+
+void SDLFreeBitmapTextures(Bitmap *bitmap)
+{
+#if defined(TARGET_SDL2)
+  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;
+#endif
+}
+
 void SDLInitVideoDisplay(void)
 {
 #if !defined(TARGET_SDL2)
@@ -444,7 +551,7 @@ void SDLInitVideoBuffer(DrawBuffer **backbuffer, DrawWindow **window,
 
   /* !!! SDL2 can only set the window icon if the window already exists !!! */
   /* set window icon */
-  SDLSetWindowIcon(program.sdl_icon_filename);
+  SDLSetWindowIcon(program.icon_filename);
 
   /* set window and icon title */
 #if defined(TARGET_SDL2)
@@ -476,7 +583,6 @@ static SDL_Surface *SDLCreateScreen(DrawBuffer **backbuffer,
   SDL_Surface *new_surface = NULL;
 
 #if defined(TARGET_SDL2)
-  static boolean fullscreen_enabled = FALSE;
   int surface_flags_window = SURFACE_FLAGS | SDL_WINDOW_RESIZABLE;
 #if USE_DESKTOP_FULLSCREEN
   int surface_flags_fullscreen = SURFACE_FLAGS | SDL_WINDOW_FULLSCREEN_DESKTOP;
@@ -500,9 +606,8 @@ static SDL_Surface *SDLCreateScreen(DrawBuffer **backbuffer,
 
 #if defined(TARGET_SDL2)
 
-  // store if initial screen mode on game start is fullscreen mode
-  if (sdl_window == NULL)
-    video.fullscreen_initial = fullscreen;
+  // store if initial screen mode is fullscreen mode when changing screen size
+  video.fullscreen_initial = fullscreen;
 
 #if USE_RENDERER
   float window_scaling_factor = (float)setup.window_scaling_percent / 100;
@@ -706,9 +811,12 @@ boolean SDLSetVideoMode(DrawBuffer **backbuffer, boolean fullscreen)
   SDLRedrawWindow();			// map window
 #endif
 
+#ifdef DEBUG
+#if defined(PLATFORM_WIN32)
+  // experimental drag and drop code
+
   SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);
 
-#if defined(PLATFORM_WIN32)
   {
     SDL_SysWMinfo wminfo;
     HWND hwnd;
@@ -733,6 +841,7 @@ boolean SDLSetVideoMode(DrawBuffer **backbuffer, boolean fullscreen)
       DragAcceptFiles(hwnd, TRUE);
     }
   }
+#endif
 #endif
 
   return success;
@@ -802,9 +911,9 @@ void SDLSetWindowFullscreen(boolean fullscreen)
 #endif
 
   if (SDL_SetWindowFullscreen(sdl_window, flags) == 0)
-    video.fullscreen_enabled = fullscreen;
+    video.fullscreen_enabled = fullscreen_enabled = fullscreen;
 
-  // if game started in fullscreen mode, window will also get fullscreen size
+  // if screen size was changed in fullscreen mode, correct desktop window size
   if (!fullscreen && video.fullscreen_initial)
   {
     SDLSetWindowScaling(setup.window_scaling_percent);
@@ -841,8 +950,19 @@ void SDLFreeBitmapPointers(Bitmap *bitmap)
     SDL_FreeSurface(bitmap->surface);
   if (bitmap->surface_masked)
     SDL_FreeSurface(bitmap->surface_masked);
+
   bitmap->surface = NULL;
   bitmap->surface_masked = NULL;
+
+#if defined(TARGET_SDL2)
+  if (bitmap->texture)
+    SDL_DestroyTexture(bitmap->texture);
+  if (bitmap->texture_masked)
+    SDL_DestroyTexture(bitmap->texture_masked);
+
+  bitmap->texture = NULL;
+  bitmap->texture_masked = NULL;
+#endif
 }
 
 void SDLCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
@@ -896,6 +1016,37 @@ void SDLCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 #endif
 }
 
+void SDLBlitTexture(Bitmap *bitmap,
+		    int src_x, int src_y, int width, int height,
+		    int dst_x, int dst_y, int mask_mode)
+{
+#if defined(TARGET_SDL2)
+#if USE_RENDERER
+  SDL_Texture *texture;
+  SDL_Rect src_rect;
+  SDL_Rect dst_rect;
+
+  texture =
+    (mask_mode == BLIT_MASKED ? bitmap->texture_masked : bitmap->texture);
+
+  if (texture == NULL)
+    return;
+
+  src_rect.x = src_x;
+  src_rect.y = src_y;
+  src_rect.w = width;
+  src_rect.h = height;
+
+  dst_rect.x = dst_x;
+  dst_rect.y = dst_y;
+  dst_rect.w = width;
+  dst_rect.h = height;
+
+  SDL_RenderCopy(sdl_renderer, texture, &src_rect, &dst_rect);
+#endif
+#endif
+}
+
 void SDLFillRectangle(Bitmap *dst_bitmap, int x, int y, int width, int height,
 		      Uint32 color)
 {
@@ -1167,18 +1318,69 @@ void SDLFadeRectangle(Bitmap *bitmap_cross, int x, int y, int width, int height,
 	if (draw_border_function != NULL)
 	  draw_border_function();
 
-#if defined(TARGET_SDL2)
-	// SDL_UpdateWindowSurface(sdl_window);
-	// SDL_UpdateWindowSurfaceRects(sdl_window, &dst_rect2, 1);
 	UpdateScreen(&dst_rect2);
+      }
+    }
+  }
+  else if (fade_mode == FADE_MODE_CURTAIN)
+  {
+    float xx;
+    int xx_final;
+    int xx_size = width / 2;
+
+    SDL_BlitSurface(surface_target, &src_rect, surface_screen, &dst_rect);
+#if defined(TARGET_SDL2)
+    SDL_SetSurfaceBlendMode(surface_source, SDL_BLENDMODE_NONE);
 #else
-	// SDL_UpdateRect(surface_screen, dst_x, dst_y, width, height);
-	UpdateScreen(&dst_rect2);
+    SDL_SetAlpha(surface_source, 0, 0);		/* disable alpha blending */
 #endif
+
+    for (xx = 0; xx < xx_size;)
+    {
+      time_last = time_current;
+      time_current = SDL_GetTicks();
+      xx += xx_size * ((float)(time_current - time_last) / fade_delay);
+      xx_final = MIN(MAX(0, xx), xx_size);
+
+      src_rect.x = src_x;
+      src_rect.y = src_y;
+      src_rect.w = width;
+      src_rect.h = height;
+
+      dst_rect.x = dst_x;
+      dst_rect.y = dst_y;
+
+      /* draw new (target) image to screen buffer */
+      SDL_BlitSurface(surface_target, &src_rect, surface_screen, &dst_rect);
+
+      if (xx_final < xx_size)
+      {
+	src_rect.w = xx_size - xx_final;
+	src_rect.h = height;
+
+	/* draw old (source) image to screen buffer (left side) */
+
+	src_rect.x = src_x + xx_final;
+	dst_rect.x = dst_x;
+
+	SDL_BlitSurface(surface_source, &src_rect, surface_screen, &dst_rect);
+
+	/* draw old (source) image to screen buffer (right side) */
+
+	src_rect.x = src_x + xx_size;
+	dst_rect.x = dst_x + xx_size + xx_final;
+
+	SDL_BlitSurface(surface_source, &src_rect, surface_screen, &dst_rect);
       }
+
+      if (draw_border_function != NULL)
+	draw_border_function();
+
+      /* only update the region of the screen that is affected from fading */
+      UpdateScreen(&dst_rect2);
     }
   }
-  else
+  else		/* fading in, fading out or cross-fading */
   {
     float alpha;
     int alpha_final;
@@ -1210,7 +1412,24 @@ void SDLFadeRectangle(Bitmap *bitmap_cross, int x, int y, int width, int height,
     }
   }
 
-  Delay(post_delay);
+  if (post_delay > 0)
+  {
+    unsigned int time_post_delay;
+
+    time_current = SDL_GetTicks();
+    time_post_delay = time_current + post_delay;
+
+    while (time_current < time_post_delay)
+    {
+      // do not wait longer than 10 ms at a time to be able to ...
+      Delay(MIN(10, time_post_delay - time_current));
+
+      // ... continue drawing global animations during post delay
+      UpdateScreen(NULL);
+
+      time_current = SDL_GetTicks();
+    }
+  }
 }
 
 void SDLDrawSimpleLine(Bitmap *dst_bitmap, int from_x, int from_y,
@@ -2363,7 +2582,10 @@ void SDLNextEvent(Event *event)
 
 void SDLHandleWindowManagerEvent(Event *event)
 {
+#ifdef DEBUG
 #if defined(PLATFORM_WIN32)
+  // experimental drag and drop code
+
   SDL_SysWMEvent *syswmevent = (SDL_SysWMEvent *)event;
   SDL_SysWMmsg *syswmmsg = (SDL_SysWMmsg *)(syswmevent->msg);
 
@@ -2401,6 +2623,7 @@ void SDLHandleWindowManagerEvent(Event *event)
 #endif
   }
 #endif
+#endif
 }