canvas_navigation_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_OVERWORLD_CANVAS_NAVIGATION_MANAGER_H
#define YAZE_APP_EDITOR_OVERWORLD_CANVAS_NAVIGATION_MANAGER_H
 
#include <array>
#include <functional>
#include <memory>
#include <optional>
#include <vector>
 
#include "absl/status/status.h"
#include "app/editor/overworld/ui/ui_constants.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/render/tilemap.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/widgets/tile_selector_widget.h"
#include "rom/rom.h"
#include "zelda3/common.h"
#include "zelda3/overworld/overworld.h"
 
namespace yaze::editor {
 
// Forward declarations
class OverworldEntityRenderer;
 
struct StickyWheelPan {
  ImVec2 residual{0.0f, 0.0f};
  float idle_seconds = 0.0f;
 
  ImVec2 Consume(ImVec2 wheel, float dt, float step_px, float snap_px);
};
 
ImVec2 ScrollForZoomAtAnchor(ImVec2 scroll, ImVec2 anchor, float old_scale,
                             float new_scale);
 
// =============================================================================
// CanvasNavigationManager
// =============================================================================
//
// Extracted from OverworldEditor to encapsulate all canvas navigation logic:
//   - Map hover detection and lazy loading (CheckForCurrentMap)
//   - Pan and zoom controls
//   - Map interaction (context menus, lock toggle)
//   - Background preloading of adjacent maps
//   - Blockset selector synchronization
//
// The manager holds pointers to shared editor state (via NavigationContext)
// and uses callbacks for operations that remain in the editor (e.g. map
// refresh, texture creation).
// =============================================================================
 
struct CanvasNavigationContext {
  // Canvas references
  gui::Canvas* ow_map_canvas = nullptr;
 
  // Data model
  zelda3::Overworld* overworld = nullptr;
  Rom* rom = nullptr;
 
  // Selection state (mutable pointers into editor fields)
  int* current_map = nullptr;
  int* current_world = nullptr;
  int* current_parent = nullptr;
  int* current_tile16 = nullptr;
  int* hovered_map = nullptr;
 
  // Mode state
  EditingMode* current_mode = nullptr;
  bool* current_map_lock = nullptr;
  bool* is_dragging_entity = nullptr;
 
  // Graphics
  std::array<gfx::Bitmap, zelda3::kExpandedMapCount>* maps_bmp = nullptr;
  gfx::Tilemap* tile16_blockset = nullptr;
 
  // Widgets (read-only pointer to editor's unique_ptr)
  std::unique_ptr<gui::TileSelectorWidget>* blockset_selector = nullptr;
};
 
struct CanvasNavigationCallbacks {
  // Display-only project maps have no OverworldMap in the ROM model.
  std::function<int()> displayed_map_count;
  std::function<bool(int)> is_project_terrain_map;
  std::function<void()> refresh_overworld_map;
  std::function<absl::Status()> refresh_tile16_blockset;
  std::function<void(int)> ensure_map_texture;
  std::function<void(int, bool)> select_map_for_editing;
  std::function<bool()> pick_tile16_from_hovered_canvas;
  std::function<bool()> is_entity_hovered;
  std::function<void()> open_map_properties;
};
 
struct MapClickInput {
  EditingMode mode = EditingMode::MOUSE;
  bool left_released = false;
  bool left_dragged = false;  // Moved past the drag threshold while down.
  // The left press this release ends also landed on this canvas, on the map
  // now under the cursor. False for a press that dismissed a popup or menu,
  // or began on another window or another map.
  bool left_press_owned = false;
  bool right_clicked = false;
  bool shift = false;
  bool entity_hovered = false;
};
 
bool IsMapSelectClick(const MapClickInput& input);
 
class CanvasNavigationManager {
 public:
  CanvasNavigationManager() = default;
 
  void Initialize(const CanvasNavigationContext& context,
                  const CanvasNavigationCallbacks& callbacks);
 
  // ===========================================================================
  // Map Detection and Loading
  // ===========================================================================
 
  absl::Status CheckForCurrentMap();
 
  // Update hover and unpinned selection using scaled canvas-local coordinates.
  // Separate from rendering so all edit modes share the same tracking policy.
  std::optional<int> TrackMapAtCanvasPosition(ImVec2 scaled_position);
 
  // ===========================================================================
  // Map Interaction
  // ===========================================================================
 
  void HandleMapInteraction();
 
  bool SelectMapUnderCursor();
 
  // ===========================================================================
  // Pan and Zoom
  // ===========================================================================
  //
  // All scrolling of the canvas child goes through this manager:
  //   BeginCanvasViewport()  immediately before BeginChild: applies zoom,
  //                          drag pan and wheel input via SetNextWindowScroll
  //                          so the frame draws with its final scroll.
  //   EndCanvasViewport()    inside the child after BeginCanvas: records the
  //                          viewport rect, scroll and hover for next frame.
  // The child is created with ImGuiWindowFlags_NoScrollWithMouse so ImGui's
  // own fractional wheel scroll never runs on the canvas.
 
  void BeginCanvasViewport();
  void EndCanvasViewport(bool canvas_item_hovered);
 
  void ZoomIn();
 
  void ZoomOut();
 
  void ZoomToFit();
 
  void ResetOverworldView();
 
  void CenterOverworldView();
 
  void CenterOnMap(int map_id);
  void CenterOnWorldTile(int world_x, int world_y);
 
  bool is_panning() const { return pan_active_; }
 
  void SuspendHoverFollowUntilMouseMoves();
 
  // ===========================================================================
  // Blockset Selector Synchronization
  // ===========================================================================
 
  void ScrollBlocksetCanvasToCurrentTile();
 
  void UpdateBlocksetSelectorState();
 
  // ===========================================================================
  // Background Pre-loading
  // ===========================================================================
 
  void QueueAdjacentMapsForPreload(int center_map);
 
  void ProcessPreloadQueue();
 
 private:
  CanvasNavigationContext ctx_;
  CanvasNavigationCallbacks callbacks_;
 
  // Map under the cursor: the hover-tracked map, else the canvas position.
  std::optional<int> MapUnderCursor() const;
 
  // Left press owned by this canvas (see MapClickInput::left_press_owned):
  // ImGuiIO::MouseClickedTime of that press and the map it landed on.
  double left_press_time_ = -1.0;
  std::optional<int> left_press_map_;
 
  // Hover debounce state
  int last_hovered_map_ = -1;
  float hover_time_ = 0.0f;
  static constexpr float kHoverBuildDelay = 0.15f;
 
  // Background pre-loading state
  std::vector<int> preload_queue_;
  static constexpr float kPreloadStartDelay = 0.3f;
 
  // Zoom by `steps` of kOverworldZoomStep about a viewport-local anchor.
  void ZoomBySteps(int steps, ImVec2 anchor);
  void SetScaleAboutAnchor(float new_scale, ImVec2 anchor);
  ImVec2 ClampScroll(ImVec2 scroll) const;
  ImVec2 ContentSize() const;
 
  // Viewport state recorded by EndCanvasViewport (previous frame).
  ImVec2 viewport_min_{0.0f, 0.0f};
  ImVec2 viewport_size_{0.0f, 0.0f};
  ImVec2 last_scroll_{0.0f, 0.0f};
  bool canvas_item_hovered_ = false;
  bool canvas_window_hovered_ = false;
  bool viewport_known_ = false;
 
  std::optional<ImVec2> hover_follow_suspended_at_;
 
  // Scroll to apply at the next BeginCanvasViewport.
  std::optional<ImVec2> pending_scroll_;
  std::optional<int> pending_center_map_;
 
  // Wheel state
  StickyWheelPan wheel_pan_;
  float zoom_residual_ = 0.0f;
  float zoom_idle_seconds_ = 0.0f;
 
  // Drag pan: content stays pinned to the point grabbed at mouse-down.
  int pan_button_ = -1;
  bool pan_active_ = false;
  ImVec2 pan_anchor_mouse_{0.0f, 0.0f};
  ImVec2 pan_anchor_scroll_{0.0f, 0.0f};
};
 
}  // namespace yaze::editor
 
#endif  // YAZE_APP_EDITOR_OVERWORLD_CANVAS_NAVIGATION_MANAGER_H