tile_object_handler.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_INTERACTION_TILE_OBJECT_HANDLER_H
#define YAZE_APP_EDITOR_DUNGEON_INTERACTION_TILE_OBJECT_HANDLER_H
 
#include <vector>
#include "app/editor/dungeon/interaction/base_entity_handler.h"
#include "app/editor/dungeon/interaction/ghost_preview_feedback.h"
#include "app/editor/dungeon/interaction/interaction_context.h"
#include "app/gfx/render/background_buffer.h"
#include "zelda3/dungeon/room.h"
#include "zelda3/dungeon/room_object.h"
 
namespace yaze::editor {
 
class TileObjectHandler : public BaseEntityHandler {
 public:
  using GhostCapacityState = PlacementCapacityState;
  struct GhostPreviewGeometry {
    int render_anchor_x_tiles = 0;
    int render_anchor_y_tiles = 0;
    int offset_x_tiles = 0;
    int offset_y_tiles = 0;
    int width_pixels = 8;
    int height_pixels = 8;
    int buffer_width_pixels = 8;
    int buffer_height_pixels = 8;
  };
 
  enum class PlacementBlockReason {
    kNone = 0,
    kInvalidRoom,
    kObjectLimit,
  };
 
  TileObjectHandler() : ghost_preview_buffer_(nullptr) {}
  explicit TileObjectHandler(InteractionContext* ctx) { SetContext(ctx); }
 
  // ========================================================================
  // BaseEntityHandler interface
  // ========================================================================
 
  void BeginPlacement() override;
  void CancelPlacement() override;
  bool IsPlacementActive() const override { return object_placement_mode_; }
 
  bool HandleClick(int canvas_x, int canvas_y) override;
  void HandleDrag(ImVec2 current_pos, ImVec2 delta) override;
  void HandleRelease() override;
  bool HandleMouseWheel(float delta) override;
 
  void DrawGhostPreview() override;
  void DrawSelectionHighlight() override;
 
  void InitDrag(const ImVec2& start_pos);
 
  // ========================================================================
  // Marquee (Rectangle) Selection
  // ========================================================================
 
  // Begin a rectangle selection drag on empty space (canvas-local coords).
  void BeginMarqueeSelection(const ImVec2& start_pos);
 
  // Update/draw active marquee selection and finalize on mouse release.
  void HandleMarqueeSelection(const ImVec2& mouse_pos, bool mouse_left_down,
                              bool mouse_left_released, bool shift_down,
                              bool toggle_down, bool alt_down,
                              bool draw_box = true);
 
  std::optional<size_t> GetEntityAtPosition(int canvas_x,
                                            int canvas_y) const override;
 
  void MoveObjects(int room_id, const std::vector<size_t>& indices, int delta_x,
                   int delta_y, bool notify_mutation = true);
 
  std::vector<size_t> DuplicateObjects(int room_id,
                                       const std::vector<size_t>& indices,
                                       int delta_x, int delta_y,
                                       bool notify_mutation = true);
 
  void DeleteObjects(int room_id, std::vector<size_t> indices);
 
  void DeleteAllObjects(int room_id);
 
  void SendToFront(int room_id, const std::vector<size_t>& indices);
  void SendToBack(int room_id, const std::vector<size_t>& indices);
  void MoveForward(int room_id, const std::vector<size_t>& indices);
  void MoveBackward(int room_id, const std::vector<size_t>& indices);
 
  bool ResizeObjects(int room_id, const std::vector<size_t>& indices, int delta,
                     bool horizontal = false);
 
  bool PlaceObjectAt(int room_id, const zelda3::RoomObject& object, int x,
                     int y);
 
  bool was_placement_blocked() const {
    return placement_block_reason_ != PlacementBlockReason::kNone;
  }
  PlacementBlockReason placement_block_reason() const {
    return placement_block_reason_;
  }
  void clear_placement_blocked() {
    placement_block_reason_ = PlacementBlockReason::kNone;
  }
  GhostCapacityState GetPlacementGhostCapacityState() const;
 
  void UpdateObjectsId(int room_id, const std::vector<size_t>& indices,
                       int16_t new_id);
 
  void UpdateObjectsSize(int room_id, const std::vector<size_t>& indices,
                         uint8_t new_size);
 
  // Returns false when the request is rejected. Accepted no-op updates return
  // true so inspector controls can distinguish validation failures from an
  // already-selected target.
  bool UpdateObjectsLayer(int room_id, const std::vector<size_t>& indices,
                          int new_layer);
 
  void SetPreviewObject(const zelda3::RoomObject& object);
  const zelda3::RoomObject& GetPreviewObject() const { return preview_object_; }
 
  void RefreshPreviewGraphics();
 
  static GhostPreviewGeometry CalculateGhostPreviewGeometry(
      const zelda3::RoomObject& object);
 
  const gfx::BackgroundBuffer* ghost_preview_buffer_for_testing() const {
    return ghost_preview_buffer_.get();
  }
 
  // ========================================================================
  // Clipboard Operations
  // ========================================================================
 
  void CopyObjectsToClipboard(int room_id, const std::vector<size_t>& indices);
 
  std::vector<size_t> PasteFromClipboard(int room_id, int offset_x,
                                         int offset_y);
 
  std::vector<size_t> PasteFromClipboardAt(int room_id, int target_x,
                                           int target_y);
 
  bool HasClipboardData() const { return !clipboard_.empty(); }
 
  void ClearClipboard() { clipboard_.clear(); }
 
 private:
  // Placement state
  bool object_placement_mode_ = false;
  PlacementBlockReason placement_block_reason_ = PlacementBlockReason::kNone;
  zelda3::RoomObject preview_object_{-1, 0, 0, 0};
  std::unique_ptr<gfx::BackgroundBuffer> ghost_preview_buffer_;
  bool ghost_preview_bitmap_ready_ = false;
  bool ghost_preview_create_queued_ = false;
  uint64_t ghost_preview_graphics_revision_ = 0;
  int ghost_preview_room_id_ = -1;
 
  // Clipboard
  std::vector<zelda3::RoomObject> clipboard_;
 
  void RenderGhostPreviewBitmap();
 
  // Drag state
  bool is_dragging_ = false;
  ImVec2 drag_start_{0, 0};
  ImVec2 drag_current_{0, 0};
  int drag_last_dx_ = 0;
  int drag_last_dy_ = 0;
  bool drag_has_duplicated_ = false;
  bool drag_mutation_started_ = false;
 
  ImVec2 ApplyDragModifiers(const ImVec2& delta) const;
  void DrawSmartGuides(const std::vector<zelda3::RoomObject>& objects) const;
 
  zelda3::Room* GetRoom(int room_id);
  void NotifyChange(zelda3::Room* room);
};
 
}  // namespace yaze::editor
 
#endif  // YAZE_APP_EDITOR_DUNGEON_INTERACTION_TILE_OBJECT_HANDLER_H