1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "spritecache.h"

     4

#include "strings.h"

     5

#include "string.h"

     6

#include "gfx.h"

     7

#include "table/palettes.h"

     8

#include "hal.h"

    10

    11

Colour _cur_palette[256];

    12

    13

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

    14

    15

static int _stringwidth_out;

    16

static Pixel _cursor_backup[64 * 64];

    17

static Rect _invalid_rect;

    18

static const byte *_color_remap_ptr;

    19

static byte _string_colorremap[3];

    20

    21

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    22

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    23

    24

    25

    26

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

    27

{

    28

	byte *dp = (byte*)d;

    29

	byte *sp = (byte*)s;

    30

    31

	assert(h >= 0);

    32

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

    33

		memcpy(dp, sp, w);

    34

		dp += dpitch;

    35

		sp += spitch;

    36

	}

    37

}

    38

    39

    40

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

    41

{

    42

	const Pixel *src;

    43

	Pixel *dst;

    44

	int p;

    45

	int ht;

    46

    47

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

    48

    49

	if (_cursor.visible) UndrawMouseCursor();

    50

	UndrawTextMessage();

    51

    52

	p = _screen.pitch;

    53

    54

	if (yo > 0) {

    55

		// Calculate pointers

    56

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

    57

		src = dst - yo * p;

    58

    59

		// Decrease height and increase top

    60

		top += yo;

    61

		height -= yo;

    62

		assert(height > 0);

    63

    64

		// Adjust left & width

    65

		if (xo >= 0) {

    66

			dst += xo;

    67

			left += xo;

    68

			width -= xo;

    69

		} else {

    70

			src -= xo;

    71

			width += xo;

    72

		}

    73

    74

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

    75

			memcpy(dst, src, width);

    76

			src -= p;

    77

			dst -= p;

    78

		}

    79

	} else {

    80

		// Calculate pointers

    81

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

    82

		src = dst - yo * p;

    83

    84

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

    85

		height += yo;

    86

		assert(height > 0);

    87

    88

		// Adjust left & width

    89

		if (xo >= 0) {

    90

			dst += xo;

    91

			left += xo;

    92

			width -= xo;

    93

		} else {

    94

			src -= xo;

    95

			width += xo;

    96

		}

    97

    98

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

    99

		// because source and destination may overlap

   100

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

   101

			memmove(dst, src, width);

   102

			src += p;

   103

			dst += p;

   104

		}

   105

	}

   106

	// This part of the screen is now dirty.

   107

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

   108

}

   109

   110

   111

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

   112

{

   113

	DrawPixelInfo *dpi = _cur_dpi;

   114

	Pixel *dst;

   115

	const int otop = top;

   116

	const int oleft = left;

   117

   118

	if (dpi->zoom != 0) 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 = dpi->dst_ptr + top * dpi->pitch + left;

   136

   137

	if (!(color & 0x8000)) {

   138

		if (!(color & 0x4000)) {

   139

			do {

   140

				memset(dst, color, right);

   141

				dst += dpi->pitch;

   142

			} while (--bottom);

   143

		} else {

   144

			/* use colortable mode */

   145

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

   146

   147

			do {

   148

				int i;

   149

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

   150

				dst += dpi->pitch;

   151

			} while (--bottom);

   152

		}

   153

	} else {

   154

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

   155

		do {

   156

			int i;

   157

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

   158

			dst += dpi->pitch;

   159

		} while (--bottom > 0);

   160

	}

   161

}

   162

   163

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

   164

{

   165

	DrawPixelInfo *dpi = _cur_dpi;

   166

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

   167

		return;

   168

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

   169

}

   170

   171

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

   172

{

   173

	int dy;

   174

	int dx;

   175

	int stepx;

   176

	int stepy;

   177

	int frac;

   178

   179

	// Check clipping first

   180

	{

   181

		DrawPixelInfo *dpi = _cur_dpi;

   182

		int t;

   183

   184

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

   185

   186

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

   187

   188

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

   189

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

   190

   191

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

   192

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

   193

	}

   194

   195

	dy = (y2 - y) * 2;

   196

	if (dy < 0) {

   197

		dy = -dy;

   198

		stepy = -1;

   199

	} else {

   200

		stepy = 1;

   201

	}

   202

   203

	dx = (x2 - x) * 2;

   204

	if (dx < 0) {

   205

		dx = -dx;

   206

		stepx = -1;

   207

	} else {

   208

		stepx = 1;

   209

	}

   210

   211

	GfxSetPixel(x, y, color);

   212

	if (dx > dy) {

   213

		frac = dy - (dx >> 1);

   214

		while (x != x2) {

   215

			if (frac >= 0) {

   216

				y += stepy;

   217

				frac -= dx;

   218

			}

   219

			x += stepx;

   220

			frac += dy;

   221

			GfxSetPixel(x, y, color);

   222

		}

   223

	} else {

   224

		frac = dx - (dy >> 1);

   225

		while (y != y2) {

   226

			if (frac >= 0) {

   227

				x += stepx;

   228

				frac -= dy;

   229

			}

   230

			y += stepy;

   231

			frac += dx;

   232

			GfxSetPixel(x, y, color);

   233

		}

   234

	}

   235

}

   236

   237

// ASSIGNMENT OF ASCII LETTERS < 32

   238

// 0 - end of string

   239

// 1 - SETX <BYTE>

   240

// 2 - SETXY <BYTE> <BYTE>

   241

// 3-7 -

   242

// 8 - TINYFONT

   243

// 9 - BIGFONT

   244

// 10 - newline

   245

// 11-14 -

   246

// 15-31 - 17 colors

   247

   248

   249

enum {

   250

	ASCII_SETX = 1,

   251

	ASCII_SETXY = 2,

   252

   253

	ASCII_TINYFONT = 8,

   254

	ASCII_BIGFONT = 9,

   255

	ASCII_NL = 10,

   256

   257

	ASCII_COLORSTART = 15,

   258

};

   259

   260

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

   261

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

   262

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

   263

 * @param maxw maximum width in pixels of the string

   264

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

   265

static int TruncateString(char *str, int maxw)

   266

{

   267

	int w = 0;

   268

	int base = _stringwidth_base;

   269

	int ddd, ddd_w;

   270

   271

	byte c;

   272

	char *ddd_pos;

   273

   274

	base = _stringwidth_base;

   275

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

   276

   277

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

   278

		if (c >= ASCII_LETTERSTART) {

   279

			w += GetCharacterWidth(base + c);

   280

   281

			if (w >= maxw) {

   282

				// string got too big... insert dotdotdot

   283

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

   284

				ddd_pos[3] = 0;

   285

				return ddd_w;

   286

			}

   287

		} else {

   288

			if (c == ASCII_SETX) str++;

   289

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

   290

			else if (c == ASCII_TINYFONT) {

   291

				base = 224;

   292

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

   293

			} else if (c == ASCII_BIGFONT) {

   294

				base = 448;

   295

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

   296

			}

   297

		}

   298

   299

		// Remember the last position where three dots fit.

   300

		if (w + ddd < maxw) {

   301

			ddd_w = w + ddd;

   302

			ddd_pos = str;

   303

		}

   304

	}

   305

   306

	return w;

   307

}

   308

   309

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

   310

{

   311

	GetString(dest, src);

   312

	return TruncateString(dest, maxw);

   313

}

   314

   315

/* returns right coordinate */

   316

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

   317

{

   318

	char buffer[512];

   319

   320

	GetString(buffer, str);

   321

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

   322

}

   323

   324

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

   325

{

   326

	char buffer[512];

   327

	TruncateStringID(str, buffer, maxw);

   328

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

   329

}

   330

   331

   332

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

   333

{

   334

	char buffer[512];

   335

   336

	GetString(buffer, str);

   337

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

   338

}

   339

   340

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

   341

{

   342

	char buffer[512];

   343

   344

	TruncateStringID(str, buffer, maxw);

   345

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

   346

}

   347

   348

   349

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

   350

{

   351

	char buffer[512];

   352

	int w;

   353

   354

	GetString(buffer, str);

   355

   356

	w = GetStringWidth(buffer);

   357

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

   358

   359

	return w;

   360

}

   361

   362

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

   363

{

   364

	char buffer[512];

   365

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

   366

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

   367

}

   368

   369

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

   370

{

   371

	int w = GetStringWidth(str);

   372

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

   373

	return w;

   374

}

   375

   376

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

   377

{

   378

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

   379

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

   380

}

   381

   382

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

   383

{

   384

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

   385

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

   386

}

   387

   388

static uint32 FormatStringLinebreaks(char *str, int maxw)

   389

{

   390

	int num = 0;

   391

	int base = _stringwidth_base;

   392

	int w;

   393

	char *last_space;

   394

	byte c;

   395

   396

	for(;;) {

   397

		w = 0;

   398

		last_space = NULL;

   399

   400

		for(;;) {

   401

			c = *str++;

   402

			if (c == ASCII_LETTERSTART) last_space = str;

   403

   404

			if (c >= ASCII_LETTERSTART) {

   405

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

   406

				if (w > maxw) {

   407

					str = last_space;

   408

					if (str == NULL)

   409

						return num + (base << 16);

   410

					break;

   411

				}

   412

			} else {

   413

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

   414

				if (c == ASCII_NL) break;

   415

   416

				if (c == ASCII_SETX) str++;

   417

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

   418

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

   419

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

   420

			}

   421

		}

   422

   423

		num++;

   424

		str[-1] = 0;

   425

	}

   426

}

   427

   428

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

   429

{

   430

	char buffer[512];

   431

	uint32 tmp;

   432

	int num, w, mt, t;

   433

	const char *src;

   434

	byte c;

   435

   436

	GetString(buffer, str);

   437

   438

	tmp = FormatStringLinebreaks(buffer, maxw);

   439

	num = (uint16)tmp;

   440

	t = tmp >> 16;

   441

   442

	mt = 10;

   443

	if (t != 0) {

   444

		mt = 6;

   445

		if (t != 244) mt = 18;

   446

	}

   447

   448

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

   449

   450

	src = buffer;

   451

   452

	for(;;) {

   453

		w = GetStringWidth(src);

   454

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

   455

		_stringwidth_base = _stringwidth_out;

   456

   457

		for(;;) {

   458

			c = *src++;

   459

			if (c == 0) {

   460

				y += mt;

   461

				if (--num < 0) {

   462

					_stringwidth_base = 0;

   463

					return;

   464

				}

   465

				break;

   466

			} else if (c == ASCII_SETX) {

   467

				src++;

   468

			} else if (c == ASCII_SETXY) {

   469

				src+=2;

   470

			}

   471

		}

   472

	}

   473

}

   474

   475

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

   476

{

   477

	char buffer[512];

   478

	uint32 tmp;

   479

	int num, w, mt, t;

   480

	const char *src;

   481

	byte c;

   482

   483

	GetString(buffer, str);

   484

   485

	tmp = FormatStringLinebreaks(buffer, maxw);

   486

	num = (uint16)tmp;

   487

	t = tmp >> 16;

   488

	mt = 10;

   489

	if (t != 0) {

   490

		mt = 6;

   491

		if (t != 244) mt = 18;

   492

	}

   493

   494

	src = buffer;

   495

   496

	for(;;) {

   497

		w = GetStringWidth(src);

   498

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

   499

		_stringwidth_base = _stringwidth_out;

   500

   501

		for(;;) {

   502

			c = *src++;

   503

			if (c == 0) {

   504

				y += mt;

   505

				if (--num < 0) {