screen_editor.cc

Go to the documentation of this file.

#include "screen_editor.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
 
#include "absl/strings/str_format.h"
#include "app/editor/agent/agent_ui_theme.h"
#include "app/editor/editor_manager.h"
#include "app/editor/graphics/graphics_editor.h"
#include "app/editor/graphics/screen_editor_internal.h"
#include "app/editor/graphics/screen_graphics_context.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gui/automation/widget_auto_register.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/widgets/themed_widgets.h"
#include "imgui/imgui.h"
#include "util/file_util.h"
#include "util/hex.h"
#include "util/macro.h"
 
namespace yaze {
namespace editor {
 
void ScreenEditor::Initialize() {
  if (!dependencies_.window_manager)
    return;
  auto* window_manager = dependencies_.window_manager;
 
  window_manager->RegisterPanel(
      {.card_id = "screen.dungeon_maps",
       .display_name = "Dungeon Maps",
       .window_title = " Dungeon Map Editor",
       .icon = ICON_MD_MAP,
       .category = "Screen",
       .shortcut_hint = "Alt+1",
       .priority = 10,
       .enabled_condition = [this]() { return rom()->is_loaded(); },
       .disabled_tooltip = "Load a ROM first"});
  window_manager->RegisterPanel(
      {.card_id = "screen.inventory_menu",
       .display_name = "Inventory Menu",
       .window_title = " Inventory Menu",
       .icon = ICON_MD_INVENTORY,
       .category = "Screen",
       .shortcut_hint = "Alt+2",
       .priority = 20,
       .enabled_condition = [this]() { return rom()->is_loaded(); },
       .disabled_tooltip = "Load a ROM first"});
  window_manager->RegisterPanel(
      {.card_id = "screen.overworld_map",
       .display_name = "Overworld Map",
       .window_title = " Overworld Map",
       .icon = ICON_MD_PUBLIC,
       .category = "Screen",
       .shortcut_hint = "Alt+3",
       .priority = 30,
       .enabled_condition = [this]() { return rom()->is_loaded(); },
       .disabled_tooltip = "Load a ROM first"});
  window_manager->RegisterPanel(
      {.card_id = "screen.title_screen",
       .display_name = "Title Screen",
       .window_title = " Title Screen",
       .icon = ICON_MD_TITLE,
       .category = "Screen",
       .shortcut_hint = "Alt+4",
       .priority = 40,
       .enabled_condition = [this]() { return rom()->is_loaded(); },
       .disabled_tooltip = "Load a ROM first"});
  window_manager->RegisterPanel(
      {.card_id = "screen.naming_screen",
       .display_name = "Naming Screen",
       .window_title = " Naming Screen",
       .icon = ICON_MD_EDIT,
       .category = "Screen",
       .shortcut_hint = "Alt+5",
       .priority = 50,
       .enabled_condition = [this]() { return rom()->is_loaded(); },
       .disabled_tooltip = "Load a ROM first"});
  // "screen.menu_tilemap" is registered below via RegisterWindowContent()
  // only (no RegisterPanel() literal): as an EmbeddedTool (see
  // MenuTilemapPanel::GetPresentationPolicy()), its full WindowDescriptor
  // -- including presentation/workflow/shortcut/size metadata -- is
  // derived from the panel's own virtual overrides (the post-#262
  // admission-policy pattern), not hand-duplicated here.
 
  // Register WindowContent implementations
  window_manager->RegisterWindowContent(std::make_unique<DungeonMapsPanel>(
      [this]() { DrawDungeonMapsEditor(); }));
  window_manager->RegisterWindowContent(std::make_unique<InventoryMenuPanel>(
      [this]() { DrawInventoryMenuEditor(); }));
  window_manager->RegisterWindowContent(
      std::make_unique<OverworldMapScreenPanel>(
          [this]() { DrawOverworldMapEditor(); }));
  window_manager->RegisterWindowContent(std::make_unique<TitleScreenPanel>(
      [this]() { DrawTitleScreenEditor(); }));
  window_manager->RegisterWindowContent(std::make_unique<NamingScreenPanel>(
      [this]() { DrawNamingScreenEditor(); }));
  window_manager->RegisterWindowContent(std::make_unique<MenuTilemapPanel>(
      [this]() { DrawMenuTilemapEditor(); },
      [this]() { return rom() && rom()->is_loaded(); }));
 
  // Show title screen by default
  window_manager->OpenWindow("screen.title_screen");
}
 
absl::Status ScreenEditor::Load() {
  gfx::ScopedTimer timer("ScreenEditor::Load");
  ResetRomBackedStateForLoad();
  if (!rom_ || !rom_->is_loaded() || !game_data()) {
    return absl::FailedPreconditionError(
        "Screen Editor requires a loaded ROM and GameData");
  }
  if (game_data()->palette_groups.dungeon_main.size() <= 3) {
    return absl::FailedPreconditionError(
        "Screen Editor requires dungeon palette 3");
  }
 
  ASSIGN_OR_RETURN(dungeon_maps_,
                   zelda3::LoadDungeonMaps(*rom(), dungeon_map_labels_));
  RETURN_IF_ERROR(
      zelda3::LoadDungeonMapTile16(tile16_blockset_, *rom(), game_data(),
                                   game_data()->graphics_buffer, false));
 
  // Load graphics sheets and apply dungeon palette
  // Recreate sheet contents in place. Arena commands retain Bitmap*, so the
  // unique_ptr owners must remain stable across reloads.
  for (int i = 0; i < 4; i++) {
    const auto pixels = game_data()->sheet_store.Sheet(212 + i);
    if (pixels.size() != 128 * 32) {
      return absl::FailedPreconditionError(absl::StrFormat(
          "Screen Dungeon Map sheet %d is unavailable in this ROM session",
          212 + i));
    }
    auto* sheet = GetOrCreateSheet(i);
    sheet->Create(128, 32, 8,
                  std::vector<uint8_t>(pixels.begin(), pixels.end()));
    sheet->SetPalette(
        *game_data()->palette_groups.dungeon_main.mutable_palette(3));
    gfx::Arena::Get().QueueTextureCommand(
        gfx::Arena::TextureCommandType::CREATE, sheet);
  }
 
  // Create a single tilemap for tile8 graphics with on-demand texture creation
  // Combine all 4 sheets (128x32 each) into one bitmap (128x128)
  // This gives us 16 tiles per row × 16 rows = 256 tiles total
  const int tile8_width = 128;
  const int tile8_height = 128;  // 4 sheets × 32 pixels each
  std::vector<uint8_t> tile8_data(tile8_width * tile8_height);
 
  // Copy data from all 4 sheets into the combined bitmap
  for (int sheet_idx = 0; sheet_idx < 4; sheet_idx++) {
    const auto& sheet = *sheets_[sheet_idx];
    int dest_y_offset = sheet_idx * 32;  // Each sheet is 32 pixels tall
 
    for (int y = 0; y < 32; y++) {
      for (int x = 0; x < 128; x++) {
        int src_index = y * 128 + x;
        int dest_index = (dest_y_offset + y) * 128 + x;
 
        if (src_index < sheet.size() && dest_index < tile8_data.size()) {
          tile8_data[dest_index] = sheet.data()[src_index];
        }
      }
    }
  }
 
  // Create tilemap with 8x8 tile size
  tile8_tilemap_.tile_size = {8, 8};
  tile8_tilemap_.map_size = {256, 256};  // Logical size for tile count
  tile8_tilemap_.atlas.Create(tile8_width, tile8_height, 8, tile8_data);
  tile8_tilemap_.atlas.SetPalette(
      *game_data()->palette_groups.dungeon_main.mutable_palette(3));
 
  // Queue single texture creation for the atlas (not individual tiles)
  gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
                                        &tile8_tilemap_.atlas);
  RefreshTileCacheForReload(tile16_blockset_);
  RefreshTileCacheForReload(tile8_tilemap_);
  loaded_rom_ = rom_;
  loaded_game_data_ = game_data();
  rom_backed_state_valid_ = true;
  return absl::OkStatus();
}
 
void ScreenEditor::RefreshDungeonMapGraphicsFromSession() {
  // Rebuild only the source-dependent bitmaps. Keep floor layouts, Tile16
  // composition words, undo history, and pending save flags in memory.
  if (!rom_backed_state_valid_ || binary_gfx_loaded_ || !game_data()) {
    return;
  }
  std::vector<uint8_t> atlas_pixels(128 * 128);
  for (int slot = 0; slot < 4; ++slot) {
    const auto pixels = game_data()->sheet_store.Sheet(212 + slot);
    if (pixels.size() != 128 * 32) {
      return;
    }
    std::copy(pixels.begin(), pixels.end(),
              atlas_pixels.begin() + slot * 128 * 32);
    auto* sheet = GetOrCreateSheet(slot);
    sheet->Create(128, 32, 8,
                  std::vector<uint8_t>(pixels.begin(), pixels.end()));
    sheet->SetPalette(
        *game_data()->palette_groups.dungeon_main.mutable_palette(3));
    gfx::Arena::Get().QueueTextureCommand(
        gfx::Arena::TextureCommandType::CREATE, sheet);
  }
  tile8_tilemap_.atlas.Create(128, 128, 8, atlas_pixels);
  tile8_tilemap_.atlas.SetPalette(
      *game_data()->palette_groups.dungeon_main.mutable_palette(3));
  gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
                                        &tile8_tilemap_.atlas);
  RefreshTileCacheForReload(tile8_tilemap_);
 
  // Recompose from the current in-memory Tile16 words, not the ROM table: an
  // unsaved Tile16 edit must survive the return from Graphics.
  for (size_t tile_id = 0; tile_id < tile16_blockset_.tile_info.size();
       ++tile_id) {
    const auto info = tile16_blockset_.tile_info[tile_id];
    gfx::ModifyTile16(tile16_blockset_, game_data()->graphics_buffer, info[0],
                      info[1], info[2], info[3], 212,
                      static_cast<int>(tile_id));
  }
  gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::UPDATE,
                                        &tile16_blockset_.atlas);
  RefreshTileCacheForReload(tile16_blockset_);
}
 
absl::Status ScreenEditor::OpenDungeonMapTileGraphics() {
  if (!rom_backed_state_valid_ || !rom_ || !rom_->is_loaded() || !game_data()) {
    return absl::FailedPreconditionError(
        "Screen Dungeon Map graphics are not loaded");
  }
  auto context = MakeDungeonMapTilesGfxEditContext(game_data(), selected_tile8_,
                                                   binary_gfx_loaded_);
  if (!context.ok()) {
    return context.status();
  }
  auto* manager = static_cast<EditorManager*>(dependencies_.custom_data);
  if (manager == nullptr) {
    return absl::FailedPreconditionError("Editor manager is unavailable");
  }
  auto* editor_set = manager->GetCurrentEditorSet();
  if (editor_set == nullptr || editor_set->GetGraphicsEditor() == nullptr) {
    return absl::FailedPreconditionError("Graphics editor is unavailable");
  }
  context->return_to_source = [this, manager] {
    RefreshDungeonMapGraphicsFromSession();
    manager->SwitchToEditor(EditorType::kScreen, true);
    if (dependencies_.window_manager) {
      dependencies_.window_manager->OpenWindow("screen.dungeon_maps");
    }
  };
  RETURN_IF_ERROR(manager->EnsureEditorAssetsLoaded(EditorType::kGraphics));
  RETURN_IF_ERROR(
      editor_set->GetGraphicsEditor()->OpenInContext(std::move(*context)));
  manager->SwitchToEditor(EditorType::kGraphics, true);
  return absl::OkStatus();
}
 
absl::StatusOr<zelda3::DungeonMapWritePlan>
ScreenEditor::PrepareDungeonMapSave() const {
  if (HasPendingDungeonMapTile16Changes() || HasPendingTitleScreenChanges() ||
      HasPendingOverworldMapChanges()) {
    return absl::FailedPreconditionError(
        "Save blocked: Screen Editor edits are pending in unsupported domains. "
        "Dungeon-map Tile16 artwork, title-screen, and overworld pause-map "
        "writes remain disabled; undo or discard those edits before saving.");
  }
  if (!rom_backed_state_valid_) {
    return absl::FailedPreconditionError(
        "Screen Editor ROM-backed state is invalid; reload Screen assets "
        "before saving");
  }
  if (has_pending_dungeon_undo_ || has_pending_tile16_undo_) {
    return absl::FailedPreconditionError(
        "Finish the current Screen Editor edit before saving");
  }
  if (!HasPendingDungeonMapChanges()) {
    return zelda3::DungeonMapWritePlan{};
  }
  if (!core::FeatureFlags::get().kSaveDungeonMaps) {
    return absl::FailedPreconditionError(
        "Save blocked: Screen Editor edits are pending, but Save Dungeon "
        "Maps is disabled. Enable it or undo the map edits before saving.");
  }
  if (!rom_ || !rom_->is_loaded() || loaded_rom_ != rom_ || !game_data() ||
      loaded_game_data_ != game_data()) {
    return absl::FailedPreconditionError(
        "Dungeon maps do not belong to the current ROM session; reload "
        "Screen assets before saving");
  }
  return zelda3::BuildDungeonMapWritePlan(*rom_, dungeon_maps_);
}
 
absl::Status ScreenEditor::BeginSaveTransaction() {
  if (map_save_transaction_active_) {
    return absl::FailedPreconditionError("Screen save is already in progress");
  }
  map_save_transaction_active_ = true;
  map_save_serialized_ = false;
  return absl::OkStatus();
}
 
void ScreenEditor::RollbackSaveTransaction() {
  // Save never mutates the model, history, or pending flags. The enclosing ROM
  // transaction restores bytes; there is no editor state to reconstruct.
  map_save_transaction_active_ = false;
  map_save_serialized_ = false;
}
 
void ScreenEditor::CommitSaveTransaction() {
  if (map_save_transaction_active_ && map_save_serialized_) {
    pending_dungeon_map_changes_ = false;
  }
  RollbackSaveTransaction();
}
 
absl::Status ScreenEditor::Save() {
  ASSIGN_OR_RETURN(auto plan, PrepareDungeonMapSave());
  if (plan.writes.empty()) {
    return absl::OkStatus();
  }
  RETURN_IF_ERROR(zelda3::SaveDungeonMaps(*rom_, dungeon_maps_));
  // A direct Save writes only the in-memory ROM. Only the outer file-save
  // commit may mark the editor clean; Undo/Redo remain available after it.
  map_save_serialized_ = map_save_transaction_active_;
  return absl::OkStatus();
}
 
absl::Status ScreenEditor::Update() {
  // Panel drawing is handled centrally by WorkspaceWindowManager::DrawAllVisiblePanels()
  // via the WindowContent implementations registered in Initialize().
  // No local drawing needed here - this fixes duplicate panel rendering.
  return status_;
}
 
void ScreenEditor::DrawToolset() {
  // Sidebar is now drawn by EditorManager for card-based editors
  // This method kept for compatibility but sidebar handles card toggles
}
 
void ScreenEditor::DrawInventoryMenuEditor() {
  if (!rom_backed_state_valid_) {
    ImGui::TextWrapped(
        tr("Screen assets are unavailable. Reload the active ROM before "
           "drawing or editing the inventory screen."));
    return;
  }
  if (!inventory_loaded_ && rom()->is_loaded() && game_data()) {
    status_ = inventory_->Create(rom(), game_data());
    if (status_.ok()) {
      palette_ = inventory_->palette();
      inventory_loaded_ = true;
    } else {
      const auto& theme = AgentUI::GetTheme();
      ImGui::TextColored(theme.text_error_red,
                         tr("Error loading inventory: %s"),
                         status_.message().data());
      return;
    }
  }
 
  DrawInventoryToolset();
 
  if (ImGui::BeginTable("InventoryScreen", 4, ImGuiTableFlags_Resizable)) {
    ImGui::TableSetupColumn("Canvas");
    ImGui::TableSetupColumn("Tilesheet");
    ImGui::TableSetupColumn("Item Icons");
    ImGui::TableSetupColumn("Palette");
    ImGui::TableHeadersRow();
 
    ImGui::TableNextColumn();
    {
      gui::CanvasFrameOptions frame_opts;
      frame_opts.draw_grid = true;
      frame_opts.grid_step = 32.0f;
      frame_opts.render_popups = true;
      auto runtime = gui::BeginCanvas(screen_canvas_, frame_opts);
      gui::DrawBitmap(runtime, inventory_->bitmap(), 2,
                      inventory_loaded_ ? 1.0f : 0.0f);
      gui::EndCanvas(screen_canvas_, runtime, frame_opts);
    }
 
    ImGui::TableNextColumn();
    {
      gui::CanvasFrameOptions frame_opts;
      frame_opts.canvas_size = ImVec2(128 * 2 + 2, (192 * 2) + 4);
      frame_opts.draw_grid = true;
      frame_opts.grid_step = 16.0f;
      frame_opts.render_popups = true;
      auto runtime = gui::BeginCanvas(tilesheet_canvas_, frame_opts);
      gui::DrawBitmap(runtime, inventory_->tilesheet(), 2,
                      inventory_loaded_ ? 1.0f : 0.0f);
      gui::EndCanvas(tilesheet_canvas_, runtime, frame_opts);
    }
 
    ImGui::TableNextColumn();
    DrawInventoryItemIcons();
 
    ImGui::TableNextColumn();
    gui::DisplayPalette(palette_, inventory_loaded_);
 
    ImGui::EndTable();
  }
  ImGui::Separator();
 
  // TODO(scawful): Future Oracle of Secrets menu editor integration
  // - Full inventory screen layout editor
  // - Item slot assignment and positioning
  // - Heart container and magic meter editor
  // - Equipment display customization
  // - A/B button equipment quick-select editor
}
 
void ScreenEditor::DrawInventoryToolset() {
  if (ImGui::BeginTable("InventoryToolset", 8, ImGuiTableFlags_SizingFixedFit,
                        ImVec2(0, 0))) {
    ImGui::TableSetupColumn("#drawTool");
    ImGui::TableSetupColumn("#sep1");
    ImGui::TableSetupColumn("#zoomOut");
    ImGui::TableSetupColumn("#zoomIN");
    ImGui::TableSetupColumn("#sep2");
    ImGui::TableSetupColumn("#bg2Tool");
    ImGui::TableSetupColumn("#bg3Tool");
    ImGui::TableSetupColumn("#itemTool");
 
    ImGui::TableNextColumn();
    ImGui::BeginDisabled(!undo_manager_.CanUndo());
    if (gui::ToolbarIconButton(ICON_MD_UNDO, "Undo")) {
      status_ = Undo();
    }
    ImGui::EndDisabled();
    ImGui::TableNextColumn();
    ImGui::BeginDisabled(!undo_manager_.CanRedo());
    if (gui::ToolbarIconButton(ICON_MD_REDO, "Redo")) {
      status_ = Redo();
    }
    ImGui::EndDisabled();
    ImGui::TableNextColumn();
    ImGui::Text(ICON_MD_MORE_VERT);
    ImGui::TableNextColumn();
    if (gui::ToolbarIconButton(ICON_MD_ZOOM_OUT, "Zoom Out")) {
      screen_canvas_.ZoomOut();
    }
    ImGui::TableNextColumn();
    if (gui::ToolbarIconButton(ICON_MD_ZOOM_IN, "Zoom In")) {
      screen_canvas_.ZoomIn();
    }
    ImGui::TableNextColumn();
    ImGui::Text(ICON_MD_MORE_VERT);
    ImGui::TableNextColumn();
    if (gui::ToolbarIconButton(ICON_MD_DRAW, "Draw Mode")) {
      current_mode_ = EditingMode::DRAW;
    }
    ImGui::TableNextColumn();
    if (gui::ToolbarIconButton(ICON_MD_BUILD, "Build Mode")) {
      // current_mode_ = EditingMode::BUILD;
    }
 
    ImGui::EndTable();
  }
}
 
void ScreenEditor::DrawInventoryItemIcons() {
  if (ImGui::BeginChild("##ItemIconsList", ImVec2(0, 0), true,
                        ImGuiWindowFlags_HorizontalScrollbar)) {
    ImGui::Text(tr("Item Icons (2x2 tiles each)"));
    ImGui::Separator();
 
    auto& icons = inventory_->item_icons();
    if (icons.empty()) {
      ImGui::TextWrapped(
          tr("No item icons loaded. Icons will be loaded when the "
             "inventory is initialized."));
      ImGui::EndChild();
      return;
    }
 
    // Display icons in a table format
    if (ImGui::BeginTable("##IconsTable", 2,
                          ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg)) {
      ImGui::TableSetupColumn("Icon Name");
      ImGui::TableSetupColumn("Tile Data");
      ImGui::TableHeadersRow();
 
      for (size_t i = 0; i < icons.size(); i++) {
        const auto& icon = icons[i];
 
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
 
        // Display icon name with selectable row
        if (ImGui::Selectable(icon.name.c_str(), false,
                              ImGuiSelectableFlags_SpanAllColumns)) {
          // TODO: Select this icon for editing
        }
 
        ImGui::TableNextColumn();
        // Display tile word data in hex format
        ImGui::Text(tr("TL:%04X TR:%04X"), icon.tile_tl, icon.tile_tr);
        ImGui::SameLine();
        ImGui::Text(tr("BL:%04X BR:%04X"), icon.tile_bl, icon.tile_br);
      }
 
      ImGui::EndTable();
    }
 
    ImGui::Separator();
    ImGui::TextWrapped(tr(
        "NOTE: Individual icon editing will be implemented in the future "
        "Oracle of Secrets menu editor. Each icon is composed of 4 tile words "
        "representing a 2x2 arrangement of 8x8 tiles in SNES tile format "
        "(vhopppcc cccccccc)."));
  }
  ImGui::EndChild();
}
 
void ScreenEditor::DrawDungeonMapScreen(int i) {
  gfx::ScopedTimer timer("screen_editor_draw_dungeon_map_screen");
 
  if (!rom_backed_state_valid_ || !HasValidDungeonFloorSelection(i)) {
    ImGui::TextWrapped(tr("No valid dungeon-map floor is loaded."));
    return;
  }
 
  const auto& theme = AgentUI::GetTheme();
  auto& current_dungeon = dungeon_maps_[selected_dungeon];
 
  floor_number = i;
  // The dungeon-map-screen canvas is a tile picker: read-only display of
  // dungeon room placements with click-to-select for tile16 assignment.
  screen_canvas_.GetConfig().role = gui::CanvasRole::kSelectionSource;
  screen_canvas_.DrawBackground(ImVec2(325, 325));
  screen_canvas_.DrawTileSelector(64.f);
 
  auto boss_room = current_dungeon.boss_room;
 
  // Pre-allocate vectors for batch operations
  std::vector<int> tile_ids_to_render;
  std::vector<ImVec2> tile_positions;
  tile_ids_to_render.reserve(zelda3::kNumRooms);
  tile_positions.reserve(zelda3::kNumRooms);
 
  for (int j = 0; j < zelda3::kNumRooms; j++) {
    if (current_dungeon.floor_rooms[floor_number][j] != 0x0F) {
      int tile16_id = current_dungeon.floor_gfx[floor_number][j];
      int posX = ((j % 5) * 32);
      int posY = ((j / 5) * 32);
 
      // Batch tile rendering
      tile_ids_to_render.push_back(tile16_id);
      tile_positions.emplace_back(posX * 2, posY * 2);
    }
  }
 
  // Batch render all tiles
  for (size_t idx = 0; idx < tile_ids_to_render.size(); ++idx) {
    int tile16_id = tile_ids_to_render[idx];
    ImVec2 pos = tile_positions[idx];
 
    // Extract tile data from the atlas directly
    const int tiles_per_row = tile16_blockset_.atlas.width() / 16;
    const int tiles_per_column = tile16_blockset_.atlas.height() / 16;
    if (tiles_per_row <= 0 || tiles_per_column <= 0 || tile16_id < 0 ||
        tile16_id >= tiles_per_row * tiles_per_column) {
      continue;
    }
    const int tile_x = (tile16_id % tiles_per_row) * 16;
    const int tile_y = (tile16_id / tiles_per_row) * 16;
 
    std::vector<uint8_t> tile_data(16 * 16);
    int tile_data_offset = 0;
    tile16_blockset_.atlas.Get16x16Tile(tile_x, tile_y, tile_data,
                                        tile_data_offset);
 
    // Create or update cached tile
    auto* cached_tile = tile16_blockset_.tile_cache.GetTile(tile16_id);
    if (!cached_tile) {
      // Create new cached tile
      gfx::Bitmap new_tile(16, 16, 8, tile_data);
      new_tile.SetPalette(tile16_blockset_.atlas.palette());
      tile16_blockset_.tile_cache.CacheTile(tile16_id, std::move(new_tile));
      cached_tile = tile16_blockset_.tile_cache.GetTile(tile16_id);
    } else {
      // Update existing cached tile data
      cached_tile->set_data(tile_data);
    }
 
    if (cached_tile && cached_tile->is_active()) {
      // Ensure the cached tile has a valid texture
      if (!cached_tile->texture()) {
        // Queue texture creation via Arena's deferred system
        gfx::Arena::Get().QueueTextureCommand(
            gfx::Arena::TextureCommandType::CREATE, cached_tile);
      }
      screen_canvas_.DrawBitmap(*cached_tile, pos.x, pos.y, 4.0F, 255);
    }
  }
 
  // Draw overlays and labels
  for (int j = 0; j < zelda3::kNumRooms; j++) {
    if (current_dungeon.floor_rooms[floor_number][j] != 0x0F) {
      int posX = ((j % 5) * 32);
      int posY = ((j / 5) * 32);
 
      if (current_dungeon.floor_rooms[floor_number][j] == boss_room) {
        screen_canvas_.DrawOutlineWithColor((posX * 2), (posY * 2), 64, 64,
                                            theme.status_error);
      }
 
      std::string label =
          dungeon_map_labels_[selected_dungeon][floor_number][j];
      screen_canvas_.DrawText(label, (posX * 2), (posY * 2));
      std::string gfx_id =
          util::HexByte(current_dungeon.floor_gfx[floor_number][j]);
      screen_canvas_.DrawText(gfx_id, (posX * 2), (posY * 2) + 16);
    }
  }
 
  screen_canvas_.DrawGrid(64.f, 5);
  screen_canvas_.DrawOverlay();
 
  if (!screen_canvas_.points().empty()) {
    int x = screen_canvas_.points().front().x / 64;
    int y = screen_canvas_.points().front().y / 64;
    const int room = x + (y * 5);
    if (room >= 0 && room < zelda3::kNumRooms) {
      selected_room = static_cast<uint8_t>(room);
    }
  }
}
 
void ScreenEditor::DrawDungeonMapsTabs() {
  gui::AutoWidgetScope widget_scope("Screen/DungeonMap");
  if (!rom_backed_state_valid_ || !HasValidDungeonSelection()) {
    ImGui::TextWrapped(tr("No valid dungeon map is loaded."));
    return;
  }
  auto& current_dungeon = dungeon_maps_[selected_dungeon];
  const int floor_count =
      current_dungeon.nbr_of_floor + current_dungeon.nbr_of_basement;
  if (floor_count <= 0 ||
      floor_count > static_cast<int>(current_dungeon.floor_rooms.size()) ||
      floor_count > static_cast<int>(current_dungeon.floor_gfx.size()) ||
      floor_count >
          static_cast<int>(dungeon_map_labels_[selected_dungeon].size())) {
    ImGui::TextWrapped(tr("This dungeon has no drawable map floors."));
    return;
  }
  if (!HasValidDungeonFloorSelection(floor_number)) {
    floor_number = 0;
  }
  if (selected_room >= zelda3::kNumRooms) {
    selected_room = 0;
  }
  if (gui::BeginThemedTabBar("##DungeonMapTabs")) {
    const int requested_floor = floor_number;
    for (int i = 0; i < floor_count; i++) {
      int basement_num = current_dungeon.nbr_of_basement - i;
      std::string tab_name = absl::StrFormat("Basement %d", basement_num);
      if (i >= current_dungeon.nbr_of_basement) {
        tab_name = absl::StrFormat("Floor %d",
                                   i - current_dungeon.nbr_of_basement + 1);
      }
      const auto flags = select_floor_tab_ && i == requested_floor
                             ? ImGuiTabItemFlags_SetSelected
                             : ImGuiTabItemFlags_None;
      if (ImGui::BeginTabItem(tab_name.data(), nullptr, flags)) {
        DrawDungeonMapScreen(i);
        ImGui::EndTabItem();
      }
    }
    gui::EndThemedTabBar();
    select_floor_tab_ = false;
  }
 
  {
    auto room_before = CaptureDungeonMapSnapshot();
    if (gui::InputHexByte(
            "Selected Room",
            &current_dungeon.floor_rooms[floor_number].at(selected_room))) {
      dungeon_map_labels_[selected_dungeon][floor_number][selected_room] =
          util::HexByte(
              current_dungeon.floor_rooms[floor_number][selected_room]);
      auto after = CaptureDungeonMapSnapshot();
      undo_manager_.Push(std::make_unique<ScreenEditAction>(
          room_before, after,
          [this](const ScreenSnapshot& s) { RestoreFromSnapshot(s); },
          "Edit room assignment"));
      MarkDungeonMapModified();
    }
  }
 
  {
    auto boss_before = CaptureDungeonMapSnapshot();
    if (gui::InputHexWord("Boss Room", &current_dungeon.boss_room)) {
      auto after = CaptureDungeonMapSnapshot();
      undo_manager_.Push(std::make_unique<ScreenEditAction>(
          boss_before, after,
          [this](const ScreenSnapshot& s) { RestoreFromSnapshot(s); },
          "Edit boss room"));
      MarkDungeonMapModified();
    }
  }
 
  const auto button_size = ImVec2(130, 0);
 
  if (gui::AutoButton(tr("Add Floor"), button_size)) {
    status_ = ChangeDungeonMapFloorCount(/*basement=*/false, /*add=*/true);
  }
  ImGui::SameLine();
  if (gui::AutoButton(tr("Remove Floor"), button_size)) {
    status_ = ChangeDungeonMapFloorCount(/*basement=*/false, /*add=*/false);
  }
  if (gui::AutoButton(tr("Add Basement"), button_size)) {
    status_ = ChangeDungeonMapFloorCount(/*basement=*/true, /*add=*/true);
  }
  ImGui::SameLine();
  if (gui::AutoButton(tr("Remove Basement"), button_size)) {
    status_ = ChangeDungeonMapFloorCount(/*basement=*/true, /*add=*/false);
  }
 
  if (gui::AutoButton(tr("Copy Floor"), button_size)) {
    copy_button_pressed = true;
  }
  ImGui::SameLine();
  if (gui::AutoButton(tr("Paste Floor"), button_size)) {
    paste_button_pressed = true;
  }
}
 
void ScreenEditor::DrawDungeonMapsRoomGfx() {
  gfx::ScopedTimer timer("screen_editor_draw_dungeon_maps_room_gfx");
 
  if (!rom_backed_state_valid_ ||
      !HasValidDungeonFloorSelection(floor_number) ||
      selected_room >= zelda3::kNumRooms ||
      tile16_blockset_.atlas.width() < 16 ||
      tile16_blockset_.atlas.height() < 16 ||
      tile16_blockset_.tile_info.empty() || tile8_tilemap_.atlas.width() < 8 ||
      tile8_tilemap_.atlas.height() < 8) {
    ImGui::TextWrapped(tr("Dungeon-map graphics are not ready to draw."));
    return;
  }
 
  if (ImGui::BeginChild("##DungeonMapTiles", ImVec2(0, 0), true)) {
    // Enhanced tilesheet canvas with BeginCanvas/EndCanvas pattern
    {
      gui::CanvasFrameOptions tilesheet_opts;
      tilesheet_opts.canvas_size = ImVec2((256 * 2) + 2, (192 * 2) + 4);
      tilesheet_opts.draw_grid = true;
      tilesheet_opts.grid_step = 32.0f;
      tilesheet_opts.render_popups = true;
 
      tilesheet_canvas_.GetConfig().role = gui::CanvasRole::kSelectionSource;
      auto tilesheet_rt = gui::BeginCanvas(tilesheet_canvas_, tilesheet_opts);
 
      // Interactive tile16 selector with grid snapping
      ImVec2 selected_pos;
      if (gui::DrawTileSelector(tilesheet_rt, 32, 0, &selected_pos)) {
        // Double-click detected - handle tile confirmation if needed
      }
 
      // Check for single-click selection (legacy compatibility)
      if (tilesheet_canvas_.IsMouseHovering() &&
          ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
        if (!tilesheet_canvas_.points().empty()) {
          const int selected_tile16 = static_cast<int>(
              tilesheet_canvas_.points().front().x / 32 +
              (tilesheet_canvas_.points().front().y / 32) * 16);
 
          if (selected_tile16 >= 0 &&
              selected_tile16 <
                  static_cast<int>(tile16_blockset_.tile_info.size())) {
            selected_tile16_ = selected_tile16;
            // Render selected tile16 and cache tile metadata
            gfx::RenderTile16(nullptr, tile16_blockset_, selected_tile16_);
            std::ranges::copy(tile16_blockset_.tile_info[selected_tile16_],
                              current_tile16_info.begin());
          }
        }
      }
 
      // Use stateless bitmap rendering for tilesheet
      gui::DrawBitmap(tilesheet_rt, tile16_blockset_.atlas, 1, 1, 2.0F, 255);
 
      gui::EndCanvas(tilesheet_canvas_, tilesheet_rt, tilesheet_opts);
    }
 
    if (!tilesheet_canvas_.points().empty() &&
        !screen_canvas_.points().empty()) {
      SaveDungeonMapUndoState("Place tile on dungeon map");
      dungeon_maps_[selected_dungeon].floor_gfx[floor_number][selected_room] =
          selected_tile16_;
      CommitDungeonMapUndo();
      tilesheet_canvas_.mutable_points()->clear();
    }
 
    ImGui::Separator();
 
    // Current tile canvas with BeginCanvas/EndCanvas pattern
    {
      gui::CanvasFrameOptions current_tile_opts;
      current_tile_opts.draw_grid = true;
      current_tile_opts.grid_step = 16.0f;
      current_tile_opts.render_popups = true;
 
      current_tile_canvas_.GetConfig().role = gui::CanvasRole::kPreviewOnly;
      auto current_tile_rt =
          gui::BeginCanvas(current_tile_canvas_, current_tile_opts);
 
      // Get tile8 from cache on-demand (only create texture when needed)
      if (selected_tile8_ >= 0 && selected_tile8_ < 256) {
        auto* cached_tile8 = tile8_tilemap_.tile_cache.GetTile(selected_tile8_);
 
        if (!cached_tile8) {
          // Extract tile from atlas and cache it
          const int tiles_per_row =
              tile8_tilemap_.atlas.width() / 8;  // 128 / 8 = 16
          const int tile_x = (selected_tile8_ % tiles_per_row) * 8;
          const int tile_y = (selected_tile8_ / tiles_per_row) * 8;
 
          // Extract 8x8 tile data from atlas
          std::vector<uint8_t> tile_data(64);
          for (int py = 0; py < 8; py++) {
            for (int px = 0; px < 8; px++) {
              int src_x = tile_x + px;
              int src_y = tile_y + py;
              int src_index = src_y * tile8_tilemap_.atlas.width() + src_x;
              int dst_index = py * 8 + px;
 
              if (src_index < tile8_tilemap_.atlas.size() && dst_index < 64) {
                tile_data[dst_index] = tile8_tilemap_.atlas.data()[src_index];
              }
            }
          }
 
          gfx::Bitmap new_tile8(8, 8, 8, tile_data);
          new_tile8.SetPalette(tile8_tilemap_.atlas.palette());
          tile8_tilemap_.tile_cache.CacheTile(selected_tile8_,
                                              std::move(new_tile8));
          cached_tile8 = tile8_tilemap_.tile_cache.GetTile(selected_tile8_);
        }
 
        if (cached_tile8 && cached_tile8->is_active()) {
          // Create texture on-demand only when needed
          if (!cached_tile8->texture()) {
            gfx::Arena::Get().QueueTextureCommand(
                gfx::Arena::TextureCommandType::CREATE, cached_tile8);
          }
 
          // DrawTilePainter still uses member function (not yet migrated)
          if (current_tile_canvas_.DrawTilePainter(*cached_tile8, 16)) {
            // Modify the tile16 based on the selected tile and
            // current_tile16_info
            SaveTile16CompUndoState(
                absl::StrFormat("Paint tile16 #%d", selected_tile16_));
            gfx::ModifyTile16(tile16_blockset_, game_data()->graphics_buffer,
                              current_tile16_info[0], current_tile16_info[1],
                              current_tile16_info[2], current_tile16_info[3],
                              212, selected_tile16_);
            gfx::UpdateTile16(nullptr, tile16_blockset_, selected_tile16_);
            CommitTile16CompUndo();
          }
        }
      }
 
      // Get selected tile from cache and draw with stateless helper
      auto* selected_tile =
          tile16_blockset_.tile_cache.GetTile(selected_tile16_);
      if (selected_tile && selected_tile->is_active()) {
        // Ensure the selected tile has a valid texture
        if (!selected_tile->texture()) {
          gfx::Arena::Get().QueueTextureCommand(
              gfx::Arena::TextureCommandType::CREATE, selected_tile);
        }
        gui::DrawBitmap(current_tile_rt, *selected_tile, 2, 2, 4.0f, 255);
      }
 
      gui::EndCanvas(current_tile_canvas_, current_tile_rt, current_tile_opts);
    }
 
    gui::InputTileInfo("TL", &current_tile16_info[0]);
    ImGui::SameLine();
    gui::InputTileInfo("TR", &current_tile16_info[1]);
    gui::InputTileInfo("BL", &current_tile16_info[2]);
    ImGui::SameLine();
    gui::InputTileInfo("BR", &current_tile16_info[3]);
 
    if (ImGui::Button(tr("Modify Tile16")) && selected_tile16_ >= 0 &&
        selected_tile16_ <
            static_cast<int>(tile16_blockset_.tile_info.size())) {
      SaveTile16CompUndoState(
          absl::StrFormat("Modify tile16 #%d", selected_tile16_));
      gfx::ModifyTile16(tile16_blockset_, game_data()->graphics_buffer,
                        current_tile16_info[0], current_tile16_info[1],
                        current_tile16_info[2], current_tile16_info[3], 212,
                        selected_tile16_);
      gfx::UpdateTile16(nullptr, tile16_blockset_, selected_tile16_);
      CommitTile16CompUndo();
    }
  }
  ImGui::EndChild();
}
 
void ScreenEditor::DrawDungeonMapsEditor() {
  if (!rom_backed_state_valid_) {
    ImGui::TextWrapped(
        tr("Screen assets are unavailable. Reload the active ROM before "
           "drawing or editing dungeon maps."));
    return;
  }
  if (!HasValidDungeonSelection()) {
    ImGui::TextWrapped(tr("No valid dungeon-map model is loaded."));
    return;
  }
 
  // Enhanced editing mode controls with visual feedback
  if (gui::ToolbarIconButton(ICON_MD_DRAW, "Draw Mode")) {
    current_mode_ = EditingMode::DRAW;
  }
  ImGui::SameLine();
  if (gui::ToolbarIconButton(ICON_MD_EDIT, "Edit Mode")) {
    current_mode_ = EditingMode::EDIT;
  }
  ImGui::SameLine();
  ImGui::BeginDisabled();
  gui::ToolbarIconButton(ICON_MD_SAVE, "Save dungeon map tiles");
  ImGui::EndDisabled();
  if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(
        tr("Dungeon-map Tile16 saving is disabled until it can participate in "
           "the coordinated ROM save transaction."));
  }
 
  static std::vector<std::string> dungeon_names = {
      "Sewers/Sanctuary",   "Hyrule Castle", "Eastern Palace",
      "Desert Palace",      "Tower of Hera", "Agahnim's Tower",
      "Palace of Darkness", "Swamp Palace",  "Skull Woods",
      "Thieves' Town",      "Ice Palace",    "Misery Mire",
      "Turtle Rock",        "Ganon's Tower"};
 
  if (ImGui::BeginTable("DungeonMapsTable", 4,
                        ImGuiTableFlags_Resizable |
                            ImGuiTableFlags_Reorderable |
                            ImGuiTableFlags_Hideable)) {
    ImGui::TableSetupColumn("Dungeon");
    ImGui::TableSetupColumn("Map");
    ImGui::TableSetupColumn("Rooms Gfx");
    ImGui::TableSetupColumn("Tiles Gfx");
    ImGui::TableHeadersRow();
 
    ImGui::TableNextColumn();
    const size_t dungeon_count =
        std::min(dungeon_names.size(), dungeon_maps_.size());
    for (size_t i = 0; i < dungeon_count; i++) {
      rom()->resource_label()->SelectableLabelWithNameEdit(
          selected_dungeon == static_cast<int>(i), "Dungeon Names",
          absl::StrFormat("%d", i), dungeon_names[i]);
      if (ImGui::IsItemClicked()) {
        selected_dungeon = static_cast<int>(i);
      }
    }
 
    ImGui::TableNextColumn();
    DrawDungeonMapsTabs();
 
    ImGui::TableNextColumn();
    DrawDungeonMapsRoomGfx();
 
    ImGui::TableNextColumn();
    tilemap_canvas_.GetConfig().role = gui::CanvasRole::kSelectionSource;
    tilemap_canvas_.DrawBackground();
    tilemap_canvas_.DrawContextMenu();
    tilemap_canvas_.DrawTileSelector(16);
    if (tilemap_canvas_.IsMouseHovering() &&
        ImGui::IsMouseClicked(ImGuiMouseButton_Left) &&
        !tilemap_canvas_.points().empty()) {
      // Four 128x32 sheets are displayed at 2x: 16 tiles per row, 16 rows.
      // Canvas::GetTileIdFromMousePos uses the unscaled 8px grid here, so it
      // would select a different tile than the visible 16px highlight.
      const auto point = tilemap_canvas_.points().front();
      const int x = static_cast<int>(point.x) / 16;
      const int y = static_cast<int>(point.y) / 16;
      if (x >= 0 && x < 16 && y >= 0 && y < 16) {
        selected_tile8_ = x + y * 16;
      }
    }
    tilemap_canvas_.DrawBitmapTable(sheets_);
    tilemap_canvas_.DrawGrid();
    tilemap_canvas_.DrawOverlay();
 
    ImGui::Text(tr("Selected tile8: %d"), selected_tile8_);
    ImGui::SameLine();
    if (ImGui::Button(tr("Edit selected graphics tile"))) {
      status_ = OpenDungeonMapTileGraphics();
    }
    if (!status_.ok()) {
      ImGui::TextWrapped("%s", std::string(status_.message()).c_str());
    }
    ImGui::Separator();
    ImGui::Text(tr("For use with custom inserted graphics assembly patches."));
    if (ImGui::Button(tr("Load GFX from BIN file")))
      LoadBinaryGfx();
 
    ImGui::EndTable();
  }
}
 
void ScreenEditor::LoadBinaryGfx() {
  std::string bin_file = util::FileDialogWrapper::ShowOpenFileDialog();
  if (!bin_file.empty()) {
    std::ifstream file(bin_file, std::ios::binary);
    if (file.is_open()) {
      // Read the gfx data into a buffer
      std::vector<uint8_t> bin_data((std::istreambuf_iterator<char>(file)),
                                    std::istreambuf_iterator<char>());
      if (auto converted_bin = gfx::SnesTo8bppSheet(bin_data, 4, 4);
          zelda3::LoadDungeonMapTile16(tile16_blockset_, *rom(), game_data(),
                                       converted_bin, true)
              .ok()) {
        std::vector<std::vector<uint8_t>> gfx_sheets;
        for (int i = 0; i < 4; i++) {
          gfx_sheets.emplace_back(converted_bin.begin() + (i * 0x1000),
                                  converted_bin.begin() + ((i + 1) * 0x1000));
          auto* sheet = GetOrCreateSheet(i);
          sheet->Create(128, 32, 8, gfx_sheets[i]);
          sheet->SetPalette(
              *game_data()->palette_groups.dungeon_main.mutable_palette(3));
          // Queue texture creation via Arena's deferred system
          gfx::Arena::Get().QueueTextureCommand(
              gfx::Arena::TextureCommandType::CREATE, sheet);
        }
        RefreshTileCacheForReload(tile16_blockset_);
        binary_gfx_loaded_ = true;
        MarkDungeonMapTile16Modified();
      } else {
        status_ = absl::InternalError("Failed to load dungeon map tile16");
      }
      file.close();
    }
  }
}
 
void ScreenEditor::DrawTitleScreenEditor() {
  if (!rom_backed_state_valid_) {
    ImGui::TextWrapped(
        tr("Screen assets are unavailable. Reload the active ROM before "
           "drawing or editing the title screen."));
    return;
  }
  // Initialize title screen on first draw
  if (!title_screen_loaded_ && rom()->is_loaded() && game_data()) {
    status_ = title_screen_.Create(rom(), game_data());
    if (!status_.ok()) {
      const auto& theme = AgentUI::GetTheme();
      ImGui::TextColored(theme.text_error_red,
                         tr("Error loading title screen: %s"),
                         status_.message().data());
      return;
    }
    title_screen_loaded_ = true;
  }
 
  if (!title_screen_loaded_) {
    ImGui::Text(tr("Title screen not loaded. Ensure ROM is loaded."));
    return;
  }
 
  // Toolbar with mode controls
  if (ImGui::Button(ICON_MD_DRAW)) {
    current_mode_ = EditingMode::DRAW;
  }
  ImGui::SameLine();
  ImGui::BeginDisabled();
  if (ImGui::Button(ICON_MD_SAVE)) {
    status_ = SaveTitleScreenToRom();
  }
  ImGui::EndDisabled();
  if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(
        tr("Title-screen ROM saving is disabled until write/reopen/readback "
           "verification exists."));
  }
  ImGui::SameLine();
  ImGui::Text(tr("Selected Tile: %d"), selected_title_tile16_);
 
  // Layer visibility controls
  bool prev_bg1 = show_title_bg1_;
  bool prev_bg2 = show_title_bg2_;
  ImGui::Checkbox(tr("Show BG1"), &show_title_bg1_);
  ImGui::SameLine();
  ImGui::Checkbox(tr("Show BG2"), &show_title_bg2_);
 
  // Re-render composite if visibility changed
  if (prev_bg1 != show_title_bg1_ || prev_bg2 != show_title_bg2_) {
    status_ =
        title_screen_.RenderCompositeLayer(show_title_bg1_, show_title_bg2_);
    if (status_.ok()) {
      gfx::Arena::Get().QueueTextureCommand(
          gfx::Arena::TextureCommandType::UPDATE,
          &title_screen_.composite_bitmap());
    }
  }
 
  // Layout: 2-column table (composite view + tile selector)
  if (ImGui::BeginTable("TitleScreenTable", 2,
                        ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders)) {
    ImGui::TableSetupColumn("Title Screen (Composite)");
    ImGui::TableSetupColumn("Tile Selector");
    ImGui::TableHeadersRow();
 
    // Column 1: Composite Canvas (BG1+BG2 stacked)
    ImGui::TableNextColumn();
    DrawTitleScreenCompositeCanvas();
 
    // Column 2: Blockset Selector
    ImGui::TableNextColumn();
    DrawTitleScreenBlocksetSelector();
 
    ImGui::EndTable();
  }
}
 
void ScreenEditor::DrawTitleScreenCompositeCanvas() {
  // The title-screen view stacks BG1 + BG2 into one composite bitmap; the
  // canvas is read-only relative to that output (painting goes to the BG1
  // tilemap, which then re-renders the composite). Marking both ends lets
  // tools tell composite outputs apart from editable scratchpads without
  // consulting caller convention.
  title_bg1_canvas_.GetConfig().role = gui::CanvasRole::kCompositeOutput;
  title_bg1_canvas_.DrawBackground();
  title_bg1_canvas_.DrawContextMenu();
 
  // Draw composite tilemap (BG1+BG2 stacked with transparency).
  // EnsureCompositeBitmapTextureQueued closes the A4 first-frame race: the
  // composite has its CREATE queued during TitleScreen::Create(), but if the
  // canvas draw runs before ProcessTextureQueue, texture() is still null and
  // canvas_rendering's silent guard would drop the draw. The helper also
  // pins metadata().purpose so the diagnostic log can name the bitmap.
  auto& composite_bitmap = title_screen_.composite_bitmap();
  internal::EnsureCompositeBitmapTextureQueued(composite_bitmap);
  if (composite_bitmap.is_active()) {
    title_bg1_canvas_.DrawBitmap(composite_bitmap, 0, 0, 2.0f, 255);
  }
 
  // Handle tile painting - always paint to BG1 layer
  if (current_mode_ == EditingMode::DRAW && selected_title_tile16_ >= 0) {
    if (title_bg1_canvas_.DrawTileSelector(8.0f)) {
      if (!title_bg1_canvas_.points().empty()) {
        auto click_pos = title_bg1_canvas_.points().front();
        int tile_x = static_cast<int>(click_pos.x) / 8;
        int tile_y = static_cast<int>(click_pos.y) / 8;
 
        if (tile_x >= 0 && tile_x < 32 && tile_y >= 0 && tile_y < 32) {
          int tilemap_index = tile_y * 32 + tile_x;
 
          // Create tile word: tile_id | (palette << 10) | h_flip | v_flip
          uint16_t tile_word = selected_title_tile16_ & 0x3FF;
          tile_word |= (title_palette_ & 0x07) << 10;
          if (title_h_flip_)
            tile_word |= 0x4000;
          if (title_v_flip_)
            tile_word |= 0x8000;
 
          // Update BG1 buffer and re-render both layers and composite
          title_screen_.mutable_bg1_buffer()[tilemap_index] = tile_word;
          MarkTitleScreenModified();
          status_ = title_screen_.RenderBG1Layer();
          if (status_.ok()) {
            // Update BG1 texture
            gfx::Arena::Get().QueueTextureCommand(
                gfx::Arena::TextureCommandType::UPDATE,
                &title_screen_.bg1_bitmap());
 
            // Re-render and update composite
            status_ = title_screen_.RenderCompositeLayer(show_title_bg1_,
                                                         show_title_bg2_);
            if (status_.ok()) {
              gfx::Arena::Get().QueueTextureCommand(
                  gfx::Arena::TextureCommandType::UPDATE, &composite_bitmap);
            }
          }
        }
      }
    }
  }
 
  title_bg1_canvas_.DrawGrid();
  title_bg1_canvas_.DrawOverlay();
}
 
void ScreenEditor::DrawTitleScreenBG1Canvas() {
  title_bg1_canvas_.DrawBackground();
  title_bg1_canvas_.DrawContextMenu();
 
  // Draw BG1 tilemap
  auto& bg1_bitmap = title_screen_.bg1_bitmap();
  if (bg1_bitmap.is_active()) {
    title_bg1_canvas_.DrawBitmap(bg1_bitmap, 0, 0, 2.0f, 255);
  }
 
  // Handle tile painting
  if (current_mode_ == EditingMode::DRAW && selected_title_tile16_ >= 0) {
    if (title_bg1_canvas_.DrawTileSelector(8.0f)) {
      if (!title_bg1_canvas_.points().empty()) {
        auto click_pos = title_bg1_canvas_.points().front();
        int tile_x = static_cast<int>(click_pos.x) / 8;
        int tile_y = static_cast<int>(click_pos.y) / 8;
 
        if (tile_x >= 0 && tile_x < 32 && tile_y >= 0 && tile_y < 32) {
          int tilemap_index = tile_y * 32 + tile_x;
 
          // Create tile word: tile_id | (palette << 10) | h_flip | v_flip
          uint16_t tile_word = selected_title_tile16_ & 0x3FF;
          tile_word |= (title_palette_ & 0x07) << 10;
          if (title_h_flip_)
            tile_word |= 0x4000;
          if (title_v_flip_)
            tile_word |= 0x8000;
 
          // Update buffer and re-render
          title_screen_.mutable_bg1_buffer()[tilemap_index] = tile_word;
          MarkTitleScreenModified();
          status_ = title_screen_.RenderBG1Layer();
          if (status_.ok()) {
            gfx::Arena::Get().QueueTextureCommand(
                gfx::Arena::TextureCommandType::UPDATE, &bg1_bitmap);
          }
        }
      }
    }
  }
 
  title_bg1_canvas_.DrawGrid(8.0f);
  title_bg1_canvas_.DrawOverlay();
}
 
void ScreenEditor::DrawTitleScreenBG2Canvas() {
  title_bg2_canvas_.GetConfig().role = gui::CanvasRole::kEditableScratchpad;
  title_bg2_canvas_.DrawBackground();
  title_bg2_canvas_.DrawContextMenu();
 
  // Draw BG2 tilemap
  auto& bg2_bitmap = title_screen_.bg2_bitmap();
  if (bg2_bitmap.is_active()) {
    title_bg2_canvas_.DrawBitmap(bg2_bitmap, 0, 0, 2.0f, 255);
  }
 
  // Handle tile painting
  if (current_mode_ == EditingMode::DRAW && selected_title_tile16_ >= 0) {
    if (title_bg2_canvas_.DrawTileSelector(8.0f)) {
      if (!title_bg2_canvas_.points().empty()) {
        auto click_pos = title_bg2_canvas_.points().front();
        int tile_x = static_cast<int>(click_pos.x) / 8;
        int tile_y = static_cast<int>(click_pos.y) / 8;
 
        if (tile_x >= 0 && tile_x < 32 && tile_y >= 0 && tile_y < 32) {
          int tilemap_index = tile_y * 32 + tile_x;
 
          // Create tile word: tile_id | (palette << 10) | h_flip | v_flip
          uint16_t tile_word = selected_title_tile16_ & 0x3FF;
          tile_word |= (title_palette_ & 0x07) << 10;
          if (title_h_flip_)
            tile_word |= 0x4000;
          if (title_v_flip_)
            tile_word |= 0x8000;
 
          // Update buffer and re-render
          title_screen_.mutable_bg2_buffer()[tilemap_index] = tile_word;
          MarkTitleScreenModified();
          status_ = title_screen_.RenderBG2Layer();
          if (status_.ok()) {
            gfx::Arena::Get().QueueTextureCommand(
                gfx::Arena::TextureCommandType::UPDATE, &bg2_bitmap);
          }
        }
      }
    }
  }
 
  title_bg2_canvas_.DrawGrid(8.0f);
  title_bg2_canvas_.DrawOverlay();
}
 
void ScreenEditor::DrawTitleScreenBlocksetSelector() {
  title_blockset_canvas_.GetConfig().role = gui::CanvasRole::kSelectionSource;
  title_blockset_canvas_.DrawBackground();
  title_blockset_canvas_.DrawContextMenu();
 
  // Draw tile8 bitmap (8x8 tiles used to compose tile16)
  auto& tiles8_bitmap = title_screen_.tiles8_bitmap();
  if (tiles8_bitmap.is_active()) {
    title_blockset_canvas_.DrawBitmap(tiles8_bitmap, 0, 0, 2.0f, 255);
  }
 
  // Handle tile selection (8x8 tiles)
  if (title_blockset_canvas_.DrawTileSelector(8.0f)) {
    // Calculate selected tile ID from click position
    if (!title_blockset_canvas_.points().empty()) {
      auto click_pos = title_blockset_canvas_.points().front();
      int tile_x = static_cast<int>(click_pos.x) / 8;
      int tile_y = static_cast<int>(click_pos.y) / 8;
      int tiles_per_row = 128 / 8;  // 16 tiles per row for 8x8 tiles
      selected_title_tile16_ = tile_x + (tile_y * tiles_per_row);
    }
  }
 
  title_blockset_canvas_.DrawGrid(8.0f);
  title_blockset_canvas_.DrawOverlay();
 
  // Show selected tile preview and controls
  if (selected_title_tile16_ >= 0) {
    ImGui::Text(tr("Selected Tile: %d"), selected_title_tile16_);
 
    // Flip controls
    ImGui::Checkbox(tr("H Flip"), &title_h_flip_);
    ImGui::SameLine();
    ImGui::Checkbox(tr("V Flip"), &title_v_flip_);
 
    // Palette selector (0-7 for 3BPP graphics)
    ImGui::SetNextItemWidth(100);
    ImGui::SliderInt(tr("Palette"), &title_palette_, 0, 7);
  }
}
 
void ScreenEditor::DrawNamingScreenEditor() {}
 
void ScreenEditor::DrawMenuTilemapEditor() {
  menu_tilemap_ui_.Draw(rom(), game_data(), project(), &undo_manager_);
}
 
EditorContextSnapshot ScreenEditor::BuildContextSnapshot() const {
  EditorContextSnapshot snapshot = Editor::BuildContextSnapshot();
  if (menu_tilemap_ui_.loaded()) {
    snapshot.metadata.push_back(
        {.id = "menu_tilemap_file",
         .label = "Menu tilemap",
         .value = util::GetFileName(menu_tilemap_ui_.current_path())});
    if (menu_tilemap_ui_.dirty()) {
      snapshot.has_pending_changes = true;
      snapshot.pending_label = "Menu tilemap has unsaved edits";
    }
  }
  return snapshot;
}
 
void ScreenEditor::DrawOverworldMapEditor() {
  if (!rom_backed_state_valid_) {
    ImGui::TextWrapped(
        tr("Screen assets are unavailable. Reload the active ROM before "
           "drawing or editing the pause-map screen."));
    return;
  }
  // Initialize overworld map on first draw
  if (!ow_map_loaded_ && rom()->is_loaded()) {
    status_ = ow_map_screen_.Create(rom());
    if (!status_.ok()) {
      const auto& theme = AgentUI::GetTheme();
      ImGui::TextColored(theme.text_error_red,
                         tr("Error loading overworld map: %s"),
                         status_.message().data());
      return;
    }
    ow_map_loaded_ = true;
  }
 
  if (!ow_map_loaded_) {
    ImGui::Text(tr("Overworld map not loaded. Ensure ROM is loaded."));
    return;
  }
 
  // Toolbar with mode controls. Keep this explicit: beta users confused this
  // panel with the main Overworld Editor, but it edits the pause-menu world map
  // art.
  if (ImGui::Button(tr("Paint Mode"))) {
    current_mode_ = EditingMode::DRAW;
  }
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(tr(
        "Paint the pause-menu world map: choose an 8x8 tile in Tileset, then "
        "click Map Canvas."));
  }
  ImGui::SameLine();
  ImGui::BeginDisabled();
  if (ImGui::Button(tr("Save World Map"))) {
    status_ = SaveOverworldMapToRom();
  }
  ImGui::EndDisabled();
  if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(tr(
        "Pause-map ROM saving is disabled until Light World, Dark World, and "
        "palette writes pass write/reopen/readback verification."));
  }
  ImGui::SameLine();
 
  // World toggle
  if (ImGui::Button(ow_show_dark_world_ ? "Dark World" : "Light World")) {
    ow_show_dark_world_ = !ow_show_dark_world_;
    // Re-render map with new world
    status_ = ow_map_screen_.RenderMapLayer(ow_show_dark_world_);
    if (status_.ok()) {
      gfx::Arena::Get().QueueTextureCommand(
          gfx::Arena::TextureCommandType::UPDATE, &ow_map_screen_.map_bitmap());
    }
  }
  ImGui::SameLine();
 
  // Custom map load/save buttons
  if (ImGui::Button(tr("Load Custom Map..."))) {
    std::string path = util::FileDialogWrapper::ShowOpenFileDialog();
    if (!path.empty()) {
      status_ = ow_map_screen_.LoadCustomMap(path);
      if (!status_.ok()) {
        ImGui::OpenPopup("CustomMapLoadError");
      } else {
        MarkOverworldMapModified();
      }
    }
  }
  ImGui::SameLine();
  if (ImGui::Button(tr("Save Custom Map..."))) {
    std::string path = util::FileDialogWrapper::ShowSaveFileDialog();
    if (!path.empty()) {
      status_ = ow_map_screen_.SaveCustomMap(path, ow_show_dark_world_);
      if (status_.ok()) {
        ImGui::OpenPopup("CustomMapSaveSuccess");
      }
    }
  }
 
  ImGui::SameLine();
  ImGui::Text(tr("Selected Tile: %d"), selected_ow_tile_);
 
  ImGui::TextWrapped(tr(
      "This edits the pause-menu world map art, not the 160 playable "
      "overworld areas. For area-map painting, entrances, exits, items, and "
      "sprites, use Overworld Editor. Paint flow here: pick an 8x8 tile from "
      "Tileset, then click Map Canvas; use Light/Dark World to choose the "
      "target map."));
  ImGui::Separator();
 
  // Custom map error/success popups
  if (ImGui::BeginPopup("CustomMapLoadError")) {
    ImGui::Text(tr("Error loading custom map: %s"), status_.message().data());
    ImGui::EndPopup();
  }
  if (ImGui::BeginPopup("CustomMapSaveSuccess")) {
    ImGui::Text(tr("Custom map saved successfully!"));
    ImGui::EndPopup();
  }
 
  // Layout: 3-column table
  if (ImGui::BeginTable("OWMapTable", 3,
                        ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders)) {
    ImGui::TableSetupColumn("Map Canvas");
    ImGui::TableSetupColumn("Tileset");
    ImGui::TableSetupColumn("Palette");
    ImGui::TableHeadersRow();
 
    // Column 1: Map Canvas
    ImGui::TableNextColumn();
    ow_map_canvas_.GetConfig().role = gui::CanvasRole::kPreviewOnly;
    ow_map_canvas_.DrawBackground();
    ow_map_canvas_.DrawContextMenu();
 
    auto& map_bitmap = ow_map_screen_.map_bitmap();
    if (map_bitmap.is_active()) {
      ow_map_canvas_.DrawBitmap(map_bitmap, 0, 0, 1.0f, 255);
    }
 
    // Handle tile painting
    if (current_mode_ == EditingMode::DRAW && selected_ow_tile_ >= 0) {
      if (ow_map_canvas_.DrawTileSelector(8.0f)) {
        if (!ow_map_canvas_.points().empty()) {
          auto click_pos = ow_map_canvas_.points().front();
          int tile_x = static_cast<int>(click_pos.x) / 8;
          int tile_y = static_cast<int>(click_pos.y) / 8;
 
          if (tile_x >= 0 && tile_x < 64 && tile_y >= 0 && tile_y < 64) {
            int tile_index = tile_x + (tile_y * 64);
 
            // Update appropriate world's tile data
            if (ow_show_dark_world_) {
              ow_map_screen_.mutable_dw_tiles()[tile_index] = selected_ow_tile_;
            } else {
              ow_map_screen_.mutable_lw_tiles()[tile_index] = selected_ow_tile_;
            }
            MarkOverworldMapModified();
 
            // Re-render map
            status_ = ow_map_screen_.RenderMapLayer(ow_show_dark_world_);
            if (status_.ok()) {
              gfx::Arena::Get().QueueTextureCommand(
                  gfx::Arena::TextureCommandType::UPDATE, &map_bitmap);
            }
          }
        }
      }
    }
 
    ow_map_canvas_.DrawGrid(8.0f);
    ow_map_canvas_.DrawOverlay();
 
    // Column 2: Tileset Selector
    ImGui::TableNextColumn();
    ow_tileset_canvas_.GetConfig().role = gui::CanvasRole::kSelectionSource;
    ow_tileset_canvas_.DrawBackground();
    ow_tileset_canvas_.DrawContextMenu();
 
    auto& tiles8_bitmap = ow_map_screen_.tiles8_bitmap();
    if (tiles8_bitmap.is_active()) {
      ow_tileset_canvas_.DrawBitmap(tiles8_bitmap, 0, 0, 2.0f, 255);
    }
 
    // Handle tile selection
    if (ow_tileset_canvas_.DrawTileSelector(8.0f)) {
      if (!ow_tileset_canvas_.points().empty()) {
        auto click_pos = ow_tileset_canvas_.points().front();
        int tile_x = static_cast<int>(click_pos.x) / 8;
        int tile_y = static_cast<int>(click_pos.y) / 8;
        selected_ow_tile_ = tile_x + (tile_y * 16);  // 16 tiles per row
      }
    }
 
    ow_tileset_canvas_.DrawGrid(8.0f);
    ow_tileset_canvas_.DrawOverlay();
 
    // Column 3: Palette Display
    ImGui::TableNextColumn();
    auto& palette = ow_show_dark_world_ ? ow_map_screen_.dw_palette()
                                        : ow_map_screen_.lw_palette();
    // Use inline palette editor for full 128-color palette
    const auto palette_before = palette;
    gui::InlinePaletteEditor(palette, "Overworld Map Palette");
    if (palette != palette_before) {
      MarkOverworldMapPaletteModified();
    }
 
    ImGui::EndTable();
  }
}
 
void ScreenEditor::DrawDungeonMapToolset() {
  static bool show_bg1 = true;
  static bool show_bg2 = true;
  static bool show_bg3 = true;
 
  static bool drawing_bg1 = true;
  static bool drawing_bg2 = false;
  static bool drawing_bg3 = false;
 
  ImGui::Checkbox(tr("Show BG1"), &show_bg1);
  ImGui::SameLine();
  ImGui::Checkbox(tr("Show BG2"), &show_bg2);
 
  ImGui::Checkbox(tr("Draw BG1"), &drawing_bg1);
  ImGui::SameLine();
  ImGui::Checkbox(tr("Draw BG2"), &drawing_bg2);
  ImGui::SameLine();
  ImGui::Checkbox(tr("Draw BG3"), &drawing_bg3);
}
 
// ---------------------------------------------------------------------------
// Undo/redo helpers
// ---------------------------------------------------------------------------
 
absl::Status ScreenEditor::ChangeDungeonMapFloorCount(bool basement, bool add) {
  if (!rom_backed_state_valid_ || !HasValidDungeonSelection() ||
      has_pending_dungeon_undo_ || has_pending_tile16_undo_) {
    return absl::FailedPreconditionError("Dungeon map edit is unavailable");
  }
  auto& map = dungeon_maps_[selected_dungeon];
  auto& labels = dungeon_map_labels_[selected_dungeon];
  const size_t total = map.nbr_of_basement + map.nbr_of_floor;
  const int count = basement ? map.nbr_of_basement : map.nbr_of_floor;
  if (map.floor_rooms.size() != total || map.floor_gfx.size() != total ||
      labels.size() != total) {
    return absl::InvalidArgumentError(
        "Dungeon map floor vectors are inconsistent");
  }
  if ((add && count >= 8) || (!add && (count == 0 || total <= 1))) {
    return absl::FailedPreconditionError(
        "Keep at least one map floor and at most eight floors of each type");
  }
  const size_t index = basement ? 0 : (add ? total : total - 1);
  if (!add && map.boss_room != 0x000F && map.boss_room != 0xFFFF) {
    const auto& rooms = map.floor_rooms[index];
    if (std::find(rooms.begin(), rooms.end(), map.boss_room) != rooms.end()) {
      return absl::FailedPreconditionError(
          "Move or clear the boss before removing its map floor");
    }
  }
  // All refusal paths precede history/model changes. Basement insertion/removal
  // acts on the deepest row; upper floors act on the last row.
  SaveDungeonMapUndoState(
      add ? (basement ? "Add basement" : "Add floor")
          : (basement ? "Remove basement" : "Remove floor"));
  if (add) {
    std::array<uint8_t, zelda3::kNumRooms> rooms, graphics;
    std::array<std::string, zelda3::kNumRooms> row_labels;
    rooms.fill(0x0F);
    graphics.fill(0xFF);
    row_labels.fill(util::HexByte(0x0F));
    map.floor_rooms.insert(map.floor_rooms.begin() + index, rooms);
    map.floor_gfx.insert(map.floor_gfx.begin() + index, graphics);
    labels.insert(labels.begin() + index, row_labels);
    if (basement && total > 0)
      ++floor_number;
  } else {
    map.floor_rooms.erase(map.floor_rooms.begin() + index);
    map.floor_gfx.erase(map.floor_gfx.begin() + index);
    labels.erase(labels.begin() + index);
    if (basement)
      --floor_number;
  }
  auto& changed_count = basement ? map.nbr_of_basement : map.nbr_of_floor;
  changed_count += add ? 1 : -1;
  floor_number =
      std::clamp(floor_number, 0, static_cast<int>(map.floor_rooms.size()) - 1);
  select_floor_tab_ = true;
  CommitDungeonMapUndo();
  return absl::OkStatus();
}
 
ScreenSnapshot ScreenEditor::CaptureDungeonMapSnapshot() const {
  ScreenSnapshot snap;
  snap.edit_type = ScreenEditType::kDungeonMap;
  snap.dungeon_map.dungeon_index = selected_dungeon;
  snap.dungeon_map.floor_index = floor_number;
  if (selected_dungeon >= 0 &&
      selected_dungeon < static_cast<int>(dungeon_maps_.size())) {
    snap.dungeon_map.map_data = dungeon_maps_[selected_dungeon];
    snap.dungeon_map.labels = dungeon_map_labels_[selected_dungeon];
  }
  return snap;
}
 
ScreenSnapshot ScreenEditor::CaptureTile16CompSnapshot() const {
  ScreenSnapshot snap;
  snap.edit_type = ScreenEditType::kTile16Edit;
  snap.tile16_comp.tile16_id = selected_tile16_;
  snap.tile16_comp.tile_info = current_tile16_info;
  return snap;
}
 
void ScreenEditor::SaveDungeonMapUndoState(const std::string& description) {
  pending_dungeon_before_ = CaptureDungeonMapSnapshot();
  pending_dungeon_desc_ = description;
  has_pending_dungeon_undo_ = true;
}
 
void ScreenEditor::SaveTile16CompUndoState(const std::string& description) {
  pending_tile16_before_ = CaptureTile16CompSnapshot();
  pending_tile16_desc_ = description;
  has_pending_tile16_undo_ = true;
}
 
void ScreenEditor::CommitDungeonMapUndo() {
  if (!has_pending_dungeon_undo_)
    return;
  has_pending_dungeon_undo_ = false;
 
  auto after = CaptureDungeonMapSnapshot();
  undo_manager_.Push(std::make_unique<ScreenEditAction>(
      pending_dungeon_before_, after,
      [this](const ScreenSnapshot& snap) { RestoreFromSnapshot(snap); },
      pending_dungeon_desc_));
  MarkDungeonMapModified();
}
 
void ScreenEditor::CommitTile16CompUndo() {
  if (!has_pending_tile16_undo_)
    return;
  has_pending_tile16_undo_ = false;
 
  auto after = CaptureTile16CompSnapshot();
  undo_manager_.Push(std::make_unique<ScreenEditAction>(
      pending_tile16_before_, after,
      [this](const ScreenSnapshot& snap) { RestoreFromSnapshot(snap); },
      pending_tile16_desc_));
  MarkDungeonMapTile16Modified();
}
 
void ScreenEditor::RestoreFromSnapshot(const ScreenSnapshot& snapshot) {
  switch (snapshot.edit_type) {
    case ScreenEditType::kDungeonMap: {
      int idx = snapshot.dungeon_map.dungeon_index;
      if (idx >= 0 && idx < static_cast<int>(dungeon_maps_.size())) {
        dungeon_maps_[idx] = snapshot.dungeon_map.map_data;
        dungeon_map_labels_[idx] = snapshot.dungeon_map.labels;
        selected_dungeon = idx;
        floor_number = std::clamp(
            snapshot.dungeon_map.floor_index, 0,
            std::max(
                0,
                static_cast<int>(dungeon_maps_[idx].floor_rooms.size()) - 1));
        select_floor_tab_ = true;
        MarkDungeonMapModified();
      }
      break;
    }
    case ScreenEditType::kTile16Edit: {
      selected_tile16_ = snapshot.tile16_comp.tile16_id;
      current_tile16_info = snapshot.tile16_comp.tile_info;
      // Re-apply tile16 composition to the blockset
      if (game_data()) {
        gfx::ModifyTile16(tile16_blockset_, game_data()->graphics_buffer,
                          current_tile16_info[0], current_tile16_info[1],
                          current_tile16_info[2], current_tile16_info[3], 212,
                          selected_tile16_);
        gfx::UpdateTile16(nullptr, tile16_blockset_, selected_tile16_);
      }
      MarkDungeonMapTile16Modified();
      break;
    }
  }
}
 
absl::Status ScreenEditor::SaveTitleScreenToRom() {
  return absl::FailedPreconditionError(
      "Title-screen ROM saving is disabled until write/reopen/readback "
      "verification exists");
}
 
absl::Status ScreenEditor::SaveOverworldMapToRom() {
  return absl::FailedPreconditionError(
      "Pause-map ROM saving is disabled until Light World, Dark World, and "
      "palette writes pass write/reopen/readback verification");
}
 
void ScreenEditor::InvalidateRomBackedState() {
  ResetRomBackedStateForLoad();
}
 
absl::Status ScreenEditor::RefreshRomBackedState() {
  return Load();
}
 
gfx::Bitmap* ScreenEditor::GetOrCreateSheet(int index) {
  auto& sheet = sheets_[index];
  if (!sheet) {
    sheet = std::make_unique<gfx::Bitmap>();
  }
  return sheet.get();
}
 
void ScreenEditor::RefreshTileCacheForReload(gfx::Tilemap& tilemap) {
  if (tilemap.tile_size.x <= 0 || tilemap.tile_size.y <= 0) {
    return;
  }
  for (auto& [tile_id, bitmap] : tilemap.tile_cache.cache_) {
    if (!bitmap) {
      continue;
    }
    auto data = gfx::GetTilemapData(tilemap, tile_id);
    bitmap->Create(tilemap.tile_size.x, tilemap.tile_size.y, 8, data);
    bitmap->SetPalette(tilemap.atlas.palette());
    gfx::Arena::Get().QueueTextureCommand(
        gfx::Arena::TextureCommandType::CREATE, bitmap.get());
  }
}
 
bool ScreenEditor::HasValidDungeonSelection() const {
  return selected_dungeon >= 0 &&
         selected_dungeon < static_cast<int>(dungeon_maps_.size()) &&
         selected_dungeon < static_cast<int>(dungeon_map_labels_.size());
}
 
bool ScreenEditor::HasValidDungeonFloorSelection(int floor) const {
  if (!HasValidDungeonSelection() || floor < 0) {
    return false;
  }
  const auto& dungeon = dungeon_maps_[selected_dungeon];
  return floor < static_cast<int>(dungeon.floor_rooms.size()) &&
         floor < static_cast<int>(dungeon.floor_gfx.size()) &&
         floor < static_cast<int>(dungeon_map_labels_[selected_dungeon].size());
}
 
void ScreenEditor::ResetRomBackedStateForLoad() {
  rom_backed_state_valid_ = false;
  loaded_rom_ = nullptr;
  loaded_game_data_ = nullptr;
  RollbackSaveTransaction();
  select_floor_tab_ = true;
  dungeon_maps_.clear();
  for (auto& labels : dungeon_map_labels_) {
    labels.clear();
  }
 
  undo_manager_.Clear();
  has_pending_dungeon_undo_ = false;
  has_pending_tile16_undo_ = false;
  pending_dungeon_before_ = ScreenSnapshot{};
  pending_tile16_before_ = ScreenSnapshot{};
  pending_dungeon_desc_.clear();
  pending_tile16_desc_.clear();
  pending_dungeon_map_changes_ = false;
  pending_dungeon_map_tile16_changes_ = false;
  pending_title_screen_changes_ = false;
  pending_overworld_map_changes_ = false;
  pending_overworld_map_palette_changes_ = false;
 
  binary_gfx_loaded_ = false;
  inventory_loaded_ = false;
  title_screen_loaded_ = false;
  ow_map_loaded_ = false;
  inventory_->ResetForReload();
  title_screen_.ResetForReload();
  ow_map_screen_.ResetForReload();
  palette_.clear();
  tile16_blockset_.tile_info.clear();
  tile16_blockset_.tile_size = {0, 0};
  tile16_blockset_.map_size = {0, 0};
  tile8_tilemap_.tile_info.clear();
  tile8_tilemap_.tile_size = {0, 0};
  tile8_tilemap_.map_size = {0, 0};
 
  selected_room = 0;
  selected_tile16_ = 0;
  selected_tile8_ = 0;
  selected_dungeon = 0;
  floor_number = 0;
  copy_button_pressed = false;
  paste_button_pressed = false;
  current_mode_ = EditingMode::DRAW;
  selected_title_tile16_ = 0;
  title_h_flip_ = false;
  title_v_flip_ = false;
  title_palette_ = 0;
  show_title_bg1_ = true;
  show_title_bg2_ = true;
  selected_ow_tile_ = 0;
  ow_show_dark_world_ = false;
  for (auto* canvas :
       {&current_tile_canvas_, &screen_canvas_, &tilesheet_canvas_,
        &tilemap_canvas_, &title_bg1_canvas_, &title_bg2_canvas_,
        &title_blockset_canvas_, &ow_map_canvas_, &ow_tileset_canvas_}) {
    canvas->ClearSelection();
  }
  current_tile16_info = {};
  status_ = absl::OkStatus();
}
 
}  // namespace editor
}  // namespace yaze