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"

    15

    16

#ifdef _DEBUG

    17

bool _dbg_screen_rect;

    18

#endif

    19

    20

Colour _cur_palette[256];

    21

    22

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

    23

    24

static int _stringwidth_out;

    25

static Pixel _cursor_backup[64 * 64];

    26

static Rect _invalid_rect;

    27

static const byte *_color_remap_ptr;

    28

static byte _string_colorremap[3];

    29

    30

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    31

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    32

    33

    34

    35

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

    36

{

    37

	byte *dp = (byte*)d;

    38

	byte *sp = (byte*)s;

    39

    40

	assert(h >= 0);

    41

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

    42

		memcpy(dp, sp, w);

    43

		dp += dpitch;

    44

		sp += spitch;

    45

	}

    46

}

    47

    48

    49

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

    50

{

    51

	const Pixel *src;

    52

	Pixel *dst;

    53

	int p;

    54

	int ht;

    55

    56

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

    57

    58

	if (_cursor.visible) UndrawMouseCursor();

    59

	UndrawTextMessage();

    60

    61

	p = _screen.pitch;

    62

    63

	if (yo > 0) {

    64

		// Calculate pointers

    65

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

    66

		src = dst - yo * p;

    67

    68

		// Decrease height and increase top

    69

		top += yo;

    70

		height -= yo;

    71

		assert(height > 0);

    72

    73

		// Adjust left & width

    74

		if (xo >= 0) {

    75

			dst += xo;

    76

			left += xo;

    77

			width -= xo;

    78

		} else {

    79

			src -= xo;

    80

			width += xo;

    81

		}

    82

    83

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

    84

			memcpy(dst, src, width);

    85

			src -= p;

    86

			dst -= p;

    87

		}

    88

	} else {

    89

		// Calculate pointers

    90

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

    91

		src = dst - yo * p;

    92

    93

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

    94

		height += yo;

    95

		assert(height > 0);

    96

    97

		// Adjust left & width

    98

		if (xo >= 0) {

    99

			dst += xo;

   100

			left += xo;

   101

			width -= xo;

   102

		} else {

   103

			src -= xo;

   104

			width += xo;

   105

		}

   106

   107

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

   108

		// because source and destination may overlap

   109

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

   110

			memmove(dst, src, width);

   111

			src += p;

   112

			dst += p;

   113

		}

   114

	}

   115

	// This part of the screen is now dirty.

   116

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

   117

}

   118

   119

   120

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

   121

{

   122

	const DrawPixelInfo* dpi = _cur_dpi;

   123

	Pixel *dst;

   124

	const int otop = top;

   125

	const int oleft = left;

   126

   127

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

   128

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

   129

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

   130

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

   131

   132

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

   133

	right = right - dpi->left + 1;

   134

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

   135

	right -= left;

   136

	assert(right > 0);

   137

   138

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

   139

	bottom = bottom - dpi->top + 1;

   140

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

   141

	bottom -= top;

   142

	assert(bottom > 0);

   143

   144

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

   145

   146

	if (!(color & PALETTE_MODIFIER_GREYOUT)) {

   147

		if (!(color & USE_COLORTABLE)) {

   148

			do {

   149

				memset(dst, color, right);

   150

				dst += dpi->pitch;

   151

			} while (--bottom);

   152

		} else {

   153

			/* use colortable mode */

   154

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

   155

   156

			do {

   157

				int i;

   158

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

   159

				dst += dpi->pitch;

   160

			} while (--bottom);

   161

		}

   162

	} else {

   163

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

   164

		do {

   165

			int i;

   166

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

   167

			dst += dpi->pitch;

   168

		} while (--bottom > 0);

   169

	}

   170

}

   171

   172

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

   173

{

   174

	const DrawPixelInfo* dpi = _cur_dpi;

   175

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

   176

		return;

   177

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

   178

}

   179

   180

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

   181

{

   182

	int dy;

   183

	int dx;

   184

	int stepx;

   185

	int stepy;

   186

	int frac;

   187

   188

	// Check clipping first

   189

	{

   190

		DrawPixelInfo *dpi = _cur_dpi;

   191

		int t;

   192

   193

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

   194

   195

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

   196

   197

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

   198

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

   199

   200

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

   201

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

   202

	}

   203

   204

	dy = (y2 - y) * 2;

   205

	if (dy < 0) {

   206

		dy = -dy;

   207

		stepy = -1;

   208

	} else {

   209

		stepy = 1;

   210

	}

   211

   212

	dx = (x2 - x) * 2;

   213

	if (dx < 0) {

   214

		dx = -dx;

   215

		stepx = -1;

   216

	} else {

   217

		stepx = 1;

   218

	}

   219

   220

	GfxSetPixel(x, y, color);

   221

	if (dx > dy) {

   222

		frac = dy - (dx >> 1);

   223

		while (x != x2) {

   224

			if (frac >= 0) {

   225

				y += stepy;

   226

				frac -= dx;

   227

			}

   228

			x += stepx;

   229

			frac += dy;

   230

			GfxSetPixel(x, y, color);

   231

		}

   232

	} else {

   233

		frac = dx - (dy >> 1);

   234

		while (y != y2) {

   235

			if (frac >= 0) {

   236

				x += stepx;

   237

				frac -= dy;

   238

			}

   239

			y += stepy;

   240

			frac += dx;

   241

			GfxSetPixel(x, y, color);

   242

		}

   243

	}

   244

}

   245

   246

// ASSIGNMENT OF ASCII LETTERS < 32

   247

// 0 - end of string

   248

// 1 - SETX <BYTE>

   249

// 2 - SETXY <BYTE> <BYTE>

   250

// 3-7 -

   251

// 8 - TINYFONT

   252

// 9 - BIGFONT

   253

// 10 - newline

   254

// 11-14 -

   255

// 15-31 - 17 colors

   256

   257

   258

enum {

   259

	ASCII_SETX = 1,

   260

	ASCII_SETXY = 2,

   261

   262

	ASCII_TINYFONT = 8,

   263

	ASCII_BIGFONT = 9,

   264

	ASCII_NL = 10,

   265

   266

	ASCII_COLORSTART = 15,

   267

};

   268

   269

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

   270

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

   271

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

   272

 * @param maxw maximum width in pixels of the string

   273

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

   274

static int TruncateString(char *str, int maxw)

   275

{

   276

	int w = 0;

   277

	int base = _stringwidth_base;

   278

	int ddd, ddd_w;

   279

   280

	byte c;

   281

	char *ddd_pos;

   282

   283

	base = _stringwidth_base;

   284

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

   285

   286

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

   287

		if (c >= ASCII_LETTERSTART) {

   288

			w += GetCharacterWidth(base + c);

   289

   290

			if (w >= maxw) {

   291

				// string got too big... insert dotdotdot

   292

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

   293

				ddd_pos[3] = 0;

   294

				return ddd_w;

   295

			}

   296

		} else {

   297

			if (c == ASCII_SETX) str++;

   298

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

   299

			else if (c == ASCII_TINYFONT) {

   300

				base = 224;

   301

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

   302

			} else if (c == ASCII_BIGFONT) {

   303

				base = 448;

   304

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

   305

			}

   306

		}

   307

   308

		// Remember the last position where three dots fit.

   309

		if (w + ddd < maxw) {

   310

			ddd_w = w + ddd;

   311

			ddd_pos = str;

   312

		}

   313

	}

   314

   315

	return w;

   316

}

   317

   318

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

   319

{

   320

	GetString(dest, src);

   321

	return TruncateString(dest, maxw);

   322

}

   323

   324

/* returns right coordinate */

   325

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

   326

{

   327

	char buffer[512];

   328

   329

	GetString(buffer, str);

   330

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

   331

}

   332

   333

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

   334

{

   335

	char buffer[512];

   336

	TruncateStringID(str, buffer, maxw);

   337

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

   338

}

   339

   340

   341

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

   342

{

   343

	char buffer[512];

   344

   345

	GetString(buffer, str);

   346

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

   347

}

   348

   349

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

   350

{

   351

	char buffer[512];

   352

   353

	TruncateStringID(str, buffer, maxw);

   354

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

   355

}

   356

   357

   358

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

   359

{

   360

	char buffer[512];

   361

	int w;

   362

   363

	GetString(buffer, str);

   364

   365

	w = GetStringWidth(buffer);

   366

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

   367

   368

	return w;

   369

}

   370

   371

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

   372

{

   373

	char buffer[512];

   374

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

   375

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

   376

}

   377

   378

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

   379

{

   380

	int w = GetStringWidth(str);

   381

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

   382

	return w;

   383

}

   384

   385

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

   386

{

   387

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

   388

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

   389

}

   390

   391

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

   392

{

   393

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

   394

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

   395

}

   396

   397

static uint32 FormatStringLinebreaks(char *str, int maxw)

   398

{

   399

	int num = 0;

   400

	int base = _stringwidth_base;

   401

	int w;

   402

	char *last_space;

   403

	byte c;

   404

   405

	for(;;) {

   406

		w = 0;

   407

		last_space = NULL;

   408

   409

		for(;;) {

   410

			c = *str++;

   411

			if (c == ASCII_LETTERSTART) last_space = str;

   412

   413

			if (c >= ASCII_LETTERSTART) {

   414

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

   415

				if (w > maxw) {

   416

					str = last_space;

   417

					if (str == NULL)

   418

						return num + (base << 16);

   419

					break;

   420

				}

   421

			} else {

   422

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

   423

				if (c == ASCII_NL) break;

   424

   425

				if (c == ASCII_SETX) str++;

   426

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

   427

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

   428

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

   429

			}

   430

		}

   431

   432

		num++;

   433

		str[-1] = '\0';

   434

	}

   435

}

   436

   437

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

   438

{

   439

	char buffer[512];

   440

	uint32 tmp;

   441

	int num, w, mt;

   442

	const char *src;

   443

	byte c;

   444

   445

	GetString(buffer, str);

   446

   447

	tmp = FormatStringLinebreaks(buffer, maxw);

   448

	num = GB(tmp, 0, 16);

   449

   450

	switch (GB(tmp, 16, 16)) {

   451

		case   0: mt = 10; break;

   452

		case 244: mt =  6; break;

   453

		default:  mt = 18; break;

   454

	}

   455

   456

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

   457

   458

	src = buffer;

   459

   460

	for(;;) {

   461

		w = GetStringWidth(src);

   462

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

   463

		_stringwidth_base = _stringwidth_out;

   464

   465

		for(;;) {

   466

			c = *src++;

   467

			if (c == 0) {

   468

				y += mt;

   469

				if (--num < 0) {

   470

					_stringwidth_base = 0;

   471

					return;

   472

				}

   473

				break;

   474

			} else if (c == ASCII_SETX) {

   475

				src++;

   476

			} else if (c == ASCII_SETXY) {

   477

				src+=2;

   478

			}

   479

		}

   480

	}

   481

}

   482

   483

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

   484

{

   485

	char buffer[512];

   486

	uint32 tmp;

   487

	int num, mt;

   488

	const char *src;

   489

	byte c;

   490

   491

	GetString(buffer, str);

   492

   493

	tmp = FormatStringLinebreaks(buffer, maxw);

   494

	num = GB(tmp, 0, 16);

   495

   496

	switch (GB(tmp, 16, 16)) {

   497

		case   0: mt = 10; break;

   498

		case 244: mt =  6; break;

   499

		default:  mt = 18; break;

   500

	}

   501

   502

	src = buffer;