X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Ftext.c;h=d00151646f6c51d96b6c8abe29b0f1995ec04549;hb=9ec014a4e4a6a2332bb45c6cea8cccc46c64c6ae;hp=28f88c56019fe51dd4c6a1d711483a8493bf05c9;hpb=da14f69fd95c7bd5a0d70cdf4935af06f1f20a04;p=rocksndiamonds.git diff --git a/src/libgame/text.c b/src/libgame/text.c index 28f88c56..d0015164 100644 --- a/src/libgame/text.c +++ b/src/libgame/text.c @@ -1,120 +1,216 @@ /*********************************************************** -* Rocks'n'Diamonds -- McDuffin Strikes Back! * +* Artsoft Retro-Game Library * *----------------------------------------------------------* -* (c) 1995-98 Artsoft Entertainment * -* Holger Schemel * -* Oststrasse 11a * -* 33604 Bielefeld * -* phone: ++49 +521 290471 * -* email: aeglos@valinor.owl.de * +* (c) 1994-2002 Artsoft Entertainment * +* Holger Schemel * +* Detmolder Strasse 189 * +* 33604 Bielefeld * +* Germany * +* e-mail: info@artsoft.org * *----------------------------------------------------------* -* text.c * +* text.c * ***********************************************************/ +#include #include -#include "libgame.h" +#include "text.h" +#include "misc.h" -#include "main_TMP.h" -int getFontWidth(int font_size, int font_type) +/* ========================================================================= */ +/* font functions */ +/* ========================================================================= */ + +#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; + +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)); + + 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)) { - 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); + 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 getFontHeight(int font_size, int font_type) +int getFontWidth(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].width; } -void DrawInitText(char *text, int ypos, int color) +int getFontHeight(int font_nr) { - if (window && pix[PIX_SMALLFONT]) + return gfx.font_bitmap_info[font_nr].height; +} + +void DrawInitText(char *text, int ypos, int font_nr) +{ + if (window && + gfx.num_fonts > 0 && + gfx.font_bitmap_info[font_nr].bitmap != NULL) { - ClearRectangle(window, 0, ypos, WIN_XSIZE, FONT2_YSIZE); - DrawTextExt(window, gc, (WIN_XSIZE - 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[FULL_SXSIZE / FONT5_XSIZE + 10]; - int font_width = getFontWidth(FS_SMALL, font_type); + char buffer[MAX_OUTPUT_LINESIZE + 1]; va_list ap; va_start(ap, format); vsprintf(buffer, format, ap); va_end(ap); - DrawText(SX + (SXSIZE - strlen(buffer) * font_width) / 2, 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[FULL_SXSIZE / FONT5_XSIZE + 10]; + char buffer[MAX_OUTPUT_LINESIZE + 1]; va_list ap; va_start(ap, format); vsprintf(buffer, format, ap); va_end(ap); - DrawText(SX + x, 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, gc, 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 < DX) + if (x < gfx.dx) redraw_mask |= REDRAW_FIELD; - else if (y < VY) + else if (y < gfx.vy || gfx.vy == 0) redraw_mask |= REDRAW_DOOR_1; } -void DrawTextExt(DrawBuffer d, GC gc, 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) { - int font_width, font_height, font_start; - int font_bitmap; + 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; + if (font->bitmap == NULL) + return; - font_width = getFontWidth(font_size, font_type); - font_height = getFontHeight(font_size, font_type); - - font_bitmap = (font_size == FS_BIG ? PIX_BIGFONT : - font_size == FS_MEDIUM ? PIX_MEDIUMFONT : - PIX_SMALLFONT); - font_start = (font_type * (font_size == FS_BIG ? FONT1_YSIZE : - font_size == FS_MEDIUM ? FONT6_YSIZE : - FONT2_YSIZE) * - FONT_LINES_PER_FONT); - - 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; @@ -128,29 +224,66 @@ void DrawTextExt(DrawBuffer d, GC gc, int x, int y, c = 92; else if (c == 'ü' || c == 'Ü') c = 93; + else if (c == '[' || c == ']') /* map to normal braces */ + c = (c == '[' ? '(' : ')'); + else if (c == '\\') /* bad luck ... */ + c = '/'; - if (c >= 32 && c <= 95) + 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 == '´' || c == '|') /* map '°' and 'TM' signs */ + { + 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) /* 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); - if (print_inverse) + /* 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(pix[font_bitmap], d, - FONT_CHARS_PER_LINE * font_width, - 3 * font_height + font_start, - font_width, font_height, x, y); - - SetClipOrigin(clip_gc[font_bitmap], dest_x - src_x, dest_y - src_y); - BlitBitmapMasked(pix_masked[font_bitmap], d, - 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(pix[font_bitmap], d, - src_x, src_y, font_width, font_height, dest_x, dest_y); } - x += font_width; + dst_x += font->width; } }