Add object layer rendering

engine/breeze/world/map.c

@@ -146,7 +146,10 @@ BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
             BzTileLayer *layer = map.layers + slot;
             const BzTileLayerDesc *layerDesc = desc->layers + slot;
             handleTileLayer(layer, cuteLayer);
-            if (layerDesc->handler) layerDesc->handler(layer);
+            if (layerDesc->handler && !layerDesc->handler(layer)) {
+                bzFree(layer->data);
+                layer->dataCount = 0;
+            }
             map.layerCount++;
         } else {
             BzTileObjectLayer *objectLayer = map.objectLayers + slot;
@@ -155,7 +158,10 @@ BzTileMap bzTileMapCreate(const BzTileMapDesc *desc) {
             if (!hashFunc)
                 hashFunc = bzStringDefaultHash;
             handleTileObjectLayer(objectLayer, cuteLayer, hashFunc);
-            if (objectLayerDesc->handler) objectLayerDesc->handler(objectLayer);
+            if (objectLayerDesc->handler && !objectLayerDesc->handler(objectLayer)) {
+                bzFree(objectLayer->objects);
+                objectLayer->objectCount = 0;
+            }
             map.objectLayerCount++;
         }
 
@@ -228,15 +234,42 @@ static void drawLayer(BzTileLayer *layer, BzTileset *tileset) {
 
 }
 
+static void drawObjectLayer(BzTileObjectLayer *objectLayer) {
+    Color color = ORANGE;
+    for (int i = 0; i < objectLayer->objectCount; i++) {
+        BzTileShape shape = objectLayer->objects[i].shape;
+        switch (shape.type) {
+            case BZ_TILE_SHAPE_NONE:
+                break;
+            case BZ_TILE_SHAPE_POINT:
+                DrawCircle(shape.x, shape.y, 2.0f, color);
+                break;
+            case BZ_TILE_SHAPE_RECT:
+                DrawRectangle(shape.x, shape.y, shape.sizeX, shape.sizeY, color);
+                break;
+            case BZ_TILE_SHAPE_ELLIPSE:
+                DrawEllipse(shape.x, shape.y, shape.sizeX, shape.sizeY, color);
+                break;
+        }
+    }
+}
+
 void bzTileMapDraw(BzTileMap *map) {
     for (i32 i = 0; i < map->layerCount; i++) {
         BzTileLayer *layer = map->layers + i;
+        if (!layer->data) continue;
         BzTileset *tileset = NULL;
         if (layer->tilesetIdx != -1) {
             tileset = map->tilesets + layer->tilesetIdx;
         }
         drawLayer(map->layers + i, tileset);
     }
+
+    for (i32 i = 0; i < map->objectLayerCount; i++) {
+        BzTileObjectLayer *objectLayer = map->objectLayers + i;
+        if (!objectLayer->objects) continue;
+        drawObjectLayer(objectLayer);
+    }
 }
 
 void bzTileMapDrawColliders(BzTileMap *map) {

engine/breeze/world/map.h

@@ -25,11 +25,15 @@ typedef struct BzTileLayer {
     f32 opacity;
 
     i32 tilesetIdx;
+
+    void *userData;
 } BzTileLayer;
 
 typedef struct BzTileObject {
     u32 id;
     BzTileShape shape;
+
+    void *userData;
 } BzTileObject;
 
 typedef struct BzTileObjectLayer {
@@ -37,17 +41,22 @@ typedef struct BzTileObjectLayer {
     i32 objectCount;
 } BzTileObjectLayer;
 
-// Return true, if it should be added to map
-typedef bool BzTileLayerHandler(BzTileLayer *layer);
-typedef bool BzTileObjectsHandler(BzTileObjectLayer *objectLayer);
+// Return true, if you want to keep data allocated
+typedef bool BzTileLayerFunc(BzTileLayer *layer);
+typedef bool BzTileObjectsFunc(BzTileObjectLayer *objectLayer);
+
+typedef void BzTileLayerRenderFunc(BzTileLayer *layer);
+typedef void BzTileObjectsRenderFunc(BzTileObjectLayer *objectLayer);
 
 typedef struct BzTileLayerDesc {
     const char *name; // Matches map layer names
-    BzTileLayerHandler *handler;
+    BzTileLayerFunc *handler;
+    BzTileLayerRenderFunc *renderer;
 } BzTileLayerDesc;
 typedef struct BzTileObjectsDesc {
     const char *name; // Matches map layer names
-    BzTileObjectsHandler *handler;
+    BzTileObjectsFunc *handler;
+    BzTileObjectsRenderFunc *renderer;
     BzStringHashFunc *hashFunc;
 } BzTileObjectsDesc;
 

game/main.c

@@ -27,6 +27,10 @@ bool handleGameObjects(BzTileObjectLayer *objectLayer) {
     return false;
 }
 
+bool handleBuildLayer(BzTileLayer *layer) {
+    return true;
+}
+
 bool canBuildOn(BzTileMap *map, i32 tileX, i32 tileY, i32 sizeX, i32 sizeY) {
     // Ensure that it is within the map
     if (tileX < 0 || tileX + sizeX > map->width ||
@@ -106,7 +110,7 @@ bool init(Game *game) {
         .layers[1]=(BzTileLayerDesc) {"Foliage", NULL},
         .layers[2]=(BzTileLayerDesc) {"Trees", NULL},
         .layers[3]=(BzTileLayerDesc) {"TreesS", NULL},
-        .layers[4]=(BzTileLayerDesc) {"Buildings", NULL},
+        .layers[4]=(BzTileLayerDesc) {"Buildings", handleBuildLayer},
 
         .objectLayers[0]=(BzTileObjectsDesc) {"Game", handleGameObjects},
         .objectLayers[1]=(BzTileObjectsDesc ) {"Entities", NULL}