palette_group_card.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/gfx/types/snes_color.h"
#include "app/gfx/types/snes_palette.h"
#include "app/rom.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace editor {
 
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 PaletteGroupCard {
 public:
  PaletteGroupCard(const std::string& group_name,
                   const std::string& display_name,
                   Rom* rom);
 
  virtual ~PaletteGroupCard() = default;
 
  // ========== Main Rendering ==========
 
  void Draw();
 
  // ========== Card Control ==========
 
  void Show() { show_ = true; }
  void Hide() { show_ = false; }
  bool IsVisible() const { return show_; }
  bool* visibility_flag() { return &show_; }
 
  // ========== 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) { selected_palette_ = 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;
 
  virtual void DrawPaletteGrid() = 0;
 
  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;
 
  absl::Status WriteColorToRom(int palette_index, int color_index,
                                const gfx::SnesColor& color);
 
  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
  bool show_ = false;            // Visibility flag
 
  // Selection state
  int selected_palette_ = 0;     // Currently selected palette index
  int selected_color_ = -1;      // Currently selected color (-1 = none)
  gfx::SnesColor editing_color_; // Color being edited in picker
 
  // Settings
  bool auto_save_enabled_ = false;  // Auto-save to ROM on every change
  bool show_snes_format_ = true;    // Show SNES $xxxx format in info
  bool show_hex_format_ = true;     // Show #xxxxxx hex in info
};
 
// ============================================================================
// Concrete Palette Card Implementations
// ============================================================================
 
class OverworldMainPaletteCard : public PaletteGroupCard {
 public:
  explicit OverworldMainPaletteCard(Rom* rom);
  ~OverworldMainPaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 8; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class OverworldAnimatedPaletteCard : public PaletteGroupCard {
 public:
  explicit OverworldAnimatedPaletteCard(Rom* rom);
  ~OverworldAnimatedPaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 8; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class DungeonMainPaletteCard : public PaletteGroupCard {
 public:
  explicit DungeonMainPaletteCard(Rom* rom);
  ~DungeonMainPaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 16; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritePaletteCard : public PaletteGroupCard {
 public:
  explicit SpritePaletteCard(Rom* rom);
  ~SpritePaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 16; }
  void DrawCustomPanels() override;  // Show VRAM info
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritesAux1PaletteCard : public PaletteGroupCard {
 public:
  explicit SpritesAux1PaletteCard(Rom* rom);
  ~SpritesAux1PaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 8; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritesAux2PaletteCard : public PaletteGroupCard {
 public:
  explicit SpritesAux2PaletteCard(Rom* rom);
  ~SpritesAux2PaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 8; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class SpritesAux3PaletteCard : public PaletteGroupCard {
 public:
  explicit SpritesAux3PaletteCard(Rom* rom);
  ~SpritesAux3PaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 8; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
class EquipmentPaletteCard : public PaletteGroupCard {
 public:
  explicit EquipmentPaletteCard(Rom* rom);
  ~EquipmentPaletteCard() override = default;
 
 protected:
  gfx::PaletteGroup* GetPaletteGroup() override;
  const gfx::PaletteGroup* GetPaletteGroup() const override;
  const PaletteGroupMetadata& GetMetadata() const override { return metadata_; }
  void DrawPaletteGrid() override;
  int GetColorsPerRow() const override { return 8; }
 
 private:
  static PaletteGroupMetadata InitializeMetadata();
  static const PaletteGroupMetadata metadata_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_GRAPHICS_PALETTE_GROUP_CARD_H