1

#include "stdafx.h"

     2

#include "openttd.h"

     4

#include "player.h"

     5

#include "spritecache.h"

     6

#include "strings.h"

     7

#include "string.h"

     8

#include "gfx.h"

     9

#include "table/palettes.h"

    10

#include "hal.h"

    11

#include "variables.h"

    12

    13

Colour _cur_palette[256];

    14

    15

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

    16

    17

static int _stringwidth_out;

    18

static Pixel _cursor_backup[64 * 64];

    19

static Rect _invalid_rect;

    20

static const byte *_color_remap_ptr;

    21

static byte _string_colorremap[3];

    22

    23

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    24

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    25

    26

    27

    28

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

    29

{

    30

	byte *dp = (byte*)d;

    31

	byte *sp = (byte*)s;

    32

    33

	assert(h >= 0);

    34

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

    35

		memcpy(dp, sp, w);

    36

		dp += dpitch;

    37

		sp += spitch;

    38

	}

    39

}

    40

    41

    42

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

    43

{

    44

	const Pixel *src;

    45

	Pixel *dst;

    46

	int p;

    47

	int ht;

    48

    49

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

    50

    51

	if (_cursor.visible) UndrawMouseCursor();

    52

	UndrawTextMessage();

    53

    54

	p = _screen.pitch;

    55

    56

	if (yo > 0) {

    57

		// Calculate pointers

    58

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

    59

		src = dst - yo * p;

    60

    61

		// Decrease height and increase top

    62

		top += yo;

    63

		height -= yo;

    64

		assert(height > 0);

    65

    66

		// Adjust left & width

    67

		if (xo >= 0) {

    68

			dst += xo;

    69

			left += xo;

    70

			width -= xo;

    71

		} else {

    72

			src -= xo;

    73

			width += xo;

    74

		}

    75

    76

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

    77

			memcpy(dst, src, width);

    78

			src -= p;

    79

			dst -= p;

    80

		}

    81

	} else {

    82

		// Calculate pointers

    83

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

    84

		src = dst - yo * p;

    85

    86

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

    87

		height += yo;

    88

		assert(height > 0);

    89

    90

		// Adjust left & width

    91

		if (xo >= 0) {

    92

			dst += xo;

    93

			left += xo;

    94

			width -= xo;

    95

		} else {

    96

			src -= xo;

    97

			width += xo;

    98

		}

    99

   100

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

   101

		// because source and destination may overlap

   102

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

   103

			memmove(dst, src, width);

   104

			src += p;

   105

			dst += p;

   106

		}

   107

	}

   108

	// This part of the screen is now dirty.

   109

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

   110

}

   111

   112

   113

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

   114

{

   115

	DrawPixelInfo *dpi = _cur_dpi;

   116

	Pixel *dst;

   117

	const int otop = top;

   118

	const int oleft = left;

   119

   120

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

   121

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

   122

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

   123

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

   124

   125

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

   126

	right = right - dpi->left + 1;

   127

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

   128

	right -= left;

   129

	assert(right > 0);

   130

   131

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

   132

	bottom = bottom - dpi->top + 1;

   133

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

   134

	bottom -= top;

   135

	assert(bottom > 0);

   136

   137

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

   138

   139

	if (!(color & 0x8000)) {

   140

		if (!(color & 0x4000)) {

   141

			do {

   142

				memset(dst, color, right);

   143

				dst += dpi->pitch;

   144

			} while (--bottom);

   145

		} else {

   146

			/* use colortable mode */

   147

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

   148

   149

			do {

   150

				int i;

   151

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

   152

				dst += dpi->pitch;

   153

			} while (--bottom);

   154

		}

   155

	} else {

   156

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

   157

		do {

   158

			int i;

   159

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

   160

			dst += dpi->pitch;

   161

		} while (--bottom > 0);

   162

	}

   163

}

   164

   165

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

   166

{

   167

	DrawPixelInfo *dpi = _cur_dpi;

   168

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

   169

		return;

   170

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

   171

}

   172

   173

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

   174

{

   175

	int dy;

   176

	int dx;

   177

	int stepx;

   178

	int stepy;

   179

	int frac;

   180

   181

	// Check clipping first

   182

	{

   183

		DrawPixelInfo *dpi = _cur_dpi;

   184

		int t;

   185

   186

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

   187

   188

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

   189

   190

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

   191

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

   192

   193

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

   194

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

   195

	}

   196

   197

	dy = (y2 - y) * 2;

   198

	if (dy < 0) {

   199

		dy = -dy;

   200

		stepy = -1;

   201

	} else {

   202

		stepy = 1;

   203

	}

   204

   205

	dx = (x2 - x) * 2;

   206

	if (dx < 0) {

   207

		dx = -dx;

   208

		stepx = -1;

   209

	} else {

   210

		stepx = 1;

   211

	}

   212

   213

	GfxSetPixel(x, y, color);

   214

	if (dx > dy) {

   215

		frac = dy - (dx >> 1);

   216

		while (x != x2) {

   217

			if (frac >= 0) {

   218

				y += stepy;

   219

				frac -= dx;

   220

			}

   221

			x += stepx;

   222

			frac += dy;

   223

			GfxSetPixel(x, y, color);

   224

		}

   225

	} else {

   226

		frac = dx - (dy >> 1);

   227

		while (y != y2) {

   228

			if (frac >= 0) {

   229

				x += stepx;

   230

				frac -= dy;

   231

			}

   232

			y += stepy;

   233

			frac += dx;

   234

			GfxSetPixel(x, y, color);

   235

		}

   236

	}

   237

}

   238

   239

// ASSIGNMENT OF ASCII LETTERS < 32

   240

// 0 - end of string

   241

// 1 - SETX <BYTE>

   242

// 2 - SETXY <BYTE> <BYTE>

   243

// 3-7 -

   244

// 8 - TINYFONT

   245

// 9 - BIGFONT

   246

// 10 - newline

   247

// 11-14 -

   248

// 15-31 - 17 colors

   249

   250

   251

enum {

   252

	ASCII_SETX = 1,

   253

	ASCII_SETXY = 2,

   254

   255

	ASCII_TINYFONT = 8,

   256

	ASCII_BIGFONT = 9,

   257

	ASCII_NL = 10,

   258

   259

	ASCII_COLORSTART = 15,

   260

};

   261

   262

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

   263

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

   264

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

   265

 * @param maxw maximum width in pixels of the string

   266

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

   267

static int TruncateString(char *str, int maxw)

   268

{

   269

	int w = 0;

   270

	int base = _stringwidth_base;

   271

	int ddd, ddd_w;

   272

   273

	byte c;

   274

	char *ddd_pos;

   275

   276

	base = _stringwidth_base;

   277

	ddd_w = ddd = GetCharacterWidth(base + '.') * 3;

   278

   279

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

   280

		if (c >= ASCII_LETTERSTART) {

   281

			w += GetCharacterWidth(base + c);

   282

   283

			if (w >= maxw) {

   284

				// string got too big... insert dotdotdot

   285

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

   286

				ddd_pos[3] = 0;

   287

				return ddd_w;

   288

			}

   289

		} else {

   290

			if (c == ASCII_SETX) str++;

   291

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

   292

			else if (c == ASCII_TINYFONT) {

   293

				base = 224;

   294

				ddd = GetCharacterWidth(base + '.') * 3;

   295

			} else if (c == ASCII_BIGFONT) {

   296

				base = 448;

   297

				ddd = GetCharacterWidth(base + '.') * 3;

   298

			}

   299

		}

   300

   301

		// Remember the last position where three dots fit.

   302

		if (w + ddd < maxw) {

   303

			ddd_w = w + ddd;

   304

			ddd_pos = str;

   305

		}

   306

	}

   307

   308

	return w;

   309

}

   310

   311

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

   312

{

   313

	GetString(dest, src);

   314

	return TruncateString(dest, maxw);

   315

}

   316

   317

/* returns right coordinate */

   318

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

   319

{

   320

	char buffer[512];

   321

   322

	GetString(buffer, str);

   323

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

   324

}

   325

   326

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

   327

{

   328

	char buffer[512];

   329

	TruncateStringID(str, buffer, maxw);

   330

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

   331

}

   332

   333

   334

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

   335

{

   336

	char buffer[512];

   337

   338

	GetString(buffer, str);

   339

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

   340

}

   341

   342

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

   343

{

   344

	char buffer[512];

   345

   346

	TruncateStringID(str, buffer, maxw);

   347

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

   348

}

   349

   350

   351

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

   352

{

   353

	char buffer[512];

   354

	int w;

   355

   356

	GetString(buffer, str);

   357

   358

	w = GetStringWidth(buffer);

   359

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

   360

   361

	return w;

   362

}

   363

   364

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

   365

{

   366

	char buffer[512];

   367

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

   368

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

   369

}

   370

   371

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

   372

{

   373

	int w = GetStringWidth(str);

   374

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

   375

	return w;

   376

}

   377

   378

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

   379

{

   380

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

   381

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

   382

}

   383

   384

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

   385

{

   386

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

   387

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

   388

}

   389

   390

static uint32 FormatStringLinebreaks(char *str, int maxw)

   391

{

   392

	int num = 0;

   393

	int base = _stringwidth_base;

   394

	int w;

   395

	char *last_space;

   396

	byte c;

   397

   398

	for(;;) {

   399

		w = 0;

   400

		last_space = NULL;

   401

   402

		for(;;) {

   403

			c = *str++;

   404

			if (c == ASCII_LETTERSTART) last_space = str;

   405

   406

			if (c >= ASCII_LETTERSTART) {

   407

				w += GetCharacterWidth(base + (byte)c);

   408

				if (w > maxw) {

   409

					str = last_space;

   410

					if (str == NULL)

   411

						return num + (base << 16);

   412

					break;

   413

				}

   414

			} else {

   415

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

   416

				if (c == ASCII_NL) break;

   417

   418

				if (c == ASCII_SETX) str++;

   419

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

   420

				else if (c == ASCII_TINYFONT) base = 224;

   421

				else if (c == ASCII_BIGFONT) base = 448;

   422

			}

   423

		}

   424

   425

		num++;

   426

		str[-1] = 0;

   427

	}

   428

}

   429

   430

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

   431

{

   432

	char buffer[512];

   433

	uint32 tmp;

   434

	int num, w, mt, t;

   435

	const char *src;

   436

	byte c;

   437

   438

	GetString(buffer, str);

   439

   440

	tmp = FormatStringLinebreaks(buffer, maxw);

   441

	num = (uint16)tmp;

   442

	t = tmp >> 16;

   443

   444

	mt = 10;

   445

	if (t != 0) {

   446

		mt = 6;

   447

		if (t != 244) mt = 18;

   448

	}

   449

   450

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

   451

   452

	src = buffer;

   453

   454

	for(;;) {

   455

		w = GetStringWidth(src);

   456

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

   457

		_stringwidth_base = _stringwidth_out;

   458

   459

		for(;;) {

   460

			c = *src++;

   461

			if (c == 0) {

   462

				y += mt;

   463

				if (--num < 0) {

   464

					_stringwidth_base = 0;

   465

					return;

   466

				}

   467

				break;

   468

			} else if (c == ASCII_SETX) {

   469

				src++;

   470

			} else if (c == ASCII_SETXY) {

   471

				src+=2;

   472

			}

   473

		}

   474

	}

   475

}

   476

   477

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

   478

{

   479

	char buffer[512];

   480

	uint32 tmp;

   481

	int num, w, mt, t;

   482

	const char *src;

   483

	byte c;

   484

   485

	GetString(buffer, str);

   486

   487

	tmp = FormatStringLinebreaks(buffer, maxw);

   488

	num = (uint16)tmp;

   489

	t = tmp >> 16;

   490

	mt = 10;

   491

	if (t != 0) {

   492

		mt = 6;

   493

		if (t != 244) mt = 18;

   494

	}

   495

   496

	src = buffer;

   497

   498

	for(;;) {

   499

		w = GetStringWidth(src);

   500

		DoDrawString(src, x, y, 0xFE);

   501

		_stringwidth_base = _stringwidth_out;

   502

   503

		for(;;) {

   504

			c = *src++;

   505

			if (c == 0) {