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"
 
namespace yaze {
 
// Forward declarations
class Rom;
namespace zelda3 {
struct GameData;
}
 
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(zelda3::GameData* game_data);
 
  void Initialize(Rom* rom);
 
  bool IsInitialized() const { return game_data_ != nullptr || rom_ != nullptr; }
 
  void ResetForTesting();
 
  // ========== 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();
 
  // ========== Preview Mode ==========
 
  absl::Status ApplyPreviewChanges();
 
  // ========== 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 ==========
 
  zelda3::GameData* game_data_ = nullptr;
 
  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