Refactor bitmap and tilesheet classes: improve variable naming, remove unused methods, and add tile data mirroring functionality for enhanced clarity and maintainability

src/app/gfx/tilesheet.cc

@@ -32,12 +32,12 @@ absl::StatusOr<Tilesheet> CreateTilesheetFromGraphicsBuffer(
       // Copy the tile data into the tilesheet
       for (int y = 0; y < 8; ++y) {
         for (int x = 0; x < 8; ++x) {
-          int srcIndex = tile_index + (y * 8 + x);
-          int destX = col * 8 + x;
-          int destY = row * 8 + y;
-          int destIndex = (destY * width * 8) + destX;
-          tilesheet.mutable_bitmap()->mutable_data()[destIndex] =
-              graphics_buffer[srcIndex];
+          int src_index = tile_index + (y * 8 + x);
+          int dest_x = col * 8 + x;
+          int dest_y = row * 8 + y;
+          int dest_index = (dest_y * width * 8) + dest_x;
+          tilesheet.mutable_bitmap()->mutable_data()[dest_index] =
+              graphics_buffer[src_index];
         }
       }
     }
@@ -68,14 +68,15 @@ void Tilesheet::ComposeTile16(const std::vector<uint8_t>& graphics_buffer,
   int tiles_per_row = bitmap_->width() / tile_width_;
   int tile16_row = num_tiles_ / tiles_per_row;
   int tile16_column = num_tiles_ % tiles_per_row;
-  int baseX = tile16_column * tile_width_;
-  int baseY = tile16_row * tile_height_;
+  int base_x = tile16_column * tile_width_;
+  int base_y = tile16_row * tile_height_;
 
   // Compose and place each part of the Tile16
-  ComposeAndPlaceTilePart(graphics_buffer, top_left, baseX, baseY);
-  ComposeAndPlaceTilePart(graphics_buffer, top_right, baseX + 8, baseY);
-  ComposeAndPlaceTilePart(graphics_buffer, bottom_left, baseX, baseY + 8);
-  ComposeAndPlaceTilePart(graphics_buffer, bottom_right, baseX + 8, baseY + 8);
+  ComposeAndPlaceTilePart(graphics_buffer, top_left, base_x, base_y);
+  ComposeAndPlaceTilePart(graphics_buffer, top_right, base_x + 8, base_y);
+  ComposeAndPlaceTilePart(graphics_buffer, bottom_left, base_x, base_y + 8);
+  ComposeAndPlaceTilePart(graphics_buffer, bottom_right, base_x + 8,
+                          base_y + 8);
 
   tile_info_.push_back({top_left, top_right, bottom_left, bottom_right});
 
@@ -84,7 +85,7 @@ void Tilesheet::ComposeTile16(const std::vector<uint8_t>& graphics_buffer,
 
 void Tilesheet::ComposeAndPlaceTilePart(
     const std::vector<uint8_t>& graphics_buffer, const TileInfo& tile_info,
-    int baseX, int baseY) {
+    int base_x, int base_y) {
   std::vector<uint8_t> tile_data =
       FetchTileDataFromGraphicsBuffer(graphics_buffer, tile_info.id_);
 
@@ -98,17 +99,91 @@ void Tilesheet::ComposeAndPlaceTilePart(
   // Place the tile data into the full-size bitmap at the calculated position
   for (int y = 0; y < 8; ++y) {
     for (int x = 0; x < 8; ++x) {
-      int srcIndex = y * 8 + x;
-      int destX = baseX + x;
-      int destY = baseY + y;
-      int destIndex = (destY * bitmap_->width()) + destX;
-      internal_data_[destIndex] = tile_data[srcIndex];
+      int src_index = y * 8 + x;
+      int dest_x = base_x + x;
+      int dest_y = base_y + y;
+      int dest_index = (dest_y * bitmap_->width()) + dest_x;
+      internal_data_[dest_index] = tile_data[src_index];
     }
   }
 
   bitmap_->set_data(internal_data_);
 }
 
+std::vector<uint8_t> Tilesheet::FetchTileDataFromGraphicsBuffer(
+    const std::vector<uint8_t>& graphics_buffer, int tile_id) {
+  const int tile_width = 8;
+  const int tile_height = 8;
+  const int buffer_width = 128;
+  const int sheet_height = 32;
+
+  const int tiles_per_row = buffer_width / tile_width;
+  const int rows_per_sheet = sheet_height / tile_height;
+  const int tiles_per_sheet = tiles_per_row * rows_per_sheet;
+
+  // Calculate the position in the graphics_buffer_ based on tile_id
+  std::vector<uint8_t> tile_data(0x40, 0x00);
+  int sheet = (tile_id / tiles_per_sheet) % 4 + 212;
+  int position_in_sheet = tile_id % tiles_per_sheet;
+  int row_in_sheet = position_in_sheet / tiles_per_row;
+  int column_in_sheet = position_in_sheet % tiles_per_row;
+
+  // Ensure that the sheet ID is between 212 and 215
+  assert(sheet >= 212 && sheet <= 215);
+
+  // Copy the tile data from the graphics_buffer_ to tile_data
+  for (int y = 0; y < 8; ++y) {
+    for (int x = 0; x < 8; ++x) {
+      // Calculate the position in the graphics_buffer_ based on tile_id
+      int src_x = column_in_sheet * tile_width + x;
+      int src_y = (sheet * sheet_height) + (row_in_sheet * tile_height) + y;
+
+      int src_index = (src_y * buffer_width) + src_x;
+      int dest_index = y * tile_width + x;
+
+      tile_data[dest_index] = graphics_buffer[src_index];
+    }
+  }
+
+  return tile_data;
+}
+
+void Tilesheet::MirrorTileDataVertically(std::vector<uint8_t>& tile_data) {
+  std::vector<uint8_t> tile_data_copy = tile_data;
+  for (int i = 0; i < 8; ++i) {    // For each row
+    for (int j = 0; j < 8; ++j) {  // For each column
+      int src_index = i * 8 + j;
+      int dest_index = (7 - i) * 8 + j;  // Calculate the mirrored row
+      tile_data_copy[dest_index] = tile_data[src_index];
+    }
+  }
+  tile_data = tile_data_copy;
+}
+
+void Tilesheet::MirrorTileDataHorizontally(std::vector<uint8_t>& tile_data) {
+  std::vector<uint8_t> tile_data_copy = tile_data;
+  for (int i = 0; i < 8; ++i) {    // For each row
+    for (int j = 0; j < 8; ++j) {  // For each column
+      int src_index = i * 8 + j;
+      int dest_index = i * 8 + (7 - j);  // Calculate the mirrored column
+      tile_data_copy[dest_index] = tile_data[src_index];
+    }
+  }
+  tile_data = tile_data_copy;
+}
+
+void Tilesheet::MirrorTileData(std::vector<uint8_t>& tile_data, bool mirrorX,
+                               bool mirrorY) {
+  std::vector tile_data_copy = tile_data;
+  if (mirrorX) {
+    MirrorTileDataHorizontally(tile_data_copy);
+  }
+  if (mirrorY) {
+    MirrorTileDataVertically(tile_data_copy);
+  }
+  tile_data = tile_data_copy;
+}
+
 }  // namespace gfx
 }  // namespace app
 }  // namespace yaze