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

#include "network/network_func.h"

    24

    25

#include "table/palettes.h"

    26

#include "table/sprites.h"

    27

#include "table/control_codes.h"

    28

    29

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

    30

bool _fullscreen;

    31

CursorVars _cursor;

    32

bool _ctrl_pressed;   ///< Is Ctrl pressed?

    33

bool _shift_pressed;  ///< Is Shift pressed?

    34

byte _fast_forward;

    35

bool _left_button_down;     ///< Is left mouse button pressed?

    36

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

    37

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

    38

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

    39

DrawPixelInfo _screen;

    40

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

    41

bool _exit_game;

    42

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

    43

byte _game_mode;

    44

int8 _pause_game;

    45

int _pal_first_dirty;

    46

int _pal_count_dirty;

    47

    48

Colour _cur_palette[256];

    49

byte _stringwidth_table[FS_END][224]; ///< Cache containing width of often used characters. @see GetCharacterWidth()

    50

DrawPixelInfo *_cur_dpi;

    51

byte _colour_gradient[COLOUR_END][8];

    52

    53

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

    54

static int ReallyDoDrawString(const char *string, int x, int y, uint16 real_colour, bool parse_string_also_when_clipped = false);

    55

    56

FontSize _cur_fontsize;

    57

static FontSize _last_fontsize;

    58

static uint8 _cursor_backup[64 * 64 * 4];

    59

    60

/**

    61

 * The rect for repaint.

    62

 *

    63

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

    64

 *

    65

 * @ingroup dirty

    66

 */

    67

static Rect _invalid_rect;

    68

static const byte *_color_remap_ptr;

    69

static byte _string_colorremap[3];

    70

    71

enum {

    72

	DIRTY_BLOCK_HEIGHT   = 8,

    73

	DIRTY_BLOCK_WIDTH    = 64,

    74

};

    75

static uint _dirty_bytes_per_line = 0;

    76

static byte *_dirty_blocks = NULL;

    77

    78

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

    79

{

    80

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

    81

    82

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

    83

    84

	if (_cursor.visible) UndrawMouseCursor();

    85

    86

#ifdef ENABLE_NETWORK

    87

	NetworkUndrawChatMessage();

    88

#endif /* ENABLE_NETWORK */

    89

    90

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

    91

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

    92

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

    93

}

    94

    95

    96

/**

    97

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

    98

 *

    99

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

   100

 * @param left Minimum X (inclusive)

   101

 * @param top Minimum Y (inclusive)

   102

 * @param right Maximum X (inclusive)

   103

 * @param bottom Maximum Y (inclusive)

   104

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

   105

 * @param mode

   106

 *         FILLRECT_OPAQUE:   Fill the rectangle with the specified color

   107

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

   108

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

   109

 */

   110

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

   111

{

   112

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   113

	const DrawPixelInfo *dpi = _cur_dpi;

   114

	void *dst;

   115

	const int otop = top;

   116

	const int oleft = left;

   117

   118

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

   119

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

   120

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

   121

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

   122

   123

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

   124

	right = right - dpi->left + 1;

   125

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

   126

	right -= left;

   127

	assert(right > 0);

   128

   129

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

   130

	bottom = bottom - dpi->top + 1;

   131

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

   132

	bottom -= top;

   133

	assert(bottom > 0);

   134

   135

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

   136

   137

	switch (mode) {

   138

		default: // FILLRECT_OPAQUE

   139

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

   140

			break;

   141

   142

		case FILLRECT_RECOLOR:

   143

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

   144

			break;

   145

   146

		case FILLRECT_CHECKER: {

   147

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

   148

			do {

   149

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

   150

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

   151

			} while (--bottom > 0);

   152

			break;

   153

		}

   154

	}

   155

}

   156

   157

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

   158

{

   159

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   160

	DrawPixelInfo *dpi = _cur_dpi;

   161

   162

	x -= dpi->left;

   163

	x2 -= dpi->left;

   164

	y -= dpi->top;

   165

	y2 -= dpi->top;

   166

   167

	/* Check clipping */

   168

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

   169

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

   170

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

   171

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

   172

   173

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

   174

}

   175

   176

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

   177

{

   178

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   179

	DrawPixelInfo *dpi = _cur_dpi;

   180

   181

	x -= dpi->left;

   182

	x2 -= dpi->left;

   183

	y -= dpi->top;

   184

	y2 -= dpi->top;

   185

   186

	/* Check clipping */

   187

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

   188

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

   189

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

   190

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

   191

   192

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

   193

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

   194

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

   195

}

   196

   197

/**

   198

 * Draws the projection of a parallelepiped.

   199

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

   200

 *

   201

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

   202

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

   203

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

   204

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

   205

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

   206

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

   207

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

   208

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

   209

 */

   210

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

   211

{

   212

	/*           ....

   213

	 *         ..    ....

   214

	 *       ..          ....

   215

	 *     ..                ^

   216

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

   217

	 *   :    --__       /   :

   218

	 *   :        --__ /     :

   219

	 *   :            *(x,y) :

   220

	 *   :            |      :

   221

	 *   :            |     ..

   222

	 *    ....        |(dx3,dy3)

   223

	 *        ....    | ..

   224

	 *            ....V.

   225

	 */

   226

   227

	static const byte color = 255;

   228

   229

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

   230

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

   231

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

   232

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

}

   240

   241

   242

#if !defined(WITH_ICU)

   243

static void HandleBiDiAndArabicShapes(char *text, const char *lastof) {}

   244

#else

   245

#include "unicode/ubidi.h"

   246

#include "unicode/ushape.h"

   247

   248

/**

   249

 * Function to be able to handle right-to-left text and Arabic chars properly.

   250

 *

   251

 * First: right-to-left (RTL) is stored 'logically' in almost all applications

   252

 *        and so do we. This means that their text is stored from right to the

   253

 *        left in memory and any non-RTL text (like numbers or English) are

   254

 *        then stored from left-to-right. When we want to actually draw the

   255

 *        text we need to reverse the RTL text in memory, which is what

   256

 *        happens in ubidi_writeReordered.

   257

 * Second: Arabic characters "differ" based on their context. To draw the

   258

 *        correct variant we pass it through u_shapeArabic. This function can

   259

 *        add or remove some characters. This is the reason for the lastof

   260

 *        so we know till where we can fill the output.

   261

 *

   262

 * Sadly enough these functions work with a custom character format, UChar,

   263

 * which isn't the same size as WChar. Because of that we need to transform

   264

 * our text first to UChars and then back to something we can use.

   265

 *

   266

 * To be able to truncate strings properly you must truncate before passing to

   267

 * this function. This way the logical begin of the string remains and the end

   268

 * gets chopped of instead of the other way around.

   269

 *

   270

 * The reshaping of Arabic characters might increase or decrease the width of

   271

 * the characters/string. So it might still overflow after truncation, though

   272

 * the chance is fairly slim as most characters get shorter instead of longer.

   273

 * @param buffer the buffer to read from/to

   274

 * @param lastof the end of the buffer

   275

 */

   276

static void HandleBiDiAndArabicShapes(char *buffer, const char *lastof)

   277

{

   278

	UChar input_output[DRAW_STRING_BUFFER];

   279

	UChar intermediate[DRAW_STRING_BUFFER];

   280

   281

	char *t = buffer;

   282

	size_t length = 0;

   283

	while (*t != '\0' && length < lengthof(input_output)) {

   284

		WChar tmp;

   285

		t += Utf8Decode(&tmp, t);

   286

		input_output[length++] = tmp;

   287

	}

   288

	input_output[length] = 0;

   289

   290

	UErrorCode err = U_ZERO_ERROR;

   291

	UBiDi *para = ubidi_openSized((int32_t)length, 0, &err);

   292

	if (para == NULL) return;

   293

   294

	ubidi_setPara(para, input_output, (int32_t)length, _dynlang.text_dir == TD_RTL ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR, NULL, &err);

   295

	ubidi_writeReordered(para, intermediate, (int32_t)length, 0, &err);

   296

	length = u_shapeArabic(intermediate, (int32_t)length, input_output, lengthof(input_output), U_SHAPE_TEXT_DIRECTION_VISUAL_LTR | U_SHAPE_LETTERS_SHAPE, &err);

   297

	ubidi_close(para);

   298

   299

	if (U_FAILURE(err)) return;

   300

   301

	t = buffer;

   302

	for (size_t i = 0; i < length && t < (lastof - 4); i++) {

   303

		t += Utf8Encode(t, input_output[i]);

   304

	}

   305

	*t = '\0';

   306

}

   307

#endif /* WITH_ICU */

   308

   309

   310

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

   311

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

   312

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

   313

 * @param maxw maximum width in pixels of the string

   314

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

   315

static int TruncateString(char *str, int maxw)

   316

{

   317

	int w = 0;

   318

	FontSize size = _cur_fontsize;

   319

	int ddd, ddd_w;

   320

   321

	WChar c;

   322

	char *ddd_pos;

   323

   324

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

   325

   326

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

   327

		if (IsPrintable(c)) {

   328

			w += GetCharacterWidth(size, c);

   329

   330

			if (w >= maxw) {

   331

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

   332

				 * print anything beyond the string termination character. */

   333

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

   334

				*ddd_pos = '\0';

   335

				return ddd_w;

   336

			}

   337

		} else {

   338

			if (c == SCC_SETX) {

   339

				w = *str;

   340

				str++;

   341

			} else if (c == SCC_SETXY) {

   342

				w = *str;

   343

				str += 2;

   344

			} else if (c == SCC_TINYFONT) {

   345

				size = FS_SMALL;

   346

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

   347

			} else if (c == SCC_BIGFONT) {

   348

				size = FS_LARGE;

   349

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

   350

			}

   351

		}

   352

   353

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

   354

		if (w + ddd < maxw) {

   355

			ddd_w = w + ddd;

   356

			ddd_pos = str;

   357

		}

   358

	}

   359

   360

	return w;

   361

}

   362

   363

/**

   364

 * Write string to output buffer, truncating it to specified maximal width in pixels if it is too long.

   365

 *

   366

 * @param src   String to truncate

   367

 * @param dest  Start of character output buffer where truncated string is stored

   368

 * @param maxw  Maximal allowed length of the string in pixels

   369

 * @param last  Address of last character in output buffer

   370

 *

   371

 * @return Actual width of the (possibly) truncated string in pixels

   372

 */

   373

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

   374

{

   375

	GetString(dest, src, last);

   376

	return TruncateString(dest, maxw);

   377

}

   378

   379

/**

   380

 * Draw string starting at position (x,y).

   381

 *

   382

 * @param x      X position to start drawing

   383

 * @param y      Y position to start drawing

   384

 * @param str    String to draw

   385

 * @param color  Color used for drawing the string, see DoDrawString() for details

   386

 *

   387

 * @return Horizontal coordinate after drawing the string

   388

 */

   389

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

   390

{

   391

	char buffer[DRAW_STRING_BUFFER];

   392

   393

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

   394

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

   395

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

   396

}

   397

   398

/**

   399

 * Draw string, possibly truncated to make it fit in its allocated space

   400

 *

   401

 * @param x      X position to start drawing

   402

 * @param y      Y position to start drawing

   403

 * @param str    String to draw

   404

 * @param color  Color used for drawing the string, see DoDrawString() for details

   405

 * @param maxw   Maximal width of the string

   406

 *

   407

 * @return Horizontal coordinate after drawing the (possibly truncated) string

   408

 */

   409

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

   410

{

   411

	char buffer[DRAW_STRING_BUFFER];

   412

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

   413

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

   414

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

   415

}

   416

   417

/**

   418

 * Draw string right-aligned.

   419

 *

   420

 * @param x      Right-most x position of the string

   421

 * @param y      Y position of the string

   422

 * @param str    String to draw

   423

 * @param color  Color used for drawing the string, see DoDrawString() for details

   424

 *

   425

 * @return Width of drawn string in pixels

   426

 */

   427

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

   428

{

   429

	char buffer[DRAW_STRING_BUFFER];

   430

	int w;

   431

   432

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

   433

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

   434

   435

	w = GetStringBoundingBox(buffer).width;

   436

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

   437

   438

	return w;

   439

}

   440

   441

/**

   442

 * Draw string right-aligned, possibly truncated to make it fit in its allocated space

   443

 *

   444

 * @param x      Right-most x position to start drawing

   445

 * @param y      Y position to start drawing

   446

 * @param str    String to draw

   447

 * @param color  Color used for drawing the string, see DoDrawString() for details

   448

 * @param maxw   Maximal width of the string

   449

 */

   450

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

   451

{

   452

	char buffer[DRAW_STRING_BUFFER];

   453

   454

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

   455

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

   456

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

   457

}

   458

   459

/**

   460

 * Draw string right-aligned with a line underneath it.

   461

 *

   462

 * @param x      Right-most x position of the string

   463

 * @param y      Y position of the string

   464

 * @param str    String to draw

   465

 * @param color  Color used for drawing the string, see DoDrawString() for details

   466

 */

   467

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

   468

{

   469

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

   470

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

   471

}

   472

   473

/**

   474

 * Draw string centered.

   475

 *

   476

 * @param x      X position of center of the string

   477

 * @param y      Y position of center of the string

   478

 * @param str    String to draw

   479

 * @param color  Color used for drawing the string, see DoDrawString() for details

   480

 *

   481

 * @return Width of the drawn string in pixels

   482

 */

   483

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

   484

{

   485

	char buffer[DRAW_STRING_BUFFER];

   486

	int w;

   487

   488

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