X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fsystem.c;h=dce2b888943693f787fb882b19dd4a20dd9413e3;hb=97baecdfcf386d972f6f8e6eec9ddfd3021ed7ed;hp=09c804f06a4a3f6687266356e41b9d4672ffdbf8;hpb=4231c290a878b5fb95bffdf78b5486359ce1268f;p=rocksndiamonds.git

diff --git a/src/libgame/system.c b/src/libgame/system.c
index 09c804f0..dce2b888 100644
--- a/src/libgame/system.c
+++ b/src/libgame/system.c
@@ -166,8 +166,10 @@ void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize,
 
   gfx.field_save_buffer = field_save_buffer;
 
+#if 0
   gfx.background_bitmap = NULL;
   gfx.background_bitmap_mask = REDRAW_NONE;
+#endif
 
   SetDrawDeactivationMask(REDRAW_NONE);		/* do not deactivate drawing */
   SetDrawBackgroundMask(REDRAW_NONE);		/* deactivate masked drawing */
@@ -189,13 +191,49 @@ void InitGfxDoor2Info(int vx, int vy, int vxsize, int vysize)
   gfx.vysize = vysize;
 }
 
+void InitGfxWindowInfo(int win_xsize, int win_ysize)
+{
+  gfx.win_xsize = win_xsize;
+  gfx.win_ysize = win_ysize;
+
+#if 1
+  gfx.background_bitmap_mask = REDRAW_NONE;
+
+  ReCreateBitmap(&gfx.background_bitmap, win_xsize, win_ysize, DEFAULT_DEPTH);
+#endif
+}
+
 void InitGfxScrollbufferInfo(int scrollbuffer_width, int scrollbuffer_height)
 {
   /* currently only used by MSDOS code to alloc VRAM buffer, if available */
+  /* 2009-03-24: also (temporarily?) used for overlapping blit workaround */
   gfx.scrollbuffer_width = scrollbuffer_width;
   gfx.scrollbuffer_height = scrollbuffer_height;
 }
 
+void InitGfxClipRegion(boolean enabled, int x, int y, int width, int height)
+{
+  gfx.clipping_enabled = enabled;
+  gfx.clip_x = x;
+  gfx.clip_y = y;
+  gfx.clip_width = width;
+  gfx.clip_height = height;
+}
+
+void InitGfxDrawBusyAnimFunction(void (*draw_busy_anim_function)(void))
+{
+  gfx.draw_busy_anim_function = draw_busy_anim_function;
+}
+
+void InitGfxCustomArtworkInfo()
+{
+  gfx.override_level_graphics = FALSE;
+  gfx.override_level_sounds = FALSE;
+  gfx.override_level_music = FALSE;
+
+  gfx.draw_init_text = TRUE;
+}
+
 void SetDrawDeactivationMask(int draw_deactivation_mask)
 {
   gfx.draw_deactivation_mask = draw_deactivation_mask;
@@ -206,6 +244,8 @@ void SetDrawBackgroundMask(int draw_background_mask)
   gfx.draw_background_mask = draw_background_mask;
 }
 
+#if 0
+
 static void DrawBitmapFromTile(Bitmap *bitmap, Bitmap *tile,
 			       int dest_x, int dest_y, int width, int height)
 {
@@ -238,9 +278,11 @@ void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
   else
     gfx.background_bitmap_mask &= ~mask;
 
+#if 0
   if (gfx.background_bitmap == NULL)
     gfx.background_bitmap = CreateBitmap(video.width, video.height,
 					 DEFAULT_DEPTH);
+#endif
 
   if (background_bitmap_tile == NULL)	/* empty background requested */
     return;
@@ -260,19 +302,59 @@ void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
   }
 }
 
+#else
+
+void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
+{
+  if (background_bitmap_tile != NULL)
+    gfx.background_bitmap_mask |= mask;
+  else
+    gfx.background_bitmap_mask &= ~mask;
+
+#if 0
+  if (gfx.background_bitmap == NULL)
+    gfx.background_bitmap = CreateBitmap(video.width, video.height,
+					 DEFAULT_DEPTH);
+#endif
+
+  if (background_bitmap_tile == NULL)	/* empty background requested */
+    return;
+
+  if (mask == REDRAW_ALL)
+    BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
+		    0, 0, video.width, video.height);
+  else if (mask == REDRAW_FIELD)
+    BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
+		    gfx.real_sx, gfx.real_sy, gfx.full_sxsize, gfx.full_sysize);
+  else if (mask == REDRAW_DOOR_1)
+  {
+    BlitBitmapTiled(background_bitmap_tile, gfx.background_bitmap, 0, 0, 0, 0,
+		    gfx.dx, gfx.dy, gfx.dxsize, gfx.dysize);
+  }
+}
+
+#endif
+
 void SetWindowBackgroundBitmap(Bitmap *background_bitmap_tile)
 {
+  /* remove every mask before setting mask for window */
+  /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
+  SetBackgroundBitmap(NULL, 0xffff);		/* !!! FIX THIS !!! */
   SetBackgroundBitmap(background_bitmap_tile, REDRAW_ALL);
 }
 
 void SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
 {
+  /* remove window area mask before setting mask for main area */
+  /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
   SetBackgroundBitmap(NULL, REDRAW_ALL);	/* !!! FIX THIS !!! */
   SetBackgroundBitmap(background_bitmap_tile, REDRAW_FIELD);
 }
 
 void SetDoorBackgroundBitmap(Bitmap *background_bitmap_tile)
 {
+  /* remove window area mask before setting mask for door area */
+  /* (!!! TO BE FIXED: The whole REDRAW_* system really sucks! !!!) */
   SetBackgroundBitmap(NULL, REDRAW_ALL);	/* !!! FIX THIS !!! */
   SetBackgroundBitmap(background_bitmap_tile, REDRAW_DOOR_1);
 }
@@ -339,8 +421,10 @@ void InitVideoBuffer(int width, int height, int depth, boolean fullscreen)
 
   video.fullscreen_available = FULLSCREEN_STATUS;
   video.fullscreen_enabled = FALSE;
-  video.fullscreen_modes = NULL;
+#if 0
   video.fullscreen_mode_current = NULL;
+  video.fullscreen_modes = NULL;
+#endif
 
 #if defined(TARGET_SDL)
   SDLInitVideoBuffer(&backbuffer, &window, fullscreen);
@@ -351,32 +435,6 @@ void InitVideoBuffer(int width, int height, int depth, boolean fullscreen)
   drawto = backbuffer;
 }
 
-Bitmap *CreateBitmapStruct(void)
-{
-#if defined(TARGET_SDL)
-  return checked_calloc(sizeof(struct SDLSurfaceInfo));
-#else
-  return checked_calloc(sizeof(struct X11DrawableInfo));
-#endif
-}
-
-Bitmap *CreateBitmap(int width, int height, int depth)
-{
-  Bitmap *new_bitmap = CreateBitmapStruct();
-  int real_depth = GetRealDepth(depth);
-
-#if defined(TARGET_SDL)
-  SDLCreateBitmapContent(new_bitmap, width, height, real_depth);
-#else
-  X11CreateBitmapContent(new_bitmap, width, height, real_depth);
-#endif
-
-  new_bitmap->width = width;
-  new_bitmap->height = height;
-
-  return new_bitmap;
-}
-
 inline static void FreeBitmapPointers(Bitmap *bitmap)
 {
   if (bitmap == NULL)
@@ -413,16 +471,53 @@ void FreeBitmap(Bitmap *bitmap)
   free(bitmap);
 }
 
-void CloseWindow(DrawWindow *window)
+Bitmap *CreateBitmapStruct(void)
 {
-#if defined(TARGET_X11)
-  if (window->drawable)
+#if defined(TARGET_SDL)
+  return checked_calloc(sizeof(struct SDLSurfaceInfo));
+#else
+  return checked_calloc(sizeof(struct X11DrawableInfo));
+#endif
+}
+
+Bitmap *CreateBitmap(int width, int height, int depth)
+{
+  Bitmap *new_bitmap = CreateBitmapStruct();
+  int real_width  = MAX(1, width);	/* prevent zero bitmap width */
+  int real_height = MAX(1, height);	/* prevent zero bitmap height */
+  int real_depth  = GetRealDepth(depth);
+
+#if defined(TARGET_SDL)
+  SDLCreateBitmapContent(new_bitmap, real_width, real_height, real_depth);
+#else
+  X11CreateBitmapContent(new_bitmap, real_width, real_height, real_depth);
+#endif
+
+  new_bitmap->width  = real_width;
+  new_bitmap->height = real_height;
+
+  return new_bitmap;
+}
+
+void ReCreateBitmap(Bitmap **bitmap, int width, int height, int depth)
+{
+  Bitmap *new_bitmap = CreateBitmap(width, height, depth);
+
+  if (*bitmap == NULL)
+  {
+    *bitmap = new_bitmap;
+  }
+  else
   {
-    XUnmapWindow(display, window->drawable);
-    XDestroyWindow(display, window->drawable);
+    TransferBitmapPointers(new_bitmap, *bitmap);
+    free(new_bitmap);
   }
-  if (window->gc)
-    XFreeGC(display, window->gc);
+}
+
+void CloseWindow(DrawWindow *window)
+{
+#if defined(TARGET_X11)
+  X11CloseWindow(window);
 #endif
 }
 
@@ -461,21 +556,233 @@ boolean DrawingOnBackground(int x, int y)
 	  CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
 }
 
+static boolean InClippedRectangle(Bitmap *bitmap, int *x, int *y,
+				  int *width, int *height, boolean is_dest)
+{
+#if 1
+  int clip_x, clip_y, clip_width, clip_height;
+
+  if (gfx.clipping_enabled && is_dest)	/* only clip destination bitmap */
+  {
+    clip_x = MIN(MAX(0, gfx.clip_x), bitmap->width);
+    clip_y = MIN(MAX(0, gfx.clip_y), bitmap->height);
+    clip_width = MIN(MAX(0, gfx.clip_width), bitmap->width - clip_x);
+    clip_height = MIN(MAX(0, gfx.clip_height), bitmap->height - clip_y);
+  }
+  else
+  {
+    clip_x = 0;
+    clip_y = 0;
+    clip_width = bitmap->width;
+    clip_height = bitmap->height;
+  }
+
+  /* skip if rectangle completely outside bitmap */
+
+  if (*x + *width  <= clip_x ||
+      *y + *height <= clip_y ||
+      *x >= clip_x + clip_width ||
+      *y >= clip_y + clip_height)
+    return FALSE;
+
+  /* clip if rectangle overlaps bitmap */
+
+  if (*x < clip_x)
+  {
+    *width -= clip_x - *x;
+    *x = clip_x;
+  }
+  else if (*x + *width > clip_x + clip_width)
+  {
+    *width = clip_x + clip_width - *x;
+  }
+
+  if (*y < clip_y)
+  {
+    *height -= clip_y - *y;
+    *y = clip_y;
+  }
+  else if (*y + *height > clip_y + clip_height)
+  {
+    *height = clip_y + clip_height - *y;
+  }
+
+  return TRUE;
+
+#else
+
+  /* skip if rectangle completely outside bitmap */
+
+  if (*x + *width <= 0 ||
+      *y + *height <= 0 ||
+      *x >= bitmap->width ||
+      *y >= bitmap->height)
+    return FALSE;
+
+  /* clip if rectangle overlaps bitmap */
+
+  if (*x < 0)
+  {
+    *width += *x;
+    *x = 0;
+  }
+  else if (*x + *width > bitmap->width)
+  {
+    *width = bitmap->width - *x;
+  }
+
+  if (*y < 0)
+  {
+    *height += *y;
+    *y = 0;
+  }
+  else if (*y + *height > bitmap->height)
+  {
+    *height = bitmap->height - *y;
+  }
+
+  return TRUE;
+#endif
+}
+
 void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
 		int src_x, int src_y, int width, int height,
 		int dst_x, int dst_y)
 {
+  int dst_x_unclipped = dst_x;
+  int dst_y_unclipped = dst_y;
+
   if (DrawingDeactivated(dst_x, dst_y, width, height))
     return;
 
-  sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
-	      dst_x, dst_y, BLIT_OPAQUE);
+#if 1
+  if (!InClippedRectangle(src_bitmap, &src_x, &src_y, &width, &height, FALSE) ||
+      !InClippedRectangle(dst_bitmap, &dst_x, &dst_y, &width, &height, TRUE))
+    return;
+
+  /* source x/y might need adjustment if destination x/y was clipped top/left */
+  src_x += dst_x - dst_x_unclipped;
+  src_y += dst_y - dst_y_unclipped;
+
+#else
+  /* skip if rectangle starts outside bitmap */
+  if (src_x >= src_bitmap->width ||
+      src_y >= src_bitmap->height ||
+      dst_x >= dst_bitmap->width ||
+      dst_y >= dst_bitmap->height)
+    return;
+
+  /* clip if rectangle overlaps bitmap */
+  if (src_x + width > src_bitmap->width)
+    width = src_bitmap->width - src_x;
+  if (src_y + height > src_bitmap->height)
+    height = src_bitmap->height - src_y;
+  if (dst_x + width > dst_bitmap->width)
+    width = dst_bitmap->width - dst_x;
+  if (dst_y + height > dst_bitmap->height)
+    height = dst_bitmap->height - dst_y;
+#endif
+
+#if 0
+  /* !!! 2009-03-30: Fixed by using self-compiled, patched SDL.dll !!! */
+  /* (This bug still exists in the actual (as of 2009-06-15) version 1.2.13,
+     but is already fixed in SVN and should therefore finally be fixed with
+     the next official SDL release, which is probably version 1.2.14.) */
+#if 1
+  /* !!! 2009-03-24: It seems that this problem still exists in 1.2.12 !!! */
+#if defined(TARGET_SDL) && defined(PLATFORM_WIN32)
+  if (src_bitmap == dst_bitmap)
+  {
+    /* !!! THIS IS A BUG (IN THE SDL LIBRARY?) AND SHOULD BE FIXED !!! */
+
+    /* needed when blitting directly to same bitmap -- should not be needed with
+       recent SDL libraries, but apparently does not work in 1.2.11 directly */
+
+    static Bitmap *tmp_bitmap = NULL;
+    static int tmp_bitmap_xsize = 0;
+    static int tmp_bitmap_ysize = 0;
+
+    /* start with largest static bitmaps for initial bitmap size ... */
+    if (tmp_bitmap_xsize == 0 && tmp_bitmap_ysize == 0)
+    {
+      tmp_bitmap_xsize = MAX(gfx.win_xsize, gfx.scrollbuffer_width);
+      tmp_bitmap_ysize = MAX(gfx.win_ysize, gfx.scrollbuffer_height);
+    }
+
+    /* ... and allow for later re-adjustments due to custom artwork bitmaps */
+    if (src_bitmap->width > tmp_bitmap_xsize ||
+	src_bitmap->height > tmp_bitmap_ysize)
+    {
+      tmp_bitmap_xsize = MAX(tmp_bitmap_xsize, src_bitmap->width);
+      tmp_bitmap_ysize = MAX(tmp_bitmap_ysize, src_bitmap->height);
+
+      FreeBitmap(tmp_bitmap);
+
+      tmp_bitmap = NULL;
+    }
+
+    if (tmp_bitmap == NULL)
+      tmp_bitmap = CreateBitmap(tmp_bitmap_xsize, tmp_bitmap_ysize,
+				DEFAULT_DEPTH);
+
+    sysCopyArea(src_bitmap, tmp_bitmap,
+		src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
+    sysCopyArea(tmp_bitmap, dst_bitmap,
+		dst_x, dst_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
+
+    return;
+  }
+#endif
+#endif
+#endif
+
+#if 0
+  if (dst_x < gfx.sx + gfx.sxsize)
+    printf("::: %d: BlitBitmap(%d, %d, %d, %d)\n",
+	   FrameCounter, dst_x, dst_y, width, height);
+#endif
+
+  sysCopyArea(src_bitmap, dst_bitmap,
+	      src_x, src_y, width, height, dst_x, dst_y, BLIT_OPAQUE);
+}
+
+void BlitBitmapTiled(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+		     int src_x, int src_y, int src_width, int src_height,
+		     int dst_x, int dst_y, int dst_width, int dst_height)
+{
+  int src_xsize = (src_width  == 0 ? src_bitmap->width  : src_width);
+  int src_ysize = (src_height == 0 ? src_bitmap->height : src_height);
+  int dst_xsize = dst_width;
+  int dst_ysize = dst_height;
+  int src_xsteps = (dst_xsize + src_xsize - 1) / src_xsize;
+  int src_ysteps = (dst_ysize + src_ysize - 1) / src_ysize;
+  int x, y;
+
+  for (y = 0; y < src_ysteps; y++)
+  {
+    for (x = 0; x < src_xsteps; x++)
+    {
+      int draw_x = dst_x + x * src_xsize;
+      int draw_y = dst_y + y * src_ysize;
+      int draw_xsize = MIN(src_xsize, dst_xsize - x * src_xsize);
+      int draw_ysize = MIN(src_ysize, dst_ysize - y * src_ysize);
+
+      BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, draw_xsize, draw_ysize,
+		 draw_x, draw_y);
+    }
+  }
 }
 
 void FadeRectangle(Bitmap *bitmap_cross, int x, int y, int width, int height,
 		   int fade_mode, int fade_delay, int post_delay,
 		   void (*draw_border_function)(void))
 {
+#if 1
+  /* (use destination bitmap "backbuffer" -- "bitmap_cross" may be undefined) */
+  if (!InClippedRectangle(backbuffer, &x, &y, &width, &height, TRUE))
+    return;
+#endif
+
 #if defined(TARGET_SDL)
   SDLFadeRectangle(bitmap_cross, x, y, width, height,
 		   fade_mode, fade_delay, post_delay, draw_border_function);
@@ -491,6 +798,22 @@ void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
   if (DrawingDeactivated(x, y, width, height))
     return;
 
+#if 1
+  if (!InClippedRectangle(bitmap, &x, &y, &width, &height, TRUE))
+    return;
+#else
+  /* skip if rectangle starts outside bitmap */
+  if (x >= bitmap->width ||
+      y >= bitmap->height)
+    return;
+
+  /* clip if rectangle overlaps bitmap */
+  if (x + width > bitmap->width)
+    width = bitmap->width - x;
+  if (y + height > bitmap->height)
+    height = bitmap->height - y;
+#endif
+
   sysFillRectangle(bitmap, x, y, width, height, color);
 }
 
@@ -839,13 +1162,10 @@ Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
   return dst_bitmap;
 }
 
-#define MORE_ZOOM	1
-
 static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
 				boolean create_small_bitmaps)
 {
   Bitmap swap_bitmap;
-#if MORE_ZOOM
   Bitmap *new_bitmap;
   Bitmap *tmp_bitmap_1;
   Bitmap *tmp_bitmap_2;
@@ -859,10 +1179,6 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
   int width_8, height_8;
   int width_16, height_16;
   int width_32, height_32;
-#else
-  Bitmap *new_bitmap, *tmp_bitmap_1, *tmp_bitmap_2, *tmp_bitmap_4,*tmp_bitmap_8;
-  int width_1, height_1, width_2, height_2, width_4, height_4, width_8,height_8;
-#endif
   int new_width, new_height;
 
   /* calculate new image dimensions for normal sized image */
@@ -876,12 +1192,11 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
     tmp_bitmap_1 = old_bitmap;
 
   /* this is only needed to make compilers happy */
-#if MORE_ZOOM
-  tmp_bitmap_2 = tmp_bitmap_4 = tmp_bitmap_8 = tmp_bitmap_16 = NULL;
+  tmp_bitmap_2 = NULL;
+  tmp_bitmap_4 = NULL;
+  tmp_bitmap_8 = NULL;
+  tmp_bitmap_16 = NULL;
   tmp_bitmap_32 = NULL;
-#else
-  tmp_bitmap_2 = tmp_bitmap_4 = tmp_bitmap_8 = NULL;
-#endif
 
   if (create_small_bitmaps)
   {
@@ -892,12 +1207,12 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
     height_4 = height_1 / 4;
     width_8  = width_1  / 8;
     height_8 = height_1 / 8;
-#if MORE_ZOOM
     width_16  = width_1  / 16;
     height_16 = height_1 / 16;
     width_32  = width_1  / 32;
     height_32 = height_1 / 32;
-#endif
+
+    UPDATE_BUSY_STATE();
 
     /* get image with 1/2 of normal size (for use in the level editor) */
     if (zoom_factor != 2)
@@ -905,33 +1220,42 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
     else
       tmp_bitmap_2 = old_bitmap;
 
+    UPDATE_BUSY_STATE();
+
     /* get image with 1/4 of normal size (for use in the level editor) */
     if (zoom_factor != 4)
       tmp_bitmap_4 = ZoomBitmap(tmp_bitmap_2, width_2 / 2, height_2 / 2);
     else
       tmp_bitmap_4 = old_bitmap;
 
+    UPDATE_BUSY_STATE();
+
     /* get image with 1/8 of normal size (for use on the preview screen) */
     if (zoom_factor != 8)
       tmp_bitmap_8 = ZoomBitmap(tmp_bitmap_4, width_4 / 2, height_4 / 2);
     else
       tmp_bitmap_8 = old_bitmap;
 
-#if MORE_ZOOM
+    UPDATE_BUSY_STATE();
+
     /* get image with 1/16 of normal size (for use on the preview screen) */
     if (zoom_factor != 16)
       tmp_bitmap_16 = ZoomBitmap(tmp_bitmap_8, width_8 / 2, height_8 / 2);
     else
       tmp_bitmap_16 = old_bitmap;
 
+    UPDATE_BUSY_STATE();
+
     /* get image with 1/32 of normal size (for use on the preview screen) */
     if (zoom_factor != 32)
       tmp_bitmap_32 = ZoomBitmap(tmp_bitmap_16, width_16 / 2, height_16 / 2);
     else
       tmp_bitmap_32 = old_bitmap;
-#endif
+
+    UPDATE_BUSY_STATE();
   }
 
+#if 0
   /* if image was scaled up, create new clipmask for normal size image */
   if (zoom_factor != 1)
   {
@@ -956,6 +1280,7 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
     SDL_SetColorKey(tmp_surface_1, 0, 0);	/* reset transparent pixel */
 #endif
   }
+#endif
 
   if (create_small_bitmaps)
   {
@@ -971,12 +1296,12 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
 	       width_1 / 2, height_1);
     BlitBitmap(tmp_bitmap_8, new_bitmap, 0, 0, width_1 / 8, height_1 / 8,
 	       3 * width_1 / 4, height_1);
-#if MORE_ZOOM
     BlitBitmap(tmp_bitmap_16, new_bitmap, 0, 0, width_1 / 16, height_1 / 16,
 	       7 * width_1 / 8, height_1);
     BlitBitmap(tmp_bitmap_32, new_bitmap, 0, 0, width_1 / 32, height_1 / 32,
 	       15 * width_1 / 16, height_1);
-#endif
+
+    UPDATE_BUSY_STATE();
   }
   else
   {
@@ -1001,12 +1326,11 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
     if (zoom_factor != 8)
       FreeBitmap(tmp_bitmap_8);
 
-#if MORE_ZOOM
     if (zoom_factor != 16)
       FreeBitmap(tmp_bitmap_16);
+
     if (zoom_factor != 32)
       FreeBitmap(tmp_bitmap_32);
-#endif
   }
 
   /* replace image with extended image (containing 1/1, 1/2, 1/4, 1/8 size) */
@@ -1024,7 +1348,7 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
   old_bitmap->height = new_bitmap->height;
 
 #if 1
-  /* !!! THIS URGENTLY NEEDS OPTIMIZATION -- DO NOT CREATE MASKS BEFORE !!! */
+  /* this replaces all blit masks created when loading -- maybe optimize this */
   {
 #if defined(TARGET_X11)
     if (old_bitmap->clip_mask)
@@ -1049,6 +1373,8 @@ static void CreateScaledBitmaps(Bitmap *old_bitmap, int zoom_factor,
   }
 #endif
 
+  UPDATE_BUSY_STATE();
+
   FreeBitmap(new_bitmap);	/* this actually frees the _old_ bitmap now */
 }