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

Colour _cur_palette[256];

    17

    18

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

    19

    20

static int _stringwidth_out;

    21

static Pixel _cursor_backup[64 * 64];

    22

static Rect _invalid_rect;

    23

static const byte *_color_remap_ptr;

    24

static byte _string_colorremap[3];

    25

    26

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    27

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    28

    29

    30

    31

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

    32

{

    33

	byte *dp = (byte*)d;

    34

	byte *sp = (byte*)s;

    35

    36

	assert(h >= 0);

    37

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

    38

		memcpy(dp, sp, w);

    39

		dp += dpitch;

    40

		sp += spitch;

    41

	}

    42

}

    43

    44

    45

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

    46

{

    47

	const Pixel *src;

    48

	Pixel *dst;

    49

	int p;

    50

	int ht;

    51

    52

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

    53

    54

	if (_cursor.visible) UndrawMouseCursor();

    55

	UndrawTextMessage();

    56

    57

	p = _screen.pitch;

    58

    59

	if (yo > 0) {

    60

		// Calculate pointers

    61

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

    62

		src = dst - yo * p;

    63

    64

		// Decrease height and increase top

    65

		top += yo;

    66

		height -= yo;

    67

		assert(height > 0);

    68

    69

		// Adjust left & width

    70

		if (xo >= 0) {

    71

			dst += xo;

    72

			left += xo;

    73

			width -= xo;

    74

		} else {

    75

			src -= xo;

    76

			width += xo;

    77

		}

    78

    79

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

    80

			memcpy(dst, src, width);

    81

			src -= p;

    82

			dst -= p;

    83

		}

    84

	} else {

    85

		// Calculate pointers

    86

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

    87

		src = dst - yo * p;

    88

    89

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

    90

		height += yo;

    91

		assert(height > 0);

    92

    93

		// Adjust left & width

    94

		if (xo >= 0) {

    95

			dst += xo;

    96

			left += xo;

    97

			width -= xo;

    98

		} else {

    99

			src -= xo;

   100

			width += xo;

   101

		}

   102

   103

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

   104

		// because source and destination may overlap

   105

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

   106

			memmove(dst, src, width);

   107

			src += p;

   108

			dst += p;

   109

		}

   110

	}

   111

	// This part of the screen is now dirty.

   112

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

   113

}

   114

   115

   116

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

   117

{

   118

	DrawPixelInfo *dpi = _cur_dpi;

   119

	Pixel *dst;

   120

	const int otop = top;

   121

	const int oleft = left;

   122

   123

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

   124

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

   125

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

   126

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

   127

   128

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

   129

	right = right - dpi->left + 1;

   130

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

   131

	right -= left;

   132

	assert(right > 0);

   133

   134

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

   135

	bottom = bottom - dpi->top + 1;

   136

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

   137

	bottom -= top;

   138

	assert(bottom > 0);

   139

   140

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

   141

   142

	if (!(color & PALETTE_MODIFIER_GREYOUT)) {

   143

		if (!(color & USE_COLORTABLE)) {

   144

			do {

   145

				memset(dst, color, right);

   146

				dst += dpi->pitch;

   147

			} while (--bottom);

   148

		} else {

   149

			/* use colortable mode */

   150

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

   151

   152

			do {

   153

				int i;

   154

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

   155

				dst += dpi->pitch;

   156

			} while (--bottom);

   157

		}

   158

	} else {

   159

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

   160

		do {

   161

			int i;

   162

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

   163

			dst += dpi->pitch;

   164

		} while (--bottom > 0);

   165

	}

   166

}

   167

   168

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

   169

{

   170

	DrawPixelInfo *dpi = _cur_dpi;

   171

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

   172

		return;

   173

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

   174

}

   175

   176

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

   177

{

   178

	int dy;

   179

	int dx;

   180

	int stepx;

   181

	int stepy;

   182

	int frac;

   183

   184

	// Check clipping first

   185

	{

   186

		DrawPixelInfo *dpi = _cur_dpi;

   187

		int t;

   188

   189

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

   190

   191

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

   192

   193

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

   194

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

   195

   196

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

   197

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

   198

	}

   199

   200

	dy = (y2 - y) * 2;

   201

	if (dy < 0) {

   202

		dy = -dy;

   203

		stepy = -1;

   204

	} else {

   205

		stepy = 1;

   206

	}

   207

   208

	dx = (x2 - x) * 2;

   209

	if (dx < 0) {

   210

		dx = -dx;

   211

		stepx = -1;

   212

	} else {

   213

		stepx = 1;

   214

	}

   215

   216

	GfxSetPixel(x, y, color);

   217

	if (dx > dy) {

   218

		frac = dy - (dx >> 1);

   219

		while (x != x2) {

   220

			if (frac >= 0) {

   221

				y += stepy;

   222

				frac -= dx;

   223

			}

   224

			x += stepx;

   225

			frac += dy;

   226

			GfxSetPixel(x, y, color);

   227

		}

   228

	} else {

   229

		frac = dx - (dy >> 1);

   230

		while (y != y2) {

   231

			if (frac >= 0) {

   232

				x += stepx;

   233

				frac -= dy;

   234

			}

   235

			y += stepy;

   236

			frac += dx;

   237

			GfxSetPixel(x, y, color);

   238

		}

   239

	}

   240

}

   241

   242

// ASSIGNMENT OF ASCII LETTERS < 32

   243

// 0 - end of string

   244

// 1 - SETX <BYTE>

   245

// 2 - SETXY <BYTE> <BYTE>

   246

// 3-7 -

   247

// 8 - TINYFONT

   248

// 9 - BIGFONT

   249

// 10 - newline

   250

// 11-14 -

   251

// 15-31 - 17 colors

   252

   253

   254

enum {

   255

	ASCII_SETX = 1,

   256

	ASCII_SETXY = 2,

   257

   258

	ASCII_TINYFONT = 8,

   259

	ASCII_BIGFONT = 9,

   260

	ASCII_NL = 10,

   261

   262

	ASCII_COLORSTART = 15,

   263

};

   264

   265

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

   266

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

   267

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

   268

 * @param maxw maximum width in pixels of the string

   269

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

   270

static int TruncateString(char *str, int maxw)

   271

{

   272

	int w = 0;

   273

	int base = _stringwidth_base;

   274

	int ddd, ddd_w;

   275

   276

	byte c;

   277

	char *ddd_pos;

   278

   279

	base = _stringwidth_base;

   280

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

   281

   282

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

   283

		if (c >= ASCII_LETTERSTART) {

   284

			w += GetCharacterWidth(base + c);

   285

   286

			if (w >= maxw) {

   287

				// string got too big... insert dotdotdot

   288

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

   289

				ddd_pos[3] = 0;

   290

				return ddd_w;

   291

			}

   292

		} else {

   293

			if (c == ASCII_SETX) str++;

   294

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

   295

			else if (c == ASCII_TINYFONT) {

   296

				base = 224;

   297

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

   298

			} else if (c == ASCII_BIGFONT) {

   299

				base = 448;

   300

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

   301

			}

   302

		}

   303

   304

		// Remember the last position where three dots fit.

   305

		if (w + ddd < maxw) {

   306

			ddd_w = w + ddd;

   307

			ddd_pos = str;

   308

		}

   309

	}

   310

   311

	return w;

   312

}

   313

   314

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

   315

{

   316

	GetString(dest, src);

   317

	return TruncateString(dest, maxw);

   318

}

   319

   320

/* returns right coordinate */

   321

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

   322

{

   323

	char buffer[512];

   324

   325

	GetString(buffer, str);

   326

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

   327

}

   328

   329

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

   330

{

   331

	char buffer[512];

   332

	TruncateStringID(str, buffer, maxw);

   333

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

   334

}

   335

   336

   337

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

   338

{

   339

	char buffer[512];

   340

   341

	GetString(buffer, str);

   342

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

   343

}

   344

   345

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

   346

{

   347

	char buffer[512];

   348

   349

	TruncateStringID(str, buffer, maxw);

   350

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

   351

}

   352

   353

   354

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

   355

{

   356

	char buffer[512];

   357

	int w;

   358

   359

	GetString(buffer, str);

   360

   361

	w = GetStringWidth(buffer);

   362

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

   363

   364

	return w;

   365

}

   366

   367

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

   368

{

   369

	char buffer[512];

   370

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

   371

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

   372

}

   373

   374

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

   375

{

   376

	int w = GetStringWidth(str);

   377

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

   378

	return w;

   379

}

   380

   381

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

   382

{

   383

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

   384

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

   385

}

   386

   387

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

   388

{

   389

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

   390

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

   391

}

   392

   393

static uint32 FormatStringLinebreaks(char *str, int maxw)

   394

{

   395

	int num = 0;

   396

	int base = _stringwidth_base;

   397

	int w;

   398

	char *last_space;

   399

	byte c;

   400

   401

	for(;;) {

   402

		w = 0;

   403

		last_space = NULL;

   404

   405

		for(;;) {

   406

			c = *str++;

   407

			if (c == ASCII_LETTERSTART) last_space = str;

   408

   409

			if (c >= ASCII_LETTERSTART) {

   410

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

   411

				if (w > maxw) {

   412

					str = last_space;

   413

					if (str == NULL)

   414

						return num + (base << 16);

   415

					break;

   416

				}

   417

			} else {

   418

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

   419

				if (c == ASCII_NL) break;

   420

   421

				if (c == ASCII_SETX) str++;

   422

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

   423

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

   424

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

   425

			}

   426

		}

   427

   428

		num++;

   429

		str[-1] = 0;

   430

	}

   431

}

   432

   433

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

   434

{

   435

	char buffer[512];

   436

	uint32 tmp;

   437

	int num, w, mt, t;

   438

	const char *src;

   439

	byte c;

   440

   441

	GetString(buffer, str);

   442

   443

	tmp = FormatStringLinebreaks(buffer, maxw);

   444

	num = (uint16)tmp;

   445

	t = tmp >> 16;

   446

   447

	mt = 10;

   448

	if (t != 0) {

   449

		mt = 6;

   450

		if (t != 244) mt = 18;

   451

	}

   452

   453

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

   454

   455

	src = buffer;

   456

   457

	for(;;) {

   458

		w = GetStringWidth(src);

   459

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

   460

		_stringwidth_base = _stringwidth_out;

   461

   462

		for(;;) {

   463

			c = *src++;

   464

			if (c == 0) {

   465

				y += mt;

   466

				if (--num < 0) {

   467

					_stringwidth_base = 0;

   468

					return;

   469

				}

   470

				break;

   471

			} else if (c == ASCII_SETX) {

   472

				src++;

   473

			} else if (c == ASCII_SETXY) {

   474

				src+=2;

   475

			}

   476

		}

   477

	}

   478

}

   479

   480

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

   481

{

   482

	char buffer[512];

   483

	uint32 tmp;

   484

	int num, w, mt, t;

   485

	const char *src;

   486

	byte c;

   487

   488

	GetString(buffer, str);

   489

   490

	tmp = FormatStringLinebreaks(buffer, maxw);

   491

	num = (uint16)tmp;

   492

	t = tmp >> 16;

   493

	mt = 10;

   494

	if (t != 0) {

   495

		mt = 6;

   496

		if (t != 244) mt = 18;

   497

	}

   498

   499

	src = buffer;

   500

   501

	for(;;) {

   502

		w = GetStringWidth(src);

   503

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

   504

		_stringwidth_base = _stringwidth_out;