1

/* $Id$ */

     2

     3

#ifndef GFX_H

     4

#define GFX_H

     5

     6

     7

enum WindowKeyCodes {

     8

	WKC_SHIFT = 0x8000,

     9

	WKC_CTRL  = 0x4000,

    10

	WKC_ALT   = 0x2000,

    11

	WKC_META  = 0x1000,

    12

    13

	// Special ones

    14

	WKC_NONE        =  0,

    15

	WKC_ESC         =  1,

    16

	WKC_BACKSPACE   =  2,

    17

	WKC_INSERT      =  3,

    18

	WKC_DELETE      =  4,

    19

    20

	WKC_PAGEUP      =  5,

    21

	WKC_PAGEDOWN    =  6,

    22

	WKC_END         =  7,

    23

	WKC_HOME        =  8,

    24

    25

	// Arrow keys

    26

	WKC_LEFT        =  9,

    27

	WKC_UP          = 10,

    28

	WKC_RIGHT       = 11,

    29

	WKC_DOWN        = 12,

    30

    31

	// Return & tab

    32

	WKC_RETURN      = 13,

    33

	WKC_TAB         = 14,

    34

    35

	// Numerical keyboard

    36

	WKC_NUM_0       = 16,

    37

	WKC_NUM_1       = 17,

    38

	WKC_NUM_2       = 18,

    39

	WKC_NUM_3       = 19,

    40

	WKC_NUM_4       = 20,

    41

	WKC_NUM_5       = 21,

    42

	WKC_NUM_6       = 22,

    43

	WKC_NUM_7       = 23,

    44

	WKC_NUM_8       = 24,

    45

	WKC_NUM_9       = 25,

    46

	WKC_NUM_DIV     = 26,

    47

	WKC_NUM_MUL     = 27,

    48

	WKC_NUM_MINUS   = 28,

    49

	WKC_NUM_PLUS    = 29,

    50

	WKC_NUM_ENTER   = 30,

    51

	WKC_NUM_DECIMAL = 31,

    52

    53

	// Space

    54

	WKC_SPACE       = 32,

    55

    56

	// Function keys

    57

	WKC_F1          = 33,

    58

	WKC_F2          = 34,

    59

	WKC_F3          = 35,

    60

	WKC_F4          = 36,

    61

	WKC_F5          = 37,

    62

	WKC_F6          = 38,

    63

	WKC_F7          = 39,

    64

	WKC_F8          = 40,

    65

	WKC_F9          = 41,

    66

	WKC_F10         = 42,

    67

	WKC_F11         = 43,

    68

	WKC_F12         = 44,

    69

    70

	// backquote is the key left of "1"

    71

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

    72

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

    73

	WKC_BACKQUOTE   = 45,

    74

	WKC_PAUSE       = 46,

    75

    76

	// 0-9 are mapped to 48-57

    77

	// A-Z are mapped to 65-90

    78

	// a-z are mapped to 97-122

    79

};

    80

    81

enum GameModes {

    82

	GM_MENU,

    83

	GM_NORMAL,

    84

	GM_EDITOR

    85

};

    86

    87

void GameLoop(void);

    88

    89

void CreateConsole(void);

    90

    91

typedef int32 CursorID;

    92

typedef byte Pixel;

    93

    94

typedef struct Point {

    95

	int x,y;

    96

} Point;

    97

    98

typedef struct Rect {

    99

	int left,top,right,bottom;

   100

} Rect;

   101

   102

   103

typedef struct CursorVars {

   104

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

   105

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

   106

	SpriteID sprite; ///< current image of cursor

   107

	SpriteID pal;

   108

   109

	int wheel;       ///< mouse wheel movement

   110

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

   111

	uint animate_timeout;                       ///< current frame in list of animated cursor

   112

   113

	bool visible;    ///< cursor is visible

   114

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

   115

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

   116

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

   117

} CursorVars;

   118

   119

typedef struct DrawPixelInfo {

   120

	Pixel *dst_ptr;

   121

	int left, top, width, height;

   122

	int pitch;

   123

	uint16 zoom;

   124

} DrawPixelInfo;

   125

   126

typedef struct Colour {

   127

	byte r;

   128

	byte g;

   129

	byte b;

   130

} Colour;

   131

   132

   133

   134

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

   135

extern bool _fullscreen;

   136

extern CursorVars _cursor;

   137

extern bool _ctrl_pressed;   // Is Ctrl pressed?

   138

extern bool _shift_pressed;  // Is Shift pressed?

   139

extern byte _fast_forward;

   140

   141

extern bool _left_button_down;

   142

extern bool _left_button_clicked;

   143

extern bool _right_button_down;

   144

extern bool _right_button_clicked;

   145

   146

extern DrawPixelInfo _screen;

   147

extern bool _exit_game;

   148

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

   149

extern byte _game_mode;

   150

extern byte _pause;

   151

   152

extern int _pal_first_dirty;

   153

extern int _pal_last_dirty;

   154

extern int _num_resolutions;

   155

extern uint16 _resolutions[32][2];

   156

extern uint16 _cur_resolution[2];

   157

extern Colour _cur_palette[256];

   158

   159

void HandleKeypress(uint32 key);

   160

void HandleMouseEvents(void);

   161

void CSleep(int milliseconds);

   162

void UpdateWindows(void);

   163

   164

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

   165

uint InteractiveRandomRange(uint max);

   166

void DrawTextMessage(void);

   167

void DrawMouseCursor(void);

   168

void ScreenSizeChanged(void);

   169

void HandleExitGameRequest(void);

   170

void GameSizeChanged(void);

   171

void UndrawMouseCursor(void);

   172

   173

#include "helpers.hpp"

   174

   175

typedef enum FontSizes {

   176

	FS_NORMAL,

   177

	FS_SMALL,

   178

	FS_LARGE,

   179

	FS_END,

   180

} FontSize;

   181

   182

DECLARE_POSTFIX_INCREMENT(FontSize);

   183

   184

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

   185

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

   186

   187

   188

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

   189

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

   190

#define UPARROW   "\xEE\x8A\x80"

   191

#define DOWNARROW "\xEE\x8A\xAA"

   192

   193

   194

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

   195

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

   196

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

   197

   198

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

   199

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

   200

   201

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

   202

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

   203

   204

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

   205

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

   206

   207

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

   208

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

   209

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

   210

   211

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

   212

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

   213

   214

BoundingRect GetStringBoundingBox(const char *str);

   215

uint32 FormatStringLinebreaks(char *str, int maxw);

   216

void LoadStringWidthTable(void);

   217

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

   218

uint DrawStringMultiLine(int x, int y, StringID str, int maxw);

   219

void DrawDirtyBlocks(void);

   220

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

   221

void MarkWholeScreenDirty(void);

   222

   223

void GfxInitPalettes(void);

   224

   225

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

   226

   227

/* window.c */

   228

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

   229

   230

void SetMouseCursor(CursorID cursor);

   231

void SetMouseCursor(SpriteID sprite, SpriteID pal);

   232

void SetAnimatedMouseCursor(const CursorID *table);

   233

void CursorTick(void);

   234

void DrawMouseCursor(void);

   235

void ScreenSizeChanged(void);

   236

void UndrawMouseCursor(void);

   237

bool ChangeResInGame(int w, int h);

   238

void SortResolutions(int count);

   239

void ToggleFullScreen(bool fs);

   240

   241

/* gfx.c */

   242

#define ASCII_LETTERSTART 32

   243

extern FontSize _cur_fontsize;

   244

   245

byte GetCharacterWidth(FontSize size, uint32 key);

   246

   247

static inline byte GetCharacterHeight(FontSize size)

   248

{

   249

	switch (size) {

   250

		default: NOT_REACHED();

   251

		case FS_NORMAL: return 10;

   252

		case FS_SMALL:  return 6;

   253

		case FS_LARGE:  return 18;

   254

	}

   255

}

   256

   257

VARDEF DrawPixelInfo *_cur_dpi;

   258

   259

enum {

   260

	COLOUR_DARK_BLUE,

   261

	COLOUR_PALE_GREEN,

   262

	COLOUR_PINK,

   263

	COLOUR_YELLOW,

   264

	COLOUR_RED,

   265

	COLOUR_LIGHT_BLUE,

   266

	COLOUR_GREEN,

   267

	COLOUR_DARK_GREEN,

   268

	COLOUR_BLUE,

   269

	COLOUR_CREAM,

   270

	COLOUR_MAUVE,

   271

	COLOUR_PURPLE,

   272

	COLOUR_ORANGE,

   273

	COLOUR_BROWN,

   274

	COLOUR_GREY,

   275

	COLOUR_WHITE

   276

};

   277

   278

/**

   279

 * All 16 colour gradients

   280

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

   281

 */

   282

VARDEF byte _colour_gradient[16][8];

   283

   284

VARDEF bool _use_dos_palette;

   285

   286

typedef enum StringColorFlags {

   287

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

   288

} StringColorFlags;

   289

   290

   291

#ifdef _DEBUG

   292

extern bool _dbg_screen_rect;

   293

#endif

   294

   295

#endif /* GFX_H */