1

/* $Id$ */

     2

     3

/** @file gfx.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "macros.h"

     9

#include "spritecache.h"

    10

#include "strings.h"

    11

#include "string.h"

    12

#include "gfx.h"

    13

#include "table/palettes.h"

    14

#include "table/sprites.h"

    15

#include "hal.h"

    16

#include "variables.h"

    17

#include "table/control_codes.h"

    18

#include "fontcache.h"

    19

#include "genworld.h"

    20

#include "debug.h"

    21

#include "zoom.hpp"

    23

    24

#ifdef _DEBUG

    25

bool _dbg_screen_rect;

    26

#endif

    27

    28

byte _dirkeys;        ///< 1 = left, 2 = up, 4 = right, 8 = down

    29

bool _fullscreen;

    30

CursorVars _cursor;

    31

bool _ctrl_pressed;   ///< Is Ctrl pressed?

    32

bool _shift_pressed;  ///< Is Shift pressed?

    33

byte _fast_forward;

    34

bool _left_button_down;

    35

bool _left_button_clicked;

    36

bool _right_button_down;

    37

bool _right_button_clicked;

    38

DrawPixelInfo _screen;

    39

bool _exit_game;

    40

bool _networking;         ///< are we in networking mode?

    41

byte _game_mode;

    42

byte _pause_game;

    43

int _pal_first_dirty;

    44

int _pal_last_dirty;

    45

    46

Colour _cur_palette[256];

    47

byte _stringwidth_table[FS_END][224];

    48

    49

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

    50

    51

FontSize _cur_fontsize;

    52

static FontSize _last_fontsize;

    53

static Pixel _cursor_backup[64 * 64];

    54

static Rect _invalid_rect;

    55

static const byte *_color_remap_ptr;

    56

static byte _string_colorremap[3];

    57

    58

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    59

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    60

    61

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

    62

{

    63

	Pixel *dstp = (Pixel *)dst;

    64

	Pixel *srcp = (Pixel *)src;

    65

    66

	assert(h >= 0);

    67

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

    68

		memcpy(dstp, srcp, w * sizeof(Pixel));

    69

		dstp += dstpitch;

    70

		srcp += srcpitch;

    71

	}

    72

}

    73

    74

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

    75

{

    76

	const Pixel *src;

    77

	Pixel *dst;

    78

	int p;

    79

	int ht;

    80

    81

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

    82

    83

	if (_cursor.visible) UndrawMouseCursor();

    84

	UndrawTextMessage();

    85

    86

	p = _screen.pitch;

    87

    88

	if (yo > 0) {

    89

		/*Calculate pointers */

    90

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

    91

		src = dst - yo * p;

    92

    93

		/* Decrease height and increase top */

    94

		top += yo;

    95

		height -= yo;

    96

		assert(height > 0);

    97

    98

		/* Adjust left & width */

    99

		if (xo >= 0) {

   100

			dst += xo;

   101

			left += xo;

   102

			width -= xo;

   103

		} else {

   104

			src -= xo;

   105

			width += xo;

   106

		}

   107

   108

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

   109

			memcpy(dst, src, width * sizeof(Pixel));

   110

			src -= p;

   111

			dst -= p;

   112

		}

   113

	} else {

   114

		/* Calculate pointers */

   115

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

   116

		src = dst - yo * p;

   117

   118

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

   119

		height += yo;

   120

		assert(height > 0);

   121

   122

		/* Adjust left & width */

   123

		if (xo >= 0) {

   124

			dst += xo;

   125

			left += xo;

   126

			width -= xo;

   127

		} else {

   128

			src -= xo;

   129

			width += xo;

   130

		}

   131

   132

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

   133

		 * because source and destination may overlap */

   134

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

   135

			memmove(dst, src, width * sizeof(Pixel));

   136

			src += p;

   137

			dst += p;

   138

		}

   139

	}

   140

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

   141

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

   142

}

   143

   144

   145

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

   146

{

   147

	const DrawPixelInfo* dpi = _cur_dpi;

   148

	Pixel *dst;

   149

	const int otop = top;

   150

	const int oleft = left;

   151

   152

	if (dpi->zoom != ZOOM_LVL_NORMAL) return;

   153

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

   154

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

   155

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

   156

   157

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

   158

	right = right - dpi->left + 1;

   159

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

   160

	right -= left;

   161

	assert(right > 0);

   162

   163

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

   164

	bottom = bottom - dpi->top + 1;

   165

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

   166

	bottom -= top;

   167

	assert(bottom > 0);

   168

   169

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

   170

   171

	if (!HASBIT(color, PALETTE_MODIFIER_GREYOUT)) {

   172

		if (!HASBIT(color, USE_COLORTABLE)) {

   173

			do {

   174

				memset(dst, color, right * sizeof(Pixel));

   175

				dst += dpi->pitch;

   176

			} while (--bottom);

   177

		} else {

   178

			/* use colortable mode */

   179

			const byte* ctab = GetNonSprite(GB(color, 0, PALETTE_WIDTH)) + 1;

   180

   181

			do {

   182

				int i;

   183

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

   184

				dst += dpi->pitch;

   185

			} while (--bottom);

   186

		}

   187

	} else {

   188

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

   189

		do {

   190

			int i;

   191

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

   192

			dst += dpi->pitch;

   193

		} while (--bottom > 0);

   194

	}

   195

}

   196

   197

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

   198

{

   199

	const DrawPixelInfo* dpi = _cur_dpi;

   200

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

   201

		return;

   202

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

   203

}

   204

   205

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

   206

{

   207

	int dy;

   208

	int dx;

   209

	int stepx;

   210

	int stepy;

   211

	int frac;

   212

   213

	/* Check clipping first */

   214

	{

   215

		DrawPixelInfo *dpi = _cur_dpi;

   216

		int t;

   217

   218

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

   219

   220

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

   221

   222

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

   223

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

   224

   225

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

   226

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

   227

	}

   228

   229

	dy = (y2 - y) * 2;

   230

	if (dy < 0) {

   231

		dy = -dy;

   232

		stepy = -1;

   233

	} else {

   234

		stepy = 1;

   235

	}

   236

   237

	dx = (x2 - x) * 2;

   238

	if (dx < 0) {

   239

		dx = -dx;

   240

		stepx = -1;

   241

	} else {

   242

		stepx = 1;

   243

	}

   244

   245

	GfxSetPixel(x, y, color);

   246

	if (dx > dy) {

   247

		frac = dy - (dx >> 1);

   248

		while (x != x2) {

   249

			if (frac >= 0) {

   250

				y += stepy;

   251

				frac -= dx;

   252

			}

   253

			x += stepx;

   254

			frac += dy;

   255

			GfxSetPixel(x, y, color);

   256

		}

   257

	} else {

   258

		frac = dx - (dy >> 1);

   259

		while (y != y2) {

   260

			if (frac >= 0) {

   261

				x += stepx;

   262

				frac -= dy;

   263

			}

   264

			y += stepy;

   265

			frac += dx;

   266

			GfxSetPixel(x, y, color);

   267

		}

   268

	}

   269

}

   270

   271

   272

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

   273

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

   274

 * @param *str string that is checked and possibly truncated

   275

 * @param maxw maximum width in pixels of the string

   276

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

   277

static int TruncateString(char *str, int maxw)

   278

{

   279

	int w = 0;

   280

	FontSize size = _cur_fontsize;

   281

	int ddd, ddd_w;

   282

   283

	WChar c;

   284

	char *ddd_pos;

   285

   286

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

   287

   288

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

   289

		if (IsPrintable(c)) {

   290

			w += GetCharacterWidth(size, c);

   291

   292

			if (w >= maxw) {

   293

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

   294

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

   295

				ddd_pos[3] = '\0';

   296

				return ddd_w;

   297

			}

   298

		} else {

   299

			if (c == SCC_SETX) str++;

   300

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

   301

			else if (c == SCC_TINYFONT) {

   302

				size = FS_SMALL;

   303

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

   304

			} else if (c == SCC_BIGFONT) {

   305

				size = FS_LARGE;

   306

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

   307

			}

   308

		}

   309

   310

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

   311

		if (w + ddd < maxw) {

   312

			ddd_w = w + ddd;

   313

			ddd_pos = str;

   314

		}

   315

	}

   316

   317

	return w;

   318

}

   319

   320

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

   321

{

   322

	GetString(dest, src, last);

   323

	return TruncateString(dest, maxw);

   324

}

   325

   326

/* returns right coordinate */

   327

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

   328

{

   329

	char buffer[512];

   330

   331

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

   332

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

   333

}

   334

   335

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

   336

{

   337

	char buffer[512];

   338

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

   339

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

   340

}

   341

   342

   343

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

   344

{

   345

	char buffer[512];

   346

	int w;

   347

   348

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

   349

	w = GetStringBoundingBox(buffer).width;

   350

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

   351

   352

	return w;

   353

}

   354

   355

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

   356

{

   357

	char buffer[512];

   358

   359

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

   360

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

   361

}

   362

   363

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

   364

{

   365

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

   366

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

   367

}

   368

   369

   370

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

   371

{

   372

	char buffer[512];

   373

	int w;

   374

   375

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

   376

   377

	w = GetStringBoundingBox(buffer).width;

   378

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

   379

   380

	return w;

   381

}

   382

   383

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

   384

{

   385

	char buffer[512];

   386

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

   387

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

   388

}

   389

   390

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

   391

{

   392

	int w = GetStringBoundingBox(str).width;

   393

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

   394

	return w;

   395

}

   396

   397

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

   398

{

   399

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

   400

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

   401

}

   402

   403

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

   404

{

   405

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

   406

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

   407

}

   408

   409

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

   410

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

   411

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

   412

 * placeholders for the newlines.

   413

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

   414

 * line's maximum width.

   415

 *

   416

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

   417

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

   418

 * starting with index 0 is the real string end.

   419

 *

   420

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

   421

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

   422

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

   423

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

   424

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

   425

uint32 FormatStringLinebreaks(char *str, int maxw)

   426

{

   427

	FontSize size = _cur_fontsize;

   428

	int num = 0;

   429

   430

	assert(maxw > 0);

   431

   432

	for (;;) {

   433

		char *last_space = NULL;

   434

		int w = 0;

   435

   436

		for (;;) {

   437

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

   438

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

   439

			if (IsWhitespace(c)) last_space = str;

   440

   441

			if (IsPrintable(c)) {

   442

				w += GetCharacterWidth(size, c);

   443

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

   444

				 * do. We can do two things:

   445

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

   446

				 *    we will truncate the string and bail out.

   447

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

   448

				if (w > maxw) {

   449

					if (last_space == NULL) {

   450

						*Utf8PrevChar(str) = '\0';

   451

						return num + (size << 16);

   452

					}

   453

					str = last_space;

   454

					break;

   455

				}

   456

			} else {

   457

				switch (c) {

   458

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

   459

					case SCC_SETX:  str++; break;

   460

					case SCC_SETXY: str += 2; break;

   461

					case SCC_TINYFONT: size = FS_SMALL; break;

   462

					case SCC_BIGFONT:  size = FS_LARGE; break;

   463

					case '\n': goto end_of_inner_loop;

   464

				}

   465

			}

   466

		}

   467

end_of_inner_loop:

   468

		/* String didn't fit on line (or a '\n' was encountered), so 'dummy' terminate

   469

		 * and increase linecount. We use Utf8PrevChar() as also non 1 char long

   470

		 * whitespace seperators are supported */

   471

		num++;

   472

		char *s = Utf8PrevChar(str);

   473

		*s++ = '\0';

   474

   475

		/* In which case (see above) we will shift remainder to left and close the gap */

   476

		if (str - s >= 1) {

   477

			for (; str[-1] != '\0';) *s++ = *str++;

   478

		}

   479

	}

   480

}

   481

   482

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

   483

 * @param x Centre the string around this pixel width

   484

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

   485

 * @param str String to draw

   486

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

   487

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

   488

{

   489

	char buffer[512];

   490

	uint32 tmp;

   491

	int num, w, mt;