gfx.cpp

Go to the documentation of this file.

/* $Id: gfx.cpp 14555 2008-11-02 11:20:15Z skidd13 $ */

#include "stdafx.h"
#include "openttd.h"
#include "gfx_func.h"
#include "spritecache.h"
#include "variables.h"
#include "fontcache.h"
#include "genworld.h"
#include "debug.h"
#include "zoom_func.h"
#include "texteff.hpp"
#include "blitter/factory.hpp"
#include "video/video_driver.hpp"
#include "strings_func.h"
#include "core/math_func.hpp"
#include "settings_type.h"
#include "core/alloc_func.hpp"
#include "core/sort_func.hpp"
#include "landscape_type.h"
#include "network/network_func.h"

#include "table/palettes.h"
#include "table/sprites.h"
#include "table/control_codes.h"

byte _dirkeys;        
bool _fullscreen;
CursorVars _cursor;
bool _ctrl_pressed;   
bool _shift_pressed;  
byte _fast_forward;
bool _left_button_down;     
bool _left_button_clicked;  
bool _right_button_down;    
bool _right_button_clicked; 
DrawPixelInfo _screen;
bool _screen_disable_anim = false;   
bool _exit_game;
bool _networking;         
byte _game_mode;
int8 _pause_game;
int _pal_first_dirty;
int _pal_count_dirty;

Colour _cur_palette[256];
byte _stringwidth_table[FS_END][224]; 
DrawPixelInfo *_cur_dpi;
byte _colour_gradient[COLOUR_END][8];

static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub = NULL);
static int ReallyDoDrawString(const char *string, int x, int y, uint16 real_colour, bool parse_string_also_when_clipped = false);

FontSize _cur_fontsize;
static FontSize _last_fontsize;
static uint8 _cursor_backup[64 * 64 * 4];

static Rect _invalid_rect;
static const byte *_color_remap_ptr;
static byte _string_colorremap[3];

enum {
  DIRTY_BLOCK_HEIGHT   = 8,
  DIRTY_BLOCK_WIDTH    = 64,
};
static uint _dirty_bytes_per_line = 0;
static byte *_dirty_blocks = NULL;

void GfxScroll(int left, int top, int width, int height, int xo, int yo)
{
  Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

  if (xo == 0 && yo == 0) return;

  if (_cursor.visible) UndrawMouseCursor();

#ifdef ENABLE_NETWORK
  NetworkUndrawChatMessage();
#endif /* ENABLE_NETWORK */

  blitter->ScrollBuffer(_screen.dst_ptr, left, top, width, height, xo, yo);
  /* This part of the screen is now dirty. */
  _video_driver->MakeDirty(left, top, width, height);
}


void GfxFillRect(int left, int top, int right, int bottom, int color, FillRectMode mode)
{
  Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
  const DrawPixelInfo *dpi = _cur_dpi;
  void *dst;
  const int otop = top;
  const int oleft = left;

  if (dpi->zoom != ZOOM_LVL_NORMAL) 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 = blitter->MoveTo(dpi->dst_ptr, left, top);

  switch (mode) {
    default: // FILLRECT_OPAQUE
      blitter->DrawRect(dst, right, bottom, (uint8)color);
      break;

    case FILLRECT_RECOLOR:
      blitter->DrawColorMappingRect(dst, right, bottom, GB(color, 0, PALETTE_WIDTH));
      break;

    case FILLRECT_CHECKER: {
      byte bo = (oleft - left + dpi->left + otop - top + dpi->top) & 1;
      do {
        for (int i = (bo ^= 1); i < right; i += 2) blitter->SetPixel(dst, i, 0, (uint8)color);
        dst = blitter->MoveTo(dst, 0, 1);
      } while (--bottom > 0);
      break;
    }
  }
}

void GfxDrawLine(int x, int y, int x2, int y2, int color)
{
  Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
  DrawPixelInfo *dpi = _cur_dpi;

  x -= dpi->left;
  x2 -= dpi->left;
  y -= dpi->top;
  y2 -= dpi->top;

  /* Check clipping */
  if (x < 0 && x2 < 0) return;
  if (y < 0 && y2 < 0) return;
  if (x > dpi->width  && x2 > dpi->width)  return;
  if (y > dpi->height && y2 > dpi->height) return;

  blitter->DrawLine(dpi->dst_ptr, x, y, x2, y2, dpi->width, dpi->height, color);
}

void GfxDrawLineUnscaled(int x, int y, int x2, int y2, int color)
{
  Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
  DrawPixelInfo *dpi = _cur_dpi;

  x -= dpi->left;
  x2 -= dpi->left;
  y -= dpi->top;
  y2 -= dpi->top;

  /* Check clipping */
  if (x < 0 && x2 < 0) return;
  if (y < 0 && y2 < 0) return;
  if (x > dpi->width  && x2 > dpi->width)  return;
  if (y > dpi->height && y2 > dpi->height) return;

  blitter->DrawLine(dpi->dst_ptr, UnScaleByZoom(x, dpi->zoom), UnScaleByZoom(y, dpi->zoom),
      UnScaleByZoom(x2, dpi->zoom), UnScaleByZoom(y2, dpi->zoom),
      UnScaleByZoom(dpi->width, dpi->zoom), UnScaleByZoom(dpi->height, dpi->zoom), color);
}

void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3)
{
  /*           ....
   *         ..    ....
   *       ..          ....
   *     ..                ^
   *   <--__(dx1,dy1)    /(dx2,dy2)
   *   :    --__       /   :
   *   :        --__ /     :
   *   :            *(x,y) :
   *   :            |      :
   *   :            |     ..
   *    ....        |(dx3,dy3)
   *        ....    | ..
   *            ....V.
   */

  static const byte color = 255;

  GfxDrawLineUnscaled(x, y, x + dx1, y + dy1, color);
  GfxDrawLineUnscaled(x, y, x + dx2, y + dy2, color);
  GfxDrawLineUnscaled(x, y, x + dx3, y + dy3, color);

  GfxDrawLineUnscaled(x + dx1, y + dy1, x + dx1 + dx2, y + dy1 + dy2, color);
  GfxDrawLineUnscaled(x + dx1, y + dy1, x + dx1 + dx3, y + dy1 + dy3, color);
  GfxDrawLineUnscaled(x + dx2, y + dy2, x + dx2 + dx1, y + dy2 + dy1, color);
  GfxDrawLineUnscaled(x + dx2, y + dy2, x + dx2 + dx3, y + dy2 + dy3, color);
  GfxDrawLineUnscaled(x + dx3, y + dy3, x + dx3 + dx1, y + dy3 + dy1, color);
  GfxDrawLineUnscaled(x + dx3, y + dy3, x + dx3 + dx2, y + dy3 + dy2, color);
}


#if !defined(WITH_ICU)
static void HandleBiDiAndArabicShapes(char *text, const char *lastof) {}
#else
#include "unicode/ubidi.h"
#include "unicode/ushape.h"

static void HandleBiDiAndArabicShapes(char *buffer, const char *lastof)
{
  UChar input_output[DRAW_STRING_BUFFER];
  UChar intermediate[DRAW_STRING_BUFFER];

  char *t = buffer;
  size_t length = 0;
  while (*t != '\0' && length < lengthof(input_output)) {
    WChar tmp;
    t += Utf8Decode(&tmp, t);
    input_output[length++] = tmp;
  }
  input_output[length] = 0;

  UErrorCode err = U_ZERO_ERROR;
  UBiDi *para = ubidi_openSized((int32_t)length, 0, &err);
  if (para == NULL) return;

  ubidi_setPara(para, input_output, (int32_t)length, _dynlang.text_dir == TD_RTL ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR, NULL, &err);
  ubidi_writeReordered(para, intermediate, (int32_t)length, 0, &err);
  length = u_shapeArabic(intermediate, (int32_t)length, input_output, lengthof(input_output), U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_LETTERS_SHAPE, &err);
  ubidi_close(para);

  if (U_FAILURE(err)) return;

  t = buffer;
  for (size_t i = 0; i < length && t < (lastof - 4); i++) {
    t += Utf8Encode(t, input_output[i]);
  }
  *t = '\0';
}
#endif /* WITH_ICU */


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, but make sure we do not
         * print anything beyond the string termination character. */
        for (int i = 0; *ddd_pos != '\0' && i < 3; i++, ddd_pos++) *ddd_pos = '.';
        *ddd_pos = '\0';
        return ddd_w;
      }
    } else {
      if (c == SCC_SETX) {
        w = *str;
        str++;
      } else if (c == SCC_SETXY) {
        w = *str;
        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);
}

int DrawString(int x, int y, StringID str, uint16 color)
{
  char buffer[DRAW_STRING_BUFFER];

  GetString(buffer, str, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));
  return ReallyDoDrawString(buffer, x, y, color);
}

int DrawStringTruncated(int x, int y, StringID str, uint16 color, uint maxw)
{
  char buffer[DRAW_STRING_BUFFER];
  TruncateStringID(str, buffer, maxw, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));
  return ReallyDoDrawString(buffer, x, y, color);
}

int DrawStringRightAligned(int x, int y, StringID str, uint16 color)
{
  char buffer[DRAW_STRING_BUFFER];
  int w;

  GetString(buffer, str, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));

  w = GetStringBoundingBox(buffer).width;
  ReallyDoDrawString(buffer, x - w, y, color);

  return w;
}

void DrawStringRightAlignedTruncated(int x, int y, StringID str, uint16 color, uint maxw)
{
  char buffer[DRAW_STRING_BUFFER];

  TruncateStringID(str, buffer, maxw, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));
  ReallyDoDrawString(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[DRAW_STRING_BUFFER];
  int w;

  GetString(buffer, str, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));

  w = GetStringBoundingBox(buffer).width;
  ReallyDoDrawString(buffer, x - w / 2, y, color);

  return w;
}

int DrawStringCenteredTruncated(int xl, int xr, int y, StringID str, uint16 color)
{
  char buffer[DRAW_STRING_BUFFER];
  TruncateStringID(str, buffer, xr - xl, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));

  int w = GetStringBoundingBox(buffer).width;
  return ReallyDoDrawString(buffer, (xl + xr - w) / 2, y, color);
}

int DoDrawStringCentered(int x, int y, const char *str, uint16 color)
{
  char buffer[DRAW_STRING_BUFFER];
  strecpy(buffer, str, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));

  int w = GetStringBoundingBox(buffer).width;
  ReallyDoDrawString(buffer, 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]);
}

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 (IsWhitespace(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) {
            *Utf8PrevChar(str) = '\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 (or a '\n' was encountered), so 'dummy' terminate
     * and increase linecount. We use Utf8PrevChar() as also non 1 char long
     * whitespace seperators are supported */
    num++;
    char *s = Utf8PrevChar(str);
    *s++ = '\0';

    /* In which case (see above) we will shift remainder to left and close the gap */
    if (str - s >= 1) {
      for (; str[-1] != '\0';) *s++ = *str++;
    }
  }
}


static int GetMultilineStringHeight(const char *src, int num)
{
  int maxy = 0;
  int y = 0;
  int fh = GetCharacterHeight(_cur_fontsize);

  for (;;) {
    WChar c = Utf8Consume(&src);

    switch (c) {
      case 0:            y += fh; if (--num < 0) return maxy; break;
      case '\n':         y += fh;                             break;
      case SCC_SETX:     src++;                               break;
      case SCC_SETXY:    src++; y = (int)*src++;              break;
      case SCC_TINYFONT: fh = GetCharacterHeight(FS_SMALL);   break;
      case SCC_BIGFONT:  fh = GetCharacterHeight(FS_LARGE);   break;
      default:           maxy = max<int>(maxy, y + fh);       break;
    }
  }
}


int GetStringHeight(StringID str, int maxw)
{
  char buffer[DRAW_STRING_BUFFER];

  GetString(buffer, str, lastof(buffer));

  uint32 tmp = FormatStringLinebreaks(buffer, maxw);

  return GetMultilineStringHeight(buffer, GB(tmp, 0, 16));
}


void DrawStringMultiCenter(int x, int y, StringID str, int maxw)
{
  char buffer[DRAW_STRING_BUFFER];
  uint32 tmp;
  int num, 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 (;;) {
    char buf2[DRAW_STRING_BUFFER];
    strecpy(buf2, src, lastof(buf2));
    HandleBiDiAndArabicShapes(buf2, lastof(buf2));
    int w = GetStringBoundingBox(buf2).width;
    ReallyDoDrawString(buf2, x - (w >> 1), y, 0xFE, true);
    _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, int maxh)
{
  char buffer[DRAW_STRING_BUFFER];
  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;

  if (maxh != -1 && (int)total_height > maxh) {
    /* Check there's room enough for at least one line. */
    if (maxh < mt) return 0;

    num = maxh / mt - 1;
    total_height = (num + 1) * mt;
  }

  src = buffer;

  for (;;) {
    char buf2[DRAW_STRING_BUFFER];
    strecpy(buf2, src, lastof(buf2));
    HandleBiDiAndArabicShapes(buf2, lastof(buf2));
    ReallyDoDrawString(buf2, x, y, 0xFE, true);
    _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;
      }
    }
  }
}

Dimension GetStringBoundingBox(const char *str)
{
  FontSize size = _cur_fontsize;
  Dimension 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;
}

void DrawCharCentered(WChar c, int x, int y, uint16 real_color)
{
  FontSize size = FS_NORMAL;
  byte color = real_color & 0xFF;
  int w = GetCharacterWidth(size, c);

  _string_colorremap[1] = _string_colormap[_use_palette][color].text;
  _string_colorremap[2] = _string_colormap[_use_palette][color].shadow;
  _color_remap_ptr = _string_colorremap;

  GfxMainBlitter(GetGlyph(size, c), x - w / 2, y, BM_COLOUR_REMAP);
}

int DoDrawString(const char *string, int x, int y, uint16 real_colour, bool parse_string_also_when_clipped)
{
  char buffer[DRAW_STRING_BUFFER];
  strecpy(buffer, string, lastof(buffer));
  HandleBiDiAndArabicShapes(buffer, lastof(buffer));

  return ReallyDoDrawString(buffer, x, y, real_colour, parse_string_also_when_clipped);
}

static int ReallyDoDrawString(const char *string, int x, int y, uint16 real_colour, bool parse_string_also_when_clipped)
{
  DrawPixelInfo *dpi = _cur_dpi;
  FontSize size = _cur_fontsize;
  WChar c;
  int xo = x, yo = y;

  byte colour = real_colour & 0xFF;  // extract the 8 bits colour index that is required for the mapping
  byte previous_colour = colour;

  if (!parse_string_also_when_clipped) {
    /* in "mode multiline", the available space have been verified. Not in regular one.
     * So if the string cannot be drawn, return the original start to say so.*/
    if (x >= dpi->left + dpi->width || y >= dpi->top + dpi->height) return x;

    if (colour != TC_INVALID) { // the invalid colour flag test should not  really occur.  But better be safe
switch_colour:;
      if (real_colour & IS_PALETTE_COLOR) {
        _string_colorremap[1] = colour;
        _string_colorremap[2] = (_use_palette == PAL_DOS) ? 1 : 215;
      } else {
        _string_colorremap[1] = _string_colormap[_use_palette][colour].text;
        _string_colorremap[2] = _string_colormap[_use_palette][colour].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;  // Nothing more to draw, get out. And here is the new x position
    }
    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;  // We require a new line, so the x coordinate is reset
      y += GetCharacterHeight(size);
      goto check_bounds;
    } else if (c >= SCC_BLUE && c <= SCC_BLACK) { // change colour?
      previous_colour = colour;
      colour = (byte)(c - SCC_BLUE);
      goto switch_colour;
    } else if (c == SCC_PREVIOUS_COLOUR) { // revert to the previous colour
      Swap(colour, previous_colour);
      goto switch_colour;
    } 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[DRAW_STRING_BUFFER];
  strecpy(buffer, str, lastof(buffer));
  TruncateString(buffer, maxw);
  return DoDrawString(buffer, x, y, color);
}

void DrawSprite(SpriteID img, SpriteID pal, int x, int y, const SubSprite *sub)
{
  if (HasBit(img, PALETTE_MODIFIER_TRANSPARENT)) {
    _color_remap_ptr = GetNonSprite(GB(pal, 0, PALETTE_WIDTH), ST_RECOLOUR) + 1;
    GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH), ST_NORMAL), x, y, BM_TRANSPARENT, sub);
  } else if (pal != PAL_NONE) {
    _color_remap_ptr = GetNonSprite(GB(pal, 0, PALETTE_WIDTH), ST_RECOLOUR) + 1;
    GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH), ST_NORMAL), x, y, BM_COLOUR_REMAP, sub);
  } else {
    GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH), ST_NORMAL), x, y, BM_NORMAL, sub);
  }
}

static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub)
{
  const DrawPixelInfo *dpi = _cur_dpi;
  Blitter::BlitterParams bp;

  /* Amount of pixels to clip from the source sprite */
  int clip_left   = (sub != NULL ? max(0,                   -sprite->x_offs + sub->left       ) : 0);
  int clip_top    = (sub != NULL ? max(0,                   -sprite->y_offs + sub->top        ) : 0);
  int clip_right  = (sub != NULL ? max(0, sprite->width  - (-sprite->x_offs + sub->right  + 1)) : 0);
  int clip_bottom = (sub != NULL ? max(0, sprite->height - (-sprite->y_offs + sub->bottom + 1)) : 0);

  if (clip_left + clip_right >= sprite->width) return;
  if (clip_top + clip_bottom >= sprite->height) return;

  /* Move to the correct offset */
  x += sprite->x_offs;
  y += sprite->y_offs;

  /* Copy the main data directly from the sprite */
  bp.sprite = sprite->data;
  bp.sprite_width = sprite->width;
  bp.sprite_height = sprite->height;
  bp.width = UnScaleByZoom(sprite->width - clip_left - clip_right, dpi->zoom);
  bp.height = UnScaleByZoom(sprite->height - clip_top - clip_bottom, dpi->zoom);
  bp.top = 0;
  bp.left = 0;
  bp.skip_left = UnScaleByZoomLower(clip_left, dpi->zoom);
  bp.skip_top = UnScaleByZoomLower(clip_top, dpi->zoom);

  x += ScaleByZoom(bp.skip_left, dpi->zoom);
  y += ScaleByZoom(bp.skip_top, dpi->zoom);

  bp.dst = dpi->dst_ptr;
  bp.pitch = dpi->pitch;
  bp.remap = _color_remap_ptr;

  assert(sprite->width > 0);
  assert(sprite->height > 0);

  if (bp.width <= 0) return;
  if (bp.height <= 0) return;

  y -= dpi->top;
  /* Check for top overflow */
  if (y < 0) {
    bp.height -= -UnScaleByZoom(y, dpi->zoom);
    if (bp.height <= 0) return;
    bp.skip_top += -UnScaleByZoom(y, dpi->zoom);
    y = 0;
  } else {
    bp.top = UnScaleByZoom(y, dpi->zoom);
  }

  /* Check for bottom overflow */
  y += ScaleByZoom(bp.height, dpi->zoom) - dpi->height;
  if (y > 0) {
    bp.height -= UnScaleByZoom(y, dpi->zoom);
    if (bp.height <= 0) return;
  }

  x -= dpi->left;
  /* Check for left overflow */
  if (x < 0) {
    bp.width -= -UnScaleByZoom(x, dpi->zoom);
    if (bp.width <= 0) return;
    bp.skip_left += -UnScaleByZoom(x, dpi->zoom);
    x = 0;
  } else {
    bp.left = UnScaleByZoom(x, dpi->zoom);
  }

  /* Check for right overflow */
  x += ScaleByZoom(bp.width, dpi->zoom) - dpi->width;
  if (x > 0) {
    bp.width -= UnScaleByZoom(x, dpi->zoom);
    if (bp.width <= 0) return;
  }

  assert(bp.skip_left + bp.width <= UnScaleByZoom(sprite->width, dpi->zoom));
  assert(bp.skip_top + bp.height <= UnScaleByZoom(sprite->height, dpi->zoom));

  BlitterFactoryBase::GetCurrentBlitter()->Draw(&bp, mode, dpi->zoom);
}

void DoPaletteAnimations();

void GfxInitPalettes()
{
  memcpy(_cur_palette, _palettes[_use_palette], sizeof(_cur_palette));

  DoPaletteAnimations();
  _pal_first_dirty = 0;
  _pal_count_dirty = 256;
}

#define EXTR(p, q) (((uint16)(_palette_animation_counter * (p)) * (q)) >> 16)
#define EXTR2(p, q) (((uint16)(~_palette_animation_counter * (p)) * (q)) >> 16)

void DoPaletteAnimations()
{
  Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
  const Colour *s;
  const ExtraPaletteValues *ev = &_extra_palette_values;
  /* 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 int colour_rotation_amount = (_use_palette == PAL_DOS) ? PALETTE_ANIM_SIZE_DOS : PALETTE_ANIM_SIZE_WIN;
  Colour old_val[PALETTE_ANIM_SIZE_DOS];
  const int oldval_size = colour_rotation_amount * sizeof(*old_val);
  const uint old_tc = _palette_animation_counter;
  uint i;
  uint j;

  if (blitter != NULL && blitter->UsePaletteAnimation() == Blitter::PALETTE_ANIMATION_NONE) {
    _palette_animation_counter = 0;
  }

  Colour *palette_pos = &_cur_palette[PALETTE_ANIM_SIZE_START];  // Points to where animations are taking place on the palette
  /* Makes a copy of the current anmation palette in old_val,
   * so the work on the current palette could be compared, see if there has been any changes */
  memcpy(old_val, palette_pos, oldval_size);

  /* Dark blue water */
  s = (_settings_game.game_creation.landscape == LT_TOYLAND) ? ev->dark_water_TOY : ev->dark_water;
  j = EXTR(320, 5);
  for (i = 0; i != 5; i++) {
    *palette_pos++ = s[j];
    j++;
    if (j == 5) j = 0;
  }

  /* Glittery water */
  s = (_settings_game.game_creation.landscape == LT_TOYLAND) ? ev->glitter_water_TOY : ev->glitter_water;
  j = EXTR(128, 15);
  for (i = 0; i != 5; i++) {
    *palette_pos++ = s[j];
    j += 3;
    if (j >= 15) j -= 15;
  }

  /* Fizzy Drink bubbles animation */
  s = ev->fizzy_drink;
  j = EXTR2(512, 5);
  for (i = 0; i != 5; i++) {
    *palette_pos++ = 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++) {
    *palette_pos++ = s[j];
    j++;
    if (j == 7) j = 0;
  }

  /* Radio tower blinking */
  {
    byte i = (_palette_animation_counter >> 1) & 0x7F;
    byte v;

    (v = 255, i < 0x3f) ||
    (v = 128, i < 0x4A || i >= 0x75) ||
    (v = 20);
    palette_pos->r = v;
    palette_pos->g = 0;
    palette_pos->b = 0;
    palette_pos++;

    i ^= 0x40;
    (v = 255, i < 0x3f) ||
    (v = 128, i < 0x4A || i >= 0x75) ||
    (v = 20);
    palette_pos->r = v;
    palette_pos->g = 0;
    palette_pos->b = 0;
    palette_pos++;
  }

  /* Handle lighthouse and stadium animation */
  s = ev->lighthouse;
  j = EXTR(256, 4);
  for (i = 0; i != 4; i++) {
    *palette_pos++ = s[j];
    j++;
    if (j == 4) j = 0;
  }

  /* Animate water for old DOS graphics */
  if (_use_palette == PAL_DOS) {
    /* Dark blue water DOS */
    s = (_settings_game.game_creation.landscape == LT_TOYLAND) ? ev->dark_water_TOY : ev->dark_water;
    j = EXTR(320, 5);
    for (i = 0; i != 5; i++) {
      *palette_pos++ = s[j];
      j++;
      if (j == 5) j = 0;
    }

    /* Glittery water DOS */
    s = (_settings_game.game_creation.landscape == LT_TOYLAND) ? ev->glitter_water_TOY : ev->glitter_water;
    j = EXTR(128, 15);
    for (i = 0; i != 5; i++) {
      *palette_pos++ = s[j];
      j += 3;
      if (j >= 15) j -= 15;
    }
  }

  if (blitter != NULL && blitter->UsePaletteAnimation() == Blitter::PALETTE_ANIMATION_NONE) {
    _palette_animation_counter = old_tc;
  } else {
    if (memcmp(old_val, &_cur_palette[PALETTE_ANIM_SIZE_START], oldval_size) != 0) {
      /* Did we changed anything on the palette? Seems so.  Mark it as dirty */
      _pal_first_dirty = PALETTE_ANIM_SIZE_START;
      _pal_count_dirty = colour_rotation_amount;
    }
  }
}


void LoadStringWidthTable()
{
  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)
{
  /* Use _stringwidth_table cache if possible */
  if (key >= 32 && key < 256) return _stringwidth_table[size][key - 32];

  return GetGlyphWidth(size, key);
}


void ScreenSizeChanged()
{
  _dirty_bytes_per_line = (_screen.width + DIRTY_BLOCK_WIDTH - 1) / DIRTY_BLOCK_WIDTH;
  _dirty_blocks = ReallocT<byte>(_dirty_blocks, _dirty_bytes_per_line * ((_screen.height + DIRTY_BLOCK_HEIGHT - 1) / DIRTY_BLOCK_HEIGHT));

  /* 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()
{
  if (_cursor.visible) {
    Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();
    _cursor.visible = false;
    blitter->CopyFromBuffer(blitter->MoveTo(_screen.dst_ptr, _cursor.draw_pos.x, _cursor.draw_pos.y), _cursor_backup, _cursor.draw_size.x, _cursor.draw_size.y);
    _video_driver->MakeDirty(_cursor.draw_pos.x, _cursor.draw_pos.y, _cursor.draw_size.x, _cursor.draw_size.y);
  }
}

void DrawMouseCursor()
{
#if defined(WINCE)
  /* Don't ever draw the mouse for WinCE, as we work with a stylus */
  return;
#endif