gfx_type.h

Go to the documentation of this file.

/*
 * 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/>.
 */
 
#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;  
typedef uint32 PaletteID; 
typedef uint32 CursorID;  
 
struct PalSpriteID {
  SpriteID sprite;  
  PaletteID pal;    
};
 
enum WindowKeyCodes {
  WKC_SHIFT = 0x8000,
  WKC_CTRL  = 0x4000,
  WKC_ALT   = 0x2000,
  WKC_META  = 0x1000,
 
  WKC_GLOBAL_HOTKEY = 0x0800, 
 
  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, 
  WKC_SEMICOLON   = 145, 
  WKC_EQUALS      = 146, 
  WKC_L_BRACKET   = 147, 
  WKC_BACKSLASH   = 148, 
  WKC_R_BRACKET   = 149, 
  WKC_SINGLEQUOTE = 150, 
  WKC_COMMA       = 151, 
  WKC_PERIOD      = 152, 
  WKC_MINUS       = 153, 
};
 
struct AnimCursor {
  static const CursorID LAST = MAX_UVALUE(CursorID);
  CursorID sprite;   
  byte display_time; 
};
 
struct CursorVars {
  /* Logical mouse position */
  Point pos;                    
  Point delta;                  
  int wheel;                    
  bool fix_at;                  
 
  /* 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];   
  Point sprite_pos[16];         
  uint sprite_count;            
  Point total_offs, total_size; 
 
  Point draw_pos, draw_size;    
 
  const AnimCursor *animate_list; 
  const AnimCursor *animate_cur;  
  uint animate_timeout;           
 
  bool visible;                 
  bool dirty;                   
  bool in_window;               
 
  /* Drag data */
  bool vehchain;                
 
  void UpdateCursorPositionRelative(int delta_x, int delta_y);
  bool UpdateCursorPosition(int x, int y);
};
 
struct DrawPixelInfo {
  void *dst_ptr;
  int left, top, width, height;
  int pitch;
  ZoomLevel zoom;
};
 
union Colour {
  uint32 data; 
  struct {
#if defined(__EMSCRIPTEN__)
    uint8 r, g, b, a;  
#elif TTD_ENDIAN == TTD_BIG_ENDIAN
    uint8 a, r, g, b; 
#else
    uint8 b, g, r, a; 
#endif /* TTD_ENDIAN == TTD_BIG_ENDIAN */
  };
 
  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 */
  {
  }
 
  Colour(uint data = 0) : data(data)
  {
  }
};
 
static_assert(sizeof(Colour) == sizeof(uint32));
 
 
enum FontSize {
  FS_NORMAL, 
  FS_SMALL,  
  FS_LARGE,  
  FS_MONO,   
  FS_END,
 
  FS_BEGIN = FS_NORMAL, 
};
DECLARE_POSTFIX_INCREMENT(FontSize)
 
static inline const char *FontSizeToName(FontSize fs)
{
  static const char *SIZE_TO_NAME[] = { "medium", "small", "large", "mono" };
  assert(fs < FS_END);
  return SIZE_TO_NAME[fs];
}
 
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> {};
 
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, 
  TC_NO_SHADE          = 0x200, 
  TC_FORCED            = 0x400, 
 
  TC_COLOUR_MASK = 0xFF, 
  TC_FLAGS_MASK = 0x700, 
};
DECLARE_ENUM_AS_BIT_SET(TextColour)
 
 
enum PaletteAnimationSizes {
  PALETTE_ANIM_SIZE  = 28,   
  PALETTE_ANIM_START = 227,  
};
 
enum FillRectMode {
  FILLRECT_OPAQUE,  
  FILLRECT_CHECKER, 
  FILLRECT_RECOLOUR, 
};
 
enum PaletteType {
  PAL_DOS,        
  PAL_WINDOWS,    
  PAL_AUTODETECT, 
  MAX_PAL = 2,    
};
 
enum SpriteType : byte {
  ST_NORMAL   = 0,      
  ST_MAPGEN   = 1,      
  ST_FONT     = 2,      
  ST_RECOLOUR = 3,      
  ST_INVALID  = 4,      
};
 
static const uint MILLISECONDS_PER_TICK = 30;
 
struct Palette {
  Colour palette[256]; 
  int first_dirty;     
  int count_dirty;     
};
 
enum Support8bpp {
  S8BPP_NONE = 0, 
  S8BPP_SYSTEM,   
  S8BPP_HARDWARE, 
};
 
enum StringAlignment {
  SA_LEFT        = 0 << 0, 
  SA_HOR_CENTER  = 1 << 0, 
  SA_RIGHT       = 2 << 0, 
  SA_HOR_MASK    = 3 << 0, 
 
  SA_TOP         = 0 << 2, 
  SA_VERT_CENTER = 1 << 2, 
  SA_BOTTOM      = 2 << 2, 
  SA_VERT_MASK   = 3 << 2, 
 
  SA_CENTER      = SA_HOR_CENTER | SA_VERT_CENTER, 
 
  SA_FORCE       = 1 << 4, 
};
DECLARE_ENUM_AS_BIT_SET(StringAlignment)
 
#endif /* GFX_TYPE_H */