1 /* $Id$ */

     2 

     3 #include "stdafx.h"

     4 #include "openttd.h"

     5 #include "functions.h"

     6 #include "macros.h"

     7 #include "spritecache.h"

     8 #include "strings.h"

     9 #include "string.h"

    10 #include "gfx.h"

    11 #include "table/palettes.h"

    12 #include "table/sprites.h"

    13 #include "hal.h"

    14 #include "variables.h"

    15 #include "table/control_codes.h"

    16 #include "fontcache.h"

    17 #include "genworld.h"

    18 #include "debug.h"

    19 

    20 #ifdef _DEBUG

    21 bool _dbg_screen_rect;

    22 #endif

    23 

    24 Colour _cur_palette[256];

    25 byte _stringwidth_table[FS_END][224];

    26 

    27 typedef enum BlitterModes {

    28 	BM_NORMAL,

    29 	BM_COLOUR_REMAP,

    30 	BM_TRANSPARENT,

    31 } BlitterMode;

    32 

    33 static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode);

    34 

    35 FontSize _cur_fontsize;

    36 static FontSize _last_fontsize;

    37 static Pixel _cursor_backup[64 * 64];

    38 static Rect _invalid_rect;

    39 static const byte *_color_remap_ptr;

    40 static byte _string_colorremap[3];

    41 

    42 #define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    43 static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    44 

    45 void memcpy_pitch(void *dst, void *src, int w, int h, int srcpitch, int dstpitch)

    46 {

    47 	byte *dstp = (byte*)dst;

    48 	byte *srcp = (byte*)src;

    49 

    50 	assert(h >= 0);

    51 	for (; h != 0; --h) {

    52 		memcpy(dstp, srcp, w);

    53 		dstp += dstpitch;

    54 		srcp += srcpitch;

    55 	}

    56 }

    57 

    58 void GfxScroll(int left, int top, int width, int height, int xo, int yo)

    59 {

    60 	const Pixel *src;

    61 	Pixel *dst;

    62 	int p;

    63 	int ht;

    64 

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

    66 

    67 	if (_cursor.visible) UndrawMouseCursor();

    68 	UndrawTextMessage();

    69 

    70 	p = _screen.pitch;

    71 

    72 	if (yo > 0) {

    73 		// Calculate pointers

    74 		dst = _screen.dst_ptr + (top + height - 1) * p + left;

    75 		src = dst - yo * p;

    76 

    77 		// Decrease height and increase top

    78 		top += yo;

    79 		height -= yo;

    80 		assert(height > 0);

    81 

    82 		// Adjust left & width

    83 		if (xo >= 0) {

    84 			dst += xo;

    85 			left += xo;

    86 			width -= xo;

    87 		} else {

    88 			src -= xo;

    89 			width += xo;

    90 		}

    91 

    92 		for (ht = height; ht > 0; --ht) {

    93 			memcpy(dst, src, width);

    94 			src -= p;

    95 			dst -= p;

    96 		}

    97 	} else {

    98 		// Calculate pointers

    99 		dst = _screen.dst_ptr + top * p + left;

   100 		src = dst - yo * p;

   101 

   102 		// Decrese height. (yo is <=0).

   103 		height += yo;

   104 		assert(height > 0);

   105 

   106 		// Adjust left & width

   107 		if (xo >= 0) {

   108 			dst += xo;

   109 			left += xo;

   110 			width -= xo;

   111 		} else {

   112 			src -= xo;

   113 			width += xo;

   114 		}

   115 

   116 		// the y-displacement may be 0 therefore we have to use memmove,

   117 		// because source and destination may overlap

   118 		for (ht = height; ht > 0; --ht) {

   119 			memmove(dst, src, width);

   120 			src += p;

   121 			dst += p;

   122 		}

   123 	}

   124 	// This part of the screen is now dirty.

   125 	_video_driver->make_dirty(left, top, width, height);

   126 }

   127 

   128 

   129 void GfxFillRect(int left, int top, int right, int bottom, int color)

   130 {

   131 	const DrawPixelInfo* dpi = _cur_dpi;

   132 	Pixel *dst;

   133 	const int otop = top;

   134 	const int oleft = left;

   135 

   136 	if (dpi->zoom != 0) return;

   137 	if (left > right || top > bottom) return;

   138 	if (right < dpi->left || left >= dpi->left + dpi->width) return;

   139 	if (bottom < dpi->top || top >= dpi->top + dpi->height) return;

   140 

   141 	if ( (left -= dpi->left) < 0) left = 0;

   142 	right = right - dpi->left + 1;

   143 	if (right > dpi->width) right = dpi->width;

   144 	right -= left;

   145 	assert(right > 0);

   146 

   147 	if ( (top -= dpi->top) < 0) top = 0;

   148 	bottom = bottom - dpi->top + 1;

   149 	if (bottom > dpi->height) bottom = dpi->height;

   150 	bottom -= top;

   151 	assert(bottom > 0);

   152 

   153 	dst = dpi->dst_ptr + top * dpi->pitch + left;

   154 

   155 	if (!(color & PALETTE_MODIFIER_GREYOUT)) {

   156 		if (!(color & USE_COLORTABLE)) {

   157 			do {

   158 				memset(dst, color, right);

   159 				dst += dpi->pitch;

   160 			} while (--bottom);

   161 		} else {

   162 			/* use colortable mode */

   163 			const byte* ctab = GetNonSprite(color & COLORTABLE_MASK) + 1;

   164 

   165 			do {

   166 				int i;

   167 				for (i = 0; i != right; i++) dst[i] = ctab[dst[i]];

   168 				dst += dpi->pitch;

   169 			} while (--bottom);

   170 		}

   171 	} else {

   172 		byte bo = (oleft - left + dpi->left + otop - top + dpi->top) & 1;

   173 		do {

   174 			int i;

   175 			for (i = (bo ^= 1); i < right; i += 2) dst[i] = (byte)color;

   176 			dst += dpi->pitch;

   177 		} while (--bottom > 0);

   178 	}

   179 }

   180 

   181 static void GfxSetPixel(int x, int y, int color)

   182 {

   183 	const DrawPixelInfo* dpi = _cur_dpi;

   184 	if ((x-=dpi->left) < 0 || x>=dpi->width || (y-=dpi->top)<0 || y>=dpi->height)

   185 		return;

   186 	dpi->dst_ptr[y * dpi->pitch + x] = color;

   187 }

   188 

   189 void GfxDrawLine(int x, int y, int x2, int y2, int color)

   190 {

   191 	int dy;

   192 	int dx;

   193 	int stepx;

   194 	int stepy;

   195 	int frac;

   196 

   197 	// Check clipping first

   198 	{

   199 		DrawPixelInfo *dpi = _cur_dpi;

   200 		int t;

   201 

   202 		if (x < dpi->left && x2 < dpi->left) return;

   203 

   204 		if (y < dpi->top && y2 < dpi->top) return;

   205 

   206 		t = dpi->left + dpi->width;

   207 		if (x > t && x2 > t) return;

   208 

   209 		t = dpi->top + dpi->height;

   210 		if (y > t && y2 > t) return;

   211 	}

   212 

   213 	dy = (y2 - y) * 2;

   214 	if (dy < 0) {

   215 		dy = -dy;

   216 		stepy = -1;

   217 	} else {

   218 		stepy = 1;

   219 	}

   220 

   221 	dx = (x2 - x) * 2;

   222 	if (dx < 0) {

   223 		dx = -dx;

   224 		stepx = -1;

   225 	} else {

   226 		stepx = 1;

   227 	}

   228 

   229 	GfxSetPixel(x, y, color);

   230 	if (dx > dy) {

   231 		frac = dy - (dx >> 1);

   232 		while (x != x2) {

   233 			if (frac >= 0) {

   234 				y += stepy;

   235 				frac -= dx;

   236 			}

   237 			x += stepx;

   238 			frac += dy;

   239 			GfxSetPixel(x, y, color);

   240 		}

   241 	} else {

   242 		frac = dx - (dy >> 1);

   243 		while (y != y2) {

   244 			if (frac >= 0) {

   245 				x += stepx;

   246 				frac -= dy;

   247 			}

   248 			y += stepy;

   249 			frac += dx;

   250 			GfxSetPixel(x, y, color);

   251 		}

   252 	}

   253 }

   254 

   255 

   256 /** Truncate a given string to a maximum width if neccessary.

   257  * If the string is truncated, add three dots ('...') to show this.

   258  * @param *dest string that is checked and possibly truncated

   259  * @param maxw maximum width in pixels of the string

   260  * @return new width of (truncated) string */

   261 static int TruncateString(char *str, int maxw)

   262 {

   263 	int w = 0;

   264 	FontSize size = _cur_fontsize;

   265 	int ddd, ddd_w;

   266 

   267 	WChar c;

   268 	char *ddd_pos;

   269 

   270 	ddd_w = ddd = GetCharacterWidth(size, '.') * 3;

   271 

   272 	for (ddd_pos = str; (c = Utf8Consume((const char **)&str)) != '\0'; ) {

   273 		if (IsPrintable(c)) {

   274 			w += GetCharacterWidth(size, c);

   275 

   276 			if (w >= maxw) {

   277 				// string got too big... insert dotdotdot

   278 				ddd_pos[0] = ddd_pos[1] = ddd_pos[2] = '.';

   279 				ddd_pos[3] = 0;

   280 				return ddd_w;

   281 			}

   282 		} else {

   283 			if (c == SCC_SETX) str++;

   284 			else if (c == SCC_SETXY) str += 2;

   285 			else if (c == SCC_TINYFONT) {

   286 				size = FS_SMALL;

   287 				ddd = GetCharacterWidth(size, '.') * 3;

   288 			} else if (c == SCC_BIGFONT) {

   289 				size = FS_LARGE;

   290 				ddd = GetCharacterWidth(size, '.') * 3;

   291 			}

   292 		}

   293 

   294 		// Remember the last position where three dots fit.

   295 		if (w + ddd < maxw) {

   296 			ddd_w = w + ddd;

   297 			ddd_pos = str;

   298 		}

   299 	}

   300 

   301 	return w;

   302 }

   303 

   304 static inline int TruncateStringID(StringID src, char *dest, int maxw, const char* last)

   305 {

   306 	GetString(dest, src, last);

   307 	return TruncateString(dest, maxw);

   308 }

   309 

   310 /* returns right coordinate */

   311 int DrawString(int x, int y, StringID str, uint16 color)

   312 {

   313 	char buffer[512];

   314 

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

   316 	return DoDrawString(buffer, x, y, color);

   317 }

   318 

   319 int DrawStringTruncated(int x, int y, StringID str, uint16 color, uint maxw)

   320 {

   321 	char buffer[512];

   322 	TruncateStringID(str, buffer, maxw, lastof(buffer));

   323 	return DoDrawString(buffer, x, y, color);

   324 }

   325 

   326 

   327 int DrawStringRightAligned(int x, int y, StringID str, uint16 color)

   328 {

   329 	char buffer[512];

   330 	int w;

   331 

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

   333 	w = GetStringBoundingBox(buffer).width;

   334 	DoDrawString(buffer, x - w, y, color);

   335 

   336 	return w;

   337 }

   338 

   339 void DrawStringRightAlignedTruncated(int x, int y, StringID str, uint16 color, uint maxw)

   340 {

   341 	char buffer[512];

   342 

   343 	TruncateStringID(str, buffer, maxw, lastof(buffer));

   344 	DoDrawString(buffer, x - GetStringBoundingBox(buffer).width, y, color);

   345 }

   346 

   347 void DrawStringRightAlignedUnderline(int x, int y, StringID str, uint16 color)

   348 {

   349 	int w = DrawStringRightAligned(x, y, str, color);

   350 	GfxFillRect(x - w, y + 10, x, y + 10, _string_colorremap[1]);

   351 }

   352 

   353 

   354 int DrawStringCentered(int x, int y, StringID str, uint16 color)

   355 {

   356 	char buffer[512];

   357 	int w;

   358 

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

   360 

   361 	w = GetStringBoundingBox(buffer).width;

   362 	DoDrawString(buffer, x - w / 2, y, color);

   363 

   364 	return w;

   365 }

   366 

   367 int DrawStringCenteredTruncated(int xl, int xr, int y, StringID str, uint16 color)

   368 {

   369 	char buffer[512];

   370 	int w = TruncateStringID(str, buffer, xr - xl, lastof(buffer));

   371 	return DoDrawString(buffer, (xl + xr - w) / 2, y, color);

   372 }

   373 

   374 int DoDrawStringCentered(int x, int y, const char *str, uint16 color)

   375 {

   376 	int w = GetStringBoundingBox(str).width;

   377 	DoDrawString(str, x - w / 2, y, color);

   378 	return w;

   379 }

   380 

   381 void DrawStringCenterUnderline(int x, int y, StringID str, uint16 color)

   382 {

   383 	int w = DrawStringCentered(x, y, str, color);

   384 	GfxFillRect(x - (w >> 1), y + 10, x - (w >> 1) + w, y + 10, _string_colorremap[1]);

   385 }

   386 

   387 void DrawStringCenterUnderlineTruncated(int xl, int xr, int y, StringID str, uint16 color)

   388 {

   389 	int w = DrawStringCenteredTruncated(xl, xr, y, str, color);

   390 	GfxFillRect((xl + xr - w) / 2, y + 10, (xl + xr + w) / 2, y + 10, _string_colorremap[1]);

   391 }

   392 

   393 /** 'Correct' a string to a maximum length. Longer strings will be cut into

   394  * additional lines at whitespace characters if possible. The string parameter

   395  * is modified with terminating characters mid-string which are the

   396  * placeholders for the newlines.<br/>

   397  * The string WILL be truncated if there was no whitespace for the current

   398  * line's maximum width.

   399  *

   400  * @note To know if the the terminating '\0' is the string end or just a

   401  * newline, the returned 'num' value should be consulted. The num'th '\0',

   402  * starting with index 0 is the real string end.

   403  *

   404  * @param str string to check and correct for length restrictions

   405  * @param maxw the maximum width the string can have on one line

   406  * @return return a 32bit wide number consisting of 2 packed values:

   407  *  0 - 15 the number of lines ADDED to the string

   408  * 16 - 31 the fontsize in which the length calculation was done at */

   409 uint32 FormatStringLinebreaks(char *str, int maxw)

   410 {

   411 	FontSize size = _cur_fontsize;

   412 	int num = 0;

   413 

   414 	assert(maxw > 0);

   415 

   416 	for (;;) {

   417 		char *last_space = NULL;

   418 		int w = 0;

   419 

   420 		for (;;) {

   421 			WChar c = Utf8Consume((const char **)&str);

   422 			/* whitespace is where we will insert the line-break */

   423 			if (c == ' ') last_space = str;

   424 

   425 			if (IsPrintable(c)) {

   426 				w += GetCharacterWidth(size, c);

   427 				/* string is longer than maximum width so we need to decide what to

   428 				 * do. We can do two things:

   429 				 * 1. If no whitespace was found at all up until now (on this line) then

   430 				 *    we will truncate the string and bail out.

   431 				 * 2. In all other cases force a linebreak at the last seen whitespace */

   432 				if (w > maxw) {

   433 					if (last_space == NULL) {

   434 						str[-1] = '\0';

   435 						return num + (size << 16);

   436 					}

   437 					str = last_space;

   438 					break;

   439 				}

   440 			} else {

   441 				switch (c) {

   442 					case '\0': return num + (size << 16); break;

   443 					case SCC_SETX:  str++; break;

   444 					case SCC_SETXY: str +=2; break;

   445 					case SCC_TINYFONT: size = FS_SMALL; break;

   446 					case SCC_BIGFONT:  size = FS_LARGE; break;

   447 					case '\n': goto end_of_inner_loop;

   448 				}

   449 			}

   450 		}

   451 end_of_inner_loop:

   452 		/* string didn't fit on line, so 'dummy' terminate and increase linecount */

   453 		num++;

   454 		str[-1] = '\0';

   455 	}

   456 }

   457 

   458 /** Draw a given string with the centre around the given x coordinates

   459  * @param x Centre the string around this pixel width

   460  * @param y Draw the string at this pixel height (first line's bottom)

   461  * @param str String to draw

   462  * @param max Maximum width the string can have before it is wrapped */

   463 void DrawStringMultiCenter(int x, int y, StringID str, int maxw)

   464 {

   465 	char buffer[512];

   466 	uint32 tmp;

   467 	int num, w, mt;

   468 	const char *src;

   469 	WChar c;

   470 

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

   472 

   473 	tmp = FormatStringLinebreaks(buffer, maxw);

   474 	num = GB(tmp, 0, 16);

   475 

   476 	mt = GetCharacterHeight(GB(tmp, 16, 16));

   477 

   478 	y -= (mt >> 1) * num;

   479 

   480 	src = buffer;

   481 

   482 	for (;;) {

   483 		w = GetStringBoundingBox(src).width;

   484 		DoDrawString(src, x - (w>>1), y, 0xFE);

   485 		_cur_fontsize = _last_fontsize;

   486 

   487 		for (;;) {

   488 			c = Utf8Consume(&src);

   489 			if (c == 0) {

   490 				y += mt;

   491 				if (--num < 0) {

   492 					_cur_fontsize = FS_NORMAL;

   493 					return;

   494 				}

   495 				break;

   496 			} else if (c == SCC_SETX) {

   497 				src++;

   498 			} else if (c == SCC_SETXY) {

   499 				src+=2;

   500 			}

   501 		}

   502 	}

   503 }

   504 

   505 

   506 uint DrawStringMultiLine(int x, int y, StringID str, int maxw)

   507 {

   508 	char buffer[512];

   509 	uint32 tmp;

   510 	int num, mt;

   511 	uint total_height;

   512 	const char *src;

   513 	WChar c;

   514 

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

   516 

   517 	tmp = FormatStringLinebreaks(buffer, maxw);

   518 	num = GB(tmp, 0, 16);

   519 

   520 	mt = GetCharacterHeight(GB(tmp, 16, 16));

   521 	total_height = (num + 1) * mt;

   522 

   523 	src = buffer;

   524 

   525 	for (;;) {

   526 		DoDrawString(src, x, y, 0xFE);

   527 		_cur_fontsize = _last_fontsize;

   528 

   529 		for (;;) {

   530 			c = Utf8Consume(&src);

   531 			if (c == 0) {

   532 				y += mt;

   533 				if (--num < 0) {

   534 					_cur_fontsize = FS_NORMAL;

   535 					return total_height;

   536 				}

   537 				break;

   538 			} else if (c == SCC_SETX) {

   539 				src++;

   540 			} else if (c == SCC_SETXY) {

   541 				src+=2;

   542 			}

   543 		}

   544 	}

   545 }

   546 

   547 /** Return the string dimension in pixels. The height and width are returned

   548  * in a single BoundingRect value. TINYFONT, BIGFONT modifiers are only

   549  * supported as the first character of the string. The returned dimensions

   550  * are therefore a rough estimation correct for all the current strings

   551  * but not every possible combination

   552  * @param str string to calculate pixel-width

   553  * @return string width and height in pixels */

   554 BoundingRect GetStringBoundingBox(const char *str)

   555 {

   556 	FontSize size = _cur_fontsize;

   557 	BoundingRect br;

   558 	int max_width;

   559 	WChar c;

   560 

   561 	br.width = br.height = max_width = 0;

   562 	for (;;) {

   563 		c = Utf8Consume(&str);

   564 		if (c == 0) break;

   565 		if (IsPrintable(c)) {

   566 			br.width += GetCharacterWidth(size, c);

   567 		} else {

   568 			switch (c) {

   569 				case SCC_SETX: br.width += (byte)*str++; break;

   570 				case SCC_SETXY:

   571 					br.width += (byte)*str++;

   572 					br.height += (byte)*str++;

   573 					break;

   574 				case SCC_TINYFONT: size = FS_SMALL; break;

   575 				case SCC_BIGFONT:  size = FS_LARGE; break;

   576 				case '\n':

   577 					br.height += GetCharacterHeight(size);

   578 					if (br.width > max_width) max_width = br.width;

   579 					br.width = 0;

   580 					break;

   581 			}

   582 		}

   583 	}

   584 	br.height += GetCharacterHeight(size);

   585 

   586 	br.width  = max(br.width, max_width);

   587 	return br;

   588 }

   589 

   590 /** Draw a string at the given coordinates with the given colour

   591  * @param string the string to draw

   592  * @param x offset from left side of the screen, if negative offset from the right side

   593  * @param x offset from top side of the screen, if negative offset from the bottom

   594  * @param real_color colour of the string, see _string_colormap in

   595  * table/palettes.h or docs/ottd-colourtext-palette.png

   596  * @return the x-coordinates where the drawing has finished. If nothing is drawn

   597  * the originally passed x-coordinate is returned */

   598 int DoDrawString(const char *string, int x, int y, uint16 real_color)

   599 {

   600 	DrawPixelInfo *dpi = _cur_dpi;

   601 	FontSize size = _cur_fontsize;

   602 	WChar c;

   603 	byte color;

   604 	int xo = x, yo = y;

   605 

   606 	color = real_color & 0xFF;

   607 

   608 	if (color != 0xFE) {

   609 		if (x >= dpi->left + dpi->width ||

   610 				x + _screen.width*2 <= dpi->left ||

   611 				y >= dpi->top + dpi->height ||

   612 				y + _screen.height <= dpi->top)

   613 					return x;

   614 

   615 		if (color != 0xFF) {

   616 switch_color:;

   617 			if (real_color & IS_PALETTE_COLOR) {

   618 				_string_colorremap[1] = color;

   619 				_string_colorremap[2] = 215;

   620 			} else {

   621 				_string_colorremap[1] = _string_colormap[color].text;

   622 				_string_colorremap[2] = _string_colormap[color].shadow;

   623 			}

   624 			_color_remap_ptr = _string_colorremap;

   625 		}

   626 	}

   627 

   628 check_bounds:

   629 	if (y + 19 <= dpi->top || dpi->top + dpi->height <= y) {

   630 skip_char:;

   631 		for (;;) {

   632 			c = Utf8Consume(&string);

   633 			if (!IsPrintable(c)) goto skip_cont;

   634 		}

   635 	}

   636 

   637 	for (;;) {

   638 		c = Utf8Consume(&string);

   639 skip_cont:;

   640 		if (c == 0) {

   641 			_last_fontsize = size;

   642 			return x;

   643 		}

   644 		if (IsPrintable(c)) {

   645 			if (x >= dpi->left + dpi->width) goto skip_char;

   646 			if (x + 26 >= dpi->left) {

   647 				GfxMainBlitter(GetGlyph(size, c), x, y, BM_COLOUR_REMAP);

   648 			}

   649 			x += GetCharacterWidth(size, c);

   650 		} else if (c == '\n') { // newline = {}

   651 			x = xo;

   652 			y += GetCharacterHeight(size);

   653 			goto check_bounds;

   654 		} else if (c >= SCC_BLUE && c <= SCC_BLACK) { // change color?

   655 			color = (byte)(c - SCC_BLUE);

   656 			goto switch_color;

   657 		} else if (c == SCC_SETX) { // {SETX}

   658 			x = xo + (byte)*string++;

   659 		} else if (c == SCC_SETXY) {// {SETXY}

   660 			x = xo + (byte)*string++;

   661 			y = yo + (byte)*string++;

   662 		} else if (c == SCC_TINYFONT) { // {TINYFONT}

   663 			size = FS_SMALL;

   664 		} else if (c == SCC_BIGFONT) { // {BIGFONT}

   665 			size = FS_LARGE;

   666 		} else {

   667 			DEBUG(misc, 0, "[utf8] unknown string command character %d", c);

   668 		}

   669 	}

   670 }

   671 

   672 int DoDrawStringTruncated(const char *str, int x, int y, uint16 color, uint maxw)

   673 {

   674 	char buffer[512];

   675 	ttd_strlcpy(buffer, str, sizeof(buffer));

   676 	TruncateString(buffer, maxw);

   677 	return DoDrawString(buffer, x, y, color);

   678 }

   679 

   680 void DrawSprite(uint32 img, int x, int y)

   681 {

   682 	if (img & PALETTE_MODIFIER_COLOR) {

   683 		_color_remap_ptr = GetNonSprite(GB(img, PALETTE_SPRITE_START, PALETTE_SPRITE_WIDTH)) + 1;

   684 		GfxMainBlitter(GetSprite(img & SPRITE_MASK), x, y, BM_COLOUR_REMAP);

   685 	} else if (img & PALETTE_MODIFIER_TRANSPARENT) {

   686 		_color_remap_ptr = GetNonSprite(GB(img, PALETTE_SPRITE_START, PALETTE_SPRITE_WIDTH)) + 1;

   687 		GfxMainBlitter(GetSprite(img & SPRITE_MASK), x, y, BM_TRANSPARENT);

   688 	} else {

   689 		GfxMainBlitter(GetSprite(img & SPRITE_MASK), x, y, BM_NORMAL);

   690 	}

   691 }

   692 

   693 typedef struct BlitterParams {

   694 	int start_x, start_y;

   695 	const byte *sprite;

   696 	Pixel *dst;

   697 	BlitterMode mode;

   698 	int width, height;

   699 	int width_org;

   700 	int pitch;

   701 } BlitterParams;

   702 

   703 static void GfxBlitTileZoomIn(BlitterParams *bp)

   704 {

   705 	const byte *src_o = bp->sprite;

   706 	const byte *src;

   707 	int num, skip;

   708 	byte done;

   709 	Pixel *dst;

   710 	const byte *ctab;

   711 

   712 	src_o += ReadLE16Aligned(src_o + bp->start_y * 2);

   713 	switch (bp->mode) {

   714 		case BM_COLOUR_REMAP:

   715 			do {

   716 				do {

   717 					done = src_o[0];

   718 					num = done & 0x7F;

   719 					skip = src_o[1];

   720 					src = src_o + 2;

   721 					src_o += num + 2;

   722 

   723 					dst = bp->dst;

   724 

   725 					if ( (skip -= bp->start_x) > 0) {

   726 						dst += skip;

   727 					} else {

   728 						src -= skip;

   729 						num += skip;

   730 						if (num <= 0) continue;

   731 						skip = 0;

   732 					}

   733 

   734 					skip = skip + num - bp->width;

   735 					if (skip > 0) {

   736 						num -= skip;

   737 						if (num <= 0) continue;

   738 					}

   739 

   740 					ctab = _color_remap_ptr;

   741 

   742 					for (; num >= 4; num -=4) {

   743 						dst[3] = ctab[src[3]];

   744 						dst[2] = ctab[src[2]];

   745 						dst[1] = ctab[src[1]];

   746 						dst[0] = ctab[src[0]];

   747 						dst += 4;

   748 						src += 4;

   749 					}

   750 					for (; num != 0; num--) *dst++ = ctab[*src++];

   751 				} while (!(done & 0x80));

   752 

   753 				bp->dst += bp->pitch;

   754 			} while (--bp->height != 0);

   755 			break;

   756 

   757 		case BM_TRANSPARENT:

   758 			do {

   759 				do {

   760 					done = src_o[0];

   761 					num = done & 0x7F;

   762 					skip = src_o[1];

   763 					src_o += num + 2;

   764 

   765 					dst = bp->dst;

   766 

   767 					if ( (skip -= bp->start_x) > 0) {

   768 						dst += skip;

   769 					} else {

   770 						num += skip;

   771 						if (num <= 0) continue;

   772 						skip = 0;

   773 					}

   774 

   775 					skip = skip + num - bp->width;

   776 					if (skip > 0) {

   777 						num -= skip;

   778 						if (num <= 0) continue;

   779 					}

   780 

   781 					ctab = _color_remap_ptr;

   782 					for (; num != 0; num--) {

   783 						*dst = ctab[*dst];

   784 						dst++;

   785 					}

   786 				} while (!(done & 0x80));

   787 

   788 				bp->dst += bp->pitch;

   789 			} while (--bp->height != 0);

   790 			break;

   791 

   792 		default:

   793 			do {

   794 				do {

   795 					done = src_o[0];

   796 					num = done & 0x7F;

   797 					skip = src_o[1];

   798 					src = src_o + 2;

   799 					src_o += num + 2;

   800 

   801 					dst = bp->dst;

   802 

   803 					if ( (skip -= bp->start_x) > 0) {

   804 						dst += skip;

   805 					} else {

   806 						src -= skip;

   807 						num += skip;

   808 						if (num <= 0) continue;

   809 						skip = 0;

   810 					}

   811 

   812 					skip = skip + num - bp->width;

   813 					if (skip > 0) {

   814 						num -= skip;

   815 						if (num <= 0) continue;

   816 					}

   817 #if defined(_WIN32)

   818 					if (num & 1) *dst++ = *src++;

   819 					if (num & 2) { *(uint16*)dst = *(uint16*)src; dst += 2; src += 2; }

   820 					if (num >>= 2) {

   821 						do {

   822 							*(uint32*)dst = *(uint32*)src;

   823 							dst += 4;

   824 							src += 4;

   825 						} while (--num != 0);

   826 					}

   827 #else

   828 					memcpy(dst, src, num);

   829 #endif

   830 				} while (!(done & 0x80));

   831 

   832 				bp->dst += bp->pitch;

   833 			} while (--bp->height != 0);

   834 			break;

   835 	}

   836 }

   837 

   838 static void GfxBlitZoomInUncomp(BlitterParams *bp)

   839 {

   840 	const byte *src = bp->sprite;

   841 	Pixel *dst = bp->dst;

   842 	int height = bp->height;

   843 	int width = bp->width;

   844 	int i;

   845 

   846 	assert(height > 0);

   847 	assert(width > 0);

   848 

   849 	switch (bp->mode) {

   850 		case BM_COLOUR_REMAP: {

   851 			const byte *ctab = _color_remap_ptr;

   852 

   853 			do {

   854 				for (i = 0; i != width; i++) {

   855 					byte b = ctab[src[i]];

   856 

   857 					if (b != 0) dst[i] = b;

   858 				}

   859 				src += bp->width_org;

   860 				dst += bp->pitch;

   861 			} while (--height != 0);

   862 			break;

   863 		}

   864 

   865 		case BM_TRANSPARENT: {

   866 			const byte *ctab = _color_remap_ptr;

   867 

   868 			do {

   869 				for (i = 0; i != width; i++)

   870 					if (src[i] != 0) dst[i] = ctab[dst[i]];

   871 				src += bp->width_org;

   872 				dst += bp->pitch;

   873 			} while (--height != 0);

   874 			break;

   875 		}

   876 

   877 		default:

   878 			do {

   879 				int n = width;

   880 

   881 				for (; n >= 4; n -= 4) {

   882 					if (src[0] != 0) dst[0] = src[0];

   883 					if (src[1] != 0) dst[1] = src[1];

   884 					if (src[2] != 0) dst[2] = src[2];

   885 					if (src[3] != 0) dst[3] = src[3];

   886 

   887 					dst += 4;

   888 					src += 4;

   889 				}

   890 

   891 				for (; n != 0; n--) {

   892 					if (src[0] != 0) dst[0] = src[0];

   893 					src++;

   894 					dst++;

   895 				}

   896 

   897 				src += bp->width_org - width;

   898 				dst += bp->pitch - width;

   899 			} while (--height != 0);

   900 			break;

   901 	}

   902 }

   903 

   904 static void GfxBlitTileZoomMedium(BlitterParams *bp)

   905 {

   906 	const byte *src_o = bp->sprite;

   907 	const byte *src;

   908 	int num, skip;

   909 	byte done;

   910 	Pixel *dst;

   911 	const byte *ctab;

   912 

   913 	src_o += ReadLE16Aligned(src_o + bp->start_y * 2);

   914 	switch (bp->mode) {

   915 		case BM_COLOUR_REMAP:

   916 			do {

   917 				do {

   918 					done = src_o[0];

   919 					num = done & 0x7F;

   920 					skip = src_o[1];

   921 					src = src_o + 2;

   922 					src_o += num + 2;

   923 

   924 					dst = bp->dst;

   925 

   926 					if (skip & 1) {

   927 						skip++;

   928 						src++;

   929 						if (--num == 0) continue;

   930 					}

   931 

   932 					if ( (skip -= bp->start_x) > 0) {

   933 						dst += skip >> 1;

   934 					} else {

   935 						src -= skip;

   936 						num += skip;

   937 						if (num <= 0) continue;

   938 						skip = 0;

   939 					}

   940 

   941 					skip = skip + num - bp->width;

   942 					if (skip > 0) {

   943 						num -= skip;

   944 						if (num <= 0) continue;

   945 					}

   946 

   947 					ctab = _color_remap_ptr;

   948 					num = (num + 1) >> 1;

   949 					for (; num != 0; num--) {

   950 							*dst = ctab[*src];

   951 							dst++;

   952 							src += 2;

   953 					}

   954 				} while (!(done & 0x80));

   955 				bp->dst += bp->pitch;

   956 				if (--bp->height == 0) return;

   957 

   958 				do {

   959 					done = src_o[0];

   960 					src_o += (done & 0x7F) + 2;

   961 				} while (!(done & 0x80));

   962 			} while (--bp->height != 0);

   963 			break;

   964 

   965 		case BM_TRANSPARENT:

   966 			do {

   967 				do {

   968 					done = src_o[0];

   969 					num = done & 0x7F;

   970 					skip = src_o[1];

   971 					src_o += num + 2;

   972 

   973 					dst = bp->dst;

   974 

   975 					if (skip & 1) {

   976 						skip++;

   977 						if (--num == 0) continue;

   978 					}

   979 

   980 					if ( (skip -= bp->start_x) > 0) {

   981 						dst += skip >> 1;

   982 					} else {

   983 						num += skip;

   984 						if (num <= 0) continue;

   985 						skip = 0;

   986 					}

   987 

   988 					skip = skip + num - bp->width;

   989 					if (skip > 0) {

   990 						num -= skip;

   991 						if (num <= 0) continue;

   992 					}

   993 

   994 					ctab = _color_remap_ptr;

   995 					num = (num + 1) >> 1;

   996 					for (; num != 0; num--) {

   997 							*dst = ctab[*dst];

   998 							dst++;

   999 					}

  1000 				} while (!(done & 0x80));

  1001 				bp->dst += bp->pitch;

  1002 				if (--bp->height == 0) return;

  1003 

  1004 				do {

  1005 					done = src_o[0];

  1006 					src_o += (done & 0x7F) + 2;

  1007 				} while (!(done & 0x80));

  1008 			} while (--bp->height != 0);

  1009 			break;

  1010 

  1011 		default:

  1012 			do {

  1013 				do {

  1014 					done = src_o[0];

  1015 					num = done & 0x7F;

  1016 					skip = src_o[1];

  1017 					src = src_o + 2;

  1018 					src_o += num + 2;

  1019 

  1020 					dst = bp->dst;

  1021 

  1022 					if (skip & 1) {

  1023 						skip++;

  1024 						src++;

  1025 						if (--num == 0) continue;

  1026 					}

  1027 

  1028 					if ( (skip -= bp->start_x) > 0) {

  1029 						dst += skip >> 1;

  1030 					} else {

  1031 						src -= skip;

  1032 						num += skip;

  1033 						if (num <= 0) continue;

  1034 						skip = 0;

  1035 					}

  1036 

  1037 					skip = skip + num - bp->width;

  1038 					if (skip > 0) {

  1039 						num -= skip;

  1040 						if (num <= 0) continue;

  1041 					}

  1042 

  1043 					num = (num + 1) >> 1;

  1044 

  1045 					for (; num != 0; num--) {

  1046 							*dst = *src;

  1047 							dst++;

  1048 							src += 2;

  1049 					}

  1050 

  1051 				} while (!(done & 0x80));

  1052 

  1053 				bp->dst += bp->pitch;

  1054 				if (--bp->height == 0) return;

  1055 

  1056 				do {

  1057 					done = src_o[0];

  1058 					src_o += (done & 0x7F) + 2;

  1059 				} while (!(done & 0x80));

  1060 			} while (--bp->height != 0);

  1061 			break;

  1062 	}

  1063 }

  1064 

  1065 static void GfxBlitZoomMediumUncomp(BlitterParams *bp)

  1066 {

  1067 	const byte *src = bp->sprite;

  1068 	Pixel *dst = bp->dst;

  1069 	int height = bp->height;

  1070 	int width = bp->width;

  1071 	int i;

  1072 

  1073 	assert(height > 0);

  1074 	assert(width > 0);

  1075 

  1076 	switch (bp->mode) {

  1077 		case BM_COLOUR_REMAP: {

  1078 			const byte *ctab = _color_remap_ptr;

  1079 

  1080 			for (height >>= 1; height != 0; height--) {

  1081 				for (i = 0; i != width >> 1; i++) {

  1082 					byte b = ctab[src[i * 2]];

  1083 

  1084 					if (b != 0) dst[i] = b;

  1085 				}

  1086 				src += bp->width_org * 2;

  1087 				dst += bp->pitch;

  1088 			}

  1089 			break;

  1090 		}

  1091 

  1092 		case BM_TRANSPARENT: {

  1093 			const byte *ctab = _color_remap_ptr;

  1094 

  1095 			for (height >>= 1; height != 0; height--) {

  1096 				for (i = 0; i != width >> 1; i++)

  1097 					if (src[i * 2] != 0) dst[i] = ctab[dst[i]];

  1098 				src += bp->width_org * 2;

  1099 				dst += bp->pitch;

  1100 			}

  1101 			break;

  1102 		}

  1103 

  1104 		default:

  1105 			for (height >>= 1; height != 0; height--) {

  1106 				for (i = 0; i != width >> 1; i++)

  1107 					if (src[i * 2] != 0) dst[i] = src[i * 2];

  1108 				src += bp->width_org * 2;

  1109 				dst += bp->pitch;

  1110 			}

  1111 			break;

  1112 	}

  1113 }

  1114 

  1115 static void GfxBlitTileZoomOut(BlitterParams *bp)

  1116 {

  1117 	const byte *src_o = bp->sprite;

  1118 	const byte *src;

  1119 	int num, skip;

  1120 	byte done;

  1121 	Pixel *dst;

  1122 	const byte *ctab;

  1123 

  1124 	src_o += ReadLE16Aligned(src_o + bp->start_y * 2);

  1125 	switch (bp->mode) {

  1126 		case BM_COLOUR_REMAP:

  1127 			for (;;) {

  1128 				do {

  1129 					done = src_o[0];

  1130 					num = done & 0x7F;

  1131 					skip = src_o[1];

  1132 					src = src_o + 2;

  1133 					src_o += num + 2;

  1134 

  1135 					dst = bp->dst;