1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "macros.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

#include "genworld.h"

    16

    17

#ifdef _DEBUG

    18

bool _dbg_screen_rect;

    19

#endif

    20

    21

Colour _cur_palette[256];

    22

byte _stringwidth_table[FS_END][224];

    23

    24

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

    25

    26

FontSize _cur_fontsize;

    27

static FontSize _last_fontsize;

    28

static Pixel _cursor_backup[64 * 64];

    29

static Rect _invalid_rect;

    30

static const byte *_color_remap_ptr;

    31

static byte _string_colorremap[3];

    32

    33

#define DIRTY_BYTES_PER_LINE (MAX_SCREEN_WIDTH / 64)

    34

static byte _dirty_blocks[DIRTY_BYTES_PER_LINE * MAX_SCREEN_HEIGHT / 8];

    35

    36

void memcpy_pitch(void *dst, void *src, int w, int h, int srcpitch, int dstpitch)

    37

{

    38

	byte *dstp = (byte*)dst;

    39

	byte *srcp = (byte*)src;

    40

    41

	assert(h >= 0);

    42

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

    43

		memcpy(dstp, srcp, w);

    44

		dstp += dstpitch;

    45

		srcp += srcpitch;

    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

   247

static inline SpriteID GetFontBase(FontSize size)

   248

{

   249

	switch (size) {

   250

		default: NOT_REACHED();

   251

		case FS_NORMAL: return SPR_ASCII_SPACE;

   252

		case FS_SMALL:  return SPR_ASCII_SPACE_SMALL;

   253

		case FS_LARGE:  return SPR_ASCII_SPACE_BIG;

   254

	}

   255

}

   256

   257

   258

// ASSIGNMENT OF ASCII LETTERS < 32

   259

// 0 - end of string

   260

// 1 - SETX <BYTE>

   261

// 2 - SETXY <BYTE> <BYTE>

   262

// 3-7 -

   263

// 8 - TINYFONT

   264

// 9 - BIGFONT

   265

// 10 - newline

   266

// 11-14 -

   267

// 15-31 - 17 colors

   268

   269

   270

enum {

   271

	ASCII_SETX       =  1,

   272

	ASCII_SETXY      =  2,

   273

   274

	ASCII_TINYFONT   =  8,

   275

	ASCII_BIGFONT    =  9,

   276

	ASCII_NL         = 10,

   277

   278

	ASCII_COLORSTART = 15,

   279

};

   280

   281

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

   282

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

   283

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

   284

 * @param maxw maximum width in pixels of the string

   285

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

   286

static int TruncateString(char *str, int maxw)

   287

{

   288

	int w = 0;

   289

	FontSize size = _cur_fontsize;

   290

	int ddd, ddd_w;

   291

   292

	byte c;

   293

	char *ddd_pos;

   294

   295

	ddd_w = ddd = GetCharacterWidth(size, '.') * 3;

   296

   297

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

   298

		if (c >= ASCII_LETTERSTART) {

   299

			w += GetCharacterWidth(size, c);

   300

   301

			if (w >= maxw) {

   302

				// string got too big... insert dotdotdot

   303

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

   304

				ddd_pos[3] = 0;

   305

				return ddd_w;

   306

			}

   307

		} else {

   308

			if (c == ASCII_SETX) str++;

   309

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

   310

			else if (c == ASCII_TINYFONT) {

   311

				size = FS_SMALL;

   312

				ddd = GetCharacterWidth(size, '.') * 3;

   313

			} else if (c == ASCII_BIGFONT) {

   314

				size = FS_LARGE;

   315

				ddd = GetCharacterWidth(size, '.') * 3;

   316

			}

   317

		}

   318

   319

		// Remember the last position where three dots fit.

   320

		if (w + ddd < maxw) {

   321

			ddd_w = w + ddd;

   322

			ddd_pos = str;

   323

		}

   324

	}

   325

   326

	return w;

   327

}

   328

   329

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

   330

{

   331

	GetString(dest, src, last);

   332

	return TruncateString(dest, maxw);

   333

}

   334

   335

/* returns right coordinate */

   336

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

   337

{

   338

	char buffer[512];

   339

   340

	GetString(buffer, str, lastof(buffer));

   341

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

   342

}

   343

   344

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

   345

{

   346

	char buffer[512];

   347

	TruncateStringID(str, buffer, maxw, lastof(buffer));

   348

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

   349

}

   350

   351

   352

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

   353

{

   354

	char buffer[512];

   355

	int w;

   356

   357

	GetString(buffer, str, lastof(buffer));

   358

	w = GetStringBoundingBox(buffer).width;

   359

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

   360

   361

	return w;

   362

}

   363

   364

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

   365

{

   366

	char buffer[512];

   367

   368

	TruncateStringID(str, buffer, maxw, lastof(buffer));

   369

	DoDrawString(buffer, x - GetStringBoundingBox(buffer).width, y, color);

   370

}

   371

   372

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

   373

{

   374

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

   375

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

   376

}

   377

   378

   379

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

   380

{

   381

	char buffer[512];

   382

	int w;

   383

   384

	GetString(buffer, str, lastof(buffer));

   385

   386

	w = GetStringBoundingBox(buffer).width;

   387

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

   388

   389

	return w;

   390

}

   391

   392

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

   393

{

   394

	char buffer[512];

   395

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

   396

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

   397

}

   398

   399

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

   400

{

   401

	int w = GetStringBoundingBox(str).width;

   402

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

   403

	return w;

   404

}

   405

   406

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

   407

{

   408

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

   409

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

   410

}

   411

   412

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

   413

{

   414

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

   415

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

   416

}

   417

   435

{

   437

	int num = 0;

   440

   441

	for (;;) {

   444

   445

		for (;;) {

   448

			if (c == ASCII_LETTERSTART) last_space = str;

   449

   450

			if (c >= ASCII_LETTERSTART) {

   451

				w += GetCharacterWidth(size, c);

   457

				if (w > maxw) {

   462

					str = last_space;

   463

					break;

   464

				}

   465

			} else {

   474

			}

   475

		}

   478

		num++;

   479

		str[-1] = '\0';

   480

	}

   481

}

   482

   483

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

   484

{

   485

	char buffer[512];

   486

	uint32 tmp;

   487

	int num, w, mt;

   488

	const char *src;

   489

	byte c;

   490

   491

	GetString(buffer, str, lastof(buffer));

   492

   493

	tmp = FormatStringLinebreaks(buffer, maxw);

   494

	num = GB(tmp, 0, 16);

   495