Tmx.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2022 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef GF_TMX_H
#define GF_TMX_H
 
#include <cstdint>
 
#include <array>
#include <map>
#include <memory>
#include <string>
#include <variant>
#include <vector>
 
#include "CellTypes.h"
#include "CoreApi.h"
#include "Flags.h"
#include "Id.h"
#include "Path.h"
#include "Rect.h"
#include "Time.h"
#include "Vector.h"
 
namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif
  enum class TmxRenderOrder {
    RightDown, 
    RightUp,   
    LeftDown,  
    LeftUp,    
  };
 
  class GF_CORE_API TmxProperties {
  public:
    void addStringProperty(std::string name, std::string value);
 
    void addIntProperty(std::string name, int value);
 
    void addFloatProperty(std::string name, double value);
 
    void addBoolProperty(std::string name, bool value);
 
    void addColorProperty(std::string name, Color4u value);
 
    void addFileProperty(std::string name, Path value);
 
    void addObjectProperty(std::string name, Id value);
 
    void addClassProperty(std::string name, TmxProperties value);
 
    std::string getStringProperty(const std::string& name, const std::string& def) const;
 
    int getIntProperty(const std::string& name, int def) const;
 
    double getFloatProperty(const std::string& name, double def) const;
 
    bool getBoolProperty(const std::string& name, bool def) const;
 
    Color4u getColorProperty(const std::string& name, const Color4u& def) const;
 
    Path getFileProperty(const std::string& name, const Path& def) const;
 
    Id getObjectProperty(const std::string& name, Id def) const;
 
    TmxProperties getClassProperty(const std::string& name, const TmxProperties& def) const;
 
  private:
    using Value = std::variant<bool, int, double, std::string, Color4u, Path, Id, TmxProperties>;
    std::map<std::string, Value> m_props;
  };
 
  struct TmxLayers;
 
  struct TmxTileLayer;
  struct TmxObjectLayer;
  struct TmxImageLayer;
  struct TmxGroupLayer;
 
  class GF_CORE_API TmxVisitor {
  public:
    virtual ~TmxVisitor();
 
    virtual void visitTileLayer(const TmxLayers& map, const TmxTileLayer& layer);
 
    virtual void visitObjectLayer(const TmxLayers& map, const TmxObjectLayer& layer);
 
    virtual void visitImageLayer(const TmxLayers& map, const TmxImageLayer& layer);
 
    virtual void visitGroupLayer(const TmxLayers& map, const TmxGroupLayer& layer);
  };
 
  struct GF_CORE_API TmxLayer {
    virtual ~TmxLayer();
 
    virtual void accept(const TmxLayers& map, TmxVisitor& visitor) const = 0;
 
    TmxProperties properties; 
    std::string name;         
    double opacity;           
    bool visible;             
    Vector2i offset;          
  };
 
  struct GF_CORE_API TmxCell {
    uint32_t gid;             
    Flags<Flip> flip = None;  
  };
 
  struct GF_CORE_API TmxChunk {
    Vector2i position;
    Vector2i size;
    std::vector<TmxCell> cells;
  };
 
  struct GF_CORE_API TmxTileLayer : public TmxLayer {
    std::vector<TmxCell> cells; 
    std::vector<TmxChunk> chunks; 
 
    void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };
 
  enum class TmxDrawOrder {
    TopDown,  
    Index,    
  };
 
 
  struct GF_CORE_API TmxObject {
    virtual ~TmxObject();
 
    enum Kind {
      Rectangle,  
      Ellipse,    
      Polyline,   
      Polygon,    
      Tile,       
      Text,       
      Point,      
    };
 
    Kind kind;  
 
    TmxProperties properties; 
 
    int id;             
    std::string name;   
    std::string type;   
    Vector2f position;  
    double rotation;    
    bool visible;       
  };
 
  struct GF_CORE_API TmxRectangle : public TmxObject {
    Vector2f size;  
  };
 
  struct GF_CORE_API TmxEllipse : public TmxObject {
    Vector2f size;  
  };
 
  struct GF_CORE_API TmxTileObject : public TmxObject {
    uint32_t gid;
    Flags<Flip> flip;
  };
 
  struct GF_CORE_API TmxPolyline : public TmxObject {
    std::vector<Vector2f> points; 
  };
 
  struct GF_CORE_API TmxPolygon : public TmxObject {
    std::vector<Vector2f> points; 
  };
 
  struct GF_CORE_API TmxText : public TmxObject {
    std::string text;       
 
    std::string fontFamily; 
    int sizeInPixels;       
    bool wrap;              
    Color4u color;          
    bool bold;              
    bool italic;            
    bool underline;         
    bool strikeout;         
    bool kerning;           
 
    enum class HAlign {
      Left,   
      Center, 
      Right,  
    };
 
    HAlign halign;  
 
    enum class VAlign {
      Top,    
      Center, 
      Bottom, 
    };
 
    VAlign valign;  
  };
 
  struct GF_CORE_API TmxPoint : public TmxObject {
  };
 
  struct GF_CORE_API TmxObjectLayer : public TmxLayer {
#ifdef _MSC_VER
    // stupid MSVC!
    TmxObjectLayer() = default;
    TmxObjectLayer(const TmxObjectLayer&) = delete;
    TmxObjectLayer& operator=(const TmxObjectLayer&) = delete;
#endif
 
    Color4u color;  
    TmxDrawOrder drawOrder; 
    std::vector<std::unique_ptr<TmxObject>> objects;  
 
    void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };
 
  struct GF_CORE_API TmxImage {
    std::string format;   
    Path source;          
    Color4u transparent;  
    Vector2i size;        
  };
 
  struct GF_CORE_API TmxImageLayer : public TmxLayer {
    std::unique_ptr<TmxImage> image;  
 
    void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };
 
 
  struct GF_CORE_API TmxGroupLayer : public TmxLayer {
#ifdef _MSC_VER
    // stupid MSVC!
    TmxGroupLayer() = default;
    TmxGroupLayer(const TmxGroupLayer&) = delete;
    TmxGroupLayer& operator=(const TmxGroupLayer&) = delete;
#endif
 
    std::vector<std::unique_ptr<TmxLayer>> layers;  
 
    void accept(const TmxLayers& map, TmxVisitor& visitor) const override;
  };
 
  struct GF_CORE_API TmxFrame {
    int tileId;
    Time duration;
  };
 
  struct GF_CORE_API TmxAnimation {
    std::vector<TmxFrame> frames; 
  };
 
  struct GF_CORE_API TmxTile {
    TmxProperties properties; 
    int id;                   
    std::string type;         
    int probability;          
 
    std::unique_ptr<TmxImage> image;  
    std::unique_ptr<TmxObjectLayer> objects;  
    std::unique_ptr<TmxAnimation> animation;  
  };
 
  struct GF_CORE_API TmxWangColor {
    TmxProperties properties; 
    std::string name;         
    Color4u color;            
    int tile;                 
    int probability;          
  };
 
  struct GF_CORE_API TmxWangTile {
    static constexpr std::size_t Top          = 0; 
    static constexpr std::size_t TopRight     = 1; 
    static constexpr std::size_t Right        = 2; 
    static constexpr std::size_t BottomRight  = 3; 
    static constexpr std::size_t Bottom       = 4; 
    static constexpr std::size_t BottomLeft   = 5; 
    static constexpr std::size_t Left         = 6; 
    static constexpr std::size_t TopLeft      = 7; 
 
    int tileid;                 
    std::array<int, 8> wangid;  
  };
 
  struct GF_CORE_API TmxWangSet {
    TmxProperties properties; 
    std::string name;         
    int tile;                 
 
    std::vector<TmxWangColor> colors;
    std::vector<TmxWangTile> tiles;
  };
 
  struct GF_CORE_API TmxTileset {
    TmxProperties properties; 
 
    uint32_t firstGid;        
    std::string name;         
    Vector2i tileSize;        
    int spacing;              
    int margin;               
    int tileCount;            
    int columnCount;          
 
    Vector2i offset;          
 
    std::unique_ptr<TmxImage> image;  
    std::vector<TmxTile> tiles;       
    std::vector<TmxWangSet> wangsets; 
 
    const TmxTile *getTile(int id) const noexcept;
 
    RectI getSubTexture(int id, Vector2i size) const noexcept;
  };
 
  struct GF_CORE_API TmxLayers {
#ifdef _MSC_VER
    // stupid MSVC!
    TmxLayers() = default;
    TmxLayers(const TmxLayers&) = delete;
    TmxLayers& operator=(const TmxLayers&) = delete;
#endif
 
    TmxProperties properties;   
 
    std::string version;        
    std::string tiledVersion;   
    CellOrientation orientation;  
    TmxRenderOrder renderOrder; 
 
    bool infinite;              
    Vector2i mapSize;           
    Vector2i tileSize;          
 
    int hexSideLength;          
    CellAxis cellAxis;          
    CellIndex cellIndex;        
 
    Color4u backgroundColor;    
 
    int nextObjectId;           
 
    std::vector<TmxTileset> tilesets; 
    std::vector<std::unique_ptr<TmxLayer>> layers;  
 
  public:
    const TmxTileset *getTileSetFromGID(uint32_t gid) const noexcept;
 
    void visitLayers(TmxVisitor& visitor) const;
 
    bool loadFromFile(const Path& filename);
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}
 
#endif // GF_TMX_H