1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "table/palettes.h"

     5

#include "hal.h"

     6

     7

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

     8

void GfxInitPalettes();

     9

    10

static int _stringwidth_out;

    11

static byte _cursor_backup[64*64];

    12

static Rect _invalid_rect;

    13

static byte *_color_remap_ptr;

    14

static byte _string_colorremap[3];

    15

    16

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH/64)

    17

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    18

    19

    20

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

    21

{

    22

	byte *dp = (byte*)d;

    23

	byte *sp = (byte*)s;

    24

    25

	assert(h >= 0);

    26

	if (h != 0) do {

    27

		memcpy(dp, sp, w);

    28

		dp += dpitch;

    29

		sp += spitch;

    30

	} while (--h);

    31

}

    32

    33

    34

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

    35

	byte *src, *dst;

    36

	int p;

    37

	int ht;

    38

    39

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

    40

		return;

    41

    42

	if (_cursor.visible)

    43

		UndrawMouseCursor();

    44

    45

	p = _screen.pitch;

    46

    47

	if (yo > 0) {

    48

		// Calculate pointers

    49

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

    50

		src = dst - yo * p;

    51

    52

		// Decrease height and increase top

    53

		top += yo;

    54

		height -= yo;

    55

		assert(height > 0);

    56

    57

		// Adjust left & width

    58

		if (xo >= 0) {

    59

			dst += xo;

    60

			left += xo;

    61

			width -= xo;

    62

		} else {

    63

			src -= xo;

    64

			width += xo;

    65

		}

    66

    67

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

    68

			memcpy(dst, src, width);

    69

			src -= p;

    70

			dst -= p;

    71

		}

    72

	} else {

    73

		// Calculate pointers

    74

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

    75

		src = dst - yo * p;

    76

    77

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

    78

		height += yo;

    79

		assert(height > 0);

    80

    81

		// Adjust left & width

    82

		if (xo >= 0) {

    83

			dst += xo;

    84

			left += xo;

    85

			width -= xo;

    86

		} else {

    87

			src -= xo;

    88

			width += xo;

    89

		}

    90

    91

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

    92

		// because source and destination may overlap

    93

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

    94

			memmove(dst, src, width);

    95

			src += p;

    96

			dst += p;

    97

		}

    98

	}

    99

	// This part of the screen is now dirty.

   100

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

   101

}

   102

   103

   104

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

   105

	DrawPixelInfo *dpi = _cur_dpi;

   106

	byte *dst,*ctab;

   107

	const int otop = top;

   108

	const int oleft = left;

   109

   110

	if (dpi->zoom != 0)

   111

		return;

   112

   113

	if (left > right || top > bottom)

   114

		return;

   115

   116

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

   117

		return;

   118

   119

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

   120

		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

			ctab = GetSpritePtr(color & 0x3FFF) + 1;

   145

			do {

   146

				int i;

   147

				for(i=0; i!=right;i++)

   148

					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)

   157

				dst[i] = (byte)color;

   158

			dst += dpi->pitch;

   159

		} while (--bottom > 0);

   160

	}

   161

}

   162

   163

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

   184

			return;

   185

   186

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

   187

			return;

   188

   189

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

   190

		if (x > t && x2 > t)

   191

			return;

   192

   193

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

   194

		if (y > t && y2 > t)

   195

			return;

   196

	}

   197

   198

	dy = (y2 - y) * 2;

   199

	if (dy < 0) { dy = -dy;  stepy = -1; } else { stepy = 1; }

   200

   201

	dx = (x2 - x) * 2;

   202

	if (dx < 0) { dx = -dx;  stepx = -1; } else { stepx = 1; }

   203

   204

	GfxSetPixel(x, y, color);

   205

	if (dx > dy) {

   206

		frac = dy - (dx >> 1);

   207

		while (x != x2) {

   208

			if (frac >= 0) {

   209

				y += stepy;

   210

				frac -= dx;

   211

			}

   212

			x += stepx;

   213

			frac += dy;

   214

			GfxSetPixel(x, y, color);

   215

		}

   216

	} else {

   217

		frac = dx - (dy >> 1);

   218

		while (y != y2) {

   219

			if (frac >= 0) {

   220

				x += stepx;

   221

				frac -= dy;

   222

			}

   223

			y += stepy;

   224

			frac += dx;

   225

			GfxSetPixel(x, y, color);

   226

		}

   227

	}

   228

}

   229

   230

// ASSIGNMENT OF ASCII LETTERS < 32

   231

// 0 - end of string

   232

// 1 - SETX <BYTE>

   233

// 2 - SETXY <BYTE> <BYTE>

   234

// 3-7 -

   235

// 8 - TINYFONT

   236

// 9 - BIGFONT

   237

// 10 - newline

   238

// 11-14 -

   239

// 15-31 - 17 colors

   240

   241

   242

enum {

   243

	ASCII_LETTERSTART = 32,

   244

   245

	ASCII_SETX = 1,

   246

	ASCII_SETXY = 2,

   247

   248

	ASCII_TINYFONT = 8,

   249

	ASCII_BIGFONT = 9,

   250

	ASCII_NL = 10,

   251

   252

	ASCII_COLORSTART = 15,

   253

};

   254

   255

   256

/* returns right coordinate */

   257

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

   258

{

   259

	GetString(str_buffr, str);

   260

	assert(strlen(str_buffr) < sizeof(str_buffr) - 1);

   261

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

   262

}

   263

   264

   265

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

   266

{

   267

	GetString(str_buffr, str);

   268

	assert(strlen(str_buffr) < sizeof(str_buffr) - 1);

   269

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

   270

}

   271

   272

   273

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

   274

{

   275

	int w;

   276

   277

	GetString(str_buffr, str);

   278

	assert(strlen(str_buffr) < sizeof(str_buffr) - 1);

   279

   280

	w = GetStringWidth(str_buffr);

   281

	DoDrawString(str_buffr, x - (w>>1), y, color);

   282

   283

	return w;

   284

}

   285

   286

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

   287

{

   288

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

   289

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

   290

}

   291

   292

uint32 FormatStringLinebreaks(byte *str, int maxw) {

   293

	int num = 0;

   294

	int base = _stringwidth_base;

   295

	int w;

   296

	byte *last_space;

   297

	byte c;

   298

   299

	for(;;) {

   300

		w = 0;

   301

		last_space = NULL;

   302

   303

		for(;;) {

   304

			c = *str++;

   305

			if (c == ' ') last_space = str;

   306

   307

			if (c >= ASCII_LETTERSTART) {

   308

				w += _stringwidth_table[base + ((byte)c) - 0x20];

   309

				if (w > maxw) {

   310

					str = last_space;

   311

					if (str == NULL)

   312

						return num + (base << 16);

   313

					break;

   314

				}

   315

			} else {

   316

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

   317

				if (c == ASCII_NL) break;

   318

   319

				if (c == ASCII_SETX) str++;

   320

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

   321

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

   322

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

   323

			}

   324

		}

   325

   326

		num++;

   327

		str[-1] = 0;

   328

	}

   329

}

   330

   331

   332

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

   333

{

   334

	uint32 tmp;

   335

	int num, w, mt, t;

   336

	byte *src;

   337

	byte c;

   338

   339

	GetString(str_buffr, str);

   340

	assert(strlen(str_buffr) < sizeof(str_buffr) - 1);

   341

   342

	tmp = FormatStringLinebreaks(str_buffr, maxw);

   343

	num = (uint16)tmp;

   344

	t = tmp >> 16;

   345

   346

	mt = 10;

   347

	if (t != 0) {

   348

		mt = 6;

   349

		if (t != 244) mt = 18;

   350

	}

   351

   352

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

   353

   354

	src = str_buffr;

   355

   356

	for(;;) {

   357

		w = GetStringWidth(src);

   358

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

   359

		_stringwidth_base = _stringwidth_out;

   360

   361

		for(;;) {

   362

			c = *src++;

   363

			if (c == 0) {

   364

				y += mt;

   365

				if (--num < 0) {

   366

					_stringwidth_base = 0;

   367

					return;

   368

				}

   369

				break;

   370

			} else if (c == ASCII_SETX) {

   371

				src++;

   372

			} else if (c == ASCII_SETXY) {

   373

				src+=2;

   374

			}

   375

		}

   376

	}

   377

}

   378

   379

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

   380

	uint32 tmp;

   381

	int num, w, mt, t;

   382

	byte *src;

   383

	byte c;

   384

   385

	GetString(str_buffr, str);

   386

	assert(strlen(str_buffr) < sizeof(str_buffr) - 1);

   387

   388

	tmp = FormatStringLinebreaks(str_buffr, maxw);

   389

	num = (uint16)tmp;

   390

	t = tmp >> 16;

   391

	mt = 10;

   392

	if (t != 0) {

   393

		mt = 6;

   394

		if (t != 244) mt = 18;

   395

	}

   396

   397

	src = str_buffr;

   398

   399

	for(;;) {

   400

		w = GetStringWidth(src);

   401

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

   402

		_stringwidth_base = _stringwidth_out;

   403

   404

		for(;;) {

   405

			c = *src++;

   406

			if (c == 0) {

   407

				y += mt;

   408

				if (--num < 0) {

   409

					_stringwidth_base = 0;

   410

					return;

   411

				}

   412

				break;

   413

			} else if (c == ASCII_SETX) {

   414

				src++;

   415

			} else if (c == ASCII_SETXY) {

   416

				src+=2;

   417

			}

   418

		}

   419

	}

   420

}

   421

   422

int GetStringWidth(const byte *str) {

   423

	int w = -1;

   424

	byte c;

   425

	int base = _stringwidth_base;

   426

   427

	for(;;) {

   428

		c = *str++;

   429

		if (c == 0)

   430

			return w;

   431

		if (c >= ASCII_LETTERSTART) {

   432

			w += _stringwidth_table[base + c - ASCII_LETTERSTART];

   433

		} else {

   434

			if (c == ASCII_SETX) str++;

   435

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

   436

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

   437

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

   438

		}

   439

	}

   440

}

   441

   442

void DrawFrameRect(int left, int top, int right, int bottom, int ctab, int flags) {

   443

	byte color_2 = _color_list[ctab].window_color_1a;

   444

	byte color_interior = _color_list[ctab].window_color_bga;

   445

	byte color_3 = _color_list[ctab].window_color_bgb;

   446

	byte color = _color_list[ctab].window_color_2;

   447

   448

	if (!(flags & 0x8))	{

   449

		if (!(flags & 0x20)) {

   450

			GfxFillRect(left, top, left, bottom-1, color);

   451

			GfxFillRect(left+1, top, right-1, top, color);

   452

			GfxFillRect(right, top, right, bottom-1, color_2);

   453

			GfxFillRect(left, bottom, right, bottom, color_2);

   454

			if (!(flags & 0x10)) {

   455

				GfxFillRect(left+1, top+1, right-1, bottom-1, color_interior);

   456

			}

   457

		} else {

   458

			GfxFillRect(left, top, left, bottom, color_2);

   459

			GfxFillRect(left+1, top, right, top, color_2);

   460

			GfxFillRect(right, top+1, right, bottom-1, color);

   461

			GfxFillRect(left+1, bottom, right, bottom, color);

   462

			if (!(flags & 0x10)) {

   463

				GfxFillRect(left+1, top+1, right-1, bottom-1,

   464

					flags&0x40 ? color_interior : color_3);

   465

			}

   466

		}

   467

	} else if (flags & 0x1) {

   468

		// transparency

   469

		GfxFillRect(left, top, right, bottom, 0x4322);

   470

	} else {

   471

		GfxFillRect(left, top, right, bottom, color_interior);

   472

	}

   473

}

   474

   475

int DoDrawString(const byte *string, int x, int y, byte color) {

   476

	DrawPixelInfo *dpi = _cur_dpi;

   477

	int base = _stringwidth_base;

   478

	byte c, *b;

   479

	int xo = x, yo = y;

   480

   481

	if (color != 0xFE) {

   482

		if (x >= dpi->left + dpi->width ||

   483

				x + _screen.width*2 <= dpi->left ||

   484

				y >= dpi->top + dpi->height ||

   485

				y + _screen.height <= dpi->top)

   486

					return x;

   487

   488

		if (color != 0xFF) {

   489

switch_color:;

   490

			b = GetSpritePtr(674);

   491

			_string_colorremap[1] = b[color*2+8];

   492

			_string_colorremap[2] = b[color*2+9];

   493

			_color_remap_ptr = _string_colorremap;

   494

		}

   495

	}

   496

   497

check_bounds:

   498

	if (y + 19 <= dpi->top || dpi->top + dpi->height <= y) {

   499

skip_char:;

   500

		for(;;) {

   501

			c = *string++;

   502

			if (c < ASCII_LETTERSTART) goto skip_cont;

   503

		}

   504

	}

   505

   506

	for(;;) {

   507

		c = *string++;

   508

skip_cont:;

   509

		if (c == 0) {

   510

			_stringwidth_out = base;

   511

			return x;

   512

		}

   513

		if (c >= ASCII_LETTERSTART) {

   514

			if (x >= dpi->left + dpi->width) goto skip_char;

   515

			if (x + 26 >= dpi->left) {

   516

				GfxMainBlitter(GetSpritePtr(base + 2 + c - ASCII_LETTERSTART), x, y, 1);

   517

			}

   518

			x += _stringwidth_table[base + c - ' '];

   519

		} else if (c == ASCII_NL) { // newline = {}

   520

			x = xo;

   521

			y += 10;

   522

			if (base != 0) {

   523

				y -= 4;

   524

				if (base != 0xE0)

   525

					y += 12;