1 files changed, 82 insertions, 27 deletions

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);