1

/* $Id$ */

     2

     3

/** @file gfx_type.h Types related to the graphics and/or input devices. */

     4

     5

#ifndef GFX_TYPE_H

     6

#define GFX_TYPE_H

     7

     8

#include "core/endian_type.hpp"

     9

#include "core/enum_type.hpp"

    10

#include "core/geometry_type.hpp"

    11

#include "zoom_type.h"

    12

    13

typedef uint32 SpriteID;      ///< The number of a sprite, without mapping bits and colortables

    14

    15

/** Combination of a palette sprite and a 'real' sprite */

    16

struct PalSpriteID {

    17

	SpriteID sprite;  ///< The 'real' sprite

    18

	SpriteID pal;     ///< The palette (use \c PAL_NONE) if not needed)

    19

};

    20

typedef int32 CursorID;

    21

    22

enum WindowKeyCodes {

    23

	WKC_SHIFT = 0x8000,

    24

	WKC_CTRL  = 0x4000,

    25

	WKC_ALT   = 0x2000,

    26

	WKC_META  = 0x1000,

    27

    28

	/* Special ones */

    29

	WKC_NONE        =  0,

    30

	WKC_ESC         =  1,

    31

	WKC_BACKSPACE   =  2,

    32

	WKC_INSERT      =  3,

    33

	WKC_DELETE      =  4,

    34

    35

	WKC_PAGEUP      =  5,

    36

	WKC_PAGEDOWN    =  6,

    37

	WKC_END         =  7,

    38

	WKC_HOME        =  8,

    39

    40

	/* Arrow keys */

    41

	WKC_LEFT        =  9,

    42

	WKC_UP          = 10,

    43

	WKC_RIGHT       = 11,

    44

	WKC_DOWN        = 12,

    45

    46

	/* Return & tab */

    47

	WKC_RETURN      = 13,

    48

	WKC_TAB         = 14,

    49

    50

	/* Space */

    51

	WKC_SPACE       = 32,

    52

    53

	/* Function keys */

    54

	WKC_F1          = 33,

    55

	WKC_F2          = 34,

    56

	WKC_F3          = 35,

    57

	WKC_F4          = 36,

    58

	WKC_F5          = 37,

    59

	WKC_F6          = 38,

    60

	WKC_F7          = 39,

    61

	WKC_F8          = 40,

    62

	WKC_F9          = 41,

    63

	WKC_F10         = 42,

    64

	WKC_F11         = 43,

    65

	WKC_F12         = 44,

    66

    67

	/* Backquote is the key left of "1"

    68

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

    69

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

    70

	WKC_BACKQUOTE   = 45,

    71

	WKC_PAUSE       = 46,

    72

    73

	/* 0-9 are mapped to 48-57

    74

	 * A-Z are mapped to 65-90

    75

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

    76

    77

	/* Numerical keyboard */

    78

	WKC_NUM_DIV     = 138,

    79

	WKC_NUM_MUL     = 139,

    80

	WKC_NUM_MINUS   = 140,

    81

	WKC_NUM_PLUS    = 141,

    82

	WKC_NUM_ENTER   = 142,

    83

	WKC_NUM_DECIMAL = 143,

    84

    85

	/* Other keys */

    86

	WKC_SLASH       = 144, ///< / Forward slash

    87

	WKC_SEMICOLON   = 145, ///< ; Semicolon

    88

	WKC_EQUALS      = 146, ///< = Equals

    89

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

    90

	WKC_BACKSLASH   = 148, ///< \ Backslash

    91

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

    92

	WKC_SINGLEQUOTE = 150, ///< ' Single quote

    93

	WKC_COMMA       = 151, ///< , Comma

    94

	WKC_PERIOD      = 152, ///< . Period

    95

	WKC_MINUS       = 153, ///< - Minus

    96

};

    97

    98

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

    99

struct AnimCursor {

   100

	static const CursorID LAST = MAX_UVALUE(CursorID);

   101

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

   102

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

   103

};

   104

   105

/** Collection of variables for cursor-display and -animation */

   106

struct CursorVars {

   107

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

   108

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

   109

	int short_vehicle_offset;     ///< offset of the X for short vehicles

   110

	SpriteID sprite; ///< current image of cursor

   111

	SpriteID pal;

   112

   113

	int wheel;       ///< mouse wheel movement

   114

   115

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

   116

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

   117

	int v_wheel;

   118

	int h_wheel;

   119

   120

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

   121

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

   122

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

   123

   124

	bool visible;    ///< cursor is visible

   125

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

   126

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

   127

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

   128

   129

	bool vehchain;   ///< vehicle chain is dragged

   130

};

   131

   132

struct DrawPixelInfo {

   133

	void *dst_ptr;

   134

	int left, top, width, height;

   135

	int pitch;

   136

	ZoomLevel zoom;

   137

};

   138

   139

struct Colour {

   140

#if TTD_ENDIAN == TTD_BIG_ENDIAN

   141

	uint8 a, r, g, b; ///< colour channels in BE order

   142

#else

   143

	uint8 b, g, r, a; ///< colour channels in LE order

   144

#endif /* TTD_ENDIAN == TTD_BIG_ENDIAN */

   145

   146

	operator uint32 () const { return *(uint32 *)this; }

   147

};

   148

   149

/** Available font sizes */

   150

enum FontSize {

   151

	FS_NORMAL,

   152

	FS_SMALL,

   153

	FS_LARGE,

   154

	FS_END,

   155

};

   156

DECLARE_POSTFIX_INCREMENT(FontSize);

   157

   158

/**

   159

 * Used to only draw a part of the sprite.

   160

 * Draw the subsprite in the rect (sprite_x_offset + left, sprite_y_offset + top) to (sprite_x_offset + right, sprite_y_offset + bottom).

   161

 * Both corners are included in the drawing area.

   162

 */

   163

struct SubSprite {

   164

	int left, top, right, bottom;

   165

};

   166

   167

enum Colours {

   168

	COLOUR_DARK_BLUE,

   169

	COLOUR_PALE_GREEN,

   170

	COLOUR_PINK,

   171

	COLOUR_YELLOW,

   172

	COLOUR_RED,

   173

	COLOUR_LIGHT_BLUE,

   174

	COLOUR_GREEN,

   175

	COLOUR_DARK_GREEN,

   176

	COLOUR_BLUE,

   177

	COLOUR_CREAM,

   178

	COLOUR_MAUVE,

   179

	COLOUR_PURPLE,

   180

	COLOUR_ORANGE,

   181

	COLOUR_BROWN,

   182

	COLOUR_GREY,

   183

	COLOUR_WHITE,

   184

	COLOUR_END,

   185

	INVALID_COLOUR = 0xFF,

   186

};

   187

   188

/** Colour of the strings, see _string_colormap in table/palettes.h or docs/ottd-colourtext-palette.png */

   189

enum TextColour {

   190

	TC_FROMSTRING  = 0x00,

   191

	TC_BLUE        = 0x00,

   192

	TC_SILVER      = 0x01,

   193

	TC_GOLD        = 0x02,

   194

	TC_RED         = 0x03,

   195

	TC_PURPLE      = 0x04,

   196

	TC_LIGHT_BROWN = 0x05,

   197

	TC_ORANGE      = 0x06,

   198

	TC_GREEN       = 0x07,

   199

	TC_YELLOW      = 0x08,

   200

	TC_DARK_GREEN  = 0x09,

   201

	TC_CREAM       = 0x0A,

   202

	TC_BROWN       = 0x0B,

   203

	TC_WHITE       = 0x0C,

   204

	TC_LIGHT_BLUE  = 0x0D,

   205

	TC_GREY        = 0x0E,

   206

	TC_DARK_BLUE   = 0x0F,

   207

	TC_BLACK       = 0x10,

   208

	TC_INVALID     = 0xFF,

   209

};

   210

   211

/** Defines a few values that are related to animations using palette changes */

   212

enum PaletteAnimationSizes {

   213

	PALETTE_ANIM_SIZE_WIN   = 28,   ///< number of animated colours in Windows palette

   214

	PALETTE_ANIM_SIZE_DOS   = 38,   ///< number of animated colours in DOS palette

   215

	PALETTE_ANIM_SIZE_START = 217,  ///< Index in  the _palettes array from which all animations are taking places (table/palettes.h)

   216

};

   217

   218

enum StringColorFlags {

   219

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

   220

};

   221

   222

/** Define the operation GfxFillRect performs */

   223

enum FillRectMode {

   224

	FILLRECT_OPAQUE,  ///< Fill rectangle with a single color

   225

	FILLRECT_CHECKER, ///< Draw only every second pixel, used for greying-out

   226

	FILLRECT_RECOLOR, ///< Apply a recolor sprite to the screen content

   227

};

   228

   229

/** Palettes OpenTTD supports. */

   230

enum PaletteType {

   231

	PAL_DOS,        ///< Use the DOS palette.

   232

	PAL_WINDOWS,    ///< Use the Windows palette.

   233

	PAL_AUTODETECT, ///< Automatically detect the palette based on the graphics pack.

   234

	MAX_PAL = 2,    ///< The number of palettes.

   235

};

   236

   237

/** Types of sprites that might be loaded */

   238

enum SpriteType {

   239

	ST_NORMAL   = 0,      ///< The most basic (normal) sprite

   240

	ST_MAPGEN   = 1,      ///< Special sprite for the map generator

   241

	ST_FONT     = 2,      ///< A sprite used for fonts

   242

	ST_RECOLOUR = 3,      ///< Recolour sprite

   243

};

   244

   245

#endif /* GFX_TYPE_H */