dungeon_canvas_context_menu.cc

Go to the documentation of this file.

#include "app/editor/dungeon/dungeon_canvas_viewer.h"
 
#include <optional>
#include <string>
#include <utility>
 
#include "absl/strings/str_format.h"
#include "app/editor/dungeon/dungeon_canvas_transform.h"
#include "app/editor/dungeon/dungeon_coordinates.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/platform_keys.h"
#include "imgui/imgui.h"
#include "util/log.h"
#include "zelda3/dungeon/chest_edit.h"
#include "zelda3/dungeon/object_layer_semantics.h"
#include "zelda3/dungeon/object_tile_editor.h"
#include "zelda3/resource_labels.h"
#include "zelda3/sprite/sprite.h"
 
namespace yaze::editor {
 
namespace {
 
std::pair<int, int> ContextMenuRoomPosition(const gui::Canvas& canvas) {
  ImVec2 screen_position = ImGui::GetIO().MousePos;
  if (!ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {
    if (const auto popup_anchor = canvas.context_menu_open_screen_position();
        popup_anchor.has_value()) {
      screen_position = *popup_anchor;
    }
  }
  return DungeonCanvasTransform(canvas.zero_point(), canvas.scrolling(),
                                canvas.global_scale())
      .ScreenToRoomPixelCoordinates(screen_position);
}
 
}  // namespace
 
void DungeonCanvasViewer::PopulateCanvasContextMenu(int room_id) {
  canvas_.ClearContextMenuItems();
  AddInteractionContextMenuItems(room_id);
  AddLoadedRoomContextMenuItems(room_id);
}
 
void DungeonCanvasViewer::AddInteractionContextMenuItems(int room_id) {
  if (!object_interaction_enabled_) {
    return;
  }
 
  for (auto& item : BuildSelectionContextMenuItems(room_id)) {
    canvas_.AddContextMenuItem(std::move(item));
  }
  auto insert_menu = BuildInsertContextMenu();
  insert_menu.separator_after = true;
  canvas_.AddContextMenuItem(insert_menu);
}
 
void DungeonCanvasViewer::AddLoadedRoomContextMenuItems(int room_id) {
  if (!rooms_ || !rom_ || !rom_->is_loaded()) {
    return;
  }
 
  if (show_dungeon_settings_callback_) {
    gui::CanvasMenuItem inspector("Inspector...", ICON_MD_TUNE, [this]() {
      show_dungeon_settings_callback_();
    });
    inspector.separator_after = true;
    canvas_.AddContextMenuItem(std::move(inspector));
  }
  canvas_.AddContextMenuItem(BuildRoomContextMenu(room_id));
  if (auto open_menu = BuildOpenContextMenu(); open_menu.has_value()) {
    canvas_.AddContextMenuItem(std::move(*open_menu));
  }
  gui::CanvasMenuItem view;
  view.label = "View";
  view.icon = ICON_MD_VISIBILITY;
  view.subitems.emplace_back("Fit room", ICON_MD_FIT_SCREEN, [this, room_id] {
    if (auto* bitmap = PrepareRoomCompositeBitmap(room_id)) {
      canvas_.SetZoomToFit(*bitmap);
      room_viewport_auto_fit_ = true;
      room_viewport_last_scale_ = canvas_.global_scale();
    }
  });
  view.subitems.emplace_back("Zoom in", ICON_MD_ZOOM_IN, [this] {
    room_viewport_auto_fit_ = false;
    canvas_.ZoomIn();
  });
  view.subitems.emplace_back("Zoom out", ICON_MD_ZOOM_OUT, [this] {
    room_viewport_auto_fit_ = false;
    canvas_.ZoomOut();
  });
  view.subitems.back().separator_after = true;
  view.subitems.push_back(BuildLayerVisibilityContextMenu(room_id));
  view.subitems.push_back(BuildOverlayContextMenu());
  canvas_.AddContextMenuItem(std::move(view));
  canvas_.AddContextMenuItem(BuildCopyExportContextMenu(room_id));
  auto debug = BuildDebugContextMenu(room_id);
  debug.subitems.back().separator_after = true;
  debug.subitems.push_back(BuildReportContextMenu(room_id));
  canvas_.AddContextMenuItem(std::move(debug));
}
 
gui::CanvasMenuItem DungeonCanvasViewer::BuildInsertContextMenu() {
  auto enabled_if = [](bool enabled) {
    return [enabled]() {
      return enabled;
    };
  };
 
  gui::CanvasMenuItem insert_menu;
  insert_menu.label = "Insert";
  insert_menu.icon = ICON_MD_ADD_CIRCLE;
 
  gui::CanvasMenuItem insert_object_item("Object...", ICON_MD_WIDGETS,
                                         [this]() {
                                           if (show_object_panel_callback_) {
                                             show_object_panel_callback_();
                                           }
                                         });
  insert_object_item.enabled_condition =
      enabled_if(show_object_panel_callback_ != nullptr);
  insert_menu.subitems.push_back(std::move(insert_object_item));
 
  gui::CanvasMenuItem insert_sprite_item("Sprite...", ICON_MD_PERSON, [this]() {
    if (show_sprite_panel_callback_) {
      show_sprite_panel_callback_();
    }
  });
  insert_sprite_item.enabled_condition =
      enabled_if(show_sprite_panel_callback_ != nullptr);
  insert_menu.subitems.push_back(std::move(insert_sprite_item));
 
  gui::CanvasMenuItem insert_item_item("Item...", ICON_MD_INVENTORY, [this]() {
    if (show_item_panel_callback_) {
      show_item_panel_callback_();
    }
  });
  insert_item_item.enabled_condition =
      enabled_if(show_item_panel_callback_ != nullptr);
  insert_menu.subitems.push_back(std::move(insert_item_item));
 
  const bool door_mode = object_interaction_.IsDoorPlacementActive();
  insert_menu.subitems.emplace_back(
      door_mode ? "Cancel Door Placement" : "Door (Normal)", ICON_MD_DOOR_FRONT,
      [this, door_mode]() {
        object_interaction_.SetDoorPlacementMode(!door_mode,
                                                 zelda3::DoorType::NormalDoor);
      });
 
  return insert_menu;
}
 
std::optional<zelda3::RoomObject>
DungeonCanvasViewer::GetObjectUnderContextCursor(int room_id) {
  const auto index = GetObjectIndexUnderContextCursor(room_id);
  return index ? std::optional((*rooms_)[room_id].GetTileObjects()[*index])
               : std::nullopt;
}
 
std::optional<size_t> DungeonCanvasViewer::GetObjectIndexUnderContextCursor(
    int room_id) {
  if (!rooms_ || room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
    return std::nullopt;
  }
 
  const auto [canvas_x, canvas_y] = ContextMenuRoomPosition(canvas_);
  if (!dungeon_coords::IsWithinBounds(canvas_x, canvas_y)) {
    return std::nullopt;
  }
  const auto hovered_index = object_interaction_.entity_coordinator()
                                 .tile_handler()
                                 .GetEntityAtPosition(canvas_x, canvas_y);
  if (!hovered_index.has_value()) {
    return std::nullopt;
  }
 
  const auto& objects = (*rooms_)[room_id].GetTileObjects();
  if (*hovered_index >= objects.size()) {
    return std::nullopt;
  }
  return hovered_index;
}
 
std::vector<gui::CanvasMenuItem>
DungeonCanvasViewer::BuildSelectionContextMenuItems(int room_id) {
  return BuildSelectionContextMenuItems(room_id,
                                        GetObjectUnderContextCursor(room_id));
}
 
std::vector<gui::CanvasMenuItem>
DungeonCanvasViewer::BuildSelectionContextMenuItems(
    int room_id, std::optional<zelda3::RoomObject> context_object) {
  auto& interaction = object_interaction_;
  const auto selected = interaction.GetSelectedObjectIndices();
  const bool has_entity_selection = interaction.HasEntitySelection();
  const bool has_selection = !selected.empty() || has_entity_selection;
  const bool single_selection = selected.size() == 1 && !has_entity_selection;
  const bool has_clipboard = interaction.HasClipboardData();
  const bool placing_object = interaction.IsObjectLoaded();
  const bool valid_room =
      rooms_ && room_id >= 0 && room_id < zelda3::kNumberOfRooms;
  bool has_room_stream_object = false;
  bool has_special_layer_object = false;
  if (has_selection && valid_room) {
    const auto& objects = (*rooms_)[room_id].GetTileObjects();
    for (const size_t index : selected) {
      if (index >= objects.size()) {
        continue;
      }
      if (zelda3::UsesRoomObjectStream(objects[index])) {
        has_room_stream_object = true;
      } else {
        has_special_layer_object = true;
      }
    }
  }
 
  std::vector<gui::CanvasMenuItem> items;
 
  if (valid_room) {
    auto& room = (*rooms_)[room_id];
    std::optional<size_t> chest_index;
    if (context_object &&
        zelda3::IsStatefulChestObjectId(context_object->id_)) {
      if (const auto index = GetObjectIndexUnderContextCursor(room_id)) {
        chest_index =
            zelda3::ChestIndexForObject(room.GetTileObjects(), *index);
      }
    }
    if (!chest_index && single_selection) {
      chest_index =
          zelda3::ChestIndexForObject(room.GetTileObjects(), selected.front());
    }
    if (chest_index) {
      gui::CanvasMenuItem edit_chest(
          "Edit Chest...", ICON_MD_EDIT,
          [this, room_id, index = *chest_index]() {
            const auto status = OpenChestEditor(room_id, index);
            chest_editor_state_.error =
                status.ok() ? "" : std::string(status.message());
          });
      edit_chest.enabled_condition = [this, room_id, index = *chest_index]() {
        const auto* room = rooms_ ? rooms_->GetIfLoaded(room_id) : nullptr;
        return !header_read_only_ && IsObjectInteractionEnabled() &&
               chest_edit_callback_ && room && room->AreChestsLoaded() &&
               index < room->GetChests().size();
      };
      edit_chest.tooltip = "Edit this chest's reward and type.";
      edit_chest.separator_after = true;
      items.push_back(std::move(edit_chest));
    }
  }
 
  bool can_edit_selected_graphics = false;
  std::function<void()> edit_selected_graphics;
  bool can_edit_selected_tiles = false;
  std::function<void()> edit_selected_tiles;
  std::function<void()> check_selected_coverage;
  if (single_selection && valid_room) {
    auto& room = (*rooms_)[room_id];
    const auto& objects = room.GetTileObjects();
    if (selected[0] < objects.size()) {
      const auto object = objects[selected[0]];
      can_edit_selected_graphics = edit_graphics_callback_ != nullptr ||
                                   show_room_graphics_callback_ != nullptr;
      edit_selected_graphics = [this, room_id, object]() {
        if (edit_graphics_callback_) {
          edit_graphics_callback_(room_id, object);
        } else if (show_room_graphics_callback_) {
          show_room_graphics_callback_();
        }
      };
      can_edit_selected_tiles =
          edit_object_tiles_callback_ != nullptr &&
          zelda3::ObjectTileEditor::IsEditableStandardObject(object.id_);
      edit_selected_tiles = [this, room_id, object]() {
        if (edit_object_tiles_callback_) {
          edit_object_tiles_callback_(room_id, object);
        }
      };
      if (check_object_coverage_callback_) {
        check_selected_coverage = [this, room_id, object]() {
          check_object_coverage_callback_(room_id, object);
        };
      }
    }
  }
 
  auto enabled_if = [](bool enabled) {
    return [enabled]() {
      return enabled;
    };
  };
  auto paste_item = [&]() {
    const auto [room_x, room_y] =
        has_clipboard ? ContextMenuRoomPosition(canvas_) : std::pair{0, 0};
    gui::CanvasMenuItem item(
        "Paste", ICON_MD_CONTENT_PASTE,
        [&interaction, room_x = room_x, room_y = room_y]() {
          (void)interaction.HandlePasteObjectsAt(room_x, room_y);
        },
        gui::FormatCtrlShortcut(ImGuiKey_V));
    item.enabled_condition = enabled_if(has_clipboard);
    return item;
  };
  auto disabled_item = [](const char* label, const char* icon,
                          const char* shortcut = nullptr) {
    gui::CanvasMenuItem item;
    item.label = label;
    item.icon = icon;
    if (shortcut != nullptr) {
      item.shortcut = shortcut;
    }
    item.enabled_condition = []() {
      return false;
    };
    return item;
  };
  auto layer_item = [&interaction](const char* label, int layer,
                                   const char* shortcut) {
    return gui::CanvasMenuItem(
        label, ICON_MD_LAYERS,
        [&interaction, layer]() { interaction.SendSelectedToLayer(layer); },
        shortcut);
  };
 
  gui::CanvasMenuItem sample_item("Use Object as Brush", ICON_MD_COLORIZE,
                                  [this, context_object]() {
                                    if (context_object.has_value()) {
                                      SetPreviewObject(*context_object);
                                    }
                                  });
  sample_item.enabled_condition = enabled_if(context_object.has_value());
  sample_item.separator_after = true;
 
  if (has_selection) {
    items.emplace_back(
        "Cut", ICON_MD_CONTENT_CUT,
        [&interaction]() {
          if (interaction.HandleCopySelected().ok()) {
            (void)interaction.HandleDeleteSelected();
          }
        },
        gui::FormatCtrlShortcut(ImGuiKey_X));
    items.emplace_back(
        "Copy", ICON_MD_CONTENT_COPY,
        [&interaction]() { (void)interaction.HandleCopySelected(); },
        gui::FormatCtrlShortcut(ImGuiKey_C));
    items.push_back(paste_item());
    items.emplace_back("Duplicate", ICON_MD_FILE_COPY, [&interaction]() {
      (void)interaction.HandleDuplicateSelected();
    });
    items.push_back(gui::CanvasMenuItem::Destructive(
        "Delete", ICON_MD_DELETE,
        [&interaction]() { (void)interaction.HandleDeleteSelected(); },
        /*confirm=*/false, "Delete"));
 
    items.back().separator_after = true;
    if (!selected.empty()) {
      gui::CanvasMenuItem arrange;
      arrange.label = "Arrange";
      arrange.icon = ICON_MD_LAYERS;
      arrange.subitems.emplace_back(
          "Bring to Front", ICON_MD_FLIP_TO_FRONT,
          [&interaction]() { interaction.SendSelectedToFront(); },
          gui::FormatCtrlShiftShortcut(ImGuiKey_RightBracket));
      arrange.subitems.emplace_back(
          "Send to Back", ICON_MD_FLIP_TO_BACK,
          [&interaction]() { interaction.SendSelectedToBack(); },
          gui::FormatCtrlShiftShortcut(ImGuiKey_LeftBracket));
 
      arrange.subitems.emplace_back(
          "Bring Forward", ICON_MD_ARROW_UPWARD,
          [&interaction]() { interaction.BringSelectedForward(); },
          gui::FormatCtrlShortcut(ImGuiKey_RightBracket));
      arrange.subitems.emplace_back(
          "Send Backward", ICON_MD_ARROW_DOWNWARD,
          [&interaction]() { interaction.SendSelectedBackward(); },
          gui::FormatCtrlShortcut(ImGuiKey_LeftBracket));
      items.push_back(std::move(arrange));
 
      gui::CanvasMenuItem placement;
      placement.label = "Placement";
      placement.icon = ICON_MD_LAYERS;
 
      if (has_room_stream_object && !has_special_layer_object) {
        placement.subitems.push_back(
            layer_item("Object Stream: Primary", 0, "1"));
        placement.subitems.push_back(
            layer_item("Object Stream: BG2 Overlay", 1, "2"));
        placement.subitems.push_back(
            layer_item("Object Stream: BG1 Overlay", 2, "3"));
      } else if (has_special_layer_object && !has_room_stream_object) {
        placement.subitems.push_back(layer_item("Upper Layer (BG1)", 0, "1"));
        placement.subitems.push_back(layer_item("Lower Layer (BG2)", 1, "2"));
      } else {
        placement.subitems.push_back(
            layer_item("Placement 0: Primary / Upper Layer (BG1)", 0, "1"));
        placement.subitems.push_back(
            layer_item("Placement 1: BG2 Overlay / Lower Layer (BG2)", 1, "2"));
      }
      items.push_back(std::move(placement));
    }
  }
 
  if (can_edit_selected_graphics) {
    items.emplace_back("Edit Graphics...", ICON_MD_IMAGE,
                       std::move(edit_selected_graphics));
  }
  if (can_edit_selected_tiles) {
    items.emplace_back("Edit Object Tiles...", ICON_MD_GRID_ON,
                       std::move(edit_selected_tiles));
  }
  if (check_selected_coverage) {
    items.emplace_back("Check in Object Coverage", ICON_MD_FACT_CHECK,
                       std::move(check_selected_coverage));
  }
 
  if (!has_selection && !has_entity_selection) {
    items.push_back(paste_item());
    items.push_back(disabled_item("Delete", ICON_MD_DELETE, "Delete"));
  }
 
  items.push_back(std::move(sample_item));
 
  if (placing_object) {
    gui::CanvasMenuItem cancel_item(
        "Cancel Placement", ICON_MD_CANCEL,
        [&interaction]() { interaction.CancelPlacement(); }, "Esc");
    if (!items.empty()) {
      items.back().separator_after = true;
    }
    items.push_back(std::move(cancel_item));
  }
 
  return items;
}
 
gui::CanvasMenuItem DungeonCanvasViewer::BuildRoomContextMenu(int room_id) {
  gui::CanvasMenuItem room_menu;
  room_menu.label = "Room";
  room_menu.icon = ICON_MD_HOME;
  gui::CanvasMenuItem transfer_item(
      "Clone / Import Room...", ICON_MD_CONTENT_COPY, [this, room_id]() {
        room_transfer_state_.popup_room_id = room_id;
        room_transfer_state_.request_popup = true;
      });
  room_menu.subitems.push_back(std::move(transfer_item));
  if (save_room_callback_) {
    room_menu.subitems.emplace_back(
        "Apply Room to ROM", ICON_MD_SAVE,
        [this, room_id]() { save_room_callback_(room_id); });
  }
  room_menu.subitems.emplace_back(
      "Re-render Room", ICON_MD_REFRESH, [this, room_id]() {
        if (rooms_ && room_id >= 0 && room_id < zelda3::kNumberOfRooms) {
          (*rooms_)[room_id].RenderRoomGraphics();
        }
      });
  if (rooms_ && !(*rooms_)[room_id].GetTileObjects().empty()) {
    room_menu.subitems.push_back(gui::CanvasMenuItem::Destructive(
        "Delete All Objects...", ICON_MD_DELETE_FOREVER,
        [this]() { object_interaction_.HandleDeleteAllObjects(); }));
  }
  return room_menu;
}
 
gui::CanvasMenuItem DungeonCanvasViewer::BuildReportContextMenu(int room_id) {
  gui::CanvasMenuItem report_menu;
  report_menu.label = "Capture Issue";
  report_menu.icon = ICON_MD_BUG_REPORT;
  report_menu.subitems.emplace_back(
      "Room Rendering...", ICON_MD_BUG_REPORT, [this, room_id]() {
        if (!rooms_ || room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
          return;
        }
        OpenIssueReportPopup(
            absl::StrFormat("Capture Room 0x%03X Rendering Issue", room_id),
            absl::StrFormat("Room 0x%03X render mismatch", room_id),
            "Dungeon Render Issue Report",
            BuildDrawIssueReport((*rooms_)[room_id], room_id), room_id,
            ToIssueCategoryIndex(
                DungeonIssueCategory::GeneralRoomRenderMismatch));
      });
  report_menu.subitems.emplace_back(
      "Room Palette...", ICON_MD_PALETTE, [this, room_id]() {
        if (!rooms_ || room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
          return;
        }
        OpenIssueReportPopup(
            absl::StrFormat("Capture Room 0x%03X Palette Issue", room_id),
            absl::StrFormat("Room 0x%03X palette mismatch", room_id),
            "Dungeon Palette Issue Report",
            BuildDrawIssueReport((*rooms_)[room_id], room_id), room_id,
            ToIssueCategoryIndex(DungeonIssueCategory::PaletteMismatch));
      });
  if (object_interaction_.GetSelectionCount() > 0 ||
      object_interaction_.HasEntitySelection()) {
    report_menu.subitems.emplace_back(
        "Current Selection...", ICON_MD_FACT_CHECK, [this, room_id]() {
          if (!rooms_ || room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
            return;
          }
          OpenIssueReportPopup(
              absl::StrFormat("Capture Selection Issue for Room 0x%03X",
                              room_id),
              absl::StrFormat("Room 0x%03X selection or entity mismatch",
                              room_id),
              "Dungeon Selection Issue Report",
              BuildSelectionIssueReport((*rooms_)[room_id], room_id), room_id,
              ToIssueCategoryIndex(
                  GetDefaultSelectionIssueCategory(object_interaction_)));
        });
  }
  return report_menu;
}
 
std::optional<gui::CanvasMenuItem> DungeonCanvasViewer::BuildOpenContextMenu() {
  gui::CanvasMenuItem open_menu;
  open_menu.label = "Open";
  open_menu.icon = ICON_MD_OPEN_IN_NEW;
  if (show_room_list_callback_) {
    open_menu.subitems.emplace_back("Room List", ICON_MD_LIST,
                                    [this]() { show_room_list_callback_(); });
  }
  if (show_room_matrix_callback_) {
    open_menu.subitems.emplace_back("Room Matrix", ICON_MD_GRID_VIEW,
                                    [this]() { show_room_matrix_callback_(); });
  }
  if (show_room_graphics_callback_) {
    open_menu.subitems.emplace_back("Room Graphics", ICON_MD_IMAGE, [this]() {
      show_room_graphics_callback_();
    });
  }
  if (show_door_editor_callback_) {
    open_menu.subitems.emplace_back("Door Editor", ICON_MD_DOOR_FRONT,
                                    [this]() { show_door_editor_callback_(); });
  }
  if (show_entrance_list_callback_) {
    open_menu.subitems.emplace_back("Entrance List", ICON_MD_LOGIN, [this]() {
      show_entrance_list_callback_();
    });
  }
  if (open_menu.subitems.empty()) {
    return std::nullopt;
  }
  return open_menu;
}
 
gui::CanvasMenuItem DungeonCanvasViewer::BuildCopyExportContextMenu(
    int room_id) {
  gui::CanvasMenuItem copy_export_menu;
  copy_export_menu.label = "Export";
  copy_export_menu.icon = ICON_MD_CONTENT_COPY;
  copy_export_menu.subitems.emplace_back(
      "Copy Room Summary", ICON_MD_ASSIGNMENT, [this, room_id]() {
        if (!rooms_ || room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
          return;
        }
        ImGui::SetClipboardText(
            BuildRoomMetadataSummary((*rooms_)[room_id], room_id).c_str());
      });
  copy_export_menu.subitems.emplace_back(
      "Copy Room ID", ICON_MD_CONTENT_COPY, [room_id]() {
        ImGui::SetClipboardText(absl::StrFormat("0x%03X", room_id).c_str());
      });
  if (rooms_ && room_id >= 0 && room_id < zelda3::kNumberOfRooms) {
    const std::string room_label = zelda3::GetRoomLabel(room_id);
    copy_export_menu.subitems.emplace_back(
        "Copy Room Name", ICON_MD_CONTENT_COPY,
        [room_label]() { ImGui::SetClipboardText(room_label.c_str()); });
  }
  copy_export_menu.subitems.emplace_back(
      "Copy Layout Template", ICON_MD_CONTENT_COPY, [this, room_id]() {
        if (!rooms_ || room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
          return;
        }
        auto& room = (*rooms_)[room_id];
        auto result = zelda3::ExportRoomLayoutTemplate(room);
        if (result.ok()) {
          ImGui::SetClipboardText(result.value().c_str());
        }
      });
  return copy_export_menu;
}
 
gui::CanvasMenuItem DungeonCanvasViewer::BuildLayerVisibilityContextMenu(
    int room_id) {
  gui::CanvasMenuItem layers_menu;
  layers_menu.label = "Layers";
  layers_menu.icon = ICON_MD_VISIBILITY;
 
  gui::CanvasMenuItem bg1_layout_item("BG1 Layout", [this, room_id]() {
    auto& mgr = GetRoomLayerManager(room_id);
    mgr.SetLayerVisible(zelda3::LayerType::BG1_Layout,
                        !mgr.IsLayerVisible(zelda3::LayerType::BG1_Layout));
  });
  bg1_layout_item.checked_condition = [this, room_id]() {
    return GetRoomLayerManager(room_id).IsLayerVisible(
        zelda3::LayerType::BG1_Layout);
  };
  layers_menu.subitems.push_back(std::move(bg1_layout_item));
 
  gui::CanvasMenuItem bg1_objects_item("BG1 Objects", [this, room_id]() {
    auto& mgr = GetRoomLayerManager(room_id);
    mgr.SetLayerVisible(zelda3::LayerType::BG1_Objects,
                        !mgr.IsLayerVisible(zelda3::LayerType::BG1_Objects));
  });
  bg1_objects_item.checked_condition = [this, room_id]() {
    return GetRoomLayerManager(room_id).IsLayerVisible(
        zelda3::LayerType::BG1_Objects);
  };
  layers_menu.subitems.push_back(std::move(bg1_objects_item));
 
  gui::CanvasMenuItem bg2_layout_item("BG2 Layout", [this, room_id]() {
    auto& mgr = GetRoomLayerManager(room_id);
    mgr.SetLayerVisible(zelda3::LayerType::BG2_Layout,
                        !mgr.IsLayerVisible(zelda3::LayerType::BG2_Layout));
  });
  bg2_layout_item.checked_condition = [this, room_id]() {
    return GetRoomLayerManager(room_id).IsLayerVisible(
        zelda3::LayerType::BG2_Layout);
  };
  layers_menu.subitems.push_back(std::move(bg2_layout_item));
 
  gui::CanvasMenuItem bg2_objects_item("BG2 Objects", [this, room_id]() {
    auto& mgr = GetRoomLayerManager(room_id);
    mgr.SetLayerVisible(zelda3::LayerType::BG2_Objects,
                        !mgr.IsLayerVisible(zelda3::LayerType::BG2_Objects));
  });
  bg2_objects_item.checked_condition = [this, room_id]() {
    return GetRoomLayerManager(room_id).IsLayerVisible(
        zelda3::LayerType::BG2_Objects);
  };
  layers_menu.subitems.push_back(std::move(bg2_objects_item));
 
  // The game hides the lower tilemap (BG2 here) in rooms whose layer settings
  // put it on neither the main nor the sub screen; show it anyway for editing.
  gui::CanvasMenuItem hidden_layers_item(
      "Show Layers the Game Hides", ICON_MD_VISIBILITY_OFF, [this, room_id]() {
        auto& mgr = GetRoomLayerManager(room_id);
        mgr.SetShowHiddenLayers(!mgr.ShowHiddenLayers());
      });
  hidden_layers_item.enabled_condition = [this, room_id]() {
    return GetRoomLayerManager(room_id).GameHidesLowerTilemap();
  };
  hidden_layers_item.checked_condition = [this, room_id]() {
    return GetRoomLayerManager(room_id).ShowHiddenLayers();
  };
  layers_menu.subitems.push_back(std::move(hidden_layers_item));
 
  gui::CanvasMenuItem sprites_item("Sprites", ICON_MD_PERSON, [this]() {
    entity_visibility_.show_sprites = !entity_visibility_.show_sprites;
  });
  sprites_item.checked_condition = [this]() {
    return entity_visibility_.show_sprites;
  };
  layers_menu.subitems.push_back(std::move(sprites_item));
 
  gui::CanvasMenuItem pot_items_item("Pot Items", ICON_MD_INVENTORY, [this]() {
    entity_visibility_.show_pot_items = !entity_visibility_.show_pot_items;
  });
  pot_items_item.checked_condition = [this]() {
    return entity_visibility_.show_pot_items;
  };
  layers_menu.subitems.push_back(std::move(pot_items_item));
 
  return layers_menu;
}
 
gui::CanvasMenuItem DungeonCanvasViewer::BuildOverlayContextMenu() {
  gui::CanvasMenuItem overlays_menu;
  overlays_menu.label = "Overlays";
  overlays_menu.icon = ICON_MD_LAYERS;
 
  gui::CanvasMenuItem chest_contents_item("Chest contents", [this]() {
    SetChestContentsVisible(!AreChestContentsVisible());
  });
  chest_contents_item.checked_condition = [this]() {
    return AreChestContentsVisible();
  };
  overlays_menu.subitems.push_back(std::move(chest_contents_item));
 
  gui::CanvasMenuItem coordinates_item(
      "Coordinates", ICON_MD_MY_LOCATION,
      [this]() { show_coordinate_overlay_ = !show_coordinate_overlay_; });
  coordinates_item.checked_condition = [this]() {
    return show_coordinate_overlay_;
  };
  overlays_menu.subitems.push_back(std::move(coordinates_item));
 
  gui::CanvasMenuItem minecart_toggle(
      "Minecart Tracks", ICON_MD_TRAIN,
      [this]() { show_minecart_tracks_ = !show_minecart_tracks_; });
  minecart_toggle.enabled_condition = [this]() {
    return minecart_track_panel_ != nullptr;
  };
  minecart_toggle.checked_condition = [this]() {
    return show_minecart_tracks_;
  };
  overlays_menu.subitems.push_back(std::move(minecart_toggle));
 
  gui::CanvasMenuItem custom_collision_item(
      "Custom Collision", ICON_MD_GRID_ON, [this]() {
        show_custom_collision_overlay_ = !show_custom_collision_overlay_;
      });
  custom_collision_item.checked_condition = [this]() {
    return show_custom_collision_overlay_;
  };
  overlays_menu.subitems.push_back(std::move(custom_collision_item));
 
  gui::CanvasMenuItem track_collision_item(
      "Track Collision", ICON_MD_LAYERS, [this]() {
        show_track_collision_overlay_ = !show_track_collision_overlay_;
      });
  track_collision_item.checked_condition = [this]() {
    return show_track_collision_overlay_;
  };
  overlays_menu.subitems.push_back(std::move(track_collision_item));
 
  gui::CanvasMenuItem camera_quadrants_item(
      "Camera Quadrants", ICON_MD_GRID_VIEW, [this]() {
        show_camera_quadrant_overlay_ = !show_camera_quadrant_overlay_;
      });
  camera_quadrants_item.checked_condition = [this]() {
    return show_camera_quadrant_overlay_;
  };
  overlays_menu.subitems.push_back(std::move(camera_quadrants_item));
 
  gui::CanvasMenuItem minecart_sprites_item(
      "Minecart Sprites", ICON_MD_TRAIN, [this]() {
        show_minecart_sprite_overlay_ = !show_minecart_sprite_overlay_;
      });
  minecart_sprites_item.checked_condition = [this]() {
    return show_minecart_sprite_overlay_;
  };
  overlays_menu.subitems.push_back(std::move(minecart_sprites_item));
 
  if (show_track_collision_overlay_) {
    gui::CanvasMenuItem collision_legend_item(
        "Collision Legend", ICON_MD_INFO, [this]() {
          show_track_collision_legend_ = !show_track_collision_legend_;
        });
    collision_legend_item.checked_condition = [this]() {
      return show_track_collision_legend_;
    };
    overlays_menu.subitems.push_back(std::move(collision_legend_item));
  }
 
  gui::CanvasMenuItem object_bounds_item(
      "Object Bounds", ICON_MD_CROP_SQUARE,
      [this]() { show_object_bounds_ = !show_object_bounds_; });
  object_bounds_item.checked_condition = [this]() {
    return show_object_bounds_;
  };
  overlays_menu.subitems.push_back(std::move(object_bounds_item));
 
  return overlays_menu;
}
 
gui::CanvasMenuItem DungeonCanvasViewer::BuildDebugContextMenu(int room_id) {
  gui::CanvasMenuItem debug_menu;
  debug_menu.label = "Debug";
  debug_menu.icon = ICON_MD_BUG_REPORT;
 
  debug_menu.subitems.emplace_back(
      "Chest Records...", ICON_MD_INVENTORY, [this, room_id]() {
        chest_edit_dialog_state_.diagnostics_room_id = room_id;
        chest_edit_dialog_state_.show_diagnostics = true;
      });
  debug_menu.subitems.back().separator_after = true;
 
  debug_menu.subitems.push_back(gui::CanvasMenuItem(
      "Room Info", ICON_MD_INFO,
      [this]() { show_room_debug_info_ = !show_room_debug_info_; }));
  debug_menu.subitems.back().checked_condition = [this]() {
    return show_room_debug_info_;
  };
 
  debug_menu.subitems.push_back(gui::CanvasMenuItem(
      "Texture Debug", ICON_MD_IMAGE,
      [this]() { show_texture_debug_ = !show_texture_debug_; }));
  debug_menu.subitems.back().checked_condition = [this]() {
    return show_texture_debug_;
  };
 
  gui::CanvasMenuItem object_bounds_menu;
  object_bounds_menu.label = "Object Bounds Filter";
  object_bounds_menu.icon = ICON_MD_CROP_SQUARE;
 
  object_bounds_menu.subitems.push_back(
      gui::CanvasMenuItem("Type 1 (0x00-0xFF)", [this]() {
        object_outline_toggles_.show_type1_objects =
            !object_outline_toggles_.show_type1_objects;
      }));
  object_bounds_menu.subitems.back().checked_condition = [this]() {
    return object_outline_toggles_.show_type1_objects;
  };
  object_bounds_menu.subitems.push_back(
      gui::CanvasMenuItem("Type 2 (0x100-0x1FF)", [this]() {
        object_outline_toggles_.show_type2_objects =
            !object_outline_toggles_.show_type2_objects;
      }));
  object_bounds_menu.subitems.back().checked_condition = [this]() {
    return object_outline_toggles_.show_type2_objects;
  };
  object_bounds_menu.subitems.push_back(
      gui::CanvasMenuItem("Type 3 (0xF00-0xFFF)", [this]() {
        object_outline_toggles_.show_type3_objects =
            !object_outline_toggles_.show_type3_objects;
      }));
  object_bounds_menu.subitems.back().checked_condition = [this]() {
    return object_outline_toggles_.show_type3_objects;
  };
 
  gui::CanvasMenuItem sep;
  sep.label = "---";
  sep.enabled_condition = []() {
    return false;
  };
  object_bounds_menu.subitems.push_back(std::move(sep));
 
  object_bounds_menu.subitems.push_back(
      gui::CanvasMenuItem("Primary / Upper layer (BG1)", [this]() {
        object_outline_toggles_.show_layer0_objects =
            !object_outline_toggles_.show_layer0_objects;
      }));
  object_bounds_menu.subitems.back().checked_condition = [this]() {
    return object_outline_toggles_.show_layer0_objects;
  };
  object_bounds_menu.subitems.push_back(
      gui::CanvasMenuItem("BG2 overlay / Lower layer (BG2)", [this]() {
        object_outline_toggles_.show_layer1_objects =
            !object_outline_toggles_.show_layer1_objects;
      }));
  object_bounds_menu.subitems.back().checked_condition = [this]() {
    return object_outline_toggles_.show_layer1_objects;
  };
  object_bounds_menu.subitems.push_back(
      gui::CanvasMenuItem("BG1 overlay (room stream only)", [this]() {
        object_outline_toggles_.show_layer2_objects =
            !object_outline_toggles_.show_layer2_objects;
      }));
  object_bounds_menu.subitems.back().checked_condition = [this]() {
    return object_outline_toggles_.show_layer2_objects;
  };
  debug_menu.subitems.push_back(std::move(object_bounds_menu));
 
  debug_menu.subitems.push_back(
      gui::CanvasMenuItem("Layer Info", ICON_MD_LAYERS,
                          [this]() { show_layer_info_ = !show_layer_info_; }));
  debug_menu.subitems.back().checked_condition = [this]() {
    return show_layer_info_;
  };
 
  debug_menu.subitems.push_back(
      gui::CanvasMenuItem("Force Reload", ICON_MD_REFRESH, [this, room_id]() {
        if (rooms_ && room_id >= 0 && room_id < zelda3::kNumberOfRooms) {
          (*rooms_)[room_id].ReloadGraphics(current_entrance_blockset_);
        }
      }));
 
  debug_menu.subitems.push_back(
      gui::CanvasMenuItem("Log Room State", ICON_MD_PRINT, [this, room_id]() {
        if (!rooms_ || room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
          return;
        }
        const auto& room = (*rooms_)[room_id];
        LOG_DEBUG("DungeonDebug", "=== Room %03X Debug ===", room_id);
        LOG_DEBUG("DungeonDebug", "Blockset: %d, Palette: %d, Layout: %d",
                  room.blockset(), room.palette(), room.layout_id());
        LOG_DEBUG("DungeonDebug", "Objects: %zu, Sprites: %zu",
                  room.GetTileObjects().size(), room.GetSprites().size());
        LOG_DEBUG("DungeonDebug", "BG1: %dx%d, BG2: %dx%d",
                  room.bg1_buffer().bitmap().width(),
                  room.bg1_buffer().bitmap().height(),
                  room.bg2_buffer().bitmap().width(),
                  room.bg2_buffer().bitmap().height());
      }));
 
  return debug_menu;
}
 
}  // namespace yaze::editor