diff options
Diffstat (limited to 'include/raytmx.h')
| -rw-r--r-- | include/raytmx.h | 4815 |
1 files changed, 4815 insertions, 0 deletions
diff --git a/include/raytmx.h b/include/raytmx.h new file mode 100644 index 0000000..f446272 --- /dev/null +++ b/include/raytmx.h @@ -0,0 +1,4815 @@ +/* +Copyright (c) 2024-2026 Luke Philipsen + +Permission to use, copy, modify, and/or distribute this software for +any purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL +WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE +FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY +DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +/* Usage + + Do this: + #define RAYTMX_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + You can define RAYTMX_DEC with + #define RAYTMX_DEC static + or + #define RAYTMX_DEC extern + to specify raytmx function declarations as static or extern, respectively. + The default specifier is extern. +*/ + +#ifndef RAYTMX_H + #define RAYTMX_H + +#include <ctype.h> /* isspace() */ +#include <math.h> /* floor(), INFINITY */ +#include <stddef.h> /* NULL */ +#include <stdint.h> /* int32_t, uint32_t */ +#include <stdlib.h> /* atoi(), strtoul() */ +#include <string.h> /* memcpy(), memset(), strcpy(), strcpy_s() strlen(), strncpy(), strncpy_s() */ + +#include "raylib.h" +#include "rlgl.h" + +#ifndef RAYTMX_DEC + #define RAYTMX_DEC +#endif /* RAYTMX_DEC */ + +#ifdef __cplusplus + extern "C" { +#endif /* __cpluspus */ + +/***************/ +/* Definitions */ + +/** + * Function signature of raylib's LoadTexture() as a type. For use with SetLoadTextureTMX(). + */ +typedef Texture2D (*LoadTextureCallback)(const char* fileName); + +/** + * Bit flags passed to SetTraceLogFlagsTMX() that optionally disable the logging of specific TMX elements. + */ +enum tmx_log_flags { + LOG_SKIP_PROPERTIES = 1, /**< Skip <properties> and child <property> elements. */ + LOG_SKIP_LAYERS = 2, /**< Skip <layer>, <objectgroup>, <imagelayer>, and <group> layers and children thereof. */ + LOG_SKIP_TILE_LAYERS = 4, /**< Skip <layer> layers and children thereof. */ + LOG_SKIP_TILES = 8, /**< Skip tiles (GIDs) of tile layers (<layer>s). */ + LOG_SKIP_OBJECT_GROUPS = 16, /**< Skip <objectgroup> layers and children thereof. */ + LOG_SKIP_OBJECTS = 32, /**< Skip objects of object layers (<objectgroup>s). */ + LOG_SKIP_IMAGE_LAYERS = 64, /**< Skip <imagelayer> layers and children thereof. */ + LOG_SKIP_IMAGES = 128, /**< Skip images of image layers (<imagelayer>s). */ + LOG_SKIP_WANG_SETS = 256, /**< Skip <wangsets> and child <wangset> elements. */ + LOG_SKIP_WANG_TILES = 512 /**< Skip Wang tiles of Wang sets (<wangset>s). */ +}; + +/** + * Identifiers for the possible layer types. + */ +typedef enum tmx_layer_type { + LAYER_TYPE_TILE_LAYER = 0, /**< Layer containing a set number of tiles referenced by Global IDs (GIDs). */ + LAYER_TYPE_OBJECT_GROUP, /**< Layer containing an arbitrary number of various object types. */ + LAYER_TYPE_IMAGE_LAYER, /**< Layer consisting of a single image. */ + LAYER_TYPE_GROUP /**< Container layer, with no visuals of its own, that holds other, child layers. */ +} TmxLayerType; + +/** + * Identifiers for the possible property (data) types. + */ +typedef enum tmx_property_type { + PROPERTY_TYPE_STRING = 0, /**< String, or a sequence of characters. */ + PROPERTY_TYPE_INT, /**< Integer number. */ + PROPERTY_TYPE_FLOAT, /**< Floating-point number. */ + PROPERTY_TYPE_BOOL, /**< Boolean, true or false. */ + PROPERTY_TYPE_COLOR, /**< Color with red, green, and blue values and a possible alpha value. */ + PROPERTY_TYPE_FILE, /**< File name or path to a file as a string. */ + PROPERTY_TYPE_OBJECT /**< Object (<object>) within the map as an integer ID. */ +} TmxPropertyType; + +/** + * Identifiers for the possible draw orders applicable to object layers. + */ +typedef enum tmx_object_group_draw_order { + OBJECT_GROUP_DRAW_ORDER_TOP_DOWN = 0, /**< Drawn in ascending order by y-coordinate. */ + OBJECT_GROUP_DRAW_ORDER_INDEX /**< Drawn in the order in which the appear in the document. */ +} TmxObjectGroupDrawOrder; + +/** + * Identifiers for the possible alignments of tiles with an object's bounds. + */ +typedef enum tmx_object_alignment { + OBJECT_ALIGNMENT_UNSPECIFIED = 0, /**< For orthogonal, behaves like bottom-left. For isometric, like bottm. */ + OBJECT_ALIGNMENT_TOP_LEFT, /**< Tiles are snapped to the upper-left bound of objects. */ + OBJECT_ALIGNMENT_TOP, /**< Tiles are snapped to the upper-center bound of objects. */ + OBJECT_ALIGNMENT_TOP_RIGHT, /**< Tiles are snapped to the upper-right bound of objects. */ + OBJECT_ALIGNMENT_LEFT, /**< Tiles are snapped to the left-center bound of objects. */ + OBJECT_ALIGNMENT_CENTER, /**< Tiles are snapped to the horizontal and vertical center of objects. */ + OBJECT_ALIGNMENT_RIGHT, /**< Tiles are snapped to the right-center bound of objects. */ + OBJECT_ALIGNMENT_BOTTOM_LEFT, /**< Tiles are snapped to the lower-left bound of objects. */ + OBJECT_ALIGNMENT_BOTTOM, /**< Tiles are snapped to the lower-center bound of objects. */ + OBJECT_ALIGNMENT_BOTTOM_RIGHT /**< Tiles are snapped to the lower-right bound of objects. */ +} TmxObjectAlignment; + +/** + * Identifiers for the possible object types. + */ +typedef enum tmx_object_type { + OBJECT_TYPE_RECTANGLE = 0, /**< Four-sided polygon four right angles and axis-aligned edges. */ + OBJECT_TYPE_ELLIPSE, /**< Ellipse, or a circle when the axes are equal. */ + OBJECT_TYPE_POINT, /**< Individual (X, Y) coordinate with no dimensions. */ + OBJECT_TYPE_POLYGON, /**< Filled polygon formed by an ordered series of points. */ + OBJECT_TYPE_POLYLINE, /**< Unfilled polygon formed by an ordered series of points. */ + OBJECT_TYPE_TEXT, /**< Text, or the visual representation of a string. */ + OBJECT_TYPE_TILE /**< Tile, referenced by a Global ID (GID), from a tileset known to the map. */ +} TmxObjectType; + +/** + * Identifiers for the possible horizontal alignments of text. + */ +typedef enum tmx_horizontal_alignment { + HORIZONTAL_ALIGNMENT_LEFT = 0, /**< Text is to be snapped to the left bound of its object. */ + HORIZONTAL_ALIGNMENT_CENTER, /**< Text is to be centered along the X axis of its object. */ + HORIZONTAL_ALIGNMENT_RIGHT, /**< Text is to be snapped to the right bound of its object. */ + HORIZONTAL_ALIGNMENT_JUSTIFY /**< Text is to be evenly spaced, per line, filling the object's width. */ +} TmxHorizontalAlignment; + +/** + * Identifiers for the possible vertical alignments of text. + */ +typedef enum tmx_vertical_alignment { + VERTICAL_ALIGNMENT_TOP = 0, /**< Text is to be snapped to the upper bound of its object. */ + VERTICAL_ALIGNMENT_CENTER, /**< Text is to be cnetered along the Y axis of its object. */ + VERTICAL_ALIGNMENT_BOTTOM /**< Text is to be snapped to the lower bound of its object. */ +} TmxVerticalAlignment; + +/** + * Identifiers for the possible map orientations. + */ +typedef enum tmx_orientation { + ORIENTATION_NONE = 0, /**< Orientation was not specified. Assumed to be orthogonal. */ + ORIENTATION_ORTHOGONAL, /**< Standard top-down view with rectanglular tiles. */ + ORIENTATION_ISOMETRIC, /**< Subset top-down view from a 45-degree angle. NOT supported. */ + ORIENTATION_STAGGERED, /**< Variation of isometric with staggered axes. */ + ORIENTATION_HEXAGONAL /**< Top-down view in which tiles are six-sided and alternative rows/columns are offset. */ +} TmxOrientation; + +/** + * Identifiers for the possible orders in which tiles in a tile layer are rendered/drawn. + */ +typedef enum tmx_render_order { + RENDER_ORDER_RIGHT_DOWN = 0, /**< Tiles are rendered by row, from left to right, then column, from top to bottom. */ + RENDER_ORDER_RIGHT_UP, /**< Tiles are rendered by row, from left to right, then column, from bottom to top. */ + RENDER_ORDER_LEFT_DOWN, /**< Tiles are rendered by row, from right to left, then column, from top to bottom. */ + RENDER_ORDER_LEFT_UP /**< Tiles are rendered by row, from right to left, then column, from bottom to top. */ +} TmxRenderOrder; + +/** + * Model of an <image> element. Defines an image and relevant attributes along with a loaded texture. + */ +typedef struct tmx_image { + char* source; /**< File name and/or path referencing the image on disk. */ + Color trans; /**< [optional] Color that defines is treated as transparent. Not currently implemented. */ + bool hasTrans; /**< When true, indicates 'trans' has been set with a color to be treated as transparent. */ + uint32_t width; /**< Width of the image in pixels. */ + uint32_t height; /**< Height of the image in pixels. */ + Texture2D texture; /**< The image as a raylib texture loaded into VRAM, if loading was successful. */ +} TmxImage; + +/** + * Model of a <layer> element when combined with the 'TmxLayer' model. Defines a tile layer with a fixed-size list of + * tile Global IDs (GIDs). + */ +typedef struct tmx_tile_layer { + uint32_t width; /**< Width of the layer in tiles. */ + uint32_t height; /**< Height of the layer in tiles. */ + char* encoding; /**< [optional] Encoding used to encode tiles. May be NULL, "base64," or "csv." */ + char* compression; /**< [optional] Compression used to compress tiles. May be NULL, "gzip," "zlib," or "zstd." */ + uint32_t* tiles; /**< Array of tile Global IDs (GIDs) contained by this tile layer. */ + uint32_t tilesLength; /**< Length of the 'tiles' array. */ +} TmxTileLayer; + +/** + * Contains the information needed to quickly draw a single line of a <text> element. + */ +typedef struct tmx_text_line { + char* content; /**< The string to be drawn. This may be the whole content of the parent string or partial. */ + Font font; /**< The raylib Font to be used when drawing. */ + Vector2 position; /**< Absolute position of this line. This is separate from its object layer's potential offset. */ + float spacing; /**< Spacing in pixels to be applied between each character when drawing. */ +} TmxTextLine; + +/** + * Model of a <text> element along with some pre-calculated objects for efficient drawing. + */ +typedef struct tmx_text { + char* fontFamily; /**< Font family (e.g. "sans-serif") to be used to render the text. */ + uint32_t pixelSize; /**< Size of the font in pixels. */ + bool wrap; /**< When true, indicates word wrapping should be used when appropriate. */ + Color color; /**< Color of the text. */ + bool bold; /**< When true, indicates the text should be bolded. */ + bool italic; /**< When true, indicates the text should be italicized. */ + bool underline; /**< When true, indicates the text should be underlined. */ + bool strikeOut; /**< When true, indicates the text should be struck/crossed out. */ + bool kerning; /**< When true, indicates kerning should be used when drawing. */ + TmxHorizontalAlignment halign; /**< Horizontal alignment of the text within its object. */ + TmxVerticalAlignment valign; /**< Vertical alignment of the text within its object. */ + char* content; /**< The string to be drawn. */ + TmxTextLine* lines; /**< Array of pre-calculated lines with all values needed to quickly draw this text. */ + uint32_t linesLength; /**< Length of the 'lines' array. */ +} TmxText; + +/** + * Model of a <property> element. Describes a property of the model it's attached to with a name, type, and value. + */ +typedef struct tmx_property { + TmxPropertyType type; /**< The specific (data) type of the property indicating which associated value to read. */ + char* name; /**< Name of the property. */ + char* stringValue; /**< The property's value for string-typed properties. */ + int32_t intValue; /**< The property's value for integer-typed properties. */ + float floatValue; /**< The property's value for floating point-typed properties. */ + bool boolValue; /**< The property's value for boolean-typed properties. */ + Color colorValue; /**< The property's value for color-typed properties. */ +} TmxProperty; + +/** + * Model of an <object> element within an <objectgroup> element. Objects are amorphous entities of varying type but all + * are potentially visible with positions and dimensions, although points' dimensions are effectively zero. + */ +typedef struct tmx_object { + TmxObjectType type; /**< The specific object type indicating which optional fields have relevant information. */ + uint32_t id; /**< Unique ID of the object. */ + char* name; /**< Name of the object. */ + char* typeString; /**< The type/class of the object. */ /* 'type' is a reserved keyword hence 'typeString' */ + double x; /**< X coordinate, in pixels, of the object. This is separate from its object layer's potential offset. */ + double y; /**< Y coordinate, in pixels, of the object. This is separate from its object layer's potential offset. */ + double width; /**< Width of the object in pixels. */ + double height; /**< Height of the object in pixels. */ + double rotation; /**< Rotation of the object in (clockwise) degrees around the object's (x, y) position. */ + uint32_t gid; /**< (Semi-optional) Global ID of a tile drawn as the object. If zero, the object is not a tile. */ + bool visible; /**< When true, indicates the object will be drawn. */ + char* templateString; /**< [optional] File name and/or path referencing an object template on disk applied to this + object. If NULL, no template is used. */ + Vector2* points; /**< [optional] Array of ordered points that define a poly(gon|line). Relative, not absolute. */ + uint32_t pointsLength; /**< Length of the 'points' array. */ + Vector2* drawPoints; /**< [optional] Array used as a buffer when drawing. Equal in length to the 'points' array. */ + TmxText* text; /**< [optional] Text to be drawn. */ + TmxProperty* properties; /**< Array of named, typed properties that apply to this object. */ + uint32_t propertiesLength; /**< Length of the 'properties' array. */ + Rectangle aabb; /**< Axis-Aligned Bounding Box (AABB). */ +} TmxObject; + +/** + * Model of an <objectgroup> element when combined with the 'TmxLayer' model. Defines an object layer of an arbitrary + * number of objects of varying types. + */ +typedef struct tmx_object_group { + /* uint32_t width; */ /**< Width of the object layer in tiles. TMX documentation describes it as "meaningless." */ + /* uint32_t height; */ /**< Height of the object layer in tiles. TMX documentation describes it as "meaningless." */ + Color color; /**< [optional] Color used to display objects within the layer. */ + bool hasColor; /**< When true, indicates 'color' has been set. */ + TmxObjectGroupDrawOrder drawOrder; /**< Indicates the order in which objects in this layer are drawn. */ + TmxObject* objects; /**< Array of objects contained by this object layer. */ + uint32_t objectsLength; /**< Length of the 'objects' array. */ + uint32_t* ySortedObjects; /**< Array of indexes of 'objects' sorted by the objects' y-coordinates. */ +} TmxObjectGroup; + +/** + * Model of an <imagelayer> element when combined with the 'TmxLayer' model. Defines a layer consisting of one image. + */ +typedef struct tmx_image_layer { + bool repeatX; /**< When true, indicates the image is repeated along the X axis. */ + bool repeatY; /**< When true, indicates the image is repeated along the Y axis. */ + TmxImage image; /**< Sole image of this layer. */ + bool hasImage; /**< When true, indicates 'image' has been set. Should always be true. */ +} TmxImageLayer; + +struct tmx_layer; /* Forward declaration of the following type. Contains children of the same type. */ + +/** + * Model of multiple layer elements: <layer>, <objectgroup>, <imagelayer>, or <group>. Defines a layer with attributes + * common to all, more-specific layer types. The more-specific attributes + */ +typedef struct tmx_layer { + TmxLayerType type; /**< The specific layer type indicating which associated layer ('exact') has mspecific values. */ + uint32_t id; /**< Unique integer ID of the layer. */ + char* name; /**< Name of the layer. */ + char* classString; /**< [optional] Class of the layer. If unused, defaults to an empty string. */ + bool visible; /**< When true, indicates the layer and its children will be drawn. */ + double opacity; /**< Opacity of the layer and its children where 0.0 means the layer is fully transparent. */ + Color tintColor; /**< [optional] Tint color applied to the layer and its children. */ + bool hasTintColor; /**< When true, indicates 'tintColor' has been set. */ + int32_t offsetX; /**< Horizontal offset of the layer and its children in pixels. */ + int32_t offsetY; /**< Vertical offset of the layer and its children in pixels. */ + double parallaxX; /**< Horizontal parallax factor. 1.0 means the layers position on the screen changes at the same + rate as the camera. 0.0 means the layer will not move with the camera. */ + double parallaxY; /**< Veritcal parallax factor. 1.0 means the layers position on the screen changes at the same + rate as the camera. 0.0 means the layer will not move with the camera. */ + TmxProperty* properties; /**< Array of named, typed properties that apply to this layer. */ + uint32_t propertiesLength; /**< Length of the 'properties' array. */ + struct tmx_layer* layers; /**< [optional] Array of child layers, may be NULL. Only used by group layers. */ + uint32_t layersLength; /**< Length of the 'layers' array. */ + union layer_type_union { + TmxTileLayer tileLayer; + TmxObjectGroup objectGroup; + TmxImageLayer imageLayer; + } exact; /**< Additional layer information specific to a tile, object, or image layer but not groups. */ +} TmxLayer; + +/** + * Model of a <frame> element. Defines a temporal frame of an animation with the Global ID (GID) of the tile to be + * displayed and the duration thereof. + */ +typedef struct tmx_animation_frame { + uint32_t gid; /**< The Global ID (GID) of a tile from the animation's tileset to be drawn for some duration. */ + float duration; /**< Duration in milliseconds that the frame should be displayed. */ +} TmxAnimationFrame; + +/** + * Model of an <animation> element. Defines a series of (tile) frames. + */ +typedef struct tmx_animation { + TmxAnimationFrame* frames; /**< Array of frames. These frames identify tiles and durations to be displayed. */ + uint32_t framesLength; /**< Length of the 'frames' array. */ +} TmxAnimation; + +/** + * Model of a <tile> element within a <tileset> element. Contains information about tiles that are not or cannot be + * implicitly determined from the tileset. + */ +typedef struct tmx_tileset_tile { + uint32_t id; /**< Local ID of the tile within its tileset. This is a factor in but different from its Global ID. */ + char* classString; /**< [optional] Class of the tile. If unused, defaults to an empty string. */ + int32_t x; /**< X coordinate, in pixels, of the sub-rectangle within the tileset's image to extract. */ + int32_t y; /**< Y coordinate, in pixels, of the sub-rectangle within the tileset's image to extract. */ + uint32_t width; /**< Width, in pixels, of the sub-rectangle within the tileset's image to extract. */ + uint32_t height; /**< Height, in pixels, of the sub-rectangle within the tileset's image to extract. */ + TmxImage image; /**< [optional] Image to be used as the tile for "collection of images" tilesets. */ + bool hasImage; /**< When true, indicates 'image' is set. */ + TmxAnimation animation; /**< [optional] Animation. Lists GIDs to be drawn temporarily and periodically. */ + bool hasAnimation; /**< When true, indicates 'animation' is assigned. */ + TmxProperty* properties; /**< Array of named, typed properties that apply to this tileset tile. */ + uint32_t propertiesLength; /**< Length of the 'properties' array. */ + TmxObjectGroup objectGroup; /**< [optional] 0+ objects representing collision information unique to the tile. */ +} TmxTilesetTile; + +/** + * Model of a <tileset> element. Defines an image, or serious of images, from which tiles are drawn along with + * information on how to extract areas from within the image and/or how to align them within an object. + */ +typedef struct tmx_tileset { + uint32_t firstGid; /**< First Global ID (GID) of a tile in this tileset. */ + uint32_t lastGid; /**< Last Global ID (GID) of a tile in this tileset. */ + char* source; /**< [optional] Source of this tileset, may be NULL. Only used for external tilesets. */ + char* name; /**< Name of the tileset. */ + char* classString; /**< [optional] Class of the tileset. If unused, defaults to an empty string. */ + uint32_t tileWidth; /**< Maximum, although typically exact, width of the tiles in this tileset in pixels. */ + uint32_t tileHeight; /**< Maximum, although typically exact, height of the tiles in this tileset in pixels. */ + uint32_t spacing; /**< Spacing in pixels between tiles in this tileset. */ + uint32_t margin; /**< Margin around the tiles in this tileset. */ + uint32_t tileCount; /**< Number of tiles in this tileset. Note: 'lastGid' - 'firstGid' is not always 'tileCount.' */ + uint32_t columns; /**< Number of tile columsn in this tileset. */ + TmxObjectAlignment objectAlignment; /**< Controls the alignment of tiles of this tileset when used as objects. */ + int32_t tileOffsetX; /**< Horizontal offset in pixels applied when drawing tiles from this tileset. */ + int32_t tileOffsetY; /**< Vertical offset in pixels applied when drawing tiles form this tileset. */ + TmxImage image; /**< [optional] Image from which this tilesets tiles are extracted. */ + bool hasImage; /**< When true, indicates 'image' is set. */ + TmxProperty* properties; /**< Array of named, typed properties that apply to this tileset. */ + uint32_t propertiesLength; /**< Length of the 'properties' array. */ + TmxTilesetTile* tiles; /**< Array of explicitly-defined tiles within the tileset. */ + uint32_t tilesLength; /**< Length of the 'tiles' array. */ +} TmxTileset; + +/** + * Contains the information and objects needed to quickly draw a <tile> in a raylib application. + */ +typedef struct tmx_tile { + uint32_t gid; /**< Global ID (GID) unique to the tile, used for lookups. 0 means the tile is effectively unused. */ + Rectangle sourceRect; /**< Sub-rectangle within a tileset to extract that is to be drawn. */ + Texture2D texture; /**< Texture in VRAM to be used to draw. May be used whole or as a source of a sub-rectangle. */ + Vector2 offset; /**< Offset in pixels to be applied to the tile, derived from the tileset. */ + TmxAnimation animation; /**< [optional] Animation. Lists GIDs to be drawn temporarily and periodically. */ + bool hasAnimation; /**< When true, indicates 'animation' is assigned. */ + uint32_t frameIndex; /**< For animations, the current animation frame to draw. */ + float frameTime; /**< For animations, an accumulator. The time, in seconds, the current frame has been drawn. */ + TmxObjectGroup objectGroup; /**< [optional] 0+ objects representing collision information unique to the tile. */ +} TmxTile; + +/** + * Model of a <map> element along with some pre-calculated objects for efficient drawing. + */ +typedef struct tmx_map { + char* fileName; /**< File name of the TMX file with extension. */ + TmxOrientation orientation; /**< Map orientation. May be orthogonal, isometric, staggered, or hexagonal. */ + TmxRenderOrder renderOrder; /**< Order in which tiles on tile layers are rendered. */ + uint32_t width; /**< Width of this map in tiles. */ + uint32_t height; /**< Height of htis map in tiles. */ + uint32_t tileWidth; /**< Width of a tile in pixels. */ + uint32_t tileHeight; /**< Height of a tile in pixels. */ + int32_t parallaxOriginX; /**< X coordinate, in pixels, of the parallax origin. */ + int32_t parallaxOriginY; /**< Y coordinate, in pixels, of hte parallax origin. */ + Color backgroundColor; /**< [optional] Background color to be drawn behind the map with its dimensions. */ + bool hasBackgroundColor; /**< When true, indicates 'backgroundColor' is set. */ + TmxProperty* properties; /**< Array of named, typed properties that apply to this map. */ + uint32_t propertiesLength; /**< Length of the 'properties' array. */ + TmxTileset* tilesets; /**< Array of tilesets used by the map. */ + uint32_t tilesetsLength; /**< Length of the 'tilesets' array. */ + TmxLayer* layers; /**< Array of layers and potential child layers that make up this map. */ + uint32_t layersLength; /**< Length of the 'layers' array. */ + TmxTile* gidsToTiles; /**< Array of pre-calculated tile metadata with all the values needed to quickly draw a tile + given its GID. Allocated such that gidsToTiles[1] returns the data of tile GID 1. */ + uint32_t gidsToTilesLength; /**< Length of the 'gidsToTiles' array. */ +} TmxMap; + +/** + * Given a path to TMX document, parse it and create an equivalent model that can be, among other uses, quickly drawn. + * This function allocates memory and loads textures into VRAM. To clean up, use UnloadTMX(). + * + * @param fileName File name and/or path referencing a TMX document on disk to be loaded. + * @return A model of the map as defined by the given TMX document, or NULL if loading failed for any reason. + */ +RAYTMX_DEC TmxMap* LoadTMX(const char* fileName); + +/** + * Unload a given map model by freeing memory allocations and unloading textures. In other words, free the resources + * reserved by LoadTMX(). + * + * @param map A previously-loaded map model to be freed/unloaded. + */ +RAYTMX_DEC void UnloadTMX(TmxMap* map); + +/** + * Draw the entirety of the given map at the given position. + * When a camera is also passed to this function, parallaxed scrolling can be applied to layers with parallax factors + * that are not 1.0 and the screen's surface can be known allowing for occlusion culling and the performance gains that + * come with it. + * The given tint is applied to map and its layers. When layers have their own tints, the two colors are combined. If no + * tint is needed, passing WHITE effectively means no tint is applied. + * + * @param map A loaded map model to be drawn in whole at the given coordinates. + * @param camera [optional] Camera2D to be used for parallax and/or occlusion. Required for parallax. 'viewport' takes + * priority for occlusion. + * @param viewport [optional] Region drawn to. Used for occlusion. Only tiles, objects, etc. in this region are drawn. + * @param posX X coordinate at which to draw the map. This corresponds to the top-left corner of the map. + * @param posY Y coordinate at which to draw the map. This corresponds to the top-left corner of the map. + * @param tint A tint to be applied to the map and its layers. This tint is combined with any individual layer tints. + */ +RAYTMX_DEC void DrawTMX(const TmxMap* map, const Camera2D* camera, const Rectangle* viewport, int posX, int posY, + Color tint); + +/** + * Draw the given layers at the given position. + * When a camera is also passed to this function, parallaxed scrolling can be applied to layers with parallax factors + * that are not 1.0 and the screen's surface can be known allowing for occlusion culling and the performance gains that + * come with it. + * The given tint is applied to the layers. When layers have their own tints, the two colors are combined. If no tint is + * needed, passing WHITE effectively means no tint is applied. + * + * @param map A loaded map model whose layers are to be drawn. + * @param camera [optional] Camera2D to be used for parallax and/or occlusion. Required for parallax. 'viewport' takes + * priority for occlusion. + * @param viewport [optional] Region drawn to. Used for occlusion. Only tiles, objects, etc. in this region are drawn. + * @param layers An array of select layers to be drawn. + * @param layersLength Length of the given array of layers. + * @param posX X coordinate at which to draw the layers. This corresponds to the top-left corner of the layers. + * @param posY Y coordinate at which to draw the layers. This corresponds to the top-left corner of the layers. + * @param tint A tint to be applied to the layers. This tint is combined with any individual layer tints. + */ +RAYTMX_DEC void DrawTMXLayers(const TmxMap* map, const Camera2D* camera, const Rectangle* viewport, + const TmxLayer* layers, uint32_t layersLength, int posX, int posY, Color tint); + +/** + * Progress the animations of the given map in real-time. This is intended to be called once per frame, or once per + * BeginDrawing() an EndDrawing() call. If called more or less frequently, animation speeds will be affected. + * + * @param map A loaded map model to be animated. + */ +RAYTMX_DEC void AnimateTMX(TmxMap* map); + +/** + * Check for collisions between two objects of arbitrary type. Objects that are not primitive shapes, namely text and + * tiles, are treated as rectangles. + * + * @param object1 A TMX <object> to be checked for a collision. + * @param object2 Another TMX <object> to be checked for a collision. + * @return True if the given objects collide with one another, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXObjects(TmxObject object1, TmxObject object2); + +/** + * Check for collisions between the given tile or group layers and the given rectangle. The tiles must have collision + * information created with the Tiled Collision Editor. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param map A loaded map model containing the given layers. + * @param layers An array of select tile or group layers to be checked for collisions. + * @param layersLength Length of the given array of layers. + * @param rec The rectangle to perform collision checks on. + * @param outputObject Output parameter assigned with the object the rectangle collided with. NULL if not wanted. + * @return True if the given rectangle collides with any tile in the given layers, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXTileLayersRec(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Rectangle rec, TmxObject* outputObject); + +/** + * Check for collisions between the given tile or group layers and the given circle. The tiles must have collision + * information created with the Tiled Collision Editor. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param map A loaded map model containing the given layers. + * @param layers An array of select tile or group layers to be checked for collisions. + * @param layersLength Length of the given array of layers. + * @param center The center point of the circle. + * @param radius The radius of the circle. + * @param outputObject Output parameter assigned with the object the circle collided with. NULL if not wanted. + * @return True if the given circle collides with any tile in the given layers, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXTileLayersCircle(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2 center, float radius, TmxObject* outputObject); + +/** + * Check for collisions between the given tile or group layers and the given point. The tiles must have collision + * information created with the Tiled Collision Editor. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param map A loaded map model containing the given layers. + * @param layers An array of select tile or group layers to be checked for collisions. + * @param layersLength Length of the given array of layers. + * @param point The point to perform collision checks on. + * @param outputObject Output parameter assigned with the object the point collided with. NULL if not wanted. + * @return True if the given point collides with any tile in the given layers, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXTileLayersPoint(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2 point, TmxObject* outputObject); + +/** + * Check for collisions between the given tile or group layers and the given polygon. The tiles must have collision + * information created with the Tiled Collision Editor. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * This function calculates the Axis-Aligned Bounding Box (AABB) of the polygon each time it's called. If the polygon's + * AABB is known, CheckCollisionTMXLayersPolyEx() can be used for better performance. + * + * @param map A loaded map model containing the given layers. + * @param layers An array of select tile or group layers to be checked for collisions. + * @param layersLength Length of the given array of layers. + * @param points An array of vertices defining the polygon. No repeats. + * @param pointCount The length of the array of vertices. + * @param outputObject Output parameter assigned with the object the polygon collided with. NULL if not wanted. + * @return True if the given polygon collides with any tile in the given layers, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXLayersPoly(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2* points, int pointCount, TmxObject* outputObject); + +/** + * Check for collisions between the given tile or group layers and the given polygon with the given Axis-Aligned + * Bounding Box (AABB). The tiles must have collision information created with the Tiled Collision Editor. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param map A loaded map model containing the given layers. + * @param layers An array of select tile or group layers to be checked for collisions. + * @param layersLength Length of the given array of layers. + * @param points An array of vertices defining the polygon. No repeats. + * @param pointCount The length of the array of vertices. + * @param aabb Bounding box of the polygon. Used for quicker, broad collision checks. + * @param outputObject Output parameter assigned with the object the polygon collided with. NULL if not wanted. + * @return True if the given polygon collides with any tile in the given layers, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXLayersPolyEx(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2* points, int pointCount, Rectangle aabb, TmxObject* outputObject); + +/** + * Check for collisions between the given object group, with 0+ objects of arbitrary shape, and the given rectangle. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param group The object group whose 0+ objects will be checked for collisions. + * @param rec The rectangle to perform collision checks on. + * @param outputObject Output parameter assigned with the object the rectangle collided with. NULL if not wanted. + * @return True if the given rectangle collides with any object in the object group, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXObjectGroupRec(TmxObjectGroup group, Rectangle rec, TmxObject* outputObject); + +/** + * Check for collisions between the given object group, with 0+ objects of arbitrary shape, and the given circle. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param group The object group whose 0+ objects will be checked for collisions. + * @param center The center point of the circle. + * @param radius The radius of the circle. + * @param outputObject Output parameter assigned with the object the circle collided with. NULL if not wanted. + * @return True if the given circle collides with any object in the object group, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXObjectGroupCircle(TmxObjectGroup group, Vector2 center, float radius, + TmxObject* outputObject); + +/** + * Check for collisions between the given object group, with 0+ objects of arbitrary shape, and the given point. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param group The object group whose 0+ objects will be checked for collisions. + * @param point The point to perform collision checks on. + * @param outputObject Output parameter assigned with the object the point collided with. NULL if not wanted. + * @return True if the given point collides with any object in the object group, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXObjectGroupPoint(TmxObjectGroup group, Vector2 point, TmxObject* outputObject); + +/** + * Check for collisions between the given object group, with 0+ objects of arbitrary shape, and the given polygon. + * This function calculates the Axis-Aligned Bounding Box (AABB) of the polygon each time it's called. If the polygon's + * AABB is known, CheckCollisionTMXObjectGroupPolyEx() can be used for better performance. + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param group The object group whose 0+ objects will be checked for collisions. + * @param points An array of vertices defining the polygon. No repeats. + * @param pointCount The length of the array of vertices. + * @param outputObject Output parameter assigned with the object the polygon collided with. NULL if not wanted. + * @return True if the given polygon collides with any object in the object group, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXObjectGroupPoly(TmxObjectGroup group, Vector2* points, int pointCount, + TmxObject* outputObject); + +/** + * Check for collisions between the given object group, with 0+ objects of arbitrary shape, and the given polygon with + * the given Axis-Aligned Bound Box (AABB). + * Note: This function assumes the map is positioned at (0, 0). If the map is drawn with an offset, normalize. + * + * @param group The object group whose 0+ objects will be checked for collisions. + * @param points An array of vertices defining the polygon. No repeats. + * @param pointCount The length of the array of vertices. + * @param aabb Bounding box of the polygon. Used for quicker, broad collision checks. + * @param outputObject Output parameter assigned with the object the polygon collided with. NULL if not wanted. + * @return True if the given polygon collides with any object in the object group, or false if there is no collision. + */ +RAYTMX_DEC bool CheckCollisionTMXObjectGroupPolyEx(TmxObjectGroup group, Vector2* points, int pointCount, + Rectangle aabb, TmxObject* outputObject); + +/** + * Set a custom callback in place of raylib's LoadTexture(). The callback must return a Texture2D and take a const char* + * as the sole parameter. To unset, pass NULL to this function. + * + * @param callback A function pointer with a "Texture2D CustLoadTexture(const char* fileName)" signature, or NULL if + * unsetting the custom callback. + */ +RAYTMX_DEC void SetLoadTextureTMX(LoadTextureCallback callback); + +/** + * Log properties of the given map as a formatted string. + * SetTraceLogFlagsTMX() may be used to exclude select information. + * + * @param logLevel The level/severity with which to log the string (e.g. LOG_DEBUG, LOG_INFO, etc.). + * @param map A loaded map to be logged. + */ +RAYTMX_DEC void TraceLogTMX(int logLevel, const TmxMap* map); + +/** + * Globally set logging options for TraceLogTMX() allowing for select types of information to be excluded. + * The flags used by this function are defined in the tmx_log_flags enumeration. + * + * @param logFlags Logically OR'd bit flags to be applied to all logging following this call. + */ +RAYTMX_DEC void SetTraceLogFlagsTMX(int logFlags); + +#ifdef __cplusplus + } +#endif /* __cplusplus */ + +#ifdef RAYTMX_IMPLEMENTATION + +#ifndef HOXML_IMPLEMENTATION + #define HOXML_IMPLEMENTATION +#endif +#include "hoxml.h" + +/******************/ +/* Implementation */ + +#define TMX_LINE_THICKNESS 3.0f /* Thickness, in pixels, that outlines of specific objects are drawn with */ + +/* Bit flags that GIDs may be masked with in order to indicate transformations for individual tiles */ +enum tmx_flip_flags { + FLIP_FLAG_HORIZONTAL = 0x80000000, + FLIP_FLAG_VERTICAL = 0x40000000, + FLIP_FLAG_DIAGONAL = 0x20000000, + FLIP_FLAG_ROTATE_120 = 0x10000000 +}; + +typedef enum raytmx_document_format { + FORMAT_TMX = 0, /* Tilemap with tilesets, layers, etc. */ + FORMAT_TSX, /* External tilesets */ + FORMAT_TX /* Object templates */ +} RaytmxDocumentFormat; + +typedef struct raytmx_external_tileset { + TmxTileset tileset; + bool isSuccess; /* 'isSuccess' is true when the external tileset was successfully loaded */ +} RaytmxExternalTileset; + +typedef struct raytmx_object_template { + TmxTileset tileset; + TmxObject object; + bool isSuccess, hasTileset; /* 'isSuccess' is true when the object template was successfully loaded */ +} RaytmxObjectTemplate; + +struct raytmx_cached_texture; /* Forward declaration */ +typedef struct raytmx_cached_texture { + char* fileName; + Texture2D texture; + struct raytmx_cached_texture* next; +} RaytmxCachedTextureNode; /* Associates a file name with a Texture2D allowing for the reuse of textures in VRAM */ + +struct raytmx_cached_template; /* Forward declaration */ +typedef struct raytmx_cached_template { + char* fileName; + RaytmxObjectTemplate objectTemplate; + struct raytmx_cached_template* next; +} RaytmxCachedTemplateNode; /* Associates a file name with an object template */ + +struct raytmx_property_node; /* Forward declaration */ +typedef struct raytmx_property_node { + TmxProperty property; + struct raytmx_property_node* next; +} RaytmxPropertyNode; + +struct raytmx_tileset_node; /* Forward declaration */ +typedef struct raytmx_tileset_node { + TmxTileset tileset; + struct raytmx_tileset_node* next; +} RaytmxTilesetNode; + +struct raytmx_tileset_tile_node; /* Forward declaration */ +typedef struct raytmx_tileset_tile_node { + TmxTilesetTile tile; + struct raytmx_tileset_tile_node* next; +} RaytmxTilesetTileNode; + +struct raytmx_animation_frame_node; /* Forward declaration */ +typedef struct raytmx_animation_frame_node { + TmxAnimationFrame frame; + struct raytmx_animation_frame_node* next; +} RaytmxAnimationFrameNode; + +struct raytmx_layer_node; /* Forward declaration */ +typedef struct raytmx_layer_node { + TmxLayer layer; + uint32_t childrenLength; + struct raytmx_layer_node *next, *parent, *childrenRoot, *childrenTail; +} RaytmxLayerNode; + +struct raytmx_tile_layer_tile_node; /* Forward declaration */ +typedef struct raytmx_tile_layer_tile_node { + uint32_t gid; + struct raytmx_tile_layer_tile_node* next; +} RaytmxTileLayerTileNode; + +struct raytmx_object_node; /* Forward declaration */ +typedef struct raytmx_object_node { + TmxObject object; + struct raytmx_object_node* next; +} RaytmxObjectNode; + +struct raytmx_object_sorting_node; /* Forward declaration */ +typedef struct raytmx_object_sorting_node { + double y; + uint32_t index; + struct raytmx_object_sorting_node* next; +} RaytmxObjectSortingNode; + +struct raytmx_poly_point_node; /* Forward declaration */ +typedef struct raytmx_poly_point_node { + Vector2 point; + struct raytmx_poly_point_node* next; +} RaytmxPolyPointNode; + +struct raytmx_text_line_node; /* Forward declaration */ +typedef struct raytmx_text_line_node { + TmxTextLine line; + struct raytmx_text_line_node* next; +} RaytmxTextLineNode; + +typedef struct raytmx_state { + RaytmxDocumentFormat format; + char documentDirectory[512]; + bool isSuccess; + + /* Variables intended for TMX (map) parsing */ + RaytmxCachedTextureNode* texturesRoot; + RaytmxCachedTemplateNode* templatesRoot; + TmxOrientation mapOrientation; + TmxRenderOrder mapRenderOrder; + uint32_t mapWidth, mapHeight, mapTileWidth, mapTileHeight, mapPropertiesLength; + int32_t mapParallaxOriginX, mapParallaxOriginY; + Color mapBackgroundColor; + bool mapHasBackgroundColor; + TmxProperty* mapProperties; + + /* These variables, when not NULL, are assigned to the current element(s) being parsed */ + TmxProperty* property; + TmxTileset* tileset; + TmxImage* image; + TmxTilesetTile* tilesetTile; + TmxAnimationFrame* animationFrame; + /* TmxWangSet* wangSet; */ /* TODO: Wang sets. Low priority. */ + /* TmxWangColor* wangColor; */ /* TODO: Wang sets. Low priority. */ + TmxLayer* layer; + TmxTileLayer* tileLayer; + TmxObjectGroup* objectGroup; + TmxImageLayer* imageLayer; + TmxObject* object; + + /* These variables are linked lists containing various elements where an arbitrary amount are allowed, such as */ + /* 1+ <object> elements in an <objectgroup>, that will be copied to arrays of known sizes later on */ + RaytmxPropertyNode *propertiesRoot, *propertiesTail; + RaytmxTilesetNode *tilesetsRoot, *tilesetsTail; + RaytmxTilesetTileNode *tilesetTilesRoot, *tilesetTilesTail; + RaytmxAnimationFrameNode *animationFramesRoot, *animationFramesTail; + RaytmxLayerNode *layersRoot, *layersTail, *groupNode; + RaytmxTileLayerTileNode *layerTilesRoot, *layerTilesTail; + RaytmxObjectNode *objectsRoot, *objectsTail; + uint32_t tilesetsLength, tilesetTilesLength, animationFramesLength, propertiesLength, layersLength, + layerTilesLength, objectsLength, propertiesDepth; +} RaytmxState; /* Intermediate data used internally to parse TMX (map), TSX (tileset), and TX (template) files */ + +typedef struct raytmx_transform { + Vector2 position; + Vector2 parallax; + Vector2 cameraOffset; +} RaytmxTransform; + +RaytmxExternalTileset LoadTSX(const char* fileName); +RaytmxObjectTemplate LoadTX(const char* fileName); +void ParseDocument(RaytmxState* raytmxState, const char* fileName); +void HandleElementBegin(RaytmxState* raytmxState, hoxml_context_t* hoxmlContext); +void HandleAttribute(RaytmxState* raytmxState, hoxml_context_t* hoxmlContext); +void HandleElementEnd(RaytmxState* raytmxState, hoxml_context_t* hoxmlContext); +void FreeState(RaytmxState* raytmxState); +void FreeString(char* str); +void FreeTileset(TmxTileset tileset); +void FreeProperty(TmxProperty property); +void FreeLayer(TmxLayer layer); +void FreeObject(TmxObject object); +bool IterateTileLayer(const TmxMap* map, const TmxTileLayer* layer, Rectangle viewport, RaytmxTransform transform, + uint32_t* rawGid, TmxTile* tile, Rectangle* tileRect); +void DrawTMXLayersInternal(const TmxMap* map, const Camera2D* camera, const Rectangle* viewport, const TmxLayer* layers, + uint32_t layersLength, RaytmxTransform transform, Color tint); +void DrawTMXTileLayer(const TmxMap* map, Rectangle viewport, TmxLayer layer, RaytmxTransform transform, Color tint); +void DrawTMXLayerTile(const TmxMap* map, Rectangle viewport, uint32_t rawGid, Rectangle destRect, Color tint); +void DrawTMXObjectTile(const TmxMap* map, Rectangle viewport, uint32_t rawGid, RaytmxTransform transform, float width, + float height, Color tint); +void DrawTMXObjectGroup(const TmxMap* map, Rectangle viewport, TmxLayer layer, RaytmxTransform transform, Color tint); +void DrawTMXImageLayer(const TmxMap* map, Rectangle viewport, TmxLayer layer, RaytmxTransform transform, Color tint); +bool CheckCollisionTMXTileLayerObject(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + TmxObject object, TmxObject* outputObject); +bool CheckCollisionTMXObjectGroupObject(TmxObjectGroup group, TmxObject object, TmxObject* outputObject); +void TraceLogTMXTilesets(int logLevel, TmxOrientation orientation, TmxTileset* tilesets, uint32_t tilesetsLength, + int numSpaces); +void TraceLogTMXProperties(int logLevel, TmxProperty* properties, uint32_t propertiesLength, int numSpaces); +void TraceLogTMXLayers(int logLevel, TmxLayer* layers, uint32_t layersLength, int numSpaces); +void TraceLogTMXObject(int logLevel, TmxObject object, int numSpaces); +void StringCopy(char* destination, const char* source); +TmxProperty* AddProperty(RaytmxState* raytmxState); +void AddTileLayerTile(RaytmxState* raytmxState, uint32_t gid); +TmxTileset* AddTileset(RaytmxState* raytmxState); +TmxTilesetTile* AddTilesetTile(RaytmxState* raytmxState); +TmxAnimationFrame* AddAnimationFrame(RaytmxState* raytmxState); +TmxLayer* AddGenericLayer(RaytmxState* raytmxState, bool isGroup); +TmxObject* AddObject(RaytmxState* raytmxState); +void AppendLayerTo(TmxMap* map, RaytmxLayerNode* groupNode, RaytmxLayerNode* layersRoot, uint32_t layersLength); +RaytmxCachedTextureNode* LoadCachedTexture(RaytmxState* raytmxState, const char* fileName); +RaytmxCachedTemplateNode* LoadCachedTemplate(RaytmxState* raytmxState, const char* fileName); +Color GetColorFromHexString(const char* hex); +uint32_t GetGid(uint32_t rawGid, bool* isFlippedHorizontally, bool* isFlippedVertically, bool* isFlippedDiagonally, + bool* isRotatedHexagonal120); +void* MemAllocZero(unsigned int size); +char* GetDirectoryPath2(const char* filePath); +char* JoinPath(const char* prefix, const char* suffix); +void StringCopyN(char* destination, const char* source, size_t number); +void StringConcatenate(char* destination, const char* source); + +/**********************************************************************************************************************/ +/* Public implementation. */ + +RAYTMX_DEC TmxMap* LoadTMX(const char* fileName) { + RaytmxState raytmxState[1]; + memset(raytmxState, 0, sizeof(RaytmxState)); /* Initialize all values to zero, NULL, or an equivalent enum value */ + raytmxState->format = FORMAT_TMX; + + /* Initialize the map object */ + TmxMap* map = (TmxMap*)MemAllocZero(sizeof(TmxMap)); + + /* Do format-agnostic parsing of the document. The state object will be populated with raytmx's models of the */ + /* equivalent TMX, TSX, and/or TX elements. */ + ParseDocument(raytmxState, fileName); + if (!raytmxState->isSuccess) { + UnloadTMX(map); + return NULL; + } + + /* Copy some top-level map properties */ + map->fileName = (char*)MemAllocZero((unsigned int)strlen(fileName) + 1); + StringCopy(map->fileName, GetFileName(fileName)); + map->orientation = raytmxState->mapOrientation; + map->renderOrder = raytmxState->mapRenderOrder; + map->width = raytmxState->mapWidth; + map->height = raytmxState->mapHeight; + map->tileWidth = raytmxState->mapTileWidth; + map->tileHeight = raytmxState->mapTileHeight; + map->backgroundColor = raytmxState->mapBackgroundColor; + map->parallaxOriginX = raytmxState->mapParallaxOriginX; + map->parallaxOriginY = raytmxState->mapParallaxOriginY; + map->hasBackgroundColor = raytmxState->mapHasBackgroundColor; + + uint32_t gidsToTilesLength = 0; /* Can also be seen as the last GID */ + if (raytmxState->tilesetsRoot != NULL) { /* If there is at least one tileset */ + /* Allocate the array of tilesets and zeroize every index */ + TmxTileset* tilesets = (TmxTileset*)MemAllocZero(sizeof(TmxTileset) * raytmxState->tilesetsLength); + /* Copy the TmxTileset pointers into the array */ + RaytmxTilesetNode* tilesetIterator = raytmxState->tilesetsRoot; + for (uint32_t i = 0; tilesetIterator != NULL; i++) { + TmxTileset tileset = tilesetIterator->tileset; + + if (tileset.hasImage) { /* If the tileset has a shared image and implicitly defines tiles */ + /* These tilesets implicitly have X tiles where X = <width in tiles> * <height in tiles>. But even */ + /* these tilesets may have explicitly defined tiles for things like animations, or anything else. We */ + /* need to know the greatest ID of those explicit tiles because they are allowed to have IDs that */ + /* exceed the tileset's tile count and this affects global IDs, even in other tilesets. */ + uint32_t greatestID = 0; + for (uint32_t i = 0; i < tileset.tilesLength; i++) + { + if (greatestID < tileset.tiles[i].id) + greatestID = tileset.tiles[i].id; + } + /* Determine the last GID, meaning the greatest GID value, from the greatest local ID and tile count */ + if (greatestID >= tileset.tileCount) + tileset.lastGid = tileset.firstGid + greatestID; + else + tileset.lastGid = tileset.firstGid + tileset.tileCount - 1; + } else if (tileset.tilesLength > 0) /* If the tileset is a "collection of images" with explicit tiles */ + tileset.lastGid = tileset.firstGid + tileset.tiles[tileset.tilesLength - 1].id - 1; + + if (gidsToTilesLength < tileset.lastGid + 1) + gidsToTilesLength = tileset.lastGid + 1; /* GIDs start at 1 so the length is the last GID + 1 */ + tilesets[i] = tileset; + tilesetIterator = tilesetIterator->next; + } + /* Add the tilesets array to the map */ + map->tilesets = tilesets; + map->tilesetsLength = raytmxState->tilesetsLength; + } else + TraceLog(LOG_WARNING, "RAYTMX: The map does not contain any tilesets"); + + if (raytmxState->layersRoot != NULL) { /* If there is at least one layer within the map */ + /* Due to the existence of <group> layers, layers can have children of multiple generations. To form the */ + /* resulting tree-like structure, recursion is used. */ + AppendLayerTo(map, NULL, raytmxState->layersRoot, raytmxState->layersLength); + } else + TraceLog(LOG_WARNING, "RAYTMX: The map does not contain any layers"); + + if (gidsToTilesLength > 0) { + TmxTile* gidsToTiles = (TmxTile*)MemAllocZero(sizeof(TmxTile) * gidsToTilesLength); + + for (uint32_t i = 0; i < map->tilesetsLength; i++) { + TmxTileset* tileset = &map->tilesets[i]; + if (tileset->hasImage) { /* If the tileset has a shared image (i.e. not a "collection of images") */ + /* First, iterate through the explicit tiles. These are explicitly defined with <tile> elements and */ + /* are used to, among other things, provide animations and specific source rectangles. Note: Their */ + /* IDs may exceed the tileset's tile count. */ + for (uint32_t j = 0; j < tileset->tilesLength; j++) { + TmxTilesetTile tilesetTile = tileset->tiles[j]; + uint32_t gid = tileset->firstGid + tilesetTile.id; + if (tilesetTile.hasAnimation) { /* If the tile is meta, pointing to a series of other tiles */ + gidsToTiles[gid].hasAnimation = true; + gidsToTiles[gid].animation = tilesetTile.animation; + /* Frames' tile (G)IDs are initially set with local values. Now that all tilesets are known */ + /* and this tileset's first global ID is available, update the ID to be global. */ + for (uint32_t k = 0; k < gidsToTiles[gid].animation.framesLength; k++) + gidsToTiles[gid].animation.frames[k].gid += tileset->firstGid; + } + if (tilesetTile.x != 0 || tilesetTile.y != 0 || tilesetTile.width != 0 || tilesetTile.height != 0) { + /* This tile directly tells us the area within the tileset's image to use when drawing, */ + /* overriding the implicit dimensions derived from the map's tile width and height. */ + gidsToTiles[gid].sourceRect.x = (float)tilesetTile.x; + gidsToTiles[gid].sourceRect.y = (float)tilesetTile.y; + gidsToTiles[gid].sourceRect.width = (float)tilesetTile.width; + gidsToTiles[gid].sourceRect.height = (float)tilesetTile.height; + } + /* Tiles may have child object groups. These objects are a form of collision information. The */ + /* object group may be empty or may have objects. A simple assignment covers both. */ + gidsToTiles[gid].objectGroup = tilesetTile.objectGroup; + gidsToTiles[gid].gid = gid; /* Tell the tile its GID */ + } /* for (uint32_t j = 0; j < tileset->tilesLength; j++) */ + /* Second, loop through the implicit tiles. These are inferred from knowing the dimensions of the */ + /* tileset's image, dimensiosn of tiles, and the (right-down) order of tiles within the image. */ + for (uint32_t id = 0; id < tileset->tileCount; id++) { + uint32_t gid = id + tileset->firstGid, x = id % tileset->columns, y = id / tileset->columns; + gidsToTiles[gid].gid = gid; /* Tell the tile its GID */ + /* If that source renctangle within the image was NOT explicitly defined. */ + /* Note: Float comparisons like this are typically unreliable but the GIDs-to-tiles array is */ + /* initialized with zeroes making this accurate. */ + if (gidsToTiles[gid].sourceRect.x == 0.0f && gidsToTiles[gid].sourceRect.y == 0.0f && + gidsToTiles[gid].sourceRect.width == 0.0f && gidsToTiles[gid].sourceRect.height == 0.0f) { + /* Calculate the area within the texture to be drawn from contextual information */ + gidsToTiles[gid].sourceRect.x = (float)(tileset->margin + (x * tileset->tileWidth) + + (x * tileset->spacing)); + gidsToTiles[gid].sourceRect.y = (float)(tileset->margin + (y * tileset->tileHeight) + + (y * tileset->spacing)); + gidsToTiles[gid].sourceRect.width = (float)tileset->tileWidth; + gidsToTiles[gid].sourceRect.height = (float)tileset->tileHeight; + } + gidsToTiles[gid].texture = tileset->image.texture; + gidsToTiles[gid].offset.x = (float)tileset->tileOffsetX; + gidsToTiles[gid].offset.y = (float)tileset->tileOffsetY; + } /* for (uint32_t id = 0; id < tileset->tileCount; id++) */ + } else { /* If the tileset is a collection of images where each tile has its own image */ + for (uint32_t j = 0; j < tileset->tilesLength; j++) { + TmxTilesetTile tilesetTile = tileset->tiles[j]; + if (!tilesetTile.hasImage) { + TraceLog(LOG_WARNING, "RAYTMX: Skipping tile %d of image collection tileset \"%s\" because " + "it has no image", tilesetTile.id, tileset->name); + continue; + } + + int32_t gid = tileset->firstGid + tilesetTile.id; + gidsToTiles[gid].gid = gid; + gidsToTiles[gid].sourceRect.x = (float)tilesetTile.x; /* Defaults to and probably is zero */ + gidsToTiles[gid].sourceRect.y = (float)tilesetTile.y; /* Defaults to and probably is zero */ + if (tilesetTile.width != tilesetTile.image.width) + gidsToTiles[gid].sourceRect.width = (float)tilesetTile.width; + else + gidsToTiles[gid].sourceRect.width = (float)tilesetTile.image.width; + if (tilesetTile.height != tilesetTile.image.height) + gidsToTiles[gid].sourceRect.height = (float)tilesetTile.height; + else + gidsToTiles[gid].sourceRect.height = (float)tilesetTile.image.height; + gidsToTiles[gid].texture = tilesetTile.image.texture; + } + } + } + + map->gidsToTiles = gidsToTiles; + map->gidsToTilesLength = gidsToTilesLength; + } /* gidsToTilesLength > 0 */ + + /* Free the linked lists and zeroize related values */ + FreeState(raytmxState); + + return map; +} + +RAYTMX_DEC void UnloadTMX(TmxMap* map) { + if (map == NULL) + return; + + if (map->fileName != NULL) + MemFree(map->fileName); + + if (map->properties != NULL) { + for (uint32_t i = 0; i < map->propertiesLength; i++) + FreeProperty(map->properties[i]); + MemFree(map->properties); + } + + if (map->tilesets != NULL) { + for (uint32_t i = 0; i < map->tilesetsLength; i++) + FreeTileset(map->tilesets[i]); + MemFree(map->tilesets); + } + + if (map->layers != NULL) { + for (uint32_t i = 0; i < map->layersLength; i++) + FreeLayer(map->layers[i]); + MemFree(map->layers); + } + + if (map->gidsToTiles != NULL) + MemFree(map->gidsToTiles); + + MemFree(map); +} + +RAYTMX_DEC void DrawTMX(const TmxMap* map, const Camera2D* camera, const Rectangle* viewport, int posX, int posY, + Color tint) { + if (map == NULL) + return; + + if (map->hasBackgroundColor) { + Rectangle backgroundRect; + if (viewport != NULL) + backgroundRect = *viewport; + else { + backgroundRect.x = (float)posX; + backgroundRect.y = (float)posY; + backgroundRect.width = (float)(map->width * map->tileWidth); + backgroundRect.height = (float)(map->height * map->tileHeight); + } + + DrawRectangleRec(/* rec: */ backgroundRect, /* color: */ map->backgroundColor); + } + + DrawTMXLayers(map, camera, viewport, map->layers, map->layersLength, posX, posY, tint); +} + +RAYTMX_DEC void DrawTMXLayers(const TmxMap* map, const Camera2D* camera, const Rectangle* viewport, + const TmxLayer* layers, uint32_t layersLength, int posX, int posY, Color tint) +{ + /* Pack some position and related information into an object to pass to various functions. At a minimum, this */ + /* will determine the position each layer is drawn at. With a camera, this will also be used for parallax. */ + RaytmxTransform transform = + { + .position = (Vector2){ .x = (float)posX, .y = (float)posY }, + .parallax = (Vector2){ .x = 1.0f, .y = 1.0f }, + .cameraOffset = (Vector2){ .x = 0.0, .y = 0.0f } + }; + + if (map != NULL && camera != NULL) /* If the map, with its parallax origin, and a camera are available */ + { + /* Calculate the camera's offset, or distance, from the parallax origin. This origin is the reference point */ + /* for parallax scrolling and this offset determines how much a layer will scroll as the camera moves. */ + transform.cameraOffset = (Vector2) + { + .x = camera->target.x - map->parallaxOriginX, + .y = camera->target.y - map->parallaxOriginY + }; + } + + DrawTMXLayersInternal(map, camera, viewport, layers, layersLength, transform, tint); +} + +RAYTMX_DEC void AnimateTMX(TmxMap* map) { + if (map == NULL) + return; + + float dt = GetFrameTime(); /* Returns the duration, in seconds, of the last frame drawn */ + /* Iterate through the tiles, searching for those that are animations */ + for (uint32_t gid = 0; gid < map->gidsToTilesLength; gid++) { + TmxTile* tile = &map->gidsToTiles[gid]; /* A pointer is used in case the frame time needs to be reassigned */ + /* If the GID maps to a valid tile, that tile is an animation, and the bounds check passes */ + if (tile->gid > 0 && tile->hasAnimation && tile->frameIndex < tile->animation.framesLength) { + tile->frameTime += dt; + /* If the current frame has been displayed for its whole duration, or longer */ + if (tile->frameTime > tile->animation.frames[tile->frameIndex].duration) { + tile->frameTime -= tile->animation.frames[tile->frameIndex].duration; + /* Increment the frame index to display the next one... */ + tile->frameIndex += 1; + /* ...unless the last frame was "last" in both senses */ + if (tile->frameIndex == tile->animation.framesLength) + tile->frameIndex = 0; /* Wrap around to the first frame */ + } + } + } +} + +/** + * Helper function that creates a TmxObject equivalent to the given rectangle. + * + * @param rec A rectangle as raylib's Rectangle type. + * @return An equivalent TmxObject. + */ +TmxObject CreateRectangularTMXObject(Rectangle rec) { + TmxObject recAsObject; + memset(&recAsObject, 0, sizeof(TmxObject)); /* Zero initialize */ + + recAsObject.type = OBJECT_TYPE_RECTANGLE; + recAsObject.x = (double)rec.x; + recAsObject.y = (double)rec.y; + recAsObject.width = (double)rec.width; + recAsObject.height = (double)rec.height; + recAsObject.aabb = rec; + + return recAsObject; +} + +RAYTMX_DEC bool CheckCollisionTMXTileLayersRec(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Rectangle rec, TmxObject* outputObject) { + if (map == NULL || layers == NULL || layersLength == 0) + return false; + + /* Check the rectangle against objects associated with tiles in the layers for collisions */ + return CheckCollisionTMXTileLayerObject(map, layers, layersLength, CreateRectangularTMXObject(rec), outputObject); +} + +/** + * Helper function that creates a TmxObject equivalent to the given circle. + * + * @param center The center point of the circle. + * @param radius The radius of the circle. + * @return An equivalent TmxObject. + */ +TmxObject CreateCircularTMXObject(Vector2 center, float radius) { + TmxObject circleAsObject; + memset(&circleAsObject, 0, sizeof(TmxObject)); /* Zero initialize */ + + circleAsObject.type = OBJECT_TYPE_ELLIPSE; + circleAsObject.x = (double)(center.x - radius); + circleAsObject.y = (double)(center.y - radius); + circleAsObject.width = 2.0 * (double)radius; + circleAsObject.height = 2.0 * (double)radius; + circleAsObject.aabb.x = center.x - radius; + circleAsObject.aabb.y = center.y - radius; + circleAsObject.aabb.width = 2.0f * radius; + circleAsObject.aabb.height = 2.0f * radius; + + return circleAsObject; +} + +RAYTMX_DEC bool CheckCollisionTMXTileLayersCircle(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2 center, float radius, TmxObject* outputObject) { + if (map == NULL || layers == NULL || layersLength == 0) + return false; + + /* Check the circle against objects associated with tiles in the layers for collisions */ + return CheckCollisionTMXTileLayerObject(map, layers, layersLength, CreateCircularTMXObject(center, radius), + outputObject); +} + +/** + * Helper function that creates a TmxObject equivalent to the given point. + * + * @param point The point. + * @return An equivalent TmxObject. + */ +TmxObject CreatePointTMXObject(Vector2 point) { + TmxObject pointAsObject; + memset(&pointAsObject, 0, sizeof(TmxObject)); /* Zero initialize */ + + pointAsObject.type = OBJECT_TYPE_POINT; + pointAsObject.x = (float)point.x; + pointAsObject.y = (float)point.y; + pointAsObject.aabb.x = (float)point.x; + pointAsObject.aabb.y = (float)point.y; + + return pointAsObject; +} + +RAYTMX_DEC bool CheckCollisionTMXTileLayersPoint(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2 point, TmxObject* outputObject) { + if (map == NULL || layers == NULL || layersLength == 0) + return false; + + /* Check the point against objects associated with tiles in the layers for collisions */ + return CheckCollisionTMXTileLayerObject(map, layers, layersLength, CreatePointTMXObject(point), outputObject); +} + +/** + * Helper function that creates a TmxObject equivalent to the given polygon with the given Axis-Aligned Bounding Box + * (AABB). If the AABB should be calculated from the given vertices, pass a rectangle with a zero or negative width or + * height. + * + * @param points An array of vertices defining the polygon. No repeats. + * @param pointCount The length of the array of vertices. + * @param aabb Bounding box of the polygon. Used for quicker, broad collision checks. + * @return An equivalent TmxObject. + */ +TmxObject CreatePolygonTMXObject(Vector2* points, int pointCount, Rectangle aabb) { + /* Create a polygon TMX object to represent the given polygon */ + TmxObject polygonAsObject; + memset(&polygonAsObject, 0, sizeof(TmxObject)); /* Zero initialize */ + + polygonAsObject.type = OBJECT_TYPE_POLYGON; + + if (aabb.width <= 0.0f || aabb.height <= 0.0f) { /* If the AABB wasn't pre-calculated or is just wrong */ + /* Calculate the bounding box by searching for minimum and maximum coordinates of the vertices */ + float minX = INFINITY, maxX = -INFINITY, minY = INFINITY, maxY = -INFINITY; + for (int i = 0; i < pointCount; i++) { + Vector2 point = points[i]; + if (point.x < minX) + minX = point.x; + if (point.x > maxX) + maxX = point.x; + if (point.y < minY) + minY = point.y; + if (point.y > maxY) + maxY = point.y; + } + aabb.x = minX; + aabb.y = minY; + aabb.width = maxX - minX; + aabb.height = maxY - minY; + } + + /* Polygons' points are relative to the object's position. Because this function takes points with absolute */ + /* positions, we'll account for this by making the object's position zero. */ + polygonAsObject.x = 0.0; + polygonAsObject.y = 0.0; + polygonAsObject.width = (double)aabb.width; + polygonAsObject.height = (double)aabb.height; + polygonAsObject.aabb = aabb; + polygonAsObject.points = points; + polygonAsObject.pointsLength = pointCount; + + return polygonAsObject; +} + +RAYTMX_DEC bool CheckCollisionTMXLayersPoly(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2* points, int pointCount, TmxObject* outputObject) { + if (map == NULL || layers == NULL || layersLength == 0 || points == NULL || pointCount < 3) + return false; + + /* Check the polygon against objects associated with tiles in the layers for collisions */ + return CheckCollisionTMXTileLayerObject(map, layers, layersLength, + CreatePolygonTMXObject(points, pointCount, (Rectangle){0.0f}), outputObject); +} + +RAYTMX_DEC bool CheckCollisionTMXLayersPolyEx(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + Vector2* points, int pointCount, Rectangle aabb, TmxObject* outputObject) { + if (map == NULL || layers == NULL || layersLength == 0 || points == NULL || pointCount < 3) + return false; + + /* Check the polygon against objects associated with tiles in the layers for collisions */ + return CheckCollisionTMXTileLayerObject(map, layers, layersLength, + CreatePolygonTMXObject(points, pointCount, aabb), outputObject); +} + +RAYTMX_DEC bool CheckCollisionTMXObjectGroupRec(TmxObjectGroup group, Rectangle rec, TmxObject* outputObject) { + if (group.objectsLength == 0 || rec.width < 0.0f || rec.height < 0.0f) + return false; /* Early-out opportunity. These cases would always return false. */ + + /* Check the rectangle against TMX objects in the group for collisions */ + return CheckCollisionTMXObjectGroupObject(group, CreateRectangularTMXObject(rec), outputObject); +} + +RAYTMX_DEC bool CheckCollisionTMXObjectGroupCircle(TmxObjectGroup group, Vector2 center, float radius, + TmxObject* outputObject) { + if (group.objectsLength == 0 || radius < 0.0f) + return false; /* Early-out opportunity. These cases would always return false. */ + + /* Check the circle against TMX objects in the group for collisions */ + return CheckCollisionTMXObjectGroupObject(group, CreateCircularTMXObject(center, radius), outputObject); +} + +RAYTMX_DEC bool CheckCollisionTMXObjectGroupPoint(TmxObjectGroup group, Vector2 point, TmxObject* outputObject) { + if (group.objectsLength == 0) + return false; /* Early-out opportunity. This case would always return false. */ + + /* Check the point against TMX objects in the group for collisions */ + return CheckCollisionTMXObjectGroupObject(group, CreatePointTMXObject(point), outputObject); +} + +RAYTMX_DEC bool CheckCollisionTMXObjectGroupPoly(TmxObjectGroup group, Vector2* points, int pointCount, + TmxObject* outputObject) { + if (group.objectsLength == 0 || points == NULL || pointCount < 3) + return false; /* Early-out opportunity. These cases would always return false. */ + + /* Check the polygon TMX object against other TMX objects in the group for collisions */ + return CheckCollisionTMXObjectGroupObject(group, CreatePolygonTMXObject(points, pointCount, (Rectangle){0.0f}), + outputObject); +} + +RAYTMX_DEC bool CheckCollisionTMXObjectGroupPolyEx(TmxObjectGroup group, Vector2* points, int pointCount, + Rectangle aabb, TmxObject* outputObject) { + if (group.objectsLength == 0 || points == NULL || pointCount < 3) + return false; /* Early-out opportunity. These cases would always return false. */ + + /* Check the polygon TMX object against other TMX objects in the group for collisions */ + return CheckCollisionTMXObjectGroupObject(group, CreatePolygonTMXObject(points, pointCount, aabb), outputObject); +} + +static LoadTextureCallback loadTextureOverride = NULL; + +RAYTMX_DEC void SetLoadTextureTMX(LoadTextureCallback callback) { + loadTextureOverride = callback; +} + +static int tmxLogFlags = 0; + +RAYTMX_DEC void TraceLogTMX(int logLevel, const TmxMap* map) { + if (map == NULL) + return; + + switch (map->orientation) { + case ORIENTATION_NONE: TraceLog(logLevel, "orientation: none"); break; + case ORIENTATION_ORTHOGONAL: TraceLog(logLevel, "orientation: orthogonal"); break; + case ORIENTATION_ISOMETRIC: TraceLog(logLevel, "orientation: isometric"); break; + case ORIENTATION_STAGGERED: TraceLog(logLevel, "orientation: staggered"); break; + case ORIENTATION_HEXAGONAL: TraceLog(logLevel, "orientation: hexagonal"); break; + } + + switch (map->renderOrder) { + case RENDER_ORDER_RIGHT_DOWN: TraceLog(logLevel, "render order: right-down"); break; + case RENDER_ORDER_RIGHT_UP: TraceLog(logLevel, "render order: right-up"); break; + case RENDER_ORDER_LEFT_DOWN: TraceLog(logLevel, "render order: left-down"); break; + case RENDER_ORDER_LEFT_UP: TraceLog(logLevel, "render order: left-up"); break; + } + + TraceLog(logLevel, "width: %u tiles", map->width); + TraceLog(logLevel, "height: %u tiles", map->height); + TraceLog(logLevel, "tile width: %u pixels", map->tileWidth); + TraceLog(logLevel, "tile height: %u pixels", map->tileHeight); + TraceLog(logLevel, "parallax origin X: %d pixels", map->parallaxOriginX); + TraceLog(logLevel, "parallax origin Y: %d pixels", map->parallaxOriginY); + if (map->hasBackgroundColor) + TraceLog(logLevel, "background color: 0x%08X", map->backgroundColor); + + TraceLogTMXTilesets(logLevel, map->orientation, map->tilesets, map->tilesetsLength, 0); + TraceLogTMXProperties(logLevel, map->properties, map->propertiesLength, 0); + TraceLogTMXLayers(logLevel, map->layers, map->layersLength, 0); +} + +RAYTMX_DEC void SetTraceLogFlagsTMX(int logFlags) { + tmxLogFlags = logFlags; +} + +/**********************************************************************************************************************/ +/* Private implementation. */ + +RaytmxExternalTileset LoadTSX(const char* fileName) { + RaytmxState raytmxState[1]; + memset(raytmxState, 0, sizeof(RaytmxState)); /* Initialize all values to zero, NULL, or an equivalent enum value */ + raytmxState->format = FORMAT_TSX; + + /* Initialize an external tileset object */ + RaytmxExternalTileset externalTileset; + memset(&externalTileset, 0, sizeof(RaytmxExternalTileset)); + + /* Do format-agnostic parsing of the document. The state object will be populated with raytmx's models of the */ + /* equivalent TMX, TSX, and/or TX elements. */ + ParseDocument(raytmxState, fileName); + if (!raytmxState->isSuccess) + return externalTileset; /* Will have 'isSuccess' set to false to indicate a failure */ + + if (raytmxState->tilesetsRoot != NULL) { /* If there is at least one tileset */ + /* Copy the root tileset so it can be returned */ + externalTileset.tileset = raytmxState->tilesetsRoot->tileset; + externalTileset.isSuccess = true; + /* TSX files should have only one tileset so any others will be freed/unloaded immediately */ + RaytmxTilesetNode* tilesetIterator = raytmxState->tilesetsRoot->next; + while (tilesetIterator != NULL) { + FreeTileset(tilesetIterator->tileset); + tilesetIterator = tilesetIterator->next; + } + } else + TraceLog(LOG_WARNING, "RAYTMX: TSX file (external tileset) \"%s\" does not contain any tilesets", fileName); + + /* Free the linked lists and zeroize related values */ + FreeState(raytmxState); + + return externalTileset; +} + +RaytmxObjectTemplate LoadTX(const char* fileName) { + RaytmxState raytmxState[1]; + memset(raytmxState, 0, sizeof(RaytmxState)); /* Initialize all values to zero, NULL, or an equivalent enum value */ + raytmxState->format = FORMAT_TX; + + /* Initialize an object template object */ + RaytmxObjectTemplate objectTemplate; + memset(&objectTemplate, 0, sizeof(RaytmxObjectTemplate)); + + /* Do format-agnostic parsing of the document. The state object will be populated with raytmx's models of the */ + /* equivalent TMX, TSX, and/or TX elements. */ + ParseDocument(raytmxState, fileName); + if (!raytmxState->isSuccess) + return objectTemplate; /* Will have 'isSuccess' set to false to indicate a failure */ + + if (raytmxState->objectsRoot != NULL) { /* If there is at least one object */ + /* Copy the root object so it can be returned */ + objectTemplate.object = raytmxState->objectsRoot->object; + objectTemplate.isSuccess = true; + /* TX files should have only one object so any others will be freed/unloaded immediately */ + RaytmxObjectNode* objectIterator = raytmxState->objectsRoot->next; + while (objectIterator != NULL) { + FreeObject(objectIterator->object); + objectIterator = objectIterator->next; + } + } else + TraceLog(LOG_WARNING, "RAYTMX: TX file (object template) \"%s\" does not contain any objects", fileName); + + if (raytmxState->tilesetsRoot != NULL) { /* If there is at least one tileset */ + /* Object templates may have a tileset. This is for cases where the object references a tile (i.e. its 'gid' */ + /* attribute is set). Copy the root tileset so it can be returned */ + objectTemplate.tileset = raytmxState->tilesetsRoot->tileset; + objectTemplate.hasTileset = true; + /* TX files should have at most one tileset so any others will be freed/unloaded immediately */ + RaytmxTilesetNode* tilesetsIterator = raytmxState->tilesetsRoot->next; + while (tilesetsIterator != NULL) { + FreeTileset(tilesetsIterator->tileset); + tilesetsIterator = tilesetsIterator->next; + } + } + + /* Free the linked lists and zeroize related values */ + FreeState(raytmxState); + + return objectTemplate; +} + +void ParseDocument(RaytmxState* raytmxState, const char* fileName) { + char* content = LoadFileText(fileName); + if (content == NULL) { + TraceLog(LOG_ERROR, "RAYTMX: Failed to open \"%s\"", fileName); + return; + } + size_t contentLength = strlen(content); + + StringCopy(raytmxState->documentDirectory, GetDirectoryPath2(fileName)); + + hoxml_context_t hoxmlContext[1]; + size_t bufferLength = contentLength; + char* buffer = (char*)MemAlloc((unsigned int)bufferLength); + hoxml_init(hoxmlContext, buffer, bufferLength); + + hoxml_code_t code; + while ((code = hoxml_parse(hoxmlContext, content, contentLength)) != HOXML_END_OF_DOCUMENT) { + if (code > HOXML_END_OF_DOCUMENT) { /* If there's information about an element, attribute, whatever */ + switch (code) { + case HOXML_ELEMENT_BEGIN: HandleElementBegin(raytmxState, hoxmlContext); break; + case HOXML_ELEMENT_END: HandleElementEnd(raytmxState, hoxmlContext); break; + case HOXML_ATTRIBUTE: HandleAttribute(raytmxState, hoxmlContext); + case HOXML_PROCESSING_INSTRUCTION_BEGIN: break; + case HOXML_PROCESSING_INSTRUCTION_END: break; + default: break; /* No other cases to handle but compilers like to complain */ + } + } else if (code < HOXML_END_OF_DOCUMENT) { /* If there was an error, recoverable or not */ + switch (code) { + case HOXML_ERROR_INSUFFICIENT_MEMORY: { + /* This is one we can recover from by expanding the buffer. In this case, it will be doubled. */ + TraceLog(LOG_DEBUG, "RAYTMX: Allocating a new XML parsing buffer due to insufficient memory"); + bufferLength *= 2; + char* newBuffer = (char*)MemAlloc((unsigned int)bufferLength); + hoxml_realloc(hoxmlContext, newBuffer, bufferLength); + MemFree(buffer); + buffer = newBuffer; + continue; + } case HOXML_ERROR_UNEXPECTED_EOF: + TraceLog(LOG_ERROR, "RAYTMX: Unexpected end of file"); + break; + case HOXML_ERROR_SYNTAX: + TraceLog(LOG_ERROR, "RAYTMX: Invalid syntax: line %d, column %d", hoxmlContext->line, + hoxmlContext->column); + break; + case HOXML_ERROR_ENCODING: + TraceLog(LOG_ERROR, "RAYTMX: Character encoding error: line %d, column %d", hoxmlContext->line, + hoxmlContext->column); + break; + case HOXML_ERROR_TAG_MISMATCH: + TraceLog(LOG_ERROR, "RAYTMX: Close tag does not match open tag: line %d, column %d", + hoxmlContext->line, hoxmlContext->column); + break; + case HOXML_ERROR_INVALID_DOCUMENT_TYPE_DECLARATION: + case HOXML_ERROR_INVALID_DOCUMENT_DECLARATION: + TraceLog(LOG_ERROR, "RAYTMX: Document (type) declaration error: line %d, column %d", + hoxmlContext->line, hoxmlContext->column); + break; + default: break; /* Keep the compiler happy */ + } + UnloadFileText(content); + return; + } + } + + UnloadFileText(content); + MemFree(buffer); + raytmxState->isSuccess = true; +} + +void HandleElementBegin(RaytmxState* raytmxState, hoxml_context_t* hoxmlContext) { + if (raytmxState == NULL || hoxmlContext == NULL) + return; + + if (strcmp(hoxmlContext->tag, "map") == 0) + ; + else if (strcmp(hoxmlContext->tag, "properties") == 0) { + /* TMX allows nested properties but they are not (currently?) supported. To avoid memory leaks <properties> */ + /* depth is tracked. */ + raytmxState->propertiesDepth += 1; + } else if (strcmp(hoxmlContext->tag, "property") == 0) + raytmxState->property = AddProperty(raytmxState); + else if (strcmp(hoxmlContext->tag, "tileset") == 0) + raytmxState->tileset = AddTileset(raytmxState); + else if (strcmp(hoxmlContext->tag, "image") == 0) { + /* If any of the elements that may have an image is/are open */ + if (raytmxState->tilesetTile != NULL || raytmxState->tileset != NULL || raytmxState->imageLayer != NULL) { + /* If the open element already has an image */ + /* Note: In all cases, the element can contain at most one <image> */ + if ((raytmxState->tilesetTile != NULL && raytmxState->tilesetTile->hasImage) || + (raytmxState->tileset != NULL && raytmxState->tileset->hasImage) || + (raytmxState->imageLayer != NULL && raytmxState->imageLayer->hasImage)) { + TraceLog(LOG_WARNING, "RAYTMX: an element contained multiple images; the image on line %d will be " + "dropped", hoxmlContext->line); + } else { + /* <image> elements can be children of <tileset>, <tile>, or <imagelayer> elements */ + if (raytmxState->tilesetTile != NULL) { + raytmxState->tilesetTile->hasImage = true; + raytmxState->image = &raytmxState->tilesetTile->image; + } else if (raytmxState->tileset != NULL) { + raytmxState->tileset->hasImage = true; + raytmxState->image = &raytmxState->tileset->image; + } else if (raytmxState->imageLayer != NULL) { + raytmxState->imageLayer->hasImage = true; + raytmxState->image = &raytmxState->imageLayer->image; + } + } + } + } /* strcmp(hoxmlContext->tag, "image") == 0 */ + else if (strcmp(hoxmlContext->tag, "tile") == 0) { + /* <tile> elements can be children of <tileset> or <layer>. They are also not the same element in that they */ + /* have entirely different attributes and a tileset's <tile> may have children. */ + if (raytmxState->tileset != NULL) + raytmxState->tilesetTile = AddTilesetTile(raytmxState); + /* Layer <tile>s are added during attribute handling because they provide a GID attribute and nothing else */ + } /* strcmp(hoxmlContext->tag, "tile") == 0 */ + else if (strcmp(hoxmlContext->tag, "animation") == 0) { + if (raytmxState->tilesetTile != NULL) + raytmxState->tilesetTile->hasAnimation = true; + } else if (strcmp(hoxmlContext->tag, "frame") == 0) + raytmxState->animationFrame = AddAnimationFrame(raytmxState); + else if (strcmp(hoxmlContext->tag, "layer") == 0) { + /* Allocate a new layer with 'tileLayer' allocated and append it to the current group, if it exists */ + raytmxState->layer = AddGenericLayer(raytmxState, /* isGroup: */ false); + raytmxState->layer->type = LAYER_TYPE_TILE_LAYER; + raytmxState->tileLayer = &raytmxState->layer->exact.tileLayer; + } else if (strcmp(hoxmlContext->tag, "objectgroup") == 0) { + if (raytmxState->tilesetTile != NULL) { /* If the object group is a child of a <tile>, it's collision info */ + raytmxState->objectGroup = &raytmxState->tilesetTile->objectGroup; + /* Child objects (rectangles, points, ellipses, or polygons) are expected to follow */ + } else { + /* Allocate a new layer with 'objectGroup' allocated and append it to the current group, if it exists */ + raytmxState->layer = AddGenericLayer(raytmxState, /* isGroup: */ false); + raytmxState->layer->type = LAYER_TYPE_OBJECT_GROUP; + raytmxState->objectGroup = &raytmxState->layer->exact.objectGroup; + } + } else if (strcmp(hoxmlContext->tag, "object") == 0) { + /* <object> elements are typically only allowable as children of <objectgroup>s but object templates, TX */ + /* files, contain them as children of root <template> */ + if (raytmxState->objectGroup != NULL || raytmxState->format == FORMAT_TX) + raytmxState->object = AddObject(raytmxState); + } else if (strcmp(hoxmlContext->tag, "ellipse") == 0) { + if (raytmxState->object != NULL) { + /* An <ellipse> within an <object> indicates its type but the <object>'s 'x,' 'y,' 'width,' and 'height' */ + /* attributes are used to define the ellipse so assigning the type is all that's necessary */ + raytmxState->object->type = OBJECT_TYPE_ELLIPSE; + } + } else if (strcmp(hoxmlContext->tag, "point") == 0) { + if (raytmxState->object != NULL) { + /* A <point> within an <object> indicates its type but the <object>'s 'x' and 'y' attributes are used to */ + /* define the point so assigning the type is all that's necessary */ + raytmxState->object->type = OBJECT_TYPE_POINT; + } + } else if (strcmp(hoxmlContext->tag, "polygon") == 0) { + if (raytmxState->object != NULL) { + /* Note: <polygon>s and <polyline>s have a list of points/vertices defined in a 'points' attribute */ + raytmxState->object->type = OBJECT_TYPE_POLYGON; + } + } else if (strcmp(hoxmlContext->tag, "polyline") == 0) { + if (raytmxState->object != NULL) { + /* Note: <polyline>s and <polygone>s have a list of points/vertices defined in a 'points' attribute */ + raytmxState->object->type = OBJECT_TYPE_POLYLINE; + } + } else if (strcmp(hoxmlContext->tag, "text") == 0) { + if (raytmxState->object != NULL) { + raytmxState->object->type = OBJECT_TYPE_TEXT; + raytmxState->object->text = (TmxText*)MemAllocZero(sizeof(TmxText)); + /* There are a couple non-zero default values for <text> attributes: */ + raytmxState->object->text->pixelSize = 16; + raytmxState->object->text->color.a = 255; /* Full opacity black */ + raytmxState->object->text->kerning = 1; + /* The font family will also default to "sans-serif" when the element ends if there is no attribute */ + } + } else if (strcmp(hoxmlContext->tag, "imagelayer") == 0) { + /* Allocate a new layer with 'imageLayer' allocated and append it to the current group, if it exists */ + raytmxState->layer = AddGenericLayer(raytmxState, /* isGroup: */ false); + raytmxState->layer->type = LAYER_TYPE_IMAGE_LAYER; + raytmxState->imageLayer = &raytmxState->layer->exact.imageLayer; + } else if (strcmp(hoxmlContext->tag, "group") == 0) { + /* Allocate a new layer and append it to the current group, if it exists */ + raytmxState->layer = AddGenericLayer(raytmxState, /* isGroup: */ true); + raytmxState->layer->type = LAYER_TYPE_GROUP; + } +} + +void HandleAttribute(RaytmxState* raytmxState, hoxml_context_t* hoxmlContext) { + if (raytmxState == NULL || hoxmlContext == NULL) + return; + + if (strcmp(hoxmlContext->tag, "map") == 0) { + if (strcmp(hoxmlContext->attribute, "orientation") == 0) { + if (strcmp(hoxmlContext->value, "orthogonal") == 0) + raytmxState->mapOrientation = ORIENTATION_ORTHOGONAL; + else if (strcmp(hoxmlContext->value, "isometric") == 0) + raytmxState->mapOrientation = ORIENTATION_ISOMETRIC; + else if (strcmp(hoxmlContext->value, "staggered") == 0) + raytmxState->mapOrientation = ORIENTATION_STAGGERED; + else if (strcmp(hoxmlContext->value, "hexagonal") == 0) + raytmxState->mapOrientation = ORIENTATION_HEXAGONAL; + } /* strcmp(hoxmlContext->attribute, "orientation") == 0 */ + else if (strcmp(hoxmlContext->attribute, "renderorder") == 0) { + if (strcmp(hoxmlContext->value, "right-down") == 0) + raytmxState->mapRenderOrder = RENDER_ORDER_RIGHT_DOWN; + else if (strcmp(hoxmlContext->value, "right-up") == 0) + raytmxState->mapRenderOrder = RENDER_ORDER_RIGHT_UP; + else if (strcmp(hoxmlContext->value, "left-down") == 0) + raytmxState->mapRenderOrder = RENDER_ORDER_LEFT_DOWN; + else if (strcmp(hoxmlContext->value, "left-up") == 0) + raytmxState->mapRenderOrder = RENDER_ORDER_LEFT_UP; + } /* strcmp(hoxmlContext->attribute, "renderorder") == 0 */ + else if (strcmp(hoxmlContext->attribute, "width") == 0) + raytmxState->mapWidth = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "height") == 0) + raytmxState->mapHeight = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "tilewidth") == 0) + raytmxState->mapTileWidth = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "tileheight") == 0) + raytmxState->mapTileHeight = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "parallaxoriginx") == 0) + raytmxState->mapParallaxOriginX = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "parallaxoriginy") == 0) + raytmxState->mapParallaxOriginY = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "backgroundcolor") == 0) { + raytmxState->mapBackgroundColor = GetColorFromHexString(hoxmlContext->value); + raytmxState->mapHasBackgroundColor = true; + } + } /* strcmp(hoxmlContext->tag, "map") == 0 */ + else if (strcmp(hoxmlContext->tag, "property") == 0) { + if (raytmxState->property != NULL) { + if (strcmp(hoxmlContext->attribute, "name") == 0) { + raytmxState->property->name = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->property->name, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "type") == 0) { + if (strcmp(hoxmlContext->value, "string") == 0) + raytmxState->property->type = PROPERTY_TYPE_STRING; + else if (strcmp(hoxmlContext->value, "int") == 0) + raytmxState->property->type = PROPERTY_TYPE_INT; + else if (strcmp(hoxmlContext->value, "float") == 0) + raytmxState->property->type = PROPERTY_TYPE_FLOAT; + else if (strcmp(hoxmlContext->value, "bool") == 0) + raytmxState->property->type = PROPERTY_TYPE_BOOL; + else if (strcmp(hoxmlContext->value, "color") == 0) + raytmxState->property->type = PROPERTY_TYPE_COLOR; + else if (strcmp(hoxmlContext->value, "file") == 0) + raytmxState->property->type = PROPERTY_TYPE_FILE; + else if (strcmp(hoxmlContext->value, "object") == 0) + raytmxState->property->type = PROPERTY_TYPE_OBJECT; + /* TMX documentation also mentions a "class" type but doesn't describe what it is nor does Tiled list */ + /* it as an option when adding a property. So what is it? Unsupported, that's what. */ + } /* strcmp(hoxmlContext->attribute, "type") == 0 */ + else if (strcmp(hoxmlContext->attribute, "value") == 0) { + /* Although unlikley, it's possible that 'value' attribute will be parsed before the 'type' */ + /* attribute. In that case, doing a cast/conversion now may not be possible. To avoid this, the raw */ + /* string value is copied to 'stringValue' temporarily, or permanently for string and file types, and */ + /* the cast/conversion will happen at the end of the element if needed. */ + raytmxState->property->stringValue = (char*)MemAlloc((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->property->stringValue, hoxmlContext->value); + } /* strcmp(hoxmlContext->attribute, "value") == 0 */ + } /* raytmxState->property != NULL */ + } /* strcmp(hoxmlContext->tag, "property") == 0 */ + else if (strcmp(hoxmlContext->tag, "tileset") == 0) { + if (raytmxState->tileset != NULL) { + if (strcmp(hoxmlContext->attribute, "firstgid") == 0) + raytmxState->tileset->firstGid = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "source") == 0) { + raytmxState->tileset->source = (char*)MemAlloc((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->tileset->source, hoxmlContext->value); + /* 'source' points to an external TSX file that defines the majority of the tileset. Try to load it. */ + RaytmxExternalTileset externalTileset = LoadTSX(JoinPath(raytmxState->documentDirectory, + hoxmlContext->value)); + if (externalTileset.isSuccess) { + /* A <tileset> within a <map> will have two attributes: 'firstgid' and 'source.' The rest of */ + /* the tileset's details are in the external TSX that 'source' points to. They need to be merged. */ + /* Remember the two internal attributes. */ + uint32_t tempFirstGid = raytmxState->tileset->firstGid; + char* tempSource = raytmxState->tileset->source; + /* Assign all values from the TSX's tileset to the one within the state object. This will */ + /* overrite the values of 'firstGid' and 'source.' */ + *raytmxState->tileset = externalTileset.tileset; + /* Reassign the original 'firstGid' and 'source' values */ + raytmxState->tileset->firstGid = tempFirstGid; + raytmxState->tileset->source = tempSource; + } + } else if (strcmp(hoxmlContext->attribute, "name") == 0) { + raytmxState->tileset->name = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->tileset->name, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "class") == 0) { + raytmxState->tileset->classString = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->tileset->classString, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "tilewidth") == 0) + raytmxState->tileset->tileWidth = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "tileheight") == 0) + raytmxState->tileset->tileHeight = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "spacing") == 0) + raytmxState->tileset->spacing = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "margin") == 0) + raytmxState->tileset->margin = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "tilecount") == 0) + raytmxState->tileset->tileCount = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "columns") == 0) + raytmxState->tileset->columns = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "objectalignment") == 0) { + if (strcmp(hoxmlContext->value, "unspecified") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_UNSPECIFIED; + else if (strcmp(hoxmlContext->value, "topleft") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_TOP_LEFT; + else if (strcmp(hoxmlContext->value, "top") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_TOP; + else if (strcmp(hoxmlContext->value, "topright") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_TOP_RIGHT; + else if (strcmp(hoxmlContext->value, "left") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_LEFT; + else if (strcmp(hoxmlContext->value, "center") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_CENTER; + else if (strcmp(hoxmlContext->value, "right") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_RIGHT; + else if (strcmp(hoxmlContext->value, "bottomleft") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_BOTTOM_LEFT; + else if (strcmp(hoxmlContext->value, "bottom") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_BOTTOM; + else if (strcmp(hoxmlContext->value, "bottomright") == 0) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_BOTTOM_RIGHT; + } + } /* raytmState->tileset != NULL */ + } /* strcmp(hoxmlContext->tag, "tileset") == 0 */ + else if (strcmp(hoxmlContext->tag, "tileoffset") == 0) { + if (raytmxState->tileset != NULL) { + if (strcmp(hoxmlContext->attribute, "x") == 0) + raytmxState->tileset->tileOffsetX = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "y") == 0) + raytmxState->tileset->tileOffsetY = atoi(hoxmlContext->value); + } + } /* strcmp(hoxmlContext->tag, "tileoffset") == 0 */ + else if (strcmp(hoxmlContext->tag, "image") == 0) { + if (raytmxState->image != NULL) { + if (strcmp(hoxmlContext->attribute, "source") == 0) { + raytmxState->image->source = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->image->source, hoxmlContext->value); + RaytmxCachedTextureNode* cachedTexture = LoadCachedTexture(raytmxState, hoxmlContext->value); + if (cachedTexture != NULL) + raytmxState->image->texture = cachedTexture->texture; + } else if (strcmp(hoxmlContext->attribute, "trans") == 0) { + raytmxState->image->trans = GetColorFromHexString(hoxmlContext->value); + raytmxState->image->hasTrans = true; + } else if (strcmp(hoxmlContext->attribute, "width") == 0) + raytmxState->image->width = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "height") == 0) + raytmxState->image->height = atoi(hoxmlContext->value); + } + } /* strcmp(hoxmlContext->tag, "image") == 0 */ + else if (strcmp(hoxmlContext->tag, "tile") == 0) { + if (raytmxState->tilesetTile != NULL) { /* If the <tile> corresponds to a tileset tile */ + if (strcmp(hoxmlContext->attribute, "id") == 0) + raytmxState->tilesetTile->id = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "type") == 0 || strcmp(hoxmlContext->attribute, "class") == 0) { + raytmxState->tilesetTile->classString = + (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->tilesetTile->classString, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "x") == 0) + raytmxState->tilesetTile->x = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "y") == 0) + raytmxState->tilesetTile->y = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "width") == 0) + raytmxState->tilesetTile->width = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "height") == 0) + raytmxState->tilesetTile->height = atoi(hoxmlContext->value); + } else { /* If the <tile> corresponds to a layer tile */ + if (strcmp(hoxmlContext->attribute, "gid") == 0) + AddTileLayerTile(raytmxState, atoi(hoxmlContext->value)); + } + } /* strcmp(hoxmlContext->tag, "tile") == 0 */ + else if (strcmp(hoxmlContext->tag, "frame") == 0) { + if (raytmxState->animationFrame != NULL) { + if (strcmp(hoxmlContext->attribute, "tileid") == 0) + raytmxState->animationFrame->gid = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "duration") == 0) + raytmxState->animationFrame->duration = (float)atoi(hoxmlContext->value) / 1000.0f; + } + } /* strcmp(hoxmlContext->tag, "frame") == 0 */ + else if (strcmp(hoxmlContext->tag, "layer") == 0) { + if (raytmxState->tileLayer != NULL) { + /* Check for attributes specific to <layer> layers */ + if (strcmp(hoxmlContext->attribute, "width") == 0) + raytmxState->tileLayer->width = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "height") == 0) + raytmxState->tileLayer->height = atoi(hoxmlContext->value); + } + } /* strcmp(hoxmlContext->tag, "layer") == 0) */ + else if (strcmp(hoxmlContext->tag, "data") == 0) { + if (raytmxState->tileLayer != NULL) { /* If this <data> applies to a <layer> */ + if (strcmp(hoxmlContext->attribute, "encoding") == 0) { + raytmxState->tileLayer->encoding = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->tileLayer->encoding, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "compression") == 0) { + raytmxState->tileLayer->compression = + (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->tileLayer->compression, hoxmlContext->value); + } + } else if (raytmxState->image != NULL) { /* If this <data> applies to an <image> */ + /* TODO (?): The TMX map format documentation says an <image> can contain a <data> element but doesn't */ + /* provide any more information than that. Tiled doesn't seem to have a feature for this either. */ + } + } /* strcmp(hoxmlContext->tag, "data") == 0 */ + else if (strcmp(hoxmlContext->tag, "objectgroup") == 0) { + if (raytmxState->objectGroup != NULL) { + /* Check for attributes specific to <objectgroup> layers */ + if (strcmp(hoxmlContext->attribute, "color") == 0) { + raytmxState->objectGroup->color = GetColorFromHexString(hoxmlContext->value); + raytmxState->objectGroup->hasColor = true; + } /* else if (strcmp(hoxmlContext->attribute, "width") == 0) + raytmxState->objectGroup->width = atoi(hoxmlContext->value); */ /* "Meaningless" according to docs. */ + /* else if (strcmp(hoxmlContext->attribute, "height") == 0) + raytmxState->objectGroup->height = atoi(hoxmlContext->value); */ /* "Meaningless" according to docs. */ + else if (strcmp(hoxmlContext->attribute, "draworder") == 0) { + if (strcmp(hoxmlContext->value, "index") == 0) + raytmxState->objectGroup->drawOrder = OBJECT_GROUP_DRAW_ORDER_INDEX; + else if (strcmp(hoxmlContext->value, "topdown") == 0) + raytmxState->objectGroup->drawOrder = OBJECT_GROUP_DRAW_ORDER_TOP_DOWN; + } + } + } /* strcmp(hoxmlContext->tag, "objectgroup") == 0 */ + else if (strcmp(hoxmlContext->tag, "object") == 0) { + if (raytmxState->object != NULL) { + if (strcmp(hoxmlContext->attribute, "id") == 0) + raytmxState->object->id = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "name") == 0) { + raytmxState->object->name = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->object->name, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "type") == 0) { + raytmxState->object->typeString = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->object->typeString, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "x") == 0) + raytmxState->object->x = atof(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "y") == 0) + raytmxState->object->y = atof(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "width") == 0) + raytmxState->object->width = atof(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "height") == 0) + raytmxState->object->height = atof(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "rotation") == 0) + raytmxState->object->rotation = atof(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "gid") == 0) { + raytmxState->object->gid = atoi(hoxmlContext->value); + /* The presence of a 'gid' attribute also indicates the object's type is that of a tile */ + raytmxState->object->type = OBJECT_TYPE_TILE; + } else if (strcmp(hoxmlContext->attribute, "visible") == 0) + raytmxState->object->visible = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "template") == 0) { + raytmxState->object->templateString = + (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->object->templateString, hoxmlContext->value); + } + } + } /* strcmp(hoxmlContext->tag, "object") == 0 */ + else if (strcmp(hoxmlContext->tag, "polygon") == 0 || strcmp(hoxmlContext->tag, "polyline") == 0) { + /* <polygon> and <polyline>, children of <object>, both have just one attribute: 'points' */ + if (raytmxState->object != NULL && strcmp(hoxmlContext->attribute, "points") == 0) { + if (raytmxState->object->points != NULL) { /* If there's already an array of points */ + TraceLog(LOG_WARNING, "RAYTMX: object \"%s\", has multiple 'points' attributes; points listed in any " + "latter 'points' attributes will be dropped", raytmxState->object->name); + return; + } + /* The 'points' attribute's value is a string containing all points of the poly(gon|line) in the form */ + /* "0,0 31.25,-0.75 49.5,-16.5 93.25,-17.25" where the points are [0, 0], [31.25, -0.75], etc. and these */ + /* points are relative to the object's position (its 'x' and 'y' attributes) */ + char x[32], y[32], *iterator, *terminator, *comma; + iterator = hoxmlContext->value; + RaytmxPolyPointNode *pointsRoot = NULL, *pointsTail = NULL; + uint32_t pointsLength = 0; + Vector2 vertexSum; /* Specific to polygons, the centroid is calculated requiring a sum of all vertices */ + vertexSum.x = 0; + vertexSum.y = 0; + while (iterator != NULL) { + terminator = strstr(iterator, " "); /* Use this pointer to mark the end of the current point */ + if (terminator == NULL) { /* There are no space delimiters this far into the value string */ + /* This is the end of the value string so we'll use a regular null terminator instead */ + terminator = iterator + strlen(iterator); + } + comma = strstr(iterator, ","); /* Use this pointer to mark the location of the comma between X and Y */ + if (comma == NULL) { + /* The string is malformed. Cannot continue. */ + TraceLog(LOG_WARNING, "RAYTMX: The 'points' attribute on line %d has a malformed value; at least " + "one point is lost as a result", hoxmlContext->line); + break; + } + /* 'iterator' is pointing to the first digit, 'comma' is pointing to the comma, and 'terminator' is */ + /* pointing to either the terminating space or a typical null terminator */ + StringCopyN(x, iterator, comma - iterator); /* Copy from 'iterator' up to but excluding 'comma' */ + x[comma - iterator] = '\0'; + iterator = comma + 1; /* Point the iterator right after the ',' where Y begins */ + StringCopyN(y, iterator, terminator - iterator); /* Copy 'iterator' up to but excluding 'terminator' */ + y[terminator - iterator] = '\0'; + /* Create a linked list node to hold the point and append it to the linked list */ + RaytmxPolyPointNode* node = (RaytmxPolyPointNode*)MemAllocZero(sizeof(RaytmxPolyPointNode)); + /* Note: These values may be negative. A poly(gon|line) object's position is determined by the first */ + /* vertex added leading to the first entry to be "0,0" and all other vertices relative to it. */ + node->point.x = (float)atof(x); + node->point.y = (float)atof(y); + vertexSum.x += node->point.x; + vertexSum.y += node->point.y; + if (pointsRoot == NULL) /* If this is the first point to add to the list */ + pointsRoot = node; + else /* If adding to the tail of the list */ + pointsTail->next = node; + pointsTail = node; + pointsLength += 1; + iterator = terminator[0] != '\0' ? terminator + 1 : NULL; + } + + if (pointsRoot != NULL) { /* If a list with at least one node was created from the 'points' attribute */ + /* The first vertex will be duplicated and appended to the end of the list, for drawing purposes, so */ + /* the length of the points list is incremented by one */ + pointsLength += 1; + bool isPolygon = strcmp(hoxmlContext->tag, "polygon") == 0; + if (isPolygon) { /* If the object is a polygon, not polyline */ + /* Polygons will be drawn using raylib's DrawTriangleFan() function in which the first point is */ + /* the centroid. It must also end with the first, non-centroid point. So, for polygons, the list */ + /* will have two more points. */ + pointsLength += 1; + } + /* Allocate the array and assign NULL to every index to be safe */ + Vector2* points = (Vector2*)MemAllocZero(sizeof(Vector2) * pointsLength); + if (isPolygon) { /* If the centroid should be included as a vertex */ + /* Finish calculating the centroid by averaging the sum of the vertices keeping in mind that */ + /* 'pointsLength' is equal to N + 2 */ + points[0].x = vertexSum.x / (pointsLength - 2); + points[0].y = vertexSum.y / (pointsLength - 2); + } + /* Copy the points as Vector2s into the array and free the nodes while we're at it */ + RaytmxPolyPointNode* iteratorNode = pointsRoot; + uint32_t i = isPolygon ? 1 : 0; /* Skip over the first element, the centroid, for polygons only */ + while (iteratorNode != NULL) { + points[i] = iteratorNode->point; + RaytmxPolyPointNode* parent = iteratorNode; + iteratorNode = iteratorNode->next; + i += 1; + MemFree(parent); + } + /* End the list with the first point. Both polygons and polylines use this when drawing. */ + points[pointsLength - 1].x = points[isPolygon ? 1 : 0].x; + points[pointsLength - 1].y = points[isPolygon ? 1 : 0].y; + /* TODO: sort the vertices into counter-clockwise order as DrawTriangleFan() requires it */ + /* Add the points array to the element it applies to */ + raytmxState->object->points = points; + raytmxState->object->pointsLength = pointsLength; + raytmxState->object->drawPoints = (Vector2*)MemAllocZero(sizeof(Vector2) * pointsLength); + } + } /* raytmxState->object != NULL && strcmp(hoxmlContext->attribute, "points") == 0 */ + } /* strcmp(hoxmlContext->tag, "polygon") == 0 || strcmp(hoxmlContext->tag, "polyline") == 0 */ + else if (strcmp(hoxmlContext->tag, "text") == 0) { + if (raytmxState->object != NULL && raytmxState->object->text != NULL) { + if (strcmp(hoxmlContext->attribute, "fontfamily") == 0) { + raytmxState->object->text->fontFamily = + (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->object->text->fontFamily, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "pixelsize") == 0) + raytmxState->object->text->pixelSize = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "wrap") == 0) + raytmxState->object->text->wrap = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "color") == 0) + raytmxState->object->text->color = GetColorFromHexString(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "bold") == 0) + raytmxState->object->text->bold = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "italic") == 0) + raytmxState->object->text->italic = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "underline") == 0) + raytmxState->object->text->underline = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "strikeout") == 0) + raytmxState->object->text->strikeOut = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "kerning") == 0) + raytmxState->object->text->kerning = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "halign") == 0) { + if (strcmp(hoxmlContext->value, "left") == 0) + raytmxState->object->text->halign = HORIZONTAL_ALIGNMENT_LEFT; + else if (strcmp(hoxmlContext->value, "center") == 0) + raytmxState->object->text->halign = HORIZONTAL_ALIGNMENT_CENTER; + else if (strcmp(hoxmlContext->value, "right") == 0) + raytmxState->object->text->halign = HORIZONTAL_ALIGNMENT_RIGHT; + else if (strcmp(hoxmlContext->value, "justify") == 0) + raytmxState->object->text->halign = HORIZONTAL_ALIGNMENT_JUSTIFY; + } else if (strcmp(hoxmlContext->attribute, "valign") == 0) { + if (strcmp(hoxmlContext->value, "top") == 0) + raytmxState->object->text->valign = VERTICAL_ALIGNMENT_TOP; + else if (strcmp(hoxmlContext->value, "center") == 0) + raytmxState->object->text->valign = VERTICAL_ALIGNMENT_CENTER; + else if (strcmp(hoxmlContext->value, "bottom") == 0) + raytmxState->object->text->valign = VERTICAL_ALIGNMENT_BOTTOM; + } + } /* raytmxState->object != NULL && raytmxState->object->text != NULL */ + } /* strcmp(hoxmlContext->tag, "text") == 0 */ + else if (strcmp(hoxmlContext->tag, "imagelayer") == 0) { + if (raytmxState->imageLayer != NULL) { + /* Check for attributes specific to <imagelayer> layers */ + if (strcmp(hoxmlContext->attribute, "repeatx") == 0) + raytmxState->imageLayer->repeatX = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "repeaty") == 0) + raytmxState->imageLayer->repeatY = atoi(hoxmlContext->value) != 0 ? true : false; + } + } /* strcmp(hoxmlContext->tag, "imagelayer") == 0 */ + + if (strcmp(hoxmlContext->tag, "layer") == 0 || strcmp(hoxmlContext->tag, "objectgroup") == 0 || + strcmp(hoxmlContext->tag, "imagelayer") == 0 || strcmp(hoxmlContext->tag, "group") == 0) { + if (raytmxState->layer != NULL) { + /* Check for attributes common to all layer types */ + if (strcmp(hoxmlContext->attribute, "id") == 0) + raytmxState->layer->id = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "name") == 0) { + raytmxState->layer->name = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->layer->name, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "class") == 0) { + raytmxState->layer->classString = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->value) + 1); + StringCopy(raytmxState->layer->classString, hoxmlContext->value); + } else if (strcmp(hoxmlContext->attribute, "opacity") == 0) + raytmxState->layer->opacity = atof(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "visible") == 0) + raytmxState->layer->visible = atoi(hoxmlContext->value) != 0 ? true : false; + else if (strcmp(hoxmlContext->attribute, "tintcolor") == 0) { + raytmxState->layer->tintColor = GetColorFromHexString(hoxmlContext->value); + raytmxState->layer->hasTintColor = true; + } else if (strcmp(hoxmlContext->attribute, "offsetx") == 0) + raytmxState->layer->offsetX = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "offsety") == 0) + raytmxState->layer->offsetY = atoi(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "parallaxx") == 0) + raytmxState->layer->parallaxX = atof(hoxmlContext->value); + else if (strcmp(hoxmlContext->attribute, "parallaxy") == 0) + raytmxState->layer->parallaxY = atof(hoxmlContext->value); + } + } /* strcmp(hoxmlContext->tag, "layer") == 0 || strcmp(hoxmlContext->tag, "objectgroup") == 0 || */ + /* strcmp(hoxmlContext->tag, "imagelayer") == 0 || strcmp(hoxmlContext->tag, "group") == 0 */ +} + +void HandleElementEnd(RaytmxState* raytmxState, hoxml_context_t* hoxmlContext) { + if (raytmxState == NULL || hoxmlContext == NULL) + return; + + /* If the element is one of the layer types which share some common attributes that may need default strings */ + if (strcmp(hoxmlContext->tag, "layer") == 0 || strcmp(hoxmlContext->tag, "objectgroup") == 0 || + strcmp(hoxmlContext->tag, "imagelayer") == 0 || strcmp(hoxmlContext->tag, "group") == 0) { + TmxLayer* layer = raytmxState->layer; + if (layer == NULL && raytmxState->groupNode != NULL) + layer = &raytmxState->groupNode->layer; + + if (layer != NULL) { + /* Apply default values for the attribute(s) that aren't covered by a simple memset(x, 0, sizeof(x)) */ + if (layer->name == NULL) { /* If this layer didn't have a 'name' attribute */ + /* The default value for 'name' is "" (an empty string) */ + layer->name = (char*)MemAlloc(1); + layer->name[0] = '\0'; + } + if (layer->classString == NULL) { /* If this layer didn't have a 'class' attribute */ + /* The default value for 'class' is "" (an empty string) */ + layer->classString = (char*)MemAlloc(1); + layer->classString[0] = '\0'; + } + } + } /* strcmp(hoxmlContext->tag, "layer") == 0 || strcmp(hoxmlContext->tag, "objectgroup") == 0 || */ + /* strcmp(hoxmlContext->tag, "imagelayer") == 0 || strcmp(hoxmlContext->tag, "group") == 0 */ + + if (strcmp(hoxmlContext->tag, "properties") == 0) { + if (raytmxState->propertiesRoot == NULL) + return; + /* TMX allows nested properties (e.g. <properties><properties><property/></properties></properties>) but */ + /* that is unsupported. Depth is tracked such that all properties, included nested ones, are appended to one */ + /* array when the outermost element ends. */ + raytmxState->propertiesDepth -= 1; + if (raytmxState->propertiesDepth > 0) /* If the outermost <properties> has not yet ended */ + return; + /* Allocate the array and assign NULL to every index to be safe */ + TmxProperty* properties = (TmxProperty*)MemAllocZero(sizeof(TmxProperty) * raytmxState->propertiesLength); + /* Copy the TmxProperty pointers into the array and free the nodes while we're at it */ + RaytmxPropertyNode* iterator = raytmxState->propertiesRoot; + for (uint32_t i = 0; iterator != NULL; i++) { + properties[i] = iterator->property; + RaytmxPropertyNode* parent = iterator; + iterator = iterator->next; + MemFree(parent); + } + /* Add the properties array to the element it applies to */ + /* A <property>, or rather its parent <properties>, can be within 10+ other elements. The order of the checks */ + /* here is slightly important as the most-nested elements must come first in cases where one may contain */ + /* another (e.g. an <object> within an <objectgroup> layer). */ + if (raytmxState->tilesetTile != NULL && raytmxState->tilesetTile->properties == NULL) { + raytmxState->tilesetTile->properties = properties; + raytmxState->tilesetTile->propertiesLength = raytmxState->propertiesLength; + } + /* else if (raytmxState->wangColor != NULL && raytmxState->wangColor->properties == NULL) { + raytmxState->wangColor->properties = properties; + raytmxState->wangColor->propertiesLength = raytmxState->propertiesLength; + } + else if (raytmxState->wangSet != NULL && raytmxState->wangSet->properties == NULL) { + raytmxState->wangSet->properties = properties; + raytmxState->wangSet->propertiesLength = raytmxState->propertiesLength; + } */ /* TODO: Wang sets. Low priority. */ + else if (raytmxState->tileset != NULL && raytmxState->tileset->properties == NULL) { + raytmxState->tileset->properties = properties; + raytmxState->tileset->propertiesLength = raytmxState->propertiesLength; + } else if (raytmxState->object != NULL && raytmxState->object->properties == NULL) { + raytmxState->object->properties = properties; + raytmxState->object->propertiesLength = raytmxState->propertiesLength; + } else if (raytmxState->layer != NULL && raytmxState->layer->properties == NULL) { + raytmxState->layer->properties = properties; + raytmxState->layer->propertiesLength = raytmxState->propertiesLength; + } else { + raytmxState->mapProperties = properties; + raytmxState->mapPropertiesLength = raytmxState->propertiesLength; + } + /* Clean up the state object */ + raytmxState->propertiesRoot = NULL; + raytmxState->propertiesTail = NULL; + raytmxState->propertiesLength = 0; + } /* strcmp(hoxmlContext->tag, "properties") == 0 */ + else if (strcmp(hoxmlContext->tag, "property") == 0) { + if (raytmxState->property != NULL) { + /* Apply default values for the attribute(s) that aren't covered by a simple memset(x, 0, sizeof(x)) */ + /* Properties are cast and assigned to type-specific variables at the end of the element due to the order */ + /* of the property's attributes not being guaranteed, so we wait until we have all the information */ + switch (raytmxState->property->type) { + case PROPERTY_TYPE_STRING: + default: /* The default type of a property is 'string' */ + if (raytmxState->property->stringValue == NULL) { + if (hoxmlContext->content != NULL) { /* If Tiled opted to put the value in the element's content */ + /* From the documentation: "When a string property contains newlines, the current version of */ + /* Tiled will write out the value as characters contained inside the property element rather */ + /* than as the value attribute." */ + raytmxState->property->stringValue = + (char*)MemAlloc((unsigned int)strlen(hoxmlContext->content) + 1); + StringCopy(raytmxState->property->stringValue, hoxmlContext->content); + } else { /* If the string's value was neither provided as an attribute nor content */ + /* The default value for 'string' is an empty string */ + raytmxState->property->stringValue = (char*)MemAlloc(1); + raytmxState->property->stringValue[0] = '\0'; + } + } break; + case PROPERTY_TYPE_INT: + case PROPERTY_TYPE_OBJECT: + /* The default value for 'int' and 'object' is 0 */ + raytmxState->property->intValue = atoi(raytmxState->property->stringValue); /* Defaults to 0 */ + break; + case PROPERTY_TYPE_FLOAT: + /* The default value for 'float' is 0 */ + raytmxState->property->floatValue = (float)atof(raytmxState->property->stringValue); /* Defaults to 0 */ + break; + case PROPERTY_TYPE_BOOL: + /* The default value for 'bool' is false */ + if (raytmxState->property->stringValue == NULL || + strcmp(raytmxState->property->stringValue, "true") != 0) + raytmxState->property->boolValue = false; + else + raytmxState->property->boolValue = true; + break; + case PROPERTY_TYPE_COLOR: + /* The default value for 'color' is the color #00000000 */ + if (raytmxState->property->stringValue == NULL) + raytmxState->property->colorValue = BLANK; /* #defined by raylib as { 0, 0, 0, 0 } */ + else + raytmxState->property->colorValue = GetColorFromHexString(raytmxState->property->stringValue); + break; + case PROPERTY_TYPE_FILE: + /* The default value for 'file' is "." */ + if (raytmxState->property->stringValue == NULL) { + raytmxState->property->stringValue = (char*)MemAlloc(2); + raytmxState->property->stringValue[0] = '.'; + raytmxState->property->stringValue[1] = '\0'; + } break; + } /* switch (raytmxState->property->type) */ + + /* If the type was neither 'string' nor 'file' and 'stringValue' is set */ + if (raytmxState->property->type != PROPERTY_TYPE_STRING && + raytmxState->property->type != PROPERTY_TYPE_FILE && raytmxState->property->stringValue != NULL) { + /* Properties of types other than 'string' and 'file' are placed in 'stringValue' temporarily. Now */ + /* that they have been cast and assigned appropriately, 'stringValue' can be freed. */ + MemFree(raytmxState->property->stringValue); + raytmxState->property->stringValue = NULL; + } + } + raytmxState->property = NULL; + } /* strcmp(hoxmlContext->tag, "property") == 0 */ + else if (strcmp(hoxmlContext->tag, "tileset") == 0) { + if (raytmxState->tileset != NULL) { + /* Apply default values for the attribute(s) that aren't covered by a simple memset(x, 0, sizeof(x)) */ + if (raytmxState->tileset->name == NULL) { /* If this <tileset> didn't have a 'name' attribute */ + /* The default value for 'name' is "" (an empty string) */ + raytmxState->tileset->name = (char*)MemAlloc(1); + raytmxState->tileset->name[0] = '\0'; + } + if (raytmxState->tileset->classString == NULL) { /* If this <tileset> didn't have a 'class' attribute */ + /* The default value for 'class' is "" (an empty string) */ + raytmxState->tileset->classString = (char*)MemAlloc(1); + raytmxState->tileset->classString[0] = '\0'; + } + if (raytmxState->tileset->objectAlignment == OBJECT_ALIGNMENT_UNSPECIFIED) { + /* There are default object alignments for orthogonal and isometric modes */ + if (raytmxState->mapOrientation == ORIENTATION_ORTHOGONAL) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_BOTTOM_LEFT; + else if (raytmxState->mapOrientation == ORIENTATION_ISOMETRIC) + raytmxState->tileset->objectAlignment = OBJECT_ALIGNMENT_BOTTOM; + } + + if (raytmxState->tilesetTilesRoot != NULL) { + /* Allocate the array and zeroize every index as initialization */ + TmxTilesetTile* tiles = (TmxTilesetTile*)MemAllocZero(sizeof(TmxTilesetTile) * + raytmxState->tilesetTilesLength); + /* Copy the TmxTilesetTile pointers into the array and free the nodes while we're at it */ + RaytmxTilesetTileNode* iterator = raytmxState->tilesetTilesRoot; + for (uint32_t i = 0; i < raytmxState->tilesetTilesLength && iterator != NULL; i++) { + tiles[i] = iterator->tile; + RaytmxTilesetTileNode* parent = iterator; + iterator = iterator->next; + MemFree(parent); + } + /* Add the tiles array to the tileset */ + raytmxState->tileset->tiles = tiles; + raytmxState->tileset->tilesLength = raytmxState->tilesetTilesLength; + /* Clean up the state object */ + raytmxState->tilesetTilesRoot = NULL; + raytmxState->tilesetTilesTail = NULL; + raytmxState->tilesetTilesLength = 0; + } + } + raytmxState->tileset = NULL; + } /* strcmp(hoxmlContext->tag, "tileset") == 0 */ + else if (strcmp(hoxmlContext->tag, "image") == 0) + raytmxState->image = NULL; + else if (strcmp(hoxmlContext->tag, "animation") == 0) { + if (raytmxState->tilesetTile != NULL && raytmxState->tilesetTile->hasAnimation) { + if (raytmxState->animationFramesRoot == NULL) + return; + /* Allocate the array and zeroize every index as initialization */ + TmxAnimationFrame* frames = (TmxAnimationFrame*)MemAllocZero(sizeof(TmxAnimationFrame) * + raytmxState->animationFramesLength); + /* Copy the TmxAnimationFrame pointers into the array and free the nodes while we're at it */ + RaytmxAnimationFrameNode* iterator = raytmxState->animationFramesRoot; + for (uint32_t i = 0; iterator != NULL; i++) { + frames[i] = iterator->frame; + RaytmxAnimationFrameNode* parent = iterator; + iterator = iterator->next; + MemFree(parent); + } + /* Add the frames array to the tile's animation */ + raytmxState->tilesetTile->animation.frames = frames; + raytmxState->tilesetTile->animation.framesLength = raytmxState->animationFramesLength; + /* Clean up the state object */ + raytmxState->animationFramesRoot = NULL; + raytmxState->animationFramesTail = NULL; + raytmxState->animationFramesLength = 0; + } + } /* strcmp(hoxmlContext->tag, "animation") == 0 */ + else if (strcmp(hoxmlContext->tag, "frame") == 0) + raytmxState->animationFrame = NULL; + else if (strcmp(hoxmlContext->tag, "layer") == 0) { + if (raytmxState->tileLayer != NULL) { + /* If there were 1+ <tile>s within this <layer> but this <layer> already has tiles (from a <data>?) */ + if (raytmxState->layerTilesRoot != NULL && raytmxState->tileLayer->tiles != NULL) { + TraceLog(LOG_WARNING, "RAYTMX: layer \"%s\" has more than one source of tile data - the latter tiles " + "for this layer will be dropped", raytmxState->layer->name); + /* Free the nodes and tiles therein */ + RaytmxTileLayerTileNode* iterator = raytmxState->layerTilesRoot; + while (iterator != NULL) { + RaytmxTileLayerTileNode* parent = iterator; + iterator = iterator->next; + MemFree(parent); + } + } else { + /* Allocate the array and zeroize every index as initialization */ + uint32_t* tiles = (uint32_t*)MemAllocZero(sizeof(uint32_t) * raytmxState->layerTilesLength); + /* Copy the GID into the array and free the nodes while we're at it */ + RaytmxTileLayerTileNode* iterator = raytmxState->layerTilesRoot; + for (uint32_t i = 0; iterator != NULL; i++) { + tiles[i] = iterator->gid; + RaytmxTileLayerTileNode* parent = iterator; + iterator = iterator->next; + MemFree(parent); + } + /* Add the tiles array to the tile layer */ + raytmxState->tileLayer->tiles = tiles; + raytmxState->tileLayer->tilesLength = raytmxState->layerTilesLength; + } + /* Clean up the state object */ + raytmxState->layerTilesRoot = NULL; + raytmxState->layerTilesTail = NULL; + raytmxState->layerTilesLength = 0; + } + raytmxState->tileLayer = NULL; + raytmxState->layer = NULL; + } /* strcmp(hoxmlContext->tag, "layer") == 0 */ + else if (strcmp(hoxmlContext->tag, "tile") == 0) { + if (raytmxState->tilesetTile != NULL) { + /* Apply default values for the attribute(s) that aren't covered by a simple memset(x, 0, sizeof(x)) */ + if (raytmxState->tilesetTile->classString == NULL) { /* If this <tile> didn't have a 'class' attribute */ + /* The default value for 'class' is "" (an empty string) */ + raytmxState->tilesetTile->classString = (char*)MemAlloc(1); + raytmxState->tilesetTile->classString[0] = '\0'; + } + if (raytmxState->tilesetTile->hasImage) { + /* The 'width' and 'height' attributes default to the tile's image's width and height, respectively */ + if (raytmxState->tilesetTile->width == 0) + raytmxState->tilesetTile->width = raytmxState->tilesetTile->image.width; + if (raytmxState->tilesetTile->height == 0) + raytmxState->tilesetTile->height = raytmxState->tilesetTile->image.height; + } + raytmxState->tilesetTile = NULL; + } + } /* strcmp(hoxmlContext->tag, "tile") == 0 */ + else if (strcmp(hoxmlContext->tag, "data") == 0) { + if (raytmxState->image != NULL) { + /* TODO (?): The TMX map format documentation says an <image> can contain a <data> element but doesn't */ + /* provide any more information than that. Tiled doesn't seem to have a feature for this either. */ + } else if (raytmxState->tileLayer != NULL && raytmxState->tileLayer->tiles != NULL) { + TraceLog(LOG_WARNING, "RAYTMX: layer \"%s\" has more than one source of tile data - the latter tiles for " + "this layer will be dropped", raytmxState->layer->name); + } else if (raytmxState->tileLayer != NULL && raytmxState->tileLayer->encoding != NULL) { + RaytmxTileLayerTileNode* tiles = NULL; + if (strcmp(raytmxState->tileLayer->encoding, "base64") == 0) { + /* The layer's data is a series of unsigned, 32-bit integers encoded as a Base64 string. But, XML */ + /* considers everything between <data> and </data> to be content meaning there is probably some */ + /* whitespace on both ends of the content we need to ignore. So, find the actual start and stop: */ + char *encodedStart = hoxmlContext->content, *encodedEnd; + while (isspace(*encodedStart)) + encodedStart++; + encodedEnd = encodedStart + strlen(encodedStart) - 1; + while (encodedEnd > encodedStart && isspace(*encodedEnd)) + encodedEnd--; + + /* With the string of encoded Base64 data trimmed, decode it */ + int decodedLength; + unsigned char* decoded = DecodeDataBase64((const unsigned char*)encodedStart, &decodedLength); + if (decoded != NULL) { + if (raytmxState->tileLayer->compression == NULL) { /* If the Base64-encoded data is uncompressed */ + /* Iterate through N bytes ('decodedLength') with every four bytes being a single GID */ + /* resulting in N / 4 tiles */ + uint32_t* iterator = (uint32_t*)decoded; + for (int i = 0; i < decodedLength / 4; i++) { + AddTileLayerTile(raytmxState, *iterator); + iterator += 1; /* Point to the next unsigned, 32-bit integer in the decoded data */ + } + } else { /* If the Base-64encoded data is also compressed */ + if (strcmp(raytmxState->tileLayer->compression, "gzip") == 0 || + strcmp(raytmxState->tileLayer->compression, "zlib") == 0) { + unsigned char* postHeaderDecoded = NULL; + if (strcmp(raytmxState->tileLayer->compression, "gzip") == 0) { + /* The first two bytes of a GZIP header are expected to be a magic number, 0x1F8B, */ + /* identifying the format and the third is expected to indicate the compression */ + /* method where 0x08 is DEFLATE. */ + /* If these values are found, decompression can continue */ + if (decoded[0] == 0x1F && decoded[1] == 0x8B && decoded[2] == 0x08) { + /* Skip past the GZIP header. The header is typically ten bytes. The bytes not */ + /* checked are unimportant things like a timestamp and OS ID. Additional optional */ + /* headers are possible but not used by Tiled so they are assumed to be missing. */ + postHeaderDecoded = decoded + 10; + } else { /* If the GZIP header doesn't match a decompressable one */ + TraceLog(LOG_ERROR, "RAYTMX: Layer \"%s\" uses GZIP compression but the stream's " + "header doesn't indicate DEFLATE compression", raytmxState->layer->name); + } + } else /* if (strcmp(raytmxState->tileLayer->compression, "zlib") == 0) */ { + /* The first byte of a ZLIB header is expected to be 0x78 where the 8 indicates the */ + /* DEFLATE compression method and the 7 is "compression info" that indicates a 32K */ + /* LZ77 window size and, in practice, cannot be anything else. */ + /* If these values are found, decompression can continue */ + if (decoded[0] == 0x78) { + /* Skip past the ZLIB header. The header is two bytes. */ + postHeaderDecoded = decoded + 2; + } else { /* If the ZLIB header doesn't match a decompressable one */ + TraceLog(LOG_ERROR, "RAYTMX: Layer \"%s\" uses ZLIB compression but the stream's " + "header doesn't indicate DEFLATE compression", raytmxState->layer->name); + } + } + + if (postHeaderDecoded != NULL) { + /* "zlib" and "gzip" both use the DEFLATE algorithm and raylib provides a */ + /* decompression function when it's built with SUPPORT_COMPRESSION_API (default) */ + int decompressedLength; + unsigned char* decompressed = DecompressData(postHeaderDecoded, decodedLength, + &decompressedLength); + if (decompressed != NULL && decompressedLength > 0) { + uint32_t* iterator = (uint32_t*)decompressed; + for (int i = 0; i < decompressedLength / 4; i++) { + AddTileLayerTile(raytmxState, *iterator); + iterator += 1; /* Point to the next unsigned integer in the decompressed data */ + } + MemFree(decompressed); /* Free the memory allocated by DecompressData() */ + } else { /* raylib wasn't built with compression or allocation failed */ + TraceLog(LOG_ERROR, "RAYTMX: Layer \"%s\" compressed with \"%s\" cannot be parsed " + "because DEFLATE decompression failed - either raylib was not built with " + "SUPPORT_COMPRESSION_API or memory allocation failed", raytmxState->layer->name, + raytmxState->tileLayer->compression); + } + } + } else { + TraceLog(LOG_ERROR, "RAYTMX: Layer \"%s\" cannot be parsed because the compression method " + "\"%s\" is unsupported", raytmxState->layer->name, raytmxState->tileLayer->compression); + } + } + MemFree(decoded); /* Free the memory allocated by DecodeDataBase64() */ + } else { + TraceLog(LOG_ERROR, "RAYTMX: Unable to decode Base64 data for layer \"%s\"", + raytmxState->layer->name); + } + } /* strcmp(raytmxState->tileLayer->encoding, "base64") == 0 */ + else if (strcmp(raytmxState->tileLayer->encoding, "csv") == 0) { + /* The Comma-Separated Value (CSV) list herein is a series of Global IDs (GIDs) of tiles in the form */ + /* "31,32,33" where 31, 32, and 33 are GIDs */ + char valueAsString[16]; /* Needs to fit all digits of a single value - should be more than enough */ + char* iterator = hoxmlContext->content; + while (iterator != NULL && *iterator != '\0') { /* While not pointing to the end of the string */ + memset(valueAsString, '\0', 16); /* Reset the value-as-a-string buffer with all zeroes */ + /* Copy each character into the buffer until either a comma or the terminator is reached */ + for (int i = 0; *iterator != ',' && *iterator != '\0'; i++) { + memcpy(valueAsString + i, iterator, 1); + iterator++; + } + if (*iterator == ',') /* If iteration was paused by a comma */ + iterator++; /* Advance one character so the comma isn't parsed with the value next iteration */ + AddTileLayerTile(raytmxState, atoi(valueAsString)); /* Read the value as an integer GID */ + } + } /* strcmp(raytmxState->tileLayer->encoding, "csv") == 0 */ + + if (tiles != NULL) { /* If there was no error in parsing the data and there's a linked list of tiles */ + /* Allocate the array and assign 0 to every index to be safe */ + uint32_t* tiles = (uint32_t*)MemAlloc(sizeof(uint32_t) * raytmxState->layerTilesLength); + memset(tiles, 0, sizeof(uint32_t) * raytmxState->layerTilesLength); + /* Copy the GIDs into the array and free the nodes while we're at it */ + RaytmxTileLayerTileNode* layerTilesIterator = raytmxState->layerTilesRoot; + for (uint32_t i = 0; i < raytmxState->layerTilesLength && layerTilesIterator != NULL; i++) { + tiles[i] = layerTilesIterator->gid; + RaytmxTileLayerTileNode* layerTilesTemp = layerTilesIterator; + layerTilesIterator = layerTilesIterator->next; + MemFree(layerTilesTemp); + } + /* Add the tiles array to the element it applies to */ + raytmxState->tileLayer->tiles = tiles; + raytmxState->tileLayer->tilesLength = raytmxState->layerTilesLength; + /* Clean up the state object */ + raytmxState->layerTilesRoot = NULL; + raytmxState->layerTilesTail = NULL; + raytmxState->layerTilesLength = 0; + } + } /* raytmxState->tileLayer != NULL && raytmxState->tileLayer->encoding != NULL */ + } /* strcmp(hoxmlContext->tag, "data") == 0 */ + else if (strcmp(hoxmlContext->tag, "objectgroup") == 0) { + if (raytmxState->objectGroup != NULL) { + if (raytmxState->objectsRoot == NULL) + return; + /* Allocate the arrays and zeroize every index as initialization */ + TmxObject* objects = (TmxObject*)MemAllocZero(sizeof(TmxObject) * raytmxState->objectsLength); + uint32_t* ySortedObjects = (uint32_t*)MemAllocZero(sizeof(uint32_t) * raytmxState->objectsLength); + /* Create a contiguous array of TmxObjects, create a sorted linked list of indexes within that array of */ + /* TmxObjects (sorted by ascending y-coordinate), and free the object linked list */ + RaytmxObjectNode *objectsIterator = raytmxState->objectsRoot, *objectsTemp; + RaytmxObjectSortingNode *sortingRoot = NULL, *sortingIterator, *sortingTemp, *newSortingNode; + for (uint32_t i = 0; objectsIterator != NULL; i++) { + objects[i] = objectsIterator->object; + /* Add a new node into the sorted list */ + newSortingNode = (RaytmxObjectSortingNode*)MemAllocZero(sizeof(RaytmxObjectSortingNode)); + newSortingNode->y = objects[i].y; + newSortingNode->index = i; + if (sortingRoot == NULL) /* If this is the first node */ + sortingRoot = newSortingNode; + else if (sortingRoot->y >= newSortingNode->y) { /* If replacing the root node */ + newSortingNode->next = sortingRoot; + sortingRoot = newSortingNode; + } else { /* If inserting at some location after the root */ + sortingIterator = sortingRoot; + while (sortingIterator->next != NULL && newSortingNode->y > sortingIterator->next->y) + sortingIterator = sortingIterator->next; + newSortingNode->next = sortingIterator->next; + sortingIterator->next = newSortingNode; + } + /* Free the object node */ + objectsTemp = objectsIterator; + objectsIterator = objectsIterator->next; + MemFree(objectsTemp); + } + /* Create a contiguous array from the sorted linked list such that index 0 of this array points to the */ + /* TmxObject (via its index in 'objects') with the lowest (visually, highest) y-coordinate */ + sortingIterator = sortingRoot; + for (uint32_t i = 0; sortingIterator != NULL; i++) { + ySortedObjects[i] = sortingIterator->index; + sortingTemp = sortingIterator; + sortingIterator = sortingIterator->next; + MemFree(sortingTemp); + } + /* Add the objects and ySortedObjects array to the object layer */ + raytmxState->objectGroup->objects = objects; + raytmxState->objectGroup->objectsLength = raytmxState->objectsLength; + raytmxState->objectGroup->ySortedObjects = ySortedObjects; + /* Clean up the state object */ + raytmxState->objectsRoot = NULL; + raytmxState->objectsTail = NULL; + raytmxState->objectsLength = 0; + } + raytmxState->objectGroup = NULL; + raytmxState->layer = NULL; + } else if (strcmp(hoxmlContext->tag, "object") == 0) { + if (raytmxState->object != NULL) { + /* Apply default values for the attribute(s) that aren't covered by a simple memset(x, 0, sizeof(x)) */ + if (raytmxState->object->name == NULL) { /* If this <object> didn't have a 'name' attribute */ + /* The default value for 'name' is "" (an empty string) */ + raytmxState->object->name = (char*)MemAlloc(1); + raytmxState->object->name[0] = '\0'; + } + if (raytmxState->object->typeString == NULL) { /* If this <object> didn't have a 'type' attribute */ + /* The default value for 'type' is "" (an empty string) */ + raytmxState->object->typeString = (char*)MemAlloc(1); + raytmxState->object->typeString[0] = '\0'; + } + + if (raytmxState->object->templateString != NULL) { + /* During editing, objects can be created from templates with pre-defined values and/or <properties>, */ + /* a concept similar to copying and pasting or instancing. These templates are saved in external TX */ + /* files that the 'template' attribute points to. Try to load it. */ + RaytmxCachedTemplateNode* cachedTemplate = LoadCachedTemplate(raytmxState, + raytmxState->object->templateString); + if (cachedTemplate != NULL) { + RaytmxObjectTemplate objectTemplate = cachedTemplate->objectTemplate; + /* The template's <object> will contain some subset of values and/or <properties> that apply to */ + /* the instanced <object> referencing it. For example, if the template's <object> has a 'name' */ + /* attribute with the value "cactus" then the instanced <object> will also have a 'name' */ + /* attribute. "cactus" is a default value that will be used if the instanced <object> does not */ + /* define one of its own. The template's <object> needs to be checked for non-default values and */ + /* <properties> and they need to be applied to the instanced <object> where none exist. */ + if (objectTemplate.object.name != NULL && raytmxState->object->name == NULL) { + raytmxState->object->name = + (char*)MemAllocZero((unsigned int)strlen(objectTemplate.object.name) + 1); + StringCopy(raytmxState->object->name, objectTemplate.object.name); + } + if (objectTemplate.object.typeString != NULL && raytmxState->object->typeString != NULL) { + raytmxState->object->typeString = + (char*)MemAllocZero((unsigned int)strlen(objectTemplate.object.typeString) + 1); + StringCopy(raytmxState->object->typeString, objectTemplate.object.typeString); + } + if (objectTemplate.object.x != 0.0 && raytmxState->object->x == 0.0) + raytmxState->object->x = objectTemplate.object.x; + if (objectTemplate.object.y != 0.0 && raytmxState->object->y == 0.0) + raytmxState->object->y = objectTemplate.object.y; + if (objectTemplate.object.width != 0.0 && raytmxState->object->width == 0.0) + raytmxState->object->width = objectTemplate.object.width; + if (objectTemplate.object.height != 0.0 && raytmxState->object->height == 0.0) + raytmxState->object->height = objectTemplate.object.height; + if (objectTemplate.object.rotation != 0.0 && raytmxState->object->rotation == 0.0) + raytmxState->object->rotation = objectTemplate.object.rotation; + if (objectTemplate.object.gid != 0 && raytmxState->object->gid == 0) + raytmxState->object->gid = objectTemplate.object.gid; + if (!objectTemplate.object.visible && raytmxState->object->visible) + raytmxState->object->visible = false; + /* TMX documentation doesn't specify some particulars of templates, namely if it is possible for */ + /* a template to be type-specific. In other words, can a template be a polygon? If so, are points */ + /* merged or replaced? Based on Tiled's behavior, templates do not have type-specific values or, */ + /* at least, they are ignored if they exist. However, <properties> are definitely merged. */ + /* If the template's <object> has <properties> */ + if (objectTemplate.object.properties != NULL) { + /* There are two cases here: the instanced <object> already has properties, or it doesn't */ + if (raytmxState->object->properties == NULL) { /* If the instance doesn't have <properties> */ + /* This is the easy case. Just copy the pointer to the existing array. */ + raytmxState->object->properties = objectTemplate.object.properties; + raytmxState->object->propertiesLength = objectTemplate.object.propertiesLength; + } else { + /* The two <properties> need to be merged keeping in mind that they may, or probably, */ + /* have overlapping entries. (When both have properties of the same name, the instanced */ + /* <object>'s takes priority.) Create a linked list from which to create this new, merged */ + /* properties array. */ + RaytmxPropertyNode *propertiesRoot = NULL, *propertiesTail = NULL, *node; + uint32_t propertiesLength = 0; + /* Add the properties from the instanced <object> */ + for (uint32_t i = 0; i < raytmxState->object->propertiesLength; i++) { + node = (RaytmxPropertyNode*)MemAllocZero(sizeof(RaytmxPropertyNode)); + node->property = raytmxState->object->properties[i]; + if (propertiesRoot == NULL) + propertiesRoot = node; + else + propertiesTail->next = node; + propertiesTail = node; + propertiesLength += 1; + } + /* Add the properties from the template's <object> if they do not already exist */ + for (uint32_t i = 0; i < objectTemplate.object.propertiesLength; i++) { + RaytmxPropertyNode* propertiesIterator = propertiesRoot; + bool isNew = true; + while (propertiesIterator != NULL) { + if (strcmp(objectTemplate.object.properties[i].name, + propertiesIterator->property.name) == 0) { + isNew = false; + break; + } + propertiesIterator = propertiesIterator->next; + } + if (isNew) { + node = (RaytmxPropertyNode*)MemAllocZero(sizeof(RaytmxPropertyNode)); + node->property = objectTemplate.object.properties[i]; + if (propertiesRoot == NULL) + propertiesRoot = node; + else + propertiesTail->next = node; + propertiesTail = node; + propertiesLength += 1; + } + } + /* Free the separate array that was previously allocated */ + MemFree(raytmxState->object->properties); + /* Allocate a new array to be populated with the merged properties */ + raytmxState->object->properties = + (TmxProperty*)MemAllocZero(sizeof(TmxProperty) * propertiesLength); + raytmxState->object->propertiesLength = propertiesLength; + /* Copy the TmxProperty entires into the array and free the nodes while we're at it */ + RaytmxPropertyNode* propertiesIterator = propertiesRoot; + for (uint32_t i = 0; propertiesIterator != NULL; i++) { + raytmxState->object->properties[i] = propertiesIterator->property; + RaytmxPropertyNode* propertiesTemp = propertiesIterator; + propertiesIterator = propertiesIterator->next; + MemFree(propertiesTemp); + } + } + } + } else + TraceLog(LOG_WARNING, "RAYTMX: Unable to apply template to object ID %u", raytmxState->object->id); + } + + /* Calculate the Axis-Aligned Bounding Box (AABB) of the object. This can vary by object type. Due to the */ + /* possibility of 'width' and 'height' being derived from a template, these must be calculated after a */ + /* template is applied to the object. */ + switch (raytmxState->object->type) { + case OBJECT_TYPE_RECTANGLE: + case OBJECT_TYPE_ELLIPSE: + case OBJECT_TYPE_TEXT: + raytmxState->object->aabb.x = (float)raytmxState->object->x; + raytmxState->object->aabb.y = (float)raytmxState->object->y; + raytmxState->object->aabb.width = (float)raytmxState->object->width; + raytmxState->object->aabb.height = (float)raytmxState->object->height; + break; + case OBJECT_TYPE_POINT: + { + raytmxState->object->aabb.x = (float)raytmxState->object->x; + raytmxState->object->aabb.y = (float)raytmxState->object->y; + raytmxState->object->aabb.width = 0.0f; + raytmxState->object->aabb.height = 0.0f; + } + break; + case OBJECT_TYPE_POLYGON: + case OBJECT_TYPE_POLYLINE: + { + float minX = INFINITY, maxX = -INFINITY, minY = INFINITY, maxY = -INFINITY; + for (uint32_t i = 1; i < raytmxState->object->pointsLength; i++) { + Vector2 point = raytmxState->object->points[i]; + if (point.x < minX) + minX = point.x; + if (point.x > maxX) + maxX = point.x; + if (point.y < minY) + minY = point.y; + if (point.y > maxY) + maxY = point.y; + } + /* Note: Poly(gon|line) objects' vertices are stored with relative positions whereas AABBs use */ + /* absolute values. The object's X and Y values must be added. */ + raytmxState->object->aabb.x = minX + (float)raytmxState->object->x; + raytmxState->object->aabb.y = minY + (float)raytmxState->object->y; + raytmxState->object->aabb.width = maxX - minX; + raytmxState->object->aabb.height = maxY - minY; + } + break; + case OBJECT_TYPE_TILE: + /* The tile object type can have varying sizes, depending on the tile. While most will have the width */ + /* and height defined in the top-level <map>, a "collection of images" tileset will have tiles with */ + /* arbitrary dimensions. For that reason, an AABB cannot be calculated. */ + break; + } + } + raytmxState->object = NULL; + } /* strcmp(hoxmlContext->tag, "object") == 0 */ + else if (strcmp(hoxmlContext->tag, "text") == 0) { + /* Apply default values for the attribute(s) that aren't covered by a simple memset(x, 0, sizeof(x)) */ + if (raytmxState->object != NULL && raytmxState->object->text != NULL) { + TmxObject* object = raytmxState->object; + TmxText* objectText = object->text; + if (hoxmlContext->content != NULL) { /* If the element had content e.g. <text>Content here</text> */ + objectText->content = (char*)MemAllocZero((unsigned int)strlen(hoxmlContext->content) + 1); + StringCopy(objectText->content, hoxmlContext->content); + } + + if (objectText->fontFamily == NULL) { /* If this <text> didn't have a 'fontfamily' attribute */ + /* The default value for 'fontfamily' is "sans-serif" */ + objectText->fontFamily = (char*)MemAllocZero((unsigned int)strlen("sans-serif") + 1); + StringCopy(objectText->fontFamily, "sans-serif"); + } + + if (objectText->content != NULL) { /* If there's text to be drawn */ + RaytmxTextLineNode *linesRoot = NULL, *linesTail = NULL; + uint32_t linesLength = 0; + + /* There's some aligning and allocating to be done in order to draw the text. This isn't something */ + /* that should be done per-draw and, given the text is static, can be done ahead of time. */ + Font font = GetFontDefault(); + float spacing = 1.0f * (objectText->kerning ? 1.0f : 0.0f); + + unsigned int bufferLength = (unsigned int)strlen(objectText->content) + 1; + /* This buffer will hold hold subsets of the content while iterating through it. The string in this */ + /* buffer may exceed the bounds. */ + char* testingBuffer = (char*)MemAllocZero(bufferLength); + /* This one will hold the last known good string whose graphical text would fit within the bounds */ + char* validBuffer = (char*)MemAllocZero(bufferLength); + /* This one will hold space-delimited subsets of the above */ + char* delimtedBuffer = (char*)MemAllocZero(bufferLength); + bool isDelimited = false; + + char *start = objectText->content, *end = start, *validEnd = start, *delimitedEnd = start; + /* While the 'end' iterator hasn't reached the end of the content AND further lines will fit within */ + /* the Y bounds of the object */ + while (*end != '\0' && + object->y + (objectText->pixelSize * (linesLength + 1)) <= object->y + object->height) { + end++; + int length = (int)(end - start); + if (length <= 0) /* Quick error check for a case that is hopefully impossible in practice */ + continue; + + StringCopyN(testingBuffer, start, length); + /* Remove any trailing whitespace by iterating backwards and adding a terminator in place of any */ + /* whitespace character */ + for (char* i = testingBuffer + length - 1; i > testingBuffer && isspace(*i); i--) + *i = '\0'; + + /* Measure the dimensions of the now-widest text */ + Vector2 textSize = MeasureTextEx(font, testingBuffer, (float)objectText->pixelSize, spacing); + /* If this text still fits within the width of the object (the bounds) */ + if (textSize.x <= object->width) { + /* This string is still valid. Remember the string and where it ends. Iteration may return to */ + /* last known good position. */ + validEnd = end; + StringCopy(validBuffer, testingBuffer); + /* Note: Because the testing buffer is stripped of trailing whitespace, so too is this one */ + + /* If the end of the current string is whitespace but the last character wasn't */ + if (isspace(*end) && !isspace(*(end - 1))) { + /* Taking "Hello, from TMX!" as an example, this would be triggered by the first space */ + /* with "Hello," being the string to remember. In the event that the would-be text is too */ + /* wide, meaning "Hello, from" is too long to fit width-wise, then this delimted "Hello," */ + /* will be the line and iteration will return to "from." */ + isDelimited = true; + delimitedEnd = end; + StringCopy(delimtedBuffer, validBuffer); + } + } + + /* If it's time to create a visual line of text from the string either because: 1) the string has */ + /* become too wide to fit in the bounds of the object, or 2) the end of the content was reached */ + if (textSize.x > object->width || *end == '\0') { + char* sourceBuffer; + if (*end == '\0' || !isDelimited) { + /* The valid buffer is used in cases where the would-be text is simply the remainder of */ + /* the content or the line does not have a clear separator (whitespace), like an extra */ + /* long word that continues to the next line */ + sourceBuffer = validBuffer; + start = validEnd; + } else { + /* The delimited buffer is used in cases where one or more words were identified using */ + /* space between them as a delimiter */ + sourceBuffer = delimtedBuffer; + start = delimitedEnd; + /* Skip over any whitespace at the delimiter */ + while (isspace(*start) && *start != '\0') + start++; + } + + /* The 'start' pointer is pointing to the first character of the next line. Point 'end' */ + /* to the same place and continue from there so nothing is skipped. Note: 'end' will be */ + /* incremented at the start of the next loop. */ + end = start; + + TmxTextLine line; + line.content = (char*)MemAllocZero((unsigned int)strlen(sourceBuffer) + 1); + StringCopy(line.content, sourceBuffer); + line.font = font; + line.spacing = spacing; + /* Note: The number of lines is not yet known but needs to be for Y positioning */ + + RaytmxTextLineNode* node = (RaytmxTextLineNode*)MemAllocZero(sizeof(RaytmxTextLineNode)); + node->line = line; + if (linesRoot == NULL) + linesRoot = node; + else + linesTail->next = node; + linesTail = node; + linesLength += 1; + + /* Reset variables */ + memset(testingBuffer, '\0', bufferLength); + memset(validBuffer, '\0', bufferLength); + memset(delimtedBuffer, '\0', bufferLength); + isDelimited = false; + + if (!objectText->wrap) { /* If word wrapping is disabled */ + /* It's unclear why this would be done but, having hit the end of what can be displayed */ + /* on a single line, no more text can be appended */ + break; + } + } /* textSize.x > object->width || *end == '\0' */ + } /* *end != '\0' && */ + /* object->y + (objectText->pixelSize * (linesLength + 1)) <= object->y + object->height */ + + MemFree(testingBuffer); + MemFree(validBuffer); + MemFree(delimtedBuffer); + + if (linesRoot != NULL) { + /* Allocate the array and zero out every value as initialization */ + TmxTextLine* lines = (TmxTextLine*)MemAllocZero(sizeof(TmxTextLine) * linesLength); + /* Copy the TmxTextLines into the array and free the nodes while we're at it */ + RaytmxTextLineNode* iterator = linesRoot; + for (uint32_t i = 0; i < linesLength && iterator != NULL; i++) { + lines[i] = iterator->line; + Vector2 textSize = MeasureTextEx(font, lines[i].content, (float)objectText->pixelSize, + lines[i].spacing); + + /* Horizontal alignment */ + if (objectText->halign == HORIZONTAL_ALIGNMENT_RIGHT) + lines[i].position.x = (float)(object->x + object->width) - textSize.x; + else if (objectText->halign == HORIZONTAL_ALIGNMENT_CENTER) + lines[i].position.x = (float)(object->x + (object->width / 2.0)) - (textSize.x / 2.0f); + else if (objectText->halign == HORIZONTAL_ALIGNMENT_JUSTIFY) { + /* Horizontally justified text extends from the left bound to the right bound. Typically, */ + /* this is done by adding space betweens words or, where there is only one word, adding */ + /* space between letters. All additional space is distributed evenly. However, the method */ + /* here is a hybrid: because control over spacing between words is coarse, spacing */ + /* between letters is added on top of it. */ + lines[i].position.x = (float)object->x; /* Place the text on the left bound */ + /* Count the number of spaces between words */ + uint32_t numSpaces = 0; + for (uint32_t j = 0; lines[i].content[j] != '\0'; j++) { + if (isspace(lines[i].content[j])) + numSpaces++; + } + size_t length = strlen(lines[i].content); + if (numSpaces > 0) { /* If there's more than one word in the line */ + /* Measure the dimensions of a single space using this line's configuration */ + Vector2 originalTextSize = textSize; + textSize = MeasureTextEx(font, " ", (float)objectText->pixelSize, lines[i].spacing); + /* Calculate the number of new spaces to add between words, per existing space */ + float idealNumAdditionalSpaces = + ((float)object->width - originalTextSize.x) / textSize.x; + uint32_t numSpacesToAddPer = + (uint32_t)floor((idealNumAdditionalSpaces - (float)numSpaces) / (float)numSpaces); + /* Create a new string with the additional space */ + size_t justifiedLength = length + (numSpacesToAddPer * numSpaces); + char* justifiedContent = (char*)MemAllocZero((unsigned int)justifiedLength + 1); + uint32_t sourceIndex = 0, destinationIndex = 0; + while (lines[i].content[sourceIndex] != '\0') { + justifiedContent[destinationIndex++] = lines[i].content[sourceIndex]; + /* If the current character is whitespace but the next one is not */ + if (sourceIndex < length && !isspace(lines[i].content[sourceIndex]) && + isspace(lines[i].content[sourceIndex + 1])) { + /* Add 'numSpacesToAddPer' spaces to the justified string */ + for (uint32_t j = 0; j < numSpacesToAddPer; j++) + justifiedContent[destinationIndex++] = ' '; + } + sourceIndex++; + } + /* Free the original content buffer and replace it with the justified one */ + MemFree(lines[i].content); + lines[i].content = justifiedContent; + length = justifiedLength; + } + /* Calculate a spacing, between each letter, with which the drawn text will span the full */ + /* width of the bounds */ + textSize = MeasureTextEx(font, lines[i].content, (float)objectText->pixelSize, 0.0f); + lines[i].spacing = (float)((object->width - textSize.x) / (double)(length - 1)); + } /* objectText->halign == HORIZONTAL_ALIGNMENT_JUSTIFY */ + else /* if (objectText->halign == HORIZONTAL_ALIGNMENT_LEFT) */ + lines[i].position.x = (float)object->x; + + /* Vertical alignment */ + if (objectText->valign == VERTICAL_ALIGNMENT_BOTTOM) { + lines[i].position.y = (float)(object->y + object->height) - + (float)(objectText->pixelSize * (i + 1)); + } else if (objectText->valign == VERTICAL_ALIGNMENT_CENTER) { + float totalLineHeight = (float)(objectText->pixelSize * linesLength); /* All N lines */ + lines[i].position.y = (float)object->y + /* Top of the <object>'s bounds */ + ((float)object->height / 2.0f) + /* Vertical center of the <object>'s bounds */ + (totalLineHeight / 2.0f) - /* Bottom of the centered lines' bounds */ + (float)(objectText->pixelSize * (i + 1)); + } else /* if (objectText->valign == VERTICAL_ALIGNMENT_TOP) */ + lines[i].position.y = (float)object->y + (float)(objectText->pixelSize * i); + + RaytmxTextLineNode* parent = iterator; + iterator = iterator->next; + MemFree(parent); + } + /* Add the lines array to the text object */ + objectText->lines = lines; + objectText->linesLength = linesLength; + } + } /* objectText->content != NULL */ + } + } /* strcmp(hoxmlContext->tag, "text") == 0 */ + else if (strcmp(hoxmlContext->tag, "imagelayer") == 0) { + raytmxState->imageLayer = NULL; + raytmxState->layer = NULL; + } else if (strcmp(hoxmlContext->tag, "group") == 0) { + /* <group>s can be nested so we must return to processing its parent, if it exists */ + if (raytmxState->groupNode != NULL) + raytmxState->groupNode = raytmxState->groupNode->parent; /* Will be null when returning to the root map */ + } +} + +void FreeStateLayers(RaytmxLayerNode* layers) { + RaytmxLayerNode *layersIterator = layers, *layersTemp; + while (layersIterator != NULL) { + /* Group layers may have children, forming a tree-like structure. Free the children. */ + FreeStateLayers(layersIterator->childrenRoot); + /* Iterate to the next node and free this one */ + layersTemp = layersIterator; + layersIterator = layersIterator->next; + MemFree(layersTemp); + } +} + +void FreeState(RaytmxState* raytmxState) { + if (raytmxState == NULL) + return; + + /* Clear the caches. These allow for quick lookups of previously-loaded textures and object templates. They */ + /* aren't needed once loading is complete. */ + RaytmxCachedTextureNode *cachedTextureIterator = raytmxState->texturesRoot, *cachedTextureTemp; + while (cachedTextureIterator != NULL) { + cachedTextureTemp = cachedTextureIterator; + cachedTextureIterator = cachedTextureIterator->next; + if (cachedTextureTemp->fileName != NULL) /* Just in case. Should always be set. */ + MemFree(cachedTextureTemp->fileName); + MemFree(cachedTextureTemp); + } + raytmxState->texturesRoot = NULL; + RaytmxCachedTemplateNode *cachedTemplateIterator = raytmxState->templatesRoot, *cachedTemplateTemp; + while (cachedTemplateIterator != NULL) { + cachedTemplateTemp = cachedTemplateIterator; + cachedTemplateIterator = cachedTemplateIterator->next; + FreeObject(cachedTemplateTemp->objectTemplate.object); + if (cachedTemplateTemp->fileName != NULL) /* Just in case. Should always be set. */ + MemFree(cachedTemplateTemp->fileName); + MemFree(cachedTemplateTemp); + } + raytmxState->templatesRoot = NULL; + + raytmxState->property = NULL; + raytmxState->tileset = NULL; + raytmxState->image = NULL; + raytmxState->tilesetTile = NULL; + raytmxState->animationFrame = NULL; + /* raytmxState->wangSet = NULL; */ /* TODO: Wang sets. Low priority. */ + /* raytmxState->wangColor = NULL; */ /* TODO: Wang sets. Low priority. */ + raytmxState->layer = NULL; + raytmxState->tileLayer = NULL; + raytmxState->objectGroup = NULL; + raytmxState->imageLayer = NULL; + raytmxState->object = NULL; + + /* Free each property in the linked list of properties */ + RaytmxPropertyNode *propertiesIterator = raytmxState->propertiesRoot, *propertiesTemp; + while (propertiesIterator != NULL) { + propertiesTemp = propertiesIterator; + propertiesIterator = propertiesIterator->next; + MemFree(propertiesTemp); + } + /* Zeroize this linked list's properties */ + raytmxState->propertiesRoot = NULL; + raytmxState->propertiesTail = NULL; + raytmxState->propertiesLength = 0; + + /* Free each node in the linked list of tilesets */ + RaytmxTilesetNode *tilesetsIterator = raytmxState->tilesetsRoot, *tilesetsTemp; + while (tilesetsIterator != NULL) { + tilesetsTemp = tilesetsIterator; + tilesetsIterator = tilesetsIterator->next; + MemFree(tilesetsTemp); + } + /* Zeroize this linked list's properties */ + raytmxState->tilesetsRoot = NULL; + raytmxState->tilesetsTail = NULL; + raytmxState->tilesetsLength = 0; + + /* Free each node in the linked list of tileset tiles */ + RaytmxTilesetTileNode *tilesetTilesIterator = raytmxState->tilesetTilesRoot, *tilesetTilesTemp; + while (tilesetTilesIterator != NULL) { + tilesetTilesTemp = tilesetTilesIterator; + tilesetTilesIterator = tilesetTilesIterator->next; + MemFree(tilesetTilesTemp); + } + /* Zeroize this linked list's properties */ + raytmxState->tilesetTilesRoot = NULL; + raytmxState->tilesetTilesTail = NULL; + raytmxState->tilesetTilesLength = 0; + + /* Free each node in the linked list of animation frames */ + RaytmxAnimationFrameNode *animationFramesIterator = raytmxState->animationFramesRoot, *animationFramesTemp; + while (animationFramesIterator != NULL) { + animationFramesTemp = animationFramesIterator; + animationFramesIterator = animationFramesIterator->next; + MemFree(animationFramesTemp); + } + /* Zeroize this linked list's properties */ + raytmxState->animationFramesRoot = NULL; + raytmxState->animationFramesTail = NULL; + raytmxState->animationFramesLength = 0; + + /* Layers may be groups. The resulting collection isn't a link list as much as it is a tree. So freeing layers is */ + /* best done with a recursive approach. */ + FreeStateLayers(raytmxState->layersRoot); + /* Zeroize this linked list's properties */ + raytmxState->layersRoot = NULL; + raytmxState->layersTail = NULL; + raytmxState->layersLength = 0; + + /* Free each node in the linked list of layer tiles */ + RaytmxTileLayerTileNode *layerTilesIterator = raytmxState->layerTilesRoot, *layerTilesTemp; + while (layerTilesIterator != NULL) { + layerTilesTemp = layerTilesIterator; + layerTilesIterator = layerTilesIterator->next; + MemFree(layerTilesTemp); + } + /* Zeroize this linked list's properties */ + raytmxState->layerTilesRoot = NULL; + raytmxState->layerTilesTail = NULL; + raytmxState->layerTilesLength = 0; + + /* Free each node in the linked list of objects */ + RaytmxObjectNode *objectsIterator = raytmxState->objectsRoot, *objectsTemp; + while (objectsIterator != NULL) { + objectsTemp = objectsIterator; + objectsIterator = objectsIterator->next; + MemFree(objectsTemp); + } + /* Zeroize this linked list's properties */ + raytmxState->objectsRoot = NULL; + raytmxState->objectsTail = NULL; + raytmxState->objectsLength = 0; +} + +void inline FreeString(char* str) { + if (str != NULL) + MemFree(str); +} + +void FreeTileset(TmxTileset tileset) { + FreeString(tileset.source); + FreeString(tileset.name); + FreeString(tileset.classString); + if (tileset.hasImage) { + FreeString(tileset.image.source); + UnloadTexture(tileset.image.texture); + } + if (tileset.properties != NULL) { + for (uint32_t i = 0; i < tileset.propertiesLength; i++) + FreeProperty(tileset.properties[i]); + MemFree(tileset.properties); + } + for (uint32_t i = 0; i < tileset.tilesLength; i++) { + TmxTilesetTile tile = tileset.tiles[i]; + FreeString(tile.classString); + if (tile.hasImage) { + FreeString(tile.image.source); + UnloadTexture(tile.image.texture); + if (tile.properties != NULL) { + for (uint32_t j = 0; j < tile.propertiesLength; j++) + FreeProperty(tile.properties[j]); + MemFree(tile.properties); + } + } + if (tile.animation.frames != NULL) + MemFree(tile.animation.frames); + } +} + +void FreeProperty(TmxProperty property) { + FreeString(property.name); + FreeString(property.stringValue); +} + +void FreeLayer(TmxLayer layer) { + FreeString(layer.name); + FreeString(layer.classString); + if (layer.properties != NULL) { + for (uint32_t i = 0; i < layer.propertiesLength; i++) + FreeProperty(layer.properties[i]); + MemFree(layer.properties); + } + switch (layer.type) { + case LAYER_TYPE_TILE_LAYER: + FreeString(layer.exact.tileLayer.encoding); + FreeString(layer.exact.tileLayer.compression); + MemFree(layer.exact.tileLayer.tiles); + break; + case LAYER_TYPE_OBJECT_GROUP: + for (uint32_t j = 0; j < layer.exact.objectGroup.objectsLength; j++) + FreeObject(layer.exact.objectGroup.objects[j]); + MemFree(layer.exact.objectGroup.objects); + break; + case LAYER_TYPE_IMAGE_LAYER: + if (layer.exact.imageLayer.hasImage) + UnloadTexture(layer.exact.imageLayer.image.texture); + break; + case LAYER_TYPE_GROUP: break; /* Nothing to do for this case but compilers like to complain */ + } + /* <group> layers are expected to have child layers, or child <group>s, so recursively free them too */ + for (uint32_t i = 0; i < layer.layersLength; i++) + FreeLayer(layer.layers[i]); +} + +void FreeObject(TmxObject object) { + FreeString(object.name); + FreeString(object.typeString); + FreeString(object.templateString); + if (object.points != NULL) + MemFree(object.points); + if (object.text != NULL) { + if (object.text->lines != NULL) { + for (uint32_t j = 0; j < object.text->linesLength; j++) + FreeString(object.text->lines[j].content); + MemFree(object.text->lines); + } /* object.text->lines != NULL */ + MemFree(object.text); + } /* object.text != NULL */ +} + +#define SIGN(x) (x < 0 ? -1 : +1) + +/** + * Helper function that keeps an integer within the given range. + * Note: A function named Clamp() exists in raylib but uses floats, hence Clampi(). + * + * @param value The preferred value that will be used as long as it is between the minimum and maximum values. + * @param minimum The smallest acceptable value, inclusive. + * @param maximum The largest acceptable value, inclusive. + * @return The preferred value if within the range or the nearest acceptable value. + */ +int Clampi(int value, int minimum, int maximum) { + if (value < minimum) + return minimum; + else if (value > maximum) + return maximum; + return value; +} + +/** + * Scary-looking helper function that does something kind of simple: iterates through the tiles of the given tile layer + * overlapping with the given viewport, one tile per call. This function returns true while iteration is still ongoing + * and false when done. This allows the function to be used e.g. "while (IterateTileLayer( { ...} ))". Details of the + * current tile are returned to the caller with output parameters. Iteration is done row-by-row. + * + * @param map A loaded map model containing the given tile layer. + * @param layer The tile layer within the given map whose tiles will be iterated. + * @param viewport A rectangle representing the region being drawn to. This could also be considered a search area. + * @param transform Position/offset numbers that affect where the tile is ultimately drawn. + * @param rawGid Optional output. The Global ID (GID) with possible flip flags. Pass NULL if not wanted. + * @param tile Optional output. Metadata of the current tile. Pass NULL if not wanted. + * @param tileRect Optional output. The destination rectangle, in pixels, of the current tile. Pass NULL if not wanted. + * @return True if the next tile is being provided via the output parameters, or false if iteration is done. + */ +bool IterateTileLayer(const TmxMap* map, const TmxTileLayer* layer, Rectangle viewport, RaytmxTransform transform, + uint32_t* rawGid, TmxTile* tile, Rectangle* tileRect) { + /* Static variables whose values will persist between calls. These are needed to initialize and iterate. */ + static const TmxTileLayer* currentLayer = NULL; /* Tile layer being iterated */ + static int fromX = 0; /* Initial X position, tile not pixel, that row-by-row iteration begins at */ + static int fromY = 0; /* Initial Y position, tile not pixel, that row-by-row iteration begins at */ + static int toX = 0; /* Final X position, tile not pixel, that iteration ends at */ + static int toY = 0; /* Final Y position, tile not pixel, that iteration ends at */ + static int currentX = 0; /* Current tile X position (column) within the iteration */ + static int currentY = 0; /* Current tile Y position (row) within the iteration */ + + if (map == NULL || map->width == 0 || map->height == 0 || map->tileWidth == 0 || map->tileHeight == 0 || + layer == NULL || layer->tilesLength == 0) + return false; + + if (currentLayer != layer) { /* If the layer has changed (i.e. iteration should initialize) */ + currentLayer = layer; /* Remember this layer */ + + /* Create an adjusted viewport that effectively removes the map's drawn position. With this, it doesn't need */ + /* to be a factor in the math below. */ + const Rectangle viewport2 = { + .x = viewport.x - transform.position.x, + .y = viewport.y - transform.position.y, + .width = viewport.width, + .height = viewport.height + }; + + switch (map->renderOrder) { + case RENDER_ORDER_RIGHT_DOWN: + /* Start at the top-left, iterate right, then iterate down, ending at the bottom-right. */ + /* In other words, this is the order in which English is read. */ + fromX = (int)viewport2.x / (int)map->tileWidth; + fromY = (int)viewport2.y / (int)map->tileHeight; + toX = (int)(viewport2.x + viewport2.width) / (int)map->tileWidth; + toY = (int)(viewport2.y + viewport2.height) / (int)map->tileHeight; + break; + case RENDER_ORDER_RIGHT_UP: + /* Start at the bottom-left, iterate right, then iterate up, ending at the top-right */ + fromX = (int)viewport2.x / (int)map->tileWidth; + fromY = (int)(viewport2.y + viewport2.height) / (int)map->tileHeight; + toX = (int)(viewport2.x + viewport2.width) / (int)map->tileWidth; + toY = (int)viewport2.y / (int)map->tileHeight; + break; + case RENDER_ORDER_LEFT_DOWN: + /* Start at the top-right, iterate left, then iterate down, ending at the bottom-left */ + fromX = (int)(viewport2.x + viewport2.width) / (int)map->tileWidth; + fromY = (int)viewport2.y / (int)map->tileHeight; + toX = (int)viewport2.x / (int)map->tileWidth; + toY = (int)(viewport2.y + viewport2.height) / (int)map->tileHeight; + break; + case RENDER_ORDER_LEFT_UP: + /* Start at the bottom-right, iterate left, then iterate up, ending at the top-left */ + fromX = (int)(viewport2.x + viewport2.width) / (int)map->tileWidth; + fromY = (int)(viewport2.y + viewport2.height) / (int)map->tileHeight; + toX = (int)viewport2.x / (int)map->tileWidth; + toY = (int)viewport2.y / (int)map->tileHeight; + break; + } /* switch (map->renderOrder) */ + /* Restrain the the tile positions to those within the map in case of rounding mistakes */ + fromX = Clampi(fromX, 0, (int)map->width - 1); + fromY = Clampi(fromY, 0, (int)map->height - 1); + toX = Clampi(toX, 0, (int)map->width - 1); + toY = Clampi(toY, 0, (int)map->height - 1); + /* Begin iteration from both "from" tile positions */ + currentX = fromX; + currentY = fromY; + } else if (currentX == toX) { /* If the end of the current row was reached */ + /* Rendering is done row-by-row. This row is done so move to the next one. */ + currentX = fromX; + currentY += SIGN(toY - fromY); /* Either +1 or -1 */ + } else { /* If still iterating through the current row */ + /* Move to the right or left by one tile */ + currentX += SIGN(toX - fromX); /* Either +1 or -1 */ + } + + /* If iteration has gone beyond the final row */ + if ((toY - fromY > 0 && currentY > toY) || (toY - fromY < 0 && currentY < toY)) { + /* This is the termination condition. Zero all values and return false so the caller exits its loop. */ + currentLayer = NULL; + fromX = fromY = toX = toY = currentX = currentY = 0; + return false; + } + + /* Calculate the index in the tile layer from knowing the tile's X and Y position (in tiles, not pixels) */ + int index = (currentY * (int)map->width) + currentX; + if (index < 0 || index >= (int)layer->tilesLength) { /* Bounds check */ + currentLayer = NULL; + fromX = fromY = toX = toY = currentX = currentY = 0; + return false; + } + + /* Get the raw Global ID (GID) of the tile at this position from the layer's list of tiles. This list's order */ + /* matches the map's render order. */ + uint32_t localRawGid = layer->tiles[index]; + if (rawGid != NULL) + *rawGid = localRawGid; /* Assign the value to he output parameter */ + if (tile != NULL) { + /* The raw GID may have bit flags on it. They need to be removed in order to get the actual GID value.*/ + uint32_t gid = GetGid(localRawGid, NULL, NULL, NULL, NULL); + /* Get the tile's metadata from knowing its GID */ + if (gid < map->gidsToTilesLength) /* Bounds check */ + *tile = map->gidsToTiles[gid]; + } + if (tileRect != NULL) { + /* Calculate the tile's destination rectangle, in pixels */ + *tileRect = (Rectangle) { + .x = (float)((uint32_t)currentX * map->tileWidth), + .y = (float)((uint32_t)currentY * map->tileHeight), + .width = (float)map->tileWidth, + .height = (float)map->tileHeight + }; + } + + return true; +} + +void DrawTMXLayersInternal(const TmxMap* map, const Camera2D* camera, const Rectangle* viewport, const TmxLayer* layers, + uint32_t layersLength, RaytmxTransform transform, Color tint) +{ + if (map == NULL || layers == NULL || layersLength == 0) + return; + + for (uint32_t i = 0; i < layersLength; i++) { + TmxLayer layer = layers[i]; + if (!layers[i].visible) /* If the layer is not visible */ + continue; /* Skip it - it's literally invisible */ + + /* All types of layers can have a couple attributes that affect color: 'opacity' and 'tintcolor' */ + Color layerTint = tint; + layerTint.a = (unsigned char)((double)layerTint.a * layer.opacity); + if (layer.hasTintColor) + layerTint = ColorTint(layerTint, layer.tintColor); + + /* Determine the viewport. This will depend on a couple parameters. If 'viewport' was assigned, it's used */ + /* directly. If 'camera' was assigned, its target and zoom are used to derive a reasonable viewport from the */ + /* screen's dimensions. If neither is assigned, the map's bounds are used. */ + Rectangle viewport2; + if (viewport != NULL) + viewport2 = *viewport; + else if (camera != NULL) { + viewport2.width = (float)GetScreenWidth() / camera->zoom; + viewport2.height = (float)GetScreenHeight() / camera->zoom; + viewport2.x = camera->target.x - (viewport2.width / 2.0f); + viewport2.y = camera->target.y - (viewport2.height / 2.0f); + } else { + viewport2.x = transform.position.x; + viewport2.y = transform.position.y; + viewport2.width = (float)(map->width * map->tileWidth); + viewport2.height = (float)(map->height * map->tileHeight); + } + + /* Create an updated transform for this layer. This will be the sum of the position the map is drawn at, the */ + /* layer's offset, and the effect of parallax scrolling if conditions are met. */ + RaytmxTransform transform2 = transform; + /* "The effective parallax scrolling factor of a layer is determined by multiplying the parallax scrolling */ + /* factor by the scrolling factors of all parent layers." */ + transform2.parallax.x *= (float)layer.parallaxX; + transform2.parallax.y *= (float)layer.parallaxY; + /* Apply the offset specific to this layer and/or parallax scrolling. Also applies to child layers. */ + transform2.position.x += (float)layer.offsetX + (transform2.cameraOffset.x * (1.0f - transform2.parallax.x)); + transform2.position.y += (float)layer.offsetY + (transform2.cameraOffset.y * (1.0f - transform2.parallax.y)); + + switch (layer.type) { + case LAYER_TYPE_TILE_LAYER: DrawTMXTileLayer(map, viewport2, layer, transform2, layerTint); break; + case LAYER_TYPE_OBJECT_GROUP: DrawTMXObjectGroup(map, viewport2, layer, transform2, layerTint); break; + case LAYER_TYPE_IMAGE_LAYER: DrawTMXImageLayer(map, viewport2, layer, transform2, layerTint); break; + case LAYER_TYPE_GROUP: + DrawTMXLayersInternal(map, camera, &viewport2, layer.layers, layer.layersLength, transform2, layerTint); + break; + } + } +} + +void DrawTMXTileLayer(const TmxMap* map, Rectangle viewport, TmxLayer layer, RaytmxTransform transform, Color tint) +{ + if (map == NULL || layer.type != LAYER_TYPE_TILE_LAYER || layer.exact.tileLayer.tilesLength == 0) + return; + + /* Iterate through each tile that the screen rectangle overlaps with */ + uint32_t rawGid; + Rectangle tileRect; + while (IterateTileLayer(/* map: */ map, /* layer: */ &layer.exact.tileLayer, /* viewport: */ viewport, + /* transform: */ transform, /* rawGid: */ &rawGid, /* tile: */ NULL, /* tileRect: */ &tileRect)) + { + tileRect.x += transform.position.x; + tileRect.y += transform.position.y; + DrawTMXLayerTile(/* map: */ map, /* viewport: */ viewport, /* rawGid: */ rawGid, /* destRect: */ tileRect, + /* tint: */ tint); + } +} + +void DrawTextureTile(Texture2D texture, Rectangle source, Rectangle dest, bool flipX, bool flipY, bool flipDiag, + Color tint) { + if (texture.id == 0) /* If the texture is invalid */ + return; + + float textureWidth = (float)texture.width; + float textureHeight = (float)texture.height; + + /* Determine the area within the texture to be drawn */ + /* Note: The coordinates here are in the [0.0, 1.0] range where (0.0, 0.0) is the bottom-left corner of the */ + /* texture, (1.0, 0.0) is the bottom-right, and (1.0, 1.0) is the top-right. In other words, the coordinates are */ + /* a ratio of the dimensions making (0.5, 0.5) the center of the texture regardless of its aspect ratio. */ + Vector2 sourceTopLeft, sourceTopRight, sourceBottomLeft, sourceBottomRight; + sourceTopLeft.x = source.x / textureWidth; + sourceTopLeft.y = source.y / textureHeight; + sourceTopRight.x = (source.x + source.width) / textureWidth; + sourceTopRight.y = source.y / textureHeight; + sourceBottomLeft.x = source.x / textureWidth; + sourceBottomLeft.y = (source.y + source.height) / textureHeight; + sourceBottomRight.x = (source.x + source.width) / textureWidth; + sourceBottomRight.y = (source.y + source.height) / textureHeight; + if (flipDiag) { /* If the tile uses a diagonal flip */ + /* "The diagonal flip should flip the bottom left and top right corners of the tile..." */ + Vector2 temp = sourceBottomLeft; + sourceBottomLeft = sourceTopRight; + sourceTopRight = temp; + } + + /* Determine the area on the screen to be drawn to */ + Vector2 destTopLeft, destTopRight, destBottomLeft, destBottomRight; + destTopLeft.x = dest.x; + destTopLeft.y = dest.y; + destTopRight.x = dest.x + dest.width; + destTopRight.y = dest.y; + destBottomLeft.x = dest.x; + destBottomLeft.y = dest.y + dest.height; + destBottomRight.x = dest.x + dest.width; + destBottomRight.y = dest.y + dest.height; + + rlSetTexture(texture.id); + rlBegin(RL_QUADS); + { + rlColor4ub(tint.r, tint.g, tint.b, tint.a); + rlNormal3f(0.0f, 0.0f, 1.0f); /* Normal vector pointing towards viewer */ + + /* Top-left corner of the quad */ + if (flipX && !flipY) + rlTexCoord2f(sourceTopRight.x, sourceTopRight.y); + else if (flipY && !flipX) + rlTexCoord2f(sourceBottomLeft.x, sourceBottomLeft.y); + else + rlTexCoord2f(sourceTopLeft.x, sourceTopLeft.y); + if (flipX && flipY) + rlVertex2f(destBottomRight.x, destBottomRight.y); + else + rlVertex2f(destTopLeft.x, destTopLeft.y); + + /* Bottom-left corner of the quad */ + if (flipX && !flipY) + rlTexCoord2f(sourceBottomRight.x, sourceBottomRight.y); + else if (flipY && !flipX) + rlTexCoord2f(sourceTopLeft.x, sourceTopLeft.y); + else + rlTexCoord2f(sourceBottomLeft.x, sourceBottomLeft.y); + if (flipX && flipY) + rlVertex2f(destTopRight.x, destTopRight.y); + else + rlVertex2f(destBottomLeft.x, destBottomLeft.y); + + /* Bottom-right corner of the quad */ + if (flipX && !flipY) + rlTexCoord2f(sourceBottomLeft.x, sourceBottomLeft.y); + else if (flipY && !flipX) + rlTexCoord2f(sourceTopRight.x, sourceTopRight.y); + else + rlTexCoord2f(sourceBottomRight.x, sourceBottomRight.y); + if (flipX && flipY) + rlVertex2f(destTopLeft.x, destTopLeft.y); + else + rlVertex2f(destBottomRight.x, destBottomRight.y); + + /* Top-right corner of the quad */ + if (flipX && !flipY) + rlTexCoord2f(sourceTopLeft.x, sourceTopLeft.y); + else if (flipY && !flipX) + rlTexCoord2f(sourceBottomRight.x, sourceBottomRight.y); + else + rlTexCoord2f(sourceTopRight.x, sourceTopRight.y); + if (flipX && flipY) + rlVertex2f(destBottomLeft.x, destBottomLeft.y); + else + rlVertex2f(destTopRight.x, destTopRight.y); + } + rlEnd(); + rlSetTexture(0); +} + +void DrawTMXLayerTile(const TmxMap* map, Rectangle viewport, uint32_t rawGid, Rectangle destRect, Color tint) { + if (map == NULL || tint.a == 0) + return; + + bool isFlippedHorizontally, isFlippedVertically, isFlippedDiagonally, isRotatedHexagonal120; + /* Tile Global IDs (GIDs) can have several bit flags that indicate transforms. This function is used to both get */ + /* those possible transform flags as well as the actual GID value without those bit flags. */ + uint32_t gid = GetGid(rawGid, &isFlippedHorizontally, &isFlippedVertically, &isFlippedDiagonally, + &isRotatedHexagonal120); + if (gid >= map->gidsToTilesLength) /* If the GID is outside the range of known GIDs */ + return; /* Do not attempt to draw this time */ + /* With the GID, grab the relevant tile information (texture, animation, etc.) from the global mapping */ + TmxTile tile = map->gidsToTiles[gid]; + if (tile.gid == 0) /* If the GID is not known to exist in any tilesets within the map */ + return; /* Do not attempt to draw this tile */ + if (tile.hasAnimation && tile.frameIndex < tile.animation.framesLength && + tile.animation.frames[tile.frameIndex].gid < map->gidsToTilesLength) { /* If the tile is/has an animation */ + /* Animation tiles are meta; they contain a list of other GIDs to be drawn. Get the actual tile to draw this */ + /* frame from that list. */ + gid = tile.animation.frames[tile.frameIndex].gid; + if (gid < map->gidsToTilesLength) + tile = map->gidsToTiles[gid]; + } + + /* Determine where the tile will be drawn. raylib's coordinates consider (X, Y) to be the top-left corner of the */ + /* rectangle being drawn. The TMX documentation complicates things a bit saying "Larger tiles will extend at the */ + /* top and right (anchored to the bottom left)" meaning that TMX considers (X, Y) to be the bottom-left corner. */ + /* The simplest way to reconcile the Y coordinate differences is to substract the texture's height at Y + 1. This */ + /* way, tiles larger than the map's tile height values will be drawn further up (negative Y direction). */ + destRect.x += tile.offset.x; + destRect.y += tile.offset.y + map->tileHeight - tile.sourceRect.height; + + /* If the viewport and destination rectangles are overlapping to any degree (i.e. if the tile is visible) */ + if (CheckCollisionRecs(viewport, destRect)) { + DrawTextureTile(/* texture: */ tile.texture, /* source: */ tile.sourceRect, /* dest: */ destRect, + /* flipX: */ isFlippedHorizontally, /* flipY: */ isFlippedVertically, /* flipDiag: */ isFlippedDiagonally, + /* tint: */ tint); + } +} + +void DrawTMXObjectTile(const TmxMap* map, Rectangle viewport, uint32_t rawGid, RaytmxTransform transform, float width, + float height, Color tint) { + if (map == NULL || width <= 0 || height <= 0 || tint.a == 0) + return; + + bool isFlippedHorizontally, isFlippedVertically, isFlippedDiagonally, isRotatedHexagonal120; + /* Tile Global IDs (GIDs) can have several bit flags that indicate transforms. This function is used to both get */ + /* those possible transform flags as well as the actual GID value without those bit flags. */ + uint32_t gid = GetGid(rawGid, &isFlippedHorizontally, &isFlippedVertically, &isFlippedDiagonally, + &isRotatedHexagonal120); + if (gid >= map->gidsToTilesLength) /* If the GID is outside the range of known GIDs */ + return; /* Do not attempt to draw this time */ + /* With the GID, grab the relevant tile information (texture, animation, etc.) from the global mapping */ + TmxTile tile = map->gidsToTiles[gid]; + if (tile.gid == 0) /* If the GID is not known to exist in any tilesets within the map */ + return; /* Do not attempt to draw this time */ + if (tile.hasAnimation && tile.frameIndex < tile.animation.framesLength && + tile.animation.frames[tile.frameIndex].gid < map->gidsToTilesLength) { /* If the tile is/has an animation */ + /* Animation tiles are meta; they contain a list of other GIDs to be drawn. Get the actual tile to draw this */ + /* frame from that list. */ + gid = tile.animation.frames[tile.frameIndex].gid; + if (gid < map->gidsToTilesLength) + tile = map->gidsToTiles[gid]; + } + + /* Determine the area in which to draw, and potentially stretch, the texture. This area matches that of the */ + /* <object>, not the tile size. This also means that the Y coordinate needs consideration because raylib */ + /* considers (X, Y) to the be top-left corner of any area but the TMX format considers it the bottom-left. */ + const Rectangle destRect = + { + .x = transform.position.x + tile.offset.x, + .y = transform.position.y + tile.offset.y - height, + .width = width, + .height = height + }; + + /* If the viewport and destination rectangles are overlapping to any degree (i.e. if the tile is visible) */ + if (CheckCollisionRecs(viewport, destRect)) { + DrawTextureTile(/* texture: */ tile.texture, /* source: */ tile.sourceRect, /* dest: */ destRect, + /* flipX: */ isFlippedHorizontally, /* flipY: */ isFlippedVertically, /* flipDiag: */ isFlippedDiagonally, + /* tint: */ tint); + } +} + +void DrawTMXObjectGroup(const TmxMap* map, Rectangle viewport, TmxLayer layer, RaytmxTransform transform, Color tint) { + if (map == NULL || layer.type != LAYER_TYPE_OBJECT_GROUP || tint.a == 0) + return; + + TmxObjectGroup objectGroup = layer.exact.objectGroup; + for (int32_t i = 0; i < (int32_t)objectGroup.objectsLength; i++) { + /* Select the object to draw based on the <objectgroup>'s draw order */ + TmxObject object; + if (objectGroup.drawOrder == OBJECT_GROUP_DRAW_ORDER_INDEX) + object = objectGroup.objects[i]; + else /* if (objectGroup.drawOrder == OBJECT_GROUP_DRAW_ORDER_TOP_DOWN) */ + object = objectGroup.objects[objectGroup.ySortedObjects[i]]; + + if (object.type == OBJECT_TYPE_TILE) /* If the object is a tile with an abitrary GID and dimensions */ + { + RaytmxTransform transform2 = transform; + transform2.position.x += (float)object.x; + transform2.position.y += (float)object.y; + /* Note: This draw method handles occlusion culling so it doesn't need to be done here */ + DrawTMXObjectTile(map, /* viewport: */ viewport, /* rawGid: */ object.gid, /* transform: */ transform2, + /* width: */ (float)object.width, /* height: */ (float)object.height, /* color: */ tint); + } + else /* If the object is any type other than a tile */ + { + Rectangle offsetAabb = object.aabb; + offsetAabb.x += transform.position.x; + offsetAabb.y += transform.position.y; + /* If the viewport and the polygon's AABB are overlapping to any degree (i.e. it is visible) */ + if (CheckCollisionRecs(viewport, offsetAabb)) { + switch (object.type) { + case OBJECT_TYPE_RECTANGLE: + { + const Rectangle rectangle = + { + .x = transform.position.x + (float)object.x, + .y = transform.position.y + (float)object.y, + .width = (float)object.width, + .height = (float)object.height + }; + DrawRectangleRec(/* rec: */ rectangle, /* color: */ objectGroup.color); + } + break; + case OBJECT_TYPE_ELLIPSE: + { + /* The width and height of the object determine the semi major and minor axes. That means the */ + /* object's width is twice the horizontal radius and its height is twice the vertical radius. */ + const float halfWidth = (float)object.width / 2.0f; + const float halfHeight = (float)object.height / 2.0f; + DrawEllipse(/* centerX: */ transform.position.x + (float)object.x + halfWidth, + /* centerY: */ transform.position.y + (float)object.y + halfHeight, /* radiusH: */ halfWidth, + /* radiusV: */ halfHeight, /* color: */ objectGroup.color); + } + break; + case OBJECT_TYPE_POINT: + { + /* A point is a single pixel but the TMX format doesn't require the point must be drawn any */ + /* particular way. Tiled uses a pin icon. Drawing the exact pixel is tempting but hard to see so */ + /* the point is drawn with a circle, with a diameter equal to a quarter of a tile's width. */ + const Vector2 center = + { + .x = transform.position.x + (float)object.x, + .y = transform.position.y + (float)object.y + }; + DrawCircleV(/* center: */ center, /* radius: */ (float)map->tileWidth / 4.0f, + /*color: */ objectGroup.color); + } + break; + case OBJECT_TYPE_POLYGON: + case OBJECT_TYPE_POLYLINE: + /* Copy the 'points' array to the 'drawPoints' array and apply the drawing position, an offset */ + /* applied by the layer and/or draw call. The 'drawPoints' array was allocated at the same time */ + /* as 'points' with the same size. This improves draw call times by reducing memory allocations. */ + memcpy(object.drawPoints, object.points, sizeof(Vector2) * object.pointsLength); + for (uint32_t i = 0; i < object.pointsLength; i++) { + /* Polygons' and polyglines' vertices are stored with relative positions. To get the absolute */ + /* position needed for drawing, just add the object's position and offset. */ + object.drawPoints[i].x += transform.position.x + (float)object.x; + object.drawPoints[i].y += transform.position.y + (float)object.y; + } + /* Use the offset points to draw the poly(gon|line) */ + if (object.type == OBJECT_TYPE_POLYGON) { + /* Note: Polygons' first elements are their centroids. DrawTriangleFan() requires this. */ + /* And, the last element in 'drawPoints' is a duplicate of the first, non-centroid point. */ + DrawTriangleFan(/* points: */ object.drawPoints, /* pointCount: */ object.pointsLength, + /* color: */ objectGroup.color); + } else /* if (object.type == OBJECT_TYPE_POLYLINE) */ { + /* Note: The last element in 'drawPoints' is a duplicate of the first point */ + for (uint32_t i = 1; i < object.pointsLength; i++) { + DrawLineEx(/* startPos: */ object.drawPoints[i - 1], /* endPos: */ object.drawPoints[i], + /* thick: */ TMX_LINE_THICKNESS, /* color: */ objectGroup.color); + } + } + break; + case OBJECT_TYPE_TEXT: + for (uint32_t i = 0; i < object.text->linesLength; i++) { + Vector2 position = object.text->lines[i].position; + position.x += transform.position.x; + position.y += transform.position.y; + DrawTextEx(/* font: */ object.text->lines[i].font, /* text: */ object.text->lines[i].content, + /* position: */ position, /* fontSize: */ (float)object.text->pixelSize, + /* spacing: */ object.text->lines[i].spacing, /* tint: */ object.text->color); + } + break; + case OBJECT_TYPE_TILE: + /* Object tiles are handled in the 'if' case of this 'else' block because the use of an AABB for */ + /* occlusion culling is not reliable for them */ + break; + } + } + } + } +} + +void DrawTMXImageLayer(const TmxMap* map, Rectangle viewport, TmxLayer layer, RaytmxTransform transform, Color tint) { + if (map == NULL || layer.type != LAYER_TYPE_IMAGE_LAYER || !layer.exact.imageLayer.hasImage || + layer.exact.imageLayer.image.width == 0 || layer.exact.imageLayer.image.height == 0 || tint.a == 0) + return; + + TmxImageLayer imageLayer = layer.exact.imageLayer; + /* Determine where the image of this image layer would be drawn, assuming no repetitions */ + Rectangle imageRect = + { + .x = transform.position.x, + .y = transform.position.y, + .width = (float)imageLayer.image.width, + .height = (float)imageLayer.image.height + }; + + if (!imageLayer.repeatX && !imageLayer.repeatY && CheckCollisionRecs(viewport, imageRect)) /* If visible */ + DrawTextureV(/* texture: */ imageLayer.image.texture, /* position: */ transform.position, /* tint: */ tint); + else if (imageLayer.repeatX || imageLayer.repeatY) { /* If the image might be drawn across a whole axis, or both */ + /* Use integer division to determine the X and Y positions at which a the image would appear if it were */ + /* repeated across the whole axis (i.e. if "Repeat X" and/or "Repeat Y" are enabled) */ + int coefficientX = (int)(viewport.x - imageRect.x) / (int)imageRect.width; + int coefficientY = (int)(viewport.y - imageRect.y) / (int)imageRect.height; + float x0 = imageRect.x + (imageRect.width * (float)coefficientX); /* Initial X position */ + float y0 = imageRect.y + (imageRect.height * (float)coefficientY); /* Initial Y position */ + + if (imageLayer.repeatX) /* If repeating along the X axis */ + imageRect.x = x0; /* Move the image's representative rectangle to that X */ + if (imageLayer.repeatY) + imageRect.y = y0; + if (CheckCollisionRecs(viewport, imageRect)) { /* If the repeating image would be visible in the viewport */ + /* Take a step back on each axis that the image repeats on. This ensures we don't leave any empty space */ + /* along the left and/or top edge of the viewport. */ + if (imageLayer.repeatX) + x0 -= imageRect.width; + if (imageLayer.repeatY) + y0 -= imageRect.height; + + /* Create some unchanging objects that the draw function will need */ + Rectangle sourceRect; /* Region within the texture to be drawn. We'll use the whole texture. */ + sourceRect.x = 0.0f; + sourceRect.y = 0.0f; + sourceRect.width = (float)imageLayer.image.width; + sourceRect.height = (float)imageLayer.image.height; + Vector2 origin; /* Reference point used for rotations. We're not rotating so we'll just use all zeroes. */ + origin.x = 0.0f; + origin.y = 0.0f; + + if (imageLayer.repeatX && imageLayer.repeatY) { /* If repeating on both axes */ + /* Loop over both the X and Y axes to draw an array of repeated images */ + for (float x = x0; x <= viewport.x + viewport.width; x += imageRect.width) { + for (float y = y0; y <= viewport.y + viewport.height; y += imageRect.height) { + imageRect.x = x; + imageRect.y = y; + DrawTexturePro(/* texture: */ imageLayer.image.texture, /* source: */ sourceRect, + /* dest: */ imageRect, /* origin: */ origin, /* rotation: */ 0.0f, /* tint: */ tint); + } + } + } else if (imageLayer.repeatX) { /* If repeating on just the X axis */ + /* Loop over just the X axis to draw a horizontal line of repeated images */ + for (float x = x0; x <= viewport.x + viewport.width; x += imageRect.width) { + imageRect.x = x; + DrawTexturePro(/* texture: */ imageLayer.image.texture, /* source: */ sourceRect, + /* dest: */ imageRect, /* origin: */ origin, /* rotation: */ 0.0f, /* tint: */ tint); + } + } else if (imageLayer.repeatY) { /* If repeating on just the Y axis */ + /* Loop over just the Y axis to draw a vertical line of repeated images */ + for (float y = y0; y <= viewport.y + viewport.height; y += imageRect.height) { + imageRect.y = y; + DrawTexturePro(/* texture: */ imageLayer.image.texture, /* source: */ sourceRect, + /* dest: */ imageRect, /* origin: */ origin, /* rotation: */ 0.0f, /* tint: */ tint); + } + } + } + } +} + +/** + * Helper function for detecting collisions between a line and a polygon given the line's start and end points and an + * array and count of the polygon's vertices. + * + * @param startPos One of the two points forming the line. + * @param endPos The other point forming the line. + * @param polyPos Position, in pixels, of the polygon. Its points are relative to this position. + * @param points Array of vertices of the polygon. + * @param pointCount Number of verticies in the polygon and, therefore, length of the array of vertices. + * @return True if the line and polygon collide with one another, or false if there is no collision. + */ +bool CheckCollisionLinePoly(Vector2 startPos, Vector2 endPos, Vector2 polyPos, Vector2* points, int pointCount) { + if (pointCount < 3) + return false; + + /* Cycle through each edge of the polygon */ + int nextIndex = 0; + for (int currentIndex = 0; currentIndex < pointCount; currentIndex++) { + /* Get the next index. If the current index is the last, wrap around. */ + nextIndex = currentIndex + 1; + if (nextIndex == pointCount) + nextIndex = 0; + /* Get the current and next points. These two points form an edge of the polygon. */ + Vector2 currentPoint = points[currentIndex]; + Vector2 nextPoint = points[nextIndex]; + /* Check these edges for collisions. Note: The last parameter is unused, hence zero. */ + if (CheckCollisionLines(/* startPos1: */ startPos, /* endPos1: */ endPos, /* startPos2: */ currentPoint, + /* endPos: */ nextPoint, /* collisionPoint: */ NULL)) + return true; + } + + return false; +} + +/** + * Helper function for detecting collisions between two polygons given arrays and counts of their vertices. + * + * @param polyPos1 Position, in pixels, of the first polygon. Its points are relative to this position. + * @param points1 Array of vertices of the first polygon. + * @param pointCount1 Number of vertices in the first polygon and, therefore, length of the array of vertices. + * @param polyPos2 Position, in pixels, of the second polygon. Its points are relative to this position. + * @param points2 Array of vertices of the second polygon. + * @param pointCount2 Number of vertices in the second polygon and, therefore, length of the array of vertices. + * @return True if the given polygons collide with one another, or false if there is no collision. + */ +bool CheckCollisionPolyPoly(Vector2 polyPos1, Vector2* points1, int pointCount1, Vector2 polyPos2, Vector2* points2, + int pointCount2) { + /* If either vertex array is missing or does not contain enough vertices to define a polygon */ + if (points1 == NULL || pointCount1 < 3 || points2 == NULL || pointCount2 < 3) + return false; + + /* Cycle through each edge of polygon 1 */ + int nextIndex = 0; + for (int currentIndex = 0; currentIndex < pointCount1; currentIndex++) { + /* Get the next index. If the current index is the last, wrap around. */ + nextIndex = currentIndex + 1; + if (nextIndex == pointCount1) + nextIndex = 0; + /* Get the current and next points. These two points form an edge of polygon 1. */ + Vector2 currentPoint = points1[currentIndex]; + currentPoint.x += polyPos1.x; + currentPoint.y += polyPos1.y; + Vector2 nextPoint = points1[nextIndex]; + nextPoint.x += polyPos1.x; + nextPoint.y += polyPos1.y; + /* Check this edge for collisions against edges of polygon 2 */ + if (CheckCollisionLinePoly(currentPoint, nextPoint, polyPos2, points2, pointCount2)) + return true; + } + + /* Check if polygon 1 is fully inside polygon 2 */ + if (CheckCollisionPointPoly(/* point: */ points1[0], /* points: */ points2, /* pointCount: */ pointCount2)) + return true; + + /* Check if polygon 2 is fully inside polygon 1 */ + if (CheckCollisionPointPoly(/* point: */ points2[0], /* points: */ points1, /* pointCount: */ pointCount1)) + return true; + + return false; +} + +RAYTMX_DEC bool CheckCollisionTMXObjects(TmxObject object1, TmxObject object2) { + /* Perform a quick collision check on the Axis-Aligned Bounding Boxes (AABB) before more accurate checks */ + if (!CheckCollisionRecs(/* rec1: */ object1.aabb, /* rec2: */ object2.aabb)) + return false; /* The AABBs do not collide so the objects cannot possibly collide */ + + switch (object1.type) { + case OBJECT_TYPE_RECTANGLE: /* Object 1's type */ + case OBJECT_TYPE_ELLIPSE: /* Object 1's type (treated as a rectangle due to difficulty) */ + case OBJECT_TYPE_TEXT: /* Object 1's type */ + case OBJECT_TYPE_TILE: /* Object 1's type */ + switch (object2.type) { + case OBJECT_TYPE_RECTANGLE: /* Object 2's type */ + case OBJECT_TYPE_ELLIPSE: /* Object 2's type (treated as a rectangle due to difficulty) */ + case OBJECT_TYPE_TEXT: /* Object 2's type */ + case OBJECT_TYPE_TILE: /* Object 2's type */ + /* The objects' shapes, as far as collisions are concerned, are identical to the AABB. We already */ + /* determined the AABBs collide so these objects collide. */ + return true; + + case OBJECT_TYPE_POINT: /* Object 2's type */ + return CheckCollisionPointRec(/* point: */ (Vector2){(float)object2.x, (float)object2.y}, + /* rec: */ object1.aabb); + + case OBJECT_TYPE_POLYGON: /* Object 2's type */ + case OBJECT_TYPE_POLYLINE: /* Object 2's type */ + { + /* A rectangle is a polygon. Create an array of points to treat it as a polygon keeping in mind polygon */ + /* vertices are relative so the top-left corner is always (0, 0). */ + Vector2 points[4]; + points[0] = (Vector2){0.0f, 0.0f}; + points[1] = (Vector2){(float)object1.width, 0.0f}; + points[2] = (Vector2){(float)object1.width, (float)object1.height}; + points[3] = (Vector2){0.0f, (float)object1.height}; + return CheckCollisionPolyPoly(/* polyPos1: */ (Vector2){(float)object1.x, (float)object1.y}, + /* points1: */ points, /* pointCount: */ 4, + /* polyPos2: */ (Vector2){(float)object2.x, (float)object2.y}, /* points2: */ object2.points, + /* pointCount2: */ object2.pointsLength); + } + } + break; + + case OBJECT_TYPE_POINT: /* Object 1's type */ + switch (object2.type) { + case OBJECT_TYPE_RECTANGLE: /* Object 2's type */ + case OBJECT_TYPE_ELLIPSE: /* Object 2's type (treated as a rectangle due to difficulty) */ + case OBJECT_TYPE_TEXT: /* Object 2's type */ + case OBJECT_TYPE_TILE: /* Object 2's type */ + return CheckCollisionPointRec(/* point: */ (Vector2){(float)object1.x, (float)object2.y}, + /* rec: */ object2.aabb); + + case OBJECT_TYPE_POINT: /* Object 2's type */ + return object1.x == object2.x && object1.y == object2.y; + + case OBJECT_TYPE_POLYGON: /* Object 2's type */ + case OBJECT_TYPE_POLYLINE: /* Object 2's type */ + return CheckCollisionPointPoly((Vector2){(float)object1.x, (float)object1.y}, object2.points, + object2.pointsLength); + } + break; + + case OBJECT_TYPE_POLYGON: /* Object 1's type */ + case OBJECT_TYPE_POLYLINE: /* Object 1's type */ + switch (object2.type) { + case OBJECT_TYPE_RECTANGLE: /* Object 2's type */ + case OBJECT_TYPE_ELLIPSE: /* Object 2's type (treated as a rectangle due to difficulty) */ + case OBJECT_TYPE_TEXT: /* Object 2's type */ + case OBJECT_TYPE_TILE: /* Object 2's type */ + { + /* A rectangle is a polygon. Create an array of points to treat it as a polygon keeping in mind polygon */ + /* vertices are relative so the top-left corner is always (0, 0). */ + Vector2 points[4]; + points[0] = (Vector2){0.0f, 0.0f}; + points[1] = (Vector2){(float)object2.width, 0.0f}; + points[2] = (Vector2){(float)object2.width, (float)object2.height}; + points[3] = (Vector2){0.0f, (float)object2.height}; + return CheckCollisionPolyPoly(/* polyPos1: */ (Vector2){(float)object1.x, (float)object1.y}, + /* points1: */ object1.points, /* pointCount1: */ object1.pointsLength, + /* polyPos2: */ (Vector2){(float)object2.x, (float)object2.y}, /* points2: */ points, + /* pointCount2: */ 4); + } + + case OBJECT_TYPE_POINT: /* Object 2's type */ + return CheckCollisionPointPoly(/* point: */ (Vector2){(float)object2.x, (float)object2.y}, + /* points: */ object1.points, /* pointCount: */ object1.pointsLength); + + case OBJECT_TYPE_POLYGON: /* Object 2's type */ + case OBJECT_TYPE_POLYLINE: /* Object 2's type */ + return CheckCollisionPolyPoly(/* polyPos1: */ (Vector2){(float)object1.x, (float)object1.y}, + /* points1: */ object1.points, /* pointCount1: */ object1.pointsLength, + /* polyPos2: */ (Vector2){(float)object2.x, (float)object2.y}, /* points2: */ object2.points, + /* pointCount2: */ object2.pointsLength); + } + break; + } + + return false; +} + +/** + * Helper function for applying a translation to a given object by the given deltas. + * + * @param object The object whose position(s) should be translated. + * @param dx The X delta, in pixels, to translate. + * @param dy The Y delta, in pixels, to translate. + * @return A translated copy of the given object. + */ +TmxObject TranslateObject(TmxObject object, float dx, float dy) { + /* Translate the position of the object by the different X and Y deltas */ + object.x += (double)dx; + object.y += (double)dy; + /* Translate the Axis-Aligned Bounding Box (AABB) to match */ + object.aabb.x += dx; + object.aabb.y += dy; + /* Note: Although polygons and polylines have a series of vertices, they are relative to the object. This means */ + /* nothing more needs to be done. Translating the object's X and Y effectively translates each vertex. */ + return object; +} + +/** + * Helper function for checking for collisions between 1+ tile layers, or groups potentially containing 1+ tile layers, + * and an object of arbitrary type. These checks use the collision information associated with tiles as object groups. + * + * @param map A loaded map model containing the given layers. + * @param layers An array of select tile layers or group layers to be checked for collisions. + * @param layersLength Length of the given array of tile layers. + * @param object A TMX <object> to be checked for a collision. + * @param outputObject Output parameter assigned with the object in the tile layer that the given object collided with. + * NULL if not wanted. + * @return True if one of the given tile layers collides with the given object, or false if there is no collision. + */ +bool CheckCollisionTMXTileLayerObject(const TmxMap* map, const TmxLayer* layers, uint32_t layersLength, + TmxObject object, TmxObject* outputObject) { + if (map == NULL || layers == NULL || layersLength == 0) + return false; + + /* Iterate through each layer and check their tiles for collisions with the given object */ + for (uint32_t i = 0; i < layersLength; i++) { + if (layers[i].type == LAYER_TYPE_TILE_LAYER) { /* If the layer has tiles */ + /* Iterate through each tile that the object's Axis-Aligned Bounding Box (AABB) overlaps with */ + TmxTile tile; + Rectangle tileRect; + RaytmxTransform transform = { .position = {0.0f, 0.0f}, .parallax = {1.0f, 1.0f} }; + while (IterateTileLayer(/* map: */ map, /* layer: */ &layers[i].exact.tileLayer, + /* viewport: */ object.aabb, /* transform: */ transform, /* rawGid: */ NULL, /* tile: */ &tile, + /* tileRect: */ &tileRect)) + { + /* Iterate through each object associated with the tile */ + for (uint32_t j = 0; j < tile.objectGroup.objectsLength; j++) { + /* This object, the tile's collision information, has a relative position so this object must be */ + /* translated to the position of the tile as it would be drawn with the layer */ + TmxObject positionedObject = TranslateObject(tile.objectGroup.objects[j], tileRect.x, tileRect.y); + /* If this tile's object collides with the given object */ + if (CheckCollisionTMXObjects(positionedObject, object)) { + if (outputObject != NULL) + *outputObject = positionedObject; + return true; /* Found a collision. Exit now to save some CPU cycles. */ + } + } + } + } else if (layers[i].type == LAYER_TYPE_GROUP) { /* If the layer contains other layers */ + if (CheckCollisionTMXTileLayerObject(map, layers[i].layers, layers[i].layersLength, object, outputObject)) + return true; + } + } + + return false; +} + +/** + * Helper function for checking for collisions between an object group and an object of arbitrary type. + * + * @param group The object group whose 0+ objects will be checked for collisions. + * @param object A TMX <object> to be checked for collision. + * @param outputObject Output parameter assigned with the object in the object group that the given object collided + * with. NULL if not wanted. + * @return True if an object in the object group collides with the given object, or false if there is no collision. + */ +bool CheckCollisionTMXObjectGroupObject(TmxObjectGroup group, TmxObject object, TmxObject* outputObject) { + for (size_t i = 0; i < group.objectsLength; i++) { + if (CheckCollisionTMXObjects(group.objects[i], object)) { + if (outputObject != NULL) + *outputObject = group.objects[i]; + return true; + } + } + + return false; +} + +void TraceLogTMXTilesets(int logLevel, TmxOrientation orientation, TmxTileset* tilesets, uint32_t tilesetsLength, + int numSpaces) { + for (uint32_t i = 0; i < tilesetsLength; i++) { + TmxTileset tileset = tilesets[i]; + if (i == 0) + TraceLog(logLevel, "tilesets:"); + TraceLog(logLevel, " \"%s\":", tileset.name); + TraceLog(logLevel, " first GID: %u", tileset.firstGid); + TraceLog(logLevel, " last GID: %u", tileset.lastGid); + if (tileset.source != NULL) + TraceLog(logLevel, " source: \"%s\"", tileset.source); + if (tileset.classString[0] != '\0') + TraceLog(logLevel, " class: \"%s\"", tileset.classString); + TraceLog(logLevel, " tile width: %u", tileset.tileWidth); + TraceLog(logLevel, " tile height: %u", tileset.tileHeight); + if (tileset.spacing != 0) + TraceLog(logLevel, " spacing: %u", tileset.spacing); + if (tileset.margin != 0) + TraceLog(logLevel, " margin: %u", tileset.margin); + TraceLog(logLevel, " tile count: %u", tileset.tileCount); + TraceLog(logLevel, " columns: %u", tileset.columns); + if (tileset.tileOffsetX != 0) + TraceLog(logLevel, " tile offset X: %d", tileset.tileOffsetX); + if (tileset.tileOffsetY != 0) + TraceLog(logLevel, " tile offset Y: %d", tileset.tileOffsetY); + if ((orientation == ORIENTATION_ORTHOGONAL && tileset.objectAlignment != OBJECT_ALIGNMENT_BOTTOM_LEFT) || + (orientation == ORIENTATION_ISOMETRIC && tileset.objectAlignment != OBJECT_ALIGNMENT_BOTTOM)) { + switch (tileset.objectAlignment) { + case OBJECT_ALIGNMENT_UNSPECIFIED: TraceLog(logLevel, " object alignment: unspecified"); break; + case OBJECT_ALIGNMENT_TOP_LEFT: TraceLog(logLevel, " object alignment: top-left"); break; + case OBJECT_ALIGNMENT_TOP: TraceLog(logLevel, " object alignment: top"); break; + case OBJECT_ALIGNMENT_TOP_RIGHT: TraceLog(logLevel, " object alignment: top-right"); break; + case OBJECT_ALIGNMENT_LEFT: TraceLog(logLevel, " object alignment: left"); break; + case OBJECT_ALIGNMENT_CENTER: TraceLog(logLevel, " object alignment: center"); break; + case OBJECT_ALIGNMENT_RIGHT: TraceLog(logLevel, " object alignment: right"); break; + case OBJECT_ALIGNMENT_BOTTOM_LEFT: TraceLog(logLevel, " object alignment: bottom-left"); break; + case OBJECT_ALIGNMENT_BOTTOM: TraceLog(logLevel, " object alignment: bottom"); break; + case OBJECT_ALIGNMENT_BOTTOM_RIGHT: TraceLog(logLevel, " object alignment: bottom-right"); break; + } + } + if (tileset.hasImage) { + TraceLog(logLevel, " image:"); + TraceLog(logLevel, " source: \"%s\"", tileset.image.source); + if (tileset.image.hasTrans) + TraceLog(logLevel, " trans: 0x%08X", tileset.image.trans); + if (tileset.image.width != 0) + TraceLog(logLevel, " width: %u", tileset.image.width); + if (tileset.image.height != 0) + TraceLog(logLevel, " height: %u", tileset.image.height); + TraceLog(logLevel, " texture (ID): %u", tileset.image.texture.id); + } + for (uint32_t j = 0; j < tileset.tilesLength; j++) { + TmxTilesetTile tile = tileset.tiles[j]; + if (j == 0) + TraceLog(logLevel, " tiles:"); + TraceLog(logLevel, " ID: %u", tile.id); + if (tile.hasAnimation) { + for (uint32_t i = 0; i < tile.animation.framesLength; i++) { + if (i == 0) + TraceLog(logLevel, " frames:"); + TraceLog(logLevel, " (G)ID: %u", tile.animation.frames[i].gid); + if (tileset.classString[0] != '\0') + TraceLog(logLevel, " class: \"%s\"", tileset.classString); + TraceLog(logLevel, " duration: %f", tile.animation.frames[i].duration); + } + } + TraceLogTMXProperties(logLevel, tile.properties, tile.propertiesLength, 8); + if (tile.hasImage && tile.image.texture.id != tileset.image.texture.id) { + /* The 'x,' 'y,' 'width,' and 'height' attributes relate to the image so only log them if one exists */ + if (tile.x != 0) + TraceLog(logLevel, " x: %d", tile.x); + if (tile.y != 0) + TraceLog(logLevel, " y: %d", tile.y); + if (tile.width != tile.image.width) + TraceLog(logLevel, " width: %u", tile.width); + if (tile.height != tile.image.height) + TraceLog(logLevel, " height: %u", tile.height); + TraceLog(logLevel, " image:"); + TraceLog(logLevel, " source: \"%s\"", tile.image.source); + if (tile.image.hasTrans) + TraceLog(logLevel, " trans: 0x%08X", tile.image.trans); + if (tile.image.width != 0) + TraceLog(logLevel, " width: %u", tile.image.width); + if (tile.image.height != 0) + TraceLog(logLevel, " height: %u", tile.image.height); + TraceLog(logLevel, " texture (ID): %u", tile.image.texture.id); + } + if (tile.objectGroup.objectsLength > 0) { + if (tmxLogFlags & LOG_SKIP_OBJECTS) + TraceLog(logLevel, " skipping %u objects", tile.objectGroup.objectsLength); + else { + TraceLog(logLevel, " objects:"); + for (uint32_t k = 0; k < tile.objectGroup.objectsLength; k++) + TraceLogTMXObject(logLevel, tile.objectGroup.objects[k], numSpaces + 2); + } + } + } + TraceLogTMXProperties(logLevel, tileset.properties, tileset.propertiesLength, 2); + } +} + +void TraceLogTMXProperties(int logLevel, TmxProperty* properties, uint32_t propertiesLength, int numSpaces) { + char padding[16]; + memset(padding, '\0', 16); + StringCopyN(padding, " ", numSpaces); + + if (tmxLogFlags & LOG_SKIP_PROPERTIES) + TraceLog(logLevel, "%sskipped %u properties", padding, propertiesLength); + else { + for (uint32_t i = 0; i < propertiesLength; i++) { + TmxProperty property = properties[i]; + if (i == 0) + TraceLog(logLevel, "%sproperties:", padding); + switch (property.type) { + case PROPERTY_TYPE_STRING: + case PROPERTY_TYPE_FILE: + TraceLog(logLevel, "%s \"%s\": \"%s\"", padding, property.name, property.stringValue); + break; + case PROPERTY_TYPE_INT: + case PROPERTY_TYPE_OBJECT: + TraceLog(logLevel, "%s \"%s\": %d", padding, property.name, property.intValue); + break; + case PROPERTY_TYPE_FLOAT: + TraceLog(logLevel, "%s \"%s\": %f", padding, property.name, property.floatValue); + break; + case PROPERTY_TYPE_BOOL: + TraceLog(logLevel, "%s \"%s\": %s", padding, property.name, property.boolValue ? "true" : "false"); + break; + case PROPERTY_TYPE_COLOR: + TraceLog(logLevel, "%s \"%s\": 0x%08X", padding, property.name, property.colorValue); + break; + } + } + } +} + +void TraceLogTMXLayers(int logLevel, TmxLayer* layers, uint32_t layersLength, int numSpaces) { + char padding[16]; + memset(padding, '\0', 16); + StringCopyN(padding, " ", numSpaces); + + if (tmxLogFlags & LOG_SKIP_LAYERS) + TraceLog(logLevel, "%sskipped %u layers", padding, layersLength); + else { + uint32_t numTileLayers = 0, numObjectGroups = 0, numImageLayers = 0; + for (uint32_t i = 0; i < layersLength; i++) { + TmxLayer layer = layers[i]; + if (i == 0) + TraceLog(logLevel, "%slayers:", padding); + /* If, based on the layer type, this layer isn't one that should be skipped */ + if ((layer.type == LAYER_TYPE_GROUP) || + (layer.type == LAYER_TYPE_TILE_LAYER && !(tmxLogFlags & LOG_SKIP_TILE_LAYERS)) || + (layer.type == LAYER_TYPE_OBJECT_GROUP && !(tmxLogFlags & LOG_SKIP_OBJECT_GROUPS)) || + (layer.type == LAYER_TYPE_IMAGE_LAYER && !(tmxLogFlags & LOG_SKIP_IMAGE_LAYERS))) { + /* Log the attributes of this layer common to all layers */ + TraceLog(logLevel, "%s \"%s\":", padding, layer.name); + switch (layer.type) { + case LAYER_TYPE_TILE_LAYER: TraceLog(logLevel, "%s type: tile layer", padding); break; + case LAYER_TYPE_OBJECT_GROUP: TraceLog(logLevel, "%s type: object layer", padding); break; + case LAYER_TYPE_IMAGE_LAYER: TraceLog(logLevel, "%s type: image layer", padding); break; + case LAYER_TYPE_GROUP: TraceLog(logLevel, "%s type: group", padding); break; + } + if (layer.id > 0) + TraceLog(logLevel, "%s ID: %u", padding, layer.id); + if (layer.visible == false) + TraceLog(logLevel, "%s visible: false", padding); + if (layer.classString[0] != '\0') + TraceLog(logLevel, "%s class: \"%s\"", padding, layer.classString); + if (layer.offsetX != 0) + TraceLog(logLevel, "%s offset X: %d", padding, layer.offsetX); + if (layer.offsetY != 0) + TraceLog(logLevel, "%s offset Y: %d", padding, layer.offsetY); + if (layer.parallaxX != 1.0) + TraceLog(logLevel, "%s parallax X: %f", padding, layer.parallaxX); + if (layer.parallaxY != 1.0) + TraceLog(logLevel, "%s parallax Y: %f", padding, layer.parallaxY); + if (layer.opacity != 1.0) + TraceLog(logLevel, "%s opacity: %f", padding, layer.opacity); + if (layer.hasTintColor) + TraceLog(logLevel, "%s tint color: 0x%08X", padding, layer.tintColor); + TraceLogTMXProperties(logLevel, layer.properties, layer.propertiesLength, numSpaces + 4); + } + + /* Log attributes specific to the layer's type (tile layer, object layer, image layer, or group) */ + switch (layer.type) { + case LAYER_TYPE_TILE_LAYER: + numTileLayers += 1; + if (tmxLogFlags & LOG_SKIP_TILE_LAYERS) + continue; + if (layer.exact.tileLayer.width != 0) + TraceLog(logLevel, "%s width: %u", padding, layer.exact.tileLayer.width); + if (layer.exact.tileLayer.height != 0) + TraceLog(logLevel, "%s height: %u", padding, layer.exact.tileLayer.height); + if (tmxLogFlags & LOG_SKIP_TILES) + TraceLog(logLevel, "%s skipping %u tiles", padding, layer.exact.tileLayer.tilesLength); + else { + for (uint32_t j = 0; j < layer.exact.tileLayer.tilesLength; j++) { + if (j == 0) + TraceLog(logLevel, "%s tiles:", padding); + TraceLog(logLevel, "%s GID: %u", padding, layer.exact.tileLayer.tiles[j]); + } + } + break; + case LAYER_TYPE_OBJECT_GROUP: + numObjectGroups += 1; + if (tmxLogFlags & LOG_SKIP_OBJECT_GROUPS) + continue; + if (layer.exact.objectGroup.hasColor) + TraceLog(logLevel, "%s color: 0x%08X", padding, layer.exact.objectGroup.color); + /* if (layer.exact.objectGroup.width != 0) + TraceLog(logLevel, "%s width: %u", padding, layer.exact.objectGroup.width); */ + /* if (layer.exact.objectGroup.height != 0) + TraceLog(logLevel, "%s height: %u", padding, layer.exact.objectGroup.height); */ + if (layer.exact.objectGroup.drawOrder != OBJECT_GROUP_DRAW_ORDER_TOP_DOWN) { + switch (layer.exact.objectGroup.drawOrder) { + case OBJECT_GROUP_DRAW_ORDER_TOP_DOWN: + default: + TraceLog(logLevel, "%s draw order: top-down", padding); + break; + case OBJECT_GROUP_DRAW_ORDER_INDEX: + TraceLog(logLevel, "%s draw order: index", padding); + break; + } + } + if (tmxLogFlags & LOG_SKIP_OBJECTS) + TraceLog(logLevel, "%s skipping %u objects", padding, layer.exact.objectGroup.objectsLength); + else { + for (uint32_t j = 0; j < layer.exact.objectGroup.objectsLength; j++) { + TmxObject object = layer.exact.objectGroup.objects[j]; + if (j == 0) + TraceLog(logLevel, "%s objects:", padding); + TraceLogTMXObject(logLevel, object, numSpaces); + } + } + break; + case LAYER_TYPE_IMAGE_LAYER: + numImageLayers += 1; + if (tmxLogFlags & LOG_SKIP_IMAGE_LAYERS) + continue; + if (layer.exact.imageLayer.repeatX) + TraceLog(logLevel, "%s repeat X: true", padding); + if (layer.exact.imageLayer.repeatY) + TraceLog(logLevel, "%s repeat Y: true", padding); + if (layer.exact.imageLayer.hasImage) { + TraceLog(logLevel, "%s image:", padding); + TraceLog(logLevel, "%s source: \"%s\"", padding, layer.exact.imageLayer.image.source); + if (layer.exact.imageLayer.image.hasTrans) + TraceLog(logLevel, "%s trans: 0x%08X", padding, layer.exact.imageLayer.image.trans); + if (layer.exact.imageLayer.image.width != 0) + TraceLog(logLevel, "%s width: %u", padding, layer.exact.imageLayer.image.width); + if (layer.exact.imageLayer.image.height != 0) + TraceLog(logLevel, "%s height: %u", padding, layer.exact.imageLayer.image.height); + TraceLog(logLevel, "%s texture (ID): %u", padding, layer.exact.imageLayer.image.texture.id); + } + break; + case LAYER_TYPE_GROUP: + TraceLogTMXLayers(logLevel, layer.layers, layer.layersLength, numSpaces + 4); + break; + } + } + if (tmxLogFlags & LOG_SKIP_TILE_LAYERS && numTileLayers > 0) + TraceLog(logLevel, "%s skipped %u tile layers", padding, numTileLayers); + if (tmxLogFlags & LOG_SKIP_OBJECT_GROUPS && numObjectGroups > 0) + TraceLog(logLevel, "%s skipped %u object layers", padding, numObjectGroups); + if (tmxLogFlags & LOG_SKIP_IMAGE_LAYERS && numImageLayers > 0) + TraceLog(logLevel, "%s skipped %u image layers", padding, numImageLayers); + } +} + +void TraceLogTMXObject(int logLevel, TmxObject object, int numSpaces) { + char padding[16]; + memset(padding, '\0', 16); + StringCopyN(padding, " ", numSpaces); + + TraceLog(logLevel, "%s ID: %u", padding, object.id); + TraceLog(logLevel, "%s name: \"%s\"", padding, object.name); + switch (object.type) { + case OBJECT_TYPE_RECTANGLE: TraceLog(logLevel, "%s type: quad", padding); break; + case OBJECT_TYPE_ELLIPSE: TraceLog(logLevel, "%s type: ellipse", padding); break; + case OBJECT_TYPE_POINT: TraceLog(logLevel, "%s type: point", padding); break; + case OBJECT_TYPE_POLYGON: TraceLog(logLevel, "%s type: polygon", padding); break; + case OBJECT_TYPE_POLYLINE: TraceLog(logLevel, "%s type: polyline", padding); break; + case OBJECT_TYPE_TEXT: TraceLog(logLevel, "%s type: text", padding); break; + case OBJECT_TYPE_TILE: TraceLog(logLevel, "%s type: tile", padding); break; + } + if (object.typeString[0] != '\0') + TraceLog(logLevel, "%s type: \"%s\"", padding, object.typeString); + if (object.x != 0.0) + TraceLog(logLevel, "%s x: %f", padding, object.x); + if (object.y != 0.0) + TraceLog(logLevel, "%s y: %f", padding, object.y); + if (object.width != 0.0) + TraceLog(logLevel, "%s width: %f", padding, object.width); + if (object.height != 0.0) + TraceLog(logLevel, "%s height: %f", padding, object.height); + if (object.rotation != 0.0) + TraceLog(logLevel, "%s rotation: %f", padding, object.rotation); + if (object.gid > 0) + TraceLog(logLevel, "%s GID: %u", padding, object.gid); + if (!object.visible) + TraceLog(logLevel, "%s visible: false", padding); + if (object.templateString != NULL) + TraceLog(logLevel, "%s template: \"%s\"", padding, object.templateString); + for (uint32_t k = 0; k < object.pointsLength; k++) { + if (k == 0) + TraceLog(logLevel, "%s points:", padding); + TraceLog(logLevel, "%s [%f, %f]", padding, object.points[k].x, object.points[k].y); + } + TraceLogTMXProperties(logLevel, object.properties, object.propertiesLength, numSpaces + 8); + if (object.text != NULL) { + TraceLog(logLevel, "%s font family: \"%s\"", padding, object.text->fontFamily); + TraceLog(logLevel, "%s pixel size: %u", padding, object.text->pixelSize); + if (object.text->wrap) + TraceLog(logLevel, "%s wrap: true", padding); + TraceLog(logLevel, "%s color: 0x%08X", padding, object.text->color); + if (object.text->bold) + TraceLog(logLevel, "%s bold: true", padding); + if (object.text->italic) + TraceLog(logLevel, "%s italic: true", padding); + if (object.text->underline) + TraceLog(logLevel, "%s underline: true", padding); + if (object.text->strikeOut) + TraceLog(logLevel, "%s strike out: true", padding); + if (object.text->kerning) + TraceLog(logLevel, "%s kerning: true", padding); + switch (object.text->halign) { + case HORIZONTAL_ALIGNMENT_LEFT: + TraceLog(logLevel, "%s horizontal align: left", padding); + break; + case HORIZONTAL_ALIGNMENT_CENTER: + TraceLog(logLevel, "%s horizontal align: center", padding); + break; + case HORIZONTAL_ALIGNMENT_RIGHT: + TraceLog(logLevel, "%s horizontal align: right", padding); + break; + case HORIZONTAL_ALIGNMENT_JUSTIFY: + TraceLog(logLevel, "%s horizontal align: justify", padding); + break; + } + switch (object.text->valign) { + case VERTICAL_ALIGNMENT_TOP: + TraceLog(logLevel, "%s vertical align: top", padding); + break; + case VERTICAL_ALIGNMENT_CENTER: + TraceLog(logLevel, "%s vertical align: center", padding); + break; + case VERTICAL_ALIGNMENT_BOTTOM: + TraceLog(logLevel, "%s vertical align: bottom", padding); + break; + } + if (object.text->content[0] != '\0') + TraceLog(logLevel, "%s content: \"%s\"", padding, object.text->content); + } +} + +TmxProperty* AddProperty(RaytmxState* raytmxState) { + RaytmxPropertyNode* node = (RaytmxPropertyNode*)MemAllocZero(sizeof(RaytmxPropertyNode)); + + if (raytmxState->propertiesRoot == NULL) + raytmxState->propertiesRoot = node; + else + raytmxState->propertiesTail->next = node; + raytmxState->propertiesTail = node; + raytmxState->propertiesLength += 1; + + return &node->property; +} + +void AddTileLayerTile(RaytmxState* raytmxState, uint32_t gid) { + RaytmxTileLayerTileNode* node = (RaytmxTileLayerTileNode*)MemAllocZero(sizeof(RaytmxTileLayerTileNode)); + node->gid = gid; + + if (raytmxState->layerTilesRoot == NULL) + raytmxState->layerTilesRoot = node; + else + raytmxState->layerTilesTail->next = node; + raytmxState->layerTilesTail = node; + raytmxState->layerTilesLength += 1; +} + +TmxTileset* AddTileset(RaytmxState* raytmxState) { + RaytmxTilesetNode* node = (RaytmxTilesetNode*)MemAllocZero(sizeof(RaytmxTilesetNode)); + + if (raytmxState->tilesetsRoot == NULL) + raytmxState->tilesetsRoot = node; + else + raytmxState->tilesetsTail->next = node; + raytmxState->tilesetsTail = node; + raytmxState->tilesetsLength += 1; + + return &node->tileset; +} + +TmxTilesetTile* AddTilesetTile(RaytmxState* raytmxState) { + RaytmxTilesetTileNode* node = (RaytmxTilesetTileNode*)MemAllocZero(sizeof(RaytmxTilesetTileNode)); + + if (raytmxState->tilesetTilesRoot == NULL) + raytmxState->tilesetTilesRoot = node; + else + raytmxState->tilesetTilesTail->next = node; + raytmxState->tilesetTilesTail = node; + raytmxState->tilesetTilesLength += 1; + + return &node->tile; +} + +TmxAnimationFrame* AddAnimationFrame(RaytmxState* raytmxState) { + RaytmxAnimationFrameNode* node = (RaytmxAnimationFrameNode*)MemAllocZero(sizeof(RaytmxAnimationFrameNode)); + + if (raytmxState->animationFramesRoot == NULL) + raytmxState->animationFramesRoot = node; + else + raytmxState->animationFramesTail->next = node; + raytmxState->animationFramesTail = node; + raytmxState->animationFramesLength += 1; + + return &node->frame; +} + +TmxLayer* AddGenericLayer(RaytmxState* raytmxState, bool isGroup) { + RaytmxLayerNode* node = (RaytmxLayerNode*)MemAllocZero(sizeof(RaytmxLayerNode)); + /* There are some non-zero default values for several layer attributes: */ + node->layer.opacity = 1.0; + node->layer.visible = true; + node->layer.parallaxX = 1.0; + node->layer.parallaxY = 1.0; + + if (raytmxState->groupNode != NULL) { /* If the layer is being appended to a <group> */ + node->parent = raytmxState->groupNode; + if (raytmxState->groupNode->childrenRoot == NULL) /* If the layer is the first in the group */ + raytmxState->groupNode->childrenRoot = node; + else + raytmxState->groupNode->childrenTail->next = node; + raytmxState->groupNode->childrenTail = node; + raytmxState->groupNode->childrenLength += 1; + } else { /* If there is no <group> to append to, meaning the layer belongs to the top-level <map> */ + if (raytmxState->layersRoot == NULL) /* If the layer is the first in the map */ + raytmxState->layersRoot = node; + else + raytmxState->layersTail->next = node; + raytmxState->layersTail = node; + raytmxState->layersLength += 1; + } + + if (isGroup) + raytmxState->groupNode = node; + + return &node->layer; +} + +TmxObject* AddObject(RaytmxState* raytmxState) { + RaytmxObjectNode* node = (RaytmxObjectNode*)MemAllocZero(sizeof(RaytmxObjectNode)); + /* <object> elements have one non-zero default value: */ + node->object.visible = true; + + if (raytmxState->objectsRoot == NULL) + raytmxState->objectsRoot = node; + else + raytmxState->objectsTail->next = node; + raytmxState->objectsTail = node; + raytmxState->objectsLength += 1; + + return &node->object; +} + +void AppendLayerTo(TmxMap* map, RaytmxLayerNode* groupNode, RaytmxLayerNode* layersRoot, uint32_t layersLength) { + if (map == NULL || layersRoot == NULL || layersLength == 0) + return; + + TmxLayer* groupLayer = NULL; + if (groupNode != NULL) + groupLayer = &(groupNode->layer); + + /* Allocate the array and zerioze every index as initialization */ + TmxLayer* layers = (TmxLayer*)MemAllocZero(sizeof(TmxLayer) * layersLength); + /* Copy the TmxLayers into the array */ + RaytmxLayerNode* layersIterator = layersRoot; + for (uint32_t i = 0; layersIterator != NULL; i++) { + if (layersIterator->childrenRoot != NULL) + AppendLayerTo(map, layersIterator, layersIterator->childrenRoot, layersIterator->childrenLength); + layers[i] = layersIterator->layer; + layersIterator = layersIterator->next; + } + + if (groupLayer != NULL) { /* If the list of layers is being appended to a group */ + groupLayer->layers = layers; + groupLayer->layersLength = layersLength; + } else { /* If the list of layers is being appended to the top-level map */ + map->layers = layers; + map->layersLength = layersLength; + } +} + +RaytmxCachedTextureNode* LoadCachedTexture(RaytmxState* raytmxState, const char* fileName) { + if (raytmxState == NULL || fileName == NULL) + return NULL; + + /* First try to find an already-loaded texture identified by the file name */ + RaytmxCachedTextureNode* cachedTextureNode = raytmxState->texturesRoot; + while (cachedTextureNode != NULL) { + /* If the file name associated with the node matches the given file name */ + if (strcmp(cachedTextureNode->fileName, fileName) == 0) + return cachedTextureNode; + cachedTextureNode = cachedTextureNode->next; + } + + /* Try to load the texture */ + char* fullPath = JoinPath(raytmxState->documentDirectory, fileName); + Texture2D texture = loadTextureOverride ? loadTextureOverride(fullPath) : LoadTexture(fullPath); + if (texture.id == 0) { /* If loading the texture failed */ + TraceLog(LOG_ERROR, "RAYTMX: Unable to load texture \"%s\"", fullPath); + return NULL; + } + + /* Create a new node in the list of known textures */ + cachedTextureNode = (RaytmxCachedTextureNode*)MemAllocZero(sizeof(RaytmxCachedTextureNode)); + cachedTextureNode->fileName = (char*)MemAllocZero((unsigned int)strlen(fileName) + 1); + StringCopy(cachedTextureNode->fileName, fileName); + cachedTextureNode->texture = texture; + + /* Add to the cache */ + if (raytmxState->texturesRoot == NULL) + raytmxState->texturesRoot = cachedTextureNode; + else { + RaytmxCachedTextureNode* cachedTextureIterator = raytmxState->texturesRoot; + while (cachedTextureIterator->next != NULL) + cachedTextureIterator = cachedTextureIterator->next; + cachedTextureIterator->next = cachedTextureNode; + } + + return cachedTextureNode; +} + +RaytmxCachedTemplateNode* LoadCachedTemplate(RaytmxState* raytmxState, const char* fileName) { + if (raytmxState == NULL || fileName == NULL) + return NULL; + + /* First try to find an already-loaded template identified by the file name */ + RaytmxCachedTemplateNode* cachedTemplateNode = raytmxState->templatesRoot; + while (cachedTemplateNode != NULL) { + /* If the file name associated with the node matches the given file name */ + if (strcmp(cachedTemplateNode->fileName, fileName) == 0) + return cachedTemplateNode; + cachedTemplateNode = cachedTemplateNode->next; + } + + /* Load the template from the external TX file */ + char* fullPath = JoinPath(raytmxState->documentDirectory, fileName); + RaytmxObjectTemplate objectTemplate = LoadTX(fullPath); + if (!objectTemplate.isSuccess) { /* If loading the template failed */ + TraceLog(LOG_ERROR, "RAYTMX: Unable to load template \"%s\"", fullPath); + return NULL; + } + + /* Create a new node in the list of known templates */ + cachedTemplateNode = (RaytmxCachedTemplateNode*)MemAllocZero(sizeof(RaytmxCachedTemplateNode)); + cachedTemplateNode->fileName = (char*)MemAllocZero((unsigned int)strlen(fileName) + 1); + StringCopy(cachedTemplateNode->fileName, fileName); + cachedTemplateNode->objectTemplate = objectTemplate; + + if (objectTemplate.hasTileset) { /* If the template contains a tileset in addition to an object */ + /* In cases where the template's object references a tile (i.e. its 'gid' attribute is set), the template */ + /* will have at most one tileset. Search the state object's list of tilesets and add this one if it's new. */ + RaytmxTilesetNode* tilesetsIterator = raytmxState->tilesetsRoot; + bool isNew = true; + while (tilesetsIterator != NULL) { + /* If the existing tileset has a name, the template's tileset has a name, and they match OR if the */ + /* existing tileset has a source, template's tileset has a source, and they match */ + /* TODO: The comparison of sources without respect to directory should be reviewed as it could result in */ + /* false negatives and duplicate tileset instances */ + if ((tilesetsIterator->tileset.name != NULL && objectTemplate.tileset.name != NULL && + strcmp(tilesetsIterator->tileset.name, objectTemplate.tileset.name) == 0) || + (tilesetsIterator->tileset.source != NULL && objectTemplate.tileset.source != NULL && + strcmp(tilesetsIterator->tileset.source, objectTemplate.tileset.source) == 0)) { + isNew = false; + break; + } + } + if (isNew) { + TmxTileset* tileset = AddTileset(raytmxState); + *tileset = objectTemplate.tileset; + } + } + + /* Add to the cache */ + if (raytmxState->templatesRoot == NULL) + raytmxState->templatesRoot = cachedTemplateNode; + else { + RaytmxCachedTemplateNode* cachedTemplateIterator = raytmxState->templatesRoot; + while (cachedTemplateIterator->next != NULL) + cachedTemplateIterator = cachedTemplateIterator->next; + cachedTemplateIterator->next = cachedTemplateNode; + } + + return cachedTemplateNode; +} + +Color GetColorFromHexString(const char* hex) { + Color color = BLACK; /* #define'd by raylib as { 0, 0, 0, 255 } */ + + size_t length = strlen(hex); + if (length < 6) /* If the hex string is too short to contain at least R, G, and B components */ + return color; + + /* Hex strings are in the form #AARRGGBB or #RRGGBB meaning alpha is optional. To avoid any special logic for the */ + /* two cases where alpha is or isn't given, parsing will just be done backwards. Here, 'hex' is used as an */ + /* iterator so it will begin at the end of the string. For example, for "#789abc" this begins at 'c'. */ + hex += length - 1; + + char component[] = "\0\0\0"; /* Used to hold the two-digit component (e.g. "55" or "ff") */ + for (size_t i = 0; i < length / 2; i++) { /* Iterate three or four times with four meaning alpha was included */ + component[1] = hex[0]; /* Store the char 'hex' points to. For "#789abc" this is 'c', 'a', or '8'. */ + hex--; /* Point to the previous char in the string. For "#789abc" this now points to 'b', '9' or '7'. */ + component[0] = hex[0]; /* Store the other char of the current component */ + hex--; /* Iterate backwards again in preparation for the next component */ + /* For "#789abc" the 'component' array is now "bc", "9a", or "78" */ + switch (i) { + case 0: color.b = (unsigned char)strtoul(component, NULL, 16); break; /* e.g. "ff" -> 255 for blue */ + case 1: color.g = (unsigned char)strtoul(component, NULL, 16); break; /* ...for green */ + case 2: color.r = (unsigned char)strtoul(component, NULL, 16); break; /* ...for red */ + case 3: color.a = (unsigned char)strtoul(component, NULL, 16); break; /* ...for alpha, maybe */ + } + } + + return color; +} + +uint32_t GetGid(uint32_t rawGid, bool* isFlippedHorizontally, bool* isFlippedVertically, bool* isFlippedDiagonally, + bool* isRotatedHexagonal120) { + /* If the output parameters can be written to, output the status of the flip flags */ + if (isFlippedHorizontally != NULL) + *isFlippedHorizontally = rawGid & FLIP_FLAG_HORIZONTAL; + if (isFlippedVertically != NULL) + *isFlippedVertically = rawGid & FLIP_FLAG_VERTICAL; + if (isFlippedDiagonally != NULL) + *isFlippedDiagonally = rawGid & FLIP_FLAG_DIAGONAL; + if (isRotatedHexagonal120 != NULL) + *isRotatedHexagonal120 = rawGid & FLIP_FLAG_ROTATE_120; + + /* Return the integer with flip flags removed */ + return rawGid & ~(FLIP_FLAG_HORIZONTAL | FLIP_FLAG_VERTICAL | FLIP_FLAG_DIAGONAL | FLIP_FLAG_ROTATE_120); +} + +void* MemAllocZero(unsigned int size) { + void* buffer = MemAlloc(size); /* Reserve 'size' bytes of memory */ + memset(buffer, 0, size); /* Initialize any values to zero, NULL, false, or an equivalent enum value */ + return buffer; +} + +/* "Get directory for a given filePath" */ +/* raylib's GetDirectoryPath() doesn't work as described so this is used in its place */ +char* GetDirectoryPath2(const char* filePath) { + static char directoryPath[260]; /* Max path length on Windows, the bottleneck, is 260 characters */ + memset(directoryPath, '\0', 260); + size_t length = strlen(filePath); + /* Paths beginning with a Windows drive letter (C:\, D:\, etc.) or beginning with a slash are absolute paths */ + if (length >= 2 && (filePath[1] == ':' || filePath[0] == '\\' || filePath[0] == '/')) { /* If absolute */ + if (IsPathFile(filePath)) /* If filePath points to a file, and we already know it's absolute */ + StringCopy(directoryPath, filePath); + else { /* If filePath points to a directory, and we already know it's absolute */ + StringCopy(directoryPath, filePath); + return directoryPath; + } + } else /* If filePath is relative */ + StringCopy(directoryPath, JoinPath(GetWorkingDirectory(), filePath)); + + /* The goal is to return part of filePath, up to the last slash */ + length = strlen(directoryPath); + char* iterator = directoryPath + length - 1; + /* Iterate backwards until a slash is found */ + while (iterator != directoryPath && *iterator != '\0' && *iterator != '\\' && *iterator != '/') + iterator -= 1; + *(iterator + 1) = '\0'; /* Place a null terminator after the slash to effectively end the string there */ + return directoryPath; +} + +char* JoinPath(const char* prefix, const char* suffix) { + static char joinedPath[260]; /* Max path length on Windows, the bottleneck, is 260 characters */ + memset(joinedPath, '\0', 260); + StringCopy(joinedPath, prefix); + size_t prefixLength = strlen(prefix); + if ((prefixLength >= 1) && (joinedPath[prefixLength - 1] != '/') && (joinedPath[prefixLength - 1] != '\\')) +#ifdef _WIN32 + joinedPath[prefixLength] = '\\'; /* Append the path with a '\\' separator */ +#else + joinedPath[prefixLength] = '/'; /* Append the path with a '/' separator */ +#endif + const char* suffixStart = suffix; + size_t suffixLength = strlen(suffix); + if (suffixLength >= 2 && suffix[0] == '.' && (suffix[1] == '/' || suffix[1] == '\\')) + suffixStart += 2; /* Skip over the "this directory" part (e.g. "./a.tsx" -> "a.tsx") */ + /* Note: ".." is kept in the joined path intentionally although it is possible to exceed 260 characters. TODO? */ + StringConcatenate(joinedPath, suffixStart); + return joinedPath; +} + +void StringCopy(char* destination, const char* source) { +#if (!defined _MSC_VER || defined _CRT_SECURE_NO_WARNINGS) + /* This is for build environments where "[M]icro[S]oft [C]ompiler [VER]sion" is not defined, meaning the compiler */ + /* is one other than MSVC, or where MSVC is being used but the security deprecation warning has been disabled. */ + /* MSVC does not consider strcpy() to be secure because it's somewhat unbounded. In practice, it's fine. */ + strcpy(destination, source); +#else + /* This keeps MSVC happy by providing the supposed size of the destination buffer. However, these buffers are */ + /* dynamically allocated so there's no quick way to get the actual size. The best solution is to use strlen() */ + /* but this makes the function O(2n) vs. the alternative's O(n). */ + strcpy_s(destination, strlen(source) + 1, source); /* + 1 for the terminator */ +#endif +} + +void StringCopyN(char* destination, const char* source, size_t number) { +#if (!defined _MSC_VER || defined _CRT_SECURE_NO_WARNINGS) + strncpy(destination, source, number); +#else + strncpy_s(destination, number + 1, source, number); +#endif +} + +void StringConcatenate(char* destination, const char* source) { +#if (!defined _MSC_VER || defined _CRT_SECURE_NO_WARNINGS) + strcat(destination, source); +#else + strcat_s(destination, strlen(destination) + strlen(source) + 1, source); +#endif +} + +#endif /* RAYTMX_IMPLEMENTATION */ + +#endif /* RAYTMX_H */ |