1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "player.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"

    16

    17

#ifdef _DEBUG

    18

bool _dbg_screen_rect;

    19

#endif

    20

    21

Colour _cur_palette[256];

    22

byte _stringwidth_table[FS_END][224];

    23

    24

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

    25

    26

FontSize _cur_fontsize;

    27

static FontSize _last_fontsize;

    28

static Pixel _cursor_backup[64 * 64];

    29

static Rect _invalid_rect;

    30

static const byte *_color_remap_ptr;

    31

static byte _string_colorremap[3];

    32

    33

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    34

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    35

    36

    37

    38

void memcpy_pitch(void *d, void *s, int w, int h, int spitch, int dpitch)

    39

{

    40

	byte *dp = (byte*)d;

    41

	byte *sp = (byte*)s;

    42

    43

	assert(h >= 0);

    44

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

    45

		memcpy(dp, sp, w);

    46

		dp += dpitch;

    47

		sp += spitch;

    48

	}

    49

}

    50

    51

    52

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

    53

{

    54

	const Pixel *src;

    55

	Pixel *dst;

    56

	int p;

    57

	int ht;

    58

    59

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

    60

    61

	if (_cursor.visible) UndrawMouseCursor();

    62

	UndrawTextMessage();

    63

    64

	p = _screen.pitch;

    65

    66

	if (yo > 0) {

    67

		// Calculate pointers

    68

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

    69

		src = dst - yo * p;

    70

    71

		// Decrease height and increase top

    72

		top += yo;

    73

		height -= yo;

    74

		assert(height > 0);

    75

    76

		// Adjust left & width

    77

		if (xo >= 0) {

    78

			dst += xo;

    79

			left += xo;

    80

			width -= xo;

    81

		} else {

    82

			src -= xo;

    83

			width += xo;

    84

		}

    85

    86

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

    87

			memcpy(dst, src, width);

    88

			src -= p;

    89

			dst -= p;

    90

		}

    91

	} else {

    92

		// Calculate pointers

    93

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

    94

		src = dst - yo * p;

    95

    96

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

    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

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

   111

		// because source and destination may overlap

   112

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

   113

			memmove(dst, src, width);

   114

			src += p;

   115

			dst += p;

   116

		}

   117

	}

   118

	// This part of the screen is now dirty.

   119

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

   120

}

   121

   122

   123

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

   124

{

   125

	const DrawPixelInfo* dpi = _cur_dpi;

   126

	Pixel *dst;

   127

	const int otop = top;

   128

	const int oleft = left;

   129

   130

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

   131

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

   132

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

   133

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

   134

   135

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

   136

	right = right - dpi->left + 1;

   137

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

   138

	right -= left;

   139

	assert(right > 0);

   140

   141

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

   142

	bottom = bottom - dpi->top + 1;

   143

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

   144

	bottom -= top;

   145

	assert(bottom > 0);

   146

   147

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

   148

   149

	if (!(color & PALETTE_MODIFIER_GREYOUT)) {

   150

		if (!(color & USE_COLORTABLE)) {

   151

			do {

   152

				memset(dst, color, right);

   153

				dst += dpi->pitch;

   154

			} while (--bottom);

   155

		} else {

   156

			/* use colortable mode */

   157

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

   158

   159

			do {

   160

				int i;

   161

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

   162

				dst += dpi->pitch;

   163

			} while (--bottom);

   164

		}

   165

	} else {

   166

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

   167

		do {

   168

			int i;

   169

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

   170

			dst += dpi->pitch;

   171

		} while (--bottom > 0);

   172

	}

   173

}

   174

   175

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

   176

{

   177

	const DrawPixelInfo* dpi = _cur_dpi;

   178

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

   179

		return;

   180

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

   181

}

   182

   183

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

   184

{

   185

	int dy;

   186

	int dx;

   187

	int stepx;

   188

	int stepy;

   189

	int frac;

   190

   191

	// Check clipping first

   192

	{

   193

		DrawPixelInfo *dpi = _cur_dpi;

   194

		int t;

   195

   196

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

   197

   198

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

   199

   200

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

   201

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

   202

   203

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

   204

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

   205

	}

   206

   207

	dy = (y2 - y) * 2;

   208

	if (dy < 0) {

   209

		dy = -dy;

   210

		stepy = -1;

   211

	} else {

   212

		stepy = 1;

   213

	}

   214

   215

	dx = (x2 - x) * 2;

   216

	if (dx < 0) {

   217

		dx = -dx;

   218

		stepx = -1;

   219

	} else {

   220

		stepx = 1;

   221

	}

   222

   223

	GfxSetPixel(x, y, color);

   224

	if (dx > dy) {

   225

		frac = dy - (dx >> 1);

   226

		while (x != x2) {

   227

			if (frac >= 0) {

   228

				y += stepy;

   229

				frac -= dx;

   230

			}

   231

			x += stepx;

   232

			frac += dy;

   233

			GfxSetPixel(x, y, color);

   234

		}

   235

	} else {

   236

		frac = dx - (dy >> 1);

   237

		while (y != y2) {

   238

			if (frac >= 0) {

   239

				x += stepx;

   240

				frac -= dy;

   241

			}

   242

			y += stepy;

   243

			frac += dx;

   244

			GfxSetPixel(x, y, color);

   245

		}

   246

	}

   247

}

   248

   249

   250

static inline SpriteID GetFontBase(FontSize size)

   251

{

   252

	switch (size) {

   253

		default: NOT_REACHED();

   254

		case FS_NORMAL: return SPR_ASCII_SPACE;

   255

		case FS_SMALL:  return SPR_ASCII_SPACE_SMALL;

   256

		case FS_LARGE:  return SPR_ASCII_SPACE_BIG;

   257

	}

   258

}

   259

   260

   261

// ASSIGNMENT OF ASCII LETTERS < 32

   262

// 0 - end of string

   263

// 1 - SETX <BYTE>

   264

// 2 - SETXY <BYTE> <BYTE>

   265

// 3-7 -

   266

// 8 - TINYFONT

   267

// 9 - BIGFONT

   268

// 10 - newline

   269

// 11-14 -

   270

// 15-31 - 17 colors

   271

   272

   273

enum {

   274

	ASCII_SETX = 1,

   275

	ASCII_SETXY = 2,

   276

   277

	ASCII_TINYFONT = 8,

   278

	ASCII_BIGFONT = 9,

   279

	ASCII_NL = 10,

   280

   281

	ASCII_COLORSTART = 15,

   282

};

   283

   284

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

   285

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

   286

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

   287

 * @param maxw maximum width in pixels of the string

   288

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

   289

static int TruncateString(char *str, int maxw)

   290

{

   291

	int w = 0;

   292

	FontSize size = _cur_fontsize;

   293

	int ddd, ddd_w;

   294

   295

	byte c;

   296

	char *ddd_pos;

   297

   298

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

   299

   300

	for (ddd_pos = str; (c = *str++) != '\0'; ) {

   301

		if (c >= ASCII_LETTERSTART) {

   302

			w += GetCharacterWidth(size, c);

   303

   304

			if (w >= maxw) {

   305

				// string got too big... insert dotdotdot

   306

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

   307

				ddd_pos[3] = 0;

   308

				return ddd_w;

   309

			}

   310

		} else {

   311

			if (c == ASCII_SETX) str++;

   312

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

   313

			else if (c == ASCII_TINYFONT) {

   314

				size = FS_SMALL;

   315

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

   316

			} else if (c == ASCII_BIGFONT) {

   317

				size = FS_LARGE;

   318

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

   319

			}

   320

		}

   321

   322

		// Remember the last position where three dots fit.

   323

		if (w + ddd < maxw) {

   324

			ddd_w = w + ddd;

   325

			ddd_pos = str;

   326

		}

   327

	}

   328

   329

	return w;

   330

}

   331

   332

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

   333

{

   334

	GetString(dest, src);

   335

	return TruncateString(dest, maxw);

   336

}

   337

   338

/* returns right coordinate */

   339

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

   340

{

   341

	char buffer[512];

   342

   343

	GetString(buffer, str);

   344

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

   345

}

   346

   347

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

   348

{

   349

	char buffer[512];

   350

	TruncateStringID(str, buffer, maxw);

   351

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

   352

}

   353

   354

   355

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

   356

{

   357

	char buffer[512];

   358

   359

	GetString(buffer, str);

   360

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

   361

}

   362

   363

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

   364

{

   365

	char buffer[512];

   366

   367

	TruncateStringID(str, buffer, maxw);

   368

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

   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);

   378

   379

	w = GetStringWidth(buffer);

   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);

   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 = GetStringWidth(str);

   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

static uint32 FormatStringLinebreaks(char *str, int maxw)

   412

{

   413

	int num = 0;

   414

	FontSize size = _cur_fontsize;

   415

	int w;

   416

	char *last_space;

   417

	byte c;

   418

   419

	for (;;) {

   420

		w = 0;

   421

		last_space = NULL;

   422

   423

		for (;;) {

   424

			c = *str++;

   425

			if (c == ASCII_LETTERSTART) last_space = str;

   426

   427

			if (c >= ASCII_LETTERSTART) {

   428

				w += GetCharacterWidth(size, c);

   429

				if (w > maxw) {

   430

					str = last_space;

   431

					if (str == NULL)

   432

						return num + (size << 16);

   433

					break;

   434

				}

   435

			} else {

   436

				if (c == 0) return num + (size << 16);

   437

				if (c == ASCII_NL) break;

   438

   439

				if (c == ASCII_SETX) str++;

   440

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

   441

				else if (c == ASCII_TINYFONT) size = FS_SMALL;

   442

				else if (c == ASCII_BIGFONT) size = FS_LARGE;

   443

			}

   444

		}

   445

   446

		num++;

   447

		str[-1] = '\0';

   448

	}

   449

}

   450

   451

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

   452

{

   453

	char buffer[512];

   454

	uint32 tmp;

   455

	int num, w, mt;

   456

	const char *src;

   457

	byte c;

   458

   459

	GetString(buffer, str);

   460

   461

	tmp = FormatStringLinebreaks(buffer, maxw);

   462

	num = GB(tmp, 0, 16);

   463

   464

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

   465

   466

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

   467

   468

	src = buffer;

   469

   470

	for (;;) {

   471

		w = GetStringWidth(src);

   472

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

   473

		_cur_fontsize = _last_fontsize;

   474

   475

		for (;;) {

   476

			c = *src++;

   477

			if (c == 0) {

   478

				y += mt;

   479

				if (--num < 0) {

   480

					_cur_fontsize = FS_NORMAL;

   481

					return;

   482

				}

   483

				break;

   484

			} else if (c == ASCII_SETX) {

   485

				src++;

   486

			} else if (c == ASCII_SETXY) {

   487

				src+=2;

   488

			}

   489

		}

   490

	}

   491

}

   492

   493

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

   494

{

   495

	char buffer[512];

   496

	uint32 tmp;

   497

	int num, mt;

   498

	const char *src;