dungeon_workbench_content.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_WORKSPACE_DUNGEON_WORKBENCH_CONTENT_H
#define YAZE_APP_EDITOR_DUNGEON_WORKSPACE_DUNGEON_WORKBENCH_CONTENT_H
 
#include <cstdint>
#include <deque>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/dungeon/dungeon_proposal_overlay.h"
#include "app/editor/dungeon/dungeon_workbench_state.h"
#include "app/editor/system/editor_panel.h"
 
namespace yaze {
class Rom;
}  // namespace yaze
 
namespace yaze::zelda3 {
class PitDamageTable;
}  // namespace yaze::zelda3
 
namespace yaze::editor {
 
class DungeonCanvasViewer;
class DungeonMapPanel;
class DungeonEntrancesPanel;
class DungeonRoomSelector;
class RoomMatrixContent;
class CustomCollisionPanel;
class MinecartTrackEditorPanel;
class RoomTagEditorPanel;
class WaterFillPanel;
enum class RoomSelectionIntent;
 
struct DungeonWorkbenchResponsiveLayout {
  bool show_left = false;
  bool show_right = false;
  bool compact_left = false;
  bool compact_right = false;
};
 
struct DungeonWorkbenchPaneLayout {
  DungeonWorkbenchResponsiveLayout responsive{};
  float left_width = 0.0f;
  float center_width = 0.0f;
  float right_width = 0.0f;
  float min_left_width = 0.0f;
  float min_right_width = 0.0f;
};
 
struct DungeonWorkbenchTestRect {
  bool visible = false;
  float min_x = 0.0f;
  float min_y = 0.0f;
  float max_x = 0.0f;
  float max_y = 0.0f;
};
 
struct DungeonWorkbenchPitDamageControlRects {
  DungeonWorkbenchTestRect add_current;
  DungeonWorkbenchTestRect replace_current;
};
 
enum class DungeonWorkbenchToolRequestTarget : uint8_t {
  kEmbeddedInspector,
  kStandaloneWindow,
};
 
DungeonWorkbenchResponsiveLayout ResolveDungeonWorkbenchResponsiveLayout(
    float total_width, float min_canvas_width, float min_sidebar_width,
    float splitter_width, bool want_left, bool want_right);
 
DungeonWorkbenchPaneLayout ResolveDungeonWorkbenchPaneLayout(
    float total_width, float min_canvas_width, float min_sidebar_width,
    float splitter_width, float stored_left_width, float stored_right_width,
    bool want_left, bool want_right);
 
// An already-open standalone tool owns its WindowContent for that frame. Route
// repeated Workbench requests back to that window instead of drawing the same
// instance in both presentations.
DungeonWorkbenchToolRequestTarget ResolveDungeonWorkbenchToolRequestTarget(
    bool standalone_window_open);
 
// Single stable window for dungeon editing. This is step 2 in the Workbench plan.
class DungeonWorkbenchContent : public WindowContent {
 public:
  DungeonWorkbenchContent(
      DungeonRoomSelector* room_selector, int* current_room_id,
      std::function<void(int)> on_room_selected,
      std::function<void(int, RoomSelectionIntent)>
          on_room_selected_with_intent,
      std::function<void(int)> on_save_room,
      std::function<void()> on_save_all_rooms,
      std::function<DungeonCanvasViewer*()> get_viewer,
      std::function<DungeonCanvasViewer*(int)> get_compare_viewer,
      std::function<const std::deque<int>&()> get_recent_rooms,
      std::function<void(int)> forget_recent_room,
      std::function<void(bool)> set_workflow_mode, Rom* rom = nullptr);
  ~DungeonWorkbenchContent() override;
 
  std::string GetId() const override;
  std::string GetDisplayName() const override;
  std::string GetIcon() const override;
  std::string GetEditorCategory() const override;
  int GetPriority() const override;
  std::string GetWorkflowGroup() const override { return "Core"; }
 
  void SetRom(Rom* rom);
  void SetEmbeddedToolPanels(RoomTagEditorPanel* room_tags,
                             CustomCollisionPanel* custom_collision,
                             WaterFillPanel* water_fill,
                             MinecartTrackEditorPanel* minecart_tracks);
  void SetObjectCoverageContent(WindowContent* object_coverage) {
    object_coverage_content_ = object_coverage;
  }
  void SetEmbeddedEditorPanels(WindowContent* object_selector,
                               WindowContent* door_editor,
                               WindowContent* sprite_editor,
                               WindowContent* item_editor,
                               WindowContent* room_graphics,
                               WindowContent* palette_editor);
  void SetNavigationPanels(RoomMatrixContent* room_matrix,
                           DungeonEntrancesPanel* entrances) {
    room_matrix_content_ = room_matrix;
    entrance_navigator_content_ = entrances;
  }
  void SetRoomRenderContextCallback(std::function<void(int)> callback) {
    prepare_room_render_context_ = std::move(callback);
  }
  // Rename (label set) or reset (nullopt) a room's project name. The owner
  // writes the authoritative project and marks it dirty; without a callback
  // the rename control is hidden.
  using RoomLabelEditCallback =
      std::function<absl::Status(int, std::optional<std::string>)>;
  void SetRoomLabelEditCallback(RoomLabelEditCallback callback) {
    room_label_edit_callback_ = std::move(callback);
  }
  void SetStandaloneToolCallbacks(
      std::function<bool(const std::string&)> is_window_open,
      std::function<bool(const std::string&)> open_and_focus_window) {
    is_standalone_tool_open_ = std::move(is_window_open);
    open_and_focus_standalone_tool_ = std::move(open_and_focus_window);
  }
  void SetOpenKeyboardShortcutsCallback(std::function<void()> callback) {
    open_keyboard_shortcuts_ = std::move(callback);
  }
  void SetPitDamageTableProvider(
      std::function<zelda3::PitDamageTable*()> provider,
      std::function<void()> on_change = {}) {
    get_pit_damage_table_ = std::move(provider);
    on_pit_damage_changed_ = std::move(on_change);
  }
  void FocusRoomInspector();
  void FocusSelectionInspector();
  void FocusRoomMatrix();
  void FocusEntranceBrowser();
  void ShowConnectedGraph();
  void RequestDungeonMapPopup();
  // Opens the read-only Proposal Preview window (room renders + overlay).
  void RequestProposalPreview();
  // Loads an overlay file; returns false and records the error on failure.
  bool LoadProposalOverlay(const std::string& path);
  const std::string& loaded_proposal_path() const {
    return loaded_proposal_path_;
  }
  const std::optional<DungeonProposalOverlay>& proposal_overlay() const {
    return proposal_overlay_;
  }
  const std::string& proposal_error() const { return proposal_error_; }
  void OpenObjectSelectorTool();
  void OpenDoorTool();
  void OpenSpriteTool();
  void OpenItemTool();
  void OpenRoomGraphicsTool();
  void OpenPaletteTool();
  void OpenRoomTagsTool();
  void OpenCustomCollisionTool();
  void OpenWaterFillTool();
  void OpenMinecartTool();
  void OpenObjectCoverageTool();
  bool PopOutActiveTool();
 
  void SetPrimaryCanvasDrawnCallback(
      std::function<void(DungeonCanvasViewer&)> cb) {
    on_primary_canvas_drawn_ = std::move(cb);
  }
 
  enum class RoomInspectorSubTab : uint8_t { Mechanics, Warps, TagsAndChests };
  void SetRoomInspectorSubTab(RoomInspectorSubTab tab) {
    room_inspector_sub_tab_ = tab;
  }
  RoomInspectorSubTab room_inspector_sub_tab() const {
    return room_inspector_sub_tab_;
  }
 
  // Lightweight state probes for unit tests; production rendering remains
  // driven by the Workbench inspector.
  bool IsToolInspectorActiveForTesting() const;
  const char* GetInspectorModeIdForTesting() const;
  const char* GetActiveToolIdForTesting() const;
  const char* GetSidebarModeIdForTesting() const;
  void DrawPitDamageControlsForTesting(int room_id) {
    DrawPitDamageControls(room_id);
  }
  const DungeonWorkbenchPitDamageControlRects&
  GetPitDamageControlRectsForTesting() const {
    return pit_damage_control_rects_;
  }
  void SetAllSaveFlagsForTesting(bool value) { SetAllSaveFlags(value); }
 
  void NotifyRoomChanged(int previous_room_id) {
    previous_room_id_ = previous_room_id;
  }
 
  // Wire undo/redo state from the editor's UndoManager.
  void SetUndoRedoProvider(std::function<bool()> can_undo,
                           std::function<bool()> can_redo,
                           std::function<void()> on_undo,
                           std::function<void()> on_redo,
                           std::function<std::string()> undo_desc,
                           std::function<std::string()> redo_desc,
                           std::function<int()> undo_depth) {
    can_undo_ = std::move(can_undo);
    can_redo_ = std::move(can_redo);
    on_undo_ = std::move(on_undo);
    on_redo_ = std::move(on_redo);
    undo_desc_ = std::move(undo_desc);
    redo_desc_ = std::move(redo_desc);
    undo_depth_ = std::move(undo_depth);
  }
 
  void Draw(bool* p_open) override;
 
 private:
  friend class DungeonWorkbenchContentTestPeer;
  enum class WorkbenchTool : uint8_t {
    None,
    RoomTags,
    CustomCollision,
    WaterFill,
    MinecartTracks,
    ObjectCoverage,
    ObjectSelector,
    DoorEditor,
    SpriteEditor,
    ItemEditor,
    RoomGraphics,
    Palette,
  };
 
  void DrawSidebarPane(float width, float height, float button_size,
                       bool compact);
  void DrawSidebarHeader(float button_size, bool compact);
  void DrawSidebarModeTabs();
  void DrawSidebarContent();
  void DrawCanvasPane(float width, float height,
                      DungeonCanvasViewer* primary_viewer);
  void DrawSplitView(DungeonCanvasViewer& primary_viewer);
  void DrawInspectorPane(float width, float height, float button_size,
                         bool compact, DungeonCanvasViewer* viewer);
  void DrawInspectorHeader(float button_size, bool compact);
  void DrawInspector(DungeonCanvasViewer& viewer, bool compact);
  void DrawInspectorShelf(DungeonCanvasViewer& viewer, bool compact);
  void DrawInspectorShelfRoom(DungeonCanvasViewer& viewer);
  void DrawRoomContextHeader(DungeonCanvasViewer& viewer);
  void DrawRoomContextRow(DungeonCanvasViewer& viewer);
  void DrawLayoutOptions();
  void DrawInspectorShelfSelection(DungeonCanvasViewer& viewer);
  bool DrawObjectPlacementInspector(DungeonCanvasViewer& viewer);
  void DrawSelectedObjectActions(DungeonCanvasViewer& viewer, size_t index);
  void DrawInspectorToolPanel(DungeonCanvasViewer& viewer);
  void DrawInspectorToolPicker();
  void DrawWorkbenchTool(DungeonCanvasViewer& viewer, WorkbenchTool tool);
  void OpenTool(WorkbenchTool tool);
  void CloseToolInspector();
  WindowContent* GetWorkbenchToolContent(WorkbenchTool tool) const;
  bool IsStandaloneToolOpen(WorkbenchTool tool) const;
  bool IsWorkbenchToolAvailable(WorkbenchTool tool) const;
  const char* GetWorkbenchToolId(WorkbenchTool tool) const;
  const char* GetWorkbenchToolShortLabel(WorkbenchTool tool) const;
  const char* GetWorkbenchToolUnavailableMessage(WorkbenchTool tool) const;
  void DrawApplyScopeControls(int room_id);
  void DrawPitDamageControls(int room_id, bool compact = false);
  void DrawDungeonMapPopup(DungeonCanvasViewer& viewer);
  void DrawProposalPreviewWindow(DungeonCanvasViewer& viewer);
  DungeonMapPanel* GetEmbeddedDungeonMap(DungeonCanvasViewer& viewer);
  void SetAllSaveFlags(bool value);
 
  // Lazily build a room_id → dungeon_name cache from ROM entrance tables so the
  // room badge can show accurate group context for custom Oracle dungeons.
  void BuildRoomDungeonCache();
 
  DungeonRoomSelector* room_selector_ = nullptr;
  int* current_room_id_ = nullptr;
 
  // Workbench-owned UI state (was in DungeonEditorV2, moved here Phase 6.2).
  int previous_room_id_ = -1;
  bool split_view_enabled_ = false;
  int compare_room_id_ = -1;
  DungeonWorkbenchLayoutState layout_state_{};
  std::function<void(int)> on_room_selected_;
  std::function<void(int, RoomSelectionIntent)> on_room_selected_with_intent_;
  std::function<void(int)> on_save_room_;
  std::function<void()> on_save_all_rooms_;
  std::function<DungeonCanvasViewer*()> get_viewer_;
  std::function<DungeonCanvasViewer*(int)> get_compare_viewer_;
  std::function<const std::deque<int>&()> get_recent_rooms_;
  std::function<void(int)> forget_recent_room_;
  std::function<void(bool)> set_workflow_mode_;
  std::function<bool(const std::string&)> is_standalone_tool_open_;
  std::function<bool(const std::string&)> open_and_focus_standalone_tool_;
  std::function<void()> open_keyboard_shortcuts_;
  std::function<void(DungeonCanvasViewer&)> on_primary_canvas_drawn_;
  std::function<void(int)> prepare_room_render_context_;
  RoomLabelEditCallback room_label_edit_callback_;
  char room_rename_buffer_[128] = {};
  std::string room_rename_error_;
  std::function<zelda3::PitDamageTable*()> get_pit_damage_table_;
  std::function<void()> on_pit_damage_changed_;
  Rom* rom_ = nullptr;
 
  enum class SidebarMode : uint8_t {
    Room,
    Objects,
    Sprites,
    Doors,
    Items,
    Entrance,
    Tools
  };
  SidebarMode sidebar_mode_ = SidebarMode::Room;
  float navigator_tools_fraction_ = 0.30f;
  bool show_room_matrix_ = true;
 
  RoomInspectorSubTab room_inspector_sub_tab_ = RoomInspectorSubTab::Mechanics;
 
  enum class InspectorMode : uint8_t { Inspect, Tools };
  InspectorMode inspector_mode_ = InspectorMode::Inspect;
  WorkbenchTool active_tool_ = WorkbenchTool::ObjectSelector;
 
  char compare_search_buf_[64] = {};
 
  // ROM-based room→dungeon group label cache (lazy-built on first room render).
  std::unordered_map<int, std::string> room_dungeon_cache_;
  bool room_dungeon_cache_built_ = false;
 
  // Undo/redo providers (set via SetUndoRedoProvider).
  std::function<bool()> can_undo_;
  std::function<bool()> can_redo_;
  std::function<void()> on_undo_;
  std::function<void()> on_redo_;
  std::function<std::string()> undo_desc_;
  std::function<std::string()> redo_desc_;
  std::function<int()> undo_depth_;
 
  bool open_dungeon_map_popup_ = false;
 
  // Proposal Preview window state (read-only review of layout proposals).
  bool show_proposal_preview_ = false;
  char proposal_path_[1024] = {};
  std::optional<DungeonProposalOverlay> proposal_overlay_;
  std::string proposal_error_;
  std::string loaded_proposal_path_;
  std::vector<char> proposal_layer_visible_;
  bool proposal_show_overlay_ = true;
  float proposal_scale_ = 1.0f;
  uint16_t pit_damage_replacement_room_id_ = 0;
  uint16_t pit_damage_victim_room_id_ = 0;
  int pit_damage_chooser_room_id_ = -1;
  std::string pit_damage_status_message_;
  bool pit_damage_status_error_ = false;
  DungeonWorkbenchPitDamageControlRects pit_damage_control_rects_{};
  std::unique_ptr<DungeonMapPanel> embedded_dungeon_map_;
  RoomTagEditorPanel* room_tag_panel_ = nullptr;
  CustomCollisionPanel* custom_collision_panel_ = nullptr;
  WaterFillPanel* water_fill_panel_ = nullptr;
  MinecartTrackEditorPanel* minecart_track_panel_ = nullptr;
  WindowContent* object_coverage_content_ = nullptr;
  WindowContent* object_selector_content_ = nullptr;
  WindowContent* door_editor_content_ = nullptr;
  WindowContent* sprite_editor_content_ = nullptr;
  WindowContent* item_editor_content_ = nullptr;
  WindowContent* room_graphics_content_ = nullptr;
  WindowContent* palette_editor_content_ = nullptr;
  RoomMatrixContent* room_matrix_content_ = nullptr;
  DungeonEntrancesPanel* entrance_navigator_content_ = nullptr;
};
 
}  // namespace yaze::editor
 
#endif  // YAZE_APP_EDITOR_DUNGEON_WORKSPACE_DUNGEON_WORKBENCH_CONTENT_H