Files
@ r26254:4dd185cf8a2d
Branch filter:
Location: cpp/openttd-patchpack/source/src/gfx_type.h
r26254:4dd185cf8a2d
10.9 KiB
text/x-c
Merge with master
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 | /*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file gfx_type.h Types related to the graphics and/or input devices. */
#ifndef GFX_TYPE_H
#define GFX_TYPE_H
#include "core/endian_type.hpp"
#include "core/geometry_type.hpp"
#include "zoom_type.h"
typedef uint32 SpriteID; ///< The number of a sprite, without mapping bits and colourtables
typedef uint32 PaletteID; ///< The number of the palette
typedef uint32 CursorID; ///< The number of the cursor (sprite)
/** Combination of a palette sprite and a 'real' sprite */
struct PalSpriteID {
SpriteID sprite; ///< The 'real' sprite
PaletteID pal; ///< The palette (use \c PAL_NONE) if not needed)
};
enum WindowKeyCodes {
WKC_SHIFT = 0x8000,
WKC_CTRL = 0x4000,
WKC_ALT = 0x2000,
WKC_META = 0x1000,
WKC_GLOBAL_HOTKEY = 0x0800, ///< Fake keycode bit to indicate global hotkeys
WKC_SPECIAL_KEYS = WKC_SHIFT | WKC_CTRL | WKC_ALT | WKC_META | WKC_GLOBAL_HOTKEY,
/* Special ones */
WKC_NONE = 0,
WKC_ESC = 1,
WKC_BACKSPACE = 2,
WKC_INSERT = 3,
WKC_DELETE = 4,
WKC_PAGEUP = 5,
WKC_PAGEDOWN = 6,
WKC_END = 7,
WKC_HOME = 8,
/* Arrow keys */
WKC_LEFT = 9,
WKC_UP = 10,
WKC_RIGHT = 11,
WKC_DOWN = 12,
/* Return & tab */
WKC_RETURN = 13,
WKC_TAB = 14,
/* Space */
WKC_SPACE = 32,
/* Function keys */
WKC_F1 = 33,
WKC_F2 = 34,
WKC_F3 = 35,
WKC_F4 = 36,
WKC_F5 = 37,
WKC_F6 = 38,
WKC_F7 = 39,
WKC_F8 = 40,
WKC_F9 = 41,
WKC_F10 = 42,
WKC_F11 = 43,
WKC_F12 = 44,
/* Backquote is the key left of "1"
* we only store this key here, no matter what character is really mapped to it
* on a particular keyboard. (US keyboard: ` and ~ ; German keyboard: ^ and °) */
WKC_BACKQUOTE = 45,
WKC_PAUSE = 46,
/* 0-9 are mapped to 48-57
* A-Z are mapped to 65-90
* a-z are mapped to 97-122 */
/* Numerical keyboard */
WKC_NUM_DIV = 138,
WKC_NUM_MUL = 139,
WKC_NUM_MINUS = 140,
WKC_NUM_PLUS = 141,
WKC_NUM_ENTER = 142,
WKC_NUM_DECIMAL = 143,
/* Other keys */
WKC_SLASH = 144, ///< / Forward slash
WKC_SEMICOLON = 145, ///< ; Semicolon
WKC_EQUALS = 146, ///< = Equals
WKC_L_BRACKET = 147, ///< [ Left square bracket
WKC_BACKSLASH = 148, ///< \ Backslash
WKC_R_BRACKET = 149, ///< ] Right square bracket
WKC_SINGLEQUOTE = 150, ///< ' Single quote
WKC_COMMA = 151, ///< , Comma
WKC_PERIOD = 152, ///< . Period
WKC_MINUS = 153, ///< - Minus
};
/** A single sprite of a list of animated cursors */
struct AnimCursor {
static const CursorID LAST = MAX_UVALUE(CursorID);
CursorID sprite; ///< Must be set to LAST_ANIM when it is the last sprite of the loop
byte display_time; ///< Amount of ticks this sprite will be shown
};
/** Collection of variables for cursor-display and -animation */
struct CursorVars {
/* Logical mouse position */
Point pos; ///< logical mouse position
Point delta; ///< relative mouse movement in this tick
int wheel; ///< mouse wheel movement
bool fix_at; ///< mouse is moving, but cursor is not (used for scrolling)
/* We need two different vars to keep track of how far the scrollwheel moved.
* OSX uses this for scrolling around the map. */
int v_wheel;
int h_wheel;
/* Mouse appearance */
PalSpriteID sprite_seq[16]; ///< current image of cursor
Point sprite_pos[16]; ///< relative position of individual sprites
uint sprite_count; ///< number of sprites to draw
Point total_offs, total_size; ///< union of sprite properties
Point draw_pos, draw_size; ///< position and size bounding-box for drawing
const AnimCursor *animate_list; ///< in case of animated cursor, list of frames
const AnimCursor *animate_cur; ///< in case of animated cursor, current frame
uint animate_timeout; ///< in case of animated cursor, number of ticks to show the current cursor
bool visible; ///< cursor is visible
bool dirty; ///< the rect occupied by the mouse is dirty (redraw)
bool in_window; ///< mouse inside this window, determines drawing logic
/* Drag data */
bool vehchain; ///< vehicle chain is dragged
void UpdateCursorPositionRelative(int delta_x, int delta_y);
bool UpdateCursorPosition(int x, int y, bool queued_warp);
private:
bool queued_warp;
Point last_position;
};
/** Data about how and where to blit pixels. */
struct DrawPixelInfo {
void *dst_ptr;
int left, top, width, height;
int pitch;
ZoomLevel zoom;
};
/** Structure to access the alpha, red, green, and blue channels from a 32 bit number. */
union Colour {
uint32 data; ///< Conversion of the channel information to a 32 bit number.
struct {
#if defined(__EMSCRIPTEN__)
uint8 r, g, b, a; ///< colour channels as used in browsers
#elif TTD_ENDIAN == TTD_BIG_ENDIAN
uint8 a, r, g, b; ///< colour channels in BE order
#else
uint8 b, g, r, a; ///< colour channels in LE order
#endif /* TTD_ENDIAN == TTD_BIG_ENDIAN */
};
/**
* Create a new colour.
* @param r The channel for the red colour.
* @param g The channel for the green colour.
* @param b The channel for the blue colour.
* @param a The channel for the alpha/transparency.
*/
Colour(uint8 r, uint8 g, uint8 b, uint8 a = 0xFF) :
#if defined(__EMSCRIPTEN__)
r(r), g(g), b(b), a(a)
#elif TTD_ENDIAN == TTD_BIG_ENDIAN
a(a), r(r), g(g), b(b)
#else
b(b), g(g), r(r), a(a)
#endif /* TTD_ENDIAN == TTD_BIG_ENDIAN */
{
}
/**
* Create a new colour.
* @param data The colour in the correct packed format.
*/
Colour(uint data = 0) : data(data)
{
}
};
static_assert(sizeof(Colour) == sizeof(uint32));
/** Available font sizes */
enum FontSize {
FS_NORMAL, ///< Index of the normal font in the font tables.
FS_SMALL, ///< Index of the small font in the font tables.
FS_LARGE, ///< Index of the large font in the font tables.
FS_MONO, ///< Index of the monospaced font in the font tables.
FS_END,
FS_BEGIN = FS_NORMAL, ///< First font.
};
DECLARE_POSTFIX_INCREMENT(FontSize)
/**
* Used to only draw a part of the sprite.
* Draw the subsprite in the rect (sprite_x_offset + left, sprite_y_offset + top) to (sprite_x_offset + right, sprite_y_offset + bottom).
* Both corners are included in the drawing area.
*/
struct SubSprite {
int left, top, right, bottom;
};
enum Colours : byte {
COLOUR_BEGIN,
COLOUR_DARK_BLUE = COLOUR_BEGIN,
COLOUR_PALE_GREEN,
COLOUR_PINK,
COLOUR_YELLOW,
COLOUR_RED,
COLOUR_LIGHT_BLUE,
COLOUR_GREEN,
COLOUR_DARK_GREEN,
COLOUR_BLUE,
COLOUR_CREAM,
COLOUR_MAUVE,
COLOUR_PURPLE,
COLOUR_ORANGE,
COLOUR_BROWN,
COLOUR_GREY,
COLOUR_WHITE,
COLOUR_END,
INVALID_COLOUR = 0xFF,
};
template <> struct EnumPropsT<Colours> : MakeEnumPropsT<Colours, byte, COLOUR_BEGIN, COLOUR_END, INVALID_COLOUR, 8> {};
/** Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palette.png */
enum TextColour {
TC_BEGIN = 0x00,
TC_FROMSTRING = 0x00,
TC_BLUE = 0x00,
TC_SILVER = 0x01,
TC_GOLD = 0x02,
TC_RED = 0x03,
TC_PURPLE = 0x04,
TC_LIGHT_BROWN = 0x05,
TC_ORANGE = 0x06,
TC_GREEN = 0x07,
TC_YELLOW = 0x08,
TC_DARK_GREEN = 0x09,
TC_CREAM = 0x0A,
TC_BROWN = 0x0B,
TC_WHITE = 0x0C,
TC_LIGHT_BLUE = 0x0D,
TC_GREY = 0x0E,
TC_DARK_BLUE = 0x0F,
TC_BLACK = 0x10,
TC_END,
TC_INVALID = 0xFF,
TC_IS_PALETTE_COLOUR = 0x100, ///< Colour value is already a real palette colour index, not an index of a StringColour.
TC_NO_SHADE = 0x200, ///< Do not add shading to this text colour.
TC_FORCED = 0x400, ///< Ignore colour changes from strings.
};
DECLARE_ENUM_AS_BIT_SET(TextColour)
/** Defines a few values that are related to animations using palette changes */
enum PaletteAnimationSizes {
PALETTE_ANIM_SIZE = 28, ///< number of animated colours
PALETTE_ANIM_START = 227, ///< Index in the _palettes array from which all animations are taking places (table/palettes.h)
};
/** Define the operation GfxFillRect performs */
enum FillRectMode {
FILLRECT_OPAQUE, ///< Fill rectangle with a single colour
FILLRECT_CHECKER, ///< Draw only every second pixel, used for greying-out
FILLRECT_RECOLOUR, ///< Apply a recolour sprite to the screen content
};
/** Palettes OpenTTD supports. */
enum PaletteType {
PAL_DOS, ///< Use the DOS palette.
PAL_WINDOWS, ///< Use the Windows palette.
PAL_AUTODETECT, ///< Automatically detect the palette based on the graphics pack.
MAX_PAL = 2, ///< The number of palettes.
};
/** Types of sprites that might be loaded */
enum SpriteType : byte {
ST_NORMAL = 0, ///< The most basic (normal) sprite
ST_MAPGEN = 1, ///< Special sprite for the map generator
ST_FONT = 2, ///< A sprite used for fonts
ST_RECOLOUR = 3, ///< Recolour sprite
ST_INVALID = 4, ///< Pseudosprite or other unusable sprite, used only internally
};
/** The number of milliseconds per game tick. */
static const uint MILLISECONDS_PER_TICK = 30;
/** Information about the currently used palette. */
struct Palette {
Colour palette[256]; ///< Current palette. Entry 0 has to be always fully transparent!
int first_dirty; ///< The first dirty element.
int count_dirty; ///< The number of dirty elements.
};
/** Modes for 8bpp support */
enum Support8bpp {
S8BPP_NONE = 0, ///< No support for 8bpp by OS or hardware, force 32bpp blitters.
S8BPP_SYSTEM, ///< No 8bpp support by hardware, do not try to use 8bpp video modes or hardware palettes.
S8BPP_HARDWARE, ///< Full 8bpp support by OS and hardware.
};
/** How to align the to-be drawn text. */
enum StringAlignment {
SA_LEFT = 0 << 0, ///< Left align the text.
SA_HOR_CENTER = 1 << 0, ///< Horizontally center the text.
SA_RIGHT = 2 << 0, ///< Right align the text (must be a single bit).
SA_HOR_MASK = 3 << 0, ///< Mask for horizontal alignment.
SA_TOP = 0 << 2, ///< Top align the text.
SA_VERT_CENTER = 1 << 2, ///< Vertically center the text.
SA_BOTTOM = 2 << 2, ///< Bottom align the text.
SA_VERT_MASK = 3 << 2, ///< Mask for vertical alignment.
SA_CENTER = SA_HOR_CENTER | SA_VERT_CENTER, ///< Center both horizontally and vertically.
SA_FORCE = 1 << 4, ///< Force the alignment, i.e. don't swap for RTL languages.
};
DECLARE_ENUM_AS_BIT_SET(StringAlignment)
#endif /* GFX_TYPE_H */
|