From 21a0d0c1c424f7db90c3282aad4bf6ad4ef809b7 Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 8 Jul 2023 14:37:29 -0700 Subject: Load tile maps and tile sets from files. --- gfx-iso/src/isogfx.c | 561 ++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 401 insertions(+), 160 deletions(-) (limited to 'gfx-iso/src') diff --git a/gfx-iso/src/isogfx.c b/gfx-iso/src/isogfx.c index b38efe7..17b88b2 100644 --- a/gfx-iso/src/isogfx.c +++ b/gfx-iso/src/isogfx.c @@ -1,36 +1,106 @@ #include +#include #include +#include + #include #include #include +#include #include #include /// Maximum number of tiles unless the user chooses a non-zero value. #define DEFAULT_MAX_NUM_TILES 1024 +// ----------------------------------------------------------------------------- +// Tile set (TS) and tile map (TM) file formats. +// ----------------------------------------------------------------------------- + +/// Maximum length of path strings in .TS and .TM files. +#define MAX_PATH_LENGTH 128 + +typedef struct Ts_Tile { + uint16_t width; /// Tile width in pixels. + uint16_t height; /// Tile height in pixels. + Pixel pixels[1]; /// Count: width * height. +} Ts_Tile; + +typedef struct Ts_TileSet { + uint16_t num_tiles; + uint16_t max_tile_width; /// Maximum tile width in pixels. + uint16_t max_tile_height; /// Maximum tile height in pixels. + Ts_Tile tiles[1]; /// Count: num_tiles. +} Ts_TileSet; + +typedef struct Tm_Layer { + union { + char tileset_path[MAX_PATH_LENGTH]; // Relative to the Tm_Map file. + }; + Tile tiles[1]; /// Count: world_width * world_height. +} Tm_Layer; + +typedef struct Tm_Map { + uint16_t world_width; /// World width in number of tiles. + uint16_t world_height; /// World height in number of tiles. + uint16_t base_tile_width; + uint16_t base_tile_height; + uint16_t num_layers; + Tm_Layer layers[1]; // Count: num_layers. +} Tm_Map; + +static inline const Tm_Layer* tm_map_get_next_layer( + const Tm_Map* map, const Tm_Layer* layer) { + assert(map); + assert(layer); + return (const Tm_Layer*)((const uint8_t*)layer + sizeof(Tm_Layer) + + ((map->world_width * map->world_height - 1) * + sizeof(Tile))); +} + +static inline const Ts_Tile* ts_tileset_get_next_tile( + const Ts_TileSet* tileset, const Ts_Tile* tile) { + assert(tileset); + assert(tile); + return (const Ts_Tile*)((const uint8_t*)tile + sizeof(Ts_Tile) + + ((tile->width * tile->height - 1) * sizeof(Pixel))); +} + +// ----------------------------------------------------------------------------- +// Renderer state. +// ----------------------------------------------------------------------------- + +// typedef Ts_Tile TileData; + typedef struct TileData { - Pixel pixels[1]; // Dynamically allocated. + uint16_t width; + uint16_t height; + uint16_t num_blocks; // Number of pixel blocks in the pixels mempool. + uint16_t pixels_index; // Offset into the pixels mempool. } TileData; DEF_MEMPOOL_DYN(TilePool, TileData) +DEF_MEMPOOL_DYN(PixelPool, Pixel) typedef struct IsoGfx { - Tile* world; - Pixel* screen; - uint8_t* tile_mask; - TilePool tiles; - int screen_width; - int screen_height; - int tile_width; - int tile_height; - int world_width; - int world_height; - int max_num_tiles; + int screen_width; + int screen_height; + int tile_width; + int tile_height; + int world_width; + int world_height; + Tile* world; + Pixel* screen; + TilePool tiles; + PixelPool pixels; } IsoGfx; +// ----------------------------------------------------------------------------- +// Math and world / tile / screen access. +// ----------------------------------------------------------------------------- + typedef struct ivec2 { int x, y; } ivec2; @@ -70,38 +140,27 @@ static inline vec2 cart2iso(vec2 cart, int s, int t, int w) { .y = (-one_over_s * x + one_over_t * cart.y)}; } -Pixel* tile_xy_mut(const IsoGfx* iso, TileData* tile, int x, int y) { +static const Pixel* tile_xy_const_ref( + const IsoGfx* iso, const TileData* tile, int x, int y) { assert(iso); assert(tile); - assert(tile->pixels); assert(x >= 0); assert(y >= 0); - assert(x < iso->tile_width); - assert(y < iso->tile_height); - return &tile->pixels[y * iso->tile_width + x]; + assert(x < tile->width); + assert(y < tile->height); + return &mempool_get_block( + &iso->pixels, tile->pixels_index)[y * tile->width + x]; } -Pixel tile_xy(const IsoGfx* iso, const TileData* tile, int x, int y) { - assert(iso); - assert(tile); - assert(tile->pixels); - assert(x >= 0); - assert(y >= 0); - assert(x < iso->tile_width); - assert(y < iso->tile_height); - return tile->pixels[y * iso->tile_width + x]; +static Pixel tile_xy(const IsoGfx* iso, const TileData* tile, int x, int y) { + return *tile_xy_const_ref(iso, tile, x, y); } -static inline Tile world_xy(IsoGfx* iso, int x, int y) { - assert(iso); - assert(x >= 0); - assert(y >= 0); - assert(x < iso->world_width); - assert(y < iso->world_height); - return iso->world[y * iso->world_width + x]; +static Pixel* tile_xy_mut(const IsoGfx* iso, TileData* tile, int x, int y) { + return (Pixel*)tile_xy_const_ref(iso, tile, x, y); } -static inline Tile* world_xy_mut(IsoGfx* iso, int x, int y) { +static inline const Tile* world_xy_const_ref(const IsoGfx* iso, int x, int y) { assert(iso); assert(x >= 0); assert(y >= 0); @@ -110,16 +169,16 @@ static inline Tile* world_xy_mut(IsoGfx* iso, int x, int y) { return &iso->world[y * iso->world_width + x]; } -static inline Pixel screen_xy(IsoGfx* iso, int x, int y) { - assert(iso); - assert(x >= 0); - assert(y >= 0); - assert(x < iso->screen_width); - assert(y < iso->screen_height); - return iso->screen[y * iso->screen_width + x]; +static inline Tile world_xy(const IsoGfx* iso, int x, int y) { + return *world_xy_const_ref(iso, x, y); } -static inline Pixel* screen_xy_mut(IsoGfx* iso, int x, int y) { +static inline Tile* world_xy_mut(IsoGfx* iso, int x, int y) { + return (Tile*)world_xy_const_ref(iso, x, y); +} + +static inline const Pixel* screen_xy_const_ref( + const IsoGfx* iso, int x, int y) { assert(iso); assert(x >= 0); assert(y >= 0); @@ -128,169 +187,279 @@ static inline Pixel* screen_xy_mut(IsoGfx* iso, int x, int y) { return &iso->screen[y * iso->screen_width + x]; } -static void draw_tile(IsoGfx* iso, ivec2 origin, Tile tile) { - assert(iso); - - const TileData* data = mempool_get_block(&iso->tiles, tile); - assert(data); - - for (int py = 0; py < iso->tile_height; ++py) { - for (int px = 0; px < iso->tile_width; ++px) { - const Pixel colour = tile_xy(iso, data, px, py); - const int sx = origin.x + px; - const int sy = origin.y + py; - if ((sx >= 0) && (sy >= 0) && (sx < iso->screen_width) && - (sy < iso->screen_height)) { - const uint8_t mask = iso->tile_mask[py * iso->tile_width + px]; - if (mask == 1) { - *screen_xy_mut(iso, sx, sy) = colour; - } - } - } - } +static inline Pixel screen_xy(IsoGfx* iso, int x, int y) { + return *screen_xy_const_ref(iso, x, y); } -static void draw(IsoGfx* iso) { - assert(iso); - - const int W = iso->screen_width; - const int H = iso->screen_height; +static inline Pixel* screen_xy_mut(IsoGfx* iso, int x, int y) { + return (Pixel*)screen_xy_const_ref(iso, x, y); +} - memset(iso->screen, 0, W * H * sizeof(Pixel)); +// ----------------------------------------------------------------------------- +// Renderer, world and tile management. +// ----------------------------------------------------------------------------- - const ivec2 o = {(iso->screen_width / 2) - (iso->tile_width / 2), 0}; - const ivec2 x = {.x = iso->tile_width / 2, .y = iso->tile_height / 2}; - const ivec2 y = {.x = -iso->tile_width / 2, .y = iso->tile_height / 2}; +IsoGfx* isogfx_new(const IsoGfxDesc* desc) { + assert(desc->screen_width > 0); + assert(desc->screen_height > 0); + // Part of our implementation assumes even widths and heights for precision. + assert((desc->screen_width & 1) == 0); + assert((desc->screen_height & 1) == 0); - // TODO: Culling. - // Ex: map the screen corners to tile space to cull. - // Ex: walk in screen space and fetch the tile. - // The tile-centric approach might be more cache-friendly, however, since the - // screen-centric approach would juggle multiple tiles throughout the scan. - for (int ty = 0; ty < iso->world_height; ++ty) { - for (int tx = 0; tx < iso->world_width; ++tx) { - const Tile tile = world_xy(iso, tx, ty); - const ivec2 so = - ivec2_add(o, ivec2_add(ivec2_scale(x, tx), ivec2_scale(y, ty))); - draw_tile(iso, so, tile); - } + IsoGfx* iso = calloc(1, sizeof(IsoGfx)); + if (!iso) { + return 0; } -} - -/// Creates a tile mask procedurally. -static void make_tile_mask(IsoGfx* iso) { - assert(iso); - assert(iso->tile_mask); - for (int y = 0; y < iso->tile_height / 2; ++y) { - const int mask_start = iso->tile_width / 2 - 2 * y - 1; - const int mask_end = iso->tile_width / 2 + 2 * y + 1; - for (int x = 0; x < iso->tile_width; ++x) { - const bool masked = (mask_start <= x) && (x <= mask_end); - const uint8_t val = masked ? 1 : 0; + iso->screen_width = desc->screen_width; + iso->screen_height = desc->screen_height; - // Top half. - iso->tile_mask[y * iso->tile_width + x] = val; + const int screen_size = desc->screen_width * desc->screen_height; - // Bottom half reflects the top half. - const int y_reflected = iso->tile_height - y - 1; - iso->tile_mask[y_reflected * iso->tile_width + x] = val; - } + if (!(iso->screen = calloc(screen_size, sizeof(Pixel)))) { + goto cleanup; } + + return iso; + +cleanup: + isogfx_del(&iso); + return 0; } -/// Creates a tile with a constant colour. -static void make_tile_from_colour( - const IsoGfx* iso, Pixel colour, TileData* tile) { +/// Destroy the world and its tile set. +static void destroy_world(IsoGfx* iso) { assert(iso); - assert(tile); + if (iso->world) { + free(iso->world); + iso->world = 0; + } + mempool_del(&iso->tiles); + mempool_del(&iso->pixels); +} - for (int y = 0; y < iso->tile_height; ++y) { - for (int x = 0; x < iso->tile_width; ++x) { - *tile_xy_mut(iso, tile, x, y) = colour; +void isogfx_del(IsoGfx** pIso) { + assert(pIso); + IsoGfx* iso = *pIso; + if (iso) { + destroy_world(iso); + if (iso->screen) { + free(iso->screen); + iso->screen = 0; } + free(iso); + *pIso = 0; } } -IsoGfx* isogfx_new(const IsoGfxDesc* desc) { - assert(desc->screen_width > 0); - assert(desc->screen_height > 0); +bool isogfx_make_world(IsoGfx* iso, const WorldDesc* desc) { + assert(iso); + assert(desc); assert(desc->tile_width > 0); assert(desc->tile_height > 0); // Part of our implementation assumes even widths and heights for greater // precision. - assert((desc->screen_width & 1) == 0); - assert((desc->screen_height & 1) == 0); assert((desc->tile_width & 1) == 0); assert((desc->tile_height & 1) == 0); - IsoGfx* iso = calloc(1, sizeof(IsoGfx)); - if (!iso) { - return 0; - } - - iso->screen_width = desc->screen_width; - iso->screen_height = desc->screen_height; - iso->tile_width = desc->tile_width; - iso->tile_height = desc->tile_height; - iso->world_width = desc->world_width; - iso->world_height = desc->world_height; - iso->max_num_tiles = - desc->max_num_tiles > 0 ? desc->max_num_tiles : DEFAULT_MAX_NUM_TILES; + // Handle recreation by destroying the previous world. + destroy_world(iso); - const int world_size = desc->world_width * desc->world_height; - const int screen_size = desc->screen_width * desc->screen_height; - const int tile_size = desc->tile_width * desc->tile_height; + iso->tile_width = desc->tile_width; + iso->tile_height = desc->tile_height; + iso->world_width = desc->world_width; + iso->world_height = desc->world_height; + const int world_size = desc->world_width * desc->world_height; + const int tile_size = desc->tile_width * desc->tile_height; const int tile_size_bytes = tile_size * (int)sizeof(Pixel); + const int tile_pool_size = + desc->max_num_tiles > 0 ? desc->max_num_tiles : DEFAULT_MAX_NUM_TILES; if (!(iso->world = calloc(world_size, sizeof(Tile)))) { goto cleanup; } - if (!(iso->screen = calloc(screen_size, sizeof(Pixel)))) { + if (!mempool_make_dyn(&iso->tiles, tile_pool_size, tile_size_bytes)) { + goto cleanup; + } + + return true; + +cleanup: + destroy_world(iso); + mempool_del(&iso->tiles); + return false; +} + +bool isogfx_load_world(IsoGfx* iso, const char* filepath) { + assert(iso); + assert(filepath); + + bool success = false; + + // Handle recreation by destroying the previous world. + destroy_world(iso); + + // Load the map. + printf("Load tile map: %s\n", filepath); + Tm_Map* map = read_file(filepath); + if (!map) { goto cleanup; } - if (!(iso->tile_mask = calloc(tile_size, sizeof(uint8_t)))) { + + // Allocate memory for the map and tile sets. + const int world_size = map->world_width * map->world_height; + const int base_tile_size = map->base_tile_width * map->base_tile_height; + const int base_tile_size_bytes = base_tile_size * (int)sizeof(Pixel); + // TODO: Need to get the total number of tiles from the map. + const int tile_pool_size = DEFAULT_MAX_NUM_TILES; + + if (!(iso->world = calloc(world_size, sizeof(Tile)))) { goto cleanup; } - if (!mempool_make_dyn(&iso->tiles, iso->max_num_tiles, tile_size_bytes)) { + if (!mempool_make_dyn(&iso->tiles, tile_pool_size, sizeof(TileData))) { + goto cleanup; + } + if (!mempool_make_dyn(&iso->pixels, tile_pool_size, base_tile_size_bytes)) { goto cleanup; } - make_tile_mask(iso); + // Load the tile sets. + const Tm_Layer* layer = &map->layers[0]; + // TODO: Handle num_layers layers. + for (int i = 0; i < 1; ++i) { + const char* ts_path = layer->tileset_path; + + // Tile set path is relative to the tile map file. Make it relative to the + // current working directory before loading. + char ts_path_cwd[PATH_MAX] = {0}; + if (!make_relative_path(MAX_PATH_LENGTH, filepath, ts_path, ts_path_cwd)) { + goto cleanup; + } - return iso; + Ts_TileSet* tileset = read_file(ts_path_cwd); + if (!tileset) { + goto cleanup; + }; + + // Load tile data. + const Ts_Tile* tile = &tileset->tiles[0]; + for (uint16_t j = 0; j < tileset->num_tiles; ++j) { + // Tile dimensions should be a multiple of the base tile size. + assert((tile->width % map->base_tile_width) == 0); + assert((tile->height % map->base_tile_height) == 0); + + const uint16_t tile_size = tile->width * tile->height; + + // TODO: Add function in mempool to alloc N consecutive blocks. + const int num_blocks = tile_size / base_tile_size; + Pixel* pixels = mempool_alloc(&iso->pixels); + assert(pixels); + // This is ugly and assumes that blocks are allocated consecutively. + for (int b = 1; b < num_blocks; ++b) { + Pixel* block = mempool_alloc(&iso->pixels); + assert(block); + } + memcpy(pixels, tile->pixels, tile_size * sizeof(Pixel)); -cleanup: - isogfx_del(&iso); - return 0; -} + TileData* tile_data = mempool_alloc(&iso->tiles); + assert(tile_data); + tile_data->width = tile->width; + tile_data->height = tile->height; + tile_data->num_blocks = (uint16_t)num_blocks; + tile_data->pixels_index = + (uint16_t)mempool_get_block_index(&iso->pixels, pixels); -void isogfx_del(IsoGfx** pIso) { - assert(pIso); - IsoGfx* iso = *pIso; - if (iso) { - if (iso->world) { - free(iso->world); + tile = ts_tileset_get_next_tile(tileset, tile); } - if (iso->screen) { - free(iso->screen); + + printf("Loaded tile set (%u tiles): %s\n", tileset->num_tiles, ts_path_cwd); + + free(tileset); + layer = tm_map_get_next_layer(map, layer); + } + + // Load the map into the world. + layer = &map->layers[0]; + // TODO: Handle num_layers layers. + for (int i = 0; i < 1; ++i) { + memcpy(iso->world, layer->tiles, world_size * sizeof(Tile)); + + // TODO: We need to handle 'firsgid' in TMX files. + for (int j = 0; j < world_size; ++j) { + iso->world[j] -= 1; } - if (iso->tile_mask) { - free(iso->tile_mask); + + layer = tm_map_get_next_layer(map, layer); + } + + iso->world_width = map->world_width; + iso->world_height = map->world_height; + iso->tile_width = map->base_tile_width; + iso->tile_height = map->base_tile_height; + + success = true; + +cleanup: + if (map) { + free(map); + } + if (!success) { + destroy_world(iso); + } + return success; +} + +int isogfx_world_width(const IsoGfx* iso) { + assert(iso); + return iso->world_width; +} + +int isogfx_world_height(const IsoGfx* iso) { + assert(iso); + return iso->world_height; +} + +/// Create a tile mask procedurally. +static void make_tile_from_colour( + const IsoGfx* iso, Pixel colour, TileData* tile) { + assert(iso); + assert(tile); + + const int width = tile->width; + const int height = tile->height; + const int r = width / height; + + for (int y = 0; y < height / 2; ++y) { + const int mask_start = width / 2 - r * y - 1; + const int mask_end = width / 2 + r * y + 1; + for (int x = 0; x < width; ++x) { + const bool mask = (mask_start <= x) && (x <= mask_end); + const Pixel val = mask ? colour : (Pixel){.r = 0, .g = 0, .b = 0, .a = 0}; + + // Top half. + *tile_xy_mut(iso, tile, x, y) = val; + + // Bottom half reflects the top half. + const int y_reflected = height - y - 1; + *tile_xy_mut(iso, tile, x, y_reflected) = val; } - mempool_del(&iso->tiles); - free(iso); } } Tile isogfx_make_tile(IsoGfx* iso, const TileDesc* desc) { assert(iso); assert(desc); + // Client must create world before creating tiles. + assert(iso->tile_width > 0); + assert(iso->tile_height > 0); TileData* tile = mempool_alloc(&iso->tiles); assert(tile); // TODO: Make this a hard assert. + tile->width = desc->width; + tile->height = desc->height; + switch (desc->type) { case TileFromColour: make_tile_from_colour(iso, desc->colour, tile); @@ -311,6 +480,88 @@ void isogfx_set_tile(IsoGfx* iso, int x, int y, Tile tile) { *world_xy_mut(iso, x, y) = tile; } +void isogfx_set_tiles(IsoGfx* iso, int x0, int y0, int x1, int y1, Tile tile) { + assert(iso); + for (int y = y0; y < y1; ++y) { + for (int x = x0; x < x1; ++x) { + isogfx_set_tile(iso, x, y, tile); + } + } +} + +// ----------------------------------------------------------------------------- +// Rendering and picking. +// ----------------------------------------------------------------------------- + +static void draw_tile(IsoGfx* iso, ivec2 origin, Tile tile) { + assert(iso); + + const TileData* tile_data = mempool_get_block(&iso->tiles, tile); + assert(tile_data); + + // Tile can exceed screen bounds, so we must clip it. +#define max(a, b) (a > b ? a : b) + const int py_offset = max(0, (int)tile_data->height - origin.y); + origin.y = max(0, origin.y - (int)tile_data->height); + + // Clip along Y and X as we draw. + for (int py = py_offset; + (py < tile_data->height) && (origin.y + py < iso->screen_height); ++py) { + const int sy = origin.y + py - py_offset; + for (int px = 0; + (px < tile_data->width) && (origin.x + px < iso->screen_width); ++px) { + const Pixel colour = tile_xy(iso, tile_data, px, py); + if (colour.a > 0) { + const int sx = origin.x + px; + *screen_xy_mut(iso, sx, sy) = colour; + } + } + } + + // for (int py = 0; py < tile_data->height; ++py) { + // for (int px = 0; px < tile_data->width; ++px) { + // const Pixel colour = tile_xy(iso, tile_data, px, py); + // if (colour.a > 0) { + // const int sx = origin.x + px; + // const int sy = origin.y + py; + // if ((sx >= 0) && (sy >= 0) && (sx < iso->screen_width) && + // (sy < iso->screen_height)) { + // *screen_xy_mut(iso, sx, sy) = colour; + // } + // } + // } + // } +} + +static void draw(IsoGfx* iso) { + assert(iso); + + const int W = iso->screen_width; + const int H = iso->screen_height; + + memset(iso->screen, 0, W * H * sizeof(Pixel)); + + // const ivec2 o = {(iso->screen_width / 2) - (iso->tile_width / 2), 0}; + const ivec2 o = { + (iso->screen_width / 2) - (iso->tile_width / 2), iso->tile_height}; + const ivec2 x = {.x = iso->tile_width / 2, .y = iso->tile_height / 2}; + const ivec2 y = {.x = -iso->tile_width / 2, .y = iso->tile_height / 2}; + + // TODO: Culling. + // Ex: map the screen corners to tile space to cull. + // Ex: walk in screen space and fetch the tile. + // The tile-centric approach might be more cache-friendly since the + // screen-centric approach would juggle multiple tiles throughout the scan. + for (int ty = 0; ty < iso->world_height; ++ty) { + for (int tx = 0; tx < iso->world_width; ++tx) { + const Tile tile = world_xy(iso, tx, ty); + const ivec2 so = + ivec2_add(o, ivec2_add(ivec2_scale(x, tx), ivec2_scale(y, ty))); + draw_tile(iso, so, tile); + } + } +} + void isogfx_pick_tile( const IsoGfx* iso, double xcart, double ycart, int* xiso, int* yiso) { assert(iso); @@ -356,13 +607,3 @@ const Pixel* isogfx_get_screen_buffer(const IsoGfx* iso) { assert(iso); return iso->screen; } - -int isogfx_world_width(const IsoGfx* iso) { - assert(iso); - return iso->world_width; -} - -int isogfx_world_height(const IsoGfx* iso) { - assert(iso); - return iso->world_height; -} -- cgit v1.2.3