1 files changed, 401 insertions, 160 deletions

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 <isogfx/isogfx.h>
 
+#include <filesystem.h>
 #include <mempool.h>
 
+#include <linux/limits.h>
+
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 /// 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;
-}