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 "variables.h"

    16

#include "table/control_codes.h"

    17

#include "fontcache.h"

    18

#include "genworld.h"

    19

#include "debug.h"

    20

#include "zoom.hpp"

    21

#include "texteff.hpp"

    22

#include "blitter/factory.hpp"

    23

#include "video/video_driver.hpp"

    24

    25

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

    26

bool _fullscreen;

    27

CursorVars _cursor;

    28

bool _ctrl_pressed;   ///< Is Ctrl pressed?

    29

bool _shift_pressed;  ///< Is Shift pressed?

    30

byte _fast_forward;

    31

bool _left_button_down;

    32

bool _left_button_clicked;

    33

bool _right_button_down;

    34

bool _right_button_clicked;

    35

DrawPixelInfo _screen;

    36

bool _exit_game;

    37

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

    38

byte _game_mode;

    39

byte _pause_game;

    40

int _pal_first_dirty;

    41

int _pal_count_dirty;

    42

    43

Colour _cur_palette[256];

    44

byte _stringwidth_table[FS_END][224];

    45

    46

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

    47

    48

FontSize _cur_fontsize;

    49

static FontSize _last_fontsize;

    50

static uint8 _cursor_backup[64 * 64 * 4];

    51

static Rect _invalid_rect;

    52

static const byte *_color_remap_ptr;

    53

static byte _string_colorremap[3];

    54

    55

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    56

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    57

    58

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

    59

{

    60

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

    61

    62

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

    63

    64

	if (_cursor.visible) UndrawMouseCursor();

    66

    67

	blitter->ScrollBuffer(_screen.dst_ptr, left, top, width, height, xo, yo);

    68

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

    69

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

    70

}

    71

    72

    73

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

    74

{

    75

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

    76

	const DrawPixelInfo *dpi = _cur_dpi;

    77

	void *dst;

    78

	const int otop = top;

    79

	const int oleft = left;

    80

    81

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

    82

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

    83

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

    84

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

    85

    86

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

    87

	right = right - dpi->left + 1;

    88

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

    89

	right -= left;

    90

	assert(right > 0);

    91

    92

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

    93

	bottom = bottom - dpi->top + 1;

    94

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

    95

	bottom -= top;

    96

	assert(bottom > 0);

    97

    98

	dst = blitter->MoveTo(dpi->dst_ptr, left, top);

    99

   100

	if (!HASBIT(color, PALETTE_MODIFIER_GREYOUT)) {

   101

		if (!HASBIT(color, USE_COLORTABLE)) {

   102

			blitter->DrawRect(dst, right, bottom, (uint8)color);

   103

		} else {

   104

			blitter->DrawColorMappingRect(dst, right, bottom, GB(color, 0, PALETTE_WIDTH));

   105

		}

   106

	} else {

   107

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

   108

		do {

   109

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

   110

			dst = blitter->MoveTo(dst, 0, 1);

   111

		} while (--bottom > 0);

   112

	}

   113

}

   114

   115

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

   116

{

   117

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   118

	DrawPixelInfo *dpi = _cur_dpi;

   119

   120

	x -= dpi->left;

   121

	x2 -= dpi->left;

   122

	y -= dpi->top;

   123

	y2 -= dpi->top;

   124

   125

	/* Check clipping */

   126

	if (x < 0 && x2 < 0) return;

   127

	if (y < 0 && y2 < 0) return;

   128

	if (x > dpi->width  && x2 > dpi->width)  return;

   129

	if (y > dpi->height && y2 > dpi->height) return;

   130

   131

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

   132

}

   133

   134

   135

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

   136

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

   137

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

   138

 * @param maxw maximum width in pixels of the string

   139

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

   140

static int TruncateString(char *str, int maxw)

   141

{

   142

	int w = 0;

   143

	FontSize size = _cur_fontsize;

   144

	int ddd, ddd_w;

   145

   146

	WChar c;

   147

	char *ddd_pos;

   148

   149

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

   150

   151

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

   152

		if (IsPrintable(c)) {

   153

			w += GetCharacterWidth(size, c);

   154

   155

			if (w >= maxw) {

   156

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

   157

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

   158

				ddd_pos[3] = '\0';

   159

				return ddd_w;

   160

			}

   161

		} else {

   162

			if (c == SCC_SETX) str++;

   163

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

   164

			else if (c == SCC_TINYFONT) {

   165

				size = FS_SMALL;

   166

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

   167

			} else if (c == SCC_BIGFONT) {

   168

				size = FS_LARGE;

   169

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

   170

			}

   171

		}

   172

   173

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

   174

		if (w + ddd < maxw) {

   175

			ddd_w = w + ddd;

   176

			ddd_pos = str;

   177

		}

   178

	}

   179

   180

	return w;

   181

}

   182

   183

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

   184

{

   185

	GetString(dest, src, last);

   186

	return TruncateString(dest, maxw);

   187

}

   188

   189

/* returns right coordinate */

   190

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

   191

{

   192

	char buffer[512];

   193

   194

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

   195

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

   196

}

   197

   198

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

   199

{

   200

	char buffer[512];

   201

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

   202

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

   203

}

   204

   205

   206

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

   207

{

   208

	char buffer[512];

   209

	int w;

   210

   211

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

   212

	w = GetStringBoundingBox(buffer).width;

   213

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

   214

   215

	return w;

   216

}

   217

   218

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

   219

{

   220

	char buffer[512];

   221

   222

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

   223

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

   224

}

   225

   226

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

   227

{

   228

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

   229

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

   230

}

   231

   232

   233

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

   234

{

   235

	char buffer[512];

   236

	int w;

   237

   238

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

   239

   240

	w = GetStringBoundingBox(buffer).width;

   241

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

   242

   243

	return w;

   244

}

   245

   246

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

   247

{

   248

	char buffer[512];

   249

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

   250

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

   251

}

   252

   253

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

   254

{

   255

	int w = GetStringBoundingBox(str).width;

   256

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

   257

	return w;

   258

}

   259

   260

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

   261

{

   262

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

   263

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

   264

}

   265

   266

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

   267

{

   268

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

   269

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

   270

}

   271

   272

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

   273

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

   274

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

   275

 * placeholders for the newlines.

   276

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

   277

 * line's maximum width.

   278

 *

   279

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

   280

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

   281

 * starting with index 0 is the real string end.

   282

 *

   283

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

   284

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

   285

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

   286

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

   287

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

   288

uint32 FormatStringLinebreaks(char *str, int maxw)

   289

{

   290

	FontSize size = _cur_fontsize;

   291

	int num = 0;

   292

   293

	assert(maxw > 0);

   294

   295

	for (;;) {

   296

		char *last_space = NULL;

   297

		int w = 0;

   298

   299

		for (;;) {

   300

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

   301

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

   302

			if (IsWhitespace(c)) last_space = str;

   303

   304

			if (IsPrintable(c)) {

   305

				w += GetCharacterWidth(size, c);

   306

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

   307

				 * do. We can do two things:

   308

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

   309

				 *    we will truncate the string and bail out.

   310

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

   311

				if (w > maxw) {

   312

					if (last_space == NULL) {

   313

						*Utf8PrevChar(str) = '\0';

   314

						return num + (size << 16);

   315

					}

   316

					str = last_space;

   317

					break;

   318

				}

   319

			} else {

   320

				switch (c) {

   321

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

   322

					case SCC_SETX:  str++; break;

   323

					case SCC_SETXY: str += 2; break;

   324

					case SCC_TINYFONT: size = FS_SMALL; break;

   325

					case SCC_BIGFONT:  size = FS_LARGE; break;

   326

					case '\n': goto end_of_inner_loop;

   327

				}

   328

			}

   329

		}

   330

end_of_inner_loop:

   331

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

   332

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

   333

		 * whitespace seperators are supported */

   334

		num++;

   335

		char *s = Utf8PrevChar(str);

   336

		*s++ = '\0';

   337

   338

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

   339

		if (str - s >= 1) {

   340

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

   341

		}

   342

	}

   343

}

   344

   345

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

   346

 * @param x Centre the string around this pixel width

   347

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

   348

 * @param str String to draw

   349

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

   350

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

   351

{

   352

	char buffer[512];

   353

	uint32 tmp;

   354

	int num, w, mt;

   355

	const char *src;

   356

	WChar c;

   357

   358

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

   359

   360

	tmp = FormatStringLinebreaks(buffer, maxw);

   361

	num = GB(tmp, 0, 16);

   362

   363

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

   364

   365

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

   366

   367

	src = buffer;

   368

   369

	for (;;) {

   370

		w = GetStringBoundingBox(src).width;

   371

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

   372

		_cur_fontsize = _last_fontsize;

   373

   374

		for (;;) {

   375

			c = Utf8Consume(&src);

   376

			if (c == 0) {

   377

				y += mt;

   378

				if (--num < 0) {

   379

					_cur_fontsize = FS_NORMAL;

   380

					return;

   381

				}

   382

				break;

   383

			} else if (c == SCC_SETX) {

   384

				src++;

   385

			} else if (c == SCC_SETXY) {

   386

				src += 2;

   387

			}

   388

		}

   389

	}

   390

}

   391

   392

   393

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

   394

{

   395

	char buffer[512];

   396

	uint32 tmp;

   397

	int num, mt;

   398

	uint total_height;

   399

	const char *src;

   400

	WChar c;

   401

   402

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

   403

   404

	tmp = FormatStringLinebreaks(buffer, maxw);

   405

	num = GB(tmp, 0, 16);

   406

   407

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

   408

	total_height = (num + 1) * mt;

   409

   410

	if (maxh != -1 && (int)total_height > maxh) {

   411

		/* Check there's room enough for at least one line. */

   412

		if (maxh < mt) return 0;

   413

   414

		num = maxh / mt - 1;

   415

		total_height = (num + 1) * mt;

   416

	}

   417

   418

	src = buffer;

   419

   420

	for (;;) {

   421

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

   422

		_cur_fontsize = _last_fontsize;

   423

   424

		for (;;) {

   425

			c = Utf8Consume(&src);

   426

			if (c == 0) {

   427

				y += mt;

   428

				if (--num < 0) {

   429

					_cur_fontsize = FS_NORMAL;

   430

					return total_height;

   431

				}

   432

				break;

   433

			} else if (c == SCC_SETX) {

   434

				src++;

   435

			} else if (c == SCC_SETXY) {

   436

				src += 2;

   437

			}

   438

		}

   439

	}

   440

}

   441

   442

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

   443

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

   444

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

   445

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

   446

 * but not every possible combination

   447

 * @param str string to calculate pixel-width

   448

 * @return string width and height in pixels */

   449

BoundingRect GetStringBoundingBox(const char *str)

   450

{

   451

	FontSize size = _cur_fontsize;

   452

	BoundingRect br;

   453

	int max_width;

   454

	WChar c;

   455

   456

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

   457

	for (;;) {

   458

		c = Utf8Consume(&str);

   459

		if (c == 0) break;

   460

		if (IsPrintable(c)) {

   461

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

   462

		} else {

   463

			switch (c) {

   464

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

   465

				case SCC_SETXY:

   466

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

   467

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

   468

					break;

   469

				case SCC_TINYFONT: size = FS_SMALL; break;

   470

				case SCC_BIGFONT:  size = FS_LARGE; break;

   471

				case '\n':

   472

					br.height += GetCharacterHeight(size);

   473

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

   474

					br.width = 0;

   475

					break;

   476

			}

   477

		}

   478

	}

   479

	br.height += GetCharacterHeight(size);

   480

   481

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

   482

	return br;

   483

}

   484

   485

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