1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "macros.h"

     7

#include "spritecache.h"

     8

#include "strings.h"

     9

#include "string.h"

    10

#include "gfx.h"

    11

#include "table/palettes.h"

    12

#include "table/sprites.h"

    13

#include "hal.h"

    14

#include "variables.h"

    15

#include "table/control_codes.h"

    16

#include "fontcache.h"

    17

#include "genworld.h"

    18

#include "debug.h"

    19

    20

#ifdef _DEBUG

    21

bool _dbg_screen_rect;

    22

#endif

    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;

    39

int _pal_first_dirty;

    40

int _pal_last_dirty;

    41

    42

Colour _cur_palette[256];

    43

byte _stringwidth_table[FS_END][224];

    44

    45

typedef enum BlitterModes {

    46

	BM_NORMAL,

    47

	BM_COLOUR_REMAP,

    48

	BM_TRANSPARENT,

    49

} BlitterMode;

    50

    51

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

    52

    53

FontSize _cur_fontsize;

    54

static FontSize _last_fontsize;

    55

static Pixel _cursor_backup[64 * 64];

    56

static Rect _invalid_rect;

    57

static const byte *_color_remap_ptr;

    58

static byte _string_colorremap[3];

    59

    60

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    61

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    62

    63

void memcpy_pitch(void *dst, void *src, int w, int h, int srcpitch, int dstpitch)

    64

{

    65

	byte *dstp = (byte*)dst;

    66

	byte *srcp = (byte*)src;

    67

    68

	assert(h >= 0);

    69

	for (; h != 0; --h) {

    70

		memcpy(dstp, srcp, w);

    71

		dstp += dstpitch;

    72

		srcp += srcpitch;

    73

	}

    74

}

    75

    76

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

    77

{

    78

	const Pixel *src;

    79

	Pixel *dst;

    80

	int p;

    81

	int ht;

    82

    83

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

    84

    85

	if (_cursor.visible) UndrawMouseCursor();

    86

	UndrawTextMessage();

    87

    88

	p = _screen.pitch;

    89

    90

	if (yo > 0) {

    91

		// Calculate pointers

    92

		dst = _screen.dst_ptr + (top + height - 1) * p + left;

    93

		src = dst - yo * p;

    94

    95

		// Decrease height and increase top

    96

		top += yo;

    97

		height -= yo;

    98

		assert(height > 0);

    99

   100

		// Adjust left & width

   101

		if (xo >= 0) {

   102

			dst += xo;

   103

			left += xo;

   104

			width -= xo;

   105

		} else {

   106

			src -= xo;

   107

			width += xo;

   108

		}

   109

   110

		for (ht = height; ht > 0; --ht) {

   111

			memcpy(dst, src, width);

   112

			src -= p;

   113

			dst -= p;

   114

		}

   115

	} else {

   116

		// Calculate pointers

   117

		dst = _screen.dst_ptr + top * p + left;

   118

		src = dst - yo * p;

   119

   120

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

   121

		height += yo;

   122

		assert(height > 0);

   123

   124

		// Adjust left & width

   125

		if (xo >= 0) {

   126

			dst += xo;

   127

			left += xo;

   128

			width -= xo;

   129

		} else {

   130

			src -= xo;

   131

			width += xo;

   132

		}

   133

   134

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

   135

		// because source and destination may overlap

   136

		for (ht = height; ht > 0; --ht) {

   137

			memmove(dst, src, width);

   138

			src += p;

   139

			dst += p;

   140

		}

   141

	}

   142

	// This part of the screen is now dirty.

   143

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

   144

}

   145

   146

   147

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

   148

{

   149

	const DrawPixelInfo* dpi = _cur_dpi;

   150

	Pixel *dst;

   151

	const int otop = top;

   152

	const int oleft = left;

   153

   154

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

   155

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

   156

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

   157

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

   158

   159

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

   160

	right = right - dpi->left + 1;

   161

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

   162

	right -= left;

   163

	assert(right > 0);

   164

   165

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

   166

	bottom = bottom - dpi->top + 1;

   167

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

   168

	bottom -= top;

   169

	assert(bottom > 0);

   170

   171

	dst = dpi->dst_ptr + top * dpi->pitch + left;

   172

   173

	if (!HASBIT(color, PALETTE_MODIFIER_GREYOUT)) {

   174

		if (!HASBIT(color, USE_COLORTABLE)) {

   175

			do {

   176

				memset(dst, color, right);

   177

				dst += dpi->pitch;

   178

			} while (--bottom);

   179

		} else {

   180

			/* use colortable mode */

   181

			const byte* ctab = GetNonSprite(GB(color, 0, PALETTE_WIDTH)) + 1;

   182

   183

			do {

   184

				int i;

   185

				for (i = 0; i != right; i++) dst[i] = ctab[dst[i]];

   186

				dst += dpi->pitch;

   187

			} while (--bottom);

   188

		}

   189

	} else {

   190

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

   191

		do {

   192

			int i;

   193

			for (i = (bo ^= 1); i < right; i += 2) dst[i] = (byte)color;

   194

			dst += dpi->pitch;

   195

		} while (--bottom > 0);

   196

	}

   197

}

   198

   199

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

   200

{

   201

	const DrawPixelInfo* dpi = _cur_dpi;

   202

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

   203

		return;

   204

	dpi->dst_ptr[y * dpi->pitch + x] = color;

   205

}

   206

   207

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

   208

{

   209

	int dy;

   210

	int dx;

   211

	int stepx;

   212

	int stepy;

   213

	int frac;

   214

   215

	// Check clipping first

   216

	{

   217

		DrawPixelInfo *dpi = _cur_dpi;

   218

		int t;

   219

   220

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

   221

   222

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

   223

   224

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

   225

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

   226

   227

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

   228

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

   229

	}

   230

   231

	dy = (y2 - y) * 2;

   232

	if (dy < 0) {

   233

		dy = -dy;

   234

		stepy = -1;

   235

	} else {

   236

		stepy = 1;

   237

	}

   238

   239

	dx = (x2 - x) * 2;

   240

	if (dx < 0) {

   241

		dx = -dx;

   242

		stepx = -1;

   243

	} else {

   244

		stepx = 1;

   245

	}

   246

   247

	GfxSetPixel(x, y, color);

   248

	if (dx > dy) {

   249

		frac = dy - (dx >> 1);

   250

		while (x != x2) {

   251

			if (frac >= 0) {

   252

				y += stepy;

   253

				frac -= dx;

   254

			}

   255

			x += stepx;

   256

			frac += dy;

   257

			GfxSetPixel(x, y, color);

   258

		}

   259

	} else {

   260

		frac = dx - (dy >> 1);

   261

		while (y != y2) {

   262

			if (frac >= 0) {

   263

				x += stepx;

   264

				frac -= dy;

   265

			}

   266

			y += stepy;

   267

			frac += dx;

   268

			GfxSetPixel(x, y, color);

   269

		}

   270

	}

   271

}

   272

   273

   274

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

   275

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

   276

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

   277

 * @param maxw maximum width in pixels of the string

   278

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

   279

static int TruncateString(char *str, int maxw)

   280

{

   281

	int w = 0;

   282

	FontSize size = _cur_fontsize;

   283

	int ddd, ddd_w;

   284

   285

	WChar c;

   286

	char *ddd_pos;

   287

   288

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

   289

   290

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

   291

		if (IsPrintable(c)) {

   292

			w += GetCharacterWidth(size, c);

   293

   294

			if (w >= maxw) {

   295

				// string got too big... insert dotdotdot

   296

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

   297

				ddd_pos[3] = 0;

   298

				return ddd_w;

   299

			}

   300

		} else {

   301

			if (c == SCC_SETX) str++;

   302

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

   303

			else if (c == SCC_TINYFONT) {

   304

				size = FS_SMALL;

   305

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

   306

			} else if (c == SCC_BIGFONT) {

   307

				size = FS_LARGE;

   308

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

   309

			}

   310

		}

   311

   312

		// Remember the last position where three dots fit.

   313

		if (w + ddd < maxw) {

   314

			ddd_w = w + ddd;

   315

			ddd_pos = str;

   316

		}

   317

	}

   318

   319

	return w;

   320

}

   321

   322

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

   323

{

   324

	GetString(dest, src, last);

   325

	return TruncateString(dest, maxw);

   326

}

   327

   328

/* returns right coordinate */

   329

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

   330

{

   331

	char buffer[512];

   332

   333

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

   334

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

   335

}

   336

   337

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

   338

{

   339

	char buffer[512];

   340

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

   341

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

   342

}

   343

   344

   345

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

   346

{

   347

	char buffer[512];

   348

	int w;

   349

   350

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

   351

	w = GetStringBoundingBox(buffer).width;

   352

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

   353

   354

	return w;

   355

}

   356

   357

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

   358

{

   359

	char buffer[512];

   360

   361

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

   362

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

   363

}

   364

   365

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

   366

{

   367

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

   368

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

   369

}

   370

   371

   372

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

   373

{

   374

	char buffer[512];

   375

	int w;

   376

   377

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

   378

   379

	w = GetStringBoundingBox(buffer).width;

   380

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

   381

   382

	return w;

   383

}

   384

   385

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

   386

{

   387

	char buffer[512];

   388

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

   389

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

   390

}

   391

   392

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

   393

{

   394

	int w = GetStringBoundingBox(str).width;

   395

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

   396

	return w;

   397

}

   398

   399

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

   400

{

   401

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

   402

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

   403

}

   404

   405

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

   406

{

   407

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

   408

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

   409

}

   410

   411

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

   412

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

   413

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

   414

 * placeholders for the newlines.<br/>

   415

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

   416

 * line's maximum width.

   417

 *

   418

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

   419

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

   420

 * starting with index 0 is the real string end.

   421

 *

   422

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

   423

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

   424

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

   425

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

   426

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

   427

uint32 FormatStringLinebreaks(char *str, int maxw)

   428

{

   429

	FontSize size = _cur_fontsize;

   430

	int num = 0;

   431

   432

	assert(maxw > 0);

   433

   434

	for (;;) {

   435

		char *last_space = NULL;

   436

		int w = 0;

   437

   438

		for (;;) {

   439

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

   440

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

   441

			if (c == ' ') last_space = str;

   442

   443

			if (IsPrintable(c)) {

   444

				w += GetCharacterWidth(size, c);

   445

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

   446

				 * do. We can do two things:

   447

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

   448

				 *    we will truncate the string and bail out.

   449

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

   450

				if (w > maxw) {

   451

					if (last_space == NULL) {

   452

						str[-1] = '\0';

   453

						return num + (size << 16);

   454

					}

   455

					str = last_space;

   456

					break;

   457

				}

   458

			} else {

   459

				switch (c) {

   460

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

   461

					case SCC_SETX:  str++; break;

   462

					case SCC_SETXY: str +=2; break;

   463

					case SCC_TINYFONT: size = FS_SMALL; break;

   464

					case SCC_BIGFONT:  size = FS_LARGE; break;

   465

					case '\n': goto end_of_inner_loop;

   466

				}

   467

			}

   468

		}

   469

end_of_inner_loop:

   470

		/* string didn't fit on line, so 'dummy' terminate and increase linecount */

   471

		num++;

   472

		str[-1] = '\0';

   473

	}

   474

}

   475

   476

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

   477

 * @param x Centre the string around this pixel width

   478

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

   479

 * @param str String to draw

   480

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

   481

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

   482

{

   483

	char buffer[512];

   484

	uint32 tmp;

   485

	int num, w, mt;

   486

	const char *src;

   487

	WChar c;

   488

   489

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

   490

   491

	tmp = FormatStringLinebreaks(buffer, maxw);

   492

	num = GB(tmp, 0, 16);

   493

   494

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