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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef GFX_TYPE_H
#define GFX_TYPE_H
 
#include "core/enum_type.hpp"
#include "core/geometry_type.hpp"
#include "zoom_type.h"
 
typedef uint32_t SpriteID;  
typedef uint32_t PaletteID; 
typedef uint32_t CursorID;  

struct PalSpriteID {
  SpriteID sprite{};  
  PaletteID pal{};    
 
  auto operator<=>(const PalSpriteID&) const = default;
};
 
enum WindowKeyCodes : uint16_t {
  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 {
  CursorID sprite; 
  uint8_t display_time; 
};
 
struct CursorSprite {
  PalSpriteID image; 
  Point pos; 
 
  constexpr CursorSprite(SpriteID spr, PaletteID pal, int x, int y) : image({spr, pal}), pos({x, y}) {}
};

struct CursorVars {
  /* Logical mouse position */
  Point pos;                    
  Point delta;                  
  int wheel;                    
  bool fix_at;                  
 
  /* 2D wheel scrolling for moving around the map */
  bool wheel_moved;
  float v_wheel;
  float h_wheel;
 
  /* Mouse appearance */
  std::vector<CursorSprite> sprites; 
  Point total_offs, total_size; 
 
  Point draw_pos, draw_size;    
 
  std::span<const AnimCursor> animate_list{}; 
  std::span<const AnimCursor>::iterator animate_cur = std::end(animate_list);  
  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 ColourRGBA {
  uint32_t data; 
  struct {
    uint8_t r, g, b, a; 
  };

  constexpr ColourRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xFF) : r(r), g(g), b(b), a(a) { }

  constexpr ColourRGBA(uint data = 0) : data(data) { }
 
  bool operator==(const ColourRGBA &other) const { return this->data == other.data; };
};

union ColourARGB {
  uint32_t data; 
  struct {
    uint8_t a, r, g, b; 
  };

  constexpr ColourARGB(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xFF) : a(a), r(r), g(g), b(b) { }

  constexpr ColourARGB(uint data = 0) : data(data) { }
 
  bool operator==(const ColourARGB &other) const { return this->data == other.data; };
};

union ColourBGRA {
  uint32_t data; 
  struct {
    uint8_t b, g, r, a; 
  };

  constexpr ColourBGRA(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 0xFF) : b(b), g(g), r(r), a(a) { }

  constexpr ColourBGRA(uint data = 0) : data(data) { }
 
  bool operator==(const ColourBGRA &other) const { return this->data == other.data; };
};
 
#if defined(__EMSCRIPTEN__)
using Colour = ColourRGBA;
#else
using Colour = std::conditional_t<std::endian::native == std::endian::little, ColourBGRA, ColourARGB>;
#endif /* defined(__EMSCRIPTEN__) */
 
static_assert(sizeof(Colour) == sizeof(uint32_t));

enum class FontSize : uint8_t {
  Normal, 
  Small, 
  Large, 
  Monospace, 
 
  End, 
  Begin = FontSize::Normal, 
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(FontSize)
 
using FontSizes = EnumBitSet<FontSize, uint8_t>;

constexpr FontSizes FONTSIZES_ALL{FontSize::Normal, FontSize::Small, FontSize::Large, FontSize::Monospace};
constexpr FontSizes FONTSIZES_REQUIRED{FontSize::Normal, FontSize::Small, FontSize::Large};
 
inline std::string_view FontSizeToName(FontSize fs)
{
  static const std::string_view SIZE_TO_NAME[] = { "medium", "small", "large", "mono" };
  assert(fs < FontSize::End);
  return SIZE_TO_NAME[to_underlying(fs)];
}

struct SubSprite {
  int left, top, right, bottom;
};

enum class Colours : uint8_t {
  Begin, 
  DarkBlue = Colours::Begin, 
  PaleGreen, 
  Pink, 
  Yellow, 
  Red, 
  LightBlue, 
  Green, 
  DarkGreen, 
  Blue, 
  Cream, 
  Mauve, 
  Purple, 
  Orange, 
  Brown, 
  Grey, 
  White, 
  End, 
  Invalid = 0xFF, 
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(Colours)
 

struct PixelColour {
  uint8_t p; 
 
  constexpr PixelColour() : p(0) {}
  explicit constexpr PixelColour(uint8_t p) : p(p) {}
};

enum class TextColour : uint8_t {
  Begin = 0x00, 
  FromString = Begin, 
  Blue = Begin, 
  Silver, 
  Gold, 
  Red, 
  Purple, 
  LightBrown, 
  Orange, 
  Green, 
  Yellow, 
  DarkGreen, 
  Cream, 
  Brown, 
  White, 
  LightBlue, 
  Grey, 
  DarkBlue, 
  Black, 
  End, 
  Invalid = 0xFF, 
};

enum class ExtendedTextColourFlag : uint8_t{
  IsPaletteColour, 
  NoShade, 
  Forced, 
};
using ExtendedTextColourFlags = EnumBitSet<ExtendedTextColourFlag, uint8_t>; 

struct ExtendedTextColour {
  constexpr ExtendedTextColour(TextColour colour = TextColour::Invalid, ExtendedTextColourFlags flags = {}) : colour(colour), flags(flags) {}

  constexpr ExtendedTextColour(PixelColour pc) : colour(static_cast<TextColour>(pc.p)), flags(ExtendedTextColourFlag::IsPaletteColour) {}
 
  TextColour colour; 
  ExtendedTextColourFlags flags{}; 

  constexpr auto operator<=>(const ExtendedTextColour &) const = default;

  constexpr static ExtendedTextColour FromNetwork(uint16_t tc) { return ExtendedTextColour{static_cast<TextColour>(tc & 0xFF), ExtendedTextColourFlags(tc >> 8)}; }

  constexpr uint16_t ToNetwork() const { return to_underlying(this->colour) | this->flags.base() << 8; }
};
 
/* A few values that are related to animations using palette changes */
static constexpr uint8_t PALETTE_ANIM_SIZE = 28; 
static constexpr uint8_t PALETTE_ANIM_START = 227; 

enum class FillRectMode : uint8_t {
  Opaque, 
  Checker, 
  Recolour, 
};

enum class PaletteType : uint8_t {
  DOS, 
  Windows, 
};

enum class SpriteType : uint8_t {
  Normal   = 0,      
  MapGen   = 1,      
  Font     = 2,      
  Recolour = 3,      
  Invalid  = 4,      
};

static const uint MILLISECONDS_PER_TICK = 27;

struct Palette {
  Colour palette[256]; 
  int first_dirty;     
  int count_dirty;     
};

enum class Support8bpp : uint8_t {
  None = 0, 
  System, 
  Hardware, 
};

enum StringAlignment : uint8_t {
  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)
 

enum class DirectionKey {
  Left, 
  Up, 
  Right, 
  Down, 
};
using DirectionKeys = EnumBitSet<DirectionKey, uint8_t>; 
 
#endif /* GFX_TYPE_H */