palette_group_panel.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_GRAPHICS_PALETTE_GROUP_CARD_H
#define YAZE_APP_EDITOR_GRAPHICS_PALETTE_GROUP_CARD_H
 
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/system/editor_panel.h"
#include "app/gfx/types/snes_color.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/core/icons.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "zelda3/game_data.h"
 
namespace yaze {
namespace project {
struct YazeProject;
}
namespace editor {
 
// Forward declaration
class ToastManager;
 
struct ColorChange {
  int palette_index;
  int color_index;
  gfx::SnesColor original_color;
  gfx::SnesColor new_color;
  uint64_t timestamp;  // For history ordering
};
 
struct PaletteMetadata {
  int palette_id;           // Palette ID in ROM
  std::string name;         // Display name (e.g., "Light World Main")
  std::string description;  // Usage description
  uint32_t rom_address;     // Base ROM address for this palette
  uint32_t vram_address;    // VRAM address (for sprite palettes, 0 if N/A)
  std::string usage_notes;  // Additional usage information
};
 
struct PaletteGroupMetadata {
  std::string group_name;                 // Internal group name
  std::string display_name;               // Display name for UI
  std::vector<PaletteMetadata> palettes;  // Metadata for each palette
  int colors_per_palette;  // Number of colors per palette (usually 8 or 16)
  int colors_per_row;      // Colors per row for grid layout
};
 
class PaletteGroupPanel : public WindowContent {
 public:
  PaletteGroupPanel(const std::string& group_name,
                    const std::string& display_name, Rom* rom,
                    zelda3::GameData* game_data = nullptr);
 
  void SetGameData(zelda3::GameData* game_data) { game_data_ = game_data; }
 
  virtual ~PaletteGroupPanel() = default;
 
  // ========== Main Rendering ==========
 
  void Draw(bool* p_open) override;
  // Same editing surface, without a second save/undo toolbar.
  void DrawEmbedded();
 
  // WindowContent Implementation
  std::string GetId() const override { return "palette." + group_name_; }
  std::string GetDisplayName() const override { return display_name_; }
  std::string GetIcon() const override {
    return ICON_MD_PALETTE;
  }  // Default, override in derived
  std::string GetEditorCategory() const override { return "Palette"; }
  // Optional comparison windows reuse the main workspace editing controls.
  WindowPresentationPolicy GetPresentationPolicy() const override {
    return WindowPresentationPolicy::OptionalPopOut();
  }
  int GetPriority() const override {
    return 50;
  }  // Default, override in derived
 
  // ========== Panel Control ==========
 
  void Show() { show_ = true; }
  void Hide() { show_ = false; }
  bool IsVisible() const { return show_; }
  bool* visibility_flag() { return &show_; }
 
  void SetToastManager(ToastManager* toast_manager) {
    toast_manager_ = toast_manager;
  }
  void SetProject(const project::YazeProject* project) { project_ = project; }
  bool IsOwnedByRom(const Rom* rom) const { return rom_ == rom; }
 
  // ========== Palette Operations ==========
 
  absl::Status SaveToRom();
 
  void DiscardChanges();
 
  void ResetPalette(int palette_index);
 
  void ResetColor(int palette_index, int color_index);
 
  void SetColor(int palette_index, int color_index,
                const gfx::SnesColor& new_color);
 
  // ========== History Management ==========
 
  void Undo();
  void Redo();
  bool CanUndo() const;
  bool CanRedo() const;
  void ClearHistory();
 
  // ========== State Queries ==========
 
  bool HasUnsavedChanges() const;
  bool IsPaletteModified(int palette_index) const;
  bool IsColorModified(int palette_index, int color_index) const;
 
  int GetSelectedPaletteIndex() const { return selected_palette_; }
  void SetSelectedPaletteIndex(int index);
 
  int GetSelectedColorIndex() const { return selected_color_; }
  void SetSelectedColorIndex(int index) { selected_color_ = index; }
 
  // ========== Export/Import ==========
 
  std::string ExportToJson() const;
  absl::Status ImportFromJson(const std::string& json);
 
  std::string ExportToClipboard() const;
  absl::Status ImportFromClipboard();
 
 protected:
  // ========== Pure Virtual Methods (Implemented by Derived Classes) ==========
 
  virtual gfx::PaletteGroup* GetPaletteGroup() = 0;
  virtual const gfx::PaletteGroup* GetPaletteGroup() const = 0;
 
  virtual const PaletteGroupMetadata& GetMetadata() const = 0;
 
  void DrawPaletteGrid();
  void DrawContent(bool embedded);
 
  virtual int GetColorsPerRow() const = 0;
 
  // ========== Optional Overrides ==========
 
  virtual void DrawCustomToolbarButtons() {}
 
  virtual void DrawCustomPanels() {}
 
  // ========== Common UI Components ==========
 
  void DrawToolbar();
 
  void DrawPaletteSelector();
 
  void DrawColorPicker();
 
  void DrawColorInfo();
 
  void DrawMetadataInfo();
 
  void DrawBatchOperationsPopup();
 
  // ========== Helper Methods ==========
 
  gfx::SnesPalette* GetMutablePalette(int index);
 
  gfx::SnesColor GetOriginalColor(int palette_index, int color_index) const;
 
  bool IsManagedSession() const;
 
  void MarkModified(int palette_index, int color_index);
 
  void ClearModified(int palette_index);
 
  // ========== Member Variables ==========
 
  std::string group_name_;    // Internal name (e.g., "ow_main")
  std::string display_name_;  // Display name (e.g., "Overworld Main")
  Rom* rom_;                  // ROM instance
  zelda3::GameData* game_data_ = nullptr;          // GameData instance
  const project::YazeProject* project_ = nullptr;  // Session save policy
  bool show_ = false;                              // Visibility flag
 
  // Selection state
  int selected_palette_ = 0;  // Currently selected palette index
  int selected_color_ = -1;   // Currently selected color (-1 = none)
 
  // Widget identity keeps an optional comparison window from ending the
  // workspace picker gesture when both render this panel in the same frame.
  ImGuiID active_picker_ = 0;
  bool picker_cancelled_ = false;
 
  // Settings
  bool show_snes_format_ = true;  // Show SNES $xxxx format in info
  bool show_hex_format_ = true;   // Show #xxxxxx hex in info
 
  ToastManager* toast_manager_ = nullptr;
};
 
// ============================================================================
// Concrete Palette Panel Implementations
// ============================================================================
 
class OverworldMainPalettePanel : public PaletteGroupPanel {
 public:
  explicit OverworldMainPalettePanel(Rom* rom,
                                     zelda3::GameData* game_data = nullptr);
  ~OverworldMainPalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 7; }
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_LANDSCAPE; }
  int GetPriority() const override { return 20; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class OverworldAnimatedPalettePanel : public PaletteGroupPanel {
 public:
  explicit OverworldAnimatedPalettePanel(Rom* rom,
                                         zelda3::GameData* game_data = nullptr);
  ~OverworldAnimatedPalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 7; }
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_WATER; }
  int GetPriority() const override { return 30; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class DungeonMainPalettePanel : public PaletteGroupPanel {
 public:
  explicit DungeonMainPalettePanel(Rom* rom,
                                   zelda3::GameData* game_data = nullptr);
  ~DungeonMainPalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 15; }
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_CASTLE; }
  int GetPriority() const override { return 40; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritePalettePanel : public PaletteGroupPanel {
 public:
  explicit SpritePalettePanel(Rom* rom, zelda3::GameData* game_data = nullptr);
  ~SpritePalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 15; }
  void DrawCustomPanels() override;  // Show VRAM info
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_PETS; }
  int GetPriority() const override { return 50; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritesAux1PalettePanel : public PaletteGroupPanel {
 public:
  explicit SpritesAux1PalettePanel(Rom* rom,
                                   zelda3::GameData* game_data = nullptr);
  ~SpritesAux1PalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 7; }
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_FILTER_1; }
  int GetPriority() const override { return 51; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritesAux2PalettePanel : public PaletteGroupPanel {
 public:
  explicit SpritesAux2PalettePanel(Rom* rom,
                                   zelda3::GameData* game_data = nullptr);
  ~SpritesAux2PalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 7; }
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_FILTER_2; }
  int GetPriority() const override { return 52; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritesAux3PalettePanel : public PaletteGroupPanel {
 public:
  explicit SpritesAux3PalettePanel(Rom* rom,
                                   zelda3::GameData* game_data = nullptr);
  ~SpritesAux3PalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 7; }
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_FILTER_3; }
  int GetPriority() const override { return 53; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class EquipmentPalettePanel : public PaletteGroupPanel {
 public:
  explicit EquipmentPalettePanel(Rom* rom,
                                 zelda3::GameData* game_data = nullptr);
  ~EquipmentPalettePanel() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  int GetColorsPerRow() const override { return 15; }
 
  // WindowContent Overrides
  std::string GetIcon() const override { return ICON_MD_SHIELD; }
  int GetPriority() const override { return 60; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_GRAPHICS_PALETTE_GROUP_CARD_H