object_editor_panel.cc

Go to the documentation of this file.

// Related header
#include "object_editor_panel.h"
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
 
// Third-party library headers
#include "absl/strings/str_format.h"
#include "editor/dungeon/dungeon_canvas_viewer.h"
#include "gfx/types/snes_palette.h"
#include "imgui/imgui.h"
 
// Project headers
#include "app/editor/agent/agent_ui_theme.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/style_guard.h"
#include "app/gui/core/ui_helpers.h"
#include "app/gui/widgets/themed_widgets.h"
#include "rom/rom.h"
#include "zelda3/dungeon/door_types.h"
#include "zelda3/dungeon/dungeon_limits.h"
#include "zelda3/dungeon/dungeon_object_editor.h"
#include "zelda3/dungeon/dungeon_validator.h"
#include "zelda3/dungeon/object_drawer.h"
#include "zelda3/dungeon/object_layer_semantics.h"
#include "zelda3/dungeon/object_parser.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze {
namespace editor {
 
ObjectEditorPanel::ObjectEditorPanel(
    gfx::IRenderer* renderer, Rom* rom, DungeonCanvasViewer* canvas_viewer,
    std::shared_ptr<zelda3::DungeonObjectEditor> object_editor)
    : renderer_(renderer),
      rom_(rom),
      canvas_viewer_(canvas_viewer),
      object_selector_(rom),
      object_editor_(object_editor) {
  emulator_preview_.Initialize(renderer, rom);
 
  // Initialize object parser for static editor info lookup
  if (rom) {
    object_parser_ = std::make_unique<zelda3::ObjectParser>(rom);
  }
 
  // Wire up object selector callback
  object_selector_.SetObjectSelectedCallback(
      [this](const zelda3::RoomObject& obj) {
        preview_object_ = obj;
        has_preview_object_ = true;
        if (canvas_viewer_) {
          canvas_viewer_->SetPreviewObject(preview_object_);
          canvas_viewer_->SetObjectInteractionEnabled(true);
        }
 
        // Sync with backend editor if available
        if (object_editor_) {
          object_editor_->SetMode(zelda3::DungeonObjectEditor::Mode::kInsert);
          object_editor_->SetCurrentObjectType(obj.id_);
        }
      });
 
  // Wire up double-click callback for static object editor
  object_selector_.SetObjectDoubleClickCallback(
      [this](int obj_id) { OpenStaticObjectEditor(obj_id); });
 
  // Wire up selection change callback for property panel sync
  SetupSelectionCallbacks();
}
 
void ObjectEditorPanel::SetupSelectionCallbacks() {
  if (!canvas_viewer_ || selection_callbacks_setup_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  interaction.SetSelectionChangeCallback([this]() { OnSelectionChanged(); });
 
  selection_callbacks_setup_ = true;
}
 
void ObjectEditorPanel::OnSelectionChanged() {
  if (!canvas_viewer_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  cached_selection_count_ = interaction.GetSelectionCount();
 
  // Sync with backend editor if available
  if (object_editor_) {
    auto indices = interaction.GetSelectedObjectIndices();
    // Clear backend selection first
    (void)object_editor_->ClearSelection();
 
    // Add each selected index to backend
    for (size_t idx : indices) {
      (void)object_editor_->AddToSelection(idx);
    }
  }
}
 
void ObjectEditorPanel::Draw(bool* p_open) {
  const auto& theme = AgentUI::GetTheme();
  const int max_objects = static_cast<int>(zelda3::kMaxTileObjects);
  const int max_sprites = static_cast<int>(zelda3::kMaxTotalSprites);
  const int max_doors = static_cast<int>(zelda3::kMaxDoors);
 
  // Check if placement was blocked by ROM limits
  if (canvas_viewer_) {
    auto& coordinator =
        canvas_viewer_->object_interaction().entity_coordinator();
 
    auto& tile_handler = coordinator.tile_handler();
    if (tile_handler.was_placement_blocked()) {
      const auto reason = tile_handler.placement_block_reason();
      tile_handler.clear_placement_blocked();
      switch (reason) {
        case TileObjectHandler::PlacementBlockReason::kObjectLimit:
          SetPlacementError(absl::StrFormat(
              "Object limit reached (%d max) - placement blocked",
              max_objects));
          break;
        case TileObjectHandler::PlacementBlockReason::kInvalidRoom:
          SetPlacementError("Invalid room target - placement blocked");
          break;
        case TileObjectHandler::PlacementBlockReason::kNone:
        default:
          SetPlacementError("Object placement blocked");
          break;
      }
    }
 
    auto& sprite_handler = coordinator.sprite_handler();
    if (sprite_handler.was_placement_blocked()) {
      const auto reason = sprite_handler.placement_block_reason();
      sprite_handler.clear_placement_blocked();
      switch (reason) {
        case SpriteInteractionHandler::PlacementBlockReason::kSpriteLimit:
          SetPlacementError(absl::StrFormat(
              "Sprite limit reached (%d max) - placement blocked",
              max_sprites));
          break;
        case SpriteInteractionHandler::PlacementBlockReason::kInvalidRoom:
          SetPlacementError("Invalid room target - sprite placement blocked");
          break;
        case SpriteInteractionHandler::PlacementBlockReason::kNone:
        default:
          SetPlacementError("Sprite placement blocked");
          break;
      }
    }
 
    auto& door_handler = coordinator.door_handler();
    if (door_handler.was_placement_blocked()) {
      const auto reason = door_handler.placement_block_reason();
      door_handler.clear_placement_blocked();
      switch (reason) {
        case DoorInteractionHandler::PlacementBlockReason::kDoorLimit:
          SetPlacementError(absl::StrFormat(
              "Door limit reached (%d max) - placement blocked", max_doors));
          break;
        case DoorInteractionHandler::PlacementBlockReason::kInvalidPosition:
          SetPlacementError("Invalid door position - must be near a wall");
          break;
        case DoorInteractionHandler::PlacementBlockReason::kInvalidRoom:
          SetPlacementError("Invalid room target - door placement blocked");
          break;
        case DoorInteractionHandler::PlacementBlockReason::kNone:
        default:
          SetPlacementError("Door placement blocked");
          break;
      }
    }
  }
 
  // Room validation bar (object/sprite/door/chest counts)
  DrawRoomValidationBar();
 
  // Door Section (Collapsible)
  if (ImGui::CollapsingHeader(ICON_MD_DOOR_FRONT " Doors",
                              ImGuiTreeNodeFlags_DefaultOpen)) {
    DrawDoorSection();
  }
 
  ImGui::Separator();
 
  // Object Browser - takes up available space
  float available_height = ImGui::GetContentRegionAvail().y;
  // Reserve space for status indicator at bottom
  float reserved_height = 60.0f;
  // Reduce browser height when static editor is open to give it more space
  if (static_editor_open_) {
    reserved_height += 200.0f;
  }
  float browser_height = std::max(150.0f, available_height - reserved_height);
 
  ImGui::BeginChild("ObjectBrowserRegion", ImVec2(0, browser_height), true);
  DrawObjectSelector();
  ImGui::EndChild();
 
  ImGui::Separator();
 
  // Static Object Editor (if open)
  if (static_editor_open_) {
    DrawStaticObjectEditor();
    ImGui::Separator();
  }
 
  // Status indicator: show current interaction state
  {
    bool is_placing = has_preview_object_ && canvas_viewer_ &&
                      canvas_viewer_->object_interaction().IsObjectLoaded();
    if (!is_placing && has_preview_object_) {
      has_preview_object_ = false;
    }
    if (is_placing) {
      ImGui::TextColored(theme.status_warning,
                         ICON_MD_ADD_CIRCLE " Placing: Object 0x%02X",
                         preview_object_.id_);
      ImGui::SameLine();
      if (ImGui::SmallButton(ICON_MD_CANCEL " Cancel")) {
        CancelPlacement();
      }
    } else {
      ImGui::TextColored(
          theme.text_secondary_gray, ICON_MD_MOUSE
          " Selection Mode - Click to select, drag to multi-select");
      ImGui::SameLine();
      if (ImGui::SmallButton(ICON_MD_HELP_OUTLINE " ?")) {
        show_shortcut_help_ = true;
      }
    }
  }
 
  // Placement error feedback (timed)
  if (!last_placement_error_.empty()) {
    double elapsed = ImGui::GetTime() - placement_error_time_;
    if (elapsed < kPlacementErrorDuration) {
      ImGui::TextColored(theme.status_error, ICON_MD_ERROR " %s",
                         last_placement_error_.c_str());
    } else {
      last_placement_error_.clear();
    }
  }
 
  // Current object info
  DrawSelectedObjectInfo();
 
  ImGui::Separator();
 
  // Emulator Preview (Collapsible)
  bool preview_open = ImGui::CollapsingHeader(ICON_MD_MONITOR " Preview");
  show_emulator_preview_ = preview_open;
 
  if (preview_open) {
    ImGui::PushID("PreviewSection");
    DrawEmulatorPreview();
    ImGui::PopID();
  }
 
  // Keyboard shortcut help popup
  DrawKeyboardShortcutHelp();
 
  // Handle keyboard shortcuts
  HandleKeyboardShortcuts();
}
 
void ObjectEditorPanel::SelectObject(int obj_id) {
  object_selector_.SelectObject(obj_id);
}
 
void ObjectEditorPanel::SetAgentOptimizedLayout(bool enabled) {
  // In agent mode, we might force tabs open or change layout
  (void)enabled;
}
 
void ObjectEditorPanel::SetPlacementError(const std::string& message) {
  // Avoid refreshing the timer for repeated identical errors; keeps the
  // message stable during rapid blocked clicks.
  if (message == last_placement_error_ && placement_error_time_ >= 0.0) {
    double elapsed = ImGui::GetTime() - placement_error_time_;
    if (elapsed < kPlacementErrorDuration) {
      return;
    }
  }
  last_placement_error_ = message;
  placement_error_time_ = ImGui::GetTime();
}
 
void ObjectEditorPanel::DrawObjectSelector() {
  // Delegate to the DungeonObjectSelector component
  object_selector_.DrawObjectAssetBrowser();
}
 
void ObjectEditorPanel::DrawDoorSection() {
  const auto& theme = AgentUI::GetTheme();
 
  // Common door types for the grid
  static constexpr std::array<zelda3::DoorType, 20> kDoorTypes = {{
      zelda3::DoorType::NormalDoor,
      zelda3::DoorType::NormalDoorLower,
      zelda3::DoorType::CaveExit,
      zelda3::DoorType::DoubleSidedShutter,
      zelda3::DoorType::EyeWatchDoor,
      zelda3::DoorType::SmallKeyDoor,
      zelda3::DoorType::BigKeyDoor,
      zelda3::DoorType::SmallKeyStairsUp,
      zelda3::DoorType::SmallKeyStairsDown,
      zelda3::DoorType::DashWall,
      zelda3::DoorType::BombableDoor,
      zelda3::DoorType::ExplodingWall,
      zelda3::DoorType::CurtainDoor,
      zelda3::DoorType::BottomSidedShutter,
      zelda3::DoorType::TopSidedShutter,
      zelda3::DoorType::FancyDungeonExit,
      zelda3::DoorType::WaterfallDoor,
      zelda3::DoorType::ExitMarker,
      zelda3::DoorType::LayerSwapMarker,
      zelda3::DoorType::DungeonSwapMarker,
  }};
 
  // Placement mode indicator
  if (door_placement_mode_) {
    ImGui::TextColored(
        theme.status_warning,
        ICON_MD_PLACE " Placing: %s - Click wall to place",
        std::string(zelda3::GetDoorTypeName(selected_door_type_)).c_str());
    if (ImGui::SmallButton(ICON_MD_CANCEL " Cancel")) {
      door_placement_mode_ = false;
      if (canvas_viewer_) {
        canvas_viewer_->object_interaction().SetDoorPlacementMode(
            false, zelda3::DoorType::NormalDoor);
      }
    }
    ImGui::Separator();
  }
 
  // Door type selector grid with preview thumbnails
  ImGui::Text(ICON_MD_CATEGORY " Select Door Type:");
 
  constexpr float kPreviewSize = 32.0f;
  constexpr int kItemsPerRow = 5;
  float panel_width = ImGui::GetContentRegionAvail().x;
  int items_per_row =
      std::max(1, static_cast<int>(panel_width / (kPreviewSize + 8)));
 
  ImGui::BeginChild("##DoorTypeGrid", ImVec2(0, 80), true,
                    ImGuiWindowFlags_HorizontalScrollbar);
 
  int col = 0;
  for (size_t i = 0; i < kDoorTypes.size(); ++i) {
    auto door_type = kDoorTypes[i];
    bool is_selected = (selected_door_type_ == door_type);
 
    ImGui::PushID(static_cast<int>(i));
 
    // Color-coded button for door type
    ImVec4 button_color;
    // Color-code by door category
    int type_val = static_cast<int>(door_type);
    if (type_val <= 0x12) {                           // Standard doors
      button_color = ImVec4(0.3f, 0.5f, 0.7f, 1.0f);  // Blue
    } else if (type_val <= 0x1E) {                    // Shutter/special
      button_color = ImVec4(0.7f, 0.5f, 0.3f, 1.0f);  // Orange
    } else {                                          // Markers
      button_color = ImVec4(0.5f, 0.7f, 0.3f, 1.0f);  // Green
    }
 
    if (is_selected) {
      button_color.x += 0.2f;
      button_color.y += 0.2f;
      button_color.z += 0.2f;
    }
 
    {
      gui::StyleColorGuard btn_colors({
          {ImGuiCol_Button, button_color},
          {ImGuiCol_ButtonHovered,
           ImVec4(button_color.x + 0.1f, button_color.y + 0.1f,
                  button_color.z + 0.1f, 1.0f)},
          {ImGuiCol_ButtonActive,
           ImVec4(button_color.x + 0.2f, button_color.y + 0.2f,
                  button_color.z + 0.2f, 1.0f)},
      });
 
      // Draw button with door type abbreviation
      std::string label = absl::StrFormat("%02X", type_val);
      if (ImGui::Button(label.c_str(), ImVec2(kPreviewSize, kPreviewSize))) {
        selected_door_type_ = door_type;
        door_placement_mode_ = true;
        if (canvas_viewer_) {
          canvas_viewer_->object_interaction().SetDoorPlacementMode(
              true, selected_door_type_);
        }
      }
    }
 
    // Tooltip with full name
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip("%s (0x%02X)\nClick to select for placement",
                        std::string(zelda3::GetDoorTypeName(door_type)).c_str(),
                        type_val);
    }
 
    // Selection highlight
    if (is_selected) {
      ImVec2 min = ImGui::GetItemRectMin();
      ImVec2 max = ImGui::GetItemRectMax();
      ImGui::GetWindowDrawList()->AddRect(min, max, IM_COL32(255, 255, 0, 255),
                                          0.0f, 0, 2.0f);
    }
 
    ImGui::PopID();
 
    col++;
    if (col < items_per_row && i < kDoorTypes.size() - 1) {
      ImGui::SameLine();
    } else {
      col = 0;
    }
  }
 
  ImGui::EndChild();
 
  // Show current room's doors
  auto* rooms = object_selector_.get_rooms();
  if (rooms && current_room_id_ >= 0 && current_room_id_ < 296) {
    const auto& room = (*rooms)[current_room_id_];
    const auto& doors = room.GetDoors();
 
    if (!doors.empty()) {
      ImGui::Text(ICON_MD_LIST " Room Doors (%zu):", doors.size());
 
      ImGui::BeginChild("##DoorList", ImVec2(0, 80), true);
      for (size_t i = 0; i < doors.size(); ++i) {
        const auto& door = doors[i];
        auto [tile_x, tile_y] = door.GetTileCoords();
 
        ImGui::PushID(static_cast<int>(i));
 
        std::string type_name(zelda3::GetDoorTypeName(door.type));
        std::string dir_name(zelda3::GetDoorDirectionName(door.direction));
 
        ImGui::Text("[%zu] %s (%s)", i, type_name.c_str(), dir_name.c_str());
        ImGui::SameLine();
        ImGui::TextColored(theme.text_secondary_gray, "@ (%d,%d)", tile_x,
                           tile_y);
 
        ImGui::SameLine();
        if (ImGui::SmallButton(ICON_MD_DELETE "##Del")) {
          auto& mutable_room = (*rooms)[current_room_id_];
          mutable_room.RemoveDoor(i);
        }
 
        ImGui::PopID();
      }
      ImGui::EndChild();
    } else {
      ImGui::TextColored(theme.text_secondary_gray,
                         ICON_MD_INFO " No doors in this room");
    }
  }
}
 
void ObjectEditorPanel::DrawEmulatorPreview() {
  const auto& theme = AgentUI::GetTheme();
 
  ImGui::TextColored(theme.text_secondary_gray,
                     ICON_MD_INFO " Real-time object rendering preview");
  gui::HelpMarker(
      "Uses SNES emulation to render objects accurately.\n"
      "May impact performance.");
 
  ImGui::Separator();
 
  ImGui::BeginChild("##EmulatorPreviewRegion", ImVec2(0, 260), true);
  emulator_preview_.Render();
  ImGui::EndChild();
}
 
void ObjectEditorPanel::DrawSelectedObjectInfo() {
  const auto& theme = AgentUI::GetTheme();
 
  // Show selection state at top - with extra safety checks
  if (canvas_viewer_ && canvas_viewer_->HasRooms()) {
    auto& interaction = canvas_viewer_->object_interaction();
    auto selected = interaction.GetSelectedObjectIndices();
 
    if (!selected.empty()) {
      ImGui::TextColored(theme.status_success,
                         ICON_MD_CHECK_CIRCLE " Selected:");
      ImGui::SameLine();
 
      if (selected.size() == 1) {
        if (object_editor_) {
          const auto& objects = object_editor_->GetObjects();
          if (selected[0] < objects.size()) {
            const auto& obj = objects[selected[0]];
            const auto semantics = zelda3::GetObjectLayerSemantics(obj);
            ImGui::Text("Object #%zu (ID: 0x%02X)", selected[0], obj.id_);
            ImGui::TextColored(
                theme.text_secondary_gray,
                "  Position: (%d, %d)  Size: 0x%02X  Layer: %s  Draws: %s",
                obj.x_, obj.y_, obj.size_,
                obj.layer_ == zelda3::RoomObject::BG1   ? "BG1"
                : obj.layer_ == zelda3::RoomObject::BG2 ? "BG2"
                                                        : "BG3",
                zelda3::EffectiveBgLayerLabel(semantics.effective_bg_layer));
          }
        } else {
          ImGui::Text("1 object");
        }
      } else {
        ImGui::Text("%zu objects", selected.size());
        ImGui::SameLine();
        ImGui::TextColored(theme.text_secondary_gray,
                           "(Shift+click to add, Ctrl+click to toggle)");
      }
      ImGui::Separator();
    }
  }
 
  ImGui::BeginGroup();
 
  ImGui::TextColored(theme.text_info, ICON_MD_INFO " Current:");
 
  if (has_preview_object_) {
    ImGui::SameLine();
    const auto semantics = zelda3::GetObjectLayerSemantics(preview_object_);
    ImGui::Text("ID: 0x%02X", preview_object_.id_);
    ImGui::SameLine();
    ImGui::Text("Layer: %s  Draws: %s",
                preview_object_.layer_ == zelda3::RoomObject::BG1   ? "BG1"
                : preview_object_.layer_ == zelda3::RoomObject::BG2 ? "BG2"
                                                                    : "BG3",
                zelda3::EffectiveBgLayerLabel(semantics.effective_bg_layer));
  }
 
  ImGui::EndGroup();
 
  ImGui::Separator();
 
  // Delegate property editing to the backend
  if (object_editor_) {
    object_editor_->DrawPropertyUI();
  }
}
 
// =============================================================================
// Static Object Editor (opened via double-click)
// =============================================================================
 
void ObjectEditorPanel::OpenStaticObjectEditor(int object_id) {
  static_editor_open_ = true;
  static_editor_object_id_ = object_id;
  static_preview_rendered_ = false;
 
  // Sync with object selector for visual indicator
  object_selector_.SetStaticEditorObjectId(object_id);
 
  // Fetch draw routine info for this object
  if (object_parser_) {
    static_editor_draw_info_ = object_parser_->GetObjectDrawInfo(object_id);
  }
 
  // Render the object preview using ObjectDrawer
  auto* rooms = object_selector_.get_rooms();
  if (rom_ && rom_->is_loaded() && rooms && current_room_id_ >= 0 &&
      current_room_id_ < static_cast<int>(rooms->size())) {
    auto& room = (*rooms)[current_room_id_];
 
    // Ensure room graphics are loaded
    if (!room.IsLoaded()) {
      room.LoadRoomGraphics(room.blockset());
    }
 
    // Clear preview buffer and initialize bitmap
    static_preview_buffer_.ClearBuffer();
    static_preview_buffer_.EnsureBitmapInitialized();
 
    // Create a preview object at top-left of canvas (tile 2,2 = pixel 16,16)
    // to fit within the 128x128 preview area with some margin
    zelda3::RoomObject preview_obj(object_id, 2, 2, 0x12, 0);
    preview_obj.SetRom(rom_);
    preview_obj.EnsureTilesLoaded();
 
    if (preview_obj.tiles().empty()) {
      return;  // No tiles to draw
    }
 
    // Get room graphics data
    const uint8_t* gfx_data = room.get_gfx_buffer().data();
 
    // Apply palette to bitmap
    auto& bitmap = static_preview_buffer_.bitmap();
    gfx::PaletteGroup palette_group;
    auto* game_data = object_selector_.game_data();
    if (game_data && !game_data->palette_groups.dungeon_main.empty()) {
      // Use the entire dungeon_main palette group
      palette_group = game_data->palette_groups.dungeon_main;
 
      std::vector<SDL_Color> colors(256);
      size_t color_index = 0;
      for (size_t pal_idx = 0;
           pal_idx < palette_group.size() && color_index < 256; ++pal_idx) {
        const auto& pal = palette_group[pal_idx];
        for (size_t i = 0; i < pal.size() && color_index < 256; ++i) {
          ImVec4 rgb = pal[i].rgb();
          colors[color_index++] = {static_cast<Uint8>(rgb.x),
                                   static_cast<Uint8>(rgb.y),
                                   static_cast<Uint8>(rgb.z), 255};
        }
      }
      colors[255] = {0, 0, 0, 0};  // Transparent
      bitmap.SetPalette(colors);
      if (bitmap.surface()) {
        SDL_SetColorKey(bitmap.surface(), SDL_TRUE, 255);
        SDL_SetSurfaceBlendMode(bitmap.surface(), SDL_BLENDMODE_BLEND);
      }
    }
 
    // Create drawer with room's graphics data
    zelda3::ObjectDrawer drawer(rom_, current_room_id_, gfx_data);
    drawer.InitializeDrawRoutines();
 
    auto status = drawer.DrawObject(preview_obj, static_preview_buffer_,
                                    static_preview_buffer_, palette_group);
    if (status.ok()) {
      // Sync bitmap data to SDL surface
      if (bitmap.modified() && bitmap.surface() &&
          bitmap.mutable_data().size() > 0) {
        SDL_LockSurface(bitmap.surface());
        size_t surface_size = bitmap.surface()->h * bitmap.surface()->pitch;
        size_t data_size = bitmap.mutable_data().size();
        if (surface_size >= data_size) {
          memcpy(bitmap.surface()->pixels, bitmap.mutable_data().data(),
                 data_size);
        }
        SDL_UnlockSurface(bitmap.surface());
      }
 
      // Create texture
      gfx::Arena::Get().QueueTextureCommand(
          gfx::Arena::TextureCommandType::CREATE, &bitmap);
      gfx::Arena::Get().ProcessTextureQueue(renderer_);
 
      static_preview_rendered_ = bitmap.texture() != nullptr;
    }
  }
}
 
void ObjectEditorPanel::CloseStaticObjectEditor() {
  static_editor_open_ = false;
  static_editor_object_id_ = -1;
 
  // Clear the visual indicator in object selector
  object_selector_.SetStaticEditorObjectId(-1);
}
 
void ObjectEditorPanel::DrawStaticObjectEditor() {
  const auto& theme = AgentUI::GetTheme();
 
  gui::StyleColorGuard header_colors({
      {ImGuiCol_Header, ImVec4(0.15f, 0.25f, 0.35f, 1.0f)},
      {ImGuiCol_HeaderHovered, ImVec4(0.20f, 0.30f, 0.40f, 1.0f)},
  });
 
  bool header_open = ImGui::CollapsingHeader(
      absl::StrFormat(ICON_MD_CONSTRUCTION " Object 0x%02X - %s",
                      static_editor_object_id_,
                      static_editor_draw_info_.routine_name.c_str())
          .c_str(),
      ImGuiTreeNodeFlags_DefaultOpen);
 
  if (header_open) {
    gui::StyleVarGuard frame_pad_guard(ImGuiStyleVar_FramePadding,
                                       ImVec2(8, 6));
 
    // Two-column layout: Info | Preview
    if (ImGui::BeginTable("StaticEditorLayout", 2,
                          ImGuiTableFlags_BordersInnerV)) {
      ImGui::TableSetupColumn("Info", ImGuiTableColumnFlags_WidthFixed, 200);
      ImGui::TableSetupColumn("Preview", ImGuiTableColumnFlags_WidthStretch);
 
      ImGui::TableNextRow();
 
      // Left column: Object information
      ImGui::TableNextColumn();
      {
        // Object ID with hex/decimal display
        ImGui::TextColored(theme.text_info, ICON_MD_TAG " Object ID");
        ImGui::SameLine();
        ImGui::Text("0x%02X (%d)", static_editor_object_id_,
                    static_editor_object_id_);
 
        ImGui::Spacing();
 
        // Draw routine info
        ImGui::TextColored(theme.text_info, ICON_MD_BRUSH " Draw Routine");
        ImGui::Indent();
        ImGui::Text("ID: %d", static_editor_draw_info_.draw_routine_id);
        ImGui::Text("Name: %s", static_editor_draw_info_.routine_name.c_str());
        ImGui::Unindent();
 
        ImGui::Spacing();
 
        // Tile and size info
        ImGui::TextColored(theme.text_info, ICON_MD_GRID_VIEW " Tile Info");
        ImGui::Indent();
        ImGui::Text("Tile Count: %d", static_editor_draw_info_.tile_count);
        ImGui::Text("Orientation: %s",
                    static_editor_draw_info_.is_horizontal ? "Horizontal"
                    : static_editor_draw_info_.is_vertical ? "Vertical"
                                                           : "Both");
        if (static_editor_draw_info_.both_layers) {
          ImGui::TextColored(theme.status_warning, ICON_MD_LAYERS " Both BG");
        }
        ImGui::Unindent();
 
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Spacing();
 
        // Action buttons (vertical layout)
        if (ImGui::Button(ICON_MD_CONTENT_COPY " Copy ID", ImVec2(-1, 0))) {
          ImGui::SetClipboardText(
              absl::StrFormat("0x%02X", static_editor_object_id_).c_str());
        }
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip("Copy object ID to clipboard");
        }
 
        if (ImGui::Button(ICON_MD_CODE " Export ASM", ImVec2(-1, 0))) {
          // TODO: Implement ASM export (Phase 5)
        }
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip("Export object draw routine as ASM (Phase 5)");
        }
 
        if (ImGui::Button(ICON_MD_GRID_ON " Edit Tiles", ImVec2(-1, 0))) {
          if (tile_editor_callback_) {
            tile_editor_callback_(
                static_cast<int16_t>(static_editor_object_id_));
          }
        }
        if (ImGui::IsItemHovered()) {
          ImGui::SetTooltip("Open tile editor to rearrange 8x8 tiles");
        }
 
        ImGui::Spacing();
 
        // Close button at bottom
        if (gui::DangerButton(ICON_MD_CLOSE " Close", ImVec2(-1, 0))) {
          CloseStaticObjectEditor();
        }
      }
 
      // Right column: Preview canvas
      ImGui::TableNextColumn();
      {
        ImGui::TextColored(theme.text_secondary_gray, "Preview:");
 
        gui::PreviewPanelOpts preview_opts;
        preview_opts.canvas_size = ImVec2(128, 128);
        preview_opts.render_popups = false;
        preview_opts.grid_step = 0.0f;
        preview_opts.ensure_texture = true;
 
        gui::CanvasFrameOptions frame_opts;
        frame_opts.canvas_size = preview_opts.canvas_size;
        frame_opts.draw_context_menu = false;
        frame_opts.draw_grid = preview_opts.grid_step > 0.0f;
        if (preview_opts.grid_step > 0.0f) {
          frame_opts.grid_step = preview_opts.grid_step;
        }
        frame_opts.draw_overlay = true;
        frame_opts.render_popups = preview_opts.render_popups;
 
        auto rt = gui::BeginCanvas(static_preview_canvas_, frame_opts);
 
        if (static_preview_rendered_) {
          auto& bitmap = static_preview_buffer_.bitmap();
          gui::RenderPreviewPanel(rt, bitmap, preview_opts);
        } else {
          gui::RenderPreviewPanel(rt, static_preview_buffer_.bitmap(),
                                  preview_opts);
          static_preview_canvas_.AddTextAt(
              ImVec2(24, 56), "No preview available",
              ImGui::GetColorU32(theme.text_secondary_gray));
        }
        gui::EndCanvas(static_preview_canvas_, rt, frame_opts);
 
        // Usage hint
        ImGui::Spacing();
        ImGui::TextColored(theme.text_secondary_gray, ICON_MD_INFO
                           " Double-click objects in browser\n"
                           "to view their draw routine info.");
      }
 
      ImGui::EndTable();
    }
  }
}
 
// =============================================================================
// Room Validation Bar
// =============================================================================
 
void ObjectEditorPanel::DrawRoomValidationBar() {
  auto* rooms = object_selector_.get_rooms();
  if (!rooms || current_room_id_ < 0 ||
      current_room_id_ >= zelda3::kNumberOfRooms) {
    return;
  }
 
  const auto& theme = AgentUI::GetTheme();
  const auto& room = (*rooms)[current_room_id_];
 
  // Gather counts
  size_t object_count = room.GetTileObjects().size();
  size_t sprite_count = room.GetSprites().size();
  size_t door_count = room.GetDoors().size();
 
  // Count chests (objects in 0xF9-0xFD range)
  int chest_count = 0;
  for (const auto& obj : room.GetTileObjects()) {
    if (obj.id_ >= 0xF9 && obj.id_ <= 0xFD) {
      chest_count++;
    }
  }
 
  // Canonical limits shared across handlers/validator.
  const int kMaxObjects = static_cast<int>(zelda3::kMaxTileObjects);
  const int kMaxSprites = static_cast<int>(zelda3::kMaxTotalSprites);
  const int kMaxDoors = static_cast<int>(zelda3::kMaxDoors);
  const int kMaxChests = static_cast<int>(zelda3::kMaxChests);
 
  // Helper to pick color based on usage ratio
  auto usage_color = [&](size_t count, int max_val) -> ImVec4 {
    float ratio = static_cast<float>(count) / static_cast<float>(max_val);
    if (ratio >= 1.0f) {
      return theme.status_error;
    }
    if (ratio >= 0.75f) {
      return theme.status_warning;
    }
    return theme.text_secondary_gray;
  };
 
  // Compact inline counters
  ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 2));
 
  ImGui::TextColored(usage_color(object_count, kMaxObjects),
                     ICON_MD_WIDGETS " %zu/%d", object_count, kMaxObjects);
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip("Objects: %zu of %d maximum", object_count, kMaxObjects);
  }
 
  ImGui::SameLine();
  ImGui::TextColored(usage_color(sprite_count, kMaxSprites),
                     ICON_MD_PEST_CONTROL " %zu/%d", sprite_count, kMaxSprites);
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip("Sprites: %zu of %d maximum", sprite_count, kMaxSprites);
  }
 
  ImGui::SameLine();
  ImGui::TextColored(usage_color(door_count, kMaxDoors),
                     ICON_MD_DOOR_FRONT " %zu/%d", door_count, kMaxDoors);
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip("Doors: %zu of %d maximum", door_count, kMaxDoors);
  }
 
  ImGui::SameLine();
  ImGui::TextColored(usage_color(chest_count, kMaxChests),
                     ICON_MD_INVENTORY_2 " %d/%d", chest_count, kMaxChests);
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip("Chests: %d of %d maximum", chest_count, kMaxChests);
  }
 
  ImGui::PopStyleVar();
 
  // Run full validation and show warnings/errors inline
  zelda3::DungeonValidator validator;
  auto result = validator.ValidateRoom(room);
  if (!result.errors.empty() || !result.warnings.empty()) {
    for (const auto& err : result.errors) {
      ImGui::TextColored(theme.status_error, ICON_MD_ERROR " %s", err.c_str());
    }
    for (const auto& warn : result.warnings) {
      ImGui::TextColored(theme.status_warning, ICON_MD_WARNING " %s",
                         warn.c_str());
    }
  }
 
  ImGui::Separator();
}
 
// =============================================================================
// Keyboard Shortcut Help
// =============================================================================
 
void ObjectEditorPanel::DrawKeyboardShortcutHelp() {
  if (!show_shortcut_help_) {
    return;
  }
 
  ImGui::SetNextWindowSize(ImVec2(340, 0), ImGuiCond_Appearing);
  if (ImGui::Begin("Keyboard Shortcuts##ObjEditor", &show_shortcut_help_,
                   ImGuiWindowFlags_NoCollapse)) {
    const auto& theme = AgentUI::GetTheme();
 
    auto shortcut_row = [&](const char* keys, const char* desc) {
      ImGui::TextColored(theme.status_warning, "%-18s", keys);
      ImGui::SameLine();
      ImGui::TextUnformatted(desc);
    };
 
    ImGui::TextColored(theme.status_success, ICON_MD_KEYBOARD " Selection");
    ImGui::Separator();
    shortcut_row("Ctrl+A", "Select all objects");
    shortcut_row("Ctrl+Shift+A", "Deselect all");
    shortcut_row("Tab / Shift+Tab", "Cycle selection");
    shortcut_row("Escape", "Cancel placement / deselect");
 
    ImGui::Spacing();
    ImGui::TextColored(theme.status_success, ICON_MD_EDIT " Editing");
    ImGui::Separator();
    shortcut_row("Delete", "Remove selected");
    shortcut_row("Ctrl+D", "Duplicate selected");
    shortcut_row("Ctrl+C", "Copy selected");
    shortcut_row("Ctrl+V", "Paste");
    shortcut_row("Ctrl+Z", "Undo");
    shortcut_row("Ctrl+Shift+Z", "Redo");
 
    ImGui::Spacing();
    ImGui::TextColored(theme.status_success, ICON_MD_OPEN_WITH " Movement");
    ImGui::Separator();
    shortcut_row("Arrow Keys", "Nudge selected (1px)");
 
    ImGui::Spacing();
    ImGui::TextColored(theme.status_success, ICON_MD_VISIBILITY " Display");
    ImGui::Separator();
    shortcut_row("G", "Toggle grid");
    shortcut_row("I", "Toggle object ID labels");
    shortcut_row("?", "Show this help");
  }
  ImGui::End();
}
 
// =============================================================================
// Keyboard Shortcuts
// =============================================================================
 
void ObjectEditorPanel::HandleKeyboardShortcuts() {
  if (!ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows)) {
    return;
  }
 
  const ImGuiIO& io = ImGui::GetIO();
 
  // Ctrl+A: Select all objects
  if (ImGui::IsKeyPressed(ImGuiKey_A) && io.KeyCtrl && !io.KeyShift) {
    SelectAllObjects();
  }
 
  // Ctrl+Shift+A: Deselect all
  if (ImGui::IsKeyPressed(ImGuiKey_A) && io.KeyCtrl && io.KeyShift) {
    DeselectAllObjects();
  }
 
  // Delete: Remove selected objects
  if (ImGui::IsKeyPressed(ImGuiKey_Delete)) {
    DeleteSelectedObjects();
  }
 
  // Ctrl+D: Duplicate selected objects
  if (ImGui::IsKeyPressed(ImGuiKey_D) && io.KeyCtrl) {
    DuplicateSelectedObjects();
  }
 
  // Ctrl+C: Copy selected objects
  if (ImGui::IsKeyPressed(ImGuiKey_C) && io.KeyCtrl) {
    CopySelectedObjects();
  }
 
  // Ctrl+V: Paste objects
  if (ImGui::IsKeyPressed(ImGuiKey_V) && io.KeyCtrl) {
    PasteObjects();
  }
 
  // Ctrl+Z: Undo
  if (ImGui::IsKeyPressed(ImGuiKey_Z) && io.KeyCtrl && !io.KeyShift) {
    if (object_editor_) {
      object_editor_->Undo();
    }
  }
 
  // Ctrl+Shift+Z or Ctrl+Y: Redo
  if ((ImGui::IsKeyPressed(ImGuiKey_Z) && io.KeyCtrl && io.KeyShift) ||
      (ImGui::IsKeyPressed(ImGuiKey_Y) && io.KeyCtrl)) {
    if (object_editor_) {
      object_editor_->Redo();
    }
  }
 
  // G: Toggle grid
  if (ImGui::IsKeyPressed(ImGuiKey_G) && !io.KeyCtrl) {
    show_grid_ = !show_grid_;
  }
 
  // I: Toggle object ID labels
  if (ImGui::IsKeyPressed(ImGuiKey_I) && !io.KeyCtrl) {
    show_object_ids_ = !show_object_ids_;
  }
 
  // Arrow keys: Nudge selected objects
  if (!io.KeyCtrl) {
    int dx = 0, dy = 0;
    if (ImGui::IsKeyPressed(ImGuiKey_LeftArrow))
      dx = -1;
    if (ImGui::IsKeyPressed(ImGuiKey_RightArrow))
      dx = 1;
    if (ImGui::IsKeyPressed(ImGuiKey_UpArrow))
      dy = -1;
    if (ImGui::IsKeyPressed(ImGuiKey_DownArrow))
      dy = 1;
 
    if (dx != 0 || dy != 0) {
      NudgeSelectedObjects(dx, dy);
    }
  }
 
  // Tab: Cycle through objects
  if (ImGui::IsKeyPressed(ImGuiKey_Tab) && !io.KeyCtrl) {
    CycleObjectSelection(io.KeyShift ? -1 : 1);
  }
 
  // Escape: Cancel placement or deselect all
  if (ImGui::IsKeyPressed(ImGuiKey_Escape)) {
    if (has_preview_object_ && canvas_viewer_ &&
        canvas_viewer_->object_interaction().IsObjectLoaded()) {
      CancelPlacement();
    } else {
      DeselectAllObjects();
    }
  }
 
  // ?: Toggle shortcut help (Shift+/ on US keyboards)
  if (ImGui::IsKeyPressed(ImGuiKey_Slash) && io.KeyShift) {
    show_shortcut_help_ = !show_shortcut_help_;
  }
}
 
void ObjectEditorPanel::CancelPlacement() {
  has_preview_object_ = false;
  if (canvas_viewer_) {
    canvas_viewer_->ClearPreviewObject();
    canvas_viewer_->object_interaction().CancelPlacement();
  }
}
 
void ObjectEditorPanel::SelectAllObjects() {
  if (!canvas_viewer_ || !object_editor_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  const auto& objects = object_editor_->GetObjects();
  std::vector<size_t> all_indices;
 
  for (size_t i = 0; i < objects.size(); ++i) {
    all_indices.push_back(i);
  }
 
  interaction.SetSelectedObjects(all_indices);
}
 
void ObjectEditorPanel::DeselectAllObjects() {
  if (!canvas_viewer_)
    return;
  canvas_viewer_->object_interaction().ClearSelection();
}
 
void ObjectEditorPanel::DeleteSelectedObjects() {
  if (!object_editor_ || !canvas_viewer_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  const auto& selected = interaction.GetSelectedObjectIndices();
 
  if (selected.empty())
    return;
 
  // Show confirmation for bulk delete (more than 5 objects)
  if (selected.size() > 5) {
    show_delete_confirmation_modal_ = true;
    return;
  }
 
  PerformDelete();
}
 
void ObjectEditorPanel::PerformDelete() {
  if (!object_editor_ || !canvas_viewer_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  const auto& selected = interaction.GetSelectedObjectIndices();
 
  if (selected.empty())
    return;
 
  // Delete in reverse order to maintain indices
  std::vector<size_t> sorted_indices(selected.begin(), selected.end());
  std::sort(sorted_indices.rbegin(), sorted_indices.rend());
 
  for (size_t idx : sorted_indices) {
    object_editor_->DeleteObject(idx);
  }
 
  interaction.ClearSelection();
}
 
void ObjectEditorPanel::DuplicateSelectedObjects() {
  if (!object_editor_ || !canvas_viewer_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  const auto& selected = interaction.GetSelectedObjectIndices();
 
  if (selected.empty())
    return;
 
  std::vector<size_t> new_indices;
 
  for (size_t idx : selected) {
    auto new_idx = object_editor_->DuplicateObject(idx, 1, 1);
    if (new_idx.has_value()) {
      new_indices.push_back(*new_idx);
    }
  }
 
  interaction.SetSelectedObjects(new_indices);
}
 
void ObjectEditorPanel::CopySelectedObjects() {
  if (!object_editor_ || !canvas_viewer_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  const auto& selected = interaction.GetSelectedObjectIndices();
 
  if (selected.empty())
    return;
 
  object_editor_->CopySelectedObjects(selected);
}
 
void ObjectEditorPanel::PasteObjects() {
  if (!object_editor_ || !canvas_viewer_)
    return;
 
  auto new_indices = object_editor_->PasteObjects();
 
  if (!new_indices.empty()) {
    canvas_viewer_->object_interaction().SetSelectedObjects(new_indices);
  }
}
 
void ObjectEditorPanel::NudgeSelectedObjects(int dx, int dy) {
  if (!object_editor_ || !canvas_viewer_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  const auto& selected = interaction.GetSelectedObjectIndices();
 
  if (selected.empty())
    return;
 
  for (size_t idx : selected) {
    object_editor_->MoveObject(idx, dx, dy);
  }
}
 
void ObjectEditorPanel::CycleObjectSelection(int direction) {
  if (!canvas_viewer_ || !object_editor_)
    return;
 
  auto& interaction = canvas_viewer_->object_interaction();
  const auto& selected = interaction.GetSelectedObjectIndices();
  const auto& objects = object_editor_->GetObjects();
 
  size_t total_objects = objects.size();
  if (total_objects == 0)
    return;
 
  size_t current_idx = selected.empty() ? 0 : selected.front();
  size_t next_idx = (current_idx + direction + total_objects) % total_objects;
 
  interaction.SetSelectedObjects({next_idx});
  ScrollToObject(next_idx);
}
 
void ObjectEditorPanel::ScrollToObject(size_t index) {
  if (!canvas_viewer_ || !object_editor_)
    return;
 
  const auto& objects = object_editor_->GetObjects();
  if (index >= objects.size())
    return;
 
  const auto& obj = objects[index];
  canvas_viewer_->ScrollToTile(obj.x(), obj.y());
}
 
}  // namespace editor
}  // namespace yaze