tmj.h

Go to the documentation of this file.

#ifndef LIBTMJ_API
#define LIBTMJ_API
 
#include <stdbool.h>
#include <stdint.h>
 
#include <jansson.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct Property {
    char* name;
    char* propertytype;
    char* type;
 
    union {
        char* value_string;
        int value_int;
        double value_float;
        bool value_bool;
        char* value_color;
        char* value_file;
        int value_object;
    };
} Property;
 
typedef struct Chunk {
    int height;
    int width;
    int x;
    int y;
 
    bool data_is_str;
    size_t data_count;
 
    union {
        char* data_str;
        unsigned int* data_uint;
    };
} Chunk;
 
typedef struct Point {
    double x;
    double y;
} Point;
 
typedef struct Text {
    bool bold;
    bool italic;
    bool kerning;
    bool strikeout;
    bool underline;
    bool wrap;
 
    char* color;
    char* fontfamily;
    char* halign;
    char* text;
    char* valign;
 
    int pixelsize;
} Text;
 
typedef struct Object {
    bool ellipse;
    bool point;
    bool visible;
 
    char* name;
    char* template;
    char* type; // Optional
 
    int gid;
    int id;
 
    double height;
    double rotation;
    double width;
    double x;
    double y;
 
    bool is_polygon;
 
    union {
        size_t polygon_point_count;
        size_t polyline_point_count;
    };
    union {
        Point* polygon;
        Point* polyline;
    };
 
    size_t property_count;
    Property* properties;
 
    Text* text;
} Object;
 
typedef struct Layer {
    bool locked;
    bool repeatx; // Imagelayer only
    bool repeaty; // Imagelayer only
    bool visible;
 
    char* class; // Optional
    char* compression; // tilelayer only
    char* draworder; // objectgroup only
    char* encoding; // tilelayer only
    char* image; // imagelayer only
    char* name;
    char* tintcolor; // Optional
    char* transparentcolor; // Optional, imagelayer only
    char* type;
 
    bool data_is_str;
    size_t data_count;
    union {
        unsigned int* data_uint;
        char* data_str;
    }; // tilelayer only
 
    int height; // tilelayer only
    int id;
    int imageheight; // imagelayer only
    int imagewidth; // imagelayer only
    int startx;
    int starty;
    int width; // tilelayer only
    int x;
    int y;
 
    double offsetx;
    double offsety;
    double opacity;
    double parallaxx;
    double parallaxy;
 
    size_t chunk_count;
    Chunk* chunks; // Optional, tilelayer only
 
    size_t layer_count;
    struct Layer* layers; // group only
 
    size_t object_count;
    Object* objects; // objectgroup only
 
    size_t property_count;
    Property* properties;
} Layer;
 
typedef struct Transformations {
    bool hflip;
    bool preferuntransformed;
    bool rotate;
    bool vflip;
} Transformations;
 
typedef struct Terrain {
    char* name;
 
    int tile;
 
    size_t property_count;
    Property* properties;
} Terrain;
 
typedef struct Frame {
    int duration;
    int tileid;
} Frame;
 
typedef struct Tile {
    char* image; // Optional
    char* type; // Optional
 
    int id;
    int imageheight;
    int imagewidth;
    int x;
    int y;
    int width;
    int height;
 
    double probability; // Optional
 
    size_t animation_count;
    Frame* animation;
 
    int terrain[4]; // Optional
 
    size_t property_count;
    Property* properties;
 
    Layer* objectgroup; // Optional
} Tile;
 
typedef struct WangTile {
    int tileid;
 
    unsigned char wangid[8];
} WangTile;
 
typedef struct WangColor {
    char* class;
    char* color;
    char* name;
 
    int tile;
 
    double probability;
 
    size_t property_count;
    Property* properties;
} WangColor;
 
typedef struct WangSet {
    char* class; // Optional
    char* name;
    char* type;
 
    int tile;
 
    size_t color_count;
    WangColor* colors;
 
    size_t property_count;
    Property* properties;
 
    size_t wangtile_count;
    WangTile* wangtiles;
} WangSet;
 
typedef struct Grid {
    char* orientation;
 
    int height;
    int width;
} Grid;
 
typedef struct TileOffset {
    int x;
    int y;
} TileOffset;
 
typedef struct Tileset {
    json_t* root; // NULL for embedded tilesets; only set for external tilesets
 
    char* backgroundcolor; // Optional
    char* class; // Optional
    char* fillmode;
    char* image;
    char* name;
    char* objectalignment;
    char* source;
    char* tiledversion;
    char* tilerendersize;
    char* transparentcolor; // Optional
    char* type;
    char* version;
 
    int columns;
    int firstgid;
    int imageheight;
    int imagewidth;
    int margin;
    int spacing;
    int tilecount;
    int tileheight;
    int tilewidth;
 
    size_t property_count;
    Property* properties;
 
    size_t terrain_count;
    Terrain* terrains; // Optional
 
    size_t tile_count;
    Tile* tiles; // Optional
 
    size_t wang_set_count;
    WangSet* wangsets;
 
    Grid* grid; // Optional
 
    TileOffset* tileoffset; // Optional
 
    Transformations* transformations; // Optional
} Tileset;
 
typedef struct Map {
    json_t* root;
 
    bool infinite;
 
    char* backgroundcolor; // Optional
    char* class; // Optional
    char* orientation;
    char* renderorder; // Orthogonal maps only
    char* staggeraxis; // Staggered/hexagonal maps only
    char* staggerindex; // Staggered/hexagonal maps only
    char* tiledversion;
    char* type;
    char* version;
 
    int compressionlevel;
    int height;
    int hexsidelength; // Hexagonal maps only
    int nextlayerid;
    int nextobjectid;
    int tileheight;
    int tilewidth;
    int width;
 
    double parallaxoriginx;
    double parallaxoriginy;
 
    // Layer tree
    size_t layer_count;
    Layer* layers;
 
    size_t property_count;
    Property* properties;
 
    size_t tileset_count;
    Tileset* tilesets;
} Map;
 
typedef struct ObjectTemplate {
    char* type;
 
    Tileset* tileset; // Optional
    Object* object;
} ObjectTemplate;
 
Map* tmj_map_loadf(const char* path, bool check_extension);
 
Map* tmj_map_load(const char* map, const char* name);
 
Tileset* tmj_tileset_loadf(const char* path, bool check_extension);
 
Tileset* tmj_tileset_load(const char* tileset);
 
void tmj_map_free(Map* map);
 
void tmj_tileset_free(Tileset* tileset);
 
typedef enum TMJ_LOG_PRIORITY {
    TMJ_LOG_DEBUG,
    TMJ_LOG_INFO,
    TMJ_LOG_WARNING,
    TMJ_LOG_ERR,
    TMJ_LOG_CRIT
} tmj_log_priority;
 
void tmj_log_regcb(bool debug, void (*callback)(tmj_log_priority, const char*));
 
// * @defgroup util Util
// *
// * Helper functions.
// */
 
extern const unsigned int TMJ_VERSION_MAJOR;
 
extern const unsigned int TMJ_VERSION_MINOR;
 
extern const unsigned int TMJ_VERSION_PATCH;
 
extern const char* const TMJ_VERSION;
 
uint32_t* tmj_decode_layer(const char* data, const char* encoding, const char* compression, size_t* size);
 
#ifdef __cplusplus
}
#endif
 
#endif