screen_editor.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SCREEN_EDITOR_H
#define YAZE_APP_EDITOR_SCREEN_EDITOR_H
 
#include <array>
#include <memory>
 
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/editor/graphics/panels/screen_editor_panels.h"
#include "app/editor/graphics/screen_menu_tilemap_editor.h"
#include "app/editor/graphics/screen_undo_actions.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/render/tilemap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/canvas/canvas.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "zelda3/screen/dungeon_map.h"
#include "zelda3/screen/inventory.h"
#include "zelda3/screen/overworld_map_screen.h"
#include "zelda3/screen/title_screen.h"
 
namespace yaze {
namespace editor {
 
class ScreenEditor : public Editor {
 public:
  explicit ScreenEditor(Rom* rom = nullptr) : rom_(rom) {
    screen_canvas_.SetCanvasSize(ImVec2(512, 512));
    type_ = EditorType::kScreen;
  }
 
  void Initialize() override;
  absl::Status Load() override;
  absl::Status Update() override;
  absl::Status Undo() override { return undo_manager_.Undo(); }
  absl::Status Redo() override { return undo_manager_.Redo(); }
  absl::Status Cut() override { return absl::UnimplementedError("Cut"); }
  absl::Status Copy() override { return absl::UnimplementedError("Copy"); }
  absl::Status Paste() override { return absl::UnimplementedError("Paste"); }
  absl::Status Find() override { return absl::UnimplementedError("Find"); }
  absl::Status Save() override;
  // Pure preflight, also used before any coordinated serializer runs. Only
  // pending map records are admitted; a clean editor produces no writes.
  absl::StatusOr<zelda3::DungeonMapWritePlan> PrepareDungeonMapSave() const;
  absl::Status BeginSaveTransaction() override;
  void RollbackSaveTransaction() override;
  void CommitSaveTransaction() override;
  void set_rom(Rom* rom) { rom_ = rom; }
  Rom* rom() const { return rom_; }
 
  // Cheap contribution: just the currently-open menu tilemap file name and
  // dirty state, appended to the base Screen category snapshot. Skips
  // entirely (falls through to Editor::BuildContextSnapshot()) when no
  // tilemap is loaded, so this never does I/O or ROM work.
  EditorContextSnapshot BuildContextSnapshot() const override;
 
  // Test-only hook (see MenuTilemapEditorUI::LoadFileForTesting): loads a
  // tilemap file directly, bypassing the native "Open..." file dialog that
  // ImGuiTestEngine can't drive.
  absl::Status LoadMenuTilemapForTesting(const std::string& path) {
    return menu_tilemap_ui_.LoadFileForTesting(path);
  }
  bool IsMenuTilemapDirtyForTesting() const { return menu_tilemap_ui_.dirty(); }
  bool IsMenuTilemapLoadedForTesting() const {
    return menu_tilemap_ui_.loaded();
  }
 
  bool HasPendingDungeonMapChanges() const {
    return pending_dungeon_map_changes_;
  }
  bool HasPendingDungeonMapTile16Changes() const {
    return pending_dungeon_map_tile16_changes_;
  }
  bool HasPendingTitleScreenChanges() const {
    return pending_title_screen_changes_;
  }
  bool HasPendingOverworldMapChanges() const {
    return pending_overworld_map_changes_ ||
           pending_overworld_map_palette_changes_;
  }
  bool HasPendingScreenChanges() const {
    return HasPendingDungeonMapChanges() ||
           HasPendingDungeonMapTile16Changes() ||
           HasPendingTitleScreenChanges() || HasPendingOverworldMapChanges();
  }
  void InvalidateRomBackedState();
  absl::Status RefreshRomBackedState();
  bool IsRomBackedStateValid() const { return rom_backed_state_valid_; }
  // Opens the selected ROM-backed Dungeon Map / Tiles Gfx tile in Graphics.
  // BIN graphics and unavailable same-session sheets fail without navigation.
  absl::Status OpenDungeonMapTileGraphics();
 
  std::vector<zelda3::DungeonMap> dungeon_maps_;
 
 private:
  friend class ScreenEditorSaveStoplossTestPeer;
  friend class AuthoringSaveWorkflowTestPeer;
  friend class ScreenGraphicsContextTestPeer;
  friend class ScreenFloorMutationTestPeer;
 
  void DrawTitleScreenEditor();
  void DrawNamingScreenEditor();
  void DrawOverworldMapEditor();
 
  void DrawInventoryMenuEditor();
  void DrawInventoryItemIcons();
  void DrawMenuTilemapEditor();
  void DrawToolset();
  void DrawDungeonMapToolset();
  void DrawInventoryToolset();
 
  // Title screen layer editing
  void DrawTitleScreenCompositeCanvas();
  void DrawTitleScreenBG1Canvas();
  void DrawTitleScreenBG2Canvas();
  void DrawTitleScreenBlocksetSelector();
 
  absl::Status LoadDungeonMapTile16(const std::vector<uint8_t>& gfx_data,
                                    bool bin_mode = false);
 
  void DrawDungeonMapScreen(int i);
  void DrawDungeonMapsTabs();
  void DrawDungeonMapsEditor();
  void DrawDungeonMapsRoomGfx();
  void RefreshDungeonMapGraphicsFromSession();
 
  void LoadBinaryGfx();
  gfx::Bitmap* GetOrCreateSheet(int index);
  void RefreshTileCacheForReload(gfx::Tilemap& tilemap);
  bool HasValidDungeonSelection() const;
  bool HasValidDungeonFloorSelection(int floor) const;
 
  absl::Status ChangeDungeonMapFloorCount(bool basement, bool add);
 
  // Undo/redo helpers
  ScreenSnapshot CaptureDungeonMapSnapshot() const;
  ScreenSnapshot CaptureTile16CompSnapshot() const;
  void SaveDungeonMapUndoState(const std::string& description);
  void SaveTile16CompUndoState(const std::string& description);
  void CommitDungeonMapUndo();
  void CommitTile16CompUndo();
  void RestoreFromSnapshot(const ScreenSnapshot& snapshot);
  void ResetRomBackedStateForLoad();
  void MarkDungeonMapModified() { pending_dungeon_map_changes_ = true; }
  void MarkDungeonMapTile16Modified() {
    pending_dungeon_map_tile16_changes_ = true;
  }
  void MarkTitleScreenModified() { pending_title_screen_changes_ = true; }
  void MarkOverworldMapModified() { pending_overworld_map_changes_ = true; }
  void MarkOverworldMapPaletteModified() {
    pending_overworld_map_palette_changes_ = true;
  }
  absl::Status SaveTitleScreenToRom();
  absl::Status SaveOverworldMapToRom();
 
  enum class EditingMode { DRAW, EDIT };
 
  EditingMode current_mode_ = EditingMode::DRAW;
 
  bool binary_gfx_loaded_ = false;
 
  uint8_t selected_room = 0;
 
  int selected_tile16_ = 0;
  int selected_tile8_ = 0;
  int selected_dungeon = 0;
  int floor_number = 1;
  bool select_floor_tab_ = true;
 
  bool copy_button_pressed = false;
  bool paste_button_pressed = false;
 
  zelda3::DungeonMapLabels dungeon_map_labels_;
 
  gfx::SnesPalette palette_;
  gfx::BitmapTable sheets_;
  gfx::Tilemap tile16_blockset_;
  gfx::Tilemap tile8_tilemap_;  // Tilemap for 8x8 tiles with on-demand caching
  std::array<gfx::TileInfo, 4> current_tile16_info;
 
  gui::Canvas current_tile_canvas_{"##CurrentTileCanvas", ImVec2(32, 32),
                                   gui::CanvasGridSize::k16x16, 2.0f};
  gui::Canvas screen_canvas_;
  gui::Canvas tilesheet_canvas_;
  gui::Canvas tilemap_canvas_{"##TilemapCanvas", ImVec2(128 + 2, (192) + 4),
                              gui::CanvasGridSize::k8x8, 2.f};
 
  // Title screen canvases
  // Title screen is 32x32 tiles at 8x8 pixels = 256x256 pixels total
  gui::Canvas title_bg1_canvas_{"##TitleBG1Canvas", ImVec2(256, 256),
                                gui::CanvasGridSize::k8x8, 2.0f};
  gui::Canvas title_bg2_canvas_{"##TitleBG2Canvas", ImVec2(256, 256),
                                gui::CanvasGridSize::k8x8, 2.0f};
  // Blockset is 128 pixels wide x 512 pixels tall (16x64 8x8 tiles)
  gui::Canvas title_blockset_canvas_{"##TitleBlocksetCanvas", ImVec2(128, 512),
                                     gui::CanvasGridSize::k8x8, 2.0f};
 
  std::unique_ptr<zelda3::Inventory> inventory_ =
      std::make_unique<zelda3::Inventory>();
  bool inventory_loaded_ = false;
  MenuTilemapEditorUI menu_tilemap_ui_;
  zelda3::TitleScreen title_screen_;
  zelda3::OverworldMapScreen ow_map_screen_;
 
  // Title screen state
  int selected_title_tile16_ = 0;
  bool title_screen_loaded_ = false;
  bool title_h_flip_ = false;
  bool title_v_flip_ = false;
  int title_palette_ = 0;
  bool show_title_bg1_ = true;
  bool show_title_bg2_ = true;
 
  // Overworld map screen state
  int selected_ow_tile_ = 0;
  bool ow_map_loaded_ = false;
  bool ow_show_dark_world_ = false;
 
  // Overworld map canvases
  gui::Canvas ow_map_canvas_{"##OWMapCanvas", ImVec2(512, 512),
                             gui::CanvasGridSize::k8x8, 1.0f};
  gui::Canvas ow_tileset_canvas_{"##OWTilesetCanvas", ImVec2(128, 128),
                                 gui::CanvasGridSize::k8x8, 2.0f};
 
  // Undo/redo pending state
  bool has_pending_dungeon_undo_ = false;
  bool has_pending_tile16_undo_ = false;
  bool pending_dungeon_map_changes_ = false;
  bool pending_dungeon_map_tile16_changes_ = false;
  bool pending_title_screen_changes_ = false;
  bool pending_overworld_map_changes_ = false;
  bool pending_overworld_map_palette_changes_ = false;
  bool rom_backed_state_valid_ = false;
  Rom* loaded_rom_ = nullptr;
  zelda3::GameData* loaded_game_data_ = nullptr;
  bool map_save_transaction_active_ = false;
  bool map_save_serialized_ = false;
  ScreenSnapshot pending_dungeon_before_;
  ScreenSnapshot pending_tile16_before_;
  std::string pending_dungeon_desc_;
  std::string pending_tile16_desc_;
 
  Rom* rom_;
  absl::Status status_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif