background_buffer.cc

Go to the documentation of this file.

#include "app/gfx/render/background_buffer.h"
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <optional>
#include <vector>
 
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_tile.h"
#include "util/log.h"
 
namespace yaze::gfx {
 
std::optional<std::array<TileInfo, 8>> DecodeDungeonFloorTilePattern(
    const std::vector<uint8_t>& rom_data, int tile_address,
    int tile_address_floor, uint8_t floor_graphics) {
  const int floor_offset = static_cast<int>(floor_graphics & 0x0F) << 4;
  const auto table_is_readable = [&](int address) {
    return address >= 0 && static_cast<size_t>(address + 7) < rom_data.size();
  };
  if (!table_is_readable(tile_address + floor_offset) ||
      !table_is_readable(tile_address_floor + floor_offset)) {
    return std::nullopt;
  }
 
  std::array<TileInfo, 8> tiles;
  for (int index = 0; index < 4; ++index) {
    const int main_address = tile_address + floor_offset + index * 2;
    const int floor_address = tile_address_floor + floor_offset + index * 2;
    tiles[index] = TileInfo(rom_data[main_address], rom_data[main_address + 1]);
    tiles[index + 4] =
        TileInfo(rom_data[floor_address], rom_data[floor_address + 1]);
  }
  return tiles;
}
 
BackgroundBuffer::BackgroundBuffer(int width, int height)
    : width_(width), height_(height) {}
 
void BackgroundBuffer::EnsureTileBufferAllocated() {
  const size_t total_tiles = static_cast<size_t>((width_ / 8) * (height_ / 8));
  if (buffer_.size() != total_tiles) {
    buffer_.assign(total_tiles, 0);
  }
}
 
void BackgroundBuffer::EnsurePriorityBufferAllocated() {
  const size_t total_pixels = static_cast<size_t>(width_ * height_);
  if (priority_buffer_.size() != total_pixels) {
    priority_buffer_.assign(total_pixels, 0xFF);
  }
}
 
void BackgroundBuffer::EnsureCoverageBufferAllocated() {
  const size_t total_pixels = static_cast<size_t>(width_ * height_);
  if (coverage_buffer_.size() != total_pixels) {
    coverage_buffer_.assign(total_pixels, 0);
  }
}
 
void BackgroundBuffer::EnsureBG1RevealMaskAllocated() {
  const size_t total_pixels = static_cast<size_t>(width_ * height_);
  if (bg1_reveal_mask_buffer_.size() != total_pixels) {
    bg1_reveal_mask_buffer_.assign(total_pixels, 0);
  }
}
 
std::vector<uint8_t>& BackgroundBuffer::mutable_priority_data() {
  EnsurePriorityBufferAllocated();
  return priority_buffer_;
}
 
std::vector<uint8_t>& BackgroundBuffer::mutable_coverage_data() {
  EnsureCoverageBufferAllocated();
  return coverage_buffer_;
}
 
std::vector<uint8_t>& BackgroundBuffer::mutable_bg1_reveal_mask_data() {
  EnsureBG1RevealMaskAllocated();
  return bg1_reveal_mask_buffer_;
}
 
void BackgroundBuffer::SetTileAt(int x_pos, int y_pos, uint16_t value) {
  if (x_pos < 0 || y_pos < 0) {
    return;
  }
  int tiles_w = width_ / 8;
  int tiles_h = height_ / 8;
  if (x_pos >= tiles_w || y_pos >= tiles_h) {
    return;
  }
  EnsureTileBufferAllocated();
  buffer_[y_pos * tiles_w + x_pos] = value;
}
 
uint16_t BackgroundBuffer::GetTileAt(int x_pos, int y_pos) const {
  int tiles_w = width_ / 8;
  int tiles_h = height_ / 8;
  if (x_pos < 0 || y_pos < 0 || x_pos >= tiles_w || y_pos >= tiles_h) {
    return 0;
  }
  const size_t index = static_cast<size_t>(y_pos * tiles_w + x_pos);
  if (index >= buffer_.size()) {
    return 0;
  }
  return buffer_[index];
}
 
void BackgroundBuffer::ClearTileBuffer() {
  if (!buffer_.empty()) {
    std::fill(buffer_.begin(), buffer_.end(), 0);
  }
}
 
void BackgroundBuffer::ClearBuffer() {
  ClearTileBuffer();
  ClearPriorityBuffer();
  ClearCoverageBuffer();
  ClearBG1RevealMask();
}
 
void BackgroundBuffer::ClearPriorityBuffer() {
  // 0xFF indicates no priority set (transparent/empty pixel)
  if (!priority_buffer_.empty()) {
    std::fill(priority_buffer_.begin(), priority_buffer_.end(), 0xFF);
  }
}
 
void BackgroundBuffer::ClearCoverageBuffer() {
  // 0 indicates the layer never wrote here; 1 indicates it did.
  if (!coverage_buffer_.empty()) {
    std::fill(coverage_buffer_.begin(), coverage_buffer_.end(), 0);
  }
}
 
void BackgroundBuffer::ClearBG1RevealMask() {
  if (!bg1_reveal_mask_buffer_.empty()) {
    std::fill(bg1_reveal_mask_buffer_.begin(), bg1_reveal_mask_buffer_.end(),
              0);
  }
}
 
void BackgroundBuffer::ClearBG1RevealMask(BG1RevealMaskSource source) {
  if (bg1_reveal_mask_buffer_.empty()) {
    return;
  }
  const uint8_t keep_mask = static_cast<uint8_t>(~static_cast<uint8_t>(source));
  for (auto& value : bg1_reveal_mask_buffer_) {
    value &= keep_mask;
  }
}
 
void BackgroundBuffer::ClearBG1RevealMaskRect(BG1RevealMaskSource source,
                                              int start_x, int start_y,
                                              int width, int height) {
  if (bg1_reveal_mask_buffer_.empty() || width <= 0 || height <= 0) {
    return;
  }
  const uint8_t keep_mask = static_cast<uint8_t>(~static_cast<uint8_t>(source));
  const int end_x = std::min(start_x + width, width_);
  const int end_y = std::min(start_y + height, height_);
  for (int y = std::max(start_y, 0); y < end_y; ++y) {
    for (int x = std::max(start_x, 0); x < end_x; ++x) {
      bg1_reveal_mask_buffer_[static_cast<size_t>(y * width_ + x)] &= keep_mask;
    }
  }
}
 
void BackgroundBuffer::SetBG1RevealMaskRect(BG1RevealMaskSource source,
                                            int start_x, int start_y, int width,
                                            int height) {
  if (width <= 0 || height <= 0) {
    return;
  }
  EnsureBG1RevealMaskAllocated();
  const uint8_t source_mask = static_cast<uint8_t>(source);
  const int end_x = std::min(start_x + width, width_);
  const int end_y = std::min(start_y + height, height_);
  for (int y = std::max(start_y, 0); y < end_y; ++y) {
    for (int x = std::max(start_x, 0); x < end_x; ++x) {
      bg1_reveal_mask_buffer_[static_cast<size_t>(y * width_ + x)] |=
          source_mask;
    }
  }
}
 
uint8_t BackgroundBuffer::GetPriorityAt(int x, int y) const {
  if (x < 0 || y < 0 || x >= width_ || y >= height_) {
    return 0xFF;  // Out of bounds = no priority
  }
  return priority_buffer_[y * width_ + x];
}
 
void BackgroundBuffer::SetPriorityAt(int x, int y, uint8_t priority) {
  if (x < 0 || y < 0 || x >= width_ || y >= height_) {
    return;
  }
  EnsurePriorityBufferAllocated();
  priority_buffer_[y * width_ + x] = priority;
}
 
void BackgroundBuffer::EnsureBitmapInitialized() {
  if (!bitmap_.is_active() || bitmap_.width() == 0) {
    // IMPORTANT: Initialize to 255 (transparent fill), NOT 0!
    // In dungeon rendering, pixel value 0 represents palette[0] (actual color).
    // Only 255 is treated as transparent by IsTransparent().
    bitmap_.Create(width_, height_, 8,
                   std::vector<uint8_t>(width_ * height_, 255));
 
    // Fix: Set index 255 to be transparent so the background is actually transparent
    // instead of white (default SDL palette index 255)
    std::vector<SDL_Color> palette(256);
    // Initialize with grayscale for debugging
    for (int i = 0; i < 256; i++) {
      palette[i] = {static_cast<Uint8>(i), static_cast<Uint8>(i),
                    static_cast<Uint8>(i), 255};
    }
    // Set index 255 to transparent
    palette[255] = {0, 0, 0, 0};
    bitmap_.SetPalette(palette);
 
    // Enable blending
    if (bitmap_.surface()) {
      SDL_SetSurfaceBlendMode(bitmap_.surface(), SDL_BLENDMODE_BLEND);
    }
  }
 
  EnsurePriorityBufferAllocated();
  EnsureCoverageBufferAllocated();
}
 
void BackgroundBuffer::DrawTile(const TileInfo& tile, uint8_t* canvas,
                                const uint8_t* tiledata, int indexoffset) {
  // tiledata is now 8BPP linear data (1 byte per pixel)
  // Buffer size: 0x10000 (65536 bytes) = 64 tile rows max
  constexpr int kGfxBufferSize = 0x10000;
  constexpr int kMaxTileRow = 63;  // 64 rows (0-63), each 1024 bytes
 
  // Calculate tile position in the 8BPP buffer
  int tile_col_idx = tile.id_ % 16;
  int tile_row_idx = tile.id_ / 16;
 
  // CRITICAL: Validate tile_row to prevent index out of bounds
  if (tile_row_idx > kMaxTileRow) {
    return;  // Skip invalid tiles silently
  }
 
  int tile_base_x = tile_col_idx * 8;  // 8 pixels wide (8 bytes)
  int tile_base_y =
      tile_row_idx * 1024;  // 8 rows * 128 bytes stride (sheet width)
 
  // Palette offset: tile palette field (3-bit, 0-7) is the CGRAM row index.
  // SDL palette mirrors CGRAM directly: dungeon view loads banks 2-7 in
  // Room::RenderRoomGraphics, leaving banks 0-1 as HUD placeholders.
  // See object_drawer.cc for the canonical comment.
  const uint8_t pal = tile.palette_ & 0x07;
  const uint8_t palette_offset = static_cast<uint8_t>(pal * 16);
 
  // Pre-calculate max valid destination index
  int max_dest = width_ * height_;
 
  // Get priority bit from tile (over_ = priority bit in SNES tilemap)
  uint8_t priority = tile.over_ ? 1 : 0;
 
  // Copy 8x8 pixels
  for (int py = 0; py < 8; py++) {
    int src_row = tile.vertical_mirror_ ? (7 - py) : py;
 
    for (int px = 0; px < 8; px++) {
      int src_col = tile.horizontal_mirror_ ? (7 - px) : px;
 
      // Calculate source index
      // Stride is 128 bytes (sheet width)
      int src_index = (src_row * 128) + src_col + tile_base_x + tile_base_y;
 
      // Bounds check source
      if (src_index < 0 || src_index >= kGfxBufferSize)
        continue;
 
      uint8_t pixel = tiledata[src_index];
 
      if (pixel != 0) {
        // Pixel 0 is transparent (not written). Pixels 1-15 map to bank indices 1-15.
        // With 16-color bank chunking: final_color = pixel + (bank * 16)
        uint8_t final_color = pixel + palette_offset;
        int dest_index = indexoffset + (py * width_) + px;
 
        // Bounds check destination
        if (dest_index >= 0 && dest_index < max_dest) {
          canvas[dest_index] = final_color;
          // Also store priority for this pixel
          priority_buffer_[dest_index] = priority;
        }
      }
    }
  }
}
 
void BackgroundBuffer::DrawBackground(std::span<uint8_t> gfx16_data) {
  int tiles_w = width_ / 8;
  int tiles_h = height_ / 8;
  EnsureTileBufferAllocated();
 
  // NEVER recreate bitmap here - it should be created by DrawFloor or
  // initialized earlier. If bitmap doesn't exist, create it ONCE with 255 fill
  // IMPORTANT: Use 255 (transparent), NOT 0! Pixel value 0 = palette[0] (actual color)
  if (!bitmap_.is_active() || bitmap_.width() == 0) {
    bitmap_.Create(width_, height_, 8,
                   std::vector<uint8_t>(width_ * height_, 255));
  }
 
  EnsurePriorityBufferAllocated();
 
  // For each tile on the tile buffer
  // int drawn_count = 0;
  // int skipped_count = 0;
  for (int yy = 0; yy < tiles_h; yy++) {
    for (int xx = 0; xx < tiles_w; xx++) {
      uint16_t word = buffer_[xx + yy * tiles_w];
 
      // Skip empty tiles (0xFFFF) - these show the floor
      if (word == 0xFFFF) {
        // skipped_count++;
        continue;
      }
 
      // Skip zero tiles - also show the floor
      if (word == 0) {
        // skipped_count++;
        continue;
      }
 
      auto tile = gfx::WordToTileInfo(word);
 
      // Skip floor tiles (0xEC-0xFD) - don't overwrite DrawFloor's work
      // These are the animated floor tiles, already drawn by DrawFloor
      // Skip floor tiles (0xEC-0xFD) - don't overwrite DrawFloor's work
      // These are the animated floor tiles, already drawn by DrawFloor
      // if (tile.id_ >= 0xEC && tile.id_ <= 0xFD) {
      //   skipped_count++;
      //   continue;
      // }
 
      // Calculate pixel offset for tile position (xx, yy) in the 512x512 bitmap
      // Each tile is 8x8, so pixel Y = yy * 8, pixel X = xx * 8
      // Linear offset = (pixel_y * width) + pixel_x = (yy * 8 * 512) + (xx * 8)
      int tile_offset = (yy * 8 * width_) + (xx * 8);
      DrawTile(tile, bitmap_.mutable_data().data(), gfx16_data.data(),
               tile_offset);
      // drawn_count++;
    }
  }
  // CRITICAL: Sync bitmap data back to SDL surface!
  // DrawTile() writes to bitmap_.mutable_data(), but the SDL surface needs
  // updating
  if (bitmap_.surface() && bitmap_.mutable_data().size() > 0) {
    SDL_LockSurface(bitmap_.surface());
    memcpy(bitmap_.surface()->pixels, bitmap_.mutable_data().data(),
           bitmap_.mutable_data().size());
    SDL_UnlockSurface(bitmap_.surface());
  }
}
 
void BackgroundBuffer::DrawFloor(const std::vector<uint8_t>& rom_data,
                                 int tile_address, int tile_address_floor,
                                 uint8_t floor_graphics) {
  // Create bitmap ONCE at the start if it doesn't exist
  // IMPORTANT: Use 255 (transparent fill), NOT 0! Pixel value 0 = palette[0] (actual color)
  if (!bitmap_.is_active() || bitmap_.width() == 0) {
    LOG_DEBUG("[DrawFloor]", "Creating bitmap: %dx%d, active=%d, width=%d",
              width_, height_, bitmap_.is_active(), bitmap_.width());
    bitmap_.Create(width_, height_, 8,
                   std::vector<uint8_t>(width_ * height_, 255));
    LOG_DEBUG("[DrawFloor]", "After Create: active=%d, width=%d, height=%d",
              bitmap_.is_active(), bitmap_.width(), bitmap_.height());
  } else {
    LOG_DEBUG("[DrawFloor]",
              "Bitmap already exists: active=%d, width=%d, height=%d",
              bitmap_.is_active(), bitmap_.width(), bitmap_.height());
  }
 
  const auto floor_tiles = DecodeDungeonFloorTilePattern(
      rom_data, tile_address, tile_address_floor, floor_graphics);
  if (!floor_tiles.has_value()) {
    LOG_DEBUG("[DrawFloor]", "Floor pattern %d is outside the ROM data",
              static_cast<int>(floor_graphics));
    return;
  }
 
  // Floor tiles specify which 8-color sub-palette from the 90-color dungeon
  // palette e.g., palette 6 = colors 48-55 (6 * 8 = 48)
 
  // Draw the floor tiles in a pattern
  // Convert TileInfo to 16-bit words with palette information
  std::array<uint16_t, 8> words;
  std::transform(floor_tiles->begin(), floor_tiles->end(), words.begin(),
                 [](const TileInfo& tile) { return TileInfoToWord(tile); });
  for (int xx = 0; xx < 16; xx++) {
    for (int yy = 0; yy < 32; yy++) {
      for (int column = 0; column < 4; ++column) {
        SetTileAt((xx * 4) + column, yy * 2, words[column]);
        SetTileAt((xx * 4) + column, (yy * 2) + 1, words[column + 4]);
      }
    }
  }
}
 
}  // namespace yaze::gfx