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

Colour _cur_palette[256];

    25

byte _stringwidth_table[FS_END][224];

    26

    27

typedef enum BlitterModes {

    28

	BM_NORMAL,

    29

	BM_COLOUR_REMAP,

    30

	BM_TRANSPARENT,

    31

} BlitterMode;

    32

    33

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

    34

    35

FontSize _cur_fontsize;

    36

static FontSize _last_fontsize;

    37

static Pixel _cursor_backup[64 * 64];

    38

static Rect _invalid_rect;

    39

static const byte *_color_remap_ptr;

    40

static byte _string_colorremap[3];

    41

    42

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    43

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    44

    45

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

    46

{

    47

	byte *dstp = (byte*)dst;

    48

	byte *srcp = (byte*)src;

    49

    50

	assert(h >= 0);

    51

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

    52

		memcpy(dstp, srcp, w);

    53

		dstp += dstpitch;

    54

		srcp += srcpitch;

    55

	}

    56

}

    57

    58

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

    59

{

    60

	const Pixel *src;

    61

	Pixel *dst;

    62

	int p;

    63

	int ht;

    64

    65

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

    66

    67

	if (_cursor.visible) UndrawMouseCursor();

    68

	UndrawTextMessage();

    69

    70

	p = _screen.pitch;

    71

    72

	if (yo > 0) {

    73

		// Calculate pointers

    74

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

    75

		src = dst - yo * p;

    76

    77

		// Decrease height and increase top

    78

		top += yo;

    79

		height -= yo;

    80

		assert(height > 0);

    81

    82

		// Adjust left & width

    83

		if (xo >= 0) {

    84

			dst += xo;

    85

			left += xo;

    86

			width -= xo;

    87

		} else {

    88

			src -= xo;

    89

			width += xo;

    90

		}

    91

    92

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

    93

			memcpy(dst, src, width);

    94

			src -= p;

    95

			dst -= p;

    96

		}

    97

	} else {

    98

		// Calculate pointers

    99

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

   100

		src = dst - yo * p;

   101

   102

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

   103

		height += yo;

   104

		assert(height > 0);

   105

   106

		// Adjust left & width

   107

		if (xo >= 0) {

   108

			dst += xo;

   109

			left += xo;

   110

			width -= xo;

   111

		} else {

   112

			src -= xo;

   113

			width += xo;

   114

		}

   115

   116

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

   117

		// because source and destination may overlap

   118

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

   119

			memmove(dst, src, width);

   120

			src += p;

   121

			dst += p;

   122

		}

   123

	}

   124

	// This part of the screen is now dirty.

   125

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

   126

}

   127

   128

   129

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

   130

{

   131

	const DrawPixelInfo* dpi = _cur_dpi;

   132

	Pixel *dst;

   133

	const int otop = top;

   134

	const int oleft = left;

   135

   136

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

   137

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

   138

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

   139

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

   140

   141

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

   142

	right = right - dpi->left + 1;

   143

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

   144

	right -= left;

   145

	assert(right > 0);

   146

   147

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

   148

	bottom = bottom - dpi->top + 1;

   149

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

   150

	bottom -= top;

   151

	assert(bottom > 0);

   152

   153

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

   154

   155

	if (!(color & PALETTE_MODIFIER_GREYOUT)) {

   156

		if (!(color & USE_COLORTABLE)) {

   157

			do {

   158

				memset(dst, color, right);

   159

				dst += dpi->pitch;

   160

			} while (--bottom);

   161

		} else {

   162

			/* use colortable mode */

   163

			const byte* ctab = GetNonSprite(color & COLORTABLE_MASK) + 1;

   164

   165

			do {

   166

				int i;

   167

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

   168

				dst += dpi->pitch;

   169

			} while (--bottom);

   170

		}

   171

	} else {

   172

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

   173

		do {

   174

			int i;

   175

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

   176

			dst += dpi->pitch;

   177

		} while (--bottom > 0);

   178

	}

   179

}

   180

   181

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

   182

{

   183

	const DrawPixelInfo* dpi = _cur_dpi;

   184

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

   185

		return;

   186

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

   187

}

   188

   189

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

   190

{

   191

	int dy;

   192

	int dx;

   193

	int stepx;

   194

	int stepy;

   195

	int frac;

   196

   197

	// Check clipping first

   198

	{

   199

		DrawPixelInfo *dpi = _cur_dpi;

   200

		int t;

   201

   202

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

   203

   204

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

   205

   206

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

   207

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

   208

   209

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

   210

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

   211

	}

   212

   213

	dy = (y2 - y) * 2;

   214

	if (dy < 0) {

   215

		dy = -dy;

   216

		stepy = -1;

   217

	} else {

   218

		stepy = 1;

   219

	}

   220

   221

	dx = (x2 - x) * 2;

   222

	if (dx < 0) {

   223

		dx = -dx;

   224

		stepx = -1;

   225

	} else {

   226

		stepx = 1;

   227

	}

   228

   229

	GfxSetPixel(x, y, color);

   230

	if (dx > dy) {

   231

		frac = dy - (dx >> 1);

   232

		while (x != x2) {

   233

			if (frac >= 0) {

   234

				y += stepy;

   235

				frac -= dx;

   236

			}

   237

			x += stepx;

   238

			frac += dy;

   239

			GfxSetPixel(x, y, color);

   240

		}

   241

	} else {

   242

		frac = dx - (dy >> 1);

   243

		while (y != y2) {

   244

			if (frac >= 0) {

   245

				x += stepx;

   246

				frac -= dy;

   247

			}

   248

			y += stepy;

   249

			frac += dx;

   250

			GfxSetPixel(x, y, color);

   251

		}

   252

	}

   253

}

   254

   255

   256

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

   257

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

   258

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

   259

 * @param maxw maximum width in pixels of the string

   260

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

   261

static int TruncateString(char *str, int maxw)

   262

{

   263

	int w = 0;

   264

	FontSize size = _cur_fontsize;

   265

	int ddd, ddd_w;

   266

   267

	WChar c;

   268

	char *ddd_pos;

   269

   270

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

   271

   272

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

   273

		if (IsPrintable(c)) {

   274

			w += GetCharacterWidth(size, c);

   275

   276

			if (w >= maxw) {

   277

				// string got too big... insert dotdotdot

   278

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

   279

				ddd_pos[3] = 0;

   280

				return ddd_w;

   281

			}

   282

		} else {

   283

			if (c == SCC_SETX) str++;

   284

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

   285

			else if (c == SCC_TINYFONT) {

   286

				size = FS_SMALL;

   287

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

   288

			} else if (c == SCC_BIGFONT) {

   289

				size = FS_LARGE;

   290

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

   291

			}

   292

		}

   293

   294

		// Remember the last position where three dots fit.

   295

		if (w + ddd < maxw) {

   296

			ddd_w = w + ddd;

   297

			ddd_pos = str;

   298

		}

   299

	}

   300

   301

	return w;

   302

}

   303

   304

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

   305

{

   306

	GetString(dest, src, last);

   307

	return TruncateString(dest, maxw);

   308

}

   309

   310

/* returns right coordinate */

   311

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

   312

{

   313

	char buffer[512];

   314

   315

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

   316

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

   317

}

   318

   319

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

   320

{

   321

	char buffer[512];

   322

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

   323

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

   324

}

   325

   326

   327

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

   328

{

   329

	char buffer[512];

   330

	int w;

   331

   332

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

   333

	w = GetStringBoundingBox(buffer).width;

   334

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

   335

   336

	return w;

   337

}

   338

   339

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

   340

{

   341

	char buffer[512];

   342

   343

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

   344

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

   345

}

   346

   347

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

   348

{

   349

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

   350

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

   351

}

   352

   353

   354

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

   355

{

   356

	char buffer[512];

   357

	int w;

   358

   359

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

   360

   361

	w = GetStringBoundingBox(buffer).width;

   362

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

   363

   364

	return w;

   365

}

   366

   367

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

   368

{

   369

	char buffer[512];

   370

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

   371

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

   372

}

   373

   374

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

   375

{

   376

	int w = GetStringBoundingBox(str).width;

   377

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

   378

	return w;

   379

}

   380

   381

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

   382

{

   383

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

   384

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

   385

}

   386

   387

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

   388

{

   389

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

   390

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

   391

}

   392

   393

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

   394

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

   395

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

   396

 * placeholders for the newlines.<br/>

   397

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

   398

 * line's maximum width.

   399

 *

   400

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

   401

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

   402

 * starting with index 0 is the real string end.

   403

 *

   404

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

   405

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

   406

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

   407

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

   408

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

   409

uint32 FormatStringLinebreaks(char *str, int maxw)

   410

{

   411

	FontSize size = _cur_fontsize;

   412

	int num = 0;

   413

   414

	assert(maxw > 0);

   415

   416

	for (;;) {

   417

		char *last_space = NULL;

   418

		int w = 0;

   419

   420

		for (;;) {

   421

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

   422

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

   423

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

   424

   425

			if (IsPrintable(c)) {

   426

				w += GetCharacterWidth(size, c);

   427

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

   428

				 * do. We can do two things:

   429

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

   430

				 *    we will truncate the string and bail out.

   431

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

   432

				if (w > maxw) {

   433

					if (last_space == NULL) {

   434

						str[-1] = '\0';

   435

						return num + (size << 16);

   436

					}

   437

					str = last_space;

   438

					break;

   439

				}

   440

			} else {

   441

				switch (c) {

   442

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

   443

					case SCC_SETX:  str++; break;

   444

					case SCC_SETXY: str +=2; break;

   445

					case SCC_TINYFONT: size = FS_SMALL; break;

   446

					case SCC_BIGFONT:  size = FS_LARGE; break;

   447

					case '\n': goto end_of_inner_loop;

   448

				}

   449

			}

   450

		}

   451

end_of_inner_loop:

   452

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

   453

		num++;

   454

		str[-1] = '\0';

   455

	}

   456

}

   457

   458

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

   459

 * @param x Centre the string around this pixel width

   460

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

   461

 * @param str String to draw

   462

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

   463

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

   464

{

   465

	char buffer[512];

   466

	uint32 tmp;

   467

	int num, w, mt;

   468

	const char *src;

   469

	WChar c;

   470

   471

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

   472

   473

	tmp = FormatStringLinebreaks(buffer, maxw);

   474

	num = GB(tmp, 0, 16);

   475

   476

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

   477

   478

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

   479

   480

	src = buffer;

   481

   482

	for (;;) {

   483

		w = GetStringBoundingBox(src).width;

   484

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

   485

		_cur_fontsize = _last_fontsize;

   486

   487

		for (;;) {

   488

			c = Utf8Consume(&src);

   489

			if (c == 0) {

   490

				y += mt;

   491

				if (--num < 0) {

   492

					_cur_fontsize = FS_NORMAL;

   493

					return;

   494