th_gfx.h

Go to the documentation of this file.

/*
Copyright (c) 2009 Peter "Corsix" Cawley
 
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_H_
#define CORSIX_TH_TH_GFX_H_
 
#include "config.h"
 
#include <map>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include "lua.hpp"
#include "th.h"
#include "th_gfx_common.h"
#include "th_gfx_sdl.h"
#include "th_lua.h"
 
class lua_persist_reader;
class lua_persist_writer;
class memory_reader;
struct map_tile;
 
enum class scaled_items { none, sprite_sheets, bitmaps, all };
 
void clip_rect_intersection(clip_rect& rcClip, const clip_rect& rcIntersect);
 
enum draw_flags : uint32_t {
  /* Where possible, designed to be the same values used by TH data files */
 
  thdf_flip_horizontal = 1 << 0,
  thdf_flip_vertical = 1 << 1,
  thdf_alpha_50 = 1 << 2,
  thdf_alpha_75 = 1 << 3,
  thdf_alt_palette = 1 << 4,
 
  /* A 3 bit field (bits 5,6,7), currently 2 bits used. */
 
  thdf_alt32_start = 5,
  thdf_alt32_mask = 0x7 << thdf_alt32_start,
 
  thdf_alt32_plain = 0 << thdf_alt32_start,
  thdf_alt32_grey_scale = 1 << thdf_alt32_start,
  thdf_alt32_blue_red_swap = 2 << thdf_alt32_start,
 
  /* (should be set prior to attaching to a tile) */
  thdf_early_list = 1 << 10,
 
  thdf_bound_box_hit_test = 1 << 12,
  thdf_crop = 1 << 13,
  thdf_nearest = 1 << 14,
};
 
// Integer 2D pair.
struct xy_pair {
  int x{};  
  int y{};  
};
 
// TODO: Replace this struct with something cleaner
struct drawable : public link_list {
  drawable() = default;
 
 
  virtual void draw_fn(render_target* canvas, const xy_pair& draw_pos) = 0;
 
 
  virtual bool hit_test_fn(const xy_pair& draw_pos, const xy_pair& obj_pos) = 0;
 
  virtual bool is_multiple_frame_animation_fn() = 0;
 
  int get_drawing_layer() { return drawing_layer; }
  void set_drawing_layer(int layer) { drawing_layer = layer; }
 
  uint32_t flags{0};
 
 private:
  int drawing_layer{0};
};
 
class chunk_renderer {
 public:
 
  chunk_renderer(int width, int height, std::vector<uint8_t>::iterator start);
 
 
  void decode_chunks(const uint8_t* pData, int iDataLen, bool bComplex);
 
  void chunk_copy(int npixels, const uint8_t* in_data);
 
  void chunk_fill(int npixels, uint8_t value);
 
  void chunk_fill_to_end_of_line(uint8_t value);
 
  void chunk_finish(uint8_t value);
 
 private:
  inline bool is_done() const { return ptr == end; }
  inline void fix_n_pixels(int& npixels) const;
  inline void increment_position(int npixels);
 
  std::vector<uint8_t>::iterator ptr, end;
  int x{0}, y{0};
  int width, height;
  bool skip_eol{false};
};
 
//  a nibble.
const int max_number_of_layers = 13;
 
struct layers {
  uint8_t layer_contents[max_number_of_layers]{};
};
 
struct animation_key {
  std::string name;  
  int tile_size;     
};
 
 
inline bool operator<(const animation_key& oK, const animation_key& oL) {
  if (oK.tile_size != oL.tile_size) return oK.tile_size < oL.tile_size;
  return oK.name < oL.name;
}
 
struct animation_start_frames {
  long north{-1};  
  long east{-1};   
  long south{-1};  
  long west{-1};   
};
 
typedef std::map<animation_key, animation_start_frames> named_animations_map;
 
typedef std::pair<animation_key, animation_start_frames> named_animation_pair;
 
 
class animation_manager {
 public:
  animation_manager() = default;
 
  void set_sprite_sheet(sprite_sheet* pSpriteSheet);
 
 
  bool load_from_th_file(const uint8_t* pStartData, size_t iStartDataLength,
                         const uint8_t* pFrameData, size_t iFrameDataLength,
                         const uint8_t* pListData, size_t iListDataLength,
                         const uint8_t* pElementData,
                         size_t iElementDataLength);
 
 
  void set_canvas(render_target* pCanvas);
 
 
  bool load_custom_animations(const uint8_t* pData, size_t iDataLength);
 
  size_t get_animation_count() const;
 
  size_t get_frame_count() const;
 
  size_t get_first_frame(size_t iAnimation) const;
 
 
  size_t get_next_frame(size_t iFrame) const;
 
 
  void set_animation_alt_palette_map(size_t iAnimation, const uint8_t* pMap,
                                     uint32_t iAlt32);
 
 
  void draw_frame(render_target* pCanvas, size_t iFrame,
                  const ::layers& oLayers, int iX, int iY, uint32_t iFlags,
                  animation_effect patient_effect = animation_effect::none,
                  size_t patient_effect_offset = 0) const;
 
  void get_frame_extent(size_t iFrame, const ::layers& oLayers, int* pMinX,
                        int* pMaxX, int* pMinY, int* pMaxY,
                        uint32_t iFlags) const;
  size_t get_frame_sound(size_t iFrame);
 
  bool hit_test(size_t iFrame, const ::layers& oLayers, int iX, int iY,
                uint32_t iFlags, int iTestX, int iTestY) const;
 
  bool set_frame_primary_marker(size_t iFrame, int iX, int iY);
  bool set_frame_secondary_marker(size_t iFrame, int iX, int iY);
  bool get_frame_primary_marker(size_t iFrame, int* pX, int* pY);
  bool get_frame_secondary_marker(size_t iFrame, int* pX, int* pY);
 
 
  const animation_start_frames& get_named_animations(std::string_view sName,
                                                     int iTilesize) const;
 
  void tick();
 
 private:
  struct frame {
    size_t list_index;   
    size_t next_frame;   
    unsigned int sound;  
    unsigned int flags;  
 
    // Bounding rectangle is with all layers / options enabled - used as a
    // quick test prior to a full pixel perfect test.
    int bounding_left;    
    int bounding_right;   
    int bounding_top;     
    int bounding_bottom;  
 
    // Markers are used to know where humanoids are on an frame. The
    // positions are pixels offsets from the centre of the frame's base
    // tile to the centre of the humanoid's feet.
    int primary_marker_x;    
    int primary_marker_y;    
    int secondary_marker_x;  
    int secondary_marker_y;  
  };
 
  struct element {
    size_t sprite;     
    uint32_t flags;    
    int x;             
    int y;             
    uint8_t layer;     
    uint8_t layer_id;  
 
    sprite_sheet* element_sprite_sheet;  
  };
 
  std::vector<size_t> first_frames;    
  std::vector<frame> frames;           
  std::vector<uint16_t> element_list;  
  std::vector<element> elements;       
  std::vector<sprite_sheet>
      custom_sheets;  
  named_animations_map named_animations;  
 
  sprite_sheet* sheet{nullptr};    
  render_target* canvas{nullptr};  
 
  size_t animation_count{0};     
  size_t frame_count{0};         
  size_t element_list_count{0};  
  size_t element_count{0};       
 
  size_t game_ticks{0};
 
 
  void set_bounding_box(frame& oFrame);
 
 
  size_t load_elements(memory_reader& input, sprite_sheet* pSpriteSheet,
                       size_t iNumElements, size_t& iLoadedElements,
                       size_t iElementStart, size_t iElementCount);
 
 
  size_t make_list_elements(size_t iFirstElement, size_t iNumElements,
                            size_t& iLoadedListElements, size_t iListStart,
                            size_t iListCount);
 
 
  void fix_next_frame(uint32_t iFirst, size_t iLength);
};
 
class animation_base : public drawable {
 public:
  animation_base();
 
  void remove_from_tile();
  void attach_to_tile(const xy_pair& tile_pos, map_tile* node, int layer);
 
  uint32_t get_flags() const { return flags; }
  const xy_pair& get_pixel_offset() const { return pixel_offset; }
  const xy_pair& get_tile() const { return tile; }
 
  void set_flags(uint32_t iFlags) { flags = iFlags; }
  void set_tile(const xy_pair& tile_pos) { tile = tile_pos; }
  void set_pixel_offset(int x, int y) {
    pixel_offset.x = x;
    pixel_offset.y = y;
  }
  void set_layer(int iLayer, int iId);
  void set_layers_from(const animation_base* pSrc) { layers = pSrc->layers; }
 
 protected:
  xy_pair tile{-1, -1};
 
  xy_pair pixel_offset{0, 0};
 
  ::layers layers{};
};
 
enum class animation_kind { primary_child, secondary_child, normal, morph };
 
class animation : public animation_base {
 public:
  animation();
 
  void set_parent(animation* parent_anim, bool use_primary);
 
  void tick();
  void draw(render_target* canvas, const xy_pair& draw_pos);
  void draw_morph(render_target* canvas, const xy_pair& draw_pos);
  void draw_child(render_target* canvas, const xy_pair& draw_pos,
                  bool use_primary);
 
  void draw_fn(render_target* canvas, const xy_pair& draw_pos) override {
    switch (anim_kind) {
      case animation_kind::normal:
        draw(canvas, draw_pos);
        return;
      case animation_kind::primary_child:
        draw_child(canvas, draw_pos, true);
        return;
      case animation_kind::secondary_child:
        draw_child(canvas, draw_pos, false);
        return;
      case animation_kind::morph:
        draw_morph(canvas, draw_pos);
        return;
    }
  }
 
  bool hit_test(const xy_pair& draw_pos, const xy_pair& obj_pos);
  bool hit_test_morph(const xy_pair& draw_pos, const xy_pair& obj_pos);
  bool hit_test_child(const xy_pair& draw_pos, const xy_pair& obj_pos);
 
  bool hit_test_fn(const xy_pair& draw_pos, const xy_pair& obj_pos) override {
    switch (anim_kind) {
      case animation_kind::normal:
        return hit_test(draw_pos, obj_pos);
      case animation_kind::primary_child:
      case animation_kind::secondary_child:
        return hit_test_child(draw_pos, obj_pos);
      case animation_kind::morph:
        return hit_test_morph(draw_pos, obj_pos);
    }
    return false;
  }
 
  bool is_multiple_frame_animation_fn() override {
    size_t anim = get_animation();
    size_t first_frame = get_animation_manager()->get_first_frame(anim);
    size_t next_frame = get_animation_manager()->get_next_frame(first_frame);
    return next_frame != first_frame;
  }
 
  link_list* get_previous() { return prev; }
  size_t get_animation() const { return animation_index; }
  bool get_primary_marker(int* pX, int* pY);
  bool get_secondary_marker(int* pX, int* pY);
  size_t get_frame() const { return frame_index; }
  int get_crop_column() const { return crop_column; }
 
  void set_animation(animation_manager* mgr, size_t anim);
  void set_morph_target(animation* target, int duration = 1);
  void set_frame(size_t new_frame);
 
  void set_speed(int x, int y) {
    speed.x = x;
    speed.y = y;
  }
  void set_crop_column(int column) { crop_column = column; }
 
  void persist(lua_persist_writer* writer) const;
  void depersist(lua_persist_reader* reader);
 
  void set_patient_effect(animation_effect patient_effect);
  void set_animation_kind(animation_kind anim_kind);
  animation_kind get_animation_kind() { return anim_kind; }
 
  animation_manager* get_animation_manager() { return manager; }
 
 private:
  animation_manager* manager{nullptr};
  animation* morph_target{nullptr};
  size_t animation_index{};  
  size_t frame_index{};      
  union {
    xy_pair speed{};  
 
    animation* parent;
  };
 
  size_t sound_to_play{};
  int crop_column{};
  animation_kind anim_kind{animation_kind::normal};
  animation_effect patient_effect{animation_effect::none};
  size_t patient_effect_offset;
};
 
class sprite_render_list : public animation_base {
 public:
  void tick();
 
  void set_sheet(sprite_sheet* new_sheet) { sheet = new_sheet; }
  void set_speed(int x_speed, int y_speed) {
    dx_per_tick = x_speed;
    dy_per_tick = y_speed;
  }
  void set_lifetime(int life_time);
  void set_use_intermediate_buffer();
  void append_sprite(size_t spr_num, int xpos, int ypos);
  bool is_dead() const { return lifetime == 0; }
 
  void persist(lua_persist_writer* writer) const;
  void depersist(lua_persist_reader* reader);
 
  void draw(render_target* canvas, const xy_pair& draw_pos);
 
  void draw_fn(render_target* canvas, const xy_pair& draw_pos) override {
    draw(canvas, draw_pos);
  }
 
  bool hit_test(const xy_pair& draw_pos, const xy_pair& obj_pos);
 
  bool hit_test_fn(const xy_pair& draw_pos, const xy_pair& obj_pos) override {
    return hit_test(draw_pos, obj_pos);
  }
 
  bool is_multiple_frame_animation_fn() override { return false; }
 
 private:
  struct sprite {
    size_t index;
    int x;
    int y;
  };
 
  sprite_sheet* sheet{nullptr};
  std::vector<sprite> sprites{};
 
  int dx_per_tick{0};
  int dy_per_tick{0};
  int lifetime{-1};
  bool use_intermediate_buffer{false};
};
 
// Find the appropriate subclass of animation_base for a given
// userdata object.
//
// th_lua_internal.h defines our c++ binding class metatables:
// metatable: { __index = method_table, ... }
// method_table: { ... }
// method_table metatable: { __class_name = class_name }
inline animation_base* luaT_toanimationbase(lua_State* L, int idx) {
  return luaT_touserdata_base<animation_base, animation, sprite_render_list>(
      L, idx, {"animation", "spriteList"});
}
 
#endif  // CORSIX_TH_TH_GFX_H_