graphics_editor.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_GRAPHICS_EDITOR_H
#define YAZE_APP_EDITOR_GRAPHICS_EDITOR_H
 
#include <array>
#include <functional>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include <map>
#include "absl/status/status.h"
#include "app/editor/editor.h"
#include "app/editor/graphics/gfx_group_editor.h"
#include "app/editor/graphics/graphics_editor_state.h"
#include "app/editor/graphics/graphics_save_plan.h"
#include "app/editor/graphics/graphics_sheet_sync.h"
#include "app/editor/graphics/link_sprite_panel.h"
#include "app/editor/graphics/palette_controls_panel.h"
#include "app/editor/graphics/paletteset_editor_panel.h"
#include "app/editor/graphics/pixel_editor_panel.h"
#include "app/editor/graphics/polyhedral_editor_panel.h"
#include "app/editor/graphics/sheet_browser_panel.h"
#include "app/editor/graphics/ui/image_import/image_import_view.h"
#include "app/editor/graphics/ui/scratch/graphics_scratch_view.h"
#include "app/editor/graphics/ui/usage/usage_preview_view.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/canvas/canvas.h"
#include "rom/rom.h"
#include "zelda3/game_data.h"
 
namespace yaze {
namespace editor {
 
class GraphicsEditorSaveStoplossTestPeer;
 
// Super Donkey prototype graphics offsets (from leaked dev materials)
const std::string kSuperDonkeyTiles[] = {
    "97C05", "98219", "9871E", "98C00", "99084", "995AF", "99DE0", "9A27E",
    "9A741", "9AC31", "9B07E", "9B55C", "9B963", "9BB99", "9C009", "9C4B4",
    "9C92B", "9CDD6", "9D2C2", "9E037", "9E527", "9EA56", "9EF65", "9FCD1",
    "A0193", "A059E", "A0B17", "A0FB6", "A14A5", "A1988", "A1E66", "A232B",
    "A27F0", "A2B6E", "A302C", "A3453", "A38CA", "A42BB", "A470C", "A4BA9",
    "A5089", "A5385", "A5742", "A5BCC", "A6017", "A6361", "A66F8"};
 
const std::string kSuperDonkeySprites[] = {
    "A8E5D", "A9435", "A9934", "A9D83", "AA2F1", "AA6D4", "AABE4", "AB127",
    "AB65A", "ABBDD", "AC38D", "AC797", "ACCC8", "AD0AE", "AD245", "AD554",
    "ADAAC", "ADECC", "AE453", "AE9D2", "AEF40", "AF3C9", "AF92E", "AFE9D",
    "B03D2", "B09AC", "B0F0C", "B1430", "B1859", "B1E01", "B229A", "B2854",
    "B2D27", "B31D7", "B3B58", "B40B5", "B45A5", "B4D64", "B5031", "B555F",
    "B5F30", "B6858", "B70DD", "B7526", "B79EC", "B7C83", "B80F7", "B85CC",
    "B8A3F", "B8F97", "B94F2", "B9A20", "B9E9A", "BA3A2", "BA8F6", "BACDC",
    "BB1F9", "BB781", "BBCCA", "BC26D", "BC7D4", "BCBB0", "BD082", "BD5FC",
    "BE115", "BE5C2", "BEB63", "BF0CB", "BF607", "BFA55", "BFD71", "C017D",
    "C0567", "C0981", "C0BA7", "C116D", "C166A", "C1FE0", "C24CE", "C2B19"};
 
class GraphicsEditor : public Editor {
 public:
  explicit GraphicsEditor(Rom* rom = nullptr) : rom_(rom) {
    type_ = EditorType::kGraphics;
  }
 
  void SetDependencies(const EditorDependencies& deps) override {
    Editor::SetDependencies(deps);
    if (gfx_group_panel_) {
      gfx_group_panel_->SetWorkspaceState(deps.gfx_group_workspace);
    }
  }
 
  void SetMainGraphicsUsageCallback(
      GfxGroupEditor::MainUsageCallback callback) {
    main_graphics_usage_ = std::move(callback);
    if (gfx_group_panel_)
      gfx_group_panel_->SetMainUsageCallback(main_graphics_usage_);
  }
  void SetRoomsetGraphicsUsageCallback(
      GfxGroupEditor::RoomsetUsageCallback callback) {
    roomset_graphics_usage_ = std::move(callback);
    if (gfx_group_panel_)
      gfx_group_panel_->SetRoomsetUsageCallback(roomset_graphics_usage_);
  }
  void SetRoomUsageProvider(usage_preview::LiveRoomProvider provider) {
    room_usage_provider_ = std::move(provider);
    if (usage_preview_view_)
      usage_preview_view_->SetLiveRoomProvider(room_usage_provider_);
  }
  void SetOverworldUsageProvider(
      usage_preview::LiveOverworldProvider provider) {
    overworld_usage_provider_ = std::move(provider);
    if (usage_preview_view_)
      usage_preview_view_->SetLiveOverworldProvider(overworld_usage_provider_);
  }
  void PrepareForSessionTeardown() override {
    if (gfx_group_panel_)
      gfx_group_panel_->DetachRuntimeContext();
    SetRoomUsageProvider({});
    SetOverworldUsageProvider({});
    main_graphics_usage_ = {};
    roomset_graphics_usage_ = {};
  }
  void Initialize() override;
  absl::Status Load() override;
  absl::Status Save() override;
  // Detached assets save independently of ROM sheet serialization settings.
  absl::Status SaveScratchAssets();
  absl::Status Update() override;
  // Cut, Copy and Paste use the system clipboard as PNG (pixel editor).
  absl::StatusOr<std::vector<GraphicsSavePlanEntry>> PlanGraphicsSave();
 
  absl::Status Cut() override;
  absl::Status Copy() override;
  absl::Status Paste() override;
  absl::Status Undo() override;
  absl::Status Redo() override;
  absl::Status Find() override { return absl::UnimplementedError("Find"); }
  void ContributeStatus(StatusBar* status_bar) override;
  EditorContextSnapshot BuildContextSnapshot() const override;
 
  bool HasPendingGraphicsChanges() const {
    return state_.HasUnsavedChanges() || state_.selection.is_floating ||
           (pixel_editor_panel_ && pixel_editor_panel_->HasActiveStroke()) ||
           (scratch_view_ && scratch_view_->HasPendingChanges());
  }
 
  // Coordinated ROM save: Save() clears the modified-sheet set, so a failed
  // save elsewhere must put it back (the ROM bytes are restored separately).
  absl::Status BeginSaveTransaction() override {
    // A floating paste has visible pixels but no committed sheet diff. Do not
    // report it saved or choose its placement on the user's behalf.
    if (state_.selection.is_floating)
      return absl::FailedPreconditionError(
          "Commit or cancel the floating paste in Graphics before saving "
          "(Enter to commit, Esc to cancel)");
    if (pixel_editor_panel_) {
      pixel_editor_panel_->FinishReleasedGesture();
      if (pixel_editor_panel_->HasActiveStroke())
        return absl::FailedPreconditionError(
            "Finish the pixel stroke before saving");
    }
    save_transaction_modified_sheets_ = state_.modified_sheets;
    return absl::OkStatus();
  }
  void RollbackSaveTransaction() override {
    if (save_transaction_modified_sheets_.has_value()) {
      state_.modified_sheets = std::move(*save_transaction_modified_sheets_);
      save_transaction_modified_sheets_.reset();
    }
  }
  void CommitSaveTransaction() override {
    save_transaction_modified_sheets_.reset();
  }
 
  // Set the ROM pointer (propagates to panels that cache `Rom*`.)
  void set_rom(Rom* rom) {
    if (rom_ != rom) {
      state_.ClearSourceContext();
      state_.ClearPreviewPalettes();
    }
    rom_ = rom;
    if (sheet_browser_panel_) {
      sheet_browser_panel_->SetDataSources(
          rom, game_data_,
          [this]() -> const project::YazeProject* { return project(); });
    }
    if (pixel_editor_panel_) {
      pixel_editor_panel_->SetRom(rom);
    }
    if (link_sprite_panel_) {
      link_sprite_panel_->SetRom(rom);
    }
    if (gfx_group_panel_) {
      gfx_group_panel_->SetRom(rom);
    }
    if (paletteset_panel_) {
      paletteset_panel_->SetRom(rom);
    }
    if (polyhedral_panel_) {
      polyhedral_panel_->SetRom(rom);
    }
    if (usage_preview_view_) {
      usage_preview_view_->SetRom(rom);
    }
  }
 
  // Set the game data pointer
  void SetGameData(zelda3::GameData* game_data) override {
    game_data_ = game_data;
    AttachSheetStore(state_, game_data);
    if (sheet_browser_panel_) {
      sheet_browser_panel_->SetDataSources(
          rom_, game_data,
          [this]() -> const project::YazeProject* { return project(); });
    }
    if (gfx_group_panel_) {
      gfx_group_panel_->SetGameData(game_data);
    }
    if (paletteset_panel_) {
      paletteset_panel_->SetGameData(game_data);
    }
    if (usage_preview_view_) {
      usage_preview_view_->SetGameData(game_data);
    }
  }
 
  // Editor shortcuts
  void NextSheet();
  // Keyboard shortcut targets (shortcut_configurator.cc).
  void SetPixelTool(PixelTool tool);
  void ZoomIn();
  void ZoomOut();
  void ToggleGrid();
  void PrevSheet();
  void SelectSheet(uint16_t sheet_id);
  void FinishPixelGesture();
  // Opens only Pixel Editor and Usage Preview, retaining the source editor's
  // resolved colors and live preview for this ROM session.
  absl::Status OpenInContext(GraphicsEditContext context);
  absl::Status ImportScratchBin(const std::string& path, int bpp, size_t offset,
                                const gfx::SnesPalette& palette = {});
  void SetScratchPreview(std::string label, ScratchPreviewCallback callback);
  // Callable command only; the existing controls own its future UI entry point.
  absl::Status ReorderSourcePalette(const std::vector<size_t>& targets,
                                    const std::array<uint8_t, 8>& permutation);
  void HighlightTile(uint16_t sheet_id, uint16_t tile_index,
                     const std::string& label = "", double duration_secs = 3.0);
 
  // Get the ROM pointer
  Rom* rom() const { return rom_; }
 
 private:
  struct PreparedGraphicsSave {
    zelda3::GfxSheetWritePolicy policy;
    zelda3::GfxSheetPointerTables tables;
    std::vector<uint16_t> sheet_ids;           // sheets to write
    std::map<uint16_t, std::string> refusals;  // sheet -> reason
  };
  // Checks shared by Save and PlanGraphicsSave.
  absl::StatusOr<PreparedGraphicsSave> PrepareGraphicsSave();
  // Read-back check run on every written sheet. Tests replace it to force a
  // mismatch and exercise the abort path.
  std::function<absl::Status(const Rom&, uint16_t, const std::vector<uint8_t>&,
                             const zelda3::GfxSheetPointerTables&)>
      verify_written_sheet_ = VerifyWrittenSheetPixels;
 
  friend class EditorManagerLayoutTestPeer;
  friend class GraphicsEditorSaveStoplossTestPeer;
  friend class AuthoringSaveWorkflowTestPeer;
  friend class DungeonPaletteSourceTestPeer;
 
  // Applies `edit` to the active project (the copy that is saved) and to this
  // session's project snapshot, then marks the project dirty. Fails when no
  // project file backs this ROM session.
  absl::Status EditProject(
      const std::function<void(project::YazeProject&)>& edit);
 
  // --- Panel-Based Architecture ---
  GraphicsEditorState state_;
  std::optional<std::set<uint16_t>> save_transaction_modified_sheets_;
  std::unique_ptr<SheetBrowserPanel> sheet_browser_panel_;
  std::unique_ptr<PixelEditorPanel> pixel_editor_panel_;
  std::unique_ptr<PaletteControlsPanel> palette_controls_panel_;
  std::unique_ptr<LinkSpritePanel> link_sprite_panel_;
  std::unique_ptr<GfxGroupEditor> gfx_group_panel_;
  GfxGroupEditor::MainUsageCallback main_graphics_usage_;
  GfxGroupEditor::RoomsetUsageCallback roomset_graphics_usage_;
  std::unique_ptr<PalettesetEditorPanel> paletteset_panel_;
  std::unique_ptr<PolyhedralEditorPanel> polyhedral_panel_;
  std::unique_ptr<ImageImportView> image_import_view_;
  usage_preview::LiveRoomProvider room_usage_provider_;
  usage_preview::LiveOverworldProvider overworld_usage_provider_;
  std::unique_ptr<UsagePreviewView> usage_preview_view_;
  std::unique_ptr<GraphicsScratchView> scratch_view_;
 
  // --- Prototype Viewer (Super Donkey / Dev Format Imports) ---
  void DrawPrototypeViewer();
  absl::Status DrawCgxImport();
  absl::Status DrawScrImport();
  absl::Status DrawFileImport();
  absl::Status DrawObjImport();
  absl::Status DrawTilemapImport();
  absl::Status DrawPaletteControls();
  absl::Status DrawClipboardImport();
  absl::Status DrawExperimentalFeatures();
  absl::Status DrawMemoryEditor();
  absl::Status DecompressImportData(int size);
  absl::Status DecompressSuperDonkey();
 
  // Prototype viewer state
  int current_palette_ = 0;
  uint64_t current_offset_ = 0;
  uint64_t current_palette_index_ = 0;
  int current_bpp_ = 0;
  int scr_mod_value_ = 0;
  uint64_t num_sheets_to_load_ = 1;
  uint64_t bin_size_ = 0;
  uint64_t clipboard_offset_ = 0;
  uint64_t clipboard_size_ = 0;
  bool refresh_graphics_ = false;
  bool open_memory_editor_ = false;
  bool gfx_loaded_ = false;
  bool is_open_ = false;
  bool super_donkey_ = false;
  bool col_file_ = false;
  bool cgx_loaded_ = false;
  bool scr_loaded_ = false;
  bool obj_loaded_ = false;
  bool tilemap_loaded_ = false;
 
  std::string file_path_;
  std::string col_file_path_;
  std::string col_file_name_;
  std::string cgx_file_path_;
  std::string cgx_file_name_;
  std::string scr_file_path_;
  std::string scr_file_name_;
  std::string obj_file_path_;
  std::string tilemap_file_path_;
  std::string tilemap_file_name_;
 
  Rom temp_rom_;
  Rom tilemap_rom_;
  std::vector<uint8_t> import_data_;
  std::vector<uint8_t> decoded_cgx_;
  std::vector<uint8_t> cgx_data_;
  std::vector<uint8_t> extra_cgx_data_;
  std::vector<SDL_Color> decoded_col_;
  std::vector<uint8_t> scr_data_;
  std::vector<uint8_t> decoded_scr_data_;
  gfx::Bitmap cgx_bitmap_;
  gfx::Bitmap scr_bitmap_;
  gfx::Bitmap bin_bitmap_;
  std::array<gfx::Bitmap, zelda3::kNumGfxSheets> gfx_sheets_;
  gfx::PaletteGroup col_file_palette_group_;
  gfx::SnesPalette z3_rom_palette_;
  gfx::SnesPalette col_file_palette_;
  gui::Canvas import_canvas_;
  gui::Canvas scr_canvas_;
  gui::Canvas super_donkey_canvas_;
 
  // Last prototype import error (shown inside the Prototype Research panel).
  std::string prototype_import_feedback_;
 
  // Status tracking
  absl::Status status_;
 
  // Core references
  Rom* rom_;
  zelda3::GameData* game_data_ = nullptr;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_GRAPHICS_EDITOR_H