5 files changed, 119 insertions, 52 deletions

diff --git a/demos/checkerboard/checkerboard.c b/demos/checkerboard/checkerboard.c
index 467da61..f9631d8 100644
--- a/demos/checkerboard/checkerboard.c
+++ b/demos/checkerboard/checkerboard.c
@@ -86,7 +86,8 @@ static bool init(GfxApp* app, GfxAppState* state, int argc, const char** argv) {
                       .tile_height  = TILE_HEIGHT,
                       .world_width  = WORLD_WIDTH,
                       .world_height = WORLD_HEIGHT,
-                      .num_tiles    = NUM_TILES});
+                      .num_tiles    = NUM_TILES,
+                      .orientation  = MapIsometric});
 
   const Tile black = gfx2d_make_tile(iso, &tile_set[Black]);
   const Tile white = gfx2d_make_tile(iso, &tile_set[White]);
@@ -136,7 +137,7 @@ static void render(const GfxApp* app, GfxAppState* state) {
 
   Gfx2d* iso = state->gfx;
 
-  gfx2d_render(iso);
+  gfx2d_render(iso, 0, 0);
 
   if ((state->xpick != -1) && (state->ypick != -1)) {
     gfx2d_draw_tile(iso, state->xpick, state->ypick, state->red);
diff --git a/demos/isomap/isomap.c b/demos/isomap/isomap.c
index 471ef57..e66d14d 100644
--- a/demos/isomap/isomap.c
+++ b/demos/isomap/isomap.c
@@ -47,7 +47,7 @@ static bool init(GfxApp* app, GfxAppState* state, int argc, const char** argv) {
   Gfx2d* iso = state->gfx;
 
   if (!gfx2d_load_map(
-          iso, "/home/jeanne/Nextcloud/assets/tilemaps/scrabling1.tm")) {
+          iso, "/home/jeanne/Nextcloud/assets/tilemaps/desert1.tm")) {
     return false;
   }
 
@@ -100,9 +100,9 @@ static void update(GfxApp* app, GfxAppState* state, double t, double dt) {
   assert(state);
 
   state->camera = vec2_add(state->camera, get_camera_movement(app, (R)dt));
+  gfx2d_clip_camera(state->gfx, &state->camera.x, &state->camera.y);
 
   Gfx2d* iso = state->gfx;
-  gfx2d_set_camera(iso, (int)state->camera.x, (int)state->camera.y);
   gfx2d_update(iso, t);
 }
 
@@ -111,7 +111,7 @@ static void render(const GfxApp* app, GfxAppState* state) {
   assert(state);
 
   Gfx2d* iso = state->gfx;
-  gfx2d_render(iso);
+  gfx2d_render(iso, (int)state->camera.x, (int)state->camera.y);
   gfx2d_backend_render(state->backend, iso);
 }
 
diff --git a/include/isogfx/asset.h b/include/isogfx/asset.h
index 361ffcd..74063a8 100644
--- a/include/isogfx/asset.h
+++ b/include/isogfx/asset.h
@@ -10,6 +10,7 @@
 #include <isogfx/types.h>
 
 #include <assert.h>
+#include <stddef.h>
 #include <stdint.h>
 
 // Maximum length of path strings in .TS and .TM files.
@@ -154,7 +155,7 @@ static inline const Pixel* ts_tile_get_pixels(
 }
 
 /// Return the tile's pixel at (x,y).
-static const Pixel* ts_tile_xy(
+static inline const Pixel* ts_tile_xy(
     const Pixel* tile_pixels, const Ts_Tile* tile, int x, int y) {
   assert(tile_pixels);
   assert(tile);
@@ -166,9 +167,9 @@ static const Pixel* ts_tile_xy(
 }
 
 /// Return the tile's pixel at (x,y).
-static Pixel* ts_tile_xy_mut(
-    const Pixel* pixels, const Ts_Tile* tile, int x, int y) {
-  return (Pixel*)ts_tile_xy(pixels, tile, x, y);
+static inline Pixel* ts_tile_xy_mut(
+    Pixel* tile_pixels, const Ts_Tile* tile, int x, int y) {
+  return (Pixel*)ts_tile_xy(tile_pixels, tile, x, y);
 }
 
 /// Return the ith layer in the tile map.
@@ -177,9 +178,10 @@ static inline const Tm_Layer* tm_map_get_layer(
   assert(map);
   assert(layer >= 0);
   assert(layer < map->num_layers);
-  return (const Tm_Layer*)((const uint8_t*)map->layers +
-                           (layer * map->world_width * map->world_height *
-                            sizeof(Tile)));
+  return (
+      const Tm_Layer*)((const uint8_t*)map->layers +
+                       ((size_t)(layer * map->world_width * map->world_height) *
+                        sizeof(Tile)));
 }
 
 /// Return the ith layer in the tile map.
diff --git a/include/isogfx/gfx2d.h b/include/isogfx/gfx2d.h
index 59566f3..33a4591 100644
--- a/include/isogfx/gfx2d.h
+++ b/include/isogfx/gfx2d.h
@@ -37,12 +37,18 @@ typedef struct TileDesc {
   };
 } TileDesc;
 
+typedef enum MapOrientation {
+  MapOrthogonal,
+  MapIsometric,
+} MapOrientation;
+
 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.
+  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.
+  MapOrientation orientation;  // Map orientation.
 } MapDesc;
 
 typedef struct IsoGfxDesc {
@@ -104,15 +110,8 @@ void gfx2d_set_sprite_animation(Gfx2d*, Sprite, int animation);
 /// Currently, this updates the sprite animations.
 void gfx2d_update(Gfx2d*, 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 gfx2d_set_camera(Gfx2d*, int x, int y);
-
 /// Render the world.
-void gfx2d_render(Gfx2d*);
+void gfx2d_render(Gfx2d*, int camera_x, int camera_y);
 
 /// Draw/overlay a tile at position (x,y).
 ///
@@ -121,6 +120,16 @@ void gfx2d_render(Gfx2d*);
 /// position (x,y) instead, use gfx2d_set_tile().
 void gfx2d_draw_tile(Gfx2d*, int x, int y, Tile);
 
+/// Clip camera coordinates to the loaded map.
+///
+/// This is useful for implementing camera movement, in which you typically
+/// want the camera to stay within the map's bounds.
+///
+/// (x,y) are the top-left coordinates of the camera.
+///
+/// A map must have previously been loaded.
+void gfx2d_clip_camera(const Gfx2d*, float* x, float* y);
+
 /// Get the virtual screen's dimensions.
 void gfx2d_get_screen_size(const Gfx2d*, int* width, int* height);
 
diff --git a/src/gfx2d.c b/src/gfx2d.c
index 266a5f7..1c8b06f 100644
--- a/src/gfx2d.c
+++ b/src/gfx2d.c
@@ -20,6 +20,12 @@
 /// Time between animation updates.
 #define ANIMATION_UPDATE_DELTA (1.0 / ANIMATION_FPS)
 
+/// Take the maximum of two values.
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+/// Take the minimum of two values.
+#define min(a, b) ((a) < (b) ? (a) : (b))
+
 typedef struct ivec2 {
   int x, y;
 } ivec2;
@@ -73,6 +79,10 @@ static inline ivec2 ivec2_add(ivec2 a, ivec2 b) {
   return (ivec2){.x = a.x + b.x, .y = a.y + b.y};
 }
 
+static inline ivec2 ivec2_mul(ivec2 a, ivec2 b) {
+  return (ivec2){.x = a.x * b.x, .y = a.y * b.y};
+}
+
 static inline ivec2 ivec2_scale(ivec2 a, int s) {
   return (ivec2){.x = a.x * s, .y = a.y * s};
 }
@@ -85,12 +95,14 @@ static inline vec2 vec2_add(vec2 a, vec2 b) {
 
 static inline vec2 ivec2_to_vec2(ivec2 a) { return (vec2){a.x, a.y}; }
 
-/// Map map coordinates to screen coordinates, both Cartesian.
-static ivec2 map2screen(
+/// Map ortho coordinates to screen coordinates.
+///
+/// Camera coordinates are in pixels. Map coordinates are in tiles.
+static ivec2 ortho2screen(
     ivec2 camera, int tile_width, int tile_height, int map_x, int map_y) {
   return ivec2_add(
       ivec2_neg(camera),
-      (ivec2){.x = map_x * tile_width, .y = map_y * tile_height});
+      ivec2_mul((ivec2){map_x, map_y}, (ivec2){tile_width, tile_height}));
 }
 
 // Not actually used because we pre-compute the two axis vectors instead.
@@ -144,8 +156,8 @@ static inline vec2 cart2iso(vec2 cart, int s, int t, int w) {
   const double one_over_s = 1. / (double)s;
   const double one_over_t = 1. / (double)t;
   const double x          = cart.x - (double)(w / 2);
-  return (vec2){.x = (one_over_s * x + one_over_t * cart.y),
-                .y = (-one_over_s * x + one_over_t * cart.y)};
+  return (vec2){.x = ((one_over_s * x) + (one_over_t * cart.y)),
+                .y = ((-one_over_s * x) + (one_over_t * cart.y))};
 }
 
 static inline const Pixel* screen_xy_const_ref(
@@ -155,10 +167,10 @@ static inline const Pixel* screen_xy_const_ref(
   assert(y >= 0);
   assert(x < screen->width);
   assert(y < screen->height);
-  return &screen->pixels[y * screen->width + x];
+  return &screen->pixels[(y * screen->width) + x];
 }
 
-static inline Pixel screen_xy(Screen* screen, int x, int y) {
+static inline Pixel screen_xy(const Screen* screen, int x, int y) {
   return *screen_xy_const_ref(screen, x, y);
 }
 
@@ -263,6 +275,8 @@ void gfx2d_make_map(Gfx2d* gfx, const MapDesc* desc) {
       .base_tile_width  = desc->tile_width,
       .base_tile_height = desc->tile_height,
       .num_layers       = 1,
+      .flags =
+          (desc->orientation == MapOrthogonal) ? Tm_Orthogonal : Tm_Isometric,
   };
 
   gfx->tileset  = memstack_alloc_aligned(&gfx->stack, tileset_size_bytes, 4);
@@ -352,10 +366,10 @@ static void make_tile_from_colour(
   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;
+    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 bool  mask = ((mask_start <= x) && (x <= mask_end)) != 0;
       const Pixel val = mask ? colour : (Pixel){.r = 0, .g = 0, .b = 0, .a = 0};
 
       // Top half.
@@ -563,7 +577,6 @@ static void draw_rect(
 
   // Rect origin can be outside screen bounds, so we must offset accordingly to
   // draw only the visible portion.
-#define max(a, b) (a > b ? a : b)
   const int px_offset = max(0, -top_left.x);
   const int py_offset = max(0, -top_left.y);
 
@@ -596,7 +609,7 @@ static void draw_tile_ortho(Gfx2d* gfx, Tile tile, int x, int y) {
   const Ts_Tile* pTile  = ts_tileset_get_tile(gfx->tileset, tile);
   const Pixel*   pixels = ts_tileset_get_tile_pixels(gfx->tileset, tile);
 
-  const ivec2 screen_origin = map2screen(
+  const ivec2 screen_origin = ortho2screen(
       gfx->camera, gfx->map->base_tile_width, gfx->map->base_tile_height, x, y);
 
   draw_rect(
@@ -638,14 +651,24 @@ static void draw_map_ortho(Gfx2d* gfx) {
   assert(gfx);
   assert(gfx->map);
 
-  // TODO: Same TODOs as in draw_map_iso().
-
-  const Tm_Layer* layer = tm_map_get_layer(gfx->map, 0);
-
-  for (int wy = 0; wy < gfx->map->world_height; ++wy) {
-    for (int wx = 0; wx < gfx->map->world_width; ++wx) {
-      const Tile tile = tm_layer_get_tile(gfx->map, layer, wx, wy);
-      draw_tile_ortho(gfx, tile, wx, wy);
+  // Render the tiles that the camera view rectangle intersects.
+  // +1 when computing x1,y1 because the screen dimensions need not be a
+  // multiple of the base tile dimensions.
+  const int x_tiles = gfx->screen.width / gfx->map->base_tile_width;
+  const int y_tiles = gfx->screen.height / gfx->map->base_tile_height;
+  const int x0      = gfx->camera.x / gfx->map->base_tile_width;
+  const int y0      = gfx->camera.y / gfx->map->base_tile_height;
+  const int x1      = min(gfx->map->world_width, x0 + x_tiles + 1);
+  const int y1      = min(gfx->map->world_height, y0 + y_tiles + 1);
+
+  for (uint16_t l = 0; l < gfx->map->num_layers; ++l) {
+    const Tm_Layer* layer = tm_map_get_layer(gfx->map, l);
+
+    for (int wy = y0; wy < y1; ++wy) {
+      for (int wx = x0; wx < x1; ++wx) {
+        const Tile tile = tm_layer_get_tile(gfx->map, layer, wx, wy);
+        draw_tile_ortho(gfx, tile, wx, wy);
+      }
     }
   }
 }
@@ -704,7 +727,7 @@ static void draw_sprite_ortho(
   // 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 = map2screen(
+  const ivec2 screen_origin = ortho2screen(
       gfx->camera, gfx->map->base_tile_width, gfx->map->base_tile_height,
       sprite->position.x, sprite->position.y);
 
@@ -761,13 +784,11 @@ static void draw_sprites(Gfx2d* gfx) {
   }
 }
 
-void gfx2d_set_camera(Gfx2d* gfx, int x, int y) {
-  assert(gfx);
-  gfx->camera = (ivec2){x, y};
-}
-
-void gfx2d_render(Gfx2d* gfx) {
+void gfx2d_render(Gfx2d* gfx, int camera_x, int camera_y) {
   assert(gfx);
+  // Storing the camera mostly for debugging convenience. It could otherwise be
+  // passed around.
+  gfx->camera = (ivec2){camera_x, camera_y};
   draw_map(gfx);
   draw_sprites(gfx);
 }
@@ -787,6 +808,40 @@ void gfx2d_draw_tile(Gfx2d* gfx, int x, int y, Tile tile) {
   }
 }
 
+static void clip_camera_ortho(const Gfx2d* gfx, float* x, float* y) {
+  assert(gfx);
+  assert(gfx->map);
+
+  if (x != nullptr) {
+    const int width_pixels = gfx->map->world_width * gfx->map->base_tile_width;
+    const int x_max        = width_pixels - gfx->screen.width;
+    *x                     = min((float)x_max, max(0.F, *x));
+  }
+  if (y != nullptr) {
+    const int height_pixels =
+        gfx->map->world_height * gfx->map->base_tile_height;
+    const int y_max = height_pixels - gfx->screen.height;
+    *y              = min((float)y_max, max(0.F, *y));
+  }
+}
+
+void gfx2d_clip_camera(const Gfx2d* gfx, float* x, float* y) {
+  assert(gfx);
+  assert(gfx->map);
+  assert(x);
+  assert(y);
+
+  const Tm_Flags* flags = (const Tm_Flags*)&gfx->map->flags;
+  switch (flags->orientation) {
+  case Tm_Orthogonal:
+    clip_camera_ortho(gfx, x, y);
+    break;
+  case Tm_Isometric:
+    // TODO: Clip camera in isometric maps.
+    break;
+  }
+}
+
 void gfx2d_get_screen_size(const Gfx2d* gfx, int* width, int* height) {
   assert(gfx);
   assert(width);