object_tile_editor.cc

Go to the documentation of this file.

#include "zelda3/dungeon/object_tile_editor.h"
 
#include <algorithm>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <unordered_map>
 
#include "app/gfx/types/snes_tile.h"
#include "core/features.h"
#include "util/log.h"
#include "zelda3/dungeon/custom_object.h"
#include "zelda3/dungeon/geometry/object_geometry.h"
#include "zelda3/dungeon/object_drawer.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze {
namespace zelda3 {
 
namespace {
 
constexpr int kPaletteBankSize = 16;
 
gfx::SnesPalette BuildPaddedPaletteBank(const gfx::SnesPalette& source) {
  gfx::SnesPalette padded;
  for (size_t i = 0; i < static_cast<size_t>(kPaletteBankSize); ++i) {
    if (i < source.size()) {
      padded.AddColor(source[i]);
    } else {
      padded.AddColor(gfx::SnesColor());
    }
  }
  return padded;
}
 
gfx::SnesPalette BuildCombinedPaletteBanks(const gfx::PaletteGroup& palette) {
  gfx::SnesPalette combined;
  for (int i = 0; i < palette.size(); ++i) {
    const auto padded = BuildPaddedPaletteBank(palette.palette_ref(i));
    for (size_t color = 0; color < padded.size(); ++color) {
      combined.AddColor(padded[color]);
    }
  }
  return combined;
}
 
int ResolvePaletteIndex(const gfx::PaletteGroup& palette, int requested) {
  if (palette.empty()) {
    return 0;
  }
  if (requested >= 0 && requested < static_cast<int>(palette.size())) {
    return requested;
  }
  return 0;
}
 
}  // namespace
 
// =============================================================================
// ObjectTileLayout
// =============================================================================
 
ObjectTileLayout ObjectTileLayout::FromTraces(
    const std::vector<ObjectDrawer::TileTrace>& traces) {
  ObjectTileLayout layout;
  if (traces.empty()) {
    return layout;
  }
 
  layout.object_id = static_cast<int16_t>(traces[0].object_id);
 
  // Find bounding box
  int min_x = traces[0].x_tile;
  int min_y = traces[0].y_tile;
  int max_x = min_x;
  int max_y = min_y;
  for (const auto& t : traces) {
    min_x = std::min(min_x, static_cast<int>(t.x_tile));
    min_y = std::min(min_y, static_cast<int>(t.y_tile));
    max_x = std::max(max_x, static_cast<int>(t.x_tile));
    max_y = std::max(max_y, static_cast<int>(t.y_tile));
  }
 
  layout.origin_tile_x = min_x;
  layout.origin_tile_y = min_y;
  layout.bounds_width = max_x - min_x + 1;
  layout.bounds_height = max_y - min_y + 1;
 
  std::unordered_map<uint32_t, size_t> last_trace_by_cell;
  last_trace_by_cell.reserve(traces.size());
  for (size_t i = 0; i < traces.size(); ++i) {
    const auto& t = traces[i];
    const uint32_t cell_key =
        (static_cast<uint32_t>(static_cast<uint16_t>(t.x_tile)) << 16) |
        static_cast<uint16_t>(t.y_tile);
    last_trace_by_cell[cell_key] = i;
  }
 
  std::vector<size_t> surviving_trace_indices;
  surviving_trace_indices.reserve(last_trace_by_cell.size());
  for (const auto& [_, trace_index] : last_trace_by_cell) {
    surviving_trace_indices.push_back(trace_index);
  }
  std::sort(surviving_trace_indices.begin(), surviving_trace_indices.end());
 
  layout.cells.reserve(surviving_trace_indices.size());
  for (size_t trace_index : surviving_trace_indices) {
    const auto& t = traces[trace_index];
    Cell cell;
    cell.rel_x = t.x_tile - min_x;
    cell.rel_y = t.y_tile - min_y;
 
    // Reconstruct TileInfo from trace fields
    bool h_mirror = (t.flags & 0x1) != 0;
    bool v_mirror = (t.flags & 0x2) != 0;
    bool priority = (t.flags & 0x4) != 0;
    uint8_t palette = (t.flags >> 3) & 0x7;
    cell.tile_info =
        gfx::TileInfo(t.tile_id, palette, v_mirror, h_mirror, priority);
    cell.original_word = gfx::TileInfoToWord(cell.tile_info);
    cell.write_index = static_cast<int>(trace_index);
    cell.modified = false;
 
    layout.cells.push_back(cell);
  }
 
  return layout;
}
 
ObjectTileLayout ObjectTileLayout::CreateEmpty(int width, int height,
                                               int16_t object_id,
                                               const std::string& filename) {
  ObjectTileLayout layout;
  layout.object_id = object_id;
  layout.origin_tile_x = 0;
  layout.origin_tile_y = 0;
  layout.bounds_width = width;
  layout.bounds_height = height;
  layout.tile_data_address = -1;
  layout.is_custom = true;
  layout.custom_filename = filename;
 
  layout.cells.reserve(width * height);
  for (int y = 0; y < height; ++y) {
    for (int x = 0; x < width; ++x) {
      Cell cell;
      cell.rel_x = x;
      cell.rel_y = y;
      cell.tile_info = gfx::TileInfo(0, 2, false, false, false);
      cell.original_word = gfx::TileInfoToWord(cell.tile_info);
      cell.write_index = static_cast<int>(layout.cells.size());
      cell.modified = true;
      layout.cells.push_back(cell);
    }
  }
 
  return layout;
}
 
ObjectTileLayout::Cell* ObjectTileLayout::FindCell(int rel_x, int rel_y) {
  for (auto& cell : cells) {
    if (cell.rel_x == rel_x && cell.rel_y == rel_y)
      return &cell;
  }
  return nullptr;
}
 
const ObjectTileLayout::Cell* ObjectTileLayout::FindCell(int rel_x,
                                                         int rel_y) const {
  for (const auto& cell : cells) {
    if (cell.rel_x == rel_x && cell.rel_y == rel_y)
      return &cell;
  }
  return nullptr;
}
 
bool ObjectTileLayout::HasModifications() const {
  for (const auto& cell : cells) {
    if (cell.modified)
      return true;
  }
  return false;
}
 
void ObjectTileLayout::RevertAll() {
  for (auto& cell : cells) {
    if (cell.modified) {
      cell.tile_info = gfx::WordToTileInfo(cell.original_word);
      cell.modified = false;
    }
  }
}
 
// =============================================================================
// ObjectTileEditor
// =============================================================================
 
ObjectTileEditor::ObjectTileEditor(Rom* rom) : rom_(rom) {}
 
absl::StatusOr<ObjectTileLayout> ObjectTileEditor::CaptureObjectLayout(
    int16_t object_id, const Room& room, const gfx::PaletteGroup& palette) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  // Resolve the canvas anchor through ObjectGeometry so routines that
  // draw upward or leftward (acute diagonals 0x09-0x14 / 0x15-0x20,
  // diagonal ceilings 0xA0-0xAC) replay their full extent without
  // clipping. Hardcoded (2, 2) previously
  // dropped tile writes at negative tile coordinates because
  // DrawRoutineUtils::WriteTile8 short-circuits via IsValidTilePosition
  // before invoking the trace hook.
  constexpr uint8_t kPreviewSizeByte = 0x12;
  auto [anchor_x, anchor_y] =
      ObjectGeometry::Get().ResolveAnchor(object_id, kPreviewSizeByte);
  RoomObject obj(object_id, anchor_x, anchor_y, kPreviewSizeByte, 0);
  obj.SetRom(rom_);
  obj.EnsureTilesLoaded();
 
  // Check if this is a custom object
  bool is_custom = false;
  std::string custom_filename;
  int subtype = obj.size_ & 0x1F;
  if (core::FeatureFlags::get().kEnableCustomObjects) {
    auto custom_result =
        CustomObjectManager::Get().GetObjectInternal(object_id, subtype);
    if (custom_result.ok()) {
      is_custom = true;
      custom_filename =
          CustomObjectManager::Get().ResolveFilename(object_id, subtype);
    }
  }
 
  // Create drawer and set up trace collection
  ObjectDrawer drawer(rom_, room.id(), room.get_gfx_buffer().data());
 
  std::vector<ObjectDrawer::TileTrace> traces;
  traces.reserve(256);
  drawer.SetTraceCollector(&traces, /*trace_only=*/true);
 
  // Draw the object to collect traces
  gfx::BackgroundBuffer dummy_bg1(512, 512);
  gfx::BackgroundBuffer dummy_bg2(512, 512);
  auto status = drawer.DrawObject(obj, dummy_bg1, dummy_bg2, palette);
  drawer.ClearTraceCollector();
 
  if (!status.ok()) {
    return status;
  }
 
  if (traces.empty()) {
    return absl::NotFoundError("Object produced no tile traces");
  }
 
  // Build layout from traces
  ObjectTileLayout layout = ObjectTileLayout::FromTraces(traces);
  layout.tile_data_address = obj.tile_data_ptr_;
  layout.is_custom = is_custom;
  layout.custom_filename = custom_filename;
 
  return layout;
}
 
absl::Status ObjectTileEditor::RenderLayoutToBitmap(
    const ObjectTileLayout& layout, gfx::Bitmap& bitmap,
    const uint8_t* room_gfx_buffer, const gfx::PaletteGroup& palette) {
  if (!room_gfx_buffer) {
    return absl::FailedPreconditionError("No room graphics buffer");
  }
  if (layout.cells.empty()) {
    return absl::OkStatus();
  }
 
  int bmp_w = layout.bounds_width * 8;
  int bmp_h = layout.bounds_height * 8;
 
  // Create or resize bitmap
  std::vector<uint8_t> pixel_data(bmp_w * bmp_h, 0);
  bitmap.Create(bmp_w, bmp_h, 8, pixel_data);
 
  // Preview rendering uses tile palette bank offsets (pal * 16), so the bitmap
  // needs a combined banked palette rather than a single sub-palette.
  if (!palette.empty()) {
    bitmap.SetPalette(BuildCombinedPaletteBanks(palette));
  }
 
  // Use a temporary ObjectDrawer just for its DrawTileToBitmap utility
  ObjectDrawer drawer(rom_, 0, room_gfx_buffer);
 
  for (const auto& cell : layout.cells) {
    int px = cell.rel_x * 8;
    int py = cell.rel_y * 8;
    drawer.DrawTileToBitmap(bitmap, cell.tile_info, px, py, room_gfx_buffer);
  }
 
  return absl::OkStatus();
}
 
absl::Status ObjectTileEditor::BuildTile8Atlas(gfx::Bitmap& atlas,
                                               const uint8_t* room_gfx_buffer,
                                               const gfx::PaletteGroup& palette,
                                               int display_palette) {
  if (!room_gfx_buffer) {
    return absl::FailedPreconditionError("No room graphics buffer");
  }
 
  std::vector<uint8_t> pixel_data(kAtlasWidthPx * kAtlasHeightPx, 0);
  atlas.Create(kAtlasWidthPx, kAtlasHeightPx, 8, pixel_data);
 
  const int resolved_palette = ResolvePaletteIndex(palette, display_palette);
  if (!palette.empty()) {
    atlas.SetPalette(
        BuildPaddedPaletteBank(palette.palette_ref(resolved_palette)));
  }
 
  ObjectDrawer drawer(rom_, 0, room_gfx_buffer);
 
  for (int tile_id = 0; tile_id < kAtlasTileCount; ++tile_id) {
    int col = tile_id % kAtlasTilesPerRow;
    int row = tile_id / kAtlasTilesPerRow;
    int px = col * 8;
    int py = row * 8;
 
    // The atlas bitmap already contains the selected palette bank, so tiles
    // should draw into palette row 0 inside that local 16-color palette.
    gfx::TileInfo info(static_cast<uint16_t>(tile_id), /*palette=*/0, false,
                       false, false);
    drawer.DrawTileToBitmap(atlas, info, px, py, room_gfx_buffer);
  }
 
  return absl::OkStatus();
}
 
absl::Status ObjectTileEditor::WriteBack(const ObjectTileLayout& layout) {
  if (!layout.HasModifications()) {
    return absl::OkStatus();
  }
 
  if (layout.is_custom) {
    // Custom object: serialize to binary format and write .bin file
    if (layout.custom_filename.empty()) {
      return absl::FailedPreconditionError(
          "Custom object has no filename for write-back");
    }
 
    // Group cells by rel_y to form segments
    std::map<int, std::vector<const ObjectTileLayout::Cell*>> rows;
    for (const auto& cell : layout.cells) {
      rows[cell.rel_y].push_back(&cell);
    }
 
    // Serialize to binary matching CustomObjectManager::ParseBinaryData format
    std::vector<uint8_t> binary;
    constexpr int kBufferStride = 128;
 
    int prev_buffer_pos = 0;
    for (auto& [row_y, row_cells] : rows) {
      // Sort cells by rel_x
      std::sort(
          row_cells.begin(), row_cells.end(),
          [](const auto* a, const auto* b) { return a->rel_x < b->rel_x; });
 
      int count = static_cast<int>(row_cells.size());
      int buffer_pos_for_row = row_y * kBufferStride + row_cells[0]->rel_x * 2;
      int jump_offset = (row_y == rows.rbegin()->first)
                            ? 0
                            : kBufferStride;  // Jump to next row
 
      // Header: low 5 bits = count, high byte = jump_offset
      uint16_t header = (count & 0x1F) | ((jump_offset & 0xFF) << 8);
      binary.push_back(header & 0xFF);
      binary.push_back((header >> 8) & 0xFF);
 
      for (const auto* cell : row_cells) {
        uint16_t word = gfx::TileInfoToWord(cell->tile_info);
        binary.push_back(word & 0xFF);
        binary.push_back((word >> 8) & 0xFF);
      }
 
      prev_buffer_pos = buffer_pos_for_row + count * 2;
    }
 
    // Terminator
    binary.push_back(0);
    binary.push_back(0);
 
    // Write to file
    auto& mgr = CustomObjectManager::Get();
    std::filesystem::path full_path =
        std::filesystem::path(mgr.GetBasePath()) / layout.custom_filename;
    std::ofstream file(full_path, std::ios::binary);
    if (!file) {
      return absl::InternalError("Failed to open file for writing: " +
                                 full_path.string());
    }
    file.write(reinterpret_cast<const char*>(binary.data()), binary.size());
    file.close();
 
    // Reload cache
    mgr.ReloadAll();
    return absl::OkStatus();
  }
 
  // Standard object: patch ROM at tile_data_address
  if (layout.tile_data_address < 0) {
    return absl::FailedPreconditionError(
        "No tile data address for ROM write-back");
  }
 
  for (size_t i = 0; i < layout.cells.size(); ++i) {
    const auto& cell = layout.cells[i];
    if (!cell.modified)
      continue;
 
    const int write_index =
        cell.write_index >= 0 ? cell.write_index : static_cast<int>(i);
    int addr = layout.tile_data_address + write_index * 2;
    uint16_t word = gfx::TileInfoToWord(cell.tile_info);
 
    // Write 2 bytes (little-endian SNES tilemap word)
    auto low = static_cast<uint8_t>(word & 0xFF);
    auto high = static_cast<uint8_t>((word >> 8) & 0xFF);
    RETURN_IF_ERROR(rom_->WriteByte(addr, low));
    RETURN_IF_ERROR(rom_->WriteByte(addr + 1, high));
  }
 
  return absl::OkStatus();
}
 
int ObjectTileEditor::CountObjectsSharingTileData(int16_t object_id) const {
  if (!rom_ || !rom_->is_loaded())
    return 0;
 
  // Create temporary object to get its tile_data_ptr_
  RoomObject test_obj(object_id, 0, 0, 0, 0);
  test_obj.SetRom(rom_);
  test_obj.EnsureTilesLoaded();
  int target_ptr = test_obj.tile_data_ptr_;
  if (target_ptr < 0)
    return 0;
 
  // Scan type 1 objects (0x00-0xFF) for shared pointers
  int count = 0;
  for (int id = 0; id < 0x100; ++id) {
    RoomObject scan_obj(static_cast<int16_t>(id), 0, 0, 0, 0);
    scan_obj.SetRom(rom_);
    scan_obj.EnsureTilesLoaded();
    if (scan_obj.tile_data_ptr_ == target_ptr) {
      ++count;
    }
  }
 
  return count;
}
 
}  // namespace zelda3
}  // namespace yaze