Load tile maps and tile sets from files.

10 files changed, 853 insertions, 233 deletions

diff --git a/gfx-iso/CMakeLists.txt b/gfx-iso/CMakeLists.txt
index 8f95f7f..b57a83f 100644
--- a/gfx-iso/CMakeLists.txt
+++ b/gfx-iso/CMakeLists.txt
@@ -13,18 +13,21 @@ target_include_directories(isogfx PUBLIC
   include)
 
 target_link_libraries(isogfx PRIVATE
+  filesystem
   mempool)
 
 target_compile_options(isogfx PRIVATE -Wall -Wextra -Wpedantic)
 
 # Demo
 
-project(isogfx-demo)
+project(isogfx-app)
 
-add_executable(isogfx-demo
-  demo/isogfx-demo.c)
+add_executable(isogfx-app
+  app/checkerboard.c
+  app/isogfx-demo.c
+  app/main.c)
 
-target_link_libraries(isogfx-demo PRIVATE
+target_link_libraries(isogfx-app PRIVATE
   gfx
   gfx-app
   isogfx)
diff --git a/gfx-iso/app/app.h b/gfx-iso/app/app.h
new file mode 100644
index 0000000..160da47
--- /dev/null
+++ b/gfx-iso/app/app.h
@@ -0,0 +1,11 @@
+#pragma once
+
+typedef struct IsoGfx    IsoGfx;
+typedef struct IsoGfxApp IsoGfxApp;
+
+typedef struct IsoGfxApp {
+  void* state;
+  void (*shutdown)(IsoGfx*, void* state);
+  void (*update)(IsoGfx*, void* state, double t, double dt);
+  void (*render)(IsoGfx*, void* state);
+} IsoGfxApp;
diff --git a/gfx-iso/app/checkerboard.c b/gfx-iso/app/checkerboard.c
new file mode 100644
index 0000000..8b394c4
--- /dev/null
+++ b/gfx-iso/app/checkerboard.c
@@ -0,0 +1,120 @@
+#include "isogfx-demo.h"
+
+#include <gfx/gfx_app.h>
+#include <isogfx/isogfx.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static const int TILE_WIDTH   = 64;
+static const int TILE_HEIGHT  = TILE_WIDTH / 2;
+static const int WORLD_WIDTH  = 20;
+static const int WORLD_HEIGHT = 20;
+
+static const TileDesc tile_set[] = {
+    {.type   = TileFromColour,
+     .width  = TILE_WIDTH,
+     .height = TILE_HEIGHT,
+     .colour = (Pixel){.r = 0x38, .g = 0x3b, .b = 0x46, .a = 0xff}},
+    {.type   = TileFromColour,
+     .width  = TILE_WIDTH,
+     .height = TILE_HEIGHT,
+     .colour = (Pixel){.r = 0xA5, .g = 0xb3, .b = 0xc0, .a = 0xff}},
+    {.type   = TileFromColour,
+     .width  = TILE_WIDTH,
+     .height = TILE_HEIGHT,
+     .colour = (Pixel){.r = 0xdc, .g = 0x76, .b = 0x84, .a = 0xff}},
+};
+
+typedef enum Colour {
+  Black,
+  White,
+  Red,
+} Colour;
+
+typedef struct State {
+  Tile red;
+  int  xpick;
+  int  ypick;
+} State;
+
+static void make_checkerboard(IsoGfx* iso, Tile black, Tile white) {
+  assert(iso);
+  for (int y = 0; y < isogfx_world_height(iso); ++y) {
+    for (int x = 0; x < isogfx_world_width(iso); ++x) {
+      const int  odd_col = x & 1;
+      const int  odd_row = y & 1;
+      const Tile value   = (odd_row ^ odd_col) == 0 ? black : white;
+      isogfx_set_tile(iso, x, y, value);
+    }
+  }
+}
+
+static void shutdown(IsoGfx* iso, void* app_state) {
+  assert(iso);
+  if (app_state) {
+    free(app_state);
+  }
+}
+
+static void update(IsoGfx* iso, void* app_state, double t, double dt) {
+  assert(iso);
+  assert(app_state);
+  State* state = (State*)(app_state);
+
+  double mouse_x, mouse_y;
+  gfx_app_get_mouse_position(&mouse_x, &mouse_y);
+
+  isogfx_pick_tile(iso, mouse_x, mouse_y, &state->xpick, &state->ypick);
+
+  printf("Picked tile: (%d, %d)\n", state->xpick, state->ypick);
+}
+
+static void render(IsoGfx* iso, void* app_state) {
+  assert(iso);
+  assert(app_state);
+  State* state = (State*)(app_state);
+
+  isogfx_render(iso);
+  if ((state->xpick != -1) && (state->ypick != -1)) {
+    isogfx_draw_tile(iso, state->xpick, state->ypick, state->red);
+  }
+}
+
+bool make_checkerboard_app(IsoGfx* iso, IsoGfxApp* app) {
+  assert(iso);
+  assert(app);
+
+  State* state = calloc(1, sizeof(State));
+  if (!state) {
+    return false;
+  }
+
+  if (!isogfx_make_world(
+          iso, &(WorldDesc){
+                   .tile_width   = TILE_WIDTH,
+                   .tile_height  = TILE_HEIGHT,
+                   .world_width  = WORLD_WIDTH,
+                   .world_height = WORLD_HEIGHT})) {
+    goto cleanup;
+  }
+
+  const Tile black = isogfx_make_tile(iso, &tile_set[Black]);
+  const Tile white = isogfx_make_tile(iso, &tile_set[White]);
+  state->red       = isogfx_make_tile(iso, &tile_set[Red]);
+  make_checkerboard(iso, black, white);
+  isogfx_render(iso);
+
+  app->state    = state;
+  app->shutdown = shutdown;
+  app->update   = update;
+  app->render   = render;
+
+  return true;
+
+cleanup:
+  free(state);
+  return false;
+}
diff --git a/gfx-iso/app/checkerboard.h b/gfx-iso/app/checkerboard.h
new file mode 100644
index 0000000..61725a5
--- /dev/null
+++ b/gfx-iso/app/checkerboard.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "app.h"
+
+#include <stdbool.h>
+
+typedef struct IsoGfxApp IsoGfxApp;
+
+bool make_checkerboard_app(IsoGfx*, IsoGfxApp*);
diff --git a/gfx-iso/app/isogfx-demo.c b/gfx-iso/app/isogfx-demo.c
new file mode 100644
index 0000000..15ab6be
--- /dev/null
+++ b/gfx-iso/app/isogfx-demo.c
@@ -0,0 +1,67 @@
+#include "isogfx-demo.h"
+
+#include <gfx/gfx_app.h>
+#include <isogfx/isogfx.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct State {
+  int xpick;
+  int ypick;
+} State;
+
+static void shutdown(IsoGfx* iso, void* app_state) {
+  assert(iso);
+  if (app_state) {
+    free(app_state);
+  }
+}
+
+static void update(IsoGfx* iso, void* app_state, double t, double dt) {
+  assert(iso);
+  assert(app_state);
+  State* state = (State*)(app_state);
+
+  double mouse_x, mouse_y;
+  gfx_app_get_mouse_position(&mouse_x, &mouse_y);
+
+  isogfx_pick_tile(iso, mouse_x, mouse_y, &state->xpick, &state->ypick);
+
+  // printf("Picked tile: (%d, %d)\n", state->xpick, state->ypick);
+}
+
+static void render(IsoGfx* iso, void* app_state) {
+  assert(iso);
+  assert(app_state);
+  State* state = (State*)(app_state);
+
+  isogfx_render(iso);
+}
+
+bool make_demo_app(IsoGfx* iso, IsoGfxApp* app) {
+  assert(iso);
+  assert(app);
+
+  State* state = calloc(1, sizeof(State));
+  if (!state) {
+    return false;
+  }
+
+  if (!isogfx_load_world(iso, "/home/jeanne/assets/tilemaps/demo1.tm")) {
+    goto cleanup;
+  }
+
+  app->state    = state;
+  app->shutdown = shutdown;
+  app->update   = update;
+  app->render   = render;
+
+  return true;
+
+cleanup:
+  free(state);
+  return false;
+}
diff --git a/gfx-iso/app/isogfx-demo.h b/gfx-iso/app/isogfx-demo.h
new file mode 100644
index 0000000..d099824
--- /dev/null
+++ b/gfx-iso/app/isogfx-demo.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "app.h"
+
+#include <stdbool.h>
+
+typedef struct IsoGfxApp IsoGfxApp;
+
+bool make_demo_app(IsoGfx*, IsoGfxApp*);
diff --git a/gfx-iso/demo/isogfx-demo.c b/gfx-iso/app/main.c
index d6c1ab0..fa5a76b 100644
--- a/gfx-iso/demo/isogfx-demo.c
+++ b/gfx-iso/app/main.c
@@ -1,3 +1,7 @@
+#include "app.h"
+#include "checkerboard.h"
+#include "isogfx-demo.h"
+
 #include <isogfx/isogfx.h>
 
 #include <gfx/gfx.h>
@@ -10,42 +14,19 @@
 
 #include <assert.h>
 #include <stdbool.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 static const int SCREEN_WIDTH  = 1408;
 static const int SCREEN_HEIGHT = 960;
-static const int TILE_WIDTH    = 64;
-static const int TILE_HEIGHT   = TILE_WIDTH / 2;
-static const int WORLD_WIDTH   = 20;
-static const int WORLD_HEIGHT  = 20;
-
-static const Pixel BLACK = (Pixel){.r = 0x38, .g = 0x3b, .b = 0x46};
-static const Pixel WHITE = (Pixel){.r = 0xA5, .g = 0xb3, .b = 0xc0};
-static const Pixel RED   = (Pixel){.r = 0xdc, .g = 0x76, .b = 0x84};
 
 typedef struct State {
-  Gfx*     gfx;
-  IsoGfx*  iso;
-  Tile     red;
-  int      xpick;
-  int      ypick;
-  Texture* screen_texture;
-  Scene*   scene;
+  Gfx*      gfx;
+  IsoGfx*   iso;
+  IsoGfxApp app;
+  Texture*  screen_texture;
+  Scene*    scene;
 } State;
 
-static void make_checkerboard(IsoGfx* iso, Tile black, Tile white) {
-  assert(iso);
-  for (int y = 0; y < isogfx_world_height(iso); ++y) {
-    for (int x = 0; x < isogfx_world_width(iso); ++x) {
-      const int  odd_col = x & 1;
-      const int  odd_row = y & 1;
-      const Tile value   = (odd_row ^ odd_col) == 0 ? black : white;
-      isogfx_set_tile(iso, x, y, value);
-    }
-  }
-}
-
 static bool init(const GfxAppDesc* desc, void** app_state) {
   State* state = calloc(1, sizeof(State));
   if (!state) {
@@ -53,12 +34,13 @@ static bool init(const GfxAppDesc* desc, void** app_state) {
   }
 
   if (!(state->iso = isogfx_new(&(IsoGfxDesc){
-            .screen_width  = SCREEN_WIDTH,
-            .screen_height = SCREEN_HEIGHT,
-            .tile_width    = TILE_WIDTH,
-            .tile_height   = TILE_HEIGHT,
-            .world_width   = WORLD_WIDTH,
-            .world_height  = WORLD_HEIGHT}))) {
+            .screen_width = SCREEN_WIDTH, .screen_height = SCREEN_HEIGHT}))) {
+    goto cleanup;
+  }
+  //  if (!make_checkerboard_app(state->iso, &state->app)) {
+  //    goto cleanup;
+  //  }
+  if (!make_demo_app(state->iso, &state->app)) {
     goto cleanup;
   }
   if (!(state->gfx = gfx_init())) {
@@ -71,7 +53,7 @@ static bool init(const GfxAppDesc* desc, void** app_state) {
                                 .width     = SCREEN_WIDTH,
                                 .height    = SCREEN_HEIGHT,
                                 .dimension = Texture2D,
-                                .format    = TextureRGB8,
+                                .format    = TextureSRGBA8,
                                 .filtering = NearestFiltering,
                                 .wrap      = ClampToEdge,
                                 .mipmaps   = false}))) {
@@ -116,15 +98,6 @@ static bool init(const GfxAppDesc* desc, void** app_state) {
   SceneNode* root = gfx_get_scene_root(state->scene);
   gfx_set_node_parent(node, root);
 
-  const Tile black = isogfx_make_tile(
-      state->iso, &(TileDesc){.type = TileFromColour, .colour = BLACK});
-  const Tile white = isogfx_make_tile(
-      state->iso, &(TileDesc){.type = TileFromColour, .colour = WHITE});
-  state->red = isogfx_make_tile(
-      state->iso, &(TileDesc){.type = TileFromColour, .colour = RED});
-  make_checkerboard(state->iso, black, white);
-  isogfx_render(state->iso);
-
   *app_state = state;
   return true;
 
@@ -139,6 +112,11 @@ cleanup:
 static void shutdown(void* app_state) {
   assert(app_state);
   State* state = (State*)(app_state);
+
+  if (state->app.state) {
+    assert(state->iso);
+    (*state->app.shutdown)(state->iso, state->app.state);
+  }
   isogfx_del(&state->iso);
   gfx_destroy(&state->gfx);
   free(app_state);
@@ -148,22 +126,16 @@ static void update(void* app_state, double t, double dt) {
   assert(app_state);
   State* state = (State*)(app_state);
 
-  double mouse_x, mouse_y;
-  gfx_app_get_mouse_position(&mouse_x, &mouse_y);
-
-  isogfx_pick_tile(state->iso, mouse_x, mouse_y, &state->xpick, &state->ypick);
-
-  printf("Picked tile: (%d, %d)\n", state->xpick, state->ypick);
+  assert(state->app.update);
+  (*state->app.update)(state->iso, state->app.state, t, dt);
 }
 
 static void render(void* app_state) {
   assert(app_state);
   State* state = (State*)(app_state);
 
-  isogfx_render(state->iso);
-  if ((state->xpick != -1) && (state->ypick != -1)) {
-    isogfx_draw_tile(state->iso, state->xpick, state->ypick, state->red);
-  }
+  assert(state->app.render);
+  (*state->app.render)(state->iso, state->app.state);
 
   const Pixel* screen = isogfx_get_screen_buffer(state->iso);
   assert(screen);
diff --git a/gfx-iso/asset/mkasset.py b/gfx-iso/asset/mkasset.py
new file mode 100644
index 0000000..15f7912
--- /dev/null
+++ b/gfx-iso/asset/mkasset.py
@@ -0,0 +1,155 @@
+# Converts tile sets and tile maps to binary formats (.TS, .TM) for the engine.
+#
+# Currently handles Tiled's .tsx and .tmx file formats.
+#
+# The output is a binary tile set file (.TS) or a binary tile map file (.TM).
+import argparse
+import ctypes
+from PIL import Image
+import sys
+from xml.etree import ElementTree
+
+# Maximum length of path strings in .TS and .TM files.
+MAX_PATH_LENGTH = 128
+
+
+def drop_extension(filepath):
+    return filepath[:filepath.rfind('.')]
+
+
+def to_char_array(string, length):
+    """Convert a string to a fixed-length ASCII char array.
+
+    The length of str must be at most length-1 so that the resulting string can
+    be null-terminated.
+    """
+    assert (len(string) < length)
+    chars = string.encode("ascii")
+    nulls = ("\0" * (length - len(string))).encode("ascii")
+    return chars + nulls
+
+
+def convert_tsx(input_filepath, output_filepath):
+    """Converts a Tiled .tsx tileset file to a .TS tile set file."""
+    xml = ElementTree.parse(input_filepath)
+    root = xml.getroot()
+
+    tile_count = int(root.attrib["tilecount"])
+    max_tile_width = int(root.attrib["tilewidth"])
+    max_tile_height = int(root.attrib["tileheight"])
+
+    print(f"Tile count: {tile_count}")
+    print(f"Max width:  {max_tile_width}")
+    print(f"Max height: {max_tile_height}")
+
+    with open(output_filepath, 'bw') as output:
+        output.write(ctypes.c_uint16(tile_count))
+        output.write(ctypes.c_uint16(max_tile_width))
+        output.write(ctypes.c_uint16(max_tile_height))
+
+        num_tile = 0
+        for tile in root:
+            # Skip the "grid" and other non-tile elements.
+            if not tile.tag == "tile":
+                continue
+
+            # Assuming tiles are numbered 0..N.
+            tile_id = int(tile.attrib["id"])
+            assert (tile_id == num_tile)
+            num_tile += 1
+
+            image = tile[0]
+            tile_width = int(image.attrib["width"])
+            tile_height = int(image.attrib["height"])
+            tile_path = image.attrib["source"]
+
+            output.write(ctypes.c_uint16(tile_width))
+            output.write(ctypes.c_uint16(tile_height))
+
+            with Image.open(tile_path) as im:
+                bytes = im.convert('RGBA').tobytes()
+                output.write(bytes)
+
+
+def convert_tmx(input_filepath, output_filepath):
+    """Converts a Tiled .tmx file to a .TM tile map file."""
+    xml = ElementTree.parse(input_filepath)
+    root = xml.getroot()
+
+    map_width = int(root.attrib["width"])
+    map_height = int(root.attrib["height"])
+    base_tile_width = int(root.attrib["tilewidth"])
+    base_tile_height = int(root.attrib["tileheight"])
+    num_layers = 1
+
+    print(f"Map width:   {map_width}")
+    print(f"Map height:  {map_height}")
+    print(f"Tile width:  {base_tile_width}")
+    print(f"Tile height: {base_tile_height}")
+
+    with open(output_filepath, 'bw') as output:
+        output.write(ctypes.c_uint16(map_width))
+        output.write(ctypes.c_uint16(map_height))
+        output.write(ctypes.c_uint16(base_tile_width))
+        output.write(ctypes.c_uint16(base_tile_height))
+        output.write(ctypes.c_uint16(num_layers))
+
+        tileset_path = None
+
+        for child in root:
+            if child.tag == "tileset":
+                tileset = child
+                tileset_path = tileset.attrib["source"]
+
+                print(f"Tile set: {tileset_path}")
+
+                tileset_path = tileset_path.replace("tsx", "ts")
+            elif child.tag == "layer":
+                layer = child
+                layer_id = int(layer.attrib["id"])
+                layer_width = int(layer.attrib["width"])
+                layer_height = int(layer.attrib["height"])
+
+                print(f"Layer:  {layer_id}")
+                print(f"Width:  {layer_width}")
+                print(f"Height: {layer_height}")
+
+                assert (tileset_path)
+                output.write(to_char_array(tileset_path, MAX_PATH_LENGTH))
+
+                # Assume the layer's dimensions matches the map's.
+                assert (layer_width == map_width)
+                assert (layer_height == map_height)
+
+                data = layer[0]
+                # Handle other encodings later.
+                assert (data.attrib["encoding"] == "csv")
+
+                csv = data.text.strip()
+                rows = csv.split('\n')
+                for row in rows:
+                    tile_ids = [x.strip() for x in row.split(',') if x]
+                    for tile_id in tile_ids:
+                        output.write(ctypes.c_uint16(int(tile_id)))
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", help="Input file (.tsx, .tmx)")
+    args = parser.parse_args()
+
+    output_filepath_no_ext = drop_extension(args.input)
+    if ".tsx" in args.input:
+        output_filepath = output_filepath_no_ext + ".ts"
+        convert_tsx(args.input, output_filepath)
+    elif ".tmx" in args.input:
+        output_filepath = output_filepath_no_ext + ".tm"
+        convert_tmx(args.input, output_filepath)
+    else:
+        print(f"Unhandled file format: {args.input}")
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/gfx-iso/include/isogfx/isogfx.h b/gfx-iso/include/isogfx/isogfx.h
index a5f7770..22c8fd5 100644
--- a/gfx-iso/include/isogfx/isogfx.h
+++ b/gfx-iso/include/isogfx/isogfx.h
@@ -3,64 +3,97 @@
  */
 #pragma once
 
+#include <stdbool.h>
 #include <stdint.h>
 
 typedef struct IsoGfx IsoGfx;
 
-typedef uint8_t Tile;
+/// Tile handle.
+typedef uint16_t Tile;
+
+/// Colour channel.
 typedef uint8_t Channel;
 
 typedef struct Pixel {
-  Channel r, g, b;
+  Channel r, g, b, a;
 } Pixel;
 
 typedef enum TileDescType {
   TileFromColour,
   TileFromFile,
-  TileFromMemory
+  TileFromMemory,
 } TileDescType;
 
 typedef struct TileDesc {
   TileDescType type;
+  int          width;  /// Tile width in pixels.
+  int          height; /// Tile height in pixels.
   union {
-    Pixel colour;
+    Pixel colour; /// Constant colour tile.
     struct {
       const char* path;
     } file;
     struct {
-      const void* data;
+      const uint8_t* data; /// sizeof(Pixel) * width * height
     } mem;
   };
 } TileDesc;
 
+typedef struct WorldDesc {
+  int tile_width;    /// Base tile width in pixels.
+  int tile_height;   /// Base tile height in pixels.
+  int world_width;   /// World width in tiles.
+  int world_height;  /// World height in tiles.
+  int max_num_tiles; /// 0 for an implementation-defined default.
+} WorldDesc;
+
 typedef struct IsoGfxDesc {
-  int screen_width;
-  int screen_height;
-  int tile_width;
-  int tile_height;
-  int world_width;
-  int world_height;
-  int max_num_tiles; // 0 for an implementation-defined default.
+  int screen_width;  /// Screen width in pixels.
+  int screen_height; /// Screen height in pixels.
 } IsoGfxDesc;
 
+/// Create a new isometric graphics engine.
 IsoGfx* isogfx_new(const IsoGfxDesc*);
 
+/// Destroy the isometric graphics engine.
 void isogfx_del(IsoGfx**);
 
+/// Create an empty world.
+bool isogfx_make_world(IsoGfx*, const WorldDesc*);
+
+/// Load a world from a tile map (.TM) file.
+bool isogfx_load_world(IsoGfx*, const char* filepath);
+
+/// Return the world's width.
+int isogfx_world_width(const IsoGfx*);
+
+/// Return the world's height.
+int isogfx_world_height(const IsoGfx*);
+
+/// Create a new tile.
 Tile isogfx_make_tile(IsoGfx*, const TileDesc*);
 
+/// Set the tile at position (x,y).
 void isogfx_set_tile(IsoGfx*, int x, int y, Tile);
 
+/// Set the tiles in positions in the range (x0,y0) - (x1,y1).
 void isogfx_set_tiles(IsoGfx*, int x0, int y0, int x1, int y1, Tile);
 
+/// Translate Cartesian to isometric coordinates.
 void isogfx_pick_tile(
     const IsoGfx*, double xcart, double ycart, int* xiso, int* yiso);
 
+/// Render the world.
 void isogfx_render(IsoGfx*);
 
+/// Draw/overlay a tile at position (x,y).
+///
+/// This function just renders a tile at position (x,y) and should be called
+/// after isogfx_render() to obtain the correct result. To set the tile at
+/// position (x,y) instead, use isogfx_set_tile().
 void isogfx_draw_tile(IsoGfx*, int x, int y, Tile);
 
+/// Return a pointer to the internal colour buffer.
+///
+/// Call after each call to isogfx_render() to retrieve the render output.
 const Pixel* isogfx_get_screen_buffer(const IsoGfx*);
-
-int isogfx_world_width(const IsoGfx*);
-int isogfx_world_height(const IsoGfx*);
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;
-}