graphics_editor_state.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_GRAPHICS_GRAPHICS_EDITOR_STATE_H
#define YAZE_APP_EDITOR_GRAPHICS_GRAPHICS_EDITOR_STATE_H
 
#include <array>
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include "app/editor/graphics/graphics_edit_context.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_palette.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace zelda3 {
struct GameData;
}  // namespace zelda3
 
namespace editor {
 
enum class PixelTool {
  kSelect,      // Rectangle selection
  kLasso,       // Freeform selection
  kPencil,      // Single pixel drawing
  kBrush,       // Multi-pixel brush
  kEraser,      // Set pixels to transparent (index 0)
  kFill,        // Flood fill
  kLine,        // Line drawing
  kRectangle,   // Rectangle outline/fill
  kEyedropper,  // Color picker from canvas
  kHand,        // Pan the canvas
};
 
struct PixelSelection {
  std::vector<uint8_t> pixel_data;  // Copied pixel indices
  gfx::SnesPalette palette;         // Associated palette
  int x = 0;                        // Selection origin X
  int y = 0;                        // Selection origin Y
  int width = 0;                    // Selection width
  int height = 0;                   // Selection height
  bool is_active = false;           // Whether selection exists
  bool is_floating = false;         // Floating vs committed
 
  void Clear() {
    pixel_data.clear();
    x = y = width = height = 0;
    is_active = false;
    is_floating = false;
  }
};
 
struct TileHighlight {
  uint16_t sheet_id = 0;
  uint16_t tile_index = 0;
  double start_time = 0.0;
  double duration = 0.0;
  bool active = false;
  std::string label;
 
  void Clear() {
    active = false;
    label.clear();
    duration = 0.0;
    start_time = 0.0;
  }
};
 
// A display choice, never an authored palette or a graphics-save operation.
struct GraphicsPaletteSelection {
  std::string group;
  int palette = 0;
  int row = 0;
};
 
class GraphicsEditorState {
 public:
  // --- Current Selection ---
  uint16_t current_sheet_id = 0;
  std::set<uint16_t> open_sheets;
  std::set<uint16_t> selected_sheets;  // Multi-select support
 
  // --- Editing State ---
  PixelTool current_tool = PixelTool::kPencil;
  uint8_t current_color_index = 1;  // Palette index (0 = transparent)
  uint8_t brush_size = 1;           // 1-8 pixel brush
  bool fill_contiguous = true;      // Fill tool: contiguous only
 
  // --- View State ---
  float zoom_level = 4.0f;           // 1x to 16x
  bool show_grid = true;             // 8x8 tile grid
  bool show_pixel_grid = false;      // 1-pixel grid (drawn at 6x and up)
  bool show_tile_boundaries = true;  // 16x16 tile boundaries
  ImVec2 pan_offset = {0, 0};        // Canvas pan offset
 
  // --- Overlay State (for enhanced UX) ---
  bool show_cursor_crosshair = true;    // Crosshair at cursor position
  bool show_brush_preview = true;       // Preview circle for brush/eraser
  bool show_transparency_grid = true;   // Checkerboard for transparent pixels
  bool show_pixel_info_tooltip = true;  // Tooltip with pixel info on hover
 
  // No entry means the sheet's loaded colors. This editor state belongs to one
  // session; choices survive sheet/session navigation, not a ROM replacement.
  std::map<uint16_t, GraphicsPaletteSelection> preview_palettes;
 
  const GraphicsPaletteSelection* PreviewPalette(uint16_t sheet) const {
    const auto found = preview_palettes.find(sheet);
    return found == preview_palettes.end() ? nullptr : &found->second;
  }
 
  // --- Selection State ---
  PixelSelection selection;
  ImVec2 selection_start;        // Drag start point
  bool is_selecting = false;     // Currently drawing selection
  TileHighlight tile_highlight;  // Active tile focus hint
 
  // --- Modified Sheets Tracking ---
  std::set<uint16_t> modified_sheets;
 
  // --- Sheet store (graphics_sheet_sync.h) ---
  // The session whose GraphicsSheetStore holds the pixels; pixel writes go
  // there, and the Arena's bitmaps are display copies.
  zelda3::GameData* game_data = nullptr;
  std::optional<GraphicsEditContext> source_context;
  uint64_t source_context_revision = 0;
  // Set once when navigating to an existing pixel-editor tab.
  std::optional<uint16_t> requested_sheet_tab;
 
  const GraphicsEditTarget* SourceTarget() const {
    if (!source_context || source_context->owner != game_data ||
        source_context->selected_target >= source_context->targets.size()) {
      return nullptr;
    }
    const auto& target =
        source_context->targets[source_context->selected_target];
    return target.sheet_id == current_sheet_id ? &target : nullptr;
  }
 
  void SelectSourceTarget(size_t index) {
    if (!source_context || index >= source_context->targets.size()) {
      return;
    }
    if (on_before_sheet_selected)
      on_before_sheet_selected();
    source_context->selected_target = index;
    const auto& target = source_context->targets[index];
    SelectSheet(target.sheet_id);
    requested_sheet_tab = target.sheet_id;
    current_color_index = 0;
    HighlightTile(target.sheet_id, target.tile_index, target.label, 8.0);
  }
 
  void ClearSourceContext() {
    source_context.reset();
    ++source_context_revision;
  }
  // Store revision each Arena sheet was last refreshed from.
  std::array<uint64_t, 223> arena_revisions{};
 
  // --- Callbacks for cross-panel communication ---
  std::function<void()> on_before_sheet_selected;
  std::function<void(uint16_t)> on_sheet_selected;
  std::function<void()> on_tool_changed;
  std::function<void(uint16_t)> on_sheet_modified;
 
  // --- Methods ---
 
  void MarkSheetModified(uint16_t sheet_id) {
    modified_sheets.insert(sheet_id);
    if (on_sheet_modified) {
      on_sheet_modified(sheet_id);
    }
  }
 
  void ClearModifiedSheets() { modified_sheets.clear(); }
 
  void ClearModifiedSheets(const std::set<uint16_t>& sheet_ids) {
    for (auto sheet_id : sheet_ids) {
      modified_sheets.erase(sheet_id);
    }
  }
 
  bool HasUnsavedChanges() const { return !modified_sheets.empty(); }
 
  void SelectSheet(uint16_t sheet_id) {
    if (sheet_id != current_sheet_id && on_before_sheet_selected)
      on_before_sheet_selected();
    current_sheet_id = sheet_id;
    open_sheets.insert(sheet_id);
    if (on_sheet_selected) {
      on_sheet_selected(sheet_id);
    }
  }
 
  void HighlightTile(uint16_t sheet_id, uint16_t tile_index,
                     const std::string& label = "",
                     double duration_secs = 3.0) {
    tile_highlight.sheet_id = sheet_id;
    tile_highlight.tile_index = tile_index;
    tile_highlight.label = label;
    tile_highlight.start_time = ImGui::GetTime();
    tile_highlight.duration = duration_secs;
    tile_highlight.active = true;
  }
 
  void CloseSheet(uint16_t sheet_id) { open_sheets.erase(sheet_id); }
 
  void SetTool(PixelTool tool) {
    current_tool = tool;
    if (on_tool_changed) {
      on_tool_changed();
    }
  }
 
  void SetZoom(float zoom) { zoom_level = std::clamp(zoom, 1.0f, 16.0f); }
 
  void ZoomIn() { SetZoom(zoom_level + 1.0f); }
  void ZoomOut() { SetZoom(zoom_level - 1.0f); }
 
  const char* GetToolName() const {
    switch (current_tool) {
      case PixelTool::kSelect:
        return "Select";
      case PixelTool::kLasso:
        return "Lasso";
      case PixelTool::kPencil:
        return "Pencil";
      case PixelTool::kBrush:
        return "Brush";
      case PixelTool::kEraser:
        return "Eraser";
      case PixelTool::kFill:
        return "Fill";
      case PixelTool::kLine:
        return "Line";
      case PixelTool::kRectangle:
        return "Rectangle";
      case PixelTool::kEyedropper:
        return "Eyedropper";
      case PixelTool::kHand:
        return "Hand";
      default:
        return "Unknown";
    }
  }
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_GRAPHICS_GRAPHICS_EDITOR_STATE_H