feat(deps): add raylib and raytmx dependencies

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 */