1

/* $Id$ */

     2

     3

/** @file gfx.h */

     4

     5

/**

     6

 * @defgroup dirty Dirty

     7

 *

     8

 * Handles the repaint of some part of the screen.

     9

 *

    10

 * Some places in the code are called functions which makes something "dirty".

    11

 * This has nothing to do with making a Tile or Window darker or less visible.

    12

 * This term comes from memory caching and is used to define an object must

    13

 * be repaint. If some data of an object (like a Tile, Window, Vehicle, whatever)

    14

 * are changed which are so extensive the object must be repaint its marked

    15

 * as "dirty". The video driver repaint this object instead of the whole screen

    16

 * (this is btw. also possible if needed). This is used to avoid a

    17

 * flickering of the screen by the video driver constantly repainting it.

    18

 *

    19

 * This whole mechanism is controlled by an rectangle defined in #_invalid_rect. This

    20

 * rectangle defines the area on the screen which must be repaint. If a new object

    21

 * needs to be repainted this rectangle is extended to 'catch' the object on the

    22

 * screen. At some point (which is normaly uninteressted for patch writers) this

    23

 * rectangle is send to the video drivers method

    24

 * VideoDriver::MakeDirty and it is truncated back to an empty rectangle. At some

    25

 * later point (which is uninteressted, too) the video driver

    26

 * repaints all these saved rectangle instead of the whole screen and drop the

    27

 * rectangle informations. Then a new round begins by marking objects "dirty".

    28

 *

    29

 * @see VideoDriver::MakeDirty

    30

 * @see _invalid_rect

    31

 * @see _screen

    32

 */

    33

    34

    35

#ifndef GFX_H

    36

#define GFX_H

    37

    38

#include "openttd.h"

    39

#include "zoom.hpp"

    40

    41

enum WindowKeyCodes {

    42

	WKC_SHIFT = 0x8000,

    43

	WKC_CTRL  = 0x4000,

    44

	WKC_ALT   = 0x2000,

    45

	WKC_META  = 0x1000,

    46

    47

	/* Special ones */

    48

	WKC_NONE        =  0,

    49

	WKC_ESC         =  1,

    50

	WKC_BACKSPACE   =  2,

    51

	WKC_INSERT      =  3,

    52

	WKC_DELETE      =  4,

    53

    54

	WKC_PAGEUP      =  5,

    55

	WKC_PAGEDOWN    =  6,

    56

	WKC_END         =  7,

    57

	WKC_HOME        =  8,

    58

    59

	/* Arrow keys */

    60

	WKC_LEFT        =  9,

    61

	WKC_UP          = 10,

    62

	WKC_RIGHT       = 11,

    63

	WKC_DOWN        = 12,

    64

    65

	/* Return & tab */

    66

	WKC_RETURN      = 13,

    67

	WKC_TAB         = 14,

    68

    69

	/* Space */

    70

	WKC_SPACE       = 32,

    71

    72

	/* Function keys */

    73

	WKC_F1          = 33,

    74

	WKC_F2          = 34,

    75

	WKC_F3          = 35,

    76

	WKC_F4          = 36,

    77

	WKC_F5          = 37,

    78

	WKC_F6          = 38,

    79

	WKC_F7          = 39,

    80

	WKC_F8          = 40,

    81

	WKC_F9          = 41,

    82

	WKC_F10         = 42,

    83

	WKC_F11         = 43,

    84

	WKC_F12         = 44,

    85

    86

	/* Backquote is the key left of "1"

    87

	 * we only store this key here, no matter what character is really mapped to it

    88

	 * on a particular keyboard. (US keyboard: ` and ~ ; German keyboard: ^ and °) */

    89

	WKC_BACKQUOTE   = 45,

    90

	WKC_PAUSE       = 46,

    91

    92

	/* 0-9 are mapped to 48-57

    93

	 * A-Z are mapped to 65-90

    94

	 * a-z are mapped to 97-122 */

    95

    96

	/* Numerical keyboard */

    97

	WKC_NUM_0       = 128,

    98

	WKC_NUM_1       = 129,

    99

	WKC_NUM_2       = 130,

   100

	WKC_NUM_3       = 131,

   101

	WKC_NUM_4       = 132,

   102

	WKC_NUM_5       = 133,

   103

	WKC_NUM_6       = 134,

   104

	WKC_NUM_7       = 135,

   105

	WKC_NUM_8       = 136,

   106

	WKC_NUM_9       = 137,

   107

	WKC_NUM_DIV     = 138,

   108

	WKC_NUM_MUL     = 139,

   109

	WKC_NUM_MINUS   = 140,

   110

	WKC_NUM_PLUS    = 141,

   111

	WKC_NUM_ENTER   = 142,

   112

	WKC_NUM_DECIMAL = 143,

   113

   114

	/* Other keys */

   115

	WKC_SLASH       = 144, ///< / Forward slash

   116

	WKC_SEMICOLON   = 145, ///< ; Semicolon

   117

	WKC_EQUALS      = 146, ///< = Equals

   118

	WKC_L_BRACKET   = 147, ///< [ Left square bracket

   119

	WKC_BACKSLASH   = 148, ///< \ Backslash

   120

	WKC_R_BRACKET   = 149, ///< ] Right square bracket

   121

	WKC_SINGLEQUOTE = 150, ///< ' Single quote

   122

	WKC_COMMA       = 151, ///< , Comma

   123

	WKC_PERIOD      = 152, ///< . Period

   124

	WKC_MINUS       = 153, ///< - Minus

   125

};

   126

   127

enum GameModes {

   128

	GM_MENU,

   129

	GM_NORMAL,

   130

	GM_EDITOR

   131

};

   132

   133

void GameLoop();

   134

   135

void CreateConsole();

   136

   137

typedef int32 CursorID;

   138

   139

struct Point {

   140

	int x, y;

   141

};

   142

   143

struct Rect {

   144

	int left,top,right,bottom;

   145

};

   146

   147

/** A single sprite of a list of animated cursors */

   148

struct AnimCursor {

   149

	static const CursorID LAST = MAX_UVALUE(CursorID);

   150

	CursorID sprite;   ///< Must be set to LAST_ANIM when it is the last sprite of the loop

   151

	byte display_time; ///< Amount of ticks this sprite will be shown

   152

};

   153

   154

struct CursorVars {

   155

	Point pos, size, offs, delta; ///< position, size, offset from top-left, and movement

   156

	Point draw_pos, draw_size;    ///< position and size bounding-box for drawing

   157

	SpriteID sprite; ///< current image of cursor

   158

	SpriteID pal;

   159

   160

	int wheel;       ///< mouse wheel movement

   161

   162

	/* We need two different vars to keep track of how far the scrollwheel moved.

   163

	 * OSX uses this for scrolling around the map. */

   164

	int v_wheel;

   165

	int h_wheel;

   166

   167

	const AnimCursor *animate_list; ///< in case of animated cursor, list of frames

   168

	const AnimCursor *animate_cur;  ///< in case of animated cursor, current frame

   169

	uint animate_timeout;           ///< in case of animated cursor, number of ticks to show the current cursor

   170

   171

	bool visible;    ///< cursor is visible

   172

	bool dirty;      ///< the rect occupied by the mouse is dirty (redraw)

   173

	bool fix_at;     ///< mouse is moving, but cursor is not (used for scrolling)

   174

	bool in_window;  ///< mouse inside this window, determines drawing logic

   175

};

   176

   177

struct DrawPixelInfo {

   178

	void *dst_ptr;

   179

	int left, top, width, height;

   180

	int pitch;

   181

	ZoomLevel zoom;

   182

};

   183

   184

struct Colour {

   185

	byte r;

   186

	byte g;

   187

	byte b;

   188

};

   189

   190

   191

   192

extern byte _dirkeys;        ///< 1 = left, 2 = up, 4 = right, 8 = down

   193

extern bool _fullscreen;

   194

extern CursorVars _cursor;

   195

extern bool _ctrl_pressed;   ///< Is Ctrl pressed?

   196

extern bool _shift_pressed;  ///< Is Shift pressed?

   197

extern byte _fast_forward;

   198

   199

extern bool _left_button_down;

   200

extern bool _left_button_clicked;

   201

extern bool _right_button_down;

   202

extern bool _right_button_clicked;

   203

   204

extern DrawPixelInfo _screen;

   205

extern bool _exit_game;

   206

extern bool _networking;         ///< are we in networking mode?

   207

extern byte _game_mode;

   208

extern byte _pause_game;

   209

   210

extern int _pal_first_dirty;

   211

extern int _pal_count_dirty;

   212

extern int _num_resolutions;

   213

extern uint16 _resolutions[32][2];

   214

extern uint16 _cur_resolution[2];

   215

extern Colour _cur_palette[256];

   216

   217

void HandleKeypress(uint32 key);

   218

void HandleMouseEvents();

   219

void CSleep(int milliseconds);

   220

void UpdateWindows();

   221

   222

uint32 InteractiveRandom(); //< Used for random sequences that are not the same on the other end of the multiplayer link

   223

uint InteractiveRandomRange(uint max);

   224

void DrawChatMessage();

   225

void DrawMouseCursor();

   226

void ScreenSizeChanged();

   227

void HandleExitGameRequest();

   228

void GameSizeChanged();

   229

void UndrawMouseCursor();

   230

   231

#include "helpers.hpp"

   232

   233

enum FontSize {

   234

	FS_NORMAL,

   235

	FS_SMALL,

   236

	FS_LARGE,

   237

	FS_END,

   238

};

   239

   240

DECLARE_POSTFIX_INCREMENT(FontSize);

   241

   242

void RedrawScreenRect(int left, int top, int right, int bottom);

   243

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

   244

   245

   246

/* XXX doesn't really belong here, but the only

   247

 * consumers always use it in conjunction with DoDrawString() */

   248

#define UPARROW   "\xEE\x8A\x80"

   249

#define DOWNARROW "\xEE\x8A\xAA"

   250

   251

   252

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

   253

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

   254

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

   255

   256

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

   257

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

   258

   259

int DoDrawString(const char *string, int x, int y, uint16 color);

   260

int DoDrawStringTruncated(const char *str, int x, int y, uint16 color, uint maxw);

   261

   262

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

   263

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

   264

   265

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

   266

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

   267

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

   268

   269

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

   270

void GfxDrawLine(int left, int top, int right, int bottom, int color);

   271

   272

BoundingRect GetStringBoundingBox(const char *str);

   273

uint32 FormatStringLinebreaks(char *str, int maxw);

   274

void LoadStringWidthTable();

   275

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

   276

uint DrawStringMultiLine(int x, int y, StringID str, int maxw, int maxh = -1);

   277

   278

/**

   279

 * Let the dirty blocks repainting by the video driver.

   280

 *

   281

 * @ingroup dirty

   282

 */

   283

void DrawDirtyBlocks();

   284

   285

/**

   286

 * Set a new dirty block.

   287

 *

   288

 * @ingroup dirty

   289

 */

   290

void SetDirtyBlocks(int left, int top, int right, int bottom);

   291

   292

/**

   293

 * Marks the whole screen as dirty.

   294

 *

   295

 * @ingroup dirty

   296

 */

   297

void MarkWholeScreenDirty();

   298

   299

void GfxInitPalettes();

   300

   301

bool FillDrawPixelInfo(DrawPixelInfo* n, int left, int top, int width, int height);

   302

   303

/* window.cpp */

   304

void DrawOverlappedWindowForAll(int left, int top, int right, int bottom);

   305

   306

void SetMouseCursor(SpriteID sprite, SpriteID pal);

   307

void SetAnimatedMouseCursor(const AnimCursor *table);

   308

void CursorTick();

   309

void DrawMouseCursor();

   310

void ScreenSizeChanged();

   311

void UndrawMouseCursor();

   312

bool ChangeResInGame(int w, int h);

   313

void SortResolutions(int count);

   314

void ToggleFullScreen(bool fs);

   315

   316

/* gfx.cpp */

   317

#define ASCII_LETTERSTART 32

   318

extern FontSize _cur_fontsize;

   319

   320

byte GetCharacterWidth(FontSize size, uint32 key);

   321

   322

static inline byte GetCharacterHeight(FontSize size)

   323

{

   324

	switch (size) {

   325

		default: NOT_REACHED();

   326

		case FS_NORMAL: return 10;

   327

		case FS_SMALL:  return 6;

   328

		case FS_LARGE:  return 18;

   329

	}

   330

}

   331

   332

VARDEF DrawPixelInfo *_cur_dpi;

   333

   334

enum {

   335

	COLOUR_DARK_BLUE,

   336

	COLOUR_PALE_GREEN,

   337

	COLOUR_PINK,

   338

	COLOUR_YELLOW,

   339

	COLOUR_RED,

   340

	COLOUR_LIGHT_BLUE,

   341

	COLOUR_GREEN,

   342

	COLOUR_DARK_GREEN,

   343

	COLOUR_BLUE,

   344

	COLOUR_CREAM,

   345

	COLOUR_MAUVE,

   346

	COLOUR_PURPLE,

   347

	COLOUR_ORANGE,

   348

	COLOUR_BROWN,

   349

	COLOUR_GREY,

   350

	COLOUR_WHITE

   351

};

   352

   353

/**

   354

 * All 16 colour gradients

   355

 * 8 colours per gradient from darkest (0) to lightest (7)

   356

 */

   357

VARDEF byte _colour_gradient[16][8];

   358

   359

VARDEF bool _use_dos_palette;

   360

   361

enum StringColorFlags {

   362

	IS_PALETTE_COLOR = 0x100, ///< color value is already a real palette color index, not an index of a StringColor

   363

};

   364

   365

#endif /* GFX_H */