10 files changed, 290 insertions, 168 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 72429c9..78aefa3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
 project(isogfx)
 
@@ -10,7 +10,7 @@ set(CMAKE_C_EXTENSIONS Off)
 
 add_library(isogfx
   src/asset.c
-  src/isogfx.c)
+  src/gfx2d.c)
 
 target_include_directories(isogfx PUBLIC
   include)
diff --git a/demos/checkerboard/CMakeLists.txt b/demos/checkerboard/CMakeLists.txt
index d1691c6..b4e3a2a 100644
--- a/demos/checkerboard/CMakeLists.txt
+++ b/demos/checkerboard/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
 project(checkerboard)
 
diff --git a/demos/checkerboard/checkerboard.c b/demos/checkerboard/checkerboard.c
index b408fc2..4f43526 100644
--- a/demos/checkerboard/checkerboard.c
+++ b/demos/checkerboard/checkerboard.c
@@ -1,5 +1,5 @@
 #include <isogfx/backend.h>
-#include <isogfx/isogfx.h>
+#include <isogfx/gfx2d.h>
 
 #include <gfx/app.h>
 
@@ -66,9 +66,9 @@ static void make_checkerboard(IsoGfx* iso, Tile black, Tile white) {
   }
 }
 
-static bool init(GfxAppState* state, int argc, const char** argv) {
+static bool init(GfxApp* app, GfxAppState* state, int argc, const char** argv) {
+  assert(app);
   assert(state);
-
   (void)argc;
   (void)argv;
 
@@ -81,12 +81,12 @@ static bool init(GfxAppState* state, int argc, const char** argv) {
   }
   IsoGfx* iso = state->iso;
 
-  isogfx_make_world(
-      iso, &(WorldDesc){.tile_width   = TILE_WIDTH,
-                        .tile_height  = TILE_HEIGHT,
-                        .world_width  = WORLD_WIDTH,
-                        .world_height = WORLD_HEIGHT,
-                        .num_tiles    = NUM_TILES});
+  isogfx_make_map(
+      iso, &(MapDesc){.tile_width   = TILE_WIDTH,
+                      .tile_height  = TILE_HEIGHT,
+                      .world_width  = WORLD_WIDTH,
+                      .world_height = WORLD_HEIGHT,
+                      .num_tiles    = NUM_TILES});
 
   const Tile black = isogfx_make_tile(iso, &tile_set[Black]);
   const Tile white = isogfx_make_tile(iso, &tile_set[White]);
@@ -100,14 +100,16 @@ static bool init(GfxAppState* state, int argc, const char** argv) {
   return true;
 }
 
-static void shutdown(GfxAppState* state) {
+static void shutdown(GfxApp* app, GfxAppState* state) {
+  assert(app);
   assert(state);
 
   iso_backend_shutdown(&state->backend);
   isogfx_del(&state->iso);
 }
 
-static void update(GfxAppState* state, double t, double dt) {
+static void update(GfxApp* app, GfxAppState* state, double t, double dt) {
+  assert(app);
   assert(state);
   (void)dt;
 
@@ -117,7 +119,7 @@ static void update(GfxAppState* state, double t, double dt) {
 
   // Get mouse position in window coordinates.
   double mouse_x, mouse_y;
-  gfx_app_get_mouse_position(&mouse_x, &mouse_y);
+  gfx_app_get_mouse_position(app, &mouse_x, &mouse_y);
 
   // Map from window coordinates to virtual screen coordinates.
   iso_backend_get_mouse_position(
@@ -128,7 +130,8 @@ static void update(GfxAppState* state, double t, double dt) {
   printf("Picked tile: (%d, %d)\n", state->xpick, state->ypick);
 }
 
-static void render(GfxAppState* state) {
+static void render(const GfxApp* app, GfxAppState* state) {
+  assert(app);
   assert(state);
 
   IsoGfx* iso = state->iso;
@@ -142,7 +145,8 @@ static void render(GfxAppState* state) {
   iso_backend_render(state->backend, iso);
 }
 
-static void resize(GfxAppState* state, int width, int height) {
+static void resize(GfxApp* app, GfxAppState* state, int width, int height) {
+  assert(app);
   assert(state);
 
   iso_backend_resize_window(state->backend, state->iso, width, height);
diff --git a/demos/isomap/CMakeLists.txt b/demos/isomap/CMakeLists.txt
index 2dbfd32..9467625 100644
--- a/demos/isomap/CMakeLists.txt
+++ b/demos/isomap/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
 project(isomap)
 
diff --git a/demos/isomap/isomap.c b/demos/isomap/isomap.c
index a940535..bca27f6 100644
--- a/demos/isomap/isomap.c
+++ b/demos/isomap/isomap.c
@@ -1,5 +1,5 @@
 #include <isogfx/backend.h>
-#include <isogfx/isogfx.h>
+#include <isogfx/gfx2d.h>
 
 #include <gfx/app.h>
 #include <math/vec2.h>
@@ -16,9 +16,9 @@ static const int MAX_FPS       = 60;
 static const int SCREEN_WIDTH  = 704;
 static const int SCREEN_HEIGHT = 480;
 
-static const R CAMERA_SPEED = 400;
+static const R CAMERA_SPEED = 800;
 
-#define MEMORY_SIZE (2 * 1024 * 1024)
+#define MEMORY_SIZE (8 * 1024 * 1024)
 uint8_t MEMORY[MEMORY_SIZE];
 
 typedef struct GfxAppState {
@@ -31,7 +31,8 @@ typedef struct GfxAppState {
   Sprite      stag;
 } GfxAppState;
 
-static bool init(GfxAppState* state, int argc, const char** argv) {
+static bool init(GfxApp* app, GfxAppState* state, int argc, const char** argv) {
+  assert(app);
   assert(state);
   (void)argc;
   (void)argv;
@@ -45,7 +46,8 @@ static bool init(GfxAppState* state, int argc, const char** argv) {
   }
   IsoGfx* iso = state->iso;
 
-  if (!isogfx_load_world(iso, "/home/jeanne/Nextcloud/assets/maps/demo-1.tm")) {
+  if (!isogfx_load_map(
+          iso, "/home/jeanne/Nextcloud/assets/tilemaps/scrabling1.tm")) {
     return false;
   }
 
@@ -57,7 +59,7 @@ static bool init(GfxAppState* state, int argc, const char** argv) {
   }
 
   state->stag = isogfx_make_sprite(iso, state->stag_sheet);
-  isogfx_set_sprite_position(iso, state->stag, 5, 4);
+  isogfx_set_sprite_position(iso, state->stag, 0, 0);
 
   if (!((state->backend = iso_backend_init(iso)))) {
     return false;
@@ -66,23 +68,25 @@ static bool init(GfxAppState* state, int argc, const char** argv) {
   return true;
 }
 
-static void shutdown(GfxAppState* state) {
+static void shutdown(GfxApp* app, GfxAppState* state) {
+  assert(app);
   assert(state);
-  //
 }
 
-static vec2 get_camera_movement(R dt) {
+static vec2 get_camera_movement(GfxApp* app, R dt) {
+  assert(app);
+
   vec2 offset = {0};
-  if (gfx_app_is_key_pressed(KeyA)) {
+  if (gfx_app_is_key_pressed(app, KeyA)) {
     offset.x -= 1;
   }
-  if (gfx_app_is_key_pressed(KeyD)) {
+  if (gfx_app_is_key_pressed(app, KeyD)) {
     offset.x += 1;
   }
-  if (gfx_app_is_key_pressed(KeyW)) {
+  if (gfx_app_is_key_pressed(app, KeyW)) {
     offset.y -= 1;
   }
-  if (gfx_app_is_key_pressed(KeyS)) {
+  if (gfx_app_is_key_pressed(app, KeyS)) {
     offset.y += 1;
   }
   if ((offset.x != 0) || (offset.y != 0)) {
@@ -91,17 +95,19 @@ static vec2 get_camera_movement(R dt) {
   return offset;
 }
 
-static void update(GfxAppState* state, double t, double dt) {
+static void update(GfxApp* app, GfxAppState* state, double t, double dt) {
+  assert(app);
   assert(state);
 
-  state->camera = vec2_add(state->camera, get_camera_movement((R)dt));
+  state->camera = vec2_add(state->camera, get_camera_movement(app, (R)dt));
 
   IsoGfx* iso = state->iso;
   isogfx_set_camera(iso, (int)state->camera.x, (int)state->camera.y);
   isogfx_update(iso, t);
 }
 
-static void render(GfxAppState* state) {
+static void render(const GfxApp* app, GfxAppState* state) {
+  assert(app);
   assert(state);
 
   IsoGfx* iso = state->iso;
@@ -109,7 +115,8 @@ static void render(GfxAppState* state) {
   iso_backend_render(state->backend, iso);
 }
 
-static void resize(GfxAppState* state, int width, int height) {
+static void resize(GfxApp* app, GfxAppState* state, int width, int height) {
+  assert(app);
   assert(state);
 
   iso_backend_resize_window(state->backend, state->iso, width, height);
diff --git a/include/isogfx/asset.h b/include/isogfx/asset.h
index 9aeb55d..361ffcd 100644
--- a/include/isogfx/asset.h
+++ b/include/isogfx/asset.h
@@ -25,8 +25,15 @@ typedef struct Ts_Tile {
   uint32_t pixels; // Byte offset into the Ts_TileSet's 'pixels'.
 } Ts_Tile;
 
+// Tileset.
+//
+// Tile dimensions may be larger than the baseline tile dimensions of the
+// tileset if the tileset contains supertiles. Regardless, tile dimensions are
+// always a multiple of baseline dimensions along each axis.
 typedef struct Ts_TileSet {
   uint16_t num_tiles;
+  uint16_t tile_width;  // Baseline tile width.
+  uint16_t tile_height; // Baseline tile height.
   uint16_t _pad;
   Ts_Tile  tiles[1]; // Count: num_tiles.
   Pixel    pixels[]; // Count: sum_i(tile[i].width * tile[i].height).
@@ -36,6 +43,16 @@ typedef struct Ts_TileSet {
 // Tile map (TM) file format.
 // -----------------------------------------------------------------------------
 
+typedef enum Tm_Orientation {
+  Tm_Orthogonal = 0,
+  Tm_Isometric  = 1,
+} Tm_Orientation;
+
+typedef struct Tm_Flags {
+  Tm_Orientation orientation : 1;
+  int            unused      : 15;
+} Tm_Flags;
+
 typedef struct Tm_Layer {
   Tile tiles[1]; // Count: world_width * world_height.
 } Tm_Layer;
@@ -47,6 +64,7 @@ typedef struct Tm_Map {
   uint16_t base_tile_width;
   uint16_t base_tile_height;
   uint16_t num_layers;
+  uint16_t flags;    // Tm_flagsFlags
   Tm_Layer layers[]; // Count: num_layers.
 } Tm_Map;
 
@@ -64,8 +82,8 @@ typedef struct Tm_Map {
 ///
 /// Pixels are 8-bit indices into the sprite sheet's colour palette.
 typedef struct Ss_Row {
-  uint16_t num_cols;  /// Number of columns in this row.
-  uint8_t  pixels[1]; /// Count: num_cols * sprite_width * sprite_height.
+  uint16_t num_cols;  // Number of columns in this row.
+  uint8_t  pixels[1]; // Count: num_cols * sprite_width * sprite_height.
 } Ss_Row;
 
 typedef struct Ss_Palette {
@@ -77,11 +95,11 @@ typedef struct Ss_Palette {
 ///
 /// Sprite width and height are assumed constant throughout the sprite sheet.
 typedef struct Ss_SpriteSheet {
-  uint16_t   sprite_width;  /// Sprite width in pixels.
-  uint16_t   sprite_height; /// Sprite height in pixels.
+  uint16_t   sprite_width;  // Sprite width in pixels.
+  uint16_t   sprite_height; // Sprite height in pixels.
   uint16_t   num_rows;
-  Ss_Palette palette; /// Variable size.
-  Ss_Row     rows[1]; /// Count: num_rows. Variable offset.
+  Ss_Palette palette; // Variable size.
+  Ss_Row     rows[1]; // Count: num_rows. Variable offset.
 } Ss_SpriteSheet;
 
 // -----------------------------------------------------------------------------
diff --git a/include/isogfx/isogfx.h b/include/isogfx/gfx2d.h
index e901231..323b389 100644
--- a/include/isogfx/isogfx.h
+++ b/include/isogfx/gfx2d.h
@@ -37,13 +37,13 @@ typedef struct TileDesc {
   };
 } TileDesc;
 
-typedef struct WorldDesc {
+typedef struct MapDesc {
   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 num_tiles;    // Number of tiles to allocate memory for.
-} WorldDesc;
+} MapDesc;
 
 typedef struct IsoGfxDesc {
   void*  memory;        // Block of memory for the engine to use.
@@ -61,11 +61,11 @@ void isogfx_del(IsoGfx**);
 /// Clear all loaded worlds and sprites.
 void isogfx_clear(IsoGfx*);
 
-/// Create an empty world.
-void isogfx_make_world(IsoGfx*, const WorldDesc*);
+/// Create an empty map.
+void isogfx_make_map(IsoGfx*, const MapDesc*);
 
-/// Load a world from a tile map (.TM) file.
-bool isogfx_load_world(IsoGfx*, const char* filepath);
+/// Load a tile map (.TM) file.
+bool isogfx_load_map(IsoGfx*, const char* filepath);
 
 /// Return the world's width.
 int isogfx_world_width(const IsoGfx*);
@@ -88,8 +88,10 @@ SpriteSheet isogfx_load_sprite_sheet(IsoGfx*, const char* filepath);
 /// Create an animated sprite.
 Sprite isogfx_make_sprite(IsoGfx*, SpriteSheet);
 
-/// Destroy all the sprites.
-void isogfx_del_sprites(IsoGfx*);
+// TODO: Add a function to delete a sprite. Making the caller manage and re-use
+//  sprites is a shitty API.
+//  Not that the stack allocator gets completely in the way; implement a free
+//  list of sprites so that we can re-use the ones that have been "freed".
 
 /// Set the sprite's position.
 void isogfx_set_sprite_position(IsoGfx*, Sprite, int x, int y);
@@ -99,9 +101,13 @@ void isogfx_set_sprite_animation(IsoGfx*, Sprite, int animation);
 
 /// Update the renderer.
 ///
-/// Currently this updates the sprite animations.
+/// Currently, this updates the sprite animations.
 void isogfx_update(IsoGfx*, double t);
 
+// TODO: Do we really need to store the camera in the library? It's not used
+//  for anything other than to render, so we could remove library state and
+//  take a camera argument in render() instead.
+
 /// Set the camera.
 void isogfx_set_camera(IsoGfx*, int x, int y);
 
diff --git a/src/backend.c b/src/backend.c
index 94f1728..80c5974 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -1,5 +1,5 @@
 #include <isogfx/backend.h>
-#include <isogfx/isogfx.h>
+#include <isogfx/gfx2d.h>
 
 #include <gfx/core.h>
 #include <gfx/gfx.h>
diff --git a/src/isogfx.c b/src/gfx2d.c
index c3a87bf..9767308 100644
--- a/src/isogfx.c
+++ b/src/gfx2d.c
@@ -1,4 +1,4 @@
-#include <isogfx/isogfx.h>
+#include <isogfx/gfx2d.h>
 
 #include <isogfx/asset.h>
 
@@ -79,17 +79,49 @@ static inline ivec2 ivec2_scale(ivec2 a, int s) {
 
 static inline ivec2 ivec2_neg(ivec2 a) { return (ivec2){.x = -a.x, .y = -a.y}; }
 
-static inline ivec2 iso2cart(ivec2 iso, int s, int t, int w) {
-  return (ivec2){.x = (iso.x - iso.y) * (s / 2) + (w / 2),
-                 .y = (iso.x + iso.y) * (t / 2)};
-}
-
 static inline vec2 vec2_add(vec2 a, vec2 b) {
   return (vec2){.x = a.x + b.x, .y = a.y + b.y};
 }
 
 static inline vec2 ivec2_to_vec2(ivec2 a) { return (vec2){a.x, a.y}; }
 
+// Not actually used because we pre-compute the two axis vectors instead.
+// See make_iso_coord_system() and the other definition of iso2cart() below.
+// static inline ivec2 iso2cart(ivec2 iso, int s, int t, int w) {
+//   return (ivec2){.x = (iso.x - iso.y) * (s / 2) + (w / 2),
+//                  .y = (iso.x + iso.y) * (t / 2)};
+// }
+
+/// Create the basis for the isometric coordinate system with origin and vectors
+/// expressed in the Cartesian system.
+static CoordSystem make_iso_coord_system(
+    const Tm_Map* const map, const Screen* const screen) {
+  assert(map);
+  assert(screen);
+  const ivec2 o = {screen->width / 2, 0};
+  const ivec2 x = {
+      .x = map->base_tile_width / 2, .y = map->base_tile_height / 2};
+  const ivec2 y = {
+      .x = -map->base_tile_width / 2, .y = map->base_tile_height / 2};
+  return (CoordSystem){o, x, y};
+}
+
+/// Map isometric coordinates to Cartesian coordinates.
+///
+/// For a tile, this gets the screen position of the top diamond-corner of the
+/// tile.
+///
+/// Takes the camera displacement into account.
+static ivec2 iso2cart(
+    const CoordSystem iso_space, ivec2 camera, int iso_x, int iso_y) {
+  const ivec2 vx_offset = ivec2_scale(iso_space.x, iso_x);
+  const ivec2 vy_offset = ivec2_scale(iso_space.y, iso_y);
+  const ivec2 screen_origin =
+      ivec2_add(iso_space.o, ivec2_add(vx_offset, vy_offset));
+  const ivec2 origin_view_space = ivec2_add(screen_origin, ivec2_neg(camera));
+  return origin_view_space;
+}
+
 // Method 1.
 // static inline vec2 cart2iso(vec2 cart, int s, int t, int w) {
 //  const double x    = cart.x - (double)(w / 2);
@@ -125,20 +157,6 @@ static inline Pixel* screen_xy_mut(Screen* screen, int x, int y) {
   return (Pixel*)screen_xy_const_ref(screen, x, y);
 }
 
-/// Create the basis for the isometric coordinate system with origin and vectors
-/// expressed in the Cartesian system.
-static CoordSystem make_iso_coord_system(
-    const Tm_Map* const map, const Screen* const screen) {
-  assert(map);
-  assert(screen);
-  const ivec2 o = {screen->width / 2, 0};
-  const ivec2 x = {
-      .x = map->base_tile_width / 2, .y = map->base_tile_height / 2};
-  const ivec2 y = {
-      .x = -map->base_tile_width / 2, .y = map->base_tile_height / 2};
-  return (CoordSystem){o, x, y};
-}
-
 // -----------------------------------------------------------------------------
 // Renderer, world and tile management.
 // -----------------------------------------------------------------------------
@@ -198,7 +216,7 @@ void isogfx_del(IsoGfx** ppIso) {
   }
 }
 
-void isogfx_make_world(IsoGfx* iso, const WorldDesc* desc) {
+void isogfx_make_map(IsoGfx* iso, const MapDesc* desc) {
   assert(iso);
   assert(desc);
   assert(desc->tile_width > 0);
@@ -246,7 +264,7 @@ void isogfx_make_world(IsoGfx* iso, const WorldDesc* desc) {
   iso->iso_space = make_iso_coord_system(iso->map, &iso->screen);
 }
 
-bool isogfx_load_world(IsoGfx* iso, const char* filepath) {
+bool isogfx_load_map(IsoGfx* iso, const char* filepath) {
   assert(iso);
   assert(filepath);
 
@@ -267,6 +285,8 @@ bool isogfx_load_world(IsoGfx* iso, const char* filepath) {
   }
   Tm_Map* const map = iso->map;
 
+  printf("Map orientation: %d\n", ((Tm_Flags*)&map->flags)->orientation);
+
   // Load the tile set.
   //
   // Tile set path is relative to the tile map file. Make it relative to the
@@ -496,18 +516,6 @@ void isogfx_update(IsoGfx* iso, double t) {
 // Rendering and picking.
 // -----------------------------------------------------------------------------
 
-/// Get the screen position of the top diamond-corner of the tile at world
-/// (x,y).
-static ivec2 GetTileScreenOrigin(
-    const CoordSystem iso_space, ivec2 camera, int world_x, int world_y) {
-  const ivec2 vx_offset = ivec2_scale(iso_space.x, world_x);
-  const ivec2 vy_offset = ivec2_scale(iso_space.y, world_y);
-  const ivec2 screen_origin =
-      ivec2_add(iso_space.o, ivec2_add(vx_offset, vy_offset));
-  const ivec2 origin_view_space = ivec2_add(screen_origin, ivec2_neg(camera));
-  return origin_view_space;
-}
-
 static Pixel alpha_blend(Pixel src, Pixel dst) {
   if ((src.a == 255) || (dst.a == 0)) {
     return src;
@@ -590,7 +598,7 @@ static void draw_tile(IsoGfx* iso, ivec2 screen_origin, Tile tile) {
       &iso->screen, top_left, pTile->width, pTile->height, pixels, nullptr);
 }
 
-static void draw_world(IsoGfx* iso) {
+static void draw_map(IsoGfx* iso) {
   assert(iso);
 
   const int W = iso->screen.width;
@@ -607,17 +615,15 @@ static void draw_world(IsoGfx* iso) {
   // screen-centric approach would juggle multiple tiles throughout the scan.
   for (int wy = 0; wy < iso->map->world_height; ++wy) {
     for (int wx = 0; wx < iso->map->world_width; ++wx) {
-      const Tile  tile = tm_layer_get_tile(iso->map, layer, wx, wy);
-      const ivec2 screen_origin =
-          GetTileScreenOrigin(iso->iso_space, iso->camera, wx, wy);
+      const Tile  tile          = tm_layer_get_tile(iso->map, layer, wx, wy);
+      const ivec2 screen_origin = iso2cart(iso->iso_space, iso->camera, wx, wy);
       draw_tile(iso, screen_origin, tile);
     }
   }
 }
 
 static void draw_sprite(
-    IsoGfx* iso, ivec2 origin, const SpriteInstance* sprite,
-    const Ss_SpriteSheet* sheet) {
+    IsoGfx* iso, const SpriteInstance* sprite, const Ss_SpriteSheet* sheet) {
   assert(iso);
   assert(sprite);
   assert(sheet);
@@ -625,10 +631,18 @@ static void draw_sprite(
   assert(sprite->animation < sheet->num_rows);
   assert(sprite->frame >= 0);
 
+  // Apply an offset similarly to how we offset tiles. The sprite is offset by
+  // -base_tile_width/2 along the x-axis to align the sprite with the leftmost
+  // edge of the tile it is on.
+  const ivec2 screen_origin = iso2cart(
+      iso->iso_space, iso->camera, sprite->position.x, sprite->position.y);
+  const ivec2 offset   = {-(iso->map->base_tile_width / 2), 0};
+  const ivec2 top_left = ivec2_add(screen_origin, offset);
+
   const Ss_Row*  row   = ss_get_sprite_sheet_row(sheet, sprite->animation);
   const uint8_t* frame = ss_get_sprite_sheet_sprite(sheet, row, sprite->frame);
   draw_rect(
-      &iso->screen, origin, sheet->sprite_width, sheet->sprite_height,
+      &iso->screen, top_left, sheet->sprite_width, sheet->sprite_height,
       sheet->palette.colours, frame);
 }
 
@@ -639,10 +653,7 @@ static void draw_sprites(IsoGfx* iso) {
        sprite                       = sprite->next) {
     const Ss_SpriteSheet* sheet = sprite->sheet;
     assert(sheet);
-
-    const ivec2 screen_origin = GetTileScreenOrigin(
-        iso->iso_space, iso->camera, sprite->position.x, sprite->position.y);
-    draw_sprite(iso, screen_origin, sprite, sheet);
+    draw_sprite(iso, sprite, sheet);
   }
 }
 
@@ -653,7 +664,7 @@ void isogfx_set_camera(IsoGfx* iso, int x, int y) {
 
 void isogfx_render(IsoGfx* iso) {
   assert(iso);
-  draw_world(iso);
+  draw_map(iso);
   draw_sprites(iso);
 }
 
@@ -664,8 +675,7 @@ void isogfx_draw_tile(IsoGfx* iso, int x, int y, Tile tile) {
   assert(x < iso->map->world_width);
   assert(y < iso->map->world_height);
 
-  const ivec2 screen_origin =
-      GetTileScreenOrigin(iso->iso_space, iso->camera, x, y);
+  const ivec2 screen_origin = iso2cart(iso->iso_space, iso->camera, x, y);
   draw_tile(iso, screen_origin, tile);
 }
 
diff --git a/tools/mkasset.py b/tools/mkasset.py
index ae27ead..f21a2f9 100644
--- a/tools/mkasset.py
+++ b/tools/mkasset.py
@@ -13,6 +13,8 @@
 import argparse
 import ctypes
 import sys
+from enum import IntEnum
+from typing import Generator
 from xml.etree import ElementTree
 
 from PIL import Image
@@ -22,11 +24,17 @@ from PIL import Image
 MAX_PATH_LENGTH = 128
 
 
+class Orientation(IntEnum):
+    """Map orientation. Must match Tm_Orientation in asset.h"""
+    Orthogonal = 0
+    Isometric = 1
+
+
 def drop_extension(filepath):
     return filepath[:filepath.rfind('.')]
 
 
-def to_char_array(string, length):
+def to_char_array(string, length) -> bytes:
     """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
@@ -38,58 +46,129 @@ def to_char_array(string, length):
     return chars + nulls
 
 
+def load_image(path) -> bytes:
+    """Load an image as an array of RGBA bytes."""
+    with Image.open(path) as im:
+        return im.convert('RGBA').tobytes()
+
+
+def carve_image(rgba_bytes, tile_width, tile_height, columns) -> Generator[bytearray]:
+    """Carve out individual tiles from a single-image tile set."""
+    # Image dimensions in pixels.
+    image_width = columns * tile_width
+    image_height = len(rgba_bytes) // image_width // 4
+
+    tile_bytes = bytearray(tile_width * tile_height * 4)
+    for image_y0 in range(0, image_height, tile_height):  # y-origin of tile inside image
+        for image_x0 in range(0, image_width, tile_width):  # x-origin of tile inside image
+            for y in range(tile_height):
+                image_y = image_y0 + y  # y of current pixel inside image
+                for x in range(tile_width):
+                    image_x = image_x0 + x  # x of current pixel inside image
+                    tile_bytes[(y * tile_width + x) * 4] = (
+                        rgba_bytes)[(image_y * image_width + image_x) * 4]
+            yield tile_bytes.copy()
+
+
 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()
+    tileset = xml.getroot()
+    assert (tileset.tag == "tileset")
 
-    tile_count = int(root.attrib["tilecount"])
-    max_tile_width = int(root.attrib["tilewidth"])
-    max_tile_height = int(root.attrib["tileheight"])
+    # Header.
+    tileset_tile_count = int(tileset.attrib["tilecount"])
+    tileset_tile_width = int(tileset.attrib["tilewidth"])
+    tileset_tile_height = int(tileset.attrib["tileheight"])
 
-    print(f"Tile count: {tile_count}")
-    print(f"Max width:  {max_tile_width}")
-    print(f"Max height: {max_tile_height}")
+    print(f"Tile count:  {tileset_tile_count}")
+    print(f"Tile width:  {tileset_tile_width}")
+    print(f"Tile height: {tileset_tile_height}")
 
     pixels = []  # List of byte arrays
     pixels_offset = 0
 
+    def output_tile(output, tile_width, tile_height, tile_image_bytes):
+        # Expecting RGBA pixels.
+        assert (len(tile_image_bytes) == (tile_width * tile_height * 4))
+
+        nonlocal pixels_offset
+        tile_pixels_offset = pixels_offset
+        pixels.append(tile_image_bytes)
+        pixels_offset += len(tile_image_bytes)
+
+        output.write(ctypes.c_uint16(tile_width))
+        output.write(ctypes.c_uint16(tile_height))
+        output.write(ctypes.c_uint32(tile_pixels_offset))
+
     with open(output_filepath, 'bw') as output:
         # Write the header.
-        output.write(ctypes.c_uint16(tile_count))
-        # output.write(ctypes.c_uint16(max_tile_width))
-        # output.write(ctypes.c_uint16(max_tile_height))
+        output.write(ctypes.c_uint16(tileset_tile_count))
+        output.write(ctypes.c_uint16(tileset_tile_width))
+        output.write(ctypes.c_uint16(tileset_tile_height))
         output.write(ctypes.c_uint16(0))  # Pad.
 
+        # A tileset made up of multiple images contains various 'tile' children,
+        # each with their own 'image':
+        #
+        #   <tile id="0">
+        #     <image width="32" height="32" source="separated images/tile_000.png"/>
+        #   </tile>
+        #   <tile id="1">
+        #     <image width="32" height="32" source="separated images/tile_001.png"/>
+        #   </tile>
+        #
+        # A tileset made up of a single image contains a single 'image' child:
+        #
+        #   <image source="tileset.png" width="416" height="368"/>
         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"]
-
-            assert (tile_width > 0)
-            assert (tile_height > 0)
-
-            tile_pixels_offset = pixels_offset
-            with Image.open(tile_path) as im:
-                bytes = im.convert('RGBA').tobytes()
-                pixels.append(bytes)
-                pixels_offset += len(bytes)
-
-            # Write the tile.
-            output.write(ctypes.c_uint16(tile_width))
-            output.write(ctypes.c_uint16(tile_height))
-            output.write(ctypes.c_uint32(tile_pixels_offset))
+        for child in tileset:
+            if child.tag == "image":
+                # This is a single-image tileset.
+                image = child
+                image_path = image.attrib["source"]
+                image_bytes = load_image(image_path)
+
+                # We expect the 'columns' attribute to be >0 for a single-image
+                # tile set.
+                columns = int(tileset.attrib["columns"])
+                assert (columns > 0)
+
+                # Tile dimensions are those given by the tileset's baseline width and height.
+                tile_width = tileset_tile_width
+                tile_height = tileset_tile_height
+
+                # Cut each of the WxH tiles, and store them in the output in "tile order".
+                for tile_bytes in carve_image(image_bytes, tile_width, tile_height, columns):
+                    output_tile(output, tile_width, tile_height, tile_bytes)
+
+                # Make sure not to process 'tile' elements, which may exist in
+                # a single-image tileset to define probabilities, for example.
+                break
+
+            elif child.tag == "tile":
+                # This is a tile image in a tileset made of a collection of images.
+                tile = child
+
+                # We assume that tiles are numbered 0..N-1. Assert this.
+                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"])
+                image_path = image.attrib["source"]
+
+                # Tile dimensions must be a multiple of the tileset's baseline
+                # tile width and height.
+                assert (tile_width > 0)
+                assert (tile_height > 0)
+                assert ((tile_width % tileset_tile_width) == 0)
+                assert ((tile_height % tileset_tile_height) == 0)
+
+                image_bytes = load_image(image_path)
+                output_tile(output, tile_width, tile_height, image_bytes)
 
         # Write the pixel data.
         for bytes in pixels:
@@ -106,11 +185,13 @@ def convert_tmx(input_filepath, output_filepath):
     base_tile_width = int(root.attrib["tilewidth"])
     base_tile_height = int(root.attrib["tileheight"])
     num_layers = 1
+    flags = Orientation.Isometric if (root.attrib["orientation"] == "isometric") else Orientation.Orthogonal
 
     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}")
+    print(f"Orientation: {flags}")
 
     tileset_path = None
 
@@ -133,6 +214,7 @@ def convert_tmx(input_filepath, output_filepath):
                 output.write(ctypes.c_uint16(base_tile_width))
                 output.write(ctypes.c_uint16(base_tile_height))
                 output.write(ctypes.c_uint16(num_layers))
+                output.write(ctypes.c_uint16(flags))
             elif child.tag == "layer":
                 layer = child
                 layer_id = int(layer.attrib["id"])
@@ -272,23 +354,16 @@ def convert_sprite_sheet(input_file_paths, sprite_width, sprite_height,
         # that. getcolors() returns the number of unique colors.
         # getpalette() also returns a flattened list, which is why we must *4.
         num_colours = len(im.getcolors())
-        colours = im.getpalette(rawmode="RGBA")[:4 * num_colours]
-        palette = []
-        for i in range(0, 4 * num_colours, 4):
-            palette.append((colours[i], colours[i + 1], colours[i + 2],
-                            colours[i + 3]))
+        palette = bytearray(im.getpalette(rawmode="RGBA")[:4 * num_colours])
+        assert (num_colours == (len(palette) // 4))
 
-        output.write(ctypes.c_uint16(len(palette)))
-        output.write(bytearray(colours))
+        output.write(ctypes.c_uint16(num_colours))
+        output.write(palette)
 
         print(f"Sprite width:  {sprite_width}")
         print(f"Sprite height: {sprite_height}")
         print(f"Rows:          {len(rows)}")
-        print(f"Colours:       {len(palette)}")
-
-        # print("Palette")
-        # for i, colour in enumerate(palette):
-        #     print(f"{i}: {colour}")
+        print(f"Colours:       {num_colours}")
 
         for row, num_columns in enumerate(rows):
             output.write(ctypes.c_uint16(num_columns))
@@ -310,36 +385,38 @@ def convert_sprite_sheet(input_file_paths, sprite_width, sprite_height,
 
 
 def main():
-    # TODO: Use subparser for each type of input file.
+    # TODO: Use a subparser for each type of input file for clarity of arguments.
     parser = argparse.ArgumentParser()
-    parser.add_argument("input",
-                        nargs="+",
-                        help="Input file (.tsx, .tmx) or path regex (sprite sheets)")
-    parser.add_argument("-W", "--width", type=int, help="Sprite width in pixels")
-    parser.add_argument("-H", "--height", type=int, help="Sprite height in pixels")
-    parser.add_argument("-o", "--out", help="Output file (sprite sheets)")
+    subparsers = parser.add_subparsers(dest="command")
+    # Tile sets.
+    tileset_parser = subparsers.add_parser("tileset")
+    tileset_parser.add_argument("input", help="Input file (.tsx)")
+    # Tile maps.
+    tilemap_parser = subparsers.add_parser("tilemap")
+    tilemap_parser.add_argument("input", help="Input file (.tmx)")
+    # Sprite sheet.
+    sprite_parser = subparsers.add_parser("sprite")
+    sprite_parser.add_argument("input", nargs="+", help="Input files")
+    sprite_parser.add_argument("-W", "--width", type=int, required=True, help="Sprite width in pixels")
+    sprite_parser.add_argument("-H", "--height", type=int, required=True, help="Sprite height in pixels")
+    sprite_parser.add_argument("-o", "--out", help="Output file")
     args = parser.parse_args()
 
-    # TODO: Add support for TSX files made from a single image. Currently, only collections are supported.
-    if ".tsx" in args.input[0]:
-        args.input = args.input[0]  # TODO: Remove this.
+    if args.command == "tileset":
+        print(f"Processing: {args.input}")
         output_filepath_no_ext = drop_extension(args.input)
         output_filepath = output_filepath_no_ext + ".ts"
         convert_tsx(args.input, output_filepath)
-    elif ".tmx" in args.input[0]:
-        args.input = args.input[0]  # TODO: Remove this.
+    elif args.command == "tilemap":
+        print(f"Processing: {args.input}")
         output_filepath_no_ext = drop_extension(args.input)
         output_filepath = output_filepath_no_ext + ".tm"
         convert_tmx(args.input, output_filepath)
-    else:
-        # Sprite sheets.
-        if not args.width or not args.height:
-            print("Sprite width and height must be given")
-            return 1
+    elif args.command == "sprite":
+        print(f"Processing: {args.input}")
         output_filepath = args.out if args.out else "out.ss"
         convert_sprite_sheet(args.input, args.width, args.height,
                              output_filepath)
-
     return 0