1

/* $Id$ */

     2

     3

/** @file gfx.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "spritecache.h"

     9

#include "string.h"

    10

#include "gfx.h"

    11

#include "table/palettes.h"

    12

#include "table/sprites.h"

    13

#include "variables.h"

    14

#include "table/control_codes.h"

    15

#include "fontcache.h"

    16

#include "genworld.h"

    17

#include "debug.h"

    18

#include "zoom.hpp"

    19

#include "texteff.hpp"

    20

#include "blitter/factory.hpp"

    21

#include "video/video_driver.hpp"

    22

#include "strings_func.h"

    23

    24

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

    25

bool _fullscreen;

    26

CursorVars _cursor;

    27

bool _ctrl_pressed;   ///< Is Ctrl pressed?

    28

bool _shift_pressed;  ///< Is Shift pressed?

    29

byte _fast_forward;

    30

bool _left_button_down;

    31

bool _left_button_clicked;

    32

bool _right_button_down;

    33

bool _right_button_clicked;

    34

DrawPixelInfo _screen;

    35

bool _exit_game;

    36

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

    37

byte _game_mode;

    38

byte _pause_game;

    39

int _pal_first_dirty;

    40

int _pal_count_dirty;

    41

    42

Colour _cur_palette[256];

    43

byte _stringwidth_table[FS_END][224];

    44

    45

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

    46

    47

FontSize _cur_fontsize;

    48

static FontSize _last_fontsize;

    49

static uint8 _cursor_backup[64 * 64 * 4];

    50

    51

/**

    52

 * The rect for repaint.

    53

 *

    54

 * This rectangle defines the area which should be repaint by the video driver.

    55

 *

    56

 * @ingroup dirty

    57

 */

    58

static Rect _invalid_rect;

    59

static const byte *_color_remap_ptr;

    60

static byte _string_colorremap[3];

    61

    62

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    63

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    64

    65

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

    66

{

    67

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

    68

    69

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

    70

    71

	if (_cursor.visible) UndrawMouseCursor();

    72

	UndrawChatMessage();

    73

    74

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

    75

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

    76

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

    77

}

    78

    79

    80

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

    81

{

    82

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

    83

	const DrawPixelInfo *dpi = _cur_dpi;

    84

	void *dst;

    85

	const int otop = top;

    86

	const int oleft = left;

    87

    88

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

    89

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

    90

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

    91

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

    92

    93

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

    94

	right = right - dpi->left + 1;

    95

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

    96

	right -= left;

    97

	assert(right > 0);

    98

    99

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

   100

	bottom = bottom - dpi->top + 1;

   101

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

   102

	bottom -= top;

   103

	assert(bottom > 0);

   104

   105

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

   106

   107

	if (!HasBit(color, PALETTE_MODIFIER_GREYOUT)) {

   108

		if (!HasBit(color, USE_COLORTABLE)) {

   109

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

   110

		} else {

   111

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

   112

		}

   113

	} else {

   114

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

   115

		do {

   116

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

   117

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

   118

		} while (--bottom > 0);

   119

	}

   120

}

   121

   122

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

   123

{

   124

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   125

	DrawPixelInfo *dpi = _cur_dpi;

   126

   127

	x -= dpi->left;

   128

	x2 -= dpi->left;

   129

	y -= dpi->top;

   130

	y2 -= dpi->top;

   131

   132

	/* Check clipping */

   133

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

   134

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

   135

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

   136

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

   137

   138

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

   139

}

   140

   141

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

   142

{

   143

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   144

	DrawPixelInfo *dpi = _cur_dpi;

   145

   146

	x -= dpi->left;

   147

	x2 -= dpi->left;

   148

	y -= dpi->top;

   149

	y2 -= dpi->top;

   150

   151

	/* Check clipping */

   152

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

   153

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

   154

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

   155

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

   156

   157

	blitter->DrawLine(dpi->dst_ptr, UnScaleByZoom(x, dpi->zoom), UnScaleByZoom(y, dpi->zoom),

   158

			UnScaleByZoom(x2, dpi->zoom), UnScaleByZoom(y2, dpi->zoom),

   159

			UnScaleByZoom(dpi->width, dpi->zoom), UnScaleByZoom(dpi->height, dpi->zoom), color);

   160

}

   161

   162

/**

   163

 * Draws the projection of a parallelepiped.

   164

 * This can be used to draw boxes in world coordinates.

   165

 *

   166

 * @param x   Screen X-coordinate of top front corner.

   167

 * @param y   Screen Y-coordinate of top front corner.

   168

 * @param dx1 Screen X-length of first edge.

   169

 * @param dy1 Screen Y-length of first edge.

   170

 * @param dx2 Screen X-length of second edge.

   171

 * @param dy2 Screen Y-length of second edge.

   172

 * @param dx3 Screen X-length of third edge.

   173

 * @param dy3 Screen Y-length of third edge.

   174

 */

   175

void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3)

   176

{

   177

	/*           ....

   178

	 *         ..    ....

   179

	 *       ..          ....

   180

	 *     ..                ^

   181

	 *   <--__(dx1,dy1)    /(dx2,dy2)

   182

	 *   :    --__       /   :

   183

	 *   :        --__ /     :

   184

	 *   :            *(x,y) :

   185

	 *   :            |      :

   186

	 *   :            |     ..

   187

	 *    ....        |(dx3,dy3)

   188

	 *        ....    | ..

   189

	 *            ....V.

   190

	 */

   191

   192

	static const byte color = 255;

   193

   194

	GfxDrawLineUnscaled(x, y, x + dx1, y + dy1, color);

   195

	GfxDrawLineUnscaled(x, y, x + dx2, y + dy2, color);

   196

	GfxDrawLineUnscaled(x, y, x + dx3, y + dy3, color);

   197

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

}

   205

   206

   207

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

   208

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

   209

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

   210

 * @param maxw maximum width in pixels of the string

   211

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

   212

static int TruncateString(char *str, int maxw)

   213

{

   214

	int w = 0;

   215

	FontSize size = _cur_fontsize;

   216

	int ddd, ddd_w;

   217

   218

	WChar c;

   219

	char *ddd_pos;

   220

   221

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

   222

   223

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

   224

		if (IsPrintable(c)) {

   225

			w += GetCharacterWidth(size, c);

   226

   227

			if (w >= maxw) {

   228

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

   229

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

   230

				ddd_pos[3] = '\0';

   231

				return ddd_w;

   232

			}

   233

		} else {

   234

			if (c == SCC_SETX) str++;

   235

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

   236

			else if (c == SCC_TINYFONT) {

   237

				size = FS_SMALL;

   238

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

   239

			} else if (c == SCC_BIGFONT) {

   240

				size = FS_LARGE;

   241

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

   242

			}

   243

		}

   244

   245

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

   246

		if (w + ddd < maxw) {

   247

			ddd_w = w + ddd;

   248

			ddd_pos = str;

   249

		}

   250

	}

   251

   252

	return w;

   253

}

   254

   255

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

   256

{

   257

	GetString(dest, src, last);

   258

	return TruncateString(dest, maxw);

   259

}

   260

   261

/* returns right coordinate */

   262

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

   263

{

   264

	char buffer[512];

   265

   266

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

   267

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

   268

}

   269

   270

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

   271

{

   272

	char buffer[512];

   273

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

   274

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

   275

}

   276

   277

   278

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

   279

{

   280

	char buffer[512];

   281

	int w;

   282

   283

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

   284

	w = GetStringBoundingBox(buffer).width;

   285

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

   286

   287

	return w;

   288

}

   289

   290

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

   291

{

   292

	char buffer[512];

   293

   294

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

   295

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

   296

}

   297

   298

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

   299

{

   300

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

   301

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

   302

}

   303

   304

   305

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

   306

{

   307

	char buffer[512];

   308

	int w;

   309

   310

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

   311

   312

	w = GetStringBoundingBox(buffer).width;

   313

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

   314

   315

	return w;

   316

}

   317

   318

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

   319

{

   320

	char buffer[512];

   321

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

   322

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

   323

}

   324

   325

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

   326

{

   327

	int w = GetStringBoundingBox(str).width;

   328

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

   329

	return w;

   330

}

   331

   332

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

   333

{

   334

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

   335

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

   336

}

   337

   338

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

   339

{

   340

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

   341

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

   342

}

   343

   344

/**

   345

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

   346

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

   347

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

   348

 * placeholders for the newlines.

   349

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

   350

 * line's maximum width.

   351

 *

   352

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

   353

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

   354

 * starting with index 0 is the real string end.

   355

 *

   356

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

   357

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

   358

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

   359

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

   360

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

   361

 */

   362

uint32 FormatStringLinebreaks(char *str, int maxw)

   363

{

   364

	FontSize size = _cur_fontsize;

   365

	int num = 0;

   366

   367

	assert(maxw > 0);

   368

   369

	for (;;) {

   370

		char *last_space = NULL;

   371

		int w = 0;

   372

   373

		for (;;) {

   374

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

   375

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

   376

			if (IsWhitespace(c)) last_space = str;

   377

   378

			if (IsPrintable(c)) {

   379

				w += GetCharacterWidth(size, c);

   380

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

   381

				 * do. We can do two things:

   382

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

   383

				 *    we will truncate the string and bail out.

   384

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

   385

				if (w > maxw) {

   386

					if (last_space == NULL) {

   387

						*Utf8PrevChar(str) = '\0';

   388

						return num + (size << 16);

   389

					}

   390

					str = last_space;

   391

					break;

   392

				}

   393

			} else {

   394

				switch (c) {

   395

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

   396

					case SCC_SETX:  str++; break;

   397

					case SCC_SETXY: str += 2; break;

   398

					case SCC_TINYFONT: size = FS_SMALL; break;

   399

					case SCC_BIGFONT:  size = FS_LARGE; break;

   400

					case '\n': goto end_of_inner_loop;

   401

				}

   402

			}

   403

		}

   404

end_of_inner_loop:

   405

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

   406

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

   407

		 * whitespace seperators are supported */

   408

		num++;

   409

		char *s = Utf8PrevChar(str);

   410

		*s++ = '\0';

   411

   412

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

   413

		if (str - s >= 1) {

   414

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

   415

		}

   416

	}

   417

}

   418

   419

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

   420

 * @param x Centre the string around this pixel width

   421

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

   422

 * @param str String to draw

   423

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

   424

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

   425

{

   426

	char buffer[512];

   427

	uint32 tmp;

   428

	int num, w, mt;

   429

	const char *src;

   430

	WChar c;

   431

   432

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

   433

   434

	tmp = FormatStringLinebreaks(buffer, maxw);

   435

	num = GB(tmp, 0, 16);

   436

   437

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

   438

   439

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

   440

   441

	src = buffer;

   442

   443

	for (;;) {

   444

		w = GetStringBoundingBox(src).width;

   445

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

   446

		_cur_fontsize = _last_fontsize;

   447

   448

		for (;;) {

   449

			c = Utf8Consume(&src);

   450

			if (c == 0) {

   451

				y += mt;

   452

				if (--num < 0) {

   453

					_cur_fontsize = FS_NORMAL;

   454

					return;

   455

				}

   456

				break;

   457

			} else if (c == SCC_SETX) {

   458

				src++;

   459

			} else if (c == SCC_SETXY) {

   460

				src += 2;

   461

			}

   462

		}

   463

	}

   464

}

   465

   466

   467

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

   468

{

   469

	char buffer[512];

   470

	uint32 tmp;

   471

	int num, mt;

   472

	uint total_height;

   473

	const char *src;

   474

	WChar c;

   475

   476

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

   477

   478

	tmp = FormatStringLinebreaks(buffer, maxw);

   479

	num = GB(tmp, 0, 16);

   480

   481

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

   482

	total_height = (num + 1) * mt;

   483

   484

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

   485

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

   486

		if (maxh < mt) return 0;