/* $Id$ */ /** @file gfx.cpp */ #include "stdafx.h" #include "openttd.h" #include "functions.h" #include "macros.h" #include "spritecache.h" #include "strings.h" #include "string.h" #include "gfx.h" #include "table/palettes.h" #include "table/sprites.h" #include "hal.h" #include "variables.h" #include "table/control_codes.h" #include "fontcache.h" #include "genworld.h" #include "debug.h" #ifdef _DEBUG bool _dbg_screen_rect; #endif byte _dirkeys; ///< 1 = left, 2 = up, 4 = right, 8 = down bool _fullscreen; CursorVars _cursor; bool _ctrl_pressed; ///< Is Ctrl pressed? bool _shift_pressed; ///< Is Shift pressed? byte _fast_forward; bool _left_button_down; bool _left_button_clicked; bool _right_button_down; bool _right_button_clicked; DrawPixelInfo _screen; bool _exit_game; bool _networking; ///< are we in networking mode? byte _game_mode; byte _pause; int _pal_first_dirty; int _pal_last_dirty; Colour _cur_palette[256]; byte _stringwidth_table[FS_END][224]; typedef enum BlitterModes { BM_NORMAL, BM_COLOUR_REMAP, BM_TRANSPARENT, } BlitterMode; static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode); FontSize _cur_fontsize; static FontSize _last_fontsize; static Pixel _cursor_backup[64 * 64]; static Rect _invalid_rect; static const byte *_color_remap_ptr; static byte _string_colorremap[3]; #define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64) static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8]; void memcpy_pitch(void *dst, void *src, int w, int h, int srcpitch, int dstpitch) { byte *dstp = (byte*)dst; byte *srcp = (byte*)src; assert(h >= 0); for (; h != 0; --h) { memcpy(dstp, srcp, w); dstp += dstpitch; srcp += srcpitch; } } void GfxScroll(int left, int top, int width, int height, int xo, int yo) { const Pixel *src; Pixel *dst; int p; int ht; if (xo == 0 && yo == 0) return; if (_cursor.visible) UndrawMouseCursor(); UndrawTextMessage(); p = _screen.pitch; if (yo > 0) { /*Calculate pointers */ dst = _screen.dst_ptr + (top + height - 1) * p + left; src = dst - yo * p; /* Decrease height and increase top */ top += yo; height -= yo; assert(height > 0); /* Adjust left & width */ if (xo >= 0) { dst += xo; left += xo; width -= xo; } else { src -= xo; width += xo; } for (ht = height; ht > 0; --ht) { memcpy(dst, src, width); src -= p; dst -= p; } } else { /* Calculate pointers */ dst = _screen.dst_ptr + top * p + left; src = dst - yo * p; /* Decrese height. (yo is <=0). */ height += yo; assert(height > 0); /* Adjust left & width */ if (xo >= 0) { dst += xo; left += xo; width -= xo; } else { src -= xo; width += xo; } /* the y-displacement may be 0 therefore we have to use memmove, * because source and destination may overlap */ for (ht = height; ht > 0; --ht) { memmove(dst, src, width); src += p; dst += p; } } /* This part of the screen is now dirty. */ _video_driver->make_dirty(left, top, width, height); } void GfxFillRect(int left, int top, int right, int bottom, int color) { const DrawPixelInfo* dpi = _cur_dpi; Pixel *dst; const int otop = top; const int oleft = left; if (dpi->zoom != 0) return; if (left > right || top > bottom) return; if (right < dpi->left || left >= dpi->left + dpi->width) return; if (bottom < dpi->top || top >= dpi->top + dpi->height) return; if ( (left -= dpi->left) < 0) left = 0; right = right - dpi->left + 1; if (right > dpi->width) right = dpi->width; right -= left; assert(right > 0); if ( (top -= dpi->top) < 0) top = 0; bottom = bottom - dpi->top + 1; if (bottom > dpi->height) bottom = dpi->height; bottom -= top; assert(bottom > 0); dst = dpi->dst_ptr + top * dpi->pitch + left; if (!HASBIT(color, PALETTE_MODIFIER_GREYOUT)) { if (!HASBIT(color, USE_COLORTABLE)) { do { memset(dst, color, right); dst += dpi->pitch; } while (--bottom); } else { /* use colortable mode */ const byte* ctab = GetNonSprite(GB(color, 0, PALETTE_WIDTH)) + 1; do { int i; for (i = 0; i != right; i++) dst[i] = ctab[dst[i]]; dst += dpi->pitch; } while (--bottom); } } else { byte bo = (oleft - left + dpi->left + otop - top + dpi->top) & 1; do { int i; for (i = (bo ^= 1); i < right; i += 2) dst[i] = (byte)color; dst += dpi->pitch; } while (--bottom > 0); } } static void GfxSetPixel(int x, int y, int color) { const DrawPixelInfo* dpi = _cur_dpi; if ((x-=dpi->left) < 0 || x>=dpi->width || (y-=dpi->top)<0 || y>=dpi->height) return; dpi->dst_ptr[y * dpi->pitch + x] = color; } void GfxDrawLine(int x, int y, int x2, int y2, int color) { int dy; int dx; int stepx; int stepy; int frac; /* Check clipping first */ { DrawPixelInfo *dpi = _cur_dpi; int t; if (x < dpi->left && x2 < dpi->left) return; if (y < dpi->top && y2 < dpi->top) return; t = dpi->left + dpi->width; if (x > t && x2 > t) return; t = dpi->top + dpi->height; if (y > t && y2 > t) return; } dy = (y2 - y) * 2; if (dy < 0) { dy = -dy; stepy = -1; } else { stepy = 1; } dx = (x2 - x) * 2; if (dx < 0) { dx = -dx; stepx = -1; } else { stepx = 1; } GfxSetPixel(x, y, color); if (dx > dy) { frac = dy - (dx >> 1); while (x != x2) { if (frac >= 0) { y += stepy; frac -= dx; } x += stepx; frac += dy; GfxSetPixel(x, y, color); } } else { frac = dx - (dy >> 1); while (y != y2) { if (frac >= 0) { x += stepx; frac -= dy; } y += stepy; frac += dx; GfxSetPixel(x, y, color); } } } /** Truncate a given string to a maximum width if neccessary. * If the string is truncated, add three dots ('...') to show this. * @param *dest string that is checked and possibly truncated * @param maxw maximum width in pixels of the string * @return new width of (truncated) string */ static int TruncateString(char *str, int maxw) { int w = 0; FontSize size = _cur_fontsize; int ddd, ddd_w; WChar c; char *ddd_pos; ddd_w = ddd = GetCharacterWidth(size, '.') * 3; for (ddd_pos = str; (c = Utf8Consume((const char **)&str)) != '\0'; ) { if (IsPrintable(c)) { w += GetCharacterWidth(size, c); if (w >= maxw) { /* string got too big... insert dotdotdot */ ddd_pos[0] = ddd_pos[1] = ddd_pos[2] = '.'; ddd_pos[3] = 0; return ddd_w; } } else { if (c == SCC_SETX) str++; else if (c == SCC_SETXY) str += 2; else if (c == SCC_TINYFONT) { size = FS_SMALL; ddd = GetCharacterWidth(size, '.') * 3; } else if (c == SCC_BIGFONT) { size = FS_LARGE; ddd = GetCharacterWidth(size, '.') * 3; } } /* Remember the last position where three dots fit. */ if (w + ddd < maxw) { ddd_w = w + ddd; ddd_pos = str; } } return w; } static inline int TruncateStringID(StringID src, char *dest, int maxw, const char* last) { GetString(dest, src, last); return TruncateString(dest, maxw); } /* returns right coordinate */ int DrawString(int x, int y, StringID str, uint16 color) { char buffer[512]; GetString(buffer, str, lastof(buffer)); return DoDrawString(buffer, x, y, color); } int DrawStringTruncated(int x, int y, StringID str, uint16 color, uint maxw) { char buffer[512]; TruncateStringID(str, buffer, maxw, lastof(buffer)); return DoDrawString(buffer, x, y, color); } int DrawStringRightAligned(int x, int y, StringID str, uint16 color) { char buffer[512]; int w; GetString(buffer, str, lastof(buffer)); w = GetStringBoundingBox(buffer).width; DoDrawString(buffer, x - w, y, color); return w; } void DrawStringRightAlignedTruncated(int x, int y, StringID str, uint16 color, uint maxw) { char buffer[512]; TruncateStringID(str, buffer, maxw, lastof(buffer)); DoDrawString(buffer, x - GetStringBoundingBox(buffer).width, y, color); } void DrawStringRightAlignedUnderline(int x, int y, StringID str, uint16 color) { int w = DrawStringRightAligned(x, y, str, color); GfxFillRect(x - w, y + 10, x, y + 10, _string_colorremap[1]); } int DrawStringCentered(int x, int y, StringID str, uint16 color) { char buffer[512]; int w; GetString(buffer, str, lastof(buffer)); w = GetStringBoundingBox(buffer).width; DoDrawString(buffer, x - w / 2, y, color); return w; } int DrawStringCenteredTruncated(int xl, int xr, int y, StringID str, uint16 color) { char buffer[512]; int w = TruncateStringID(str, buffer, xr - xl, lastof(buffer)); return DoDrawString(buffer, (xl + xr - w) / 2, y, color); } int DoDrawStringCentered(int x, int y, const char *str, uint16 color) { int w = GetStringBoundingBox(str).width; DoDrawString(str, x - w / 2, y, color); return w; } void DrawStringCenterUnderline(int x, int y, StringID str, uint16 color) { int w = DrawStringCentered(x, y, str, color); GfxFillRect(x - (w >> 1), y + 10, x - (w >> 1) + w, y + 10, _string_colorremap[1]); } void DrawStringCenterUnderlineTruncated(int xl, int xr, int y, StringID str, uint16 color) { int w = DrawStringCenteredTruncated(xl, xr, y, str, color); GfxFillRect((xl + xr - w) / 2, y + 10, (xl + xr + w) / 2, y + 10, _string_colorremap[1]); } /** 'Correct' a string to a maximum length. Longer strings will be cut into * additional lines at whitespace characters if possible. The string parameter * is modified with terminating characters mid-string which are the * placeholders for the newlines.<br/> * The string WILL be truncated if there was no whitespace for the current * line's maximum width. * * @note To know if the the terminating '\0' is the string end or just a * newline, the returned 'num' value should be consulted. The num'th '\0', * starting with index 0 is the real string end. * * @param str string to check and correct for length restrictions * @param maxw the maximum width the string can have on one line * @return return a 32bit wide number consisting of 2 packed values: * 0 - 15 the number of lines ADDED to the string * 16 - 31 the fontsize in which the length calculation was done at */ uint32 FormatStringLinebreaks(char *str, int maxw) { FontSize size = _cur_fontsize; int num = 0; assert(maxw > 0); for (;;) { char *last_space = NULL; int w = 0; for (;;) { WChar c = Utf8Consume((const char **)&str); /* whitespace is where we will insert the line-break */ if (c == ' ') last_space = str; if (IsPrintable(c)) { w += GetCharacterWidth(size, c); /* string is longer than maximum width so we need to decide what to * do. We can do two things: * 1. If no whitespace was found at all up until now (on this line) then * we will truncate the string and bail out. * 2. In all other cases force a linebreak at the last seen whitespace */ if (w > maxw) { if (last_space == NULL) { str[-1] = '\0'; return num + (size << 16); } str = last_space; break; } } else { switch (c) { case '\0': return num + (size << 16); break; case SCC_SETX: str++; break; case SCC_SETXY: str +=2; break; case SCC_TINYFONT: size = FS_SMALL; break; case SCC_BIGFONT: size = FS_LARGE; break; case '\n': goto end_of_inner_loop; } } } end_of_inner_loop: /* string didn't fit on line, so 'dummy' terminate and increase linecount */ num++; str[-1] = '\0'; } } /** Draw a given string with the centre around the given x coordinates * @param x Centre the string around this pixel width * @param y Draw the string at this pixel height (first line's bottom) * @param str String to draw * @param max Maximum width the string can have before it is wrapped */ void DrawStringMultiCenter(int x, int y, StringID str, int maxw) { char buffer[512]; uint32 tmp; int num, w, mt; const char *src; WChar c; GetString(buffer, str, lastof(buffer)); tmp = FormatStringLinebreaks(buffer, maxw); num = GB(tmp, 0, 16); mt = GetCharacterHeight((FontSize)GB(tmp, 16, 16)); y -= (mt >> 1) * num; src = buffer; for (;;) { w = GetStringBoundingBox(src).width; DoDrawString(src, x - (w>>1), y, 0xFE); _cur_fontsize = _last_fontsize; for (;;) { c = Utf8Consume(&src); if (c == 0) { y += mt; if (--num < 0) { _cur_fontsize = FS_NORMAL; return; } break; } else if (c == SCC_SETX) { src++; } else if (c == SCC_SETXY) { src+=2; } } } } uint DrawStringMultiLine(int x, int y, StringID str, int maxw) { char buffer[512]; uint32 tmp; int num, mt; uint total_height; const char *src; WChar c; GetString(buffer, str, lastof(buffer)); tmp = FormatStringLinebreaks(buffer, maxw); num = GB(tmp, 0, 16); mt = GetCharacterHeight((FontSize)GB(tmp, 16, 16)); total_height = (num + 1) * mt; src = buffer; for (;;) { DoDrawString(src, x, y, 0xFE); _cur_fontsize = _last_fontsize; for (;;) { c = Utf8Consume(&src); if (c == 0) { y += mt; if (--num < 0) { _cur_fontsize = FS_NORMAL; return total_height; } break; } else if (c == SCC_SETX) { src++; } else if (c == SCC_SETXY) { src+=2; } } } } /** Return the string dimension in pixels. The height and width are returned * in a single BoundingRect value. TINYFONT, BIGFONT modifiers are only * supported as the first character of the string. The returned dimensions * are therefore a rough estimation correct for all the current strings * but not every possible combination * @param str string to calculate pixel-width * @return string width and height in pixels */ BoundingRect GetStringBoundingBox(const char *str) { FontSize size = _cur_fontsize; BoundingRect br; int max_width; WChar c; br.width = br.height = max_width = 0; for (;;) { c = Utf8Consume(&str); if (c == 0) break; if (IsPrintable(c)) { br.width += GetCharacterWidth(size, c); } else { switch (c) { case SCC_SETX: br.width += (byte)*str++; break; case SCC_SETXY: br.width += (byte)*str++; br.height += (byte)*str++; break; case SCC_TINYFONT: size = FS_SMALL; break; case SCC_BIGFONT: size = FS_LARGE; break; case '\n': br.height += GetCharacterHeight(size); if (br.width > max_width) max_width = br.width; br.width = 0; break; } } } br.height += GetCharacterHeight(size); br.width = max(br.width, max_width); return br; } /** Draw a string at the given coordinates with the given colour * @param string the string to draw * @param x offset from left side of the screen, if negative offset from the right side * @param x offset from top side of the screen, if negative offset from the bottom * @param real_color colour of the string, see _string_colormap in * table/palettes.h or docs/ottd-colourtext-palette.png * @return the x-coordinates where the drawing has finished. If nothing is drawn * the originally passed x-coordinate is returned */ int DoDrawString(const char *string, int x, int y, uint16 real_color) { DrawPixelInfo *dpi = _cur_dpi; FontSize size = _cur_fontsize; WChar c; byte color; int xo = x, yo = y; color = real_color & 0xFF; if (color != 0xFE) { if (x >= dpi->left + dpi->width || x + _screen.width*2 <= dpi->left || y >= dpi->top + dpi->height || y + _screen.height <= dpi->top) return x; if (color != 0xFF) { switch_color:; if (real_color & IS_PALETTE_COLOR) { _string_colorremap[1] = color; _string_colorremap[2] = 215; } else { _string_colorremap[1] = _string_colormap[color].text; _string_colorremap[2] = _string_colormap[color].shadow; } _color_remap_ptr = _string_colorremap; } } check_bounds: if (y + 19 <= dpi->top || dpi->top + dpi->height <= y) { skip_char:; for (;;) { c = Utf8Consume(&string); if (!IsPrintable(c)) goto skip_cont; } } for (;;) { c = Utf8Consume(&string); skip_cont:; if (c == 0) { _last_fontsize = size; return x; } if (IsPrintable(c)) { if (x >= dpi->left + dpi->width) goto skip_char; if (x + 26 >= dpi->left) { GfxMainBlitter(GetGlyph(size, c), x, y, BM_COLOUR_REMAP); } x += GetCharacterWidth(size, c); } else if (c == '\n') { // newline = {} x = xo; y += GetCharacterHeight(size); goto check_bounds; } else if (c >= SCC_BLUE && c <= SCC_BLACK) { // change color? color = (byte)(c - SCC_BLUE); goto switch_color; } else if (c == SCC_SETX) { // {SETX} x = xo + (byte)*string++; } else if (c == SCC_SETXY) {// {SETXY} x = xo + (byte)*string++; y = yo + (byte)*string++; } else if (c == SCC_TINYFONT) { // {TINYFONT} size = FS_SMALL; } else if (c == SCC_BIGFONT) { // {BIGFONT} size = FS_LARGE; } else { DEBUG(misc, 0, "[utf8] unknown string command character %d", c); } } } int DoDrawStringTruncated(const char *str, int x, int y, uint16 color, uint maxw) { char buffer[512]; ttd_strlcpy(buffer, str, sizeof(buffer)); TruncateString(buffer, maxw); return DoDrawString(buffer, x, y, color); } void DrawSprite(SpriteID img, SpriteID pal, int x, int y) { if (HASBIT(img, PALETTE_MODIFIER_TRANSPARENT)) { _color_remap_ptr = GetNonSprite(GB(pal, 0, PALETTE_WIDTH)) + 1; GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH)), x, y, BM_TRANSPARENT); } else if (pal != PAL_NONE) { _color_remap_ptr = GetNonSprite(GB(pal, 0, PALETTE_WIDTH)) + 1; GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH)), x, y, BM_COLOUR_REMAP); } else { GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH)), x, y, BM_NORMAL); } } typedef struct BlitterParams { int start_x, start_y; const byte *sprite; Pixel *dst; BlitterMode mode; int width, height; int width_org; int pitch; } BlitterParams; static void GfxBlitTileZoomIn(BlitterParams *bp) { const byte *src_o = bp->sprite; const byte *src; int num, skip; byte done; Pixel *dst; const byte *ctab; src_o += ReadLE16Aligned(src_o + bp->start_y * 2); switch (bp->mode) { case BM_COLOUR_REMAP: do { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src = src_o + 2; src_o += num + 2; dst = bp->dst; if ( (skip -= bp->start_x) > 0) { dst += skip; } else { src -= skip; num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } ctab = _color_remap_ptr; for (; num >= 4; num -=4) { dst[3] = ctab[src[3]]; dst[2] = ctab[src[2]]; dst[1] = ctab[src[1]]; dst[0] = ctab[src[0]]; dst += 4; src += 4; } for (; num != 0; num--) *dst++ = ctab[*src++]; } while (!(done & 0x80)); bp->dst += bp->pitch; } while (--bp->height != 0); break; case BM_TRANSPARENT: do { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src_o += num + 2; dst = bp->dst; if ( (skip -= bp->start_x) > 0) { dst += skip; } else { num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } ctab = _color_remap_ptr; for (; num != 0; num--) { *dst = ctab[*dst]; dst++; } } while (!(done & 0x80)); bp->dst += bp->pitch; } while (--bp->height != 0); break; default: do { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src = src_o + 2; src_o += num + 2; dst = bp->dst; if ( (skip -= bp->start_x) > 0) { dst += skip; } else { src -= skip; num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } #if defined(_WIN32) if (num & 1) *dst++ = *src++; if (num & 2) { *(uint16*)dst = *(uint16*)src; dst += 2; src += 2; } if (num >>= 2) { do { *(uint32*)dst = *(uint32*)src; dst += 4; src += 4; } while (--num != 0); } #else memcpy(dst, src, num); #endif } while (!(done & 0x80)); bp->dst += bp->pitch; } while (--bp->height != 0); break; } } static void GfxBlitZoomInUncomp(BlitterParams *bp) { const byte *src = bp->sprite; Pixel *dst = bp->dst; int height = bp->height; int width = bp->width; int i; assert(height > 0); assert(width > 0); switch (bp->mode) { case BM_COLOUR_REMAP: { const byte *ctab = _color_remap_ptr; do { for (i = 0; i != width; i++) { byte b = ctab[src[i]]; if (b != 0) dst[i] = b; } src += bp->width_org; dst += bp->pitch; } while (--height != 0); break; } case BM_TRANSPARENT: { const byte *ctab = _color_remap_ptr; do { for (i = 0; i != width; i++) if (src[i] != 0) dst[i] = ctab[dst[i]]; src += bp->width_org; dst += bp->pitch; } while (--height != 0); break; } default: do { int n = width; for (; n >= 4; n -= 4) { if (src[0] != 0) dst[0] = src[0]; if (src[1] != 0) dst[1] = src[1]; if (src[2] != 0) dst[2] = src[2]; if (src[3] != 0) dst[3] = src[3]; dst += 4; src += 4; } for (; n != 0; n--) { if (src[0] != 0) dst[0] = src[0]; src++; dst++; } src += bp->width_org - width; dst += bp->pitch - width; } while (--height != 0); break; } } static void GfxBlitTileZoomMedium(BlitterParams *bp) { const byte *src_o = bp->sprite; const byte *src; int num, skip; byte done; Pixel *dst; const byte *ctab; src_o += ReadLE16Aligned(src_o + bp->start_y * 2); switch (bp->mode) { case BM_COLOUR_REMAP: do { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src = src_o + 2; src_o += num + 2; dst = bp->dst; if (skip & 1) { skip++; src++; if (--num == 0) continue; } if ( (skip -= bp->start_x) > 0) { dst += skip >> 1; } else { src -= skip; num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } ctab = _color_remap_ptr; num = (num + 1) >> 1; for (; num != 0; num--) { *dst = ctab[*src]; dst++; src += 2; } } while (!(done & 0x80)); bp->dst += bp->pitch; if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); } while (--bp->height != 0); break; case BM_TRANSPARENT: do { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src_o += num + 2; dst = bp->dst; if (skip & 1) { skip++; if (--num == 0) continue; } if ( (skip -= bp->start_x) > 0) { dst += skip >> 1; } else { num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } ctab = _color_remap_ptr; num = (num + 1) >> 1; for (; num != 0; num--) { *dst = ctab[*dst]; dst++; } } while (!(done & 0x80)); bp->dst += bp->pitch; if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); } while (--bp->height != 0); break; default: do { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src = src_o + 2; src_o += num + 2; dst = bp->dst; if (skip & 1) { skip++; src++; if (--num == 0) continue; } if ( (skip -= bp->start_x) > 0) { dst += skip >> 1; } else { src -= skip; num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } num = (num + 1) >> 1; for (; num != 0; num--) { *dst = *src; dst++; src += 2; } } while (!(done & 0x80)); bp->dst += bp->pitch; if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); } while (--bp->height != 0); break; } } static void GfxBlitZoomMediumUncomp(BlitterParams *bp) { const byte *src = bp->sprite; Pixel *dst = bp->dst; int height = bp->height; int width = bp->width; int i; assert(height > 0); assert(width > 0); switch (bp->mode) { case BM_COLOUR_REMAP: { const byte *ctab = _color_remap_ptr; for (height >>= 1; height != 0; height--) { for (i = 0; i != width >> 1; i++) { byte b = ctab[src[i * 2]]; if (b != 0) dst[i] = b; } src += bp->width_org * 2; dst += bp->pitch; } break; } case BM_TRANSPARENT: { const byte *ctab = _color_remap_ptr; for (height >>= 1; height != 0; height--) { for (i = 0; i != width >> 1; i++) if (src[i * 2] != 0) dst[i] = ctab[dst[i]]; src += bp->width_org * 2; dst += bp->pitch; } break; } default: for (height >>= 1; height != 0; height--) { for (i = 0; i != width >> 1; i++) if (src[i * 2] != 0) dst[i] = src[i * 2]; src += bp->width_org * 2; dst += bp->pitch; } break; } } static void GfxBlitTileZoomOut(BlitterParams *bp) { const byte *src_o = bp->sprite; const byte *src; int num, skip; byte done; Pixel *dst; const byte *ctab; src_o += ReadLE16Aligned(src_o + bp->start_y * 2); switch (bp->mode) { case BM_COLOUR_REMAP: for (;;) { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src = src_o + 2; src_o += num + 2; dst = bp->dst; if (skip & 1) { skip++; src++; if (--num == 0) continue; } if (skip & 2) { skip += 2; src += 2; num -= 2; if (num <= 0) continue; } if ( (skip -= bp->start_x) > 0) { dst += skip >> 2; } else { src -= skip; num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } ctab = _color_remap_ptr; num = (num + 3) >> 2; for (; num != 0; num--) { *dst = ctab[*src]; dst++; src += 4; } } while (!(done & 0x80)); bp->dst += bp->pitch; if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; } break; case BM_TRANSPARENT: for (;;) { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src_o += num + 2; dst = bp->dst; if (skip & 1) { skip++; if (--num == 0) continue; } if (skip & 2) { skip += 2; num -= 2; if (num <= 0) continue; } if ( (skip -= bp->start_x) > 0) { dst += skip >> 2; } else { num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } ctab = _color_remap_ptr; num = (num + 3) >> 2; for (; num != 0; num--) { *dst = ctab[*dst]; dst++; } } while (!(done & 0x80)); bp->dst += bp->pitch; if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; } break; default: for (;;) { do { done = src_o[0]; num = done & 0x7F; skip = src_o[1]; src = src_o + 2; src_o += num + 2; dst = bp->dst; if (skip & 1) { skip++; src++; if (--num == 0) continue; } if (skip & 2) { skip += 2; src += 2; num -= 2; if (num <= 0) continue; } if ( (skip -= bp->start_x) > 0) { dst += skip >> 2; } else { src -= skip; num += skip; if (num <= 0) continue; skip = 0; } skip = skip + num - bp->width; if (skip > 0) { num -= skip; if (num <= 0) continue; } num = (num + 3) >> 2; for (; num != 0; num--) { *dst = *src; dst++; src += 4; } } while (!(done & 0x80)); bp->dst += bp->pitch; if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; do { done = src_o[0]; src_o += (done & 0x7F) + 2; } while (!(done & 0x80)); if (--bp->height == 0) return; } break; } } static void GfxBlitZoomOutUncomp(BlitterParams *bp) { const byte *src = bp->sprite; Pixel *dst = bp->dst; int height = bp->height; int width = bp->width; int i; assert(height > 0); assert(width > 0); switch (bp->mode) { case BM_COLOUR_REMAP: { const byte *ctab = _color_remap_ptr; for (height >>= 2; height != 0; height--) { for (i = 0; i != width >> 2; i++) { byte b = ctab[src[i * 4]]; if (b != 0) dst[i] = b; } src += bp->width_org * 4; dst += bp->pitch; } break; } case BM_TRANSPARENT: { const byte *ctab = _color_remap_ptr; for (height >>= 2; height != 0; height--) { for (i = 0; i != width >> 2; i++) if (src[i * 4] != 0) dst[i] = ctab[dst[i]]; src += bp->width_org * 4; dst += bp->pitch; } break; } default: for (height >>= 2; height != 0; height--) { for (i = 0; i != width >> 2; i++) if (src[i * 4] != 0) dst[i] = src[i * 4]; src += bp->width_org * 4; dst += bp->pitch; } break; } } static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode) { const DrawPixelInfo *dpi = _cur_dpi; int start_x, start_y; BlitterParams bp; int zoom_mask = ~((1 << dpi->zoom) - 1); /* decode sprite header */ x += sprite->x_offs; y += sprite->y_offs; bp.width_org = bp.width = sprite->width; bp.height = sprite->height; bp.sprite = sprite->data; bp.dst = dpi->dst_ptr; bp.mode = mode; bp.pitch = dpi->pitch; assert(bp.height > 0); assert(bp.width > 0); if (sprite->info & 8) { /* tile blit */ start_y = 0; if (dpi->zoom > 0) { start_y += bp.height & ~zoom_mask; bp.height &= zoom_mask; if (bp.height == 0) return; y &= zoom_mask; } if ( (y -= dpi->top) < 0) { bp.height += y; if (bp.height <= 0) return; start_y -= y; y = 0; } else { bp.dst += bp.pitch * (y >> dpi->zoom); } bp.start_y = start_y; if ( (y = y + bp.height - dpi->height) > 0) { bp.height -= y; if (bp.height <= 0) return; } start_x = 0; x &= zoom_mask; if ( (x -= dpi->left) < 0) { bp.width += x; if (bp.width <= 0) return; start_x -= x; x = 0; } bp.start_x = start_x; bp.dst += x >> dpi->zoom; if ( (x = x + bp.width - dpi->width) > 0) { bp.width -= x; if (bp.width <= 0) return; } switch (dpi->zoom) { default: NOT_REACHED(); case 0: GfxBlitTileZoomIn(&bp); break; case 1: GfxBlitTileZoomMedium(&bp); break; case 2: GfxBlitTileZoomOut(&bp); break; } } else { bp.sprite += bp.width * (bp.height & ~zoom_mask); bp.height &= zoom_mask; if (bp.height == 0) return; y &= zoom_mask; if ( (y -= dpi->top) < 0) { bp.height += y; if (bp.height <= 0) return; bp.sprite -= bp.width * y; y = 0; } else { bp.dst += bp.pitch * (y >> dpi->zoom); } if (bp.height > dpi->height - y) { bp.height = dpi->height - y; if (bp.height <= 0) return; } x &= zoom_mask; if ( (x -= dpi->left) < 0) { bp.width += x; if (bp.width <= 0) return; bp.sprite -= x; x = 0; } bp.dst += x >> dpi->zoom; if (bp.width > dpi->width - x) { bp.width = dpi->width - x; if (bp.width <= 0) return; } switch (dpi->zoom) { default: NOT_REACHED(); case 0: GfxBlitZoomInUncomp(&bp); break; case 1: GfxBlitZoomMediumUncomp(&bp); break; case 2: GfxBlitZoomOutUncomp(&bp); break; } } } void DoPaletteAnimations(void); void GfxInitPalettes(void) { memcpy(_cur_palette, _palettes[_use_dos_palette ? 1 : 0], sizeof(_cur_palette)); _pal_first_dirty = 0; _pal_last_dirty = 255; DoPaletteAnimations(); } #define EXTR(p, q) (((uint16)(_timer_counter * (p)) * (q)) >> 16) #define EXTR2(p, q) (((uint16)(~_timer_counter * (p)) * (q)) >> 16) void DoPaletteAnimations(void) { const Colour *s; Colour *d; /* Amount of colors to be rotated. * A few more for the DOS palette, because the water colors are * 245-254 for DOS and 217-226 for Windows. */ const ExtraPaletteValues *ev = &_extra_palette_values; int c = _use_dos_palette ? 38 : 28; Colour old_val[38]; // max(38, 28) uint i; uint j; d = &_cur_palette[217]; memcpy(old_val, d, c * sizeof(*old_val)); /* Dark blue water */ s = (_opt.landscape == LT_CANDY) ? ev->ac : ev->a; j = EXTR(320, 5); for (i = 0; i != 5; i++) { *d++ = s[j]; j++; if (j == 5) j = 0; } /* Glittery water */ s = (_opt.landscape == LT_CANDY) ? ev->bc : ev->b; j = EXTR(128, 15); for (i = 0; i != 5; i++) { *d++ = s[j]; j += 3; if (j >= 15) j -= 15; } s = ev->e; j = EXTR2(512, 5); for (i = 0; i != 5; i++) { *d++ = s[j]; j++; if (j == 5) j = 0; } /* Oil refinery fire animation */ s = ev->oil_ref; j = EXTR2(512, 7); for (i = 0; i != 7; i++) { *d++ = s[j]; j++; if (j == 7) j = 0; } /* Radio tower blinking */ { byte i = (_timer_counter >> 1) & 0x7F; byte v; (v = 255, i < 0x3f) || (v = 128, i < 0x4A || i >= 0x75) || (v = 20); d->r = v; d->g = 0; d->b = 0; d++; i ^= 0x40; (v = 255, i < 0x3f) || (v = 128, i < 0x4A || i >= 0x75) || (v = 20); d->r = v; d->g = 0; d->b = 0; d++; } /* Handle lighthouse and stadium animation */ s = ev->lighthouse; j = EXTR(256, 4); for (i = 0; i != 4; i++) { *d++ = s[j]; j++; if (j == 4) j = 0; } /* Animate water for old DOS graphics */ if (_use_dos_palette) { /* Dark blue water DOS */ s = (_opt.landscape == LT_CANDY) ? ev->ac : ev->a; j = EXTR(320, 5); for (i = 0; i != 5; i++) { *d++ = s[j]; j++; if (j == 5) j = 0; } /* Glittery water DOS */ s = (_opt.landscape == LT_CANDY) ? ev->bc : ev->b; j = EXTR(128, 15); for (i = 0; i != 5; i++) { *d++ = s[j]; j += 3; if (j >= 15) j -= 15; } } if (memcmp(old_val, &_cur_palette[217], c * sizeof(*old_val)) != 0) { if (_pal_first_dirty > 217) _pal_first_dirty = 217; if (_pal_last_dirty < 217 + c) _pal_last_dirty = 217 + c; } } void LoadStringWidthTable(void) { uint i; /* Normal font */ for (i = 0; i != 224; i++) { _stringwidth_table[FS_NORMAL][i] = GetGlyphWidth(FS_NORMAL, i + 32); } /* Small font */ for (i = 0; i != 224; i++) { _stringwidth_table[FS_SMALL][i] = GetGlyphWidth(FS_SMALL, i + 32); } /* Large font */ for (i = 0; i != 224; i++) { _stringwidth_table[FS_LARGE][i] = GetGlyphWidth(FS_LARGE, i + 32); } } byte GetCharacterWidth(FontSize size, WChar key) { if (key >= 32 && key < 256) return _stringwidth_table[size][key - 32]; return GetGlyphWidth(size, key); } void ScreenSizeChanged(void) { /* check the dirty rect */ if (_invalid_rect.right >= _screen.width) _invalid_rect.right = _screen.width; if (_invalid_rect.bottom >= _screen.height) _invalid_rect.bottom = _screen.height; /* screen size changed and the old bitmap is invalid now, so we don't want to undraw it */ _cursor.visible = false; } void UndrawMouseCursor(void) { if (_cursor.visible) { _cursor.visible = false; memcpy_pitch( _screen.dst_ptr + _cursor.draw_pos.x + _cursor.draw_pos.y * _screen.pitch, _cursor_backup, _cursor.draw_size.x, _cursor.draw_size.y, _cursor.draw_size.x, _screen.pitch); _video_driver->make_dirty(_cursor.draw_pos.x, _cursor.draw_pos.y, _cursor.draw_size.x, _cursor.draw_size.y); } } void DrawMouseCursor(void) { int x; int y; int w; int h; /* Redraw mouse cursor but only when it's inside the window */ if (!_cursor.in_window) return; /* Don't draw the mouse cursor if it's already drawn */ if (_cursor.visible) { if (!_cursor.dirty) return; UndrawMouseCursor(); } w = _cursor.size.x; x = _cursor.pos.x + _cursor.offs.x; if (x < 0) { w += x; x = 0; } if (w > _screen.width - x) w = _screen.width - x; if (w <= 0) return; _cursor.draw_pos.x = x; _cursor.draw_size.x = w; h = _cursor.size.y; y = _cursor.pos.y + _cursor.offs.y; if (y < 0) { h += y; y = 0; } if (h > _screen.height - y) h = _screen.height - y; if (h <= 0) return; _cursor.draw_pos.y = y; _cursor.draw_size.y = h; assert(w * h < (int)sizeof(_cursor_backup)); /* Make backup of stuff below cursor */ memcpy_pitch( _cursor_backup, _screen.dst_ptr + _cursor.draw_pos.x + _cursor.draw_pos.y * _screen.pitch, _cursor.draw_size.x, _cursor.draw_size.y, _screen.pitch, _cursor.draw_size.x); /* Draw cursor on screen */ _cur_dpi = &_screen; DrawSprite(_cursor.sprite, _cursor.pal, _cursor.pos.x, _cursor.pos.y); _video_driver->make_dirty(_cursor.draw_pos.x, _cursor.draw_pos.y, _cursor.draw_size.x, _cursor.draw_size.y); _cursor.visible = true; _cursor.dirty = false; } #if defined(_DEBUG) static void DbgScreenRect(int left, int top, int right, int bottom) { DrawPixelInfo dp; DrawPixelInfo *old; old = _cur_dpi; _cur_dpi = &dp; dp = _screen; GfxFillRect(left, top, right - 1, bottom - 1, rand() & 255); _cur_dpi = old; } #endif void RedrawScreenRect(int left, int top, int right, int bottom) { assert(right <= _screen.width && bottom <= _screen.height); if (_cursor.visible) { if (right > _cursor.draw_pos.x && left < _cursor.draw_pos.x + _cursor.draw_size.x && bottom > _cursor.draw_pos.y && top < _cursor.draw_pos.y + _cursor.draw_size.y) { UndrawMouseCursor(); } } UndrawTextMessage(); #if defined(_DEBUG) if (_dbg_screen_rect) DbgScreenRect(left, top, right, bottom); else #endif DrawOverlappedWindowForAll(left, top, right, bottom); _video_driver->make_dirty(left, top, right - left, bottom - top); } void DrawDirtyBlocks(void) { byte *b = _dirty_blocks; const int w = ALIGN(_screen.width, 64); const int h = ALIGN(_screen.height, 8); int x; int y; if (IsGeneratingWorld() && !IsGeneratingWorldReadyForPaint()) return; y = 0; do { x = 0; do { if (*b != 0) { int left; int top; int right = x + 64; int bottom = y; byte *p = b; int h2; /* First try coalescing downwards */ do { *p = 0; p += DIRTY_BYTES_PER_LINE; bottom += 8; } while (bottom != h && *p != 0); /* Try coalescing to the right too. */ h2 = (bottom - y) >> 3; assert(h2 > 0); p = b; while (right != w) { byte *p2 = ++p; int h = h2; /* Check if a full line of dirty flags is set. */ do { if (!*p2) goto no_more_coalesc; p2 += DIRTY_BYTES_PER_LINE; } while (--h != 0); /* Wohoo, can combine it one step to the right! * Do that, and clear the bits. */ right += 64; h = h2; p2 = p; do { *p2 = 0; p2 += DIRTY_BYTES_PER_LINE; } while (--h != 0); } no_more_coalesc: left = x; top = y; if (left < _invalid_rect.left ) left = _invalid_rect.left; if (top < _invalid_rect.top ) top = _invalid_rect.top; if (right > _invalid_rect.right ) right = _invalid_rect.right; if (bottom > _invalid_rect.bottom) bottom = _invalid_rect.bottom; if (left < right && top < bottom) { RedrawScreenRect(left, top, right, bottom); } } } while (b++, (x += 64) != w); } while (b += -(w >> 6) + DIRTY_BYTES_PER_LINE, (y += 8) != h); _invalid_rect.left = w; _invalid_rect.top = h; _invalid_rect.right = 0; _invalid_rect.bottom = 0; /* If we are generating a world, and waiting for a paint run, mark it here * as done painting, so we can continue generating. */ if (IsGeneratingWorld() && IsGeneratingWorldReadyForPaint()) { SetGeneratingWorldPaintStatus(false); } } void SetDirtyBlocks(int left, int top, int right, int bottom) { byte *b; int width; int height; if (left < 0) left = 0; if (top < 0) top = 0; if (right > _screen.width) right = _screen.width; if (bottom > _screen.height) bottom = _screen.height; if (left >= right || top >= bottom) return; if (left < _invalid_rect.left ) _invalid_rect.left = left; if (top < _invalid_rect.top ) _invalid_rect.top = top; if (right > _invalid_rect.right ) _invalid_rect.right = right; if (bottom > _invalid_rect.bottom) _invalid_rect.bottom = bottom; left >>= 6; top >>= 3; b = _dirty_blocks + top * DIRTY_BYTES_PER_LINE + left; width = ((right - 1) >> 6) - left + 1; height = ((bottom - 1) >> 3) - top + 1; assert(width > 0 && height > 0); do { int i = width; do b[--i] = 0xFF; while (i); b += DIRTY_BYTES_PER_LINE; } while (--height != 0); } void MarkWholeScreenDirty(void) { SetDirtyBlocks(0, 0, _screen.width, _screen.height); } /** Set up a clipping area for only drawing into a certain area. To do this, * Fill a DrawPixelInfo object with the supplied relative rectangle, backup * the original (calling) _cur_dpi and assign the just returned DrawPixelInfo * _cur_dpi. When you are done, give restore _cur_dpi's original value * @param *n the DrawPixelInfo that will be the clipping rectangle box allowed * for drawing * @param left,top,width,height the relative coordinates of the clipping * rectangle relative to the current _cur_dpi. This will most likely be the * offset from the calling window coordinates * @return return false if the requested rectangle is not possible with the * current dpi pointer. Only continue of the return value is true, or you'll * get some nasty results */ bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height) { const DrawPixelInfo *o = _cur_dpi; n->zoom = 0; assert(width > 0); assert(height > 0); if ((left -= o->left) < 0) { width += left; if (width <= 0) return false; n->left = -left; left = 0; } else { n->left = 0; } if (width > o->width - left) { width = o->width - left; if (width <= 0) return false; } n->width = width; if ((top -= o->top) < 0) { height += top; if (height <= 0) return false; n->top = -top; top = 0; } else { n->top = 0; } n->dst_ptr = o->dst_ptr + left + top * (n->pitch = o->pitch); if (height > o->height - top) { height = o->height - top; if (height <= 0) return false; } n->height = height; return true; } static void SetCursorSprite(SpriteID cursor, SpriteID pal) { CursorVars *cv = &_cursor; const Sprite *p; if (cv->sprite == cursor) return; p = GetSprite(GB(cursor, 0, SPRITE_WIDTH)); cv->sprite = cursor; cv->pal = pal; cv->size.y = p->height; cv->size.x = p->width; cv->offs.x = p->x_offs; cv->offs.y = p->y_offs; cv->dirty = true; } static void SwitchAnimatedCursor(void) { const AnimCursor *cur = _cursor.animate_cur; if (cur == NULL || cur->sprite == AnimCursor::LAST) cur = _cursor.animate_list; SetCursorSprite(cur->sprite, _cursor.pal); _cursor.animate_timeout = cur->display_time; _cursor.animate_cur = cur + 1; } void CursorTick(void) { if (_cursor.animate_timeout != 0 && --_cursor.animate_timeout == 0) SwitchAnimatedCursor(); } void SetMouseCursor(SpriteID sprite, SpriteID pal) { /* Turn off animation */ _cursor.animate_timeout = 0; /* Set cursor */ SetCursorSprite(sprite, pal); } void SetAnimatedMouseCursor(const AnimCursor *table) { _cursor.animate_list = table; _cursor.animate_cur = NULL; _cursor.pal = PAL_NONE; SwitchAnimatedCursor(); } bool ChangeResInGame(int w, int h) { return (_screen.width == w && _screen.height == h) || _video_driver->change_resolution(w, h); } void ToggleFullScreen(bool fs) { _video_driver->toggle_fullscreen(fs); if (_fullscreen != fs && _num_resolutions == 0) { DEBUG(driver, 0, "Could not find a suitable fullscreen resolution"); } } static int CDECL compare_res(const void *pa, const void *pb) { int x = ((const uint16*)pa)[0] - ((const uint16*)pb)[0]; if (x != 0) return x; return ((const uint16*)pa)[1] - ((const uint16*)pb)[1]; } void SortResolutions(int count) { qsort(_resolutions, count, sizeof(_resolutions[0]), compare_res); }