1

/* $Id$ */

     2

     3

/** @file gfx.h */

     4

     5

#ifndef GFX_H

     6

#define GFX_H

     7

     8

#include "openttd.h"

     9

#include "zoom.hpp"

    10

    11

enum WindowKeyCodes {

    12

	WKC_SHIFT = 0x8000,

    13

	WKC_CTRL  = 0x4000,

    14

	WKC_ALT   = 0x2000,

    15

	WKC_META  = 0x1000,

    16

    17

	/* Special ones */

    18

	WKC_NONE        =  0,

    19

	WKC_ESC         =  1,

    20

	WKC_BACKSPACE   =  2,

    21

	WKC_INSERT      =  3,

    22

	WKC_DELETE      =  4,

    23

    24

	WKC_PAGEUP      =  5,

    25

	WKC_PAGEDOWN    =  6,

    26

	WKC_END         =  7,

    27

	WKC_HOME        =  8,

    28

    29

	/* Arrow keys */

    30

	WKC_LEFT        =  9,

    31

	WKC_UP          = 10,

    32

	WKC_RIGHT       = 11,

    33

	WKC_DOWN        = 12,

    34

    35

	/* Return & tab */

    36

	WKC_RETURN      = 13,

    37

	WKC_TAB         = 14,

    38

    39

	/* Numerical keyboard */

    40

	WKC_NUM_0       = 16,

    41

	WKC_NUM_1       = 17,

    42

	WKC_NUM_2       = 18,

    43

	WKC_NUM_3       = 19,

    44

	WKC_NUM_4       = 20,

    45

	WKC_NUM_5       = 21,

    46

	WKC_NUM_6       = 22,

    47

	WKC_NUM_7       = 23,

    48

	WKC_NUM_8       = 24,

    49

	WKC_NUM_9       = 25,

    50

	WKC_NUM_DIV     = 26,

    51

	WKC_NUM_MUL     = 27,

    52

	WKC_NUM_MINUS   = 28,

    53

	WKC_NUM_PLUS    = 29,

    54

	WKC_NUM_ENTER   = 30,

    55

	WKC_NUM_DECIMAL = 31,

    56

    57

	/* Space */

    58

	WKC_SPACE       = 32,

    59

    60

	/* Function keys */

    61

	WKC_F1          = 33,

    62

	WKC_F2          = 34,

    63

	WKC_F3          = 35,

    64

	WKC_F4          = 36,

    65

	WKC_F5          = 37,

    66

	WKC_F6          = 38,

    67

	WKC_F7          = 39,

    68

	WKC_F8          = 40,

    69

	WKC_F9          = 41,

    70

	WKC_F10         = 42,

    71

	WKC_F11         = 43,

    72

	WKC_F12         = 44,

    73

    74

	/* backquote is the key left of "1"

    75

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

    76

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

    77

	WKC_BACKQUOTE   = 45,

    78

	WKC_PAUSE       = 46,

    79

    80

	/* 0-9 are mapped to 48-57

    81

	 * A-Z are mapped to 65-90

    82

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

    83

};

    84

    85

enum GameModes {

    86

	GM_MENU,

    87

	GM_NORMAL,

    88

	GM_EDITOR

    89

};

    90

    91

void GameLoop();

    92

    93

void CreateConsole();

    94

    95

typedef int32 CursorID;

    96

typedef byte Pixel;

    97

    98

struct Point {

    99

	int x,y;

   100

};

   101

   102

struct Rect {

   103

	int left,top,right,bottom;

   104

};

   105

   106

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

   107

struct AnimCursor {

   108

	static const CursorID LAST = MAX_UVALUE(CursorID);

   109

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

   110

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

   111

};

   112

   113

struct CursorVars {

   114

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

   115

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

   116

	SpriteID sprite; ///< current image of cursor

   117

	SpriteID pal;

   118

   119

	int wheel;       ///< mouse wheel movement

   120

   121

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

   122

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

   123

	int v_wheel;

   124

	int h_wheel;

   125

   126

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

   127

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

   128

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

   129

   130

	bool visible;    ///< cursor is visible

   131

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

   132

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

   133

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

   134

};

   135

   136

struct DrawPixelInfo {

   137

	Pixel *dst_ptr;

   138

	int left, top, width, height;

   139

	int pitch;

   140

	ZoomLevel zoom;

   141

};

   142

   143

struct Colour {

   144

	byte r;

   145

	byte g;

   146

	byte b;

   147

};

   148

   149

   150

   151

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

   152

extern bool _fullscreen;

   153

extern CursorVars _cursor;

   154

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

   155

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

   156

extern byte _fast_forward;

   157

   158

extern bool _left_button_down;

   159

extern bool _left_button_clicked;

   160

extern bool _right_button_down;

   161

extern bool _right_button_clicked;

   162

   163

extern DrawPixelInfo _screen;

   164

extern bool _exit_game;

   165

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

   166

extern byte _game_mode;

   167

extern byte _pause_game;

   168

   169

extern int _pal_first_dirty;

   170

extern int _pal_last_dirty;

   171

extern int _num_resolutions;

   172

extern uint16 _resolutions[32][2];

   173

extern uint16 _cur_resolution[2];

   174

extern Colour _cur_palette[256];

   175

   176

void HandleKeypress(uint32 key);

   177

void HandleMouseEvents();

   178

void CSleep(int milliseconds);

   179

void UpdateWindows();

   180

   181

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

   182

uint InteractiveRandomRange(uint max);

   183

void DrawTextMessage();

   184

void DrawMouseCursor();

   185

void ScreenSizeChanged();

   186

void HandleExitGameRequest();

   187

void GameSizeChanged();

   188

void UndrawMouseCursor();

   189

   190

#include "helpers.hpp"

   191

   192

enum FontSize {

   193

	FS_NORMAL,

   194

	FS_SMALL,

   195

	FS_LARGE,

   196

	FS_END,

   197

};

   198

   199

DECLARE_POSTFIX_INCREMENT(FontSize);

   200

   201

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

   202

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

   203

   204

   205

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

   206

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

   207

#define UPARROW   "\xEE\x8A\x80"

   208

#define DOWNARROW "\xEE\x8A\xAA"

   209

   210

   211

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

   212

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

   213

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

   214

   215

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

   216

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

   217

   218

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

   219

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

   220

   221

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

   222

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

   223

   224

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

   225

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

   226

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

   227

   228

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

   229

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

   230

   231

BoundingRect GetStringBoundingBox(const char *str);

   232

uint32 FormatStringLinebreaks(char *str, int maxw);

   233

void LoadStringWidthTable();

   234

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

   235

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

   236

void DrawDirtyBlocks();

   237

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

   238

void MarkWholeScreenDirty();

   239

   240

void GfxInitPalettes();

   241

   242

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

   243

   244

/* window.cpp */

   245

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

   246

   247

void SetMouseCursor(SpriteID sprite, SpriteID pal);

   248

void SetAnimatedMouseCursor(const AnimCursor *table);

   249

void CursorTick();

   250

void DrawMouseCursor();

   251

void ScreenSizeChanged();

   252

void UndrawMouseCursor();

   253

bool ChangeResInGame(int w, int h);

   254

void SortResolutions(int count);

   255

void ToggleFullScreen(bool fs);

   256

   257

/* gfx.cpp */

   258

#define ASCII_LETTERSTART 32

   259

extern FontSize _cur_fontsize;

   260

   261

byte GetCharacterWidth(FontSize size, uint32 key);

   262

   263

static inline byte GetCharacterHeight(FontSize size)

   264

{

   265

	switch (size) {

   266

		default: NOT_REACHED();

   267

		case FS_NORMAL: return 10;

   268

		case FS_SMALL:  return 6;

   269

		case FS_LARGE:  return 18;

   270

	}

   271

}

   272

   273

VARDEF DrawPixelInfo *_cur_dpi;

   274

   275

enum {

   276

	COLOUR_DARK_BLUE,

   277

	COLOUR_PALE_GREEN,

   278

	COLOUR_PINK,

   279

	COLOUR_YELLOW,

   280

	COLOUR_RED,

   281

	COLOUR_LIGHT_BLUE,

   282

	COLOUR_GREEN,

   283

	COLOUR_DARK_GREEN,

   284

	COLOUR_BLUE,

   285

	COLOUR_CREAM,

   286

	COLOUR_MAUVE,

   287

	COLOUR_PURPLE,

   288

	COLOUR_ORANGE,

   289

	COLOUR_BROWN,

   290

	COLOUR_GREY,

   291

	COLOUR_WHITE

   292

};

   293

   294

/**

   295

 * All 16 colour gradients

   296

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

   297

 */

   298

VARDEF byte _colour_gradient[16][8];

   299

   300

VARDEF bool _use_dos_palette;

   301

   302

enum StringColorFlags {

   303

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

   304

};

   305

   306

   307

#ifdef _DEBUG

   308

extern bool _dbg_screen_rect;

   309

#endif

   310

   311

#endif /* GFX_H */