8 files changed, 113 insertions, 90 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e55aece..78aefa3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -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/checkerboard.c b/demos/checkerboard/checkerboard.c
index 0c8ff37..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>
 
@@ -81,12 +81,12 @@ static bool init(GfxApp* app, 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]);
diff --git a/demos/isomap/isomap.c b/demos/isomap/isomap.c
index 27c2bf3..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>
@@ -46,7 +46,7 @@ static bool init(GfxApp* app, GfxAppState* state, int argc, const char** argv) {
   }
   IsoGfx* iso = state->iso;
 
-  if (!isogfx_load_world(
+  if (!isogfx_load_map(
           iso, "/home/jeanne/Nextcloud/assets/tilemaps/scrabling1.tm")) {
     return false;
   }
@@ -59,7 +59,7 @@ static bool init(GfxApp* app, 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;
diff --git a/include/isogfx/asset.h b/include/isogfx/asset.h
index 6050500..361ffcd 100644
--- a/include/isogfx/asset.h
+++ b/include/isogfx/asset.h
@@ -43,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;
@@ -54,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;
 
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 9b9dc76..f21a2f9 100644
--- a/tools/mkasset.py
+++ b/tools/mkasset.py
@@ -13,6 +13,7 @@
 import argparse
 import ctypes
 import sys
+from enum import IntEnum
 from typing import Generator
 from xml.etree import ElementTree
 
@@ -23,6 +24,12 @@ 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('.')]
 
@@ -51,14 +58,9 @@ def carve_image(rgba_bytes, tile_width, tile_height, columns) -> Generator[bytea
     image_width = columns * tile_width
     image_height = len(rgba_bytes) // image_width // 4
 
-    tiles_x = image_width // tile_width
-    tiles_y = image_height // tile_height
-
     tile_bytes = bytearray(tile_width * tile_height * 4)
-    for i in range(tiles_y):
-        image_y0 = i * tile_height  # y-origin of tile inside image
-        for j in range(tiles_x):
-            image_x0 = j * tile_width  # x-origin of tile inside image
+    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):
@@ -183,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
 
@@ -210,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"])
@@ -349,25 +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]
-        # TODO: This palette list does not seem really necessary.
-        #  Define palette = bytearray(im.getpalette(...))
-        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))