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 <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#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;
 
  void ActivateSession(zelda3::GameData* game_data);
 
  // In-memory color changes, independent of sheet pixels and file-save state.
  uint64_t ColorRevision(const zelda3::GameData* game_data) const;
 
  bool IsSessionActive(const zelda3::GameData* game_data) const;
 
  bool IsManaging(const zelda3::GameData* game_data) const;
 
  void ReleaseSession(const zelda3::GameData* game_data);
 
  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);
 
  // A command in another editor owns history for these changes. Preflights
  // expected colors and defers notifications until the participant succeeds.
  // On failure restores palette values and tracking; the participant must
  // restore its own state before returning an error. Does not push/clear history.
  absl::Status ApplyExternalChanges(
      const zelda3::GameData* owner,
      const std::vector<PaletteColorChange>& changes,
      const std::function<absl::Status()>& participant);
 
  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);
 
  // Live single-color interaction. SetColor still publishes every preview;
  // commit records only its first/final colors. Cancel preserves Undo/Redo.
  // Explicit navigation or another operation commits the interaction. A nonzero
  // caller ID prevents another visible picker from ending this gesture.
  absl::Status BeginColorEdit(const std::string& group_name, int palette_index,
                              int color_index, uint64_t caller_id = 0);
  void CommitColorEdit(uint64_t caller_id = 0);
  void CancelColorEdit(uint64_t caller_id = 0);
  bool HasColorEdit(uint64_t caller_id = 0) const;
 
  // ========== Dirty Tracking ==========
 
  bool HasUnsavedChanges() const;
 
  bool HasUnsavedChanges(const zelda3::GameData* game_data) 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;
 
  size_t GetModifiedColorCount(const zelda3::GameData* game_data) const;
 
  std::vector<std::pair<uint32_t, uint32_t>> GetModifiedColorWriteRanges()
      const;
 
  std::vector<std::pair<uint32_t, uint32_t>> GetModifiedColorWriteRanges(
      const zelda3::GameData* game_data) const;
 
  std::vector<std::pair<uint32_t, uint32_t>> GetModifiedGroupColorWriteRanges(
      const std::string& group_name) const;
 
  // ========== Persistence ==========
 
  absl::Status SaveGroup(const std::string& group_name);
 
  absl::Status SaveAllToRom();
 
  // Checkpoint persistence metadata that SaveGroup/SaveAllToRom clear. This is
  // used by the coordinated ROM-save pipeline so a later serializer,
  // validation gate, backup, or disk failure leaves palette edits retryable.
  absl::Status BeginSaveTransaction();
  void RollbackSaveTransaction();
  void CommitSaveTransaction();
 
  void DiscardGroup(const std::string& group_name);
 
  void DiscardAllChanges();
 
  // ========== Preview Mode ==========
 
  absl::Status ApplyPreviewChanges();
 
  // ========== Undo/Redo ==========
 
  void Undo();
 
  void Redo();
 
  bool CanUndo() const;
 
  bool CanRedo() const;
 
  size_t GetUndoStackSize() const;
 
  size_t GetRedoStackSize() const;
 
  void ClearHistory();
 
  // ========== Change Notifications ==========
 
  int RegisterChangeListener(ChangeCallback callback);
 
  void UnregisterChangeListener(int callback_id);
 
  // ========== Batch Operations ==========
 
  void BeginBatch();
 
  void EndBatch();
 
  bool InBatch() const;
 
  // Original value used by ResetColor and the before/after comparison UI.
  SnesColor GetOriginalColor(const std::string& group_name, int palette_index,
                             int color_index) const;
 
 private:
  PaletteManager() = default;
  ~PaletteManager() = default;
 
  PaletteGroup* GetMutableGroup(const std::string& group_name);
 
  const PaletteGroup* GetGroup(const std::string& group_name) const;
 
  void RecordChanges(std::vector<PaletteColorChange> changes);
 
  // Simulate the complete entry in replay order before changing any color or
  // history. Repeated-slot changes compare against staged intermediate values.
  bool CanReplayHistory(const std::vector<PaletteColorChange>& changes,
                        bool redo) 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);
 
  struct SaveTransactionSnapshot {
    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;
  };
 
  struct SessionState {
    bool initialized = false;
    uint64_t color_revision = 0;
    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::optional<SaveTransactionSnapshot> save_transaction_snapshot;
    std::deque<std::vector<PaletteColorChange>> undo_stack;
    std::deque<std::vector<PaletteColorChange>> redo_stack;
    std::optional<PaletteColorChange> color_edit;
    uint64_t color_edit_caller = 0;
    int batch_depth = 0;
    std::vector<PaletteColorChange> batch_changes;
  };
 
  SessionState* CurrentState();
  const SessionState* CurrentState() const;
  const SessionState* FindState(const zelda3::GameData* game_data) const;
 
  // ========== Member Variables ==========
 
  zelda3::GameData* game_data_ = nullptr;
 
  Rom* rom_ = nullptr;
 
  std::unordered_map<const zelda3::GameData*, SessionState> session_states_;
 
  SessionState unbound_state_;
 
  static constexpr size_t kMaxUndoHistory = 500;
 
  std::unordered_map<int, ChangeCallback> change_listeners_;
  int next_callback_id_ = 1;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_PALETTE_MANAGER_H