canvas_interaction_handler.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_CANVAS_CANVAS_INTERACTION_HANDLER_H
#define YAZE_APP_GUI_CANVAS_CANVAS_INTERACTION_HANDLER_H
 
#include <vector>
#include "app/gfx/core/bitmap.h"
#include "app/gfx/render/tilemap.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
enum class TileInteractionMode {
  kNone,              // No interaction
  kPaintSingle,       // Paint single tiles
  kPaintDrag,         // Paint while dragging
  kSelectSingle,      // Select single tile
  kSelectRectangle,   // Select rectangular region
  kColorPaint         // Paint with solid color
};
 
struct TileInteractionResult {
  bool interaction_occurred = false;
  ImVec2 tile_position = ImVec2(-1, -1);
  std::vector<ImVec2> selected_tiles;
  int tile_id = -1;
  
  void Reset() {
    interaction_occurred = false;
    tile_position = ImVec2(-1, -1);
    selected_tiles.clear();
    tile_id = -1;
  }
};
 
class CanvasInteractionHandler {
 public:
  CanvasInteractionHandler() = default;
  
  void Initialize(const std::string& canvas_id);
  
  void SetMode(TileInteractionMode mode) { current_mode_ = mode; }
  TileInteractionMode GetMode() const { return current_mode_; }
  
  TileInteractionResult Update(ImVec2 canvas_p0, ImVec2 scrolling, 
                               float global_scale, float tile_size,
                               ImVec2 canvas_size, bool is_hovered);
  
  bool DrawTilePainter(const gfx::Bitmap& bitmap, ImDrawList* draw_list,
                      ImVec2 canvas_p0, ImVec2 scrolling, float global_scale,
                      float tile_size, bool is_hovered);
  
  bool DrawTilemapPainter(gfx::Tilemap& tilemap, int current_tile, 
                         ImDrawList* draw_list, ImVec2 canvas_p0, 
                         ImVec2 scrolling, float global_scale, bool is_hovered);
  
  bool DrawSolidTilePainter(const ImVec4& color, ImDrawList* draw_list,
                           ImVec2 canvas_p0, ImVec2 scrolling, 
                           float global_scale, float tile_size, bool is_hovered);
  
  bool DrawTileSelector(ImDrawList* draw_list, ImVec2 canvas_p0, 
                       ImVec2 scrolling, float tile_size, bool is_hovered);
  
  bool DrawSelectRect(int current_map, ImDrawList* draw_list, ImVec2 canvas_p0,
                     ImVec2 scrolling, float global_scale, float tile_size,
                     bool is_hovered);
  
  const ImVector<ImVec2>& GetHoverPoints() const { return hover_points_; }
  
  const ImVector<ImVec2>& GetSelectedPoints() const { return selected_points_; }
  
  const std::vector<ImVec2>& GetSelectedTiles() const { return selected_tiles_; }
  
  ImVec2 GetDrawnTilePosition() const { return drawn_tile_pos_; }
  
  ImVec2 GetMousePositionInCanvas() const { return mouse_pos_in_canvas_; }
  
  void ClearState();
  
  bool IsRectSelectActive() const { return rect_select_active_; }
  
  ImVec2 GetSelectedTilePosition() const { return selected_tile_pos_; }
  
  void SetSelectedTilePosition(ImVec2 pos) { selected_tile_pos_ = pos; }
 
 private:
  std::string canvas_id_;
  TileInteractionMode current_mode_ = TileInteractionMode::kNone;
  
  // Interaction state
  ImVector<ImVec2> hover_points_;           // Current hover preview points
  ImVector<ImVec2> selected_points_;        // Selected rectangle points
  std::vector<ImVec2> selected_tiles_;      // Selected tiles from rect
  ImVec2 drawn_tile_pos_ = ImVec2(-1, -1);  // Last drawn tile position
  ImVec2 mouse_pos_in_canvas_ = ImVec2(0, 0); // Current mouse in canvas space
  ImVec2 selected_tile_pos_ = ImVec2(-1, -1); // Single tile selection
  bool rect_select_active_ = false;
  
  // Helper methods
  ImVec2 AlignPosToGrid(ImVec2 pos, float grid_step);
  ImVec2 GetMousePosition(ImVec2 canvas_p0, ImVec2 scrolling);
  bool IsMouseClicked(ImGuiMouseButton button);
  bool IsMouseDoubleClicked(ImGuiMouseButton button);
  bool IsMouseDragging(ImGuiMouseButton button);
  bool IsMouseReleased(ImGuiMouseButton button);
};
 
}  // namespace gui
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_CANVAS_CANVAS_INTERACTION_HANDLER_H