X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Ftext.c;h=d00151646f6c51d96b6c8abe29b0f1995ec04549;hb=9ec014a4e4a6a2332bb45c6cea8cccc46c64c6ae;hp=16381e494438e8872531972fb045c6eb1a884a76;hpb=c9433eab5c4317ed4f89164b386a7d33562e29be;p=rocksndiamonds.git

diff --git a/src/libgame/text.c b/src/libgame/text.c
index 16381e49..d0015164 100644
--- a/src/libgame/text.c
+++ b/src/libgame/text.c
@@ -15,73 +15,154 @@
 #include <stdarg.h>
 
 #include "text.h"
+#include "misc.h"
 
 
 /* ========================================================================= */
-/* exported variables                                                        */
+/* font functions                                                            */
 /* ========================================================================= */
 
-struct FontInfo		font;
+#define NUM_FONT_CHARS		(FONT_LINES_PER_FONT * FONT_CHARS_PER_LINE)
 
+#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
+static GC	font_clip_gc = None;
 
-/* ========================================================================= */
-/* font functions                                                            */
-/* ========================================================================= */
+static void InitFontClipmasks()
+{
+  static boolean clipmasks_initialized = FALSE;
+  XGCValues clip_gc_values;
+  unsigned long clip_gc_valuemask;
+  GC copy_clipmask_gc;
+  int i, j;
+
+  if (gfx.num_fonts == 0 || gfx.font_bitmap_info[0].bitmap == NULL)
+    return;
+
+  if (!clipmasks_initialized)
+  {
+    for (i=0; i < gfx.num_fonts; i++)
+      gfx.font_bitmap_info[i].clip_mask = NULL;
+
+    clipmasks_initialized = TRUE;
+  }
+
+  for (i=0; i < gfx.num_fonts; i++)
+  {
+    if (gfx.font_bitmap_info[i].clip_mask)
+      for (j=0; j < NUM_FONT_CHARS; j++)
+	XFreePixmap(display, gfx.font_bitmap_info[i].clip_mask[j]);
+    free(gfx.font_bitmap_info[i].clip_mask);
+
+    gfx.font_bitmap_info[i].clip_mask = NULL;
+  }
+
+  if (font_clip_gc)
+    XFreeGC(display, font_clip_gc);
+  font_clip_gc = None;
+
+  /* This stuff is needed because X11 (XSetClipOrigin(), to be precise) is
+     often very slow when preparing a masked XCopyArea() for big Pixmaps.
+     To prevent this, create small (tile-sized) mask Pixmaps which will then
+     be set much faster with XSetClipOrigin() and speed things up a lot. */
+
+  clip_gc_values.graphics_exposures = False;
+  clip_gc_valuemask = GCGraphicsExposures;
+  font_clip_gc = XCreateGC(display, window->drawable,
+			   clip_gc_valuemask, &clip_gc_values);
+
+  /* create graphic context structures needed for clipping */
+  clip_gc_values.graphics_exposures = False;
+  clip_gc_valuemask = GCGraphicsExposures;
+  copy_clipmask_gc = XCreateGC(display,
+			       gfx.font_bitmap_info[0].bitmap->clip_mask,
+			       clip_gc_valuemask, &clip_gc_values);
+
+  /* create only those clipping Pixmaps we really need */
+  for (i=0; i < gfx.num_fonts; i++)
+  {
+    if (gfx.font_bitmap_info[i].bitmap == NULL)
+      continue;
+
+    gfx.font_bitmap_info[i].clip_mask =
+      checked_calloc(NUM_FONT_CHARS * sizeof(Pixmap));
 
-void InitFontInfo(Bitmap *bitmap_big, Bitmap *bitmap_medium,
-		  Bitmap *bitmap_small)
+    for (j=0; j < NUM_FONT_CHARS; j++)
+    {
+      Bitmap *src_bitmap = gfx.font_bitmap_info[i].bitmap;
+      Pixmap src_pixmap = src_bitmap->clip_mask;
+      int xpos = j % FONT_CHARS_PER_LINE;
+      int ypos = j / FONT_CHARS_PER_LINE;
+      int width  = gfx.font_bitmap_info[i].width;
+      int height = gfx.font_bitmap_info[i].height;
+      int src_x = gfx.font_bitmap_info[i].src_x + xpos * width;
+      int src_y = gfx.font_bitmap_info[i].src_y + ypos * height;
+
+      gfx.font_bitmap_info[i].clip_mask[j] =
+	XCreatePixmap(display, window->drawable, width, height, 1);
+
+      XCopyArea(display, src_pixmap, gfx.font_bitmap_info[i].clip_mask[j],
+		copy_clipmask_gc, src_x, src_y, width, height, 0, 0);
+    }
+  }
+
+  XFreeGC(display, copy_clipmask_gc);
+}
+#endif /* TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND */
+
+void InitFontInfo(struct FontBitmapInfo *font_bitmap_info, int num_fonts,
+		  int (*select_font_function)(int))
 {
-  font.bitmap_big = bitmap_big;
-  font.bitmap_medium = bitmap_medium;
-  font.bitmap_small = bitmap_small;
+  gfx.num_fonts = num_fonts;
+  gfx.font_bitmap_info = font_bitmap_info;
+  gfx.select_font_function = select_font_function;
+
+#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
+  InitFontClipmasks();
+#endif
 }
 
-int getFontWidth(int font_size, int font_type)
+int getFontWidth(int font_nr)
 {
-  return (font_size == FS_BIG ? FONT1_XSIZE :
-	  font_size == FS_MEDIUM ? FONT6_XSIZE :
-	  font_type == FC_SPECIAL1 ? FONT3_XSIZE :
-	  font_type == FC_SPECIAL2 ? FONT4_XSIZE :
-	  font_type == FC_SPECIAL3 ? FONT5_XSIZE :
-	  FONT2_XSIZE);
+  return gfx.font_bitmap_info[font_nr].width;
 }
 
-int getFontHeight(int font_size, int font_type)
+int getFontHeight(int font_nr)
 {
-  return (font_size == FS_BIG ? FONT1_YSIZE :
-	  font_size == FS_MEDIUM ? FONT6_YSIZE :
-	  font_type == FC_SPECIAL1 ? FONT3_YSIZE :
-	  font_type == FC_SPECIAL2 ? FONT4_YSIZE :
-	  font_type == FC_SPECIAL3 ? FONT5_YSIZE :
-	  FONT2_YSIZE);
+  return gfx.font_bitmap_info[font_nr].height;
 }
 
-void DrawInitText(char *text, int ypos, int color)
+void DrawInitText(char *text, int ypos, int font_nr)
 {
-  if (window && font.bitmap_small)
+  if (window &&
+      gfx.num_fonts > 0 &&
+      gfx.font_bitmap_info[font_nr].bitmap != NULL)
   {
-    ClearRectangle(window, 0, ypos, video.width, FONT2_YSIZE);
-    DrawTextExt(window, (video.width - strlen(text) * FONT2_XSIZE)/2,
-		ypos, text, FS_SMALL, color);
+    int text_width = strlen(text) * getFontWidth(font_nr);
+
+    ClearRectangle(window, 0, ypos, video.width, getFontHeight(font_nr));
+    DrawTextExt(window, (video.width - text_width) / 2, ypos, text, font_nr,
+		FONT_OPAQUE);
     FlushDisplay();
   }
 }
 
-void DrawTextFCentered(int y, int font_type, char *format, ...)
+void DrawTextFCentered(int y, int font_nr, char *format, ...)
 {
   char buffer[MAX_OUTPUT_LINESIZE + 1];
-  int font_width = getFontWidth(FS_SMALL, font_type);
   va_list ap;
 
   va_start(ap, format);
   vsprintf(buffer, format, ap);
   va_end(ap);
 
-  DrawText(gfx.sx + (gfx.sxsize - strlen(buffer) * font_width) / 2,
-	   gfx.sy + y, buffer, FS_SMALL, font_type);
+  if (strlen(buffer) > MAX_OUTPUT_LINESIZE)
+    Error(ERR_EXIT, "string too long in DrawTextFCentered() -- aborting");
+
+  DrawText(gfx.sx + (gfx.sxsize - strlen(buffer) * getFontWidth(font_nr)) / 2,
+	   gfx.sy + y, buffer, font_nr);
 }
 
-void DrawTextF(int x, int y, int font_type, char *format, ...)
+void DrawTextF(int x, int y, int font_nr, char *format, ...)
 {
   char buffer[MAX_OUTPUT_LINESIZE + 1];
   va_list ap;
@@ -90,12 +171,20 @@ void DrawTextF(int x, int y, int font_type, char *format, ...)
   vsprintf(buffer, format, ap);
   va_end(ap);
 
-  DrawText(gfx.sx + x, gfx.sy + y, buffer, FS_SMALL, font_type);
+  if (strlen(buffer) > MAX_OUTPUT_LINESIZE)
+    Error(ERR_EXIT, "string too long in DrawTextF() -- aborting");
+
+  DrawText(gfx.sx + x, gfx.sy + y, buffer, font_nr);
 }
 
-void DrawText(int x, int y, char *text, int font_size, int font_type)
+void DrawText(int x, int y, char *text, int font_nr)
 {
-  DrawTextExt(drawto, x, y, text, font_size, font_type);
+  int mask_mode = FONT_OPAQUE;
+
+  if (DrawingOnBackground(x, y))
+    mask_mode = FONT_MASKED;
+
+  DrawTextExt(drawto, x, y, text, font_nr, mask_mode);
 
   if (x < gfx.dx)
     redraw_mask |= REDRAW_FIELD;
@@ -103,37 +192,25 @@ void DrawText(int x, int y, char *text, int font_size, int font_type)
     redraw_mask |= REDRAW_DOOR_1;
 }
 
-void DrawTextExt(DrawBuffer *bitmap, int x, int y,
-		 char *text, int font_size, int font_type)
+void DrawTextExt(DrawBuffer *dst_bitmap, int dst_x, int dst_y, char *text,
+		 int font_nr, int mask_mode)
 {
-  Bitmap *font_bitmap;
-  int font_width, font_height, font_start;
+  int font_bitmap_id = gfx.select_font_function(font_nr);
+  struct FontBitmapInfo *font = &gfx.font_bitmap_info[font_bitmap_id];
   boolean print_inverse = FALSE;
 
-  if (font_size != FS_SMALL && font_size != FS_BIG && font_size != FS_MEDIUM)
-    font_size = FS_SMALL;
-  if (font_type < FC_RED || font_type > FC_SPECIAL3)
-    font_type = FC_RED;
-
-  font_width = getFontWidth(font_size, font_type);
-  font_height = getFontHeight(font_size, font_type);
-
-  font_bitmap = (font_size == FS_BIG ? font.bitmap_big :
-		 font_size == FS_MEDIUM ? font.bitmap_medium :
-		 font.bitmap_small);
-  font_start = (font_type * (font_size == FS_BIG ? FONT1_YSIZE :
-			     font_size == FS_MEDIUM ? FONT6_YSIZE :
-			     FONT2_YSIZE) *
-		FONT_LINES_PER_FONT);
+  if (font->bitmap == NULL)
+    return;
 
-  if (font_type == FC_SPECIAL3)
-    font_start += (FONT4_YSIZE - FONT2_YSIZE) * FONT_LINES_PER_FONT;
+  /* add offset for drawing font characters */
+  dst_x += font->draw_x;
+  dst_y += font->draw_y;
 
   while (*text)
   {
     char c = *text++;
 
-    if (c == '~' && font_size == FS_SMALL)
+    if (c == '~')
     {
       print_inverse = TRUE;
       continue;
@@ -152,35 +229,61 @@ void DrawTextExt(DrawBuffer *bitmap, int x, int y,
     else if (c == '\\')			/* bad luck ... */
       c = '/';
 
-    if ((c >= 32 && c <= 95) || c == '°' || c == '´')
+    if ((c >= 32 && c <= 95) || c == '°' || c == '´' || c == '|')
     {
-      int src_x = ((c - 32) % FONT_CHARS_PER_LINE) * font_width;
-      int src_y = ((c - 32) / FONT_CHARS_PER_LINE) * font_height + font_start;
-      int dest_x = x, dest_y = y;
+      int src_x= font->src_x + ((c - 32) % FONT_CHARS_PER_LINE) * font->width;
+      int src_y= font->src_y + ((c - 32) / FONT_CHARS_PER_LINE) * font->height;
 
-      if (c == '°' || c == '´')		/* map '°' and 'TM' signs */
+      if (c == '°' || c == '´' || c == '|')	/* map '°' and 'TM' signs */
       {
-	src_x = FONT_CHARS_PER_LINE * font_width;
-	src_y = (c == '°' ? 1 : 2) * font_height + font_start;
+	src_x = font->src_x + FONT_CHARS_PER_LINE * font->width;
+	src_y = font->src_y + (c == '°' ? 1 : c == '´' ? 2 : 3) * font->height;
       }
 
-      if (print_inverse)
+      if (print_inverse)	/* special mode for text gadgets */
+      {
+	/* first step: draw solid colored rectangle (use "cursor" character) */
+	BlitBitmap(font->bitmap, dst_bitmap,
+		   font->src_x + FONT_CHARS_PER_LINE * font->width,
+		   font->src_y + 3 * font->height,
+		   font->width, font->height, dst_x, dst_y);
+
+	/* second step: draw masked black rectangle (use "space" character) */
+	SetClipOrigin(font->bitmap, font->bitmap->stored_clip_gc,
+		      dst_x - src_x, dst_y - src_y);
+	BlitBitmapMasked(font->bitmap, dst_bitmap,
+			 0, 0, font->width, font->height, dst_x, dst_y);
+      }
+      else if (mask_mode == FONT_MASKED)
+      {
+	/* clear font character background */
+	ClearRectangleOnBackground(dst_bitmap, dst_x, dst_y,
+				   font->width, font->height);
+
+#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
+	/* use special font tile clipmasks */
+	{
+	  int font_char = (c >= 32 && c <= 95 ? c - 32 : 0);
+
+	  SetClipMask(font->bitmap, font_clip_gc,
+		      font->clip_mask[font_char]);
+	  SetClipOrigin(font->bitmap, font_clip_gc, dst_x, dst_y);
+	}
+#else
+	SetClipOrigin(font->bitmap, font->bitmap->stored_clip_gc,
+		      dst_x - src_x, dst_y - src_y);
+#endif
+
+	BlitBitmapMasked(font->bitmap, dst_bitmap, src_x, src_y,
+			 font->width, font->height, dst_x, dst_y);
+      }
+      else	/* normal, non-masked font blitting */
       {
-	BlitBitmap(font_bitmap, bitmap,
-		   FONT_CHARS_PER_LINE * font_width,
-		   3 * font_height + font_start,
-		   font_width, font_height, x, y);
-
-	SetClipOrigin(font_bitmap, font_bitmap->stored_clip_gc,
-		      dest_x - src_x, dest_y - src_y);
-	BlitBitmapMasked(font_bitmap, bitmap,
-			 0, 0, font_width, font_height, dest_x, dest_y);
+	BlitBitmap(font->bitmap, dst_bitmap, src_x, src_y,
+		   font->width, font->height, dst_x, dst_y);
       }
-      else
-	BlitBitmap(font_bitmap, bitmap,
-		   src_x, src_y, font_width, font_height, dest_x, dest_y);
     }
 
-    x += font_width;
+    dst_x += font->width;
   }
 }