canvas_interaction.cc

Go to the documentation of this file.

#include "canvas_interaction.h"
 
#include <algorithm>
#include <cmath>
 
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
namespace {
 
// Static state for rectangle selection (temporary until we have proper state
// management)
struct SelectRectState {
  ImVec2 drag_start_pos = ImVec2(-1, -1);
  bool is_dragging = false;
};
 
// Per-canvas state (keyed by canvas geometry pointer for simplicity)
// TODO(scawful): Replace with proper state management in Phase 2.5
thread_local SelectRectState g_select_rect_state;
 
}  // namespace
 
// ============================================================================
// Helper Functions
// ============================================================================
 
ImVec2 AlignToGrid(ImVec2 pos, float grid_step) {
  return ImVec2(std::floor(pos.x / grid_step) * grid_step,
                std::floor(pos.y / grid_step) * grid_step);
}
 
ImVec2 GetMouseInCanvasSpace(const CanvasGeometry& geometry) {
  const ImGuiIO& imgui_io = ImGui::GetIO();
  const ImVec2 origin(geometry.canvas_p0.x + geometry.scrolling.x,
                      geometry.canvas_p0.y + geometry.scrolling.y);
  return ImVec2(imgui_io.MousePos.x - origin.x, imgui_io.MousePos.y - origin.y);
}
 
bool IsMouseInCanvas(const CanvasGeometry& geometry) {
  const ImGuiIO& imgui_io = ImGui::GetIO();
  return imgui_io.MousePos.x >= geometry.canvas_p0.x &&
         imgui_io.MousePos.x <= geometry.canvas_p1.x &&
         imgui_io.MousePos.y >= geometry.canvas_p0.y &&
         imgui_io.MousePos.y <= geometry.canvas_p1.y;
}
 
ImVec2 CanvasToTileGrid(ImVec2 canvas_pos, float tile_size,
                        float global_scale) {
  const float scaled_size = tile_size * global_scale;
  return ImVec2(std::floor(canvas_pos.x / scaled_size),
                std::floor(canvas_pos.y / scaled_size));
}
 
// ============================================================================
// Rectangle Selection Implementation
// ============================================================================
 
RectSelectionEvent HandleRectangleSelection(const CanvasGeometry& geometry,
                                            int current_map, float tile_size,
                                            ImDrawList* draw_list,
                                            ImGuiMouseButton mouse_button) {
  RectSelectionEvent event;
  event.current_map = current_map;
 
  if (!IsMouseInCanvas(geometry)) {
    return event;
  }
 
  const ImVec2 mouse_pos = GetMouseInCanvasSpace(geometry);
  const float scaled_size =
      tile_size * geometry.scaled_size.x / geometry.canvas_sz.x;
  constexpr int kSmallMapSize = 0x200;  // 512 pixels
 
  // Calculate super X/Y accounting for world offset
  int super_y = 0;
  int super_x = 0;
  if (current_map < 0x40) {
    // Light World (0x00-0x3F)
    super_y = current_map / 8;
    super_x = current_map % 8;
  } else if (current_map < 0x80) {
    // Dark World (0x40-0x7F)
    super_y = (current_map - 0x40) / 8;
    super_x = (current_map - 0x40) % 8;
  } else {
    // Special World (0x80+)
    super_y = (current_map - 0x80) / 8;
    super_x = (current_map - 0x80) % 8;
  }
 
  // Handle mouse button press - start selection
  if (ImGui::IsMouseClicked(mouse_button)) {
    g_select_rect_state.drag_start_pos = AlignToGrid(mouse_pos, scaled_size);
    g_select_rect_state.is_dragging = false;
 
    // Single tile selection on click
    ImVec2 painter_pos = AlignToGrid(mouse_pos, scaled_size);
    int painter_x = static_cast<int>(painter_pos.x);
    int painter_y = static_cast<int>(painter_pos.y);
 
    auto tile16_x = (painter_x % kSmallMapSize) / (kSmallMapSize / 0x20);
    auto tile16_y = (painter_y % kSmallMapSize) / (kSmallMapSize / 0x20);
 
    int index_x = super_x * 0x20 + tile16_x;
    int index_y = super_y * 0x20 + tile16_y;
 
    event.start_pos = painter_pos;
    event.selected_tiles.push_back(
        ImVec2(static_cast<float>(index_x), static_cast<float>(index_y)));
  }
 
  // Handle dragging - draw preview rectangle
  ImVec2 drag_end_pos = AlignToGrid(mouse_pos, scaled_size);
  if (ImGui::IsMouseDragging(mouse_button) && draw_list) {
    g_select_rect_state.is_dragging = true;
    event.is_active = true;
    event.start_pos = g_select_rect_state.drag_start_pos;
    event.end_pos = drag_end_pos;
 
    // Draw preview rectangle
    auto start =
        ImVec2(geometry.canvas_p0.x + g_select_rect_state.drag_start_pos.x,
               geometry.canvas_p0.y + g_select_rect_state.drag_start_pos.y);
    auto end = ImVec2(geometry.canvas_p0.x + drag_end_pos.x + tile_size,
                      geometry.canvas_p0.y + drag_end_pos.y + tile_size);
    draw_list->AddRect(start, end, IM_COL32(255, 255, 255, 255));
  }
 
  // Handle mouse release - complete selection
  if (g_select_rect_state.is_dragging && !ImGui::IsMouseDown(mouse_button)) {
    g_select_rect_state.is_dragging = false;
    event.is_complete = true;
    event.is_active = false;
    event.start_pos = g_select_rect_state.drag_start_pos;
    event.end_pos = drag_end_pos;
 
    // Calculate selected tiles
    constexpr int kTile16Size = 16;
    int start_x = static_cast<int>(std::floor(
                      g_select_rect_state.drag_start_pos.x / scaled_size)) *
                  kTile16Size;
    int start_y = static_cast<int>(std::floor(
                      g_select_rect_state.drag_start_pos.y / scaled_size)) *
                  kTile16Size;
    int end_x = static_cast<int>(std::floor(drag_end_pos.x / scaled_size)) *
                kTile16Size;
    int end_y = static_cast<int>(std::floor(drag_end_pos.y / scaled_size)) *
                kTile16Size;
 
    if (start_x > end_x)
      std::swap(start_x, end_x);
    if (start_y > end_y)
      std::swap(start_y, end_y);
 
    constexpr int kTilesPerLocalMap = kSmallMapSize / 16;
 
    for (int tile_y = start_y; tile_y <= end_y; tile_y += kTile16Size) {
      for (int tile_x = start_x; tile_x <= end_x; tile_x += kTile16Size) {
        int local_map_x = tile_x / kSmallMapSize;
        int local_map_y = tile_y / kSmallMapSize;
 
        int tile16_x = (tile_x % kSmallMapSize) / kTile16Size;
        int tile16_y = (tile_y % kSmallMapSize) / kTile16Size;
 
        int index_x = local_map_x * kTilesPerLocalMap + tile16_x;
        int index_y = local_map_y * kTilesPerLocalMap + tile16_y;
 
        event.selected_tiles.emplace_back(static_cast<float>(index_x),
                                          static_cast<float>(index_y));
      }
    }
  }
 
  return event;
}
 
TileSelectionEvent HandleTileSelection(const CanvasGeometry& geometry,
                                       int current_map, float tile_size,
                                       ImGuiMouseButton mouse_button) {
  TileSelectionEvent event;
 
  if (!IsMouseInCanvas(geometry) || !ImGui::IsMouseClicked(mouse_button)) {
    return event;
  }
 
  const ImVec2 mouse_pos = GetMouseInCanvasSpace(geometry);
  const float scaled_size =
      tile_size * geometry.scaled_size.x / geometry.canvas_sz.x;
  constexpr int kSmallMapSize = 0x200;
 
  // Calculate super X/Y
  int super_y = 0;
  int super_x = 0;
  if (current_map < 0x40) {
    super_y = current_map / 8;
    super_x = current_map % 8;
  } else if (current_map < 0x80) {
    super_y = (current_map - 0x40) / 8;
    super_x = (current_map - 0x40) % 8;
  } else {
    super_y = (current_map - 0x80) / 8;
    super_x = (current_map - 0x80) % 8;
  }
 
  ImVec2 painter_pos = AlignToGrid(mouse_pos, scaled_size);
  int painter_x = static_cast<int>(painter_pos.x);
  int painter_y = static_cast<int>(painter_pos.y);
 
  auto tile16_x = (painter_x % kSmallMapSize) / (kSmallMapSize / 0x20);
  auto tile16_y = (painter_y % kSmallMapSize) / (kSmallMapSize / 0x20);
 
  int index_x = super_x * 0x20 + tile16_x;
  int index_y = super_y * 0x20 + tile16_y;
 
  event.tile_position =
      ImVec2(static_cast<float>(index_x), static_cast<float>(index_y));
  event.is_valid = true;
 
  return event;
}
 
// ============================================================================
// Tile Painting Implementation
// ============================================================================
 
TilePaintEvent HandleTilePaint(const CanvasGeometry& geometry, int tile_id,
                               float tile_size, ImGuiMouseButton mouse_button) {
  TilePaintEvent event;
  event.tile_id = tile_id;
 
  if (!IsMouseInCanvas(geometry)) {
    return event;
  }
 
  const ImVec2 mouse_pos = GetMouseInCanvasSpace(geometry);
  const float scaled_size =
      tile_size * geometry.scaled_size.x / geometry.canvas_sz.x;
 
  ImVec2 paint_pos = AlignToGrid(mouse_pos, scaled_size);
  event.position = mouse_pos;
  event.grid_position = paint_pos;
 
  // Check for paint action
  if (ImGui::IsMouseClicked(mouse_button)) {
    event.is_complete = true;
    event.is_drag = false;
  } else if (ImGui::IsMouseDragging(mouse_button)) {
    event.is_complete = true;
    event.is_drag = true;
  }
 
  return event;
}
 
TilePaintEvent HandleTilePaintWithPreview(const CanvasGeometry& geometry,
                                          const gfx::Bitmap& bitmap,
                                          float tile_size,
                                          ImDrawList* draw_list,
                                          ImGuiMouseButton mouse_button) {
  TilePaintEvent event;
 
  if (!IsMouseInCanvas(geometry)) {
    return event;
  }
 
  const ImVec2 mouse_pos = GetMouseInCanvasSpace(geometry);
  const float scaled_size =
      tile_size * geometry.scaled_size.x / geometry.canvas_sz.x;
 
  // Calculate grid-aligned paint position
  ImVec2 paint_pos = AlignToGrid(mouse_pos, scaled_size);
  event.position = mouse_pos;
  event.grid_position = paint_pos;
 
  auto paint_pos_end =
      ImVec2(paint_pos.x + scaled_size, paint_pos.y + scaled_size);
 
  // Draw preview of tile at hover position
  if (bitmap.is_active() && draw_list) {
    const ImVec2 origin(geometry.canvas_p0.x + geometry.scrolling.x,
                        geometry.canvas_p0.y + geometry.scrolling.y);
    draw_list->AddImage(
        reinterpret_cast<ImTextureID>(bitmap.texture()),
        ImVec2(origin.x + paint_pos.x, origin.y + paint_pos.y),
        ImVec2(origin.x + paint_pos_end.x, origin.y + paint_pos_end.y));
  }
 
  // Check for paint action
  if (ImGui::IsMouseClicked(mouse_button) &&
      ImGui::IsMouseDragging(mouse_button)) {
    event.is_complete = true;
    event.is_drag = true;
  }
 
  return event;
}
 
TilePaintEvent HandleTilemapPaint(const CanvasGeometry& geometry,
                                  const gfx::Tilemap& tilemap, int current_tile,
                                  ImDrawList* draw_list,
                                  ImGuiMouseButton mouse_button) {
  TilePaintEvent event;
  event.tile_id = current_tile;
 
  if (!IsMouseInCanvas(geometry)) {
    return event;
  }
 
  const ImVec2 mouse_pos = GetMouseInCanvasSpace(geometry);
  const float scaled_size =
      16.0f * geometry.scaled_size.x / geometry.canvas_sz.x;
 
  ImVec2 paint_pos = AlignToGrid(mouse_pos, scaled_size);
  event.position = mouse_pos;
  event.grid_position = paint_pos;
 
  // Draw preview if tilemap has texture
  if (tilemap.atlas.is_active() && draw_list) {
    const ImVec2 origin(geometry.canvas_p0.x + geometry.scrolling.x,
                        geometry.canvas_p0.y + geometry.scrolling.y);
    // TODO(scawful): Render tilemap preview
    (void)origin;  // Suppress unused warning
  }
 
  // Check for paint action
  if (ImGui::IsMouseDown(mouse_button)) {
    event.is_complete = true;
    event.is_drag = ImGui::IsMouseDragging(mouse_button);
  }
 
  return event;
}
 
// ============================================================================
// Hover and Preview Implementation
// ============================================================================
 
HoverEvent HandleHover(const CanvasGeometry& geometry, float tile_size) {
  HoverEvent event;
 
  if (!IsMouseInCanvas(geometry)) {
    return event;
  }
 
  const ImVec2 mouse_pos = GetMouseInCanvasSpace(geometry);
  const float scaled_size =
      tile_size * geometry.scaled_size.x / geometry.canvas_sz.x;
 
  event.position = mouse_pos;
  event.grid_position = AlignToGrid(mouse_pos, scaled_size);
  event.is_valid = true;
 
  return event;
}
 
void RenderHoverPreview(const CanvasGeometry& geometry, const HoverEvent& hover,
                        float tile_size, ImDrawList* draw_list, ImU32 color) {
  if (!hover.is_valid || !draw_list) {
    return;
  }
 
  const float scaled_size =
      tile_size * geometry.scaled_size.x / geometry.canvas_sz.x;
  const ImVec2 origin(geometry.canvas_p0.x + geometry.scrolling.x,
                      geometry.canvas_p0.y + geometry.scrolling.y);
 
  ImVec2 preview_start = ImVec2(origin.x + hover.grid_position.x,
                                origin.y + hover.grid_position.y);
  ImVec2 preview_end =
      ImVec2(preview_start.x + scaled_size, preview_start.y + scaled_size);
 
  draw_list->AddRectFilled(preview_start, preview_end, color);
}
 
// ============================================================================
// Entity Interaction Implementation (Stub for Phase 2.4)
// ============================================================================
 
EntityInteractionEvent HandleEntityInteraction(const CanvasGeometry& geometry,
                                               int entity_id,
                                               ImVec2 entity_position) {
  EntityInteractionEvent event;
  event.entity_id = entity_id;
  event.position = entity_position;
 
  if (!IsMouseInCanvas(geometry)) {
    return event;
  }
 
  // TODO(scawful): Implement entity interaction logic in Phase 2.4
  // For now, just return empty event
 
  return event;
}
 
}  // namespace gui
}  // namespace yaze