palette_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_PALETTE_MANAGER_H
#define YAZE_APP_GFX_PALETTE_MANAGER_H
 
#include <cstdint>
#include <deque>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/gfx/types/snes_color.h"
#include "app/gfx/types/snes_palette.h"
#include "app/rom.h"
 
namespace yaze {
namespace gfx {
 
struct PaletteColorChange {
  std::string group_name;        
  int palette_index;             
  int color_index;               
  SnesColor original_color;      
  SnesColor new_color;           
  uint64_t timestamp_ms;         
};
 
struct PaletteChangeEvent {
  enum class Type {
    kColorChanged,        
    kPaletteReset,        
    kGroupSaved,          
    kGroupDiscarded,      
    kAllSaved,            
    kAllDiscarded         
  };
 
  Type type;
  std::string group_name;
  int palette_index = -1;
  int color_index = -1;
};
 
class PaletteManager {
 public:
  using ChangeCallback = std::function<void(const PaletteChangeEvent&)>;
 
  static PaletteManager& Get() {
    static PaletteManager instance;
    return instance;
  }
 
  // Delete copy/move constructors and assignment operators
  PaletteManager(const PaletteManager&) = delete;
  PaletteManager& operator=(const PaletteManager&) = delete;
  PaletteManager(PaletteManager&&) = delete;
  PaletteManager& operator=(PaletteManager&&) = delete;
 
  // ========== Initialization ==========
 
  void Initialize(Rom* rom);
 
  bool IsInitialized() const { return rom_ != nullptr; }
 
  // ========== Color Operations ==========
 
  SnesColor GetColor(const std::string& group_name, int palette_index,
                     int color_index) const;
 
  absl::Status SetColor(const std::string& group_name, int palette_index,
                        int color_index, const SnesColor& new_color);
 
  absl::Status ResetColor(const std::string& group_name, int palette_index,
                          int color_index);
 
  absl::Status ResetPalette(const std::string& group_name, int palette_index);
 
  // ========== Dirty Tracking ==========
 
  bool HasUnsavedChanges() const;
 
  std::vector<std::string> GetModifiedGroups() const;
 
  bool IsGroupModified(const std::string& group_name) const;
 
  bool IsPaletteModified(const std::string& group_name,
                         int palette_index) const;
 
  bool IsColorModified(const std::string& group_name, int palette_index,
                       int color_index) const;
 
  size_t GetModifiedColorCount() const;
 
  // ========== Persistence ==========
 
  absl::Status SaveGroup(const std::string& group_name);
 
  absl::Status SaveAllToRom();
 
  void DiscardGroup(const std::string& group_name);
 
  void DiscardAllChanges();
 
  // ========== Undo/Redo ==========
 
  void Undo();
 
  void Redo();
 
  bool CanUndo() const { return !undo_stack_.empty(); }
 
  bool CanRedo() const { return !redo_stack_.empty(); }
 
  size_t GetUndoStackSize() const { return undo_stack_.size(); }
 
  size_t GetRedoStackSize() const { return redo_stack_.size(); }
 
  void ClearHistory();
 
  // ========== Change Notifications ==========
 
  int RegisterChangeListener(ChangeCallback callback);
 
  void UnregisterChangeListener(int callback_id);
 
  // ========== Batch Operations ==========
 
  void BeginBatch();
 
  void EndBatch();
 
  bool InBatch() const { return batch_depth_ > 0; }
 
 private:
  PaletteManager() = default;
  ~PaletteManager() = default;
 
  PaletteGroup* GetMutableGroup(const std::string& group_name);
 
  const PaletteGroup* GetGroup(const std::string& group_name) const;
 
  SnesColor GetOriginalColor(const std::string& group_name, int palette_index,
                              int color_index) const;
 
  void RecordChange(const PaletteColorChange& change);
 
  void NotifyListeners(const PaletteChangeEvent& event);
 
  void MarkModified(const std::string& group_name, int palette_index,
                    int color_index);
 
  void ClearModifiedFlags(const std::string& group_name);
 
  // ========== Member Variables ==========
 
  Rom* rom_ = nullptr;
 
  std::unordered_map<std::string, std::vector<SnesPalette>>
      original_palettes_;
 
  std::unordered_map<std::string, std::unordered_set<int>>
      modified_palettes_;
 
  std::unordered_map<std::string,
                     std::unordered_map<int, std::unordered_set<int>>>
      modified_colors_;
 
  std::deque<PaletteColorChange> undo_stack_;
  std::deque<PaletteColorChange> redo_stack_;
  static constexpr size_t kMaxUndoHistory = 500;
 
  std::unordered_map<int, ChangeCallback> change_listeners_;
  int next_callback_id_ = 1;
 
  int batch_depth_ = 0;
  std::vector<PaletteColorChange> batch_changes_;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_PALETTE_MANAGER_H