Remove entity map in favor of spatial grid

engine/CMakeLists.txt

@@ -38,6 +38,7 @@ set(BreezeSources
         breeze/utils/array.c
         breeze/utils/heap.c
         breeze/utils/object_pool.c
+        breeze/utils/spatial_grid.c
         breeze/utils/tokenizer.c
     )
 
@@ -53,6 +54,7 @@ set(BreezeHeaders
         breeze/utils/array.h
         breeze/utils/heap.h
         breeze/utils/object_pool.h
+        breeze/utils/spatial_grid.h
         breeze/utils/string.h
         breeze/utils/tokenizer.h
 

engine/breeze.h

@@ -9,6 +9,7 @@
 #include "breeze/utils/array.h"
 #include "breeze/utils/heap.h"
 #include "breeze/utils/object_pool.h"
+#include "breeze/utils/spatial_grid.h"
 #include "breeze/utils/string.h"
 #include "breeze/utils/tokenizer.h"
 

engine/breeze/map/tileset.c

@@ -66,14 +66,14 @@ BzTileset bzTilesetCreate(const BzTilesetDesc *desc) {
         }
     }
 
-    cute_tiled_free_external_tileset(cuteTileset);
 
     if (tileset.tiles.width != cuteTileset->imagewidth ||
         tileset.tiles.height != cuteTileset->imageheight) {
+        cute_tiled_free_external_tileset(cuteTileset);
         bzTilesetDestroy(&tileset);
         return BZ_TILESET_INVALID;
     }
-
+    cute_tiled_free_external_tileset(cuteTileset);
     tileset.isValid = true;
     return tileset;
 }
@@ -107,6 +107,7 @@ BzTileShape bzTilesetGetTileCollider(BzTileset *tileset, BzTile tileID) {
 
 void bzTilesetDestroy(BzTileset *tileset) {
     UnloadTexture(tileset->tiles);
+    bzFree(tileset->tileColliders);
     *tileset = BZ_TILESET_INVALID;
 }
 

engine/breeze/utils/object_pool.c

@@ -9,10 +9,6 @@ typedef struct BzObjectPool {
     i32 firstFree;
 } BzObjectPool;
 
-static i32 *bzObjectPoolGetObject(const BzObjectPool *pool, size_t idx) {
-    return (i32 *) ((u8 *) pool->objects + idx * pool->stride);
-}
-
 BzObjectPool *bzObjectPoolCreate(const BzObjectPoolDesc *desc) {
     BZ_ASSERT(desc->objectSize > 0);
 
@@ -53,9 +49,16 @@ void *bzObjectPool(BzObjectPool *pool) {
     pool->firstFree = *object;
     return object;
 }
+void *bzObjectPoolGetObject(BzObjectPool *pool, i32 idx) {
+    BZ_ASSERT(idx >= 0 && (size_t) idx < pool->numObjects);
+    return (void *) ((u8 *) pool->objects + idx * pool->stride);
+}
+i32 bzObjectPoolGetIdx(BzObjectPool *pool, void *object) {
+    size_t objectIdx = (size_t) object - (size_t) pool->numObjects;
+    return (i32) (objectIdx / pool->stride);
+}
 void bzObjectPoolRelease(BzObjectPool *pool, void *object) {
-    size_t objectIdx = (size_t) object - (size_t) pool->objects;
-    objectIdx /= pool->stride;
+    size_t objectIdx = bzObjectPoolGetIdx(pool, object);
     BZ_ASSERT(objectIdx < pool->numObjects);
     *(i32 *) ((u8 *) pool->objects + objectIdx * pool->stride) = pool->firstFree;
     pool->firstFree = (i32) objectIdx;

engine/breeze/utils/object_pool.h

@@ -14,6 +14,8 @@ BzObjectPool *bzObjectPoolCreate(const BzObjectPoolDesc *desc);
 void bzObjectPoolDestroy(BzObjectPool *pool);
 
 void *bzObjectPool(BzObjectPool *pool);
+void *bzObjectPoolGetObject(BzObjectPool *pool, i32 idx);
+i32 bzObjectPoolGetIdx(BzObjectPool *pool, void *object);
 void bzObjectPoolRelease(BzObjectPool *pool, void *object);
 
 #endif //BREEZE_OBJECT_POOL_H

engine/breeze/utils/spatial_grid.c

@@ -0,0 +1,226 @@
+#include "spatial_grid.h"
+
+#include "../core/memory.h"
+#include "array.h"
+#include "object_pool.h"
+
+#include <math.h>
+
+typedef struct BzSpatialGrid {
+    BzSpatialGridID **cells;
+    BzObjectPool *entriesPool;
+    i32 width;
+    i32 height;
+    i32 cellWidth;
+    i32 cellHeight;
+    i32 userDataSize;
+    i32 queryCount;
+} BzSpatialGrid;
+
+static BzSpatialGridID **getCell(const BzSpatialGrid *grid, i32 x, i32 y);
+
+BzSpatialGrid *bzSpatialGridCreate(const BzSpatialGridDesc *desc) {
+    i32 width = (desc->maxWidth + desc->cellWidth - 1) / desc->cellWidth;
+    i32 height = (desc->maxHeight + desc->cellHeight - 1) / desc->cellHeight;
+
+    size_t cellsNumBytes = width * height * sizeof(BzSpatialGridID *);
+    size_t numBytes = sizeof(BzSpatialGrid) + cellsNumBytes;
+    BzSpatialGrid *grid = bzAlloc(numBytes);
+
+    grid->width = width;
+    grid->height = height;
+    grid->cellWidth = desc->cellWidth;
+    grid->cellHeight = desc->cellHeight;
+    grid->userDataSize = desc->userDataSize;
+    grid->queryCount = 0;
+    grid->cells = (BzSpatialGridID **) (grid + 1);
+    for (i32 y = 0; y < grid->height; y++) {
+        for (i32 x = 0; x < grid->width; x++) {
+            BzSpatialGridID **cell = getCell(grid, x, y);
+            *cell = bzArrayCreate(BzSpatialGridID, 4);
+        }
+    }
+    grid->entriesPool = bzObjectPoolCreate(&(BzObjectPoolDesc) {
+        .objectSize=sizeof(BzSpatialGridEntry) + desc->userDataSize,
+        .numObjects=1024,
+    });
+    return grid;
+}
+
+void bzSpatialGridDestroy(BzSpatialGrid *grid) {
+    bzObjectPoolDestroy(grid->entriesPool);
+    grid->entriesPool = NULL;
+    for (i32 y = 0; y < grid->height; y++) {
+        for (i32 x = 0; x < grid->width; x++) {
+            BzSpatialGridID **cell = getCell(grid, x, y);
+            bzArrayDestroy(*cell);
+            *cell = NULL;
+        }
+    }
+
+    grid->cells = NULL;
+    bzFree(grid);
+}
+
+void *bzSpatialGridGetData(const BzSpatialGrid *grid, BzSpatialGridID id) {
+    return (u8 *)bzObjectPoolGetObject(grid->entriesPool, id) + sizeof(BzSpatialGridEntry);
+}
+
+
+static BzSpatialGridID **getCell(const BzSpatialGrid *grid, i32 x, i32 y) {
+    return grid->cells + y * grid->width + x;
+}
+
+static void insertCell(BzSpatialGrid *grid, BzSpatialGridID id, i32 x, i32 y) {
+    BzSpatialGridID **cell = getCell(grid, x, y);
+    bzArrayPush(*cell, id);
+}
+static void removeCell(BzSpatialGrid *grid, BzSpatialGridID id, i32 x, i32 y) {
+    BzSpatialGridID **cell = getCell(grid, x, y);
+    i32 i;
+    for (i = 0; i < bzArraySize(*cell); i++) {
+        if (i == (*cell)[i]) {
+            break;
+        }
+    }
+    if (i < bzArraySize(*cell)) {
+        BzSpatialGridID lastID = bzArrayPop(*cell);
+        (*cell)[id] = lastID;
+    }
+}
+
+static BzSpatialGridIndex calculateGridIndex(BzSpatialGrid *grid, f32 posX, f32 posY, f32 sizeX, f32 sizeY) {
+    i32 minX = (i32) floorf(posX);
+    i32 minY = (i32) floorf(posY);
+    i32 maxX = (i32) floorf(posX + sizeX);
+    i32 maxY = (i32) floorf(posY + sizeY);
+    return (BzSpatialGridIndex) {
+            (i16) (minX / grid->width),
+            (i16) (minY / grid->height),
+            (i16) (maxX / grid->width),
+            (i16) (maxY / grid->height),
+    };
+}
+
+BzSpatialGridID bzSpatialGridInsert(BzSpatialGrid *grid, void *data, f32 posX, f32 posY, f32 sizeX, f32 sizeY) {
+    BzSpatialGridEntry *entry = bzObjectPool(grid->entriesPool);
+    BZ_ASSERT(entry);
+
+    BzSpatialGridIndex index = calculateGridIndex(grid, posX, posY, sizeX, sizeY);
+
+    BzSpatialGridID id = bzObjectPoolGetIdx(grid->entriesPool, entry);
+
+    for (i32 y = index.minY; y <= index.maxY; y++) {
+        for (i32 x = index.minX; x <= index.maxX; x++) {
+            insertCell(grid, id, x, y);
+        }
+    }
+
+    entry->id = id;
+    entry->queryIdx = 0;
+    entry->index = index;
+    if (grid->userDataSize) {
+        bzMemCpy(entry + 1, data, grid->userDataSize);
+    }
+
+    return id;
+}
+BzSpatialGridID bzSpatialGridUpdate(BzSpatialGrid *grid, BzSpatialGridID id, f32 posX, f32 posY, f32 sizeX, f32 sizeY) {
+    BzSpatialGridEntry *entry = bzObjectPoolGetObject(grid->entriesPool, id);
+    BZ_ASSERT(entry && entry->id == id);
+
+    BzSpatialGridIndex index = calculateGridIndex(grid, posX, posY, sizeX, sizeY);
+    if (entry->index.minX == index.minX &&
+        entry->index.minY == index.minY &&
+        entry->index.maxX == index.maxX &&
+        entry->index.maxY == index.maxY)  {
+        return id;
+    }
+
+    return id;
+}
+void bzSpatialGridRemove(BzSpatialGrid *grid, BzSpatialGridID id) {
+    BzSpatialGridEntry *entry = bzObjectPoolGetObject(grid->entriesPool, id);
+    BZ_ASSERT(entry && entry->id == id);
+
+    BzSpatialGridIndex index = entry->index;
+    for (i32 y = index.minY; y <= index.maxY; y++) {
+        for (i32 x = index.minX; x <= index.maxX; x++) {
+            removeCell(grid, id, x, y);
+        }
+    }
+    bzObjectPoolRelease(grid->entriesPool, entry);
+}
+
+BzSpatialGridIter bzSpatialGridIter(BzSpatialGrid *grid, f32 posX, f32 posY, f32 sizeX, f32 sizeY) {
+    BzSpatialGridIndex index = calculateGridIndex(grid, posX, posY, sizeX, sizeY);
+    BzSpatialGridIter it = {
+            .index=index,
+            ._grid=grid,
+            ._queryIdx=grid->queryCount++,
+            ._x=index.minX,
+            ._y=index.minY,
+            ._cellIdx=0
+
+    };
+    return it;
+}
+bool bzSpatialGridQueryNext(BzSpatialGridIter *it) {
+    BzSpatialGridID **cell = getCell(it->_grid, it->_x, it->_y);
+    if (it->_cellIdx >= bzArraySize(*cell)) {
+        it->_cellIdx = 0;
+        it->_x++;
+        if (it->_x > it->index.maxX) {
+            if (it->_y > it->index.maxX) {
+                it->_y++;
+                if (it->_y > it->index.maxY)
+                    return false;
+            }
+        }
+    }
+
+    BzSpatialGridID id = bzArrayGet(*cell, it->_cellIdx);
+    BzSpatialGridEntry *entry = bzObjectPoolGetObject(it->_grid->entriesPool, id);
+    BZ_ASSERT(entry && id == entry->id);
+
+    it->entry = *entry;
+    it->data = (void *) (entry + 1);
+
+    it->_cellIdx++;
+    return true;
+}
+
+#include <raylib.h>
+#include <stdio.h>
+
+void bzSpatialGridDrawDebugGrid(const BzSpatialGrid *grid) {
+    // Draw lines
+    i32 posX = 0;
+    i32 posY = 0;
+    for (i32 x = 0; x <= grid->width; x++) {
+        DrawLine(posX, 0, posX, grid->height * grid->cellHeight, BLACK);
+        posX += grid->cellWidth;
+    }
+    for (i32 y = 0; y <= grid->height; y++) {
+        DrawLine(0, posY, grid->width * grid->cellWidth, posY, BLACK);
+        posY += grid->cellHeight;
+    }
+
+    posX = 0;
+    posY = 0;
+    for (i32 y = 0; y < grid->height; y++) {
+        for (i32 x = 0; x < grid->width; x++) {
+            BzSpatialGridID **cell = getCell(grid, x, y);
+            i32 numEntries = 0;
+            if (*cell) numEntries = bzArraySize(*cell);
+            char buf[8];
+            snprintf(buf, sizeof(buf), "%d", numEntries);
+            DrawText(buf, posX + 1, posY + 1, 6, WHITE);
+
+            posX += grid->cellWidth;
+        }
+        posX = 0;
+        posY += grid->cellHeight;
+    }
+
+}

engine/breeze/utils/spatial_grid.h

@@ -0,0 +1,56 @@
+#ifndef BREEZE_SPATIAL_GRID_H
+#define BREEZE_SPATIAL_GRID_H
+
+#include "../defines.h"
+
+typedef struct BzSpatialGridIndex {
+    i32 minX, minY;
+    i32 maxX, maxY;
+} BzSpatialGridIndex;
+
+typedef i32 BzSpatialGridID;
+
+typedef struct BzSpatialGridEntry {
+    i32 queryIdx;
+    BzSpatialGridID id;
+    BzSpatialGridIndex index;
+} BzSpatialGridEntry;
+
+typedef struct BzSpatialGrid BzSpatialGrid;
+
+typedef struct BzSpatialGridIter {
+    BzSpatialGridEntry entry;
+    void *data;
+    BzSpatialGridIndex index;
+
+    BzSpatialGrid *_grid;
+    i32 _queryIdx;
+
+    i32 _x;
+    i32 _y;
+    i32 _cellIdx;
+} BzSpatialGridIter;
+
+typedef struct BzSpatialGridDesc {
+    i32 maxWidth;
+    i32 maxHeight;
+    i32 cellWidth;
+    i32 cellHeight;
+    i32 userDataSize;
+} BzSpatialGridDesc;
+
+BzSpatialGrid *bzSpatialGridCreate(const BzSpatialGridDesc *desc);
+void bzSpatialGridDestroy(BzSpatialGrid *grid);
+
+//void *bzSpatialGridGetData(const BzSpatialGrid *grid, BzSpatialGridID id);
+
+BzSpatialGridID bzSpatialGridInsert(BzSpatialGrid *grid, void *data, f32 posX, f32 posY, f32 sizeX, f32 sizeY);
+BzSpatialGridID bzSpatialGridUpdate(BzSpatialGrid *grid, BzSpatialGridID id, f32 posX, f32 posY, f32 sizeX, f32 sizeY);
+void bzSpatialGridRemove(BzSpatialGrid *grid, BzSpatialGridID id);
+
+BzSpatialGridIter bzSpatialGridIter(BzSpatialGrid *grid, f32 posX, f32 posY, f32 sizeX, f32 sizeY);
+bool bzSpatialGridQueryNext(BzSpatialGridIter *it);
+
+void bzSpatialGridDrawDebugGrid(const BzSpatialGrid *grid);
+
+#endif //BREEZE_SPATIAL_GRID_H