dungeon_entrances_panel.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_PANELS_DUNGEON_ENTRANCES_PANEL_H_
#define YAZE_APP_EDITOR_DUNGEON_PANELS_DUNGEON_ENTRANCES_PANEL_H_
 
#include <algorithm>
#include <array>
#include <cstdio>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
 
#include "absl/status/status.h"
#include "absl/strings/str_format.h"
#include "app/editor/dungeon/dungeon_entrance_camera.h"
#include "app/editor/dungeon/dungeon_entrance_edit_policy.h"
#include "app/editor/dungeon/dungeon_render_context.h"
#include "app/editor/system/workspace/editor_panel.h"
#include "app/gui/automation/widget_auto_register.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "imgui/imgui.h"
#include "util/i18n/tr.h"
#include "zelda3/common.h"
#include "zelda3/dungeon/room_entrance.h"
#include "zelda3/resource_labels.h"
 
namespace yaze {
namespace editor {
 
class DungeonEntrancesPanel : public WindowContent {
 public:
  DungeonEntrancesPanel(
      std::array<zelda3::RoomEntrance, zelda3::kNumDungeonEntranceSlots>*
          entrances,
      std::array<zelda3::DungeonSpawnPoint, zelda3::kNumDungeonSpawnPoints>*
          spawn_points,
      int* current_entrance_id, std::function<void(int)> on_entrance_selected)
      : entrances_(entrances),
        spawn_points_(spawn_points),
        current_entrance_id_(current_entrance_id),
        on_entrance_selected_(std::move(on_entrance_selected)) {}
 
  // ==========================================================================
  // WindowContent Identity
  // ==========================================================================
 
  std::string GetId() const override { return "dungeon.entrance_properties"; }
  std::string GetDisplayName() const override { return "Entrances"; }
  std::string GetIcon() const override { return ICON_MD_DOOR_FRONT; }
  std::string GetEditorCategory() const override { return "Dungeon"; }
  int GetPriority() const override { return 26; }
  std::string GetWorkflowGroup() const override { return "Core"; }
 
  using CameraStateProvider =
      std::function<std::optional<DungeonEntranceCameraState>(int)>;
  using CameraRepairCallback = std::function<absl::Status(int)>;
  using EntrancePropertyEditCallback = std::function<void(
      int, const zelda3::RoomEntrance&, const zelda3::RoomEntrance&)>;
  using SpawnPropertyEditCallback = std::function<void(
      int, const zelda3::DungeonSpawnPoint&, const zelda3::DungeonSpawnPoint&)>;
 
  void SetPropertyEditCallbacks(EntrancePropertyEditCallback entrance_callback,
                                SpawnPropertyEditCallback spawn_callback) {
    entrance_property_edit_callback_ = std::move(entrance_callback);
    spawn_property_edit_callback_ = std::move(spawn_callback);
  }
 
  std::shared_ptr<const int> property_edit_gesture() const {
    return property_edit_gesture_;
  }
 
  void SetCameraTools(CameraStateProvider state_provider,
                      CameraRepairCallback repair_callback,
                      std::function<void()> data_changed_callback = {}) {
    camera_state_provider_ = std::move(state_provider);
    camera_repair_callback_ = std::move(repair_callback);
    camera_data_changed_callback_ = std::move(data_changed_callback);
  }
  bool OwnsNavigationShortcutFocus() const {
    if (!navigation_shortcut_focus_ || ImGui::GetCurrentContext() == nullptr) {
      return false;
    }
    return navigation_shortcut_last_draw_frame_ >= ImGui::GetFrameCount() - 1;
  }
 
  void SetGraphicsPreview(std::function<DungeonRenderContext()> context,
                          std::function<bool()> automatic,
                          std::function<void(int)> select) {
    preview_context_ = std::move(context);
    preview_automatic_ = std::move(automatic);
    select_preview_ = std::move(select);
  }
 
  // Shared preview selector: regular IDs are not the combined list slots,
  // whose first entries are dedicated spawn points.
  void DrawGraphicsContext(float width = -1.0f) {
    if (!entrances_ || !spawn_points_ || !current_entrance_id_)
      return;
    if (*current_entrance_id_ < 0 ||
        *current_entrance_id_ >= static_cast<int>(entrances_->size()))
      *current_entrance_id_ = zelda3::kNumDungeonSpawnPoints;
    const int selected = *current_entrance_id_;
    const uint8_t main_gfx = selected < zelda3::kNumDungeonSpawnPoints
                                 ? (*spawn_points_)[selected].main_gfx
                                 : (*entrances_)[selected].blockset_;
    std::string preview = absl::StrFormat(
        "%s / GFX %02X", DungeonEntrancePreviewLabel(selected), main_gfx);
    const bool automatic = preview_automatic_ && preview_automatic_();
    if (preview_context_) {
      const auto context = preview_context_();
      const std::string name =
          automatic && !context.owner_name.empty() ? context.owner_name
          : context.entrance_slot >= zelda3::kNumDungeonSpawnPoints
              ? zelda3::GetEntranceLabel(context.entrance_slot -
                                         zelda3::kNumDungeonSpawnPoints)
              : DungeonEntrancePreviewLabel(context.entrance_slot);
      preview =
          context.uses_entrance()
              ? absl::StrFormat(
                    "%s: %s / %s", automatic ? "Auto" : "Manual", name,
                    DungeonEntrancePreviewLabel(context.entrance_slot))
              : absl::StrFormat(
                    "Auto: %s / GFX %02X",
                    context.source == DungeonRenderContextSource::kAmbiguous
                        ? "Choose entrance"
                        : "Room fallback",
                    context.effective_blockset());
    }
    ImGui::SetNextItemWidth(width);
    const bool open = ImGui::BeginCombo(
        "##GraphicsEntrance", preview.c_str(),
        select_preview_ ? ImGuiComboFlags_HeightLarge : ImGuiComboFlags_None);
    gui::AutoRegisterLastItem("combo", "Graphics entrance");
    if (ImGui::IsItemHovered())
      ImGui::SetTooltip(
          "Auto follows the room's dungeon. Choosing an entrance pins its "
          "graphics until you choose Auto again. This changes only the "
          "preview.");
    if (open) {
      if (select_preview_) {
        if (ImGui::Selectable("Auto (follow room)", automatic))
          select_preview_(-1);
        gui::AutoRegisterLastItem("selectable", "Auto (follow room)");
        ImGui::Separator();
        // Keep Auto visible while the entrance list scrolls to a manual choice.
        ImGui::BeginChild("##EntranceChoices",
                          ImVec2(0, ImGui::GetTextLineHeightWithSpacing() * 8));
      }
      for (int slot = 0; slot < static_cast<int>(entrances_->size()); ++slot) {
        const std::string entry = DungeonEntrancePreviewLabel(slot);
        const std::string label =
            slot >= zelda3::kNumDungeonSpawnPoints
                ? entry + " - " +
                      zelda3::GetEntranceLabel(slot -
                                               zelda3::kNumDungeonSpawnPoints)
                : entry;
        if (ImGui::Selectable(label.c_str(), !automatic && slot == selected)) {
          if (select_preview_) {
            select_preview_(slot);
            ImGui::CloseCurrentPopup();
          } else {
            *current_entrance_id_ = slot;
            if (on_entrance_selected_)
              on_entrance_selected_(slot);
          }
        }
        gui::AutoRegisterLastItem("selectable", entry);
        if (ImGui::IsItemHovered() && slot >= zelda3::kNumDungeonSpawnPoints)
          ImGui::SetTooltip("%s", zelda3::GetEntranceLabel(
                                      slot - zelda3::kNumDungeonSpawnPoints)
                                      .c_str());
        if (slot == selected) {
          ImGui::SetItemDefaultFocus();
          if (select_preview_ && ImGui::IsWindowAppearing())
            ImGui::SetScrollHereY(0.5f);
        }
      }
      if (select_preview_)
        ImGui::EndChild();
      ImGui::EndCombo();
    }
  }
 
  void DrawPropertiesInWorkbench() {
    if (preview_context_ && preview_automatic_ && preview_automatic_() &&
        !preview_context_().uses_entrance()) {
      ImGui::TextWrapped("Choose an entrance to edit its properties.");
      return;
    }
    if (entrances_ && spawn_points_ && current_entrance_id_ &&
        *current_entrance_id_ >= 0 &&
        *current_entrance_id_ < static_cast<int>(entrances_->size()))
      DrawSelectedProperties();
  }
 
  // ==========================================================================
  // WindowContent Drawing
  // ==========================================================================
 
  void Draw(bool* p_open) override {
    (void)p_open;
    if (!entrances_ || !spawn_points_ || !current_entrance_id_)
      return;
    if (*current_entrance_id_ < 0 ||
        *current_entrance_id_ >= static_cast<int>(entrances_->size())) {
      *current_entrance_id_ = 0;
    }
    navigation_shortcut_last_draw_frame_ = ImGui::GetFrameCount();
    navigation_shortcut_focus_ =
        ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows);
 
    const bool split_layout = ImGui::GetContentRegionAvail().x >= 620.0f;
    if (split_layout &&
        ImGui::BeginTable("##EntranceNavigator", 2,
                          ImGuiTableFlags_Resizable |
                              ImGuiTableFlags_BordersInnerV |
                              ImGuiTableFlags_SizingStretchProp)) {
      ImGui::TableSetupColumn("Entrances", ImGuiTableColumnFlags_WidthFixed,
                              300.0f);
      ImGui::TableSetupColumn("Properties", ImGuiTableColumnFlags_WidthStretch);
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      DrawEntranceList();
      ImGui::TableNextColumn();
      DrawSelectedProperties();
      ImGui::EndTable();
      return;
    }
 
    if (ImGui::BeginTabBar("##EntranceNavigatorTabs")) {
      if (ImGui::BeginTabItem(ICON_MD_DOOR_FRONT " Entrances")) {
        DrawEntranceList();
        ImGui::EndTabItem();
      }
      if (ImGui::BeginTabItem(ICON_MD_TUNE " Properties")) {
        DrawSelectedProperties();
        ImGui::EndTabItem();
      }
      ImGui::EndTabBar();
    }
  }
 
 private:
  void DrawCameraRepairPreview() {
    if (!camera_repair_preview_.has_value()) {
      return;
    }
    const auto validation =
        ValidateDungeonEntranceCamera(*camera_repair_preview_);
    if (!ImGui::BeginPopupModal("Camera Repair Preview##DungeonEntrance",
                                nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
      return;
    }
 
    ImGui::TextWrapped(
        "Review the derived camera values before changing this entrance. "
        "The repair is one undoable action.");
    ImGui::Separator();
    if (ImGui::BeginTable(
            "##CameraRepairValues", 3,
            ImGuiTableFlags_BordersInner | ImGuiTableFlags_SizingFixedFit)) {
      ImGui::TableSetupColumn("Field");
      ImGui::TableSetupColumn("Current");
      ImGui::TableSetupColumn("Derived");
      ImGui::TableHeadersRow();
      const auto draw_word_row = [](const char* label, uint16_t current,
                                    uint16_t derived) {
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
        ImGui::TextUnformatted(label);
        ImGui::TableNextColumn();
        ImGui::Text("0x%04X", current);
        ImGui::TableNextColumn();
        ImGui::Text("0x%04X", derived);
      };
      draw_word_row("Scroll X", camera_repair_preview_->camera_x,
                    validation.expected.camera_x);
      draw_word_row("Scroll Y", camera_repair_preview_->camera_y,
                    validation.expected.camera_y);
      draw_word_row("Trigger X", camera_repair_preview_->trigger_x,
                    validation.expected.trigger_x);
      draw_word_row("Trigger Y", camera_repair_preview_->trigger_y,
                    validation.expected.trigger_y);
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      ImGui::TextUnformatted("Quadrant");
      ImGui::TableNextColumn();
      ImGui::Text("0x%02X", camera_repair_preview_->quadrant);
      ImGui::TableNextColumn();
      if (validation.quadrant_repair_safe) {
        ImGui::Text("0x%02X", validation.expected.quadrant);
      } else {
        ImGui::TextUnformatted("Preserved");
      }
      ImGui::EndTable();
    }
    ImGui::TextWrapped(
        "Boundary pages: [%02X %02X %02X %02X | %02X %02X %02X %02X] "
        "-> [%02X %02X %02X %02X | %02X %02X %02X %02X]",
        camera_repair_preview_->boundaries[0],
        camera_repair_preview_->boundaries[1],
        camera_repair_preview_->boundaries[2],
        camera_repair_preview_->boundaries[3],
        camera_repair_preview_->boundaries[4],
        camera_repair_preview_->boundaries[5],
        camera_repair_preview_->boundaries[6],
        camera_repair_preview_->boundaries[7],
        validation.expected.boundaries[0], validation.expected.boundaries[1],
        validation.expected.boundaries[2], validation.expected.boundaries[3],
        validation.expected.boundaries[4], validation.expected.boundaries[5],
        validation.expected.boundaries[6], validation.expected.boundaries[7]);
    if (!camera_repair_error_.empty()) {
      ImGui::TextWrapped("Repair failed: %s", camera_repair_error_.c_str());
    }
 
    ImGui::BeginDisabled(!validation.can_repair() || !camera_repair_callback_);
    if (ImGui::Button("Apply Safe Repair")) {
      const absl::Status status =
          camera_repair_callback_
              ? camera_repair_callback_(camera_repair_slot_)
              : absl::FailedPreconditionError(
                    "Camera repair callback is unavailable");
      if (status.ok()) {
        camera_repair_preview_.reset();
        camera_repair_slot_ = -1;
        camera_repair_error_.clear();
        ImGui::CloseCurrentPopup();
      } else {
        camera_repair_error_ = std::string(status.message());
      }
    }
    gui::AutoRegisterLastItem("button", "ApplyCameraRepair");
    ImGui::EndDisabled();
    ImGui::SameLine();
    if (ImGui::Button("Cancel")) {
      camera_repair_preview_.reset();
      camera_repair_slot_ = -1;
      camera_repair_error_.clear();
      ImGui::CloseCurrentPopup();
    }
    ImGui::EndPopup();
  }
 
  void DrawCameraSafety(int slot_index) {
    if (!camera_state_provider_) {
      return;
    }
    const auto state = camera_state_provider_(slot_index);
    if (!state.has_value()) {
      ImGui::TextDisabled("Camera validation unavailable.");
      return;
    }
    const auto validation = ValidateDungeonEntranceCamera(*state);
    ImGui::SeparatorText("Camera safety");
    if (!validation.geometry_valid()) {
      ImGui::TextColored(ImVec4(0.95f, 0.35f, 0.30f, 1.0f),
                         "Unsafe camera geometry");
      for (const auto& error : validation.errors) {
        ImGui::BulletText("%s", error.c_str());
      }
      if (validation.can_repair()) {
        ImGui::TextWrapped(
            "The room and player position are valid, so a previewed repair "
            "can replace these derived fields.");
      }
    } else if (validation.matches_derived()) {
      ImGui::TextColored(ImVec4(0.35f, 0.80f, 0.45f, 1.0f),
                         "Camera values match the player position.");
    } else {
      ImGui::TextWrapped(
          "Camera geometry is safe, but %zu derived value group(s) differ.",
          validation.differences.size());
      for (const auto& difference : validation.differences) {
        ImGui::BulletText("%s", difference.c_str());
      }
    }
 
    ImGui::BeginDisabled(!validation.can_repair() || !camera_repair_callback_);
    if (ImGui::Button("Preview Camera Repair")) {
      camera_repair_preview_ = *state;
      camera_repair_slot_ = slot_index;
      camera_repair_error_.clear();
      ImGui::OpenPopup("Camera Repair Preview##DungeonEntrance");
    }
    gui::AutoRegisterLastItem("button", "PreviewCameraRepair");
    ImGui::EndDisabled();
    DrawCameraRepairPreview();
  }
 
  void DrawSelectedProperties() {
    ObservePropertyEditGesture();
    gui::AutoWidgetScope scope("Dungeon/Entrances");
    ImGui::PushID(*current_entrance_id_);
    if (*current_entrance_id_ < zelda3::kNumDungeonSpawnPoints) {
      DrawSpawnPointProperties(*current_entrance_id_);
    } else {
      DrawRegularEntranceProperties(*current_entrance_id_);
    }
    ImGui::PopID();
  }
 
  bool DrawCameraBoundaries(const char* table_id,
                            const std::array<uint8_t*, 8>& boundaries) {
    bool changed = false;
    if (!ImGui::BeginTable(table_id, 5,
                           ImGuiTableFlags_BordersInnerV |
                               ImGuiTableFlags_SizingStretchSame)) {
      return false;
    }
    ImGui::TableSetupColumn("Mode", ImGuiTableColumnFlags_WidthFixed, 70.0f);
    ImGui::TableSetupColumn("North");
    ImGui::TableSetupColumn("East");
    ImGui::TableSetupColumn("South");
    ImGui::TableSetupColumn("West");
    ImGui::TableHeadersRow();
    constexpr std::array<int, 4> kQuadrantOrder = {0, 6, 2, 4};
    constexpr std::array<int, 4> kFullRoomOrder = {1, 7, 3, 5};
    const auto draw_row = [&changed, &boundaries](
                              const char* label,
                              const std::array<int, 4>& order) {
      ImGui::TableNextRow();
      ImGui::TableNextColumn();
      ImGui::TextUnformatted(label);
      for (const int index : order) {
        ImGui::TableNextColumn();
        ImGui::PushID(index);
        changed |= gui::InputHexByte(
            "##Boundary", boundaries[index],
            std::max(36.0f, ImGui::GetContentRegionAvail().x), true);
        ImGui::PopID();
      }
    };
    draw_row("Quadrant", kQuadrantOrder);
    draw_row("Full room", kFullRoomOrder);
    ImGui::EndTable();
    return changed;
  }
 
  void DrawEntranceList() {
    entrance_filter_.Draw(ICON_MD_SEARCH " Filter",
                          ImGui::GetContentRegionAvail().x);
    constexpr int kNumSpawnPoints = zelda3::kNumDungeonSpawnPoints;
    constexpr int kNumEntrances = zelda3::kNumRegularDungeonEntrances;
    constexpr int kTotalEntries = zelda3::kNumDungeonEntranceSlots;
 
    if (ImGui::BeginChild("##EntrancesList", ImVec2(0, 0), true,
                          ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
      for (int i = 0; i < kTotalEntries; i++) {
        std::string entrance_name;
        if (i < kNumSpawnPoints) {
          entrance_name = absl::StrFormat("Spawn Point %d", i);
        } else {
          const int entrance_id = i - kNumSpawnPoints;
          entrance_name = entrance_id < kNumEntrances
                              ? zelda3::GetEntranceLabel(entrance_id)
                              : absl::StrFormat("Unknown %d", i);
        }
 
        const int room_id = i < kNumSpawnPoints ? (*spawn_points_)[i].room_id
                                                : (*entrances_)[i].room_;
        const std::string room_name = zelda3::GetRoomLabel(room_id);
        const std::string label = absl::StrFormat(
            "[%02X] %s -> %s (%03X)", i, entrance_name, room_name, room_id);
        if (!entrance_filter_.PassFilter(label.c_str())) {
          continue;
        }
 
        const bool is_selected = (*current_entrance_id_ == i);
        if (ImGui::Selectable(label.c_str(), is_selected)) {
          *current_entrance_id_ = i;
          if (on_entrance_selected_) {
            on_entrance_selected_(i);
          }
        }
      }
    }
    ImGui::EndChild();
  }
 
  void DrawSpawnPointProperties(int slot_index) {
    auto& spawn = (*spawn_points_)[slot_index];
    const auto before = spawn;
    const bool properties_editable =
        CanEditDungeonSpawnPoint(slot_index, spawn);
    bool changed = false;
 
    ImGui::Text(tr("Spawn Point %d"), slot_index);
    if (!properties_editable) {
      ImGui::TextWrapped(tr(
          "Spawn point data is unavailable; reload the ROM before editing."));
    }
    ImGui::BeginDisabled(!properties_editable);
 
    changed |= gui::InputHexWord("Entrance ID", &spawn.entrance_id);
    changed |= gui::InputHexWord("Room ID", &spawn.room_id);
    RegisterPropertyInput("Room ID", "SpawnRoomId");
    ImGui::SameLine();
    changed |= gui::InputHexByte("Dungeon ID", &spawn.dungeon_id, 50.f, true);
 
    changed |= gui::InputHexByte("Main GFX", &spawn.main_gfx, 50.f, true);
    RegisterPropertyInput("Main GFX", "SpawnMainGfx");
    ImGui::SameLine();
    changed |= gui::InputHexByte("Song", &spawn.song, 50.f, true);
    ImGui::SameLine();
    changed |= gui::InputHexByte("Floor", &spawn.floor);
 
    ImGui::Separator();
 
    changed |= gui::InputHexWord("Player X", &spawn.x_coordinate);
    RegisterPropertyInput("Player X", "SpawnPlayerX");
    ImGui::SameLine();
    changed |= gui::InputHexWord("Player Y", &spawn.y_coordinate);
    RegisterPropertyInput("Player Y", "SpawnPlayerY");
 
    changed |= gui::InputHexWord("Overworld Door Tilemap",
                                 &spawn.overworld_door_tilemap, 70.f, true);
    ImGui::EndDisabled();
 
    CommitSpawnPropertyEdit(slot_index, before, changed);
    DrawCameraSafety(slot_index);
 
    const auto camera_before = spawn;
    changed = false;
    const bool camera_open = ImGui::CollapsingHeader("Advanced camera data");
    gui::AutoRegisterLastItem("header", "AdvancedCameraData");
    if (camera_open) {
      ImGui::BeginDisabled(!properties_editable);
      changed |= gui::InputHexWord("Camera Trigger X", &spawn.camera_trigger_x);
      RegisterPropertyInput("Camera Trigger X", "SpawnCameraTriggerX");
      ImGui::SameLine();
      changed |= gui::InputHexWord("Camera Trigger Y", &spawn.camera_trigger_y);
      RegisterPropertyInput("Camera Trigger Y", "SpawnCameraTriggerY");
 
      changed |=
          gui::InputHexWord("Horizontal Scroll", &spawn.horizontal_scroll);
      ImGui::SameLine();
      changed |= gui::InputHexWord("Vertical Scroll", &spawn.vertical_scroll);
 
      changed |= gui::InputHexByte("Layer", &spawn.layer, 50.f, true);
      ImGui::SameLine();
      changed |=
          gui::InputHexByte("Spawn Quadrant", &spawn.quadrant, 50.f, true);
      ImGui::SameLine();
      changed |= gui::InputHexByte("Scroll Controller",
                                   &spawn.camera_scroll_controller, 50.f, true);
 
      ImGui::SeparatorText(tr("Camera Boundaries"));
      changed |= DrawCameraBoundaries("##SpawnCameraBoundaries",
                                      {&spawn.camera_scroll_boundaries[0],
                                       &spawn.camera_scroll_boundaries[1],
                                       &spawn.camera_scroll_boundaries[2],
                                       &spawn.camera_scroll_boundaries[3],
                                       &spawn.camera_scroll_boundaries[4],
                                       &spawn.camera_scroll_boundaries[5],
                                       &spawn.camera_scroll_boundaries[6],
                                       &spawn.camera_scroll_boundaries[7]});
      ImGui::EndDisabled();
    }
 
    CommitSpawnPropertyEdit(slot_index, camera_before, changed);
  }
 
  void DrawRegularEntranceProperties(int slot_index) {
    auto& entrance = (*entrances_)[slot_index];
    const auto before = entrance;
    const bool properties_editable =
        CanEditDungeonEntrance(slot_index, entrance);
    bool changed = false;
 
    ImGui::Text(tr("Entrance ID: %04X"), entrance.entrance_id_);
    ImGui::BeginDisabled(!properties_editable);
    changed |= gui::InputHexWord("Room ID", &entrance.room_);
    RegisterPropertyInput("Room ID", "RegularRoomId");
    ImGui::SameLine();
    changed |=
        gui::InputHexByte("Dungeon ID", &entrance.dungeon_id_, 50.f, true);
 
    changed |= gui::InputHexByte("Blockset", &entrance.blockset_, 50.f, true);
    RegisterPropertyInput("Blockset", "RegularBlockset");
    ImGui::SameLine();
    changed |= gui::InputHexByte("Music", &entrance.music_, 50.f, true);
    ImGui::SameLine();
    changed |= gui::InputHexByte("Floor", &entrance.floor_);
 
    ImGui::Separator();
 
    changed |= gui::InputHexWord("Player X   ", &entrance.x_position_);
    RegisterPropertyInput("Player X   ", "RegularPlayerX");
    ImGui::SameLine();
    changed |= gui::InputHexWord("Player Y   ", &entrance.y_position_);
    RegisterPropertyInput("Player Y   ", "RegularPlayerY");
 
    changed |= gui::InputHexWord("Exit", &entrance.exit_, 50.f, true);
    ImGui::EndDisabled();
 
    CommitEntrancePropertyEdit(slot_index, before, changed);
    DrawCameraSafety(slot_index);
 
    const auto camera_before = entrance;
    changed = false;
    const bool camera_open = ImGui::CollapsingHeader("Advanced camera data");
    gui::AutoRegisterLastItem("header", "AdvancedCameraData");
    if (camera_open) {
      ImGui::BeginDisabled(!properties_editable);
      changed |=
          gui::InputHexWord("Camera Trigger X", &entrance.camera_trigger_x_);
      RegisterPropertyInput("Camera Trigger X", "RegularCameraTriggerX");
      ImGui::SameLine();
      changed |=
          gui::InputHexWord("Camera Trigger Y", &entrance.camera_trigger_y_);
      RegisterPropertyInput("Camera Trigger Y", "RegularCameraTriggerY");
 
      changed |= gui::InputHexWord("Scroll X", &entrance.camera_x_);
      ImGui::SameLine();
      changed |= gui::InputHexWord("Scroll Y", &entrance.camera_y_);
      changed |= gui::InputHexByte("Scroll Quadrant",
                                   &entrance.scroll_quadrant_, 50.f, true);
 
      ImGui::SeparatorText(tr("Camera Boundaries"));
      changed |= DrawCameraBoundaries(
          "##RegularCameraBoundaries",
          {&entrance.camera_boundary_qn_, &entrance.camera_boundary_fn_,
           &entrance.camera_boundary_qs_, &entrance.camera_boundary_fs_,
           &entrance.camera_boundary_qw_, &entrance.camera_boundary_fw_,
           &entrance.camera_boundary_qe_, &entrance.camera_boundary_fe_});
      ImGui::EndDisabled();
    }
 
    CommitEntrancePropertyEdit(slot_index, camera_before, changed);
  }
 
  void CommitEntrancePropertyEdit(int slot_index,
                                  const zelda3::RoomEntrance& before,
                                  bool changed) {
    auto& entrance = (*entrances_)[slot_index];
    if (!MarkDungeonEntranceDirtyIfEditable(slot_index, entrance, changed)) {
      return;
    }
    if (entrance_property_edit_callback_) {
      ObservePropertyEditGesture();
      entrance_property_edit_callback_(slot_index, before, entrance);
    }
    if (camera_data_changed_callback_) {
      camera_data_changed_callback_();
    }
  }
 
  void CommitSpawnPropertyEdit(int slot_index,
                               const zelda3::DungeonSpawnPoint& before,
                               bool changed) {
    auto& spawn = (*spawn_points_)[slot_index];
    if (!MarkDungeonSpawnPointDirtyIfEditable(slot_index, spawn, changed)) {
      return;
    }
    if (spawn_property_edit_callback_) {
      ObservePropertyEditGesture();
      spawn_property_edit_callback_(slot_index, before, spawn);
    }
    if (camera_data_changed_callback_) {
      camera_data_changed_callback_();
    }
  }
 
  void ObservePropertyEditGesture();
  void RegisterPropertyInput(const char* field_label, const char* widget_label);
 
  std::array<zelda3::RoomEntrance, zelda3::kNumDungeonEntranceSlots>*
      entrances_ = nullptr;
  std::array<zelda3::DungeonSpawnPoint, zelda3::kNumDungeonSpawnPoints>*
      spawn_points_ = nullptr;
  int* current_entrance_id_ = nullptr;
  std::function<void(int)> on_entrance_selected_;
  std::function<DungeonRenderContext()> preview_context_;
  std::function<bool()> preview_automatic_;
  std::function<void(int)> select_preview_;
  CameraStateProvider camera_state_provider_;
  CameraRepairCallback camera_repair_callback_;
  EntrancePropertyEditCallback entrance_property_edit_callback_;
  SpawnPropertyEditCallback spawn_property_edit_callback_;
  ImGuiID property_edit_active_id_ = 0;
  std::shared_ptr<const int> property_edit_gesture_;
  std::function<void()> camera_data_changed_callback_;
  std::optional<DungeonEntranceCameraState> camera_repair_preview_;
  int camera_repair_slot_ = -1;
  std::string camera_repair_error_;
  bool navigation_shortcut_focus_ = false;
  int navigation_shortcut_last_draw_frame_ = -1;
  ImGuiTextFilter entrance_filter_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_PANELS_DUNGEON_ENTRANCES_PANEL_H_