coordinate_mapper.h

Go to the documentation of this file.

#ifndef YAZE_APP_GUI_CANVAS_COORDINATE_MAPPER_H
#define YAZE_APP_GUI_CANVAS_COORDINATE_MAPPER_H
 
#include <cstdint>
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
#include "app/gui/canvas/canvas_state.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
// Forward declaration (defined in canvas.h)
struct CanvasRuntime;
 
struct TileHitInfo {
  int tile_id = -1;            
  int tile16_index = -1;       
  uint32_t rom_offset = 0;     
  int palette_group = 0;       
  int palette_index = 0;       
  ImVec2 tile_origin_px;       
  ImVec2 tile_size_px;         
  bool is_valid = false;       
 
  // Extended information for debugging
  int map_x = -1;              
  int map_y = -1;              
  int local_map_id = -1;       
  std::string canvas_id;       
};
 
struct ScreenToTileResult {
  // Input coordinates
  float screen_x = 0.0f;       
  float screen_y = 0.0f;       
 
  // Canvas-relative coordinates
  float canvas_x = 0.0f;       
  float canvas_y = 0.0f;       
 
  // Scaled coordinates (accounting for zoom)
  float scaled_x = 0.0f;       
  float scaled_y = 0.0f;       
 
  // Scroll-adjusted coordinates
  float content_x = 0.0f;      
  float content_y = 0.0f;      
 
  // Tile information
  TileHitInfo tile_info;       
 
  // Validity
  bool in_canvas_bounds = false;  
};
 
struct CoordinateMapperConfig {
  float tile_size = 16.0f;        
  int tiles_per_row = 32;         
  int tiles_per_col = 32;         
  int local_map_size = 512;       
  bool use_tile16 = true;         
};
 
class CoordinateMapper {
 public:
  CoordinateMapper() = default;
  ~CoordinateMapper() = default;
 
  // Configuration
  void SetConfig(const CoordinateMapperConfig& config) { config_ = config; }
  const CoordinateMapperConfig& GetConfig() const { return config_; }
 
  void SetGeometry(const CanvasGeometry& geometry) { geometry_ = geometry; }
  const CanvasGeometry& GetGeometry() const { return geometry_; }
 
  void SetScale(float scale) { scale_ = scale; }
  float GetScale() const { return scale_; }
 
  void SetCanvasId(const std::string& id) { canvas_id_ = id; }
  const std::string& GetCanvasId() const { return canvas_id_; }
 
  // --- Core Transformation Methods ---
 
  ScreenToTileResult ScreenToTile(float screen_x, float screen_y) const;
 
  TileHitInfo CanvasToTile(float canvas_x, float canvas_y) const;
 
  ImVec2 TileToCanvas(int tile_x, int tile_y) const;
 
  ImVec2 TileToScreen(int tile_x, int tile_y) const;
 
  int GetTileId(float canvas_x, float canvas_y) const;
 
  int GetTile16Index(float canvas_x, float canvas_y) const;
 
  // --- Bounds Checking ---
 
  bool IsInCanvasBounds(float screen_x, float screen_y) const;
 
  bool IsValidTileCoord(int tile_x, int tile_y) const;
 
  // --- ROM Offset Calculation ---
 
  uint32_t CalculateRomOffset(int tile_id, uint32_t base_offset = 0) const;
 
  using RomOffsetCalculator = std::function<uint32_t(int tile_id)>;
 
  void SetRomOffsetCalculator(RomOffsetCalculator calculator) {
    rom_offset_calculator_ = std::move(calculator);
  }
 
  // --- Local Map Calculation (for Overworld) ---
 
  int CalculateLocalMapId(float content_x, float content_y) const;
 
  // --- Batch Operations ---
 
  std::vector<ScreenToTileResult> ScreenToTileBatch(
      const std::vector<std::pair<float, float>>& positions) const;
 
 private:
  // Apply scroll offset to get content position
  ImVec2 ApplyScrollOffset(float canvas_x, float canvas_y) const;
 
  // Apply inverse scale to get unscaled position
  ImVec2 ApplyInverseScale(float x, float y) const;
 
  // Snap position to tile grid
  std::pair<int, int> SnapToTileGrid(float x, float y) const;
 
  CoordinateMapperConfig config_;
  CanvasGeometry geometry_;
  float scale_ = 1.0f;
  std::string canvas_id_;
  RomOffsetCalculator rom_offset_calculator_;
};
 
// --- Free Functions for Common Operations ---
 
TileHitInfo ScreenToTileQuick(const CanvasRuntime& runtime,
                               float screen_x, float screen_y,
                               float tile_size = 16.0f);
 
int CalculateTileIndex(float local_x, float local_y,
                       float tile_size, int tiles_per_row);
 
ImVec4 GetTileBounds(int tile_x, int tile_y, float tile_size, float scale);
 
}  // namespace gui
}  // namespace yaze
 
#endif  // YAZE_APP_GUI_CANVAS_COORDINATE_MAPPER_H