object_selection.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_OBJECT_SELECTION_H
#define YAZE_APP_EDITOR_DUNGEON_OBJECT_SELECTION_H
 
#include <cstdint>
#include <functional>
#include <set>
#include <tuple>
#include <vector>
 
#include "app/gui/canvas/canvas.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/object_dimensions.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze {
namespace editor {
 
class ObjectSelection {
 public:
  enum class SelectionMode {
    Single,     // Replace selection with single object
    Add,        // Add to existing selection (Shift)
    Toggle,     // Toggle object in selection (Ctrl)
    Rectangle,  // Rectangle drag selection
  };
 
  // Layer filter constants
  static constexpr int kLayerAll = -1;  // Select from all layers
  static constexpr int kMaskLayer =
      -2;  // Mask mode: only BG2/Layer 1 objects (overlays)
  static constexpr int kLayer1 = 0;  // BG1 (Layer 0)
  static constexpr int kLayer2 = 1;  // BG2 (Layer 1) - overlay objects
  static constexpr int kLayer3 = 2;  // BG3 (Layer 2)
 
  explicit ObjectSelection() = default;
 
  // ============================================================================
  // Selection Operations
  // ============================================================================
 
  void SelectObject(size_t index, SelectionMode mode = SelectionMode::Single);
 
  void SelectObjectsInRect(int room_min_x, int room_min_y, int room_max_x,
                           int room_max_y,
                           const std::vector<zelda3::RoomObject>& objects,
                           SelectionMode mode = SelectionMode::Single);
 
  void SelectAll(size_t object_count);
 
  void SelectAll(const std::vector<zelda3::RoomObject>& objects);
 
  void ClearSelection();
 
  bool IsObjectSelected(size_t index) const;
 
  std::vector<size_t> GetSelectedIndices() const;
 
  size_t GetSelectionCount() const { return selected_indices_.size(); }
 
  bool HasSelection() const { return !selected_indices_.empty(); }
 
  std::optional<size_t> GetPrimarySelection() const;
 
  // ============================================================================
  // Rectangle Selection State
  // ============================================================================
 
  void BeginRectangleSelection(int canvas_x, int canvas_y);
 
  void UpdateRectangleSelection(int canvas_x, int canvas_y);
 
  void EndRectangleSelection(const std::vector<zelda3::RoomObject>& objects,
                             SelectionMode mode = SelectionMode::Single);
 
  void CancelRectangleSelection();
 
  bool IsRectangleSelectionActive() const {
    return rectangle_selection_active_;
  }
 
  std::tuple<int, int, int, int> GetRectangleSelectionBounds() const;
 
  bool IsRectangleLargeEnough(int min_pixels) const;
 
  // ============================================================================
  // Visual Rendering
  // ============================================================================
 
  void DrawSelectionHighlights(
      gui::Canvas* canvas, const std::vector<zelda3::RoomObject>& objects,
      std::function<std::tuple<int, int, int, int>(const zelda3::RoomObject&)>
          bounds_calculator);
 
  void DrawRectangleSelectionBox(gui::Canvas* canvas);
 
  ImVec4 GetLayerTypeColor(const zelda3::RoomObject& object) const;
 
  // ============================================================================
  // Callbacks
  // ============================================================================
 
  void SetSelectionChangedCallback(std::function<void()> callback) {
    selection_changed_callback_ = std::move(callback);
  }
 
  // ============================================================================
  // Layer Filtering
  // ============================================================================
 
  void SetLayerFilter(int layer) { active_layer_filter_ = layer; }
 
  int GetLayerFilter() const { return active_layer_filter_; }
 
  bool IsLayerEnabled(int layer) const {
    return active_layer_filter_ == kLayerAll || active_layer_filter_ == layer;
  }
 
  bool IsLayerFilterActive() const { return active_layer_filter_ != kLayerAll; }
 
  const char* GetLayerFilterName() const {
    switch (active_layer_filter_) {
      case kMaskLayer:
        return "Mask Mode (BG2 Overlays)";
      case kLayer1:
        return "Layer 1 (BG1)";
      case kLayer2:
        return "Layer 2 (BG2)";
      case kLayer3:
        return "Layer 3 (BG3)";
      default:
        return "All Layers";
    }
  }
 
  bool IsMaskModeActive() const { return active_layer_filter_ == kMaskLayer; }
 
  bool PassesLayerFilterForObject(const zelda3::RoomObject& object) const {
    return PassesLayerFilter(object);
  }
 
  void SetLayersMerged(bool merged) { layers_merged_ = merged; }
 
  bool AreLayersMerged() const { return layers_merged_; }
 
  // ============================================================================
  // Utility Functions
  // ============================================================================
 
  static std::pair<int, int> RoomToCanvasCoordinates(int room_x, int room_y);
 
  static std::pair<int, int> CanvasToRoomCoordinates(int canvas_x,
                                                     int canvas_y);
 
  static std::tuple<int, int, int, int> GetObjectBounds(
      const zelda3::RoomObject& object);
 
 private:
  // Selection state
  std::set<size_t>
      selected_indices_;  // Using set for fast lookup and auto-sort
 
  // Rectangle selection state
  bool rectangle_selection_active_ = false;
  int rect_start_x_ = 0;
  int rect_start_y_ = 0;
  int rect_end_x_ = 0;
  int rect_end_y_ = 0;
 
  // Layer filtering state
  int active_layer_filter_ =
      kLayerAll;                // -1 = all layers, 0/1/2 = specific layer
  bool layers_merged_ = false;  // Whether room has merged layers
 
  // Callbacks
  std::function<void()> selection_changed_callback_;
 
  // Helper functions
  void NotifySelectionChanged();
  bool IsObjectInRectangle(const zelda3::RoomObject& object, int min_x,
                           int min_y, int max_x, int max_y) const;
  bool PassesLayerFilter(const zelda3::RoomObject& object) const;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_OBJECT_SELECTION_H