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"

    22

#include "blitter/blitter.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 uint8 _cursor_backup[64 * 64 * 4];

    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 GfxScroll(int left, int top, int width, int height, int xo, int yo)

    62

{

    63

	const void *src;

    64

	void *dst;

    65

    66

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

    67

    68

	if (_cursor.visible) UndrawMouseCursor();

    69

	UndrawTextMessage();

    70

    71

	if (yo > 0) {

    72

		/*Calculate pointers */

    73

		dst = _screen.renderer->MoveTo(_screen.dst_ptr, left, top + height - 1);

    74

		src = _screen.renderer->MoveTo(dst, 0, -yo);

    75

    76

		/* Decrease height and increase top */

    77

		top += yo;

    78

		height -= yo;

    79

		assert(height > 0);

    80

    81

		/* Adjust left & width */

    82

		if (xo >= 0) {

    83

			dst = _screen.renderer->MoveTo(dst, xo, 0);

    84

			left += xo;

    85

			width -= xo;

    86

		} else {

    87

			src = _screen.renderer->MoveTo(src, -xo, 0);

    88

			width += xo;

    89

		}

    90

    91

		/* Negative height as we want to copy from bottom to top */

    92

		_screen.renderer->CopyFromBuffer(dst, src, width, -height, _screen.pitch);

    93

	} else {

    94

		/* Calculate pointers */

    95

		dst = _screen.renderer->MoveTo(_screen.dst_ptr, left, top);

    96

		src = _screen.renderer->MoveTo(dst, 0, -yo);

    97

    98

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

    99

		height += yo;

   100

		assert(height > 0);

   101

   102

		/* Adjust left & width */

   103

		if (xo >= 0) {

   104

			dst = _screen.renderer->MoveTo(dst, xo, 0);

   105

			left += xo;

   106

			width -= xo;

   107

		} else {

   108

			src = _screen.renderer->MoveTo(src, -xo, 0);

   109

			width += xo;

   110

		}

   111

   112

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

   113

		 * because source and destination may overlap */

   114

		_screen.renderer->MoveBuffer(dst, src, width, height);

   115

	}

   116

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

   117

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

   118

}

   119

   120

   121

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

   122

{

   123

	const DrawPixelInfo *dpi = _cur_dpi;

   124

	void *dst;

   125

	const int otop = top;

   126

	const int oleft = left;

   127

   128

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

   129

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

   130

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

   131

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

   132

   133

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

   134

	right = right - dpi->left + 1;

   135

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

   136

	right -= left;

   137

	assert(right > 0);

   138

   139

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

   140

	bottom = bottom - dpi->top + 1;

   141

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

   142

	bottom -= top;

   143

	assert(bottom > 0);

   144

   145

	dst = _screen.renderer->MoveTo(dpi->dst_ptr, left, top);

   146

   147

	if (!HASBIT(color, PALETTE_MODIFIER_GREYOUT)) {

   148

		if (!HASBIT(color, USE_COLORTABLE)) {

   149

			do {

   150

				_screen.renderer->SetHorizontalLine(dst, right, (uint8)color);

   151

				dst = _screen.renderer->MoveTo(dst, 0, 1);

   152

			} while (--bottom);

   153

		} else {

   155

		}

   156

	} else {

   157

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

   158

		do {

   159

			for (int i = (bo ^= 1); i < right; i += 2) _screen.renderer->SetPixel(dst, i, 0, (uint8)color);

   160

			dst = _screen.renderer->MoveTo(dst, 0, 1);

   161

		} while (--bottom > 0);

   162

	}

   163

}

   164

   165

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

   166

{

   167

	const DrawPixelInfo *dpi = _cur_dpi;

   168

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

   169

	_screen.renderer->SetPixel(dpi->dst_ptr, x, y, color);

   170

}

   171

   172

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

   173

{

   174

	int dy;

   175

	int dx;

   176

	int stepx;

   177

	int stepy;

   178

	int frac;

   179

   180

	/* Check clipping first */

   181

	{

   182

		DrawPixelInfo *dpi = _cur_dpi;

   183

		int t;

   184

   185

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

   186

   187

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

   188

   189

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

   190

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

   191

   192

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

   193

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

   194

	}

   195

   196

	dy = (y2 - y) * 2;

   197

	if (dy < 0) {

   198

		dy = -dy;

   199

		stepy = -1;

   200

	} else {

   201

		stepy = 1;

   202

	}

   203

   204

	dx = (x2 - x) * 2;

   205

	if (dx < 0) {

   206

		dx = -dx;

   207

		stepx = -1;

   208

	} else {

   209

		stepx = 1;

   210

	}

   211

   212

	GfxSetPixel(x, y, color);

   213

	if (dx > dy) {

   214

		frac = dy - (dx >> 1);

   215

		while (x != x2) {

   216

			if (frac >= 0) {

   217

				y += stepy;

   218

				frac -= dx;

   219

			}

   220

			x += stepx;

   221

			frac += dy;

   222

			GfxSetPixel(x, y, color);

   223

		}

   224

	} else {

   225

		frac = dx - (dy >> 1);

   226

		while (y != y2) {

   227

			if (frac >= 0) {

   228

				x += stepx;

   229

				frac -= dy;

   230

			}

   231

			y += stepy;

   232

			frac += dx;

   233

			GfxSetPixel(x, y, color);

   234

		}

   235

	}

   236

}

   237

   238

   239

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

   240

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

   241

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

   242

 * @param maxw maximum width in pixels of the string

   243

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

   244

static int TruncateString(char *str, int maxw)

   245

{

   246

	int w = 0;

   247

	FontSize size = _cur_fontsize;

   248

	int ddd, ddd_w;

   249

   250

	WChar c;

   251

	char *ddd_pos;

   252

   253

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

   254

   255

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

   256

		if (IsPrintable(c)) {

   257

			w += GetCharacterWidth(size, c);

   258

   259

			if (w >= maxw) {

   260

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

   261

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

   262

				ddd_pos[3] = '\0';

   263

				return ddd_w;

   264

			}

   265

		} else {

   266

			if (c == SCC_SETX) str++;

   267

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

   268

			else if (c == SCC_TINYFONT) {

   269

				size = FS_SMALL;

   270

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

   271

			} else if (c == SCC_BIGFONT) {

   272

				size = FS_LARGE;

   273

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

   274

			}

   275

		}

   276

   277

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

   278

		if (w + ddd < maxw) {

   279

			ddd_w = w + ddd;

   280

			ddd_pos = str;

   281

		}

   282

	}

   283

   284

	return w;

   285

}

   286

   287

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

   288

{

   289

	GetString(dest, src, last);

   290

	return TruncateString(dest, maxw);

   291

}

   292

   293

/* returns right coordinate */

   294

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

   295

{

   296

	char buffer[512];

   297

   298

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

   299

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

   300

}

   301

   302

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

   303

{

   304

	char buffer[512];

   305

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

   306

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

   307

}

   308

   309

   310

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

   311

{

   312

	char buffer[512];

   313

	int w;

   314

   315

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

   316

	w = GetStringBoundingBox(buffer).width;

   317

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

   318

   319

	return w;

   320

}

   321

   322

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

   323

{

   324

	char buffer[512];

   325

   326

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

   327

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

   328

}

   329

   330

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

   331

{

   332

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

   333

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

   334

}

   335

   336

   337

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

   338

{

   339

	char buffer[512];

   340

	int w;

   341

   342

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

   343

   344

	w = GetStringBoundingBox(buffer).width;

   345

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

   346

   347

	return w;

   348

}

   349

   350

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

   351

{

   352

	char buffer[512];

   353

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

   354

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

   355

}

   356

   357

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

   358

{

   359

	int w = GetStringBoundingBox(str).width;

   360

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

   361

	return w;

   362

}

   363

   364

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

   365

{

   366

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

   367

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

   368

}

   369

   370

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

   371

{

   372

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

   373

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

   374

}

   375

   376

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

   377

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

   378

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

   379

 * placeholders for the newlines.

   380

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

   381

 * line's maximum width.

   382

 *

   383

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

   384

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

   385

 * starting with index 0 is the real string end.

   386

 *

   387

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

   388

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

   389

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

   390

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

   391

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

   392

uint32 FormatStringLinebreaks(char *str, int maxw)

   393

{

   394

	FontSize size = _cur_fontsize;

   395

	int num = 0;

   396

   397

	assert(maxw > 0);

   398

   399

	for (;;) {

   400

		char *last_space = NULL;

   401

		int w = 0;

   402

   403

		for (;;) {

   404

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

   405

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

   406

			if (IsWhitespace(c)) last_space = str;

   407

   408

			if (IsPrintable(c)) {

   409

				w += GetCharacterWidth(size, c);

   410

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

   411

				 * do. We can do two things:

   412

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

   413

				 *    we will truncate the string and bail out.

   414

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

   415

				if (w > maxw) {

   416

					if (last_space == NULL) {

   417

						*Utf8PrevChar(str) = '\0';

   418

						return num + (size << 16);

   419

					}

   420

					str = last_space;

   421

					break;

   422

				}

   423

			} else {

   424

				switch (c) {

   425

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

   426

					case SCC_SETX:  str++; break;

   427

					case SCC_SETXY: str += 2; break;

   428

					case SCC_TINYFONT: size = FS_SMALL; break;

   429

					case SCC_BIGFONT:  size = FS_LARGE; break;

   430

					case '\n': goto end_of_inner_loop;

   431

				}

   432

			}

   433

		}

   434

end_of_inner_loop:

   435

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

   436

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

   437

		 * whitespace seperators are supported */

   438

		num++;

   439

		char *s = Utf8PrevChar(str);

   440

		*s++ = '\0';

   441

   442

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

   443

		if (str - s >= 1) {

   444

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

   445

		}

   446

	}

   447

}

   448

   449

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

   450

 * @param x Centre the string around this pixel width

   451

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

   452

 * @param str String to draw

   453

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

   454

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

   455

{

   456

	char buffer[512];

   457

	uint32 tmp;

   458

	int num, w, mt;

   459

	const char *src;

   460

	WChar c;

   461

   462

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

   463

   464

	tmp = FormatStringLinebreaks(buffer, maxw);

   465

	num = GB(tmp, 0, 16);

   466

   467

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

   468

   469

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

   470

   471

	src = buffer;

   472

   473

	for (;;) {

   474

		w = GetStringBoundingBox(src).width;

   475

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

   476

		_cur_fontsize = _last_fontsize;

   477

   478

		for (;;) {

   479

			c = Utf8Consume(&src);

   480

			if (c == 0) {

   481

				y += mt;

   482

				if (--num < 0) {

   483

					_cur_fontsize = FS_NORMAL;

   484

					return;

   485

				}

   486

				break;

   487

			} else if (c == SCC_SETX) {

   488

				src++;

   489

			} else if (c == SCC_SETXY) {