1

/* $Id$ */

     2

     3

/** @file gfx.cpp Handling of drawing text and other gfx related stuff. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gfx_func.h"

     8

#include "spritecache.h"

     9

#include "variables.h"

    10

#include "fontcache.h"

    11

#include "genworld.h"

    12

#include "debug.h"

    13

#include "zoom_func.h"

    14

#include "texteff.hpp"

    15

#include "blitter/factory.hpp"

    16

#include "video/video_driver.hpp"

    17

#include "strings_func.h"

    18

#include "core/math_func.hpp"

    19

#include "settings_type.h"

    20

#include "core/alloc_func.hpp"

    21

#include "core/sort_func.hpp"

    22

#include "landscape_type.h"

    23

    24

#include "table/palettes.h"

    25

#include "table/sprites.h"

    26

#include "table/control_codes.h"

    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;     ///< Is left mouse button pressed?

    35

bool _left_button_clicked;  ///< Is left mouse button clicked?

    36

bool _right_button_down;    ///< Is right mouse button pressed?

    37

bool _right_button_clicked; ///< Is right mouse button clicked?

    38

DrawPixelInfo _screen;

    39

bool _screen_disable_anim = false;   ///< Disable palette animation (important for 32bpp-anim blitter during giant screenshot)

    40

bool _exit_game;

    41

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

    42

byte _game_mode;

    43

int8 _pause_game;

    44

int _pal_first_dirty;

    45

int _pal_count_dirty;

    46

    47

Colour _cur_palette[256];

    48

byte _stringwidth_table[FS_END][224];

    49

DrawPixelInfo *_cur_dpi;

    50

byte _colour_gradient[16][8];

    51

bool _use_dos_palette;

    52

    53

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

    54

    55

FontSize _cur_fontsize;

    56

static FontSize _last_fontsize;

    57

static uint8 _cursor_backup[64 * 64 * 4];

    58

    59

/**

    60

 * The rect for repaint.

    61

 *

    62

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

    63

 *

    64

 * @ingroup dirty

    65

 */

    66

static Rect _invalid_rect;

    67

static const byte *_color_remap_ptr;

    68

static byte _string_colorremap[3];

    69

    70

enum {

    71

	DIRTY_BLOCK_HEIGHT   = 8,

    72

	DIRTY_BLOCK_WIDTH    = 64,

    73

};

    74

static uint _dirty_bytes_per_line = 0;

    75

static byte *_dirty_blocks = NULL;

    76

    77

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

    78

{

    79

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

    80

    81

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

    82

    83

	if (_cursor.visible) UndrawMouseCursor();

    84

	UndrawChatMessage();

    85

    86

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

    87

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

    88

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

    89

}

    90

    91

    92

/**

    93

 * Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.

    94

 *

    95

 * @pre dpi->zoom == ZOOM_LVL_NORMAL, right >= left, bottom >= top

    96

 * @param left Minimum X (inclusive)

    97

 * @param top Minimum Y (inclusive)

    98

 * @param right Maximum X (inclusive)

    99

 * @param bottom Maximum Y (inclusive)

   100

 * @param color A 8 bit palette index (FILLRECT_OPAQUE and FILLRECT_CHECKER) or a recolor spritenumber (FILLRECT_RECOLOR)

   101

 * @param mode

   102

 *         FILLRECT_OPAQUE:   Fill the rectangle with the specified color

   103

 *         FILLRECT_CHECKER:  Like FILLRECT_OPAQUE, but only draw every second pixel (used to grey out things)

   104

 *         FILLRECT_RECOLOR:  Apply a recolor sprite to every pixel in the rectangle currently on screen

   105

 */

   106

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

   107

{

   108

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   109

	const DrawPixelInfo *dpi = _cur_dpi;

   110

	void *dst;

   111

	const int otop = top;

   112

	const int oleft = left;

   113

   114

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

   115

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

   116

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

   117

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

   118

   119

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

   120

	right = right - dpi->left + 1;

   121

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

   122

	right -= left;

   123

	assert(right > 0);

   124

   125

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

   126

	bottom = bottom - dpi->top + 1;

   127

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

   128

	bottom -= top;

   129

	assert(bottom > 0);

   130

   131

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

   132

   133

	switch (mode) {

   134

		default: // FILLRECT_OPAQUE

   135

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

   136

			break;

   137

   138

		case FILLRECT_RECOLOR:

   139

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

   140

			break;

   141

   142

		case FILLRECT_CHECKER: {

   143

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

   144

			do {

   145

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

   146

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

   147

			} while (--bottom > 0);

   148

			break;

   149

		}

   150

	}

   151

}

   152

   153

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

   154

{

   155

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   156

	DrawPixelInfo *dpi = _cur_dpi;

   157

   158

	x -= dpi->left;

   159

	x2 -= dpi->left;

   160

	y -= dpi->top;

   161

	y2 -= dpi->top;

   162

   163

	/* Check clipping */

   164

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

   165

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

   166

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

   167

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

   168

   169

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

   170

}

   171

   172

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

   173

{

   174

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   175

	DrawPixelInfo *dpi = _cur_dpi;

   176

   177

	x -= dpi->left;

   178

	x2 -= dpi->left;

   179

	y -= dpi->top;

   180

	y2 -= dpi->top;

   181

   182

	/* Check clipping */

   183

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

   184

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

   185

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

   186

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

   187

   188

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

   189

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

   190

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

   191

}

   192

   193

/**

   194

 * Draws the projection of a parallelepiped.

   195

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

   196

 *

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

 */

   206

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

   207

{

   208

	/*           ....

   209

	 *         ..    ....

   210

	 *       ..          ....

   211

	 *     ..                ^

   212

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

   213

	 *   :    --__       /   :

   214

	 *   :        --__ /     :

   215

	 *   :            *(x,y) :

   216

	 *   :            |      :

   217

	 *   :            |     ..

   218

	 *    ....        |(dx3,dy3)

   219

	 *        ....    | ..

   220

	 *            ....V.

   221

	 */

   222

   223

	static const byte color = 255;

   224

   225

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

   226

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

   227

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

   228

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

}

   236

   237

   238

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

   239

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

   240

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

   241

 * @param maxw maximum width in pixels of the string

   242

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

   243

static int TruncateString(char *str, int maxw)

   244

{

   245

	int w = 0;

   246

	FontSize size = _cur_fontsize;

   247

	int ddd, ddd_w;

   248

   249

	WChar c;

   250

	char *ddd_pos;

   251

   252

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

   253

   254

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

   255

		if (IsPrintable(c)) {

   256

			w += GetCharacterWidth(size, c);

   257

   258

			if (w >= maxw) {

   259

				/* string got too big... insert dotdotdot, but make sure we do not

   260

				 * print anything beyond the string termination character. */

   261

				for (int i = 0; *ddd_pos != '\0' && i < 3; i++, ddd_pos++) *ddd_pos = '.';

   262

				*ddd_pos = '\0';

   263

				return ddd_w;

   264

			}

   265

		} else {

   266

			if (c == SCC_SETX) {

   267

				w = *str;

   268

				str++;

   269

			} else if (c == SCC_SETXY) {

   270

				w = *str;

   271

				str += 2;

   272

			} else if (c == SCC_TINYFONT) {

   273

				size = FS_SMALL;

   274

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

   275

			} else if (c == SCC_BIGFONT) {

   276

				size = FS_LARGE;

   277

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

   278

			}

   279

		}

   280

   281

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

   282

		if (w + ddd < maxw) {

   283

			ddd_w = w + ddd;

   284

			ddd_pos = str;

   285

		}

   286

	}

   287

   288

	return w;

   289

}

   290

   291

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

   292

{

   293

	GetString(dest, src, last);

   294

	return TruncateString(dest, maxw);

   295

}

   296

   297

/* returns right coordinate */

   298

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

   299

{

   300

	char buffer[512];

   301

   302

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

   303

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

   304

}

   305

   306

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

   307

{

   308

	char buffer[512];

   309

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

   310

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

   311

}

   312

   313

   314

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

   315

{

   316

	char buffer[512];

   317

	int w;

   318

   319

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

   320

	w = GetStringBoundingBox(buffer).width;

   321

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

   322

   323

	return w;

   324

}

   325

   326

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

   327

{

   328

	char buffer[512];

   329

   330

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

   331

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

   332

}

   333

   334

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

   335

{

   336

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

   337

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

   338

}

   339

   340

   341

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

   342

{

   343

	char buffer[512];

   344

	int w;

   345

   346

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

   347

   348

	w = GetStringBoundingBox(buffer).width;

   349

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

   350

   351

	return w;

   352

}

   353

   354

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

   355

{

   356

	char buffer[512];

   357

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

   358

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

   359

}

   360

   361

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

   362

{

   363

	int w = GetStringBoundingBox(str).width;

   364

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

   365

	return w;

   366

}

   367

   368

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

   369

{

   370

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

   371

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

   372

}

   373

   374

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

   375

{

   376

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

   377

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

   378

}

   379

   380

/**

   381

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

   382

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

   383

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

   384

 * placeholders for the newlines.

   385

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

   386

 * line's maximum width.

   387

 *

   388

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

   389

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

   390

 * starting with index 0 is the real string end.

   391

 *

   392

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

   393

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

   394

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

   395

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

   396

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

   397

 */

   398

uint32 FormatStringLinebreaks(char *str, int maxw)

   399

{

   400

	FontSize size = _cur_fontsize;

   401

	int num = 0;

   402

   403

	assert(maxw > 0);

   404

   405

	for (;;) {

   406

		char *last_space = NULL;

   407

		int w = 0;

   408

   409

		for (;;) {

   410

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

   411

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

   412

			if (IsWhitespace(c)) last_space = str;

   413

   414

			if (IsPrintable(c)) {

   415

				w += GetCharacterWidth(size, c);

   416

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

   417

				 * do. We can do two things:

   418

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

   419

				 *    we will truncate the string and bail out.

   420

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

   421

				if (w > maxw) {

   422

					if (last_space == NULL) {

   423

						*Utf8PrevChar(str) = '\0';

   424

						return num + (size << 16);

   425

					}

   426

					str = last_space;

   427

					break;

   428

				}

   429

			} else {

   430

				switch (c) {

   431

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

   432

					case SCC_SETX:  str++; break;

   433

					case SCC_SETXY: str += 2; break;

   434

					case SCC_TINYFONT: size = FS_SMALL; break;

   435

					case SCC_BIGFONT:  size = FS_LARGE; break;

   436

					case '\n': goto end_of_inner_loop;

   437

				}

   438

			}

   439

		}

   440

end_of_inner_loop:

   441

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

   442

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

   443

		 * whitespace seperators are supported */

   444

		num++;

   445

		char *s = Utf8PrevChar(str);

   446

		*s++ = '\0';

   447

   448

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

   449

		if (str - s >= 1) {

   450

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

   451

		}

   452

	}

   453

}

   454

   455

/** Draw a given string with the centre around the given (x,y) coordinates

   456

 * @param x Centre the string around this pixel width

   457

 * @param y Centre the string around this pixel height

   458

 * @param str String to draw

   459

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

   460

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

   461

{

   462

	char buffer[512];

   463

	uint32 tmp;

   464

	int num, w, mt;

   465

	const char *src;

   466

	WChar c;

   467

   468

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

   469

   470

	tmp = FormatStringLinebreaks(buffer, maxw);

   471

	num = GB(tmp, 0, 16);

   472

   473

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

   474

   475

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

   476

   477

	src = buffer;

   478

   479

	for (;;) {

   480

		w = GetStringBoundingBox(src).width;

   481

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

   482

		_cur_fontsize = _last_fontsize;

   483

   484

		for (;;) {

   485

			c = Utf8Consume(&src);

   486

			if (c == 0) {

   487