dungeon_object_selector.cc

Go to the documentation of this file.

// Related header
#include "dungeon_object_selector.h"
#include "absl/strings/str_format.h"
#include "util/i18n/tr.h"
 
// C system headers
#include <cstring>
#include <filesystem>
 
// C++ standard library headers
#include <algorithm>
#include <array>
#include <cctype>
#include <iterator>
 
// Third-party library headers
#include "imgui/imgui.h"
 
// Project headers
#include "app/editor/dungeon/ui/window/object_tile_editor_panel.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/automation/widget_auto_register.h"
#include "app/gui/core/agent_theme.h"
#include "app/gui/core/drag_drop.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 "core/features.h"
#include "rom/rom.h"
#include "zelda3/dungeon/custom_object.h"  // For CustomObjectManager
#include "zelda3/dungeon/dimension_service.h"
#include "zelda3/dungeon/draw_routines/draw_routine_symbology.h"
#include "zelda3/dungeon/dungeon_object_editor.h"
#include "zelda3/dungeon/dungeon_object_registry.h"
#include "zelda3/dungeon/minecart_object_semantics.h"
#include "zelda3/dungeon/object_drawer.h"
#include "zelda3/dungeon/object_layer_semantics.h"
#include "zelda3/dungeon/object_tile_editor.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_object.h"  // For GetObjectName()
 
namespace yaze::editor {
 
namespace {
 
constexpr int kPersistedCustomSubtypeSlots = 16;
constexpr const char* kObjectGridDensityLabels[] = {"Compact", "Medium",
                                                    "Large"};
 
float GetObjectGridItemSize(int density) {
  switch (density) {
    case 0:
      return 54.0f;
    case 2:
      return 76.0f;
    case 1:
    default:
      return 60.0f;
  }
}
 
ImU32 ThemeColor(const ImVec4& color) {
  return ImGui::ColorConvertFloat4ToU32(color);
}
 
ImVec4 WithAlpha(ImVec4 color, float alpha) {
  color.w = alpha;
  return color;
}
 
void DrawFallbackPreviewTile(ImDrawList* draw_list, ImVec2 top_left,
                             ImVec2 size, const ImVec4& accent_color,
                             const char* label) {
  const auto& theme = AgentUI::GetTheme();
  draw_list->AddRectFilled(
      top_left, ImVec2(top_left.x + size.x, top_left.y + size.y),
      ThemeColor(WithAlpha(theme.panel_bg_darker, 0.72f)), 2.0f);
  draw_list->AddRectFilled(top_left,
                           ImVec2(top_left.x + 2.0f, top_left.y + size.y),
                           ThemeColor(WithAlpha(accent_color, 0.72f)), 2.0f);
 
  ImVec2 label_size = ImGui::CalcTextSize(label);
  if (label_size.x > size.x - 4.0f || label_size.y > size.y - 4.0f) {
    return;
  }
  ImVec2 label_pos(top_left.x + (size.x - label_size.x) / 2,
                   top_left.y + (size.y - label_size.y) / 2);
  draw_list->AddText(label_pos,
                     ThemeColor(WithAlpha(theme.text_primary, 0.82f)), label);
}
 
const char* CustomObjectMappingOriginLabel(
    zelda3::CustomObjectMappingOrigin origin) {
  switch (origin) {
    case zelda3::CustomObjectMappingOrigin::kDefaultFilename:
      return "Oracle default filename";
    case zelda3::CustomObjectMappingOrigin::kConfiguredFilename:
      return "Configured filename";
    case zelda3::CustomObjectMappingOrigin::kConfiguredSlotUnmapped:
      return "Configured slot unmapped";
  }
  return "Unknown mapping";
}
 
}  // namespace
 
DungeonObjectSelectorGridLayout ResolveDungeonObjectSelectorGridLayout(
    float available_width, float preferred_item_size, float item_spacing,
    float min_item_size) {
  const float safe_spacing = std::max(item_spacing, 0.0f);
  const float usable_width = std::max(available_width, 1.0f);
  const float safe_min_item_size =
      std::min(std::max(min_item_size, 1.0f), usable_width);
  const float clamped_preferred_item_size =
      std::clamp(preferred_item_size, safe_min_item_size, usable_width);
 
  DungeonObjectSelectorGridLayout layout;
  layout.columns = std::max(
      1, static_cast<int>((usable_width + safe_spacing) /
                          (clamped_preferred_item_size + safe_spacing)));
  layout.item_size = clamped_preferred_item_size;
  const float total_spacing = safe_spacing * (layout.columns - 1);
  const float occupied_width =
      layout.item_size * layout.columns + total_spacing;
  layout.leading_inset = std::max((usable_width - occupied_width) * 0.5f, 0.0f);
  return layout;
}
 
DungeonObjectPreviewFit ResolveDungeonObjectPreviewFit(float source_width,
                                                       float source_height,
                                                       float box_width,
                                                       float box_height) {
  DungeonObjectPreviewFit fit;
  if (source_width <= 0.0f || source_height <= 0.0f || box_width <= 0.0f ||
      box_height <= 0.0f) {
    return fit;
  }
 
  const float scale =
      std::min(box_width / source_width, box_height / source_height);
  fit.valid = true;
  fit.width = source_width * scale;
  fit.height = source_height * scale;
  fit.x = (box_width - fit.width) * 0.5f;
  fit.y = (box_height - fit.height) * 0.5f;
  return fit;
}
 
bool MatchesDungeonObjectStreamFilter(int object_id, int selected_filter) {
  switch (selected_filter) {
    case 1:
      return object_id >= 0x000 && object_id <= 0x0F7;
    case 2:
      return object_id >= 0x100 && object_id <= 0x13F;
    case 3:
      return object_id >= 0xF80 && object_id <= 0xFFF;
    case 0:
    default:
      return true;
  }
}
 
bool IsDungeonCustomObjectRuntimeSlot(int object_id, int subtype) {
  return subtype >= 0 &&
         subtype < zelda3::CustomObjectManager::RuntimeSubtypeCountForObject(
                       object_id);
}
 
bool IsMinecartGraphicsRuntimeSlot(int object_id, int subtype) {
  return object_id == 0x31 &&
         zelda3::IsMinecartTrackGraphicsSubtype(object_id, subtype);
}
 
std::string GetDungeonCustomObjectSlotName(int object_id, int subtype) {
  static constexpr std::array<const char*, 16> kObject31Names = {
      "Pit track horizontal",           "Pit track vertical",
      "Pit track corner top-left",      "Pit track corner top-right",
      "Pit track corner bottom-left",   "Pit track corner bottom-right",
      "Floor track vertical",           "Floor track horizontal",
      "Floor track corner top-left",    "Floor track corner top-right",
      "Floor track corner bottom-left", "Floor track corner bottom-right",
      "Floor track any direction",      "Sword House wall object",
      "Pit track any direction",        "Small statue",
  };
  static constexpr std::array<const char*, 3> kObject32Names = {
      "Ice furnace",
      "Firewood",
      "Ice chair",
  };
  static constexpr std::array<const char*, 2> kObject54Names = {
      "Kydreeok body",
      "Manhandla body",
  };
  if (object_id == 0x31 && subtype >= 0 &&
      subtype < static_cast<int>(kObject31Names.size())) {
    return kObject31Names[subtype];
  }
  if (object_id == 0x32 && subtype >= 0 &&
      subtype < static_cast<int>(kObject32Names.size())) {
    return kObject32Names[subtype];
  }
  if (object_id == 0x54 && subtype >= 0 &&
      subtype < static_cast<int>(kObject54Names.size())) {
    return kObject54Names[subtype];
  }
  return "Unknown custom runtime slot";
}
 
DungeonObjectSelector::~DungeonObjectSelector() {
  RetirePreviewCache();
}
 
bool DungeonObjectSelector::IsRepresentableChestObjectId(int object_id) {
  const auto category = zelda3::ObjectCategories::GetObjectCategory(object_id);
  return category.ok() && *category == "Chests";
}
 
ImU32 DungeonObjectSelector::GetObjectTypeColor(int object_id) {
  const auto& theme = AgentUI::GetTheme();
  const auto category = zelda3::ObjectCategories::GetObjectCategory(object_id);
  if (!category.ok())
    return ImGui::GetColorU32(theme.dungeon_object_default);
  if (*category == "Walls")
    return ImGui::GetColorU32(theme.dungeon_object_wall);
  if (*category == "Floors")
    return ImGui::GetColorU32(theme.dungeon_object_floor);
  if (*category == "Decorations")
    return ImGui::GetColorU32(theme.dungeon_object_decoration);
  if (*category == "Chests")
    return ImGui::GetColorU32(theme.item_color);
  if (*category == "Stairs")
    return ImGui::GetColorU32(theme.selection_primary);
  if (*category == "Doors")
    return ImGui::GetColorU32(theme.transport_color);
  if (*category == "Interactive")
    return ImGui::GetColorU32(theme.status_success);
  return ImGui::GetColorU32(theme.music_zone_color);
}
 
std::string DungeonObjectSelector::GetObjectTypeSymbol(int object_id) {
  const auto category = zelda3::ObjectCategories::GetObjectCategory(object_id);
  if (!category.ok())
    return "?";
  if (*category == "Walls")
    return "|";
  if (*category == "Floors")
    return "_";
  if (*category == "Decorations")
    return "~";
  if (*category == "Chests")
    return "C";
  if (*category == "Stairs")
    return "^";
  if (*category == "Doors")
    return "D";
  if (*category == "Interactive")
    return "o";
  return "S";
}
 
void DungeonObjectSelector::SelectObject(int obj_id, int subtype) {
  const int runtime_count =
      zelda3::CustomObjectManager::RuntimeSubtypeCountForObject(obj_id);
  if (runtime_count > 0 && subtype < 0 &&
      core::FeatureFlags::get().kEnableCustomObjects) {
    // In custom-enabled projects these IDs are dispatch families, not one
    // subtype-free object. Selection must come from Custom Assets so the exact
    // runtime slot and its decoded source asset are known.
    return;
  }
  if (subtype >= 0) {
    if ((runtime_count > 0 &&
         !IsDungeonCustomObjectRuntimeSlot(obj_id, subtype)) ||
        (runtime_count == 0 && subtype >= kPersistedCustomSubtypeSlots)) {
      return;
    }
    if (runtime_count > 0) {
      if (!core::FeatureFlags::get().kEnableCustomObjects) {
        return;
      }
      SynchronizeCustomObjectGeneration();
      if (!GetCustomObjectAssetStatus(obj_id, subtype).ok()) {
        return;
      }
    }
  }
 
  selected_object_id_ = obj_id;
 
  // Create and update preview object
  uint8_t size = zelda3::DefaultRoomObjectSizeForPlacement(obj_id);
  if (subtype >= 0) {
    // Oracle custom objects use the explicitly selected size as a subtype.
    size =
        zelda3::CanonicalRoomObjectSize(obj_id, static_cast<uint8_t>(subtype));
  }
  preview_object_ = zelda3::RoomObject(obj_id, 0, 0, size, 0);
  preview_object_.SetRom(rom_);
  object_loaded_ = true;
  preview_uses_custom_override_ =
      core::FeatureFlags::get().kEnableCustomObjects &&
      zelda3::CustomObjectManager::Get()
          .GetObjectInternal(obj_id, preview_object_.size_ & 0x1F)
          .ok();
 
  // Notify callback
  if (object_selected_callback_) {
    object_selected_callback_(preview_object_);
  }
}
 
bool DungeonObjectSelector::DrawMinecartPalette() {
  SynchronizeCustomObjectGeneration();
  if (!core::FeatureFlags::get().kEnableCustomObjects) {
    ImGui::TextDisabled("This project has no custom rail assets.");
    return false;
  }
  const auto layout = ResolveDungeonObjectSelectorGridLayout(
      ImGui::GetContentRegionAvail().x, 64.0f, ImGui::GetStyle().ItemSpacing.x);
  bool chosen = false;
  ImGui::PushID("MinecartRailPalette");
  // Keep the complete catalog visible, with the same shape order in both
  // families. These are artwork choices; behavior is edited separately.
  static constexpr std::array<std::array<int, 7>, 2> kFamilies = {
      {{7, 6, 8, 9, 10, 11, 12}, {0, 1, 2, 3, 4, 5, 14}}};
  for (size_t family = 0; family < kFamilies.size(); ++family) {
    ImGui::TextDisabled("%s",
                        family == 0 ? "Floor-style rails" : "Pit-style rails");
    int column = 0;
    for (int subtype : kFamilies[family]) {
      if (column)
        ImGui::SameLine();
      const auto status = GetCustomObjectAssetStatus(0x31, subtype);
      const auto name = GetDungeonCustomObjectSlotName(0x31, subtype);
      const auto label = absl::StrFormat("##Rail%d", subtype);
      ImGui::BeginDisabled(!status.ok());
      if (ImGui::Selectable(label.c_str(),
                            object_loaded_ && preview_object_.id_ == 0x31 &&
                                preview_object_.size_ == subtype,
                            0, ImVec2(layout.item_size, layout.item_size))) {
        SelectObject(0x31, subtype);
        chosen = true;
      }
      gui::AutoRegisterLastItem("selectable",
                                absl::StrFormat("Rail%d", subtype));
      ImGui::EndDisabled();
      const auto top = ImGui::GetItemRectMin();
      auto obj = MakePreviewObject(0x31);
      obj.size_ = subtype;
      const bool rendered =
          status.ok() && ImGui::IsItemVisible() &&
          DrawObjectPreview(obj, ImVec2(top.x + 3, top.y + 3),
                            ImVec2(layout.item_size - 6, layout.item_size - 6));
      if (!rendered) {
        ImGui::GetWindowDrawList()->AddText(
            top, ImGui::GetColorU32(ImGuiCol_TextDisabled),
            status.ok() ? "Preview..." : "Missing");
      }
      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
        ImGui::BeginTooltip();
        ImGui::TextUnformatted(name.c_str());
        ImGui::TextUnformatted(status.ok()
                                   ? "Click, then place on the room canvas."
                                   : std::string(status.message()).c_str());
        if (status.ok() && family == 0) {
          ImGui::TextUnformatted(
              "Uses fixed floor tiles; check the room's graphics and palette.");
        }
        ImGui::EndTooltip();
      }
      column = (column + 1) % layout.columns;
    }
  }
  ImGui::PopID();
  return chosen;
}
 
void DungeonObjectSelector::DrawObjectAssetBrowser(float minimum_grid_height) {
  if (browser_mode_ == BrowserMode::kObjects &&
      !custom_object_action_error_.empty()) {
    ImGui::TextWrapped("%s", custom_object_action_error_.c_str());
  }
  const auto& theme = AgentUI::GetTheme();
 
  // Object ranges supported by the room-object stream codec.
  struct ObjectRange {
    int start;
    int end;
    const char* label;
  };
  static const ObjectRange ranges[] = {
      {0x00, 0xF7, "Type 1"},
      {0x100, 0x13F, "Type 2"},
      {0xF80, 0xFFF, "Type 3"},
  };
 
  SynchronizeCustomObjectGeneration();
  auto& obj_manager = zelda3::CustomObjectManager::Get();
  int custom_count = 0;
  for (const int object_id : zelda3::CustomObjectManager::RuntimeObjectIds()) {
    custom_count += std::min(obj_manager.GetSubtypeCount(object_id),
                             kPersistedCustomSubtypeSlots);
  }
 
  const std::string custom_mode_label =
      absl::StrFormat("Custom Assets (%d)", custom_count);
  if (ImGui::BeginTable(
          "##ObjectBrowserMode", 2,
          ImGuiTableFlags_SizingStretchSame | ImGuiTableFlags_NoPadOuterX)) {
    ImGui::TableNextColumn();
    if (ImGui::Selectable(tr("Objects"), browser_mode_ == BrowserMode::kObjects,
                          0, ImVec2(ImGui::GetContentRegionAvail().x, 0.0f))) {
      browser_mode_ = BrowserMode::kObjects;
    }
    ImGui::TableNextColumn();
    if (ImGui::Selectable(custom_mode_label.c_str(),
                          browser_mode_ == BrowserMode::kCustomAssets, 0,
                          ImVec2(ImGui::GetContentRegionAvail().x, 0.0f))) {
      browser_mode_ = BrowserMode::kCustomAssets;
    }
    ImGui::EndTable();
  }
 
  if (browser_mode_ == BrowserMode::kCustomAssets) {
    DrawCustomObjectAssetBrowser();
    return;
  }
  ImGui::Spacing();
 
  const ImGuiStyle& style = ImGui::GetStyle();
  const float control_spacing = std::max(2.0f, style.ItemSpacing.x * 0.5f);
  {
    gui::StyleVarGuard toolbar_spacing_guard(
        ImGuiStyleVar_ItemSpacing,
        ImVec2(control_spacing, std::max(2.0f, style.ItemSpacing.y * 0.5f)));
 
    const float toolbar_width =
        std::max(ImGui::GetContentRegionAvail().x, 1.0f);
    ImGui::SetNextItemWidth(toolbar_width);
    ImGui::InputTextWithHint("##ObjectSearch", "Search by name or hex ID...",
                             object_search_buffer_,
                             sizeof(object_search_buffer_));
 
    static const char* kFilterLabels[] = {
        "All categories", "Walls", "Floors", "Chests",
        "Doorways",       "Decor", "Stairs"};
    static const char* kStreamLabels[] = {"All streams", "Type 1", "Type 2",
                                          "Type 3"};
    constexpr const char* kMoreLabel = "More##ObjectSelectorMore";
    const float more_width = ImGui::CalcTextSize(kMoreLabel, nullptr, true).x +
                             style.FramePadding.x * 2.0f;
    const bool stack_filters = toolbar_width < 230.0f;
    const float filter_row_width =
        std::max(1.0f, toolbar_width - more_width - control_spacing);
    const float used_width = ImGui::GetFrameHeight() +
                             ImGui::CalcTextSize("Used here").x +
                             style.ItemInnerSpacing.x;
    const float category_width =
        stack_filters
            ? toolbar_width
            : std::max(1.0f, filter_row_width - used_width - control_spacing);
 
    ImGui::SetNextItemWidth(category_width);
    ImGui::Combo("##ObjectFilterType", &object_type_filter_, kFilterLabels,
                 IM_ARRAYSIZE(kFilterLabels));
    if (object_type_filter_ == 4 && ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Doorways are tile objects. Use the Door Editor "
             "to place or change room doors."));
    }
    if (!stack_filters) {
      ImGui::SameLine(0.0f, control_spacing);
    }
    ImGui::Checkbox("Used here", &used_here_only_);
    ImGui::SameLine(0.0f, control_spacing);
    if (ImGui::Button(kMoreLabel, ImVec2(more_width, 0.0f))) {
      ImGui::OpenPopup("##ObjectSelectorOptionsPopup");
    }
    if (ImGui::BeginPopup("##ObjectSelectorOptionsPopup")) {
      const bool has_filters = object_search_buffer_[0] != '\0' ||
                               object_type_filter_ != 0 ||
                               object_stream_filter_ != 0 || used_here_only_;
      if (ImGui::MenuItem(tr("Clear filters"), nullptr, false, has_filters)) {
        object_search_buffer_[0] = '\0';
        object_type_filter_ = 0;
        object_stream_filter_ = 0;
        used_here_only_ = false;
      }
 
      ImGui::SetNextItemWidth(130.0f);
      ImGui::Combo("Object stream", &object_stream_filter_, kStreamLabels,
                   IM_ARRAYSIZE(kStreamLabels));
 
      ImGui::SeparatorText(tr("Display"));
      ImGui::Checkbox(tr("Show thumbnails"), &enable_object_previews_);
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip(
            tr("Show rendered object thumbnails in the selector.\n"
               "Requires a room to be loaded and may cost some performance."));
      }
      ImGui::SeparatorText(tr("Card size"));
      for (int density = 0; density < 3; ++density) {
        if (ImGui::MenuItem(kObjectGridDensityLabels[density], nullptr,
                            object_grid_density_ == density)) {
          object_grid_density_ = density;
        }
      }
 
      ImGui::EndPopup();
    }
  }
 
  // The grid is the selector's sole scroll owner. Calculate its geometry only
  // after entering the child so themed padding and the scrollbar are included.
  const float child_height = std::max(ImGui::GetContentRegionAvail().y,
                                      std::max(minimum_grid_height, 1.0f));
  if (ImGui::BeginChild("##ObjectGrid", ImVec2(0, child_height), false)) {
    const float item_spacing = control_spacing;
    // GetContentRegionAvail() already excludes the child window's scrollbar
    // and padding. Centering the fixed-density grid balances any remainder so
    // a resize cannot leave a second, artificial gutter on the right.
    const auto grid_layout = ResolveDungeonObjectSelectorGridLayout(
        ImGui::GetContentRegionAvail().x,
        GetObjectGridItemSize(object_grid_density_), item_spacing);
    const float item_size = grid_layout.item_size;
    const int columns = grid_layout.columns;
    gui::StyleVarGuard grid_spacing_guard(
        ImGuiStyleVar_ItemSpacing,
        ImVec2(item_spacing, std::max(item_spacing, style.ItemSpacing.y)));
 
    // Iterate through all object ranges
    for (const auto& range : ranges) {
      if (!MatchesDungeonObjectStreamFilter(range.start,
                                            object_stream_filter_)) {
        continue;
      }
 
      if (object_stream_filter_ == 0) {
        ImGui::TextDisabled("%s  0x%03X-0x%03X", range.label, range.start,
                            range.end);
      }
 
      int current_column = 0;
 
      for (int obj_id = range.start; obj_id <= range.end; ++obj_id) {
        if (core::FeatureFlags::get().kEnableCustomObjects &&
            zelda3::CustomObjectManager::RuntimeSubtypeCountForObject(obj_id) >
                0) {
          // Custom-enabled runtime families are shown only in Custom Assets,
          // where an exact subtype and validated source asset are required.
          continue;
        }
        if (!MatchesObjectFilter(obj_id, object_type_filter_)) {
          continue;
        }
        if (!MatchesRoomUsage(obj_id))
          continue;
        if (!MatchesDungeonObjectStreamFilter(obj_id, object_stream_filter_)) {
          continue;
        }
 
        std::string full_name = zelda3::GetObjectName(obj_id);
        if (!MatchesObjectSearch(obj_id, full_name)) {
          continue;
        }
 
        if (current_column > 0) {
          ImGui::SameLine(0.0f, item_spacing);
        } else {
          ImGui::SetCursorPosX(ImGui::GetCursorPosX() +
                               grid_layout.leading_inset);
        }
 
        ImGui::PushID(obj_id);
 
        // Create selectable button for object
        bool is_selected = (selected_object_id_ == obj_id);
        ImVec2 button_size(item_size, item_size);
 
        if (ImGui::Selectable("", is_selected, 0, button_size)) {
          SelectObject(obj_id);
        }
        const bool item_visible = ImGui::IsItemVisible();
        // Routine symbology — one fast registry lookup per visible card only.
        // Off-screen items are skipped entirely (no work queued until culled).
        zelda3::DrawRoutineSymbology sym;
        if (item_visible) {
          sym = zelda3::GetSymbologyForObject(static_cast<int16_t>(obj_id));
        }
        ImVec2 button_pos = ImGui::GetItemRectMin();
        DrawObjectContextMenu(obj_id);
        gui::BeginRoomObjectDragSource(
            static_cast<uint16_t>(obj_id), current_room_id_, 0, 0,
            zelda3::DefaultRoomObjectSizeForPlacement(obj_id));
        ImDrawList* draw_list = ImGui::GetWindowDrawList();
        const bool show_id = item_size >= 32.0f;
        const float footer_height =
            show_id ? std::min(item_size * 0.32f, ImGui::GetFontSize() + 3.0f)
                    : 0.0f;
        const float card_padding = std::min(3.0f, item_size * 0.08f);
        const ImVec2 preview_pos(button_pos.x + card_padding,
                                 button_pos.y + card_padding);
        const ImVec2 preview_box(
            std::max(1.0f, item_size - card_padding * 2.0f),
            std::max(1.0f, item_size - footer_height - card_padding * 2.0f));
 
        // Only attempt graphical preview if enabled (performance optimization)
        bool rendered = false;
        if (item_visible && enable_object_previews_) {
          rendered = DrawObjectPreview(MakePreviewObject(obj_id), preview_pos,
                                       preview_box);
        }
 
        if (item_visible && !rendered) {
          std::string symbol = GetObjectTypeSymbol(obj_id);
          DrawFallbackPreviewTile(
              draw_list, preview_pos, preview_box,
              ImGui::ColorConvertU32ToFloat4(GetObjectTypeColor(obj_id)),
              symbol.c_str());
        }
 
        const bool item_hovered = ImGui::IsItemHovered();
        if (item_visible && (is_selected || item_hovered)) {
          const ImU32 border_color =
              ImGui::GetColorU32(is_selected ? theme.dungeon_selection_primary
                                             : theme.panel_border_color);
          draw_list->AddRect(
              button_pos,
              ImVec2(button_pos.x + item_size, button_pos.y + item_size),
              border_color, 2.0f, 0, is_selected ? 2.0f : 1.0f);
        }
 
        // Compact routine symbology badge — top-right corner overlay, drawn
        // over both graphical thumbnails and fallback tiles.  Only rendered
        // for visible cards (sym is only populated when item_visible).
        // Skipped for unmapped objects (badge == "?") to reduce visual noise.
        if (item_visible && !sym.badge.empty() && sym.badge != "?") {
          const ImVec2 badge_text_size =
              ImGui::CalcTextSize(sym.badge.c_str(), nullptr, true);
          const float badge_pad = 2.0f;
          const float badge_w = badge_text_size.x + badge_pad * 2.0f;
          const float badge_h = badge_text_size.y + badge_pad;
          const ImVec2 badge_tl(button_pos.x + item_size - badge_w,
                                button_pos.y);
          const ImVec2 badge_br(button_pos.x + item_size,
                                button_pos.y + badge_h);
          draw_list->AddRectFilled(
              badge_tl, badge_br,
              ImGui::GetColorU32(WithAlpha(theme.panel_bg_darker, 0.82f)),
              1.5f);
          // BothBG routines use the wall-accent color; others use secondary
          // text so the badge never competes with the thumbnail content.
          const ImVec4& badge_color = sym.dual_layer
                                          ? theme.dungeon_object_wall
                                          : theme.text_secondary_gray;
          draw_list->AddText(
              ImVec2(badge_tl.x + badge_pad, badge_tl.y + badge_pad * 0.5f),
              ImGui::GetColorU32(badge_color), sym.badge.c_str());
        }
 
        if (item_visible && show_id) {
          const ImVec2 card_bottom(button_pos.x + item_size,
                                   button_pos.y + item_size);
          const float footer_y = card_bottom.y - footer_height;
          draw_list->AddRectFilled(
              ImVec2(button_pos.x, footer_y), card_bottom,
              ImGui::GetColorU32(WithAlpha(theme.panel_bg_darker, 0.88f)),
              2.0f);
          std::string id_text = absl::StrFormat("%03X", obj_id);
          ImVec2 id_size = ImGui::CalcTextSize(id_text.c_str());
          ImVec2 id_pos = ImVec2(button_pos.x + (item_size - id_size.x) / 2,
                                 footer_y + (footer_height - id_size.y) * 0.5f);
          draw_list->AddText(id_pos, ImGui::GetColorU32(theme.text_primary),
                             id_text.c_str());
        }
 
        // Enhanced tooltip
        if (item_hovered) {
          gui::StyleColorGuard tooltip_guard(
              {{ImGuiCol_PopupBg, theme.panel_bg_color},
               {ImGuiCol_Border, theme.panel_border_color}});
 
          if (ImGui::BeginTooltip()) {
            ImGui::TextColored(theme.selection_primary, tr("Object 0x%03X"),
                               obj_id);
            ImGui::Text("%s", full_name.c_str());
            int subtype = zelda3::GetObjectSubtype(obj_id);
            ImGui::TextColored(theme.text_secondary_gray, tr("Subtype %d"),
                               subtype);
            ImGui::TextColored(
                rendered ? theme.status_success : theme.status_warning,
                tr("Preview: %s"),
                rendered ? "rendered tile layout"
                         : (enable_object_previews_ ? "fallback symbol"
                                                    : "thumbnails off"));
            ImGui::Separator();
 
            const uint8_t preview_size =
                zelda3::DefaultRoomObjectSizeForPlacement(obj_id);
            const bool can_capture_layout =
                rom_ && rooms_ && current_room_id_ >= 0 &&
                current_room_id_ < zelda3::kNumberOfRooms;
            const zelda3::Room* layout_room =
                can_capture_layout ? &(*rooms_)[current_room_id_] : nullptr;
            const uint32_t layout_key =
                MakeLayoutCacheKey(obj_id, preview_size, layout_room);
            if (can_capture_layout &&
                layout_cache_.find(layout_key) == layout_cache_.end()) {
              zelda3::ObjectTileEditor editor(rom_);
              auto& room_ref = *layout_room;
              auto layout_or = editor.CaptureObjectLayout(
                  obj_id, room_ref, current_palette_group_, preview_size);
              if (layout_or.ok()) {
                layout_cache_[layout_key] = layout_or.value();
              }
            }
 
            if (layout_cache_.count(layout_key)) {
              const auto& layout = layout_cache_[layout_key];
              ImGui::TextColored(theme.status_success, tr("Tiles: %zu"),
                                 layout.cells.size());
 
              if (can_capture_layout) {
                auto& room_ref = (*rooms_)[current_room_id_];
                zelda3::ObjectDrawer drawer(rom_, current_room_id_,
                                            room_ref.get_gfx_buffer().data());
                int rid = drawer.GetDrawRoutineId(obj_id);
                ImGui::TextColored(theme.status_active, tr("Draw Routine: %d"),
                                   rid);
              }
 
              ImGui::Text(tr("Layout:"));
              ImDrawList* tooltip_draw_list = ImGui::GetWindowDrawList();
              ImVec2 grid_start = ImGui::GetCursorScreenPos();
              float cell_size = 4.0f;
              for (const auto& cell : layout.cells) {
                ImVec2 p1(grid_start.x + cell.rel_x * cell_size,
                          grid_start.y + cell.rel_y * cell_size);
                ImVec2 p2(p1.x + cell_size, p1.y + cell_size);
                tooltip_draw_list->AddRectFilled(
                    p1, p2, ThemeColor(theme.dungeon_grid_cell_highlight));
                tooltip_draw_list->AddRect(
                    p1, p2, ThemeColor(theme.panel_border_color));
              }
              ImGui::Dummy(ImVec2(layout.bounds_width * cell_size,
                                  layout.bounds_height * cell_size));
            }
 
            // Routine symbology context — built here (hover-only) so no
            // strings are allocated for off-screen or non-hovered items.
            // sym was computed when the card became visible; accessing it
            // inside the tooltip block is always safe.
            if (!sym.family.empty()) {
              ImGui::Separator();
              // Named specials (Chest, BigKeyLock, etc.) use item_color so
              // they stand out; directional families use secondary text.
              const bool is_named_special =
                  (sym.badge == "C" || sym.badge == "K" || sym.badge == "B" ||
                   sym.badge == "P");
              if (is_named_special) {
                ImGui::TextColored(theme.item_color, tr("Routine: %s"),
                                   sym.family.c_str());
              } else {
                ImGui::TextColored(theme.text_secondary_gray, tr("Routine: %s"),
                                   sym.family.c_str());
              }
              if (sym.dual_layer) {
                ImGui::TextColored(theme.dungeon_object_wall,
                                   tr("  BothBG: writes to BG1 and BG2"));
              }
            }
 
            ImGui::Separator();
            ImGui::TextColored(theme.text_secondary_gray,
                               tr("Click to select for placement"));
            ImGui::EndTooltip();
          }
        }
 
        ImGui::PopID();
 
        current_column = (current_column + 1) % columns;
      }  // end object loop
    }  // end range loop
  }
 
  ImGui::EndChild();
}
 
void DungeonObjectSelector::DrawObjectContextMenu(int object_id, int subtype) {
  if (!ImGui::BeginPopupContextItem("##ObjectActions"))
    return;
  const bool supported =
      subtype >= 0
          ? GetCustomObjectAssetStatus(object_id, subtype).ok()
          : zelda3::ObjectTileEditor::IsEditableStandardObject(object_id);
  const bool has_context = rooms_ && rooms_->GetIfLoaded(current_room_id_);
  const bool can_edit =
      supported && has_context &&
      (subtype >= 0 ? tile_editor_panel_ != nullptr
                    : static_cast<bool>(edit_object_tiles_callback_));
  if (ImGui::MenuItem("Edit tiles...", nullptr, false, can_edit)) {
    const auto status =
        subtype >= 0 ? OpenExistingCustomObjectEditor(object_id, subtype,
                                                      current_room_id_)
                     : edit_object_tiles_callback_(
                           current_room_id_, MakePreviewObject(object_id));
    custom_object_action_error_ =
        status.ok() ? "" : std::string(status.message());
  }
  if (!supported && ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
    ImGui::SetTooltip(
        "Tile editing is available for straight walls, 4x4 corners, "
        "fixed 2x2 objects and custom assets. This layout is not supported "
        "yet.");
  }
  ImGui::EndPopup();
}
 
bool DungeonObjectSelector::MatchesRoomUsage(int obj_id) const {
  if (!used_here_only_)
    return true;
  const auto* room = rooms_ ? rooms_->GetIfLoaded(current_room_id_) : nullptr;
  if (!room)
    return false;
  const auto& objects = room->GetTileObjects();
  return std::any_of(
      objects.begin(), objects.end(),
      [obj_id](const auto& object) { return object.id_ == obj_id; });
}
 
bool DungeonObjectSelector::MatchesObjectFilter(int obj_id, int filter_type) {
  constexpr std::array<const char*, 6> kCategories = {
      "Walls", "Floors", "Chests", "Doors", "Decorations", "Stairs"};
  if (filter_type < 1 || filter_type > static_cast<int>(kCategories.size())) {
    return true;
  }
  const auto category = zelda3::ObjectCategories::GetObjectCategory(obj_id);
  return category.ok() && *category == kCategories[filter_type - 1];
}
 
bool DungeonObjectSelector::MatchesObjectSearch(int obj_id,
                                                const std::string& name,
                                                int subtype) const {
  if (object_search_buffer_[0] == '\0') {
    return true;
  }
 
  auto to_lower = [](std::string value) {
    std::transform(value.begin(), value.end(), value.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    return value;
  };
 
  std::string needle = to_lower(object_search_buffer_);
  std::string name_lower = to_lower(name);
 
  std::string id_hex = absl::StrFormat("%03X", obj_id);
  std::string id_lower = to_lower(id_hex);
  std::string id_pref = "0x" + id_lower;
 
  if (name_lower.find(needle) != std::string::npos) {
    return true;
  }
  if (id_lower.find(needle) != std::string::npos ||
      id_pref.find(needle) != std::string::npos) {
    return true;
  }
 
  if (subtype >= 0) {
    std::string sub_hex = absl::StrFormat("%02X", subtype);
    std::string sub_lower = to_lower(sub_hex);
    std::string combined = id_lower + ":" + sub_lower;
    std::string combined_pref = "0x" + combined;
    if (combined.find(needle) != std::string::npos ||
        combined_pref.find(needle) != std::string::npos) {
      return true;
    }
  }
 
  return false;
}
 
void DungeonObjectSelector::CalculateObjectDimensions(
    const zelda3::RoomObject& object, int& width, int& height) {
  auto [w, h] = zelda3::DimensionService::Get().GetPixelDimensions(object);
  width = std::min(w, 256);
  height = std::min(h, 256);
}
 
void DungeonObjectSelector::EnsureRegistryInitialized() {
  if (registry_initialized_)
    return;
  object_registry_.RegisterVanillaRange(0x000, 0x1FF);
  registry_initialized_ = true;
}
 
void DungeonObjectSelector::SynchronizeCustomObjectGeneration() {
  const bool custom_objects_enabled =
      core::FeatureFlags::get().kEnableCustomObjects;
  const uint64_t generation =
      zelda3::CustomObjectManager::Get().asset_generation();
  const bool custom_feature_changed =
      custom_objects_enabled != observed_custom_objects_enabled_;
  if (generation == observed_custom_object_generation_ &&
      !custom_feature_changed) {
    return;
  }
 
  if (rooms_ != nullptr) {
    rooms_->ForEachMaterialized(
        [](int, zelda3::Room& room) { room.MarkObjectsDirty(); });
  }
  InvalidatePreviewCache();
  observed_custom_object_generation_ = generation;
  observed_custom_objects_enabled_ = custom_objects_enabled;
 
  const int object_id = preview_object_.id_;
  const int subtype = preview_object_.size_ & 0x1F;
  const bool fixed_runtime_slot =
      IsDungeonCustomObjectRuntimeSlot(object_id, subtype);
  auto& custom_object_manager = zelda3::CustomObjectManager::Get();
  const bool exact_override_mapped_now =
      !fixed_runtime_slot &&
      !custom_object_manager.ResolveFilename(object_id, subtype).empty();
  if (!object_loaded_ ||
      (!fixed_runtime_slot && !preview_uses_custom_override_ &&
       !exact_override_mapped_now)) {
    return;
  }
 
  // A subtype-free vanilla selection for a custom runtime family stores an
  // ordinary size in the
  // same bits used by Oracle's custom dispatch. Never reinterpret that queued
  // placement across either feature-state edge; require a fresh selection.
  if (fixed_runtime_slot && custom_feature_changed) {
    object_loaded_ = false;
    selected_object_id_ = -1;
    preview_uses_custom_override_ = false;
    if (placement_invalidated_callback_) {
      placement_invalidated_callback_();
    }
    return;
  }
 
  // With the feature stably disabled, these object IDs retain vanilla size
  // semantics. A custom-asset cache or mapping change is irrelevant to that
  // queued placement.
  if (fixed_runtime_slot && !custom_objects_enabled) {
    return;
  }
 
  if (fixed_runtime_slot &&
      !GetCustomObjectAssetStatus(object_id, subtype).ok()) {
    object_loaded_ = false;
    selected_object_id_ = -1;
    preview_uses_custom_override_ = false;
    if (placement_invalidated_callback_) {
      placement_invalidated_callback_();
    }
    return;
  }
 
  if (!fixed_runtime_slot) {
    preview_uses_custom_override_ =
        custom_objects_enabled &&
        custom_object_manager.GetObjectInternal(object_id, subtype).ok();
  }
 
  if (object_selected_callback_) {
    object_selected_callback_(preview_object_);
  }
}
 
void DungeonObjectSelector::DetachRuntimeContext() {
  edit_object_tiles_callback_ = {};
  rom_ = nullptr;
  game_data_ = nullptr;
  rooms_ = nullptr;
  tile_editor_panel_ = nullptr;
  open_tile_editor_window_callback_ = {};
  open_minecart_editor_window_callback_ = {};
  custom_object_action_error_.clear();
  object_loaded_ = false;
  selected_object_id_ = -1;
  preview_uses_custom_override_ = false;
  placement_invalidated_callback_ = {};
  InvalidatePreviewCache();
  observed_custom_object_generation_ =
      zelda3::CustomObjectManager::Get().asset_generation();
  observed_custom_objects_enabled_ =
      core::FeatureFlags::get().kEnableCustomObjects;
}
 
absl::Status DungeonObjectSelector::GetCustomObjectAssetStatus(int object_id,
                                                               int subtype) {
  if (!IsDungeonCustomObjectRuntimeSlot(object_id, subtype)) {
    return absl::OutOfRangeError(
        "Custom object subtype is outside the runtime dispatch table");
  }
 
  const uint32_t key =
      (static_cast<uint32_t>(object_id) << 8) | static_cast<uint32_t>(subtype);
  if (const auto cached = custom_asset_status_cache_.find(key);
      cached != custom_asset_status_cache_.end()) {
    return cached->second;
  }
 
  auto object_or =
      zelda3::CustomObjectManager::Get().GetObjectInternal(object_id, subtype);
  absl::Status status = object_or.ok() ? absl::OkStatus() : object_or.status();
  custom_asset_status_cache_.emplace(key, status);
  return status;
}
 
zelda3::RoomObject DungeonObjectSelector::MakePreviewObject(int obj_id) const {
  zelda3::RoomObject obj(obj_id, 0, 0,
                         zelda3::DefaultRoomObjectSizeForPlacement(obj_id), 0);
  obj.SetRom(rom_);
  return obj;
}
 
void DungeonObjectSelector::InvalidatePreviewCache() {
  RetirePreviewCache();
  layout_cache_.clear();
  custom_asset_status_cache_.clear();
  ++preview_cache_invalidations_;
}
 
void DungeonObjectSelector::RetirePreviewCache() {
  auto& arena = gfx::Arena::Get();
  for (auto& [key, preview] : preview_cache_) {
    (void)key;
    if (preview != nullptr) {
      arena.RetireBitmap(preview->bitmap());
    }
  }
  preview_cache_.clear();
  failed_preview_keys_.clear();
}
 
void DungeonObjectSelector::SynchronizePreviewCacheRoomContext(
    const zelda3::Room& room) {
  if (current_room_id_ == cached_preview_room_id_ &&
      room.graphics_revision() == cached_preview_graphics_revision_ &&
      room.blockset() == cached_preview_blockset_ &&
      room.render_entrance_blockset() == cached_preview_entrance_blockset_ &&
      room.palette() == cached_preview_palette_ &&
      room.floor1() == cached_preview_floor1_ &&
      room.floor2() == cached_preview_floor2_) {
    return;
  }
 
  InvalidatePreviewCache();
  cached_preview_room_id_ = current_room_id_;
  cached_preview_graphics_revision_ = room.graphics_revision();
  cached_preview_blockset_ = room.blockset();
  cached_preview_entrance_blockset_ = room.render_entrance_blockset();
  cached_preview_palette_ = room.palette();
  cached_preview_floor1_ = room.floor1();
  cached_preview_floor2_ = room.floor2();
}
 
uint32_t DungeonObjectSelector::MakeLayoutCacheKey(int object_id,
                                                   uint8_t preview_size,
                                                   const zelda3::Room* room) {
  uint8_t room_floor = 0;
  if (room != nullptr) {
    if (object_id == 0xC4) {
      room_floor = room->floor1() & 0x0F;
    } else if (object_id == 0xDB) {
      room_floor = room->floor2() & 0x0F;
    }
  }
 
  return (static_cast<uint32_t>(object_id) << 16) |
         (static_cast<uint32_t>(preview_size) << 8) | room_floor;
}
 
bool DungeonObjectSelector::GetOrCreatePreview(const zelda3::RoomObject& object,
                                               gfx::BackgroundBuffer** out) {
  if (out == nullptr) {
    return false;
  }
  *out = nullptr;
  if (!rom_ || !rom_->is_loaded()) {
    return false;
  }
  SynchronizeCustomObjectGeneration();
 
  // Check if room context changed - invalidate cache if so
  const zelda3::Room* room =
      rooms_ != nullptr ? rooms_->GetIfLoaded(current_room_id_) : nullptr;
  if (room == nullptr) {
    return false;
  }
  SynchronizePreviewCacheRoomContext(*room);
 
  // Check if already in cache
  // Key: object, subtype, blockset, palette, and both room floor nibbles.
  // Room/entrance changes clear the complete cache before this lookup.
  const uint8_t preview_size =
      zelda3::CanonicalRoomObjectSize(object.id_, object.size());
  int subtype = preview_size & 0x1F;
  uint64_t cache_key =
      (static_cast<uint64_t>(object.id_) << 32) |
      (static_cast<uint64_t>(subtype) << 24) |
      (static_cast<uint64_t>(cached_preview_blockset_) << 16) |
      (static_cast<uint64_t>(cached_preview_palette_) << 8) |
      (static_cast<uint64_t>(cached_preview_floor1_ & 0x0F) << 4) |
      static_cast<uint64_t>(cached_preview_floor2_ & 0x0F);
 
  auto it = preview_cache_.find(cache_key);
  if (it != preview_cache_.end()) {
    *out = it->second.get();
    return (*out)->bitmap().texture() != nullptr;
  }
  // Objects whose layout cannot be captured or rendered stay failed until the
  // cache is invalidated; without this every visible card rebuilt an
  // ObjectDrawer and two 512x512 buffers each frame.
  if (failed_preview_keys_.count(cache_key) != 0) {
    return false;
  }
 
  // Create new preview using ObjectTileEditor
  const uint8_t* gfx_data = room->get_gfx_buffer().data();
 
  zelda3::ObjectTileEditor editor(rom_);
  auto layout_or = editor.CaptureObjectLayout(
      object.id_, *room, current_palette_group_, preview_size);
  if (!layout_or.ok()) {
    failed_preview_keys_.insert(cache_key);
    return false;
  }
  const auto& layout = layout_or.value();
 
  // Create preview buffer large enough for object
  int bmp_w = std::max(8, layout.bounds_width * 8);
  int bmp_h = std::max(8, layout.bounds_height * 8);
  auto preview = std::make_unique<gfx::BackgroundBuffer>(bmp_w, bmp_h);
  preview->EnsureBitmapInitialized();
 
  // Render layout to bitmap
  auto render_status = editor.RenderLayoutToBitmap(
      layout, preview->bitmap(), gfx_data, current_palette_group_);
  if (!render_status.ok()) {
    gfx::Arena::Get().RetireBitmap(preview->bitmap());
    failed_preview_keys_.insert(cache_key);
    return false;
  }
 
  auto& bitmap = preview->bitmap();
  // Texture creation and SDL sync
  if (!bitmap.surface()) {
    gfx::Arena::Get().RetireBitmap(bitmap);
    failed_preview_keys_.insert(cache_key);
    return false;
  }
  SDL_LockSurface(bitmap.surface());
  memcpy(bitmap.surface()->pixels, bitmap.mutable_data().data(),
         bitmap.mutable_data().size());
  SDL_UnlockSurface(bitmap.surface());
 
  // Install the owner before queuing CREATE. The renderer may defer this
  // command until DoRender, so the Bitmap address must remain valid even when
  // this frame falls back to the symbolic preview.
  auto [cache_it, inserted] =
      preview_cache_.try_emplace(cache_key, std::move(preview));
  if (!inserted) {
    if (preview != nullptr) {
      gfx::Arena::Get().RetireBitmap(preview->bitmap());
    }
    *out = cache_it->second.get();
    return (*out)->bitmap().texture() != nullptr;
  }
 
  *out = cache_it->second.get();
  auto& cached_bitmap = (*out)->bitmap();
  gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
                                        &cached_bitmap);
  gfx::Arena::Get().ProcessTextureQueue(nullptr);
 
  // A null texture is an expected deferred state when the Arena has no active
  // renderer yet. Keep the cache entry and its queued owner alive; the next
  // frame will draw it after DoRender processes CREATE.
  return cached_bitmap.texture() != nullptr;
}
 
bool DungeonObjectSelector::DrawObjectPreview(const zelda3::RoomObject& object,
                                              ImVec2 top_left,
                                              ImVec2 box_size) {
  gfx::BackgroundBuffer* preview = nullptr;
  if (!GetOrCreatePreview(object, &preview)) {
    return false;
  }
 
  // Draw the cached preview image
  auto& bitmap = preview->bitmap();
  if (!bitmap.texture()) {
    return false;
  }
 
  const DungeonObjectPreviewFit fit = ResolveDungeonObjectPreviewFit(
      static_cast<float>(bitmap.width()), static_cast<float>(bitmap.height()),
      box_size.x, box_size.y);
  if (!fit.valid) {
    return false;
  }
 
  const ImVec2 image_top_left(top_left.x + fit.x, top_left.y + fit.y);
  const ImVec2 image_bottom_right(image_top_left.x + fit.width,
                                  image_top_left.y + fit.height);
  ImGui::GetWindowDrawList()->AddImage((ImTextureID)(intptr_t)bitmap.texture(),
                                       image_top_left, image_bottom_right,
                                       ImVec2(0, 0), ImVec2(1, 1),
                                       ImGui::GetColorU32(ImVec4(1, 1, 1, 1)));
  return true;
}
 
absl::Status DungeonObjectSelector::OpenExistingCustomObjectEditor(
    int16_t object_id, int subtype, int room_id) {
  if (tile_editor_panel_ == nullptr) {
    return absl::FailedPreconditionError(
        "Object Tile Editor panel is unavailable");
  }
 
  const absl::Status open_status = tile_editor_panel_->OpenForCustomObject(
      object_id, subtype, room_id, rooms_, current_palette_group_);
  if (!open_status.ok()) {
    if (tile_editor_panel_->IsOpen() && open_tile_editor_window_callback_) {
      (void)open_tile_editor_window_callback_();
    }
    return open_status;
  }
  if (!open_tile_editor_window_callback_ ||
      !open_tile_editor_window_callback_()) {
    tile_editor_panel_->Close();
    return absl::NotFoundError(
        "Object Tile Editor window is not registered in this session");
  }
  return absl::OkStatus();
}
 
void DungeonObjectSelector::DrawCustomObjectAssetBrowser() {
  const auto& theme = AgentUI::GetTheme();
  auto& obj_manager = zelda3::CustomObjectManager::Get();
  const std::string custom_base_path = obj_manager.GetBasePath();
 
  ImGui::TextColored(theme.text_info,
                     ICON_MD_PRECISION_MANUFACTURING " Custom Assets");
  ImGui::PushTextWrapPos(0.0f);
  ImGui::TextColored(
      theme.text_secondary_gray,
      tr("Manage the 21 fixed runtime assets used by Oracle custom objects."));
  ImGui::TextDisabled(
      "%s", tr("New subtypes require an ASM dispatch-table change; this "
               "browser edits or places existing slots only."));
  ImGui::PopTextWrapPos();
  ImGui::Separator();
 
  if (ImGui::BeginTable(
          "##CustomObjectToolbar", 2,
          ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_NoPadOuterX)) {
    ImGui::TableSetupColumn("Status", ImGuiTableColumnFlags_WidthStretch, 2.0f);
    ImGui::TableSetupColumn("Actions", ImGuiTableColumnFlags_WidthFixed,
                            180.0f);
    ImGui::TableNextRow();
 
    ImGui::TableNextColumn();
    if (custom_base_path.empty()) {
      ImGui::TextColored(theme.text_warning_yellow, ICON_MD_WARNING
                         " Custom object folder is not configured.");
    } else {
      ImGui::TextColored(theme.text_secondary_gray,
                         ICON_MD_FOLDER " Asset folder");
      if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip("%s", custom_base_path.c_str());
      }
    }
 
    ImGui::TableNextColumn();
    if (ImGui::Button(ICON_MD_REFRESH " Reload Assets", ImVec2(-1, 0))) {
      obj_manager.ReloadAll();
      SynchronizeCustomObjectGeneration();
      custom_object_action_error_.clear();
    }
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          tr("Refresh custom object and external sprite previews from disk. "
             "Unsaved room and tile edits are kept."));
    }
    ImGui::EndTable();
  }
 
  if (!core::FeatureFlags::get().kEnableCustomObjects) {
    ImGui::TextColored(
        theme.text_warning_yellow, ICON_MD_WARNING
        " Custom Objects is disabled for this project. Enable the feature "
        "before editing or placing runtime assets.");
    return;
  }
 
  ImGui::TextDisabled("%s", tr("Card size"));
  ImGui::SameLine();
  ImGui::SetNextItemWidth(-1.0f);
  ImGui::Combo("##CustomAssetCardSize", &object_grid_density_,
               kObjectGridDensityLabels,
               IM_ARRAYSIZE(kObjectGridDensityLabels));
 
  ImGui::PushTextWrapPos(0.0f);
  ImGui::TextColored(
      theme.text_secondary_gray, ICON_MD_INFO
      " Track tile layouts are assets here; routes and collision are managed "
      "in Minecart Tracks.");
  ImGui::PopTextWrapPos();
  ImGui::Spacing();
 
  struct CustomAssetFamily {
    int object_id;
    const char* label;
    const char* description;
  };
  static constexpr std::array<CustomAssetFamily, 3> kFamilies = {{
      {0x31, "Tracks + Props (16)",
       "Minecart tile layouts, the Sword House wall object, and a small "
       "statue"},
      {0x32, "Ice Props (3)", "Furnace, firewood, and chair assets"},
      {0x54, "Boss Bodies (2)", "Kydreeok and Manhandla body tilemaps"},
  }};
  const CustomAssetFamily* selected_family = &kFamilies.front();
  for (const auto& family : kFamilies) {
    if (custom_asset_family_id_ == family.object_id) {
      selected_family = &family;
      break;
    }
  }
  ImGui::TextDisabled("%s", tr("Asset family"));
  ImGui::SetNextItemWidth(-1.0f);
  if (ImGui::BeginCombo("##CustomAssetFamily", selected_family->label)) {
    for (const auto& family : kFamilies) {
      const bool selected = custom_asset_family_id_ == family.object_id;
      if (ImGui::Selectable(family.label, selected)) {
        custom_asset_family_id_ = family.object_id;
        custom_asset_subtype_ = 0;
        selected_family = &family;
        custom_object_action_error_.clear();
      }
      if (selected) {
        ImGui::SetItemDefaultFocus();
      }
    }
    ImGui::EndCombo();
  }
  ImGui::PushTextWrapPos(0.0f);
  ImGui::TextDisabled("%s", tr(selected_family->description));
  ImGui::PopTextWrapPos();
 
  {
    const ImGuiStyle& style = ImGui::GetStyle();
    const float item_spacing = std::max(2.0f, style.ItemSpacing.x * 0.5f);
    const auto grid_layout = ResolveDungeonObjectSelectorGridLayout(
        ImGui::GetContentRegionAvail().x,
        GetObjectGridItemSize(object_grid_density_), item_spacing);
    const int columns = grid_layout.columns;
    const float item_size = grid_layout.item_size;
    gui::StyleVarGuard grid_spacing_guard(
        ImGuiStyleVar_ItemSpacing,
        ImVec2(item_spacing, std::max(item_spacing, style.ItemSpacing.y)));
    int custom_col = 0;
    for (const int obj_id : zelda3::CustomObjectManager::RuntimeObjectIds()) {
      if (obj_id != custom_asset_family_id_) {
        continue;
      }
      const int subtype_count = std::min(obj_manager.GetSubtypeCount(obj_id),
                                         kPersistedCustomSubtypeSlots);
      for (int subtype = 0; subtype < subtype_count; ++subtype) {
        const std::string subtype_name =
            GetDungeonCustomObjectSlotName(obj_id, subtype);
 
        if (custom_col > 0) {
          ImGui::SameLine(0.0f, item_spacing);
        } else {
          ImGui::SetCursorPosX(ImGui::GetCursorPosX() +
                               grid_layout.leading_inset);
        }
 
        ImGui::PushID(obj_id * 1000 + subtype);
 
        const absl::Status asset_status =
            GetCustomObjectAssetStatus(obj_id, subtype);
        const bool asset_ready = asset_status.ok();
 
        const bool is_selected = custom_asset_family_id_ == obj_id &&
                                 custom_asset_subtype_ == subtype;
        ImVec2 button_size(item_size, item_size);
 
        if (ImGui::Selectable("", is_selected, 0, button_size)) {
          custom_asset_family_id_ = obj_id;
          custom_asset_subtype_ = subtype;
          custom_object_action_error_.clear();
        }
        const bool item_visible = ImGui::IsItemVisible();
        ImVec2 button_pos = ImGui::GetItemRectMin();
        DrawObjectContextMenu(obj_id, subtype);
        if (asset_ready && rooms_ != nullptr &&
            rooms_->GetIfLoaded(current_room_id_) != nullptr) {
          gui::BeginRoomObjectDragSource(
              static_cast<uint16_t>(obj_id), current_room_id_, 0, 0,
              zelda3::CanonicalRoomObjectSize(obj_id,
                                              static_cast<uint8_t>(subtype)));
        }
        ImDrawList* draw_list = ImGui::GetWindowDrawList();
        const bool show_id = item_size >= 44.0f;
        const float footer_height =
            show_id ? std::min(item_size * 0.32f, ImGui::GetFontSize() + 3.0f)
                    : 0.0f;
        const float card_padding = std::min(3.0f, item_size * 0.08f);
        const ImVec2 preview_pos(button_pos.x + card_padding,
                                 button_pos.y + card_padding);
        const ImVec2 preview_box(
            std::max(1.0f, item_size - card_padding * 2.0f),
            std::max(1.0f, item_size - footer_height - card_padding * 2.0f));
 
        bool rendered = false;
        if (item_visible && enable_object_previews_) {
          auto temp_obj = MakePreviewObject(obj_id);
          temp_obj.size_ = zelda3::CanonicalRoomObjectSize(
              obj_id, static_cast<uint8_t>(subtype));
          rendered = DrawObjectPreview(temp_obj, preview_pos, preview_box);
        }
 
        if (item_visible && !rendered) {
          std::string sub_text = absl::StrFormat("%02X", subtype);
          DrawFallbackPreviewTile(
              draw_list, preview_pos, preview_box,
              asset_ready ? theme.status_success : theme.status_error,
              sub_text.c_str());
        }
 
        const bool item_hovered = ImGui::IsItemHovered();
        if (item_visible && (is_selected || item_hovered)) {
          const ImU32 border_color =
              ImGui::GetColorU32(is_selected ? theme.dungeon_selection_primary
                                             : theme.panel_border_color);
          draw_list->AddRect(
              button_pos,
              ImVec2(button_pos.x + item_size, button_pos.y + item_size),
              border_color, 2.0f, 0, is_selected ? 2.0f : 1.0f);
        }
 
        if (item_visible && show_id) {
          const ImVec2 card_bottom(button_pos.x + item_size,
                                   button_pos.y + item_size);
          const float footer_y = card_bottom.y - footer_height;
          draw_list->AddRectFilled(
              ImVec2(button_pos.x, footer_y), card_bottom,
              ImGui::GetColorU32(WithAlpha(theme.panel_bg_darker, 0.88f)),
              2.0f);
          std::string id_text = absl::StrFormat("%02X:%02X", obj_id, subtype);
          ImVec2 id_size = ImGui::CalcTextSize(id_text.c_str());
          ImVec2 id_pos = ImVec2(button_pos.x + (item_size - id_size.x) / 2,
                                 footer_y + (footer_height - id_size.y) * 0.5f);
          draw_list->AddText(id_pos, ImGui::GetColorU32(theme.text_primary),
                             id_text.c_str());
        }
 
        if (item_hovered) {
          gui::StyleColorGuard tooltip_guard(
              {{ImGuiCol_PopupBg, theme.panel_bg_color},
               {ImGuiCol_Border, theme.panel_border_color}});
          if (ImGui::BeginTooltip()) {
            const auto binding_or =
                obj_manager.ResolveSlotBinding(obj_id, subtype);
            const std::string filename =
                binding_or.ok() ? binding_or->filename : "";
 
            ImGui::TextColored(theme.selection_primary,
                               tr("Custom 0x%02X:%02X"), obj_id, subtype);
            ImGui::Text("%s", subtype_name.c_str());
            ImGui::TextColored(
                rendered ? theme.status_success : theme.status_warning,
                tr("Preview: %s"),
                rendered ? "rendered custom layout"
                         : (enable_object_previews_ ? "fallback subtype"
                                                    : "thumbnails off"));
            ImGui::Separator();
            ImGui::Text(tr("File: %s"),
                        filename.empty() ? "(unmapped)" : filename.c_str());
            if (binding_or.ok()) {
              const ImVec4 mapping_color =
                  binding_or->origin ==
                          zelda3::CustomObjectMappingOrigin::kConfiguredFilename
                      ? theme.status_active
                      : (binding_or->origin ==
                                 zelda3::CustomObjectMappingOrigin::
                                     kConfiguredSlotUnmapped
                             ? theme.status_error
                             : theme.text_secondary_gray);
              ImGui::TextColored(
                  mapping_color, tr("Mapping: %s"),
                  tr(CustomObjectMappingOriginLabel(binding_or->origin)));
            }
            if (asset_ready) {
              ImGui::TextColored(theme.status_success,
                                 tr("Asset decoded and ready"));
            } else {
              ImGui::TextColored(theme.status_error, "%s",
                                 asset_status.message().data());
            }
 
            ImGui::EndTooltip();
          }
        }
 
        ImGui::PopID();
        custom_col = (custom_col + 1) % columns;
      }
    }
  }
  ImGui::Separator();
  const std::string selected_name = GetDungeonCustomObjectSlotName(
      custom_asset_family_id_, custom_asset_subtype_);
  const auto selected_binding_or = obj_manager.ResolveSlotBinding(
      custom_asset_family_id_, custom_asset_subtype_);
  const std::string selected_filename =
      selected_binding_or.ok() ? selected_binding_or->filename : "";
  const absl::Status selected_asset_status = GetCustomObjectAssetStatus(
      custom_asset_family_id_, custom_asset_subtype_);
  const auto selected_path_or =
      zelda3::ResolveCustomObjectAssetPath(custom_base_path, selected_filename);
  const bool selected_asset_ready = selected_asset_status.ok();
  ImGui::TextColored(theme.selection_primary, "0x%02X:%02X  %s",
                     custom_asset_family_id_, custom_asset_subtype_,
                     selected_name.c_str());
  ImGui::SameLine();
  ImGui::TextDisabled("%s", selected_filename.empty()
                                ? "(unmapped)"
                                : selected_filename.c_str());
  if (selected_binding_or.ok()) {
    const ImVec4 mapping_color =
        selected_binding_or->origin ==
                zelda3::CustomObjectMappingOrigin::kConfiguredFilename
            ? theme.status_active
            : (selected_binding_or->origin ==
                       zelda3::CustomObjectMappingOrigin::
                           kConfiguredSlotUnmapped
                   ? theme.status_error
                   : theme.text_secondary_gray);
    ImGui::TextColored(
        mapping_color, tr("Mapping: %s"),
        tr(CustomObjectMappingOriginLabel(selected_binding_or->origin)));
  }
  if (selected_asset_ready) {
    ImGui::TextColored(theme.status_success,
                       ICON_MD_CHECK_CIRCLE " Asset ready");
    if (selected_path_or.ok() && ImGui::IsItemHovered()) {
      ImGui::SetTooltip("%s", selected_path_or->string().c_str());
    }
  } else {
    ImGui::TextColored(theme.status_error, ICON_MD_ERROR " %s",
                       selected_asset_status.message().data());
  }
  ImGui::PushTextWrapPos(0.0f);
  if (custom_asset_family_id_ == 0x31 && custom_asset_subtype_ == 13) {
    ImGui::TextDisabled(
        "%s", tr("Custom 0x31 wall object; separate from vanilla wall and "
                 "corner tile tables"));
  } else if (IsMinecartGraphicsRuntimeSlot(custom_asset_family_id_,
                                           custom_asset_subtype_)) {
    ImGui::TextDisabled("%s", tr("Tile layout only; behavior is separate"));
  }
  if (custom_asset_family_id_ == 0x54) {
    ImGui::TextColored(theme.text_warning_yellow, ICON_MD_WARNING
                       " Tilemap editing is available; external boss pixels "
                       "are not loaded into the room preview yet.");
    if (ImGui::IsItemHovered()) {
      ImGui::SetTooltip(
          "%s",
          tr("Oracle forces nonzero body tiles into graphics page 0x300 and "
             "DMA-loads separate Kydreeok or Manhandla graphics at runtime. "
             "Yaze currently preserves the correct tilemap geometry and raw "
             "source words, but the displayed pixels are not visual-parity "
             "evidence."));
    }
  }
  ImGui::PopTextWrapPos();
  if (!custom_object_action_error_.empty()) {
    ImGui::TextColored(theme.status_error, ICON_MD_ERROR " %s",
                       custom_object_action_error_.c_str());
  }
 
  const bool has_room_context =
      rooms_ != nullptr && rooms_->GetIfLoaded(current_room_id_) != nullptr;
#if defined(__EMSCRIPTEN__)
  constexpr bool kCanPublishCustomAssets = false;
#else
  constexpr bool kCanPublishCustomAssets = true;
#endif
  const bool can_edit = selected_asset_ready && has_room_context &&
                        tile_editor_panel_ != nullptr &&
                        kCanPublishCustomAssets;
  const bool can_use_in_room = selected_asset_ready && has_room_context;
  if (ImGui::BeginTable(
          "##CustomAssetActions", 2,
          ImGuiTableFlags_SizingStretchSame | ImGuiTableFlags_NoPadOuterX)) {
    ImGui::TableNextColumn();
    if (!can_edit) {
      ImGui::BeginDisabled();
    }
    if (ImGui::Button(ICON_MD_EDIT " Edit Tile Layout", ImVec2(-1.0f, 0.0f))) {
      const absl::Status status = OpenExistingCustomObjectEditor(
          static_cast<int16_t>(custom_asset_family_id_), custom_asset_subtype_,
          current_room_id_);
      if (status.ok()) {
        custom_object_action_error_.clear();
      } else {
        custom_object_action_error_ = std::string(status.message());
      }
    }
    if (!can_edit) {
      ImGui::EndDisabled();
    }
    if (!kCanPublishCustomAssets &&
        ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
      ImGui::SetTooltip(
          "%s", tr("Custom asset publishing is desktop-only until browser "
                   "persistence can be verified."));
    }
 
    ImGui::TableNextColumn();
    if (!can_use_in_room) {
      ImGui::BeginDisabled();
    }
    if (ImGui::Button(ICON_MD_ADD " Place in Room", ImVec2(-1.0f, 0.0f))) {
      SelectObject(custom_asset_family_id_, custom_asset_subtype_);
      custom_object_action_error_.clear();
    }
    if (!can_use_in_room) {
      ImGui::EndDisabled();
    }
    ImGui::EndTable();
  }
 
  if (IsMinecartGraphicsRuntimeSlot(custom_asset_family_id_,
                                    custom_asset_subtype_)) {
    const bool can_open_minecart =
        static_cast<bool>(open_minecart_editor_window_callback_);
    if (!can_open_minecart) {
      ImGui::BeginDisabled();
    }
    if (ImGui::Button(ICON_MD_TRAIN " Minecart Routes & Collision",
                      ImVec2(-1.0f, 0.0f))) {
      if (open_minecart_editor_window_callback_()) {
        custom_object_action_error_.clear();
      } else {
        custom_object_action_error_ =
            "Minecart Tracks window is unavailable in this session";
      }
    }
    if (!can_open_minecart) {
      ImGui::EndDisabled();
    }
  }
}
 
}  // namespace yaze::editor