### Minimal raytmx Example

Source: https://github.com/luphi/raytmx/blob/main/README.md

A complete example demonstrating map loading, camera movement, animation, and rendering.

```c
#include <stddef.h> // Required for: NULL.
#include <stdlib.h> // Required for: EXIT_FAILURE, EXIT_SUCCESS.

#include "raylib.h"

#define RAYTMX_IMPLEMENTATION
#include "raytmx.h"

int main(void)
{
    // Configure the window with a resolution and title. This example will also target 60 frames per second.
    const int screenWidth = 1024;
    const int screenHeight = 768;
    const float panSpeed = 150.0f; // Pixels per second.
    InitWindow(screenWidth, screenHeight, "raytmx example");
    SetTargetFPS(60);

    // Load the map from disk. If loading fails, NULL will be returned and details will be TraceLog()'d.
    TmxMap *map = LoadTMX("example.tmx");
    if (map == NULL)
    {
        TraceLog(LOG_ERROR, "Failed to load TMX \"example.tmx\"");
        CloseWindow();
        return EXIT_FAILURE;
    }

    // Create a camera that initially looks at the center of the map.
    Camera2D camera = { 0 };
    camera.target = (Vector2){ (float)(map->width*map->tileWidth)/2.0f, (float)(map->height*map->tileHeight)/2.0f };
    camera.offset = (Vector2){ (float)screenWidth/2.0f, (float)screenHeight/2.0f };
    camera.rotation = 0.0f;
    camera.zoom = 6.0f;

    while (!WindowShouldClose())
    {
        // Pan the camera based on which arrow key, if any, is pressed.
        if (IsKeyDown(KEY_RIGHT)) camera.target.x += panSpeed*GetFrameTime();
        if (IsKeyDown(KEY_LEFT)) camera.target.x -= panSpeed*GetFrameTime();
        if (IsKeyDown(KEY_DOWN)) camera.target.y += panSpeed*GetFrameTime();
        if (IsKeyDown(KEY_UP)) camera.target.y -= panSpeed*GetFrameTime();

        BeginDrawing();
        {
            ClearBackground(BLACK);
            BeginMode2D(camera);
            {
                AnimateTMX(map);
                DrawTMX(map, &camera, NULL, 0, 0, WHITE);
            }
            EndMode2D();
        }
        EndDrawing();
    }

    UnloadTMX(map);
    CloseWindow();

    return EXIT_SUCCESS;
}
```

--------------------------------

### Initialize raytmx

Source: https://github.com/luphi/raytmx/blob/main/README.md

Define the implementation macro before including the header file in exactly one source file.

```c
#define RAYTMX_IMPLEMENTATION
#include "raytmx.h"
```

--------------------------------

### Complete Game Loop with raytmx

Source: https://context7.com/luphi/raytmx/llms.txt

This C code demonstrates a complete game loop using raytmx for map loading, player movement with collision detection, camera control, and rendering. It requires raylib and raytmx libraries. Ensure 'game_level.tmx' is in the same directory.

```c
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "raylib.h"

#define RAYTMX_IMPLEMENTATION
#include "raytmx.h"

#define PLAYER_SPEED 100.0f

int main(void)
{
    const int screenWidth = 1024;
    const int screenHeight = 768;
    InitWindow(screenWidth, screenHeight, "raytmx Complete Example");
    SetTargetFPS(60);

    TmxMap *map = LoadTMX("game_level.tmx");
    if (map == NULL)
    {
        CloseWindow();
        return EXIT_FAILURE;
    }

    // Player setup
    Vector2 playerPos = {
        (float)(map->width * map->tileWidth) / 2.0f,
        (float)(map->height * map->tileHeight) / 2.0f
    };
    float playerRadius = (float)map->tileWidth / 3.0f;

    // Camera setup
    Camera2D camera = { 0 };
    camera.offset = (Vector2){ screenWidth / 2.0f, screenHeight / 2.0f };
    camera.target = playerPos;
    camera.zoom = 4.0f;

    while (!WindowShouldClose())
    {
        // Input handling
        Vector2 velocity = { 0 };
        if (IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_D)) velocity.x += 1.0f;
        if (IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_A)) velocity.x -= 1.0f;
        if (IsKeyDown(KEY_DOWN) || IsKeyDown(KEY_S)) velocity.y += 1.0f;
        if (IsKeyDown(KEY_UP) || IsKeyDown(KEY_W)) velocity.y -= 1.0f;

        // Normalize and apply speed
        if (velocity.x != 0 || velocity.y != 0)
        {
            float length = sqrtf(velocity.x * velocity.x + velocity.y * velocity.y);
            velocity.x = (velocity.x / length) * PLAYER_SPEED * GetFrameTime();
            velocity.y = (velocity.y / length) * PLAYER_SPEED * GetFrameTime();

            // Move X axis with collision check
            Vector2 newPos = { playerPos.x + velocity.x, playerPos.y };
            if (!CheckCollisionTMXTileLayersCircle(map, map->layers, map->layersLength,
                newPos, playerRadius, NULL))
            {
                playerPos.x = newPos.x;
            }

            // Move Y axis with collision check
            newPos = (Vector2){ playerPos.x, playerPos.y + velocity.y };
            if (!CheckCollisionTMXTileLayersCircle(map, map->layers, map->layersLength,
                newPos, playerRadius, NULL))
            {
                playerPos.y = newPos.y;
            }

            camera.target = playerPos;
        }

        // Rendering
        BeginDrawing();
        ClearBackground(BLACK);
        BeginMode2D(camera)
        {
            AnimateTMX(map);
            DrawTMX(map, &camera, NULL, 0, 0, WHITE);
            DrawCircleV(playerPos, playerRadius, BLUE);
        }
        EndMode2D();
        DrawFPS(10, 10);
        EndDrawing();
    }

    UnloadTMX(map);
    CloseWindow();
    return EXIT_SUCCESS;
}

```

--------------------------------

### Configure Debug Logging in C

Source: https://context7.com/luphi/raytmx/llms.txt

Use TraceLogTMX to output map structure details and SetTraceLogFlagsTMX to filter specific data types from the logs. Flags are bitwise and can be combined to reduce log verbosity.

```c
// Log full map structure
TraceLogTMX(LOG_DEBUG, map);

// Configure logging flags to reduce output
SetTraceLogFlagsTMX(
    LOG_SKIP_TILES |           // Skip individual tile GIDs
    LOG_SKIP_PROPERTIES |      // Skip custom properties
    LOG_SKIP_OBJECTS           // Skip object details
);

// Log with filters applied
TraceLogTMX(LOG_INFO, map);

// Available flags:
// LOG_SKIP_PROPERTIES      - Skip <properties> elements
// LOG_SKIP_LAYERS          - Skip all layer types
// LOG_SKIP_TILE_LAYERS     - Skip tile layers specifically
// LOG_SKIP_TILES           - Skip individual tile GIDs
// LOG_SKIP_OBJECT_GROUPS   - Skip object group layers
// LOG_SKIP_OBJECTS         - Skip objects within groups
// LOG_SKIP_IMAGE_LAYERS    - Skip image layers
// LOG_SKIP_IMAGES          - Skip image details
// LOG_SKIP_WANG_SETS       - Skip Wang sets
// LOG_SKIP_WANG_TILES      - Skip Wang tiles
```

--------------------------------

### Draw TMX Map with Camera Support in C

Source: https://context7.com/luphi/raytmx/llms.txt

Draws all visible layers of a TMX map using DrawTMX(), supporting parallax scrolling when a Camera2D is provided. Ensure raytmx.h is included with RAYTMX_IMPLEMENTATION defined.

```c
#include "raylib.h"
#define RAYTMX_IMPLEMENTATION
#include "raytmx.h"

int main(void)
{
    const int screenWidth = 1024;
    const int screenHeight = 768;
    InitWindow(screenWidth, screenHeight, "Drawing TMX Maps");
    SetTargetFPS(60);

    TmxMap *map = LoadTMX("example.tmx");
    if (map == NULL) return EXIT_FAILURE;

    // Create a camera centered on the map
    Camera2D camera = { 0 };
    camera.offset = (Vector2){ screenWidth / 2.0f, screenHeight / 2.0f };
    camera.target = (Vector2){
        (float)(map->width * map->tileWidth) / 2.0f,
        (float)(map->height * map->tileHeight) / 2.0f
    };
    camera.zoom = 4.0f;

    const float panSpeed = 10.0f * map->tileWidth;

    while (!WindowShouldClose())
    {
        // Camera panning with arrow keys
        if (IsKeyDown(KEY_RIGHT)) camera.target.x += panSpeed * GetFrameTime();
        if (IsKeyDown(KEY_LEFT)) camera.target.x -= panSpeed * GetFrameTime();
        if (IsKeyDown(KEY_DOWN)) camera.target.y += panSpeed * GetFrameTime();
        if (IsKeyDown(KEY_UP)) camera.target.y -= panSpeed * GetFrameTime();

        BeginDrawing();
        ClearBackground(BLACK);
        BeginMode2D(camera);
        {
            // Draw all layers with parallax support
            // Parameters: map, camera (for parallax), viewport (NULL = auto), position, tint
            DrawTMX(map, &camera, NULL, 0, 0, WHITE);
        }
        EndMode2D();
        DrawFPS(10, 10);
        EndDrawing();
    }

    UnloadTMX(map);
    CloseWindow();
    return EXIT_SUCCESS;
}
```

--------------------------------

### Load and Unload TMX Map in C

Source: https://context7.com/luphi/raytmx/llms.txt

Loads a TMX map from disk using LoadTMX() and frees all associated resources with UnloadTMX(). Returns NULL on failure. Ensure raytmx.h is included with RAYTMX_IMPLEMENTATION defined.

```c
#include <stddef.h>
#include <stdlib.h>
#include "raylib.h"

#define RAYTMX_IMPLEMENTATION
#include "raytmx.h"

int main(void)
{
    InitWindow(1024, 768, "TMX Example");
    SetTargetFPS(60);

    // Load map from disk - returns NULL on failure
    TmxMap *map = LoadTMX("assets/level.tmx");
    if (map == NULL)
    {
        TraceLog(LOG_ERROR, "Failed to load TMX file");
        CloseWindow();
        return EXIT_FAILURE;
    }

    // Access map properties
    TraceLog(LOG_INFO, "Map size: %u x %u tiles", map->width, map->height);
    TraceLog(LOG_INFO, "Tile size: %u x %u pixels", map->tileWidth, map->tileHeight);
    TraceLog(LOG_INFO, "Layers: %u, Tilesets: %u", map->layersLength, map->tilesetsLength);

    // Game loop here...

    // Free all map resources including textures
    UnloadTMX(map);
    CloseWindow();
    return EXIT_SUCCESS;
}
```

--------------------------------

### Rendering and Animation

Source: https://github.com/luphi/raytmx/blob/main/README.md

Functions for drawing maps and updating animations.

```APIDOC
## DrawTMX

### Description
Draws the entire TMX map.

### Endpoint
void DrawTMX(const TmxMap *map, const Camera2D *camera, const Rectangle *viewport, int posX, int posY, Color tint);

## DrawTMXLayers

### Description
Draws specific layers of a TMX map.

### Endpoint
void DrawTMXLayers(const TmxMap *map, const Camera2D *camera, const Rectangle *viewport, const TmxLayer *layers, uint32_t layersLength, int posX, int posY, Color tint);

## AnimateTMX

### Description
Updates map animations. Should be called once per frame.

### Endpoint
void AnimateTMX(TmxMap *map);
```

--------------------------------

### Perform Collision Detection

Source: https://github.com/luphi/raytmx/blob/main/README.md

Functions for checking collisions between objects, tile layers, and shapes. Optional output variables are provided for collision response.

```c
bool CheckCollisionTMXObjects(TmxObject object1, TmxObject object2);
bool CheckCollisionTMXTileLayersRec(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength, Rectangle rec,
    TmxObject *outputObject);
bool CheckCollisionTMXTileLayersCircle(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength, Vector2 center,
    float radius, TmxObject *outputObject);
bool CheckCollisionTMXTileLayersPoint(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength, Vector2 point,
    TmxObject *outputObject);
bool CheckCollisionTMXTileLayersPolyPoly(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength,
    Vector2 *points, int pointCount, TmxObject *outputObject);
bool CheckCollisionTMXTileLayersPolyPolyEx(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength,
    Vector2 *points, int pointCount, Rectangle aabb, TmxObject *outputObject);
bool CheckCollisionTMXObjectGroupRec(TmxObjectGroup group, Rectangle rec, TmxObject *outputObject);
bool CheckCollisionTMXObjectGroupCircle(TmxObjectGroup group, Vector2 center, float radius, TmxObject *outputObject);
bool CheckCollisionTMXObjectGroupPoint(TmxObjectGroup group, Vector2 point, TmxObject *outputObject);
bool CheckCollisionTMXObjectGroupPoly(TmxObjectGroup group, Vector2 *points, int pointCount, TmxObject *outputObject);
bool CheckCollisionTMXObjectGroupPolyEx(TmxObjectGroup group, Vector2 *points, int pointCount, Rectangle aabb,
    TmxObject *outputObject);
```

--------------------------------

### Iterate Map Layers and Objects in C

Source: https://context7.com/luphi/raytmx/llms.txt

Traverse map layers and nested objects to access custom properties defined in Tiled. Ensure the map structure is loaded before accessing layer or object arrays.

```c
// Iterate through layers
for (uint32_t i = 0; i < map->layersLength; i++)
{
    TmxLayer layer = map->layers[i];
    TraceLog(LOG_INFO, "Layer: %s, Type: %d, Visible: %d",
        layer.name, layer.type, layer.visible);

    // Check layer type
    switch (layer.type)
    {
        case LAYER_TYPE_TILE_LAYER:
            TraceLog(LOG_INFO, "  Tiles: %u", layer.exact.tileLayer.tilesLength);
            break;

        case LAYER_TYPE_OBJECT_GROUP:
        {
            TmxObjectGroup group = layer.exact.objectGroup;

            // Iterate through objects in the group
            for (uint32_t j = 0; j < group.objectsLength; j++)
            {
                TmxObject obj = group.objects[j];
                TraceLog(LOG_INFO, "  Object: %s at (%.1f, %.1f) size %.1fx%.1f",
                    obj.name, obj.x, obj.y, obj.width, obj.height);

                // Access custom properties
                for (uint32_t k = 0; k < obj.propertiesLength; k++)
                {
                    TmxProperty prop = obj.properties[k];

                    switch (prop.type)
                    {
                        case PROPERTY_TYPE_STRING:
                            TraceLog(LOG_INFO, "    %s = \"%s\"", prop.name, prop.stringValue);
                            break;
                        case PROPERTY_TYPE_INT:
                            TraceLog(LOG_INFO, "    %s = %d", prop.name, prop.intValue);
                            break;
                        case PROPERTY_TYPE_FLOAT:
                            TraceLog(LOG_INFO, "    %s = %f", prop.name, prop.floatValue);
                            break;
                        case PROPERTY_TYPE_BOOL:
                            TraceLog(LOG_INFO, "    %s = %s", prop.name, prop.boolValue ? "true" : "false");
                            break;
                        case PROPERTY_TYPE_COLOR:
                            TraceLog(LOG_INFO, "    %s = color", prop.name);
                            break;
                    }
                }
            }
            break;
        }

        case LAYER_TYPE_IMAGE_LAYER:
            TraceLog(LOG_INFO, "  Image layer");
            break;

        case LAYER_TYPE_GROUP:
            TraceLog(LOG_INFO, "  Group with %u child layers", layer.layersLength);
            break;
    }
}
```

--------------------------------

### Map Lifecycle Management

Source: https://github.com/luphi/raytmx/blob/main/README.md

Functions for loading and unloading TMX map data.

```APIDOC
## LoadTMX

### Description
Loads a TMX map from a file.

### Endpoint
TmxMap* LoadTMX(const char *fileName);

## UnloadTMX

### Description
Unloads a TMX map and frees associated memory.

### Endpoint
void UnloadTMX(TmxMap *map);
```

--------------------------------

### Draw TMX Maps

Source: https://github.com/luphi/raytmx/blob/main/README.md

Functions for rendering TMX maps and specific layers.

```c
void DrawTMX(const TmxMap *map, const Camera2D *camera, const Rectangle *viewport, int posX, int posY, Color tint);
void DrawTMXLayers(const TmxMap *map, const Camera2D *camera, const Rectangle *viewport, const TmxLayer *layers,
    uint32_t layersLength, int posX, int posY, Color tint);
```

--------------------------------

### Load and Unload TMX Maps

Source: https://github.com/luphi/raytmx/blob/main/README.md

Functions for managing the lifecycle of a TMX map object.

```c
TmxMap* LoadTMX(const char *fileName);
void UnloadTMX(TmxMap *map);
```

--------------------------------

### Override Texture Loading in C

Source: https://context7.com/luphi/raytmx/llms.txt

Use SetLoadTextureTMX to register a custom callback for loading textures. This must be called before loading any TMX maps to take effect.

```c
// Custom texture loading callback
Texture2D CustomLoadTexture(const char *fileName)
{
    // Custom loading logic - e.g., from packed resources
    TraceLog(LOG_INFO, "Loading texture: %s", fileName);

    // Could load from pak file, apply processing, etc.
    return LoadTexture(fileName);
}

int main(void)
{
    InitWindow(1024, 768, "Custom Texture Loading");

    // Set custom texture loader before loading any maps
    SetLoadTextureTMX(CustomLoadTexture);

    TmxMap *map = LoadTMX("level.tmx");
    // Textures will be loaded via CustomLoadTexture

    // ...

    UnloadTMX(map);
    CloseWindow();
    return EXIT_SUCCESS;
}
```

--------------------------------

### Animate Tiles in TMX Map in C

Source: https://context7.com/luphi/raytmx/llms.txt

Updates animated tile frames based on elapsed time by calling AnimateTMX() once per frame. This function should be called between BeginDrawing() and EndDrawing() to ensure animations are rendered correctly.

```c
while (!WindowShouldClose())
{
    BeginDrawing();
    ClearBackground(BLACK);
    BeginMode2D(camera);
    {
        // Update animated tiles - call once per frame
        // Automatically advances animation frames based on frame durations
        AnimateTMX(map);

        // Draw the map with updated animations
        DrawTMX(map, &camera, NULL, 0, 0, WHITE);
    }
    EndMode2D();
    EndDrawing();
}
```

--------------------------------

### Collision Detection

Source: https://github.com/luphi/raytmx/blob/main/README.md

Functions for checking collisions between objects, tile layers, and shapes.

```APIDOC
## Collision Functions

### Description
Provides various collision detection methods for TMX objects and layers. Output objects are provided via an optional output parameter.

### Methods
- bool CheckCollisionTMXObjects(TmxObject object1, TmxObject object2);
- bool CheckCollisionTMXTileLayersRec(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength, Rectangle rec, TmxObject *outputObject);
- bool CheckCollisionTMXTileLayersCircle(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength, Vector2 center, float radius, TmxObject *outputObject);
- bool CheckCollisionTMXTileLayersPoint(const TmxMap *map, const TmxLayer *layers, uint32_t layersLength, Vector2 point, TmxObject *outputObject);
- bool CheckCollisionTMXObjectGroupRec(TmxObjectGroup group, Rectangle rec, TmxObject *outputObject);
- bool CheckCollisionTMXObjectGroupCircle(TmxObjectGroup group, Vector2 center, float radius, TmxObject *outputObject);
- bool CheckCollisionTMXObjectGroupPoint(TmxObjectGroup group, Vector2 point, TmxObject *outputObject);
```

--------------------------------

### Polygon Collision with TMX Tile Layers (Optimized)

Source: https://context7.com/luphi/raytmx/llms.txt

Perform polygon collision detection against collidable tiles in TMX map layers, using a pre-computed Axis-Aligned Bounding Box (AABB) for optimization. Requires an array of polygon points and the point count.

```c
// Polygon collision with pre-computed AABB for optimization
Vector2 polyPoints[6];
// ... fill polygon points ...
Rectangle polyAABB = { minX, minY, maxX - minX, maxY - minY };

if (CheckCollisionTMXTileLayersPolyEx(map, map->layers, map->layersLength,
    polyPoints, 6, polyAABB, NULL))
{
    // Polygon collision detected
}
```

--------------------------------

### Animate TMX Maps

Source: https://github.com/luphi/raytmx/blob/main/README.md

Updates map animations; call this function once per frame.

```c
void AnimateTMX(TmxMap *map);
```

--------------------------------

### Point Collision with TMX Tile Layers

Source: https://context7.com/luphi/raytmx/llms.txt

Determine if a specific point collides with any collidable tiles in the TMX map layers. Useful for mouse picking or click detection.

```c
// Point collision (useful for picking/clicking)
Vector2 mouseWorld = GetScreenToWorld2D(GetMousePosition(), camera);

if (CheckCollisionTMXTileLayersPoint(map, map->layers, map->layersLength, mouseWorld, &collidedObject))
{
    // Mouse is over a collidable tile
}
```

--------------------------------

### Find and Collide with TMX Object Group (Rectangle)

Source: https://context7.com/luphi/raytmx/llms.txt

Locate a specific object group by name within a TMX map and then check for rectangle collisions against the objects within that group. Useful for trigger zones or hand-placed collision volumes.

```c
// Find a collision object group by name
TmxObjectGroup wallsGroup = { 0 };
for (uint32_t i = 0; i < map->layersLength; i++)
{
    if (map->layers[i].type == LAYER_TYPE_OBJECT_GROUP &&
        strcmp(map->layers[i].name, "Walls") == 0)
    {
        wallsGroup = map->layers[i].exact.objectGroup;
        break;
    }
}

// Rectangle collision with object group
Rectangle playerRect = { playerX, playerY, 16.0f, 16.0f };
TmxObject hitObject;

if (CheckCollisionTMXObjectGroupRec(wallsGroup, playerRect, &hitObject))
{
    TraceLog(LOG_INFO, "Hit wall: %s at (%f, %f)", hitObject.name, hitObject.x, hitObject.y);
}
```

--------------------------------

### Point Collision with TMX Object Group

Source: https://context7.com/luphi/raytmx/llms.txt

Detect if a specific point collides with any objects in a TMX object group. This is commonly used for click detection on specific interactive elements.

```c
// Point collision
if (CheckCollisionTMXObjectGroupPoint(wallsGroup, point, &hitObject))
{
    // Handle collision
}
```

--------------------------------

### Draw Specific TMX Layers

Source: https://context7.com/luphi/raytmx/llms.txt

Render only specified layers from a TMX map, useful for drawing entities between background and foreground layers. Find layers by iterating through the map's layers.

```c
// Draw specific layers by reference
// Useful for drawing player between background and foreground
void DrawGame(TmxMap *map, Camera2D *camera)
{
    // Find specific layers by iterating
    TmxLayer *backgroundLayer = NULL;
    TmxLayer *foregroundLayer = NULL;

    for (uint32_t i = 0; i < map->layersLength; i++)
    {
        if (strcmp(map->layers[i].name, "Background") == 0)
            backgroundLayer = &map->layers[i];
        else if (strcmp(map->layers[i].name, "Foreground") == 0)
            foregroundLayer = &map->layers[i];
    }

    // Draw background layers
    if (backgroundLayer != NULL)
        DrawTMXLayers(map, camera, NULL, backgroundLayer, 1, 0, 0, WHITE);

    // Draw player here between layers
    DrawPlayer();

    // Draw foreground layers
    if (foregroundLayer != NULL)
        DrawTMXLayers(map, camera, NULL, foregroundLayer, 1, 0, 0, WHITE);
}
```

--------------------------------

### Polygon Collision with TMX Object Group (Optimized)

Source: https://context7.com/luphi/raytmx/llms.txt

Perform optimized polygon collision detection against objects in a TMX object group using a pre-computed AABB. This function requires the polygon points, point count, and the AABB for efficient checking.

```c
// Polygon collision with AABB optimization
if (CheckCollisionTMXObjectGroupPolyEx(wallsGroup, polyPoints, pointCount, polyAABB, NULL))
{
    // Handle collision
}
```

--------------------------------

### Circle Collision with TMX Tile Layers

Source: https://context7.com/luphi/raytmx/llms.txt

Check for collisions between a circle and collidable tiles in TMX map layers. This function can optionally return the `TmxObject` that was collided with.

```c
// Circle collision
Vector2 center = { playerX + 8.0f, playerY + 8.0f };
float radius = 8.0f;

if (CheckCollisionTMXTileLayersCircle(map, map->layers, map->layersLength, center, radius, NULL))
{
    // Handle collision
}
```

--------------------------------

### Circle Collision with TMX Object Group

Source: https://context7.com/luphi/raytmx/llms.txt

Check for collisions between a circle and objects within a specified TMX object group. This is useful for detecting interactions with circular trigger zones or collision shapes.

```c
// Circle collision
if (CheckCollisionTMXObjectGroupCircle(wallsGroup, center, radius, NULL))
{
    // Handle collision
}
```

--------------------------------

### Rectangle Collision with TMX Tile Layers

Source: https://context7.com/luphi/raytmx/llms.txt

Detect collisions between a rectangle and collidable tiles within specified layers of a TMX map. The `collidedObject` parameter will be populated with the tile's collision shape if a collision occurs.

```c
// Rectangle collision with tile collision objects
Rectangle playerRect = { playerX, playerY, 16.0f, 16.0f };
TmxObject collidedObject;

if (CheckCollisionTMXTileLayersRec(map, map->layers, map->layersLength, playerRect, &collidedObject))
{
    // Collision detected - collidedObject contains the tile's collision shape
    TraceLog(LOG_INFO, "Hit object: %s", collidedObject.name);
}
```

--------------------------------

### Object-to-Object Collision Check

Source: https://context7.com/luphi/raytmx/llms.txt

Directly check for collisions between two `TmxObject` instances. This method supports all TMX object types, including rectangles, ellipses, points, polygons, and more.

```c
// Check collision between two TMX objects
TmxObject object1 = group.objects[0];
TmxObject object2 = group.objects[1];

if (CheckCollisionTMXObjects(object1, object2))
{
    // Objects are colliding
    // Supports: rectangles, ellipses, points, polygons, polylines, text, tiles
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.