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"

     9

    10

Colour _cur_palette[256];

    11

    12

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

    13

    14

static int _stringwidth_out;

    15

static Pixel _cursor_backup[64 * 64];

    16

static Rect _invalid_rect;

    17

static const byte *_color_remap_ptr;

    18

static byte _string_colorremap[3];

    19

    20

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    21

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    22

    23

    24

    25

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

    26

{

    27

	byte *dp = (byte*)d;

    28

	byte *sp = (byte*)s;

    29

    30

	assert(h >= 0);

    31

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

    32

		memcpy(dp, sp, w);

    33

		dp += dpitch;

    34

		sp += spitch;

    35

	}

    36

}

    37

    38

    39

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

    40

{

    41

	const Pixel *src;

    42

	Pixel *dst;

    43

	int p;

    44

	int ht;

    45

    46

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

    47

    48

	if (_cursor.visible) UndrawMouseCursor();

    49

	UndrawTextMessage();

    50

    51

	p = _screen.pitch;

    52

    53

	if (yo > 0) {

    54

		// Calculate pointers

    55

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

    56

		src = dst - yo * p;

    57

    58

		// Decrease height and increase top

    59

		top += yo;

    60

		height -= yo;

    61

		assert(height > 0);

    62

    63

		// Adjust left & width

    64

		if (xo >= 0) {

    65

			dst += xo;

    66

			left += xo;

    67

			width -= xo;

    68

		} else {

    69

			src -= xo;

    70

			width += xo;

    71

		}

    72

    73

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

    74

			memcpy(dst, src, width);

    75

			src -= p;

    76

			dst -= p;

    77

		}

    78

	} else {

    79

		// Calculate pointers

    80

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

    81

		src = dst - yo * p;

    82

    83

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

    84

		height += yo;

    85

		assert(height > 0);

    86

    87

		// Adjust left & width

    88

		if (xo >= 0) {

    89

			dst += xo;

    90

			left += xo;

    91

			width -= xo;

    92

		} else {

    93

			src -= xo;

    94

			width += xo;

    95

		}

    96

    97

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

    98

		// because source and destination may overlap

    99

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

   100

			memmove(dst, src, width);

   101

			src += p;

   102

			dst += p;

   103

		}

   104

	}

   105

	// This part of the screen is now dirty.

   106

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

   107

}

   108

   109

   110

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

   111

{

   112

	DrawPixelInfo *dpi = _cur_dpi;

   113

	Pixel *dst;

   114

	const int otop = top;

   115

	const int oleft = left;

   116

   117

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

   118

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

   119

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

   120

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

   121

   122

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

   123

	right = right - dpi->left + 1;

   124

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

   125

	right -= left;

   126

	assert(right > 0);

   127

   128

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

   129

	bottom = bottom - dpi->top + 1;

   130

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

   131

	bottom -= top;

   132

	assert(bottom > 0);

   133

   134

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

   135

   136

	if (!(color & 0x8000)) {

   137

		if (!(color & 0x4000)) {

   138

			do {

   139

				memset(dst, color, right);

   140

				dst += dpi->pitch;

   141

			} while (--bottom);

   142

		} else {

   143

			/* use colortable mode */

   144

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

   145

   146

			do {

   147

				int i;

   148

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

   149

				dst += dpi->pitch;

   150

			} while (--bottom);

   151

		}

   152

	} else {

   153

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

   154

		do {

   155

			int i;

   156

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

   157

			dst += dpi->pitch;

   158

		} while (--bottom > 0);

   159

	}

   160

}

   161

   162

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

   163

{

   164

	DrawPixelInfo *dpi = _cur_dpi;

   165

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

   166

		return;

   167

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

   168

}

   169

   170

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

   171

{

   172

	int dy;

   173

	int dx;

   174

	int stepx;

   175

	int stepy;

   176

	int frac;

   177

   178

	// Check clipping first

   179

	{

   180

		DrawPixelInfo *dpi = _cur_dpi;

   181

		int t;

   182

   183

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

   184

   185

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

   186

   187

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

   188

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

   189

   190

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

   191

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

   192

	}

   193

   194

	dy = (y2 - y) * 2;

   195

	if (dy < 0) {

   196

		dy = -dy;

   197

		stepy = -1;

   198

	} else {

   199

		stepy = 1;

   200

	}

   201

   202

	dx = (x2 - x) * 2;

   203

	if (dx < 0) {

   204

		dx = -dx;

   205

		stepx = -1;

   206

	} else {

   207

		stepx = 1;

   208

	}

   209

   210

	GfxSetPixel(x, y, color);

   211

	if (dx > dy) {

   212

		frac = dy - (dx >> 1);

   213

		while (x != x2) {

   214

			if (frac >= 0) {

   215

				y += stepy;

   216

				frac -= dx;

   217

			}

   218

			x += stepx;

   219

			frac += dy;

   220

			GfxSetPixel(x, y, color);

   221

		}

   222

	} else {

   223

		frac = dx - (dy >> 1);

   224

		while (y != y2) {

   225

			if (frac >= 0) {

   226

				x += stepx;

   227

				frac -= dy;

   228

			}

   229

			y += stepy;

   230

			frac += dx;

   231

			GfxSetPixel(x, y, color);

   232

		}

   233

	}

   234

}

   235

   236

// ASSIGNMENT OF ASCII LETTERS < 32

   237

// 0 - end of string

   238

// 1 - SETX <BYTE>

   239

// 2 - SETXY <BYTE> <BYTE>

   240

// 3-7 -

   241

// 8 - TINYFONT

   242

// 9 - BIGFONT

   243

// 10 - newline

   244

// 11-14 -

   245

// 15-31 - 17 colors

   246

   247

   248

enum {

   249

	ASCII_SETX = 1,

   250

	ASCII_SETXY = 2,

   251

   252

	ASCII_TINYFONT = 8,

   253

	ASCII_BIGFONT = 9,

   254

	ASCII_NL = 10,

   255

   256

	ASCII_COLORSTART = 15,

   257

};

   258

   259

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

   260

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

   261

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

   262

 * @param maxw maximum width in pixels of the string

   263

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

   264

static int TruncateString(char *str, int maxw)

   265

{

   266

	int w = 0;

   267

	int base = _stringwidth_base;

   268

	int ddd, ddd_w;

   269

   270

	byte c;

   271

	char *ddd_pos;

   272

   273

	base = _stringwidth_base;

   274

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

   275

   276

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

   277

		if (c >= ASCII_LETTERSTART) {

   278

			w += GetCharacterWidth(base + c);

   279

   280

			if (w >= maxw) {

   281

				// string got too big... insert dotdotdot

   282

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

   283

				ddd_pos[3] = 0;

   284

				return ddd_w;

   285

			}

   286

		} else {

   287

			if (c == ASCII_SETX) str++;

   288

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

   289

			else if (c == ASCII_TINYFONT) {

   290

				base = 224;

   291

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

   292

			} else if (c == ASCII_BIGFONT) {

   293

				base = 448;

   294

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

   295

			}

   296

		}

   297

   298

		// Remember the last position where three dots fit.

   299

		if (w + ddd < maxw) {

   300

			ddd_w = w + ddd;

   301

			ddd_pos = str;

   302

		}

   303

	}

   304

   305

	return w;

   306

}

   307

   308

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

   309

{

   310

	GetString(dest, src);

   311

	return TruncateString(dest, maxw);

   312

}

   313

   314

/* returns right coordinate */

   315

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

   316

{

   317

	char buffer[512];

   318

   319

	GetString(buffer, str);

   320

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

   321

}

   322

   323

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

   324

{

   325

	char buffer[512];

   326

	TruncateStringID(str, buffer, maxw);

   327

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

   328

}

   329

   330

   331

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

   332

{

   333

	char buffer[512];

   334

   335

	GetString(buffer, str);

   336

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

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

   344

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

   345

}

   346

   347

   348

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

   349

{

   350

	char buffer[512];

   351

	int w;

   352

   353

	GetString(buffer, str);

   354

   355

	w = GetStringWidth(buffer);

   356

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

   357

   358

	return w;

   359

}

   360

   361

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

   362

{

   363

	char buffer[512];

   364

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

   365

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

   366

}

   367

   375

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

   376

{

   377

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

   378

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

   379

}

   380

   381

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

   382

{

   383

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

   384

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

   385

}

   386

   387

static uint32 FormatStringLinebreaks(char *str, int maxw)

   388

{

   389

	int num = 0;

   390

	int base = _stringwidth_base;

   391

	int w;

   392

	char *last_space;

   393

	byte c;

   394

   395

	for(;;) {

   396

		w = 0;

   397

		last_space = NULL;

   398

   399

		for(;;) {

   400

			c = *str++;

   401

			if (c == ASCII_LETTERSTART) last_space = str;

   402

   403

			if (c >= ASCII_LETTERSTART) {

   404

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

   405

				if (w > maxw) {

   406

					str = last_space;

   407

					if (str == NULL)

   408

						return num + (base << 16);

   409

					break;

   410

				}

   411

			} else {

   412

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

   413

				if (c == ASCII_NL) break;

   414

   415

				if (c == ASCII_SETX) str++;

   416

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

   417

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

   418

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

   419

			}

   420

		}

   421

   422

		num++;

   423

		str[-1] = 0;

   424

	}

   425

}

   426

   427

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

   428

{

   429

	char buffer[512];

   430

	uint32 tmp;

   431

	int num, w, mt, t;

   432

	const char *src;

   433

	byte c;

   434

   435

	GetString(buffer, str);

   436

   437

	tmp = FormatStringLinebreaks(buffer, maxw);

   438

	num = (uint16)tmp;

   439

	t = tmp >> 16;

   440

   441

	mt = 10;

   442

	if (t != 0) {

   443

		mt = 6;

   444

		if (t != 244) mt = 18;

   445

	}

   446

   447

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

   448

   449

	src = buffer;

   450

   451

	for(;;) {

   452

		w = GetStringWidth(src);

   453

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

   454

		_stringwidth_base = _stringwidth_out;

   455

   456

		for(;;) {

   457

			c = *src++;

   458

			if (c == 0) {

   459

				y += mt;

   460

				if (--num < 0) {

   461

					_stringwidth_base = 0;

   462

					return;

   463

				}

   464

				break;

   465

			} else if (c == ASCII_SETX) {

   466

				src++;

   467

			} else if (c == ASCII_SETXY) {

   468

				src+=2;

   469

			}

   470

		}

   471

	}

   472

}

   473

   474

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

   475

{

   476

	char buffer[512];

   477

	uint32 tmp;

   478

	int num, w, mt, t;

   479

	const char *src;

   480

	byte c;

   481

   482

	GetString(buffer, str);

   483

   484

	tmp = FormatStringLinebreaks(buffer, maxw);

   485

	num = (uint16)tmp;

   486

	t = tmp >> 16;

   487

	mt = 10;

   488

	if (t != 0) {

   489

		mt = 6;

   490

		if (t != 244) mt = 18;

   491

	}

   492

   493

	src = buffer;

   494

   495

	for(;;) {

   496

		w = GetStringWidth(src);

   497

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

   498

		_stringwidth_base = _stringwidth_out;

   499

   500

		for(;;) {

   501

			c = *src++;

   502

			if (c == 0) {

   503

				y += mt;

   504

				if (--num < 0) {

   505

					_stringwidth_base = 0;