th_gfx_sdl.h

Go to the documentation of this file.

/*
Copyright (c) 2009-2013 Peter "Corsix" Cawley and Edvin "Lego3" Linge
 
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#ifndef CORSIX_TH_TH_GFX_SDL_H_
#define CORSIX_TH_TH_GFX_SDL_H_
 
#include "config.h"
 
#include <SDL.h>
 
#include <array>
#include <memory>
#include <stack>
#include <stdexcept>
#include <vector>
 
#include "th_gfx_common.h"
 
class cursor;
class line_sequence;
class lua_persist_reader;
class lua_persist_writer;
 
struct clip_rect : public SDL_Rect {
  typedef Sint16 x_y_type;
  typedef Uint16 w_h_type;
};
 
struct render_target_creation_params {
  int width;               
  int height;              
  int bpp;                 
  bool fullscreen;         
  bool present_immediate;  
  bool direct_zoom;  
  int min_width;     
  int min_height;    
};
 
enum class scaled_items;
 
typedef uint32_t argb_colour;
 
class palette {
 public:  // External API
  static constexpr int color_count{256};
 
  palette() = default;
 
 
  palette(const uint8_t* pData, size_t iDataLength, bool is8bit);
 
 
  bool set_entry(int iEntry, uint8_t iR, uint8_t iG, uint8_t iB);
 
 public:  // Internal (this rendering engine only) API
 
  static constexpr argb_colour pack_argb(uint8_t iA, uint8_t iR, uint8_t iG,
                                         uint8_t iB) {
    return (static_cast<argb_colour>(iR) << 0) |
           (static_cast<argb_colour>(iG) << 8) |
           (static_cast<argb_colour>(iB) << 16) |
           (static_cast<argb_colour>(iA) << 24);
  }
 
 
  static constexpr uint8_t get_red(argb_colour iColour) {
    return static_cast<uint8_t>((iColour >> 0) & 0xFF);
  }
 
 
  static constexpr uint8_t get_green(argb_colour iColour) {
    return static_cast<uint8_t>((iColour >> 8) & 0xFF);
  }
 
 
  static constexpr uint8_t get_blue(argb_colour iColour) {
    return static_cast<uint8_t>((iColour >> 16) & 0xFF);
  }
 
 
  static constexpr uint8_t get_alpha(argb_colour iColour) {
    return static_cast<uint8_t>((iColour >> 24) & 0xFF);
  }
 
 
  const std::array<argb_colour, color_count>& get_argb_data() const;
 
 
  inline void set_argb(int iEntry, uint32_t iVal) {
    colour_index_to_argb_map[iEntry] = iVal;
  }
 
 private:
  std::array<argb_colour, color_count> colour_index_to_argb_map{};
};
 
class full_colour_renderer {
 public:
 
  full_colour_renderer(int iWidth, int iHeight);
  virtual ~full_colour_renderer() = default;
 
 
  void decode_image(const uint8_t* pImg, const ::palette* pPalette,
                    uint32_t iSpriteFlags);
 
 private:
 
  virtual void store_argb(uint32_t pixel) = 0;
 
  const int width;
  const int height;
  int x{};
  int y{};
 
 
  inline void push_pixel(uint32_t iValue) {
    if (y < height) {
      store_argb(iValue);
      x++;
      if (x >= width) {
        x = 0;
        y++;
      }
    } else {
      throw std::logic_error("Attempt to push_pixel past the end of the image");
    }
  }
};
 
class full_colour_storing : public full_colour_renderer {
 public:
  full_colour_storing(uint32_t* pDest, int iWidth, int iHeight);
 
 private:
  void store_argb(uint32_t pixel) override;
 
  uint32_t* destination;
};
 
class wx_storing : public full_colour_renderer {
 public:
  wx_storing(uint8_t* pRGBData, uint8_t* pAData, int iWidth, int iHeight);
 
 private:
  void store_argb(uint32_t pixel) override;
 
  uint8_t* rgb_data;
 
  uint8_t* alpha_data;
};
 
class render_target {
 public:  // External API
  explicit render_target(const render_target_creation_params& params);
  render_target(const render_target& other) = delete;
  render_target& operator=(const render_target& other) = delete;
  ~render_target();
 
  static constexpr uint32_t map_colour(uint8_t iR, uint8_t iG, uint8_t iB) {
    return palette::pack_argb(0xFF, iR, iG, iB);
  }
 
  bool update(const render_target_creation_params& params);
 
  const char* get_last_error();
 
  bool start_frame();
 
  bool end_frame();
 
  bool fill_black();
 
  bool fill_colour(uint32_t colour);
 
  // Used to add the blue effect when the game is paused.
  void set_blue_filter_active(bool bActivate);
 
  bool fill_rect(uint32_t iColour, int iX, int iY, int iW, int iH);
 
  int set_minimum_size(int width, int height);
 
  class scoped_clip {
   public:
    scoped_clip(render_target*, const clip_rect* pRect);
    ~scoped_clip();
 
   private:
    render_target* target{nullptr};
  };
 
  void push_clip_rect(const clip_rect* pRect);
 
  void pop_clip_rect();
 
  int get_width() const;
 
  int get_height() const;
 
  void start_nonoverlapping_draws();
 
  void finish_nonoverlapping_draws();
 
  void set_cursor(cursor* pCursor);
 
  void set_cursor_position(int iX, int iY);
 
  bool take_screenshot(const char* file_path) const;
 
 
  bool set_scale_factor(double fScale, scaled_items eWhatToScale);
 
  void set_caption(const char* sCaption);
 
  void set_window_grab(bool bActivate);
 
  const char* get_renderer_details() const;
 
  // If you add any extra methods here which are called from outside the
  // rendering engine, then be sure to at least add dummy implementations
  // to the other rendering engines.
 
 public:  // Internal (this rendering engine only) API
  class scoped_buffer {
   public:
    virtual ~scoped_buffer() = default;
  };
 
  class scoped_target_texture final : public scoped_buffer {
   public:
    scoped_target_texture(render_target* pTarget, int iX, int iY, int iWidth,
                          int iHeight, bool bScale);
    scoped_target_texture(scoped_target_texture&) = delete;
    scoped_target_texture& operator=(scoped_target_texture&) = delete;
    ~scoped_target_texture() override;
    void offset(SDL_FRect& targetRect) const;
    double scale_factor() const;
    bool is_target() const;
 
   private:
    render_target* target;
    scoped_target_texture* previous_target;
    SDL_Rect rect;
    bool scale;
    SDL_Texture* texture{nullptr};
  };
 
  SDL_Renderer* get_renderer() const { return renderer; }
 
 
  bool should_scale_bitmaps(double* pFactor);
 
  SDL_Texture* create_palettized_texture(int iWidth, int iHeight,
                                         const uint8_t* pPixels,
                                         const ::palette* pPalette,
                                         uint32_t iSpriteFlags) const;
  SDL_Texture* create_texture(int iWidth, int iHeight,
                              const uint32_t* pPixels) const;
  void draw(SDL_Texture* pTexture, const SDL_Rect* prcSrcRect,
            const SDL_Rect* prcDstRect, int iFlags);
  void draw_line(line_sequence* pLine, int iX, int iY);
 
 
  std::unique_ptr<scoped_buffer> begin_intermediate_drawing(int iX, int iY,
                                                            int iWidth,
                                                            int iHeight);
 
 private:
  friend class scoped_target_texture;
 
  double draw_scale() const;
 
  void destroy_intermediate_textures();
 
  SDL_Window* window{nullptr};
  SDL_Renderer* renderer{nullptr};
  scoped_target_texture* current_target{nullptr};
  std::unique_ptr<scoped_target_texture> zoom_buffer;
  SDL_PixelFormat* pixel_format{nullptr};
  bool blue_filter_active{false};
  cursor* game_cursor{nullptr};
  double bitmap_scale_factor{1.0};  
  double global_scale_factor{1.0};  
  int width{-1};
  int height{-1};
  int cursor_x{};
  int cursor_y{};
 
  std::stack<SDL_Rect> clip_rects;  
 
  // Intermediate textures used in the production of the current frame.
  // These are destroyed after the frame is presented.
  std::vector<SDL_Texture*> intermediate_textures;
 
  bool scale_bitmaps{false};  
  bool supports_target_textures{};
 
  // In SDL2 < 2.0.4 there is an issue with the y coordinates used for
  // ClipRects in opengl and opengles.
  // see: https://bugzilla.libsdl.org/show_bug.cgi?id=2700
  bool apply_opengl_clip_fix{};
  bool direct_zoom{};
};
 
class raw_bitmap {
 public:
  raw_bitmap() = default;
  ~raw_bitmap();
 
 
  void set_palette(const ::palette* pPalette);
 
 
  void load_from_th_file(const uint8_t* pPixelData, size_t iPixelDataLength,
                         int iWidth, render_target* pEventualCanvas,
                         uint32_t spriteFlags);
 
 
  void draw(render_target* pCanvas, int iX, int iY);
 
 
  void draw(render_target* pCanvas, int iX, int iY, int iSrcX, int iSrcY,
            int iWidth, int iHeight);
 
 private:
  SDL_Texture* texture{nullptr};
 
  const ::palette* bitmap_palette{nullptr};
 
  render_target* target{nullptr};
 
  int width{};
 
  int height{};
};
 
class sprite_sheet {
 public:  // External API
  sprite_sheet() = default;
  ~sprite_sheet();
 
 
  void set_palette(const ::palette* pPalette);
 
 
  bool load_from_th_file(const uint8_t* pTableData, size_t iTableDataLength,
                         const uint8_t* pChunkData, size_t iChunkDataLength,
                         bool bComplexChunks, render_target* pEventualCanvas);
 
 
  bool set_sprite_data(size_t iSprite, const uint8_t* pData, bool bTakeData,
                       size_t iDataLength, int iWidth, int iHeight);
 
 
  void set_sprite_alt_palette_map(size_t iSprite, const uint8_t* pMap,
                                  uint32_t iAlt32);
 
 
  size_t get_sprite_count() const;
 
 
  bool set_sprite_count(size_t iCount, render_target* pCanvas);
 
 
  bool get_sprite_size(size_t iSprite, int* pWidth, int* pHeight) const;
 
 
  void get_sprite_size_unchecked(size_t iSprite, int* pWidth,
                                 int* pHeight) const;
 
 
  bool get_sprite_average_colour(size_t iSprite, argb_colour* pColour) const;
 
 
  bool is_sprite_visible(size_t iSprite) const;
 
 
  void draw_sprite(render_target* pCanvas, size_t iSprite, int iX, int iY,
                   uint32_t iFlags, size_t effect_ticks = 0u,
                   animation_effect effect = animation_effect::none,
                   int scale_factor = 1);
 
 
  bool hit_test_sprite(size_t iSprite, int iX, int iY, uint32_t iFlags) const;
 
 public:  // Internal (this rendering engine only) API
 
  void wx_draw_sprite(size_t iSprite, uint8_t* pRGBData, uint8_t* pAData);
 
 private:
  friend class cursor;
 
  struct sprite {
    SDL_Texture* texture;
 
    SDL_Texture* alt_texture;
 
    const uint8_t* data;
 
    const uint8_t* alt_palette_map;
 
    uint32_t sprite_flags;
 
    int width;
 
    int height;
  }* sprites{nullptr};
 
  const ::palette* palette{nullptr};
 
  render_target* target{nullptr};
 
  size_t sprite_count{};
 
 
  void _freeSingleSprite(size_t iNumber);
 
  void _freeSprites();
 
 
  SDL_Texture* _makeAltBitmap(sprite* pSprite);
};
 
class cursor {
 public:
  cursor() = default;
  ~cursor();
 
  bool create_from_sprite(sprite_sheet* pSheet, size_t iSprite,
                          int iHotspotX = 0, int iHotspotY = 0);
 
  void use(render_target* pTarget);
 
  static bool set_position(render_target* pTarget, int iX, int iY);
 
  void draw(render_target* pCanvas, int iX, int iY);
 
 private:
  SDL_Surface* bitmap{nullptr};
  SDL_Cursor* hidden_cursor{nullptr};
  int hotspot_x{};
  int hotspot_y{};
};
 
class line_sequence {
 public:
  line_sequence();
 
  void move_to(double fX, double fY);
 
  void line_to(double fX, double fY);
 
  void set_width(double lineWidth);
 
  void draw(render_target* pCanvas, int iX, int iY);
 
  void set_colour(uint8_t iR, uint8_t iG, uint8_t iB, uint8_t iA = 255);
 
  void persist(lua_persist_writer* pWriter) const;
  void depersist(lua_persist_reader* pReader);
 
 private:
  friend class render_target;
 
  enum class line_command : uint32_t { move = 0, line = 1 };
 
  class line_element {
   public:
    line_command type;
    double x, y;
    line_element(line_command type, double x, double y)
        : type(type), x(x), y(y) {}
  };
 
  std::vector<line_element> line_elements;
  double width{1};
  uint8_t red{0}, green{0}, blue{0}, alpha{255};
};
 
#endif  // CORSIX_TH_TH_GFX_SDL_H_