diff options
author | KUDr <KUDr@openttd.org> | 2007-01-10 18:12:09 +0000 |
---|---|---|
committer | KUDr <KUDr@openttd.org> | 2007-01-10 18:12:09 +0000 |
commit | 07c30785ab226c4762b442f5a09ec745017cc94b (patch) | |
tree | d9abc3d9810159441bed9f82a52bd1ee52d770dd /src/gfx.cpp | |
parent | dc44d341075a525d6069bfbf935efe75ac7ff0f0 (diff) | |
download | openttd-07c30785ab226c4762b442f5a09ec745017cc94b.tar.xz |
(svn r8033) [cpp] - Prepare for merge from branches/cpp (all .c files renamed to .cpp)
Diffstat (limited to 'src/gfx.cpp')
-rw-r--r-- | src/gfx.cpp | 2031 |
1 files changed, 2031 insertions, 0 deletions
diff --git a/src/gfx.cpp b/src/gfx.cpp new file mode 100644 index 000000000..a78e20040 --- /dev/null +++ b/src/gfx.cpp @@ -0,0 +1,2031 @@ +/* $Id$ */ + +#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 + +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 (!(color & PALETTE_MODIFIER_GREYOUT)) { + if (!(color & USE_COLORTABLE)) { + do { + memset(dst, color, right); + dst += dpi->pitch; + } while (--bottom); + } else { + /* use colortable mode */ + const byte* ctab = GetNonSprite(color & COLORTABLE_MASK) + 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(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(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(uint32 img, int x, int y) +{ + if (img & PALETTE_MODIFIER_COLOR) { + _color_remap_ptr = GetNonSprite(GB(img, PALETTE_SPRITE_START, PALETTE_SPRITE_WIDTH)) + 1; + GfxMainBlitter(GetSprite(img & SPRITE_MASK), x, y, BM_COLOUR_REMAP); + } else if (img & PALETTE_MODIFIER_TRANSPARENT) { + _color_remap_ptr = GetNonSprite(GB(img, PALETTE_SPRITE_START, PALETTE_SPRITE_WIDTH)) + 1; + GfxMainBlitter(GetSprite(img & SPRITE_MASK), x, y, BM_TRANSPARENT); + } else { + GfxMainBlitter(GetSprite(img & SPRITE_MASK), 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.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(CursorID cursor) +{ + CursorVars *cv = &_cursor; + const Sprite *p; + + if (cv->sprite == cursor) return; + + p = GetSprite(cursor & SPRITE_MASK); + cv->sprite = cursor; + 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) +{ + CursorVars *cv = &_cursor; + const CursorID *cur = cv->animate_cur; + CursorID sprite; + + // ANIM_CURSOR_END is 0xFFFF in table/animcursors.h + if (cur == NULL || *cur == 0xFFFF) cur = cv->animate_list; + + sprite = cur[0]; + cv->animate_timeout = cur[1]; + cv->animate_cur = cur + 2; + + SetCursorSprite(sprite); +} + +void CursorTick(void) +{ + if (_cursor.animate_timeout != 0 && --_cursor.animate_timeout == 0) + SwitchAnimatedCursor(); +} + +void SetMouseCursor(CursorID cursor) +{ + // Turn off animation + _cursor.animate_timeout = 0; + // Set cursor + SetCursorSprite(cursor); +} + +void SetAnimatedMouseCursor(const CursorID *table) +{ + _cursor.animate_list = table; + _cursor.animate_cur = NULL; + 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); +} |