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 || (yo == 0 && xo > 0)) {

    48

		// Calculate pointers

    49

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

    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

			left += xo;

    60

			src -= xo;

    61

			width -= xo;

    62

		} else {

    63

			dst += xo;

    64

			width += xo;

    65

		}

    66

    67

		// Offset pointers to fit into the memmove call

    68

		dst += -width + 1;

    69

		src += -width + 1;

    70

		ht = height;

    71

    72

		do {

    73

			memmove(dst, src, width);

    74

			src -= p;

    75

			dst -= p;

    76

		} while (--ht);

    77

    78

    79

		// This part of the screen is now dirty.

    80

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

    81

    82

	} else {

    83

		// Calculate pointers to mem.

    84

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

    85

		src = dst - yo * p;

    86

    87

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

    88

		height += yo;

    89

		assert(height > 0);

    90

    91

		// Adjust left & width

    92

		if (xo >= 0) {

    93

			dst += xo;

    94

			left += xo;

    95

			width -= xo;

    96

		} else {

    97

			src -= xo;

    98

			width += xo;

    99

		}

   100

   101

		ht = height;

   102

   103

		do {

   104

			memcpy(dst, src, width);

   105

			src += p;

   106

			dst += p;

   107

		} while (--ht);

   108

   109

		// This part of the screen is now dirty.

   110

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

   111

	}

   112

}

   113

   114

   115

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

   116

	DrawPixelInfo *dpi = _cur_dpi;

   117

	byte *dst,*ctab;

   118

   119

	if (dpi->zoom != 0)

   120

		return;

   121

   122

	if (left > right || top > bottom)

   123

		return;

   124

   125

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

   126

		return;

   127

   128

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

   129

		return;

   130

   131

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

   132

	right = right - dpi->left + 1;

   133

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

   134

	right -= left;

   135

	assert(right > 0);

   136

   137

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

   138

	bottom = bottom - dpi->top + 1;

   139

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

   140

	bottom -= top;

   141

	assert(bottom > 0);

   142

   143

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

   144

   145

	if (!(color & 0x8000)) {

   146

		if (!(color & 0x4000)) {

   147

			do {

   148

				memset(dst, color, right);

   149

				dst += dpi->pitch;

   150

			} while (--bottom);

   151

		} else {

   152

			/* use colortable mode */

   153

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

   154

			do {

   155

				int i;

   156

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

   157

					dst[i] = ctab[dst[i]];

   158

				dst += dpi->pitch;

   159

			} while (--bottom);

   160

		}

   161

	} else {

   162

		byte bo = 0;

   163

		do {

   164

			int i;

   165

			byte b = (bo^=1);

   166

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

   167

				if ((b^=1) != 0)

   168

					dst[i] = (byte)color;

   169

			dst += dpi->pitch;

   170

		} while (--bottom);

   171

	}

   172

}

   173

   174

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

   175

{

   176

	DrawPixelInfo *dpi = _cur_dpi;

   177

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

   178

		return;

   179

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

   180

}

   181

   182

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

   183

{

   184

	int dy;

   185

	int dx;

   186

	int stepx, stepy;

   187

	int frac;

   188

   189

	// Check clipping first

   190

	{

   191

		DrawPixelInfo *dpi = _cur_dpi;

   192

		int t;

   193

   194

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

   195

			return;

   196

   197

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

   198

			return;

   199

   200

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

   201

		if (x > t && x2 > t)

   202

			return;

   203

   204

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

   205

		if (y > t && y2 > t)

   206

			return;

   207

	}

   208

   209

	dy = (y2 - y) * 2;

   210

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

   211

   212

	dx = (x2 - x) * 2;

   213

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

   214

   215

	GfxSetPixel(x, y, color);

   216

	if (dx > dy) {

   217

		frac = dy - (dx >> 1);

   218

		while (x != x2) {

   219

			if (frac >= 0) {

   220

				y += stepy;

   221

				frac -= dx;

   222

			}

   223

			x += stepx;

   224

			frac += dy;

   225

			GfxSetPixel(x, y, color);

   226

		}

   227

	} else {

   228

		frac = dx - (dy >> 1);

   229

		while (y != y2) {

   230

			if (frac >= 0) {

   231

				x += stepx;

   232

				frac -= dy;

   233

			}

   234

			y += stepy;

   235

			frac += dx;

   236

			GfxSetPixel(x, y, color);

   237

		}

   238

	}

   239

}

   240

   241

// ASSIGNMENT OF ASCII LETTERS < 32

   242

// 0 - end of string

   243

// 1 - SETX <BYTE>

   244

// 2 - SETXY <BYTE> <BYTE>

   246

// 8 - TINYFONT

   247

// 9 - BIGFONT

   248

// 10 - newline

   250

// 15-31 - 17 colors

   251

   252

   253

enum {

   254

	ASCII_LETTERSTART = 32,

   256

	ASCII_SETX = 1,

   257

	ASCII_SETXY = 2,

   258

   259

	ASCII_TINYFONT = 8,

   260

	ASCII_BIGFONT = 9,

   261

	ASCII_NL = 10,

   262

   263

	ASCII_COLORSTART = 15,

   264

};

   265

   266

   267

/* returns right coordinate */

   268

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

   269

{

   270

	GetString(str_buffr, str);

   271

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

   272

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

   273

}

   274

   275

   276

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

   277

{

   278

	GetString(str_buffr, str);

   279

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

   280

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

   281

}

   282

   283

   284

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

   285

{

   286

	int w;

   287

   288

	GetString(str_buffr, str);

   289

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

   290

   291

	w = GetStringWidth(str_buffr);

   292

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

   293

   294

	return w;

   295

}

   296

   297

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

   298

{

   299

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

   300

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

   301

}

   302

   303

uint32 FormatStringLinebreaks(byte *str, int maxw) {

   304

	int num = 0;

   305

	int base = _stringwidth_base;

   306

	int w;

   307

	byte *last_space;

   308

	byte c;

   309

   310

	for(;;) {

   311

		w = 0;

   312

		last_space = NULL;

   313

   314

		for(;;) {

   315

			c = *str++;

   316

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

   317

   318

			if (c >= ASCII_LETTERSTART) {

   319

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

   320

				if (w > maxw) {

   321

					str = last_space;

   322

					if (str == NULL)

   323

						return num + (base << 16);

   324

					break;

   325

				}

   326

			} else {

   327

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

   328

				if (c == ASCII_NL) break;

   329

   330

				if (c == ASCII_SETX) str++;

   331

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

   332

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

   333

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

   334

			}

   335

		}

   336

   337

		num++;

   338

		str[-1] = 0;

   339

	}

   340

}

   341

   342

   343

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

   344

{

   345

	uint32 tmp;

   346

	int num, w, mt, t;

   347

	byte *src;

   348

	byte c;

   349

   350

	GetString(str_buffr, str);

   351

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

   352

   353

	tmp = FormatStringLinebreaks(str_buffr, maxw);

   354

	num = (uint16)tmp;

   355

	t = tmp >> 16;

   356

   357

	mt = 10;

   358

	if (t != 0) {

   359

		mt = 6;

   360

		if (t != 244) mt = 18;

   361

	}

   362

   363

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

   364

   365

	src = str_buffr;

   366

   367

	for(;;) {

   368

		w = GetStringWidth(src);

   369

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

   370

		_stringwidth_base = _stringwidth_out;

   371

   372

		for(;;) {

   373

			c = *src++;

   374

			if (c == 0) {

   375

				y += mt;

   376

				if (--num < 0) {

   377

					_stringwidth_base = 0;

   378

					return;

   379

				}

   380

				break;

   381

			} else if (c == ASCII_SETX) {

   382

				src++;

   383

			} else if (c == ASCII_SETXY) {

   384

				src+=2;

   385

			}

   386

		}

   387

	}

   388

}

   389

   390

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

   391

	uint32 tmp;

   392

	int num, w, mt, t;

   393

	byte *src;

   394

	byte c;

   395

   396

	GetString(str_buffr, str);

   397

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

   398

   399

	tmp = FormatStringLinebreaks(str_buffr, maxw);

   400

	num = (uint16)tmp;

   401

	t = tmp >> 16;

   402

	mt = 10;

   403

	if (t != 0) {

   404

		mt = 6;

   405

		if (t != 244) mt = 18;

   406

	}

   407

   408

	src = str_buffr;

   409

   410

	for(;;) {

   411

		w = GetStringWidth(src);

   412

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

   413

		_stringwidth_base = _stringwidth_out;

   414

   415

		for(;;) {

   416

			c = *src++;

   417

			if (c == 0) {

   418

				y += mt;

   419

				if (--num < 0) {

   420

					_stringwidth_base = 0;

   421

					return;

   422

				}

   423

				break;

   424

			} else if (c == ASCII_SETX) {

   425

				src++;

   426

			} else if (c == ASCII_SETXY) {

   427

				src+=2;

   428

			}

   429

		}

   430

	}

   431

}

   432

   433

int GetStringWidth(const byte *str) {

   434

	int w = -1;

   435

	byte c;

   436

	int base = _stringwidth_base;

   437

   438

	for(;;) {

   439

		c = *str++;

   440

		if (c == 0)

   441

			return w;

   442

		if (c >= ASCII_LETTERSTART) {

   443

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

   444

		} else {

   445

			if (c == ASCII_SETX) str++;

   446

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

   447

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

   448

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

   449

		}

   450

	}

   451

}

   452

   453

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

   454

	byte color_2 = _color_list[ctab].window_color_1a;

   455

	byte color_interior = _color_list[ctab].window_color_bga;

   456

	byte color_3 = _color_list[ctab].window_color_bgb;

   457

	byte color = _color_list[ctab].window_color_2;

   458

   459

	if (!(flags & 0x8))	{

   460

		if (!(flags & 0x20)) {

   461

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

   462

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

   463

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

   464

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

   465

			if (!(flags & 0x10)) {

   466

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

   467

			}

   468

		} else {

   469

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

   470

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

   471

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

   472

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

   473

			if (!(flags & 0x10)) {

   474

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

   475

					flags&0x40 ? color_interior : color_3);

   476

			}

   477

		}

   478

	} else if (flags & 0x1) {

   479

		// transparency

   480

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

   481

	} else {

   482

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

   483

	}

   484

}

   485

   486

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

   487

	DrawPixelInfo *dpi = _cur_dpi;

   488

	int base = _stringwidth_base;

   489

	byte c, *b;

   490

	int xo = x, yo = y;

   491

   492

	if (color != 0xFE) {

   493

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

   494

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

   495

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

   496

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

   497

					return x;

   498

   499

		if (color != 0xFF) {

   500

switch_color:;

   501

			b = GetSpritePtr(674);

   502

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

   503

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

   504

			_color_remap_ptr = _string_colorremap;

   505

		}

   506

	}

   507

   508

check_bounds:

   509

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

   510

skip_char:;

   511

		for(;;) {

   512

			c = *string++;

   514

		}

   515

	}

   516

   517

	for(;;) {

   518

		c = *string++;

   519

skip_cont:;

   520

		if (c == 0) {

   521

			_stringwidth_out = base;

   522

			return x;

   523

		}

   524

		if (c >= ASCII_LETTERSTART) {

   525

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

   526

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

   527

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

   528

			}

   529

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