dungeon_canvas_viewer.cc

Go to the documentation of this file.

#include "dungeon_canvas_viewer.h"
#include "app/editor/dungeon/ui/window/minecart_track_editor_panel.h"
 
#include <algorithm>
#include <vector>
 
#include "app/editor/dungeon/dungeon_connection_edit.h"
#include "app/gui/core/agent_theme.h"
#include "zelda3/dungeon/dimension_service.h"
 
namespace yaze::editor {
 
namespace {
 
constexpr double kChangePingDurationSeconds = 0.85;
constexpr int kDungeonCanvasPixelSize = 512;
constexpr size_t kRecentRoomLimit = 5;
 
bool HasSameObjectIdentity(const zelda3::RoomObject& lhs,
                           const zelda3::RoomObject& rhs) {
  return lhs.id_ == rhs.id_ && lhs.x() == rhs.x() && lhs.y() == rhs.y() &&
         lhs.size() == rhs.size() && lhs.GetLayerValue() == rhs.GetLayerValue();
}
 
}  // namespace
 
DungeonCanvasViewer::~DungeonCanvasViewer() = default;
 
void DungeonCanvasViewer::CancelMinecartNodeDrag() {
  if (minecart_track_panel_)
    minecart_track_panel_->CancelNodeDrag(this);
}
 
absl::StatusOr<std::string> DungeonCanvasViewer::ExportRoomDocument(
    int room_id) {
  if (!room_document_export_callback_ || !rooms_ || room_id < 0 ||
      room_id >= static_cast<int>(rooms_->size())) {
    return absl::FailedPreconditionError("Room export is unavailable");
  }
  return room_document_export_callback_(room_id);
}
 
absl::StatusOr<DungeonRoomTransferPlan>
DungeonCanvasViewer::PreviewRoomTransfer(
    int source_room_id, const std::string& json,
    const DungeonRoomTransferOptions& options) {
  const auto* context =
      object_interaction_.entity_coordinator().tile_handler().context();
  if (header_read_only_ || !room_transfer_preview_callback_ || !context ||
      context->current_room_id != current_room_id_) {
    return absl::FailedPreconditionError(
        "Room replacement is not editable in this view");
  }
  return room_transfer_preview_callback_(current_room_id_, source_room_id, json,
                                         options);
}
 
absl::Status DungeonCanvasViewer::ApplyRoomTransfer(
    const DungeonRoomTransferPlan& plan) {
  const auto* context =
      object_interaction_.entity_coordinator().tile_handler().context();
  if (header_read_only_ || !room_transfer_apply_callback_ || !context ||
      context->current_room_id != current_room_id_ ||
      plan.target_room_id != current_room_id_) {
    return absl::FailedPreconditionError(
        "Room replacement is not editable in this view");
  }
  return room_transfer_apply_callback_(plan);
}
 
absl::StatusOr<DungeonConnectionPlan>
DungeonCanvasViewer::PreviewDoorConnection(
    const DungeonConnectionRequest& request) {
  const auto* context =
      object_interaction_.entity_coordinator().tile_handler().context();
  if (!door_connection_preview_callback_ || !context ||
      request.source_room_id != current_room_id_ ||
      context->current_room_id != current_room_id_) {
    return absl::FailedPreconditionError(
        "Open this room in the canvas to preview its connection");
  }
  return door_connection_preview_callback_(request);
}
 
absl::Status DungeonCanvasViewer::ApplyDoorConnection(
    const DungeonConnectionPlan& plan) {
  const auto* context =
      object_interaction_.entity_coordinator().tile_handler().context();
  if (header_read_only_ || !door_connection_apply_callback_ || !context ||
      plan.request.source_room_id != current_room_id_ ||
      context->current_room_id != current_room_id_) {
    return absl::FailedPreconditionError(
        "Door connections are not editable in this view");
  }
  return door_connection_apply_callback_(plan);
}
 
absl::Status DungeonCanvasViewer::EditRoomMetadata(
    int room_id, const RoomMetadataEdit& edit) {
  if (header_read_only_ || !metadata_edit_callback_ || !rooms_ ||
      !rooms_->GetIfLoaded(room_id)) {
    return absl::FailedPreconditionError("Room properties are not editable");
  }
  return metadata_edit_callback_(room_id, edit);
}
 
absl::Status DungeonCanvasViewer::EditRoomMetadataBatch(
    const std::vector<RoomMetadataRequest>& requests) {
  if (header_read_only_ || !metadata_batch_edit_callback_ || !rooms_) {
    return absl::FailedPreconditionError("Room properties are not editable");
  }
  for (const auto& request : requests) {
    if (!rooms_->GetIfLoaded(request.room_id)) {
      return absl::FailedPreconditionError("Room properties are not loaded");
    }
  }
  return metadata_batch_edit_callback_(requests);
}
 
absl::Status DungeonCanvasViewer::EditChest(int room_id, size_t index,
                                            uint8_t item_id, bool big_chest) {
  if (header_read_only_ || !chest_edit_callback_ || !rooms_ ||
      !rooms_->GetIfLoaded(room_id)) {
    return absl::FailedPreconditionError("Chest contents are not editable");
  }
  return chest_edit_callback_(room_id, index, item_id, big_chest);
}
 
absl::Status DungeonCanvasViewer::DeleteChest(int room_id, size_t index) {
  if (header_read_only_ || !chest_delete_callback_ || !rooms_ ||
      !rooms_->GetIfLoaded(room_id)) {
    return absl::FailedPreconditionError("Chests are not editable");
  }
  return chest_delete_callback_(room_id, index);
}
 
void DungeonCanvasViewer::RecordVisitedRoom(int room_id) {
  if (room_id < 0 || room_id >= zelda3::kNumberOfRooms) {
    return;
  }
 
  recently_visited_rooms_.erase(
      std::remove(recently_visited_rooms_.begin(),
                  recently_visited_rooms_.end(), room_id),
      recently_visited_rooms_.end());
  recently_visited_rooms_.insert(recently_visited_rooms_.begin(), room_id);
  if (recently_visited_rooms_.size() > kRecentRoomLimit) {
    recently_visited_rooms_.resize(kRecentRoomLimit);
  }
}
 
void DungeonCanvasViewer::SetProject(const project::YazeProject* project) {
  if (project_ != project) {
    crumble_floor_view_.Reset();
    InvalidateExternalSpriteResources();
  }
  project_ = project;
  ApplyTrackCollisionConfig();
}
 
void DungeonCanvasViewer::InvalidateExternalSpriteResources() {
  sprite_preview_resources_.SetContext({}, {}, {});
  sprite_preview_cache_.Clear();
  item_preview_cache_.Clear();
}
 
zelda3::RoomLayerManager& DungeonCanvasViewer::GetRoomLayerManager(
    int room_id) {
  auto& state = room_layer_managers_[room_id];
  const auto* room = rooms_ ? rooms_->GetIfMaterialized(room_id) : nullptr;
  // Initialize before controls can edit the manager. Reapply room defaults only
  // when the header changes, not on every draw, so manual blend choices persist.
  if (room && (!state.room_settings ||
               state.room_settings->first != room->layer_merging() ||
               state.room_settings->second != room->effect())) {
    state.manager.ApplyLayerMerging(room->layer_merging());
    state.manager.ApplyRoomEffect(room->effect());
    state.room_settings = std::make_pair(room->layer_merging(), room->effect());
  }
  if (room) {
    // Objects and tag2 can change the game's layer registers without changing
    // the merge mode or effect. Refresh only this derived state so manual
    // visibility and blend settings survive object edits.
    state.manager.ApplyGameLayerRegisters(room->GameLayerRegisters());
  }
  return state.manager;
}
 
void DungeonCanvasViewer::TriggerChangePing() {
  change_ping_rects_.clear();
  change_ping_start_time_ = ImGui::GetCurrentContext() ? ImGui::GetTime() : 0.0;
}
 
void DungeonCanvasViewer::TriggerCanvasPingRect(int pixel_x, int pixel_y,
                                                int pixel_w, int pixel_h) {
  change_ping_rects_.clear();
  const int x = std::clamp(pixel_x, 0, kDungeonCanvasPixelSize - 1);
  const int y = std::clamp(pixel_y, 0, kDungeonCanvasPixelSize - 1);
  const int w =
      std::clamp(pixel_w, 1, std::max(1, kDungeonCanvasPixelSize - x));
  const int h =
      std::clamp(pixel_h, 1, std::max(1, kDungeonCanvasPixelSize - y));
  change_ping_rects_.push_back(ChangePingRect{x, y, w, h});
  change_ping_start_time_ = ImGui::GetCurrentContext() ? ImGui::GetTime() : 0.0;
}
 
void DungeonCanvasViewer::TriggerObjectChangePing(
    const std::vector<zelda3::RoomObject>& previous_objects,
    const std::vector<zelda3::RoomObject>& next_objects) {
  change_ping_rects_.clear();
 
  auto append_object_rect = [this](const zelda3::RoomObject& object) {
    const auto [x, y, w, h] =
        zelda3::DimensionService::Get().GetSelectionBoundsPixels(object);
    change_ping_rects_.push_back(
        ChangePingRect{x, y, std::max(w, 8), std::max(h, 8)});
  };
 
  const size_t count = std::max(previous_objects.size(), next_objects.size());
  for (size_t i = 0; i < count; ++i) {
    const bool has_previous = i < previous_objects.size();
    const bool has_next = i < next_objects.size();
    if (has_previous && has_next &&
        HasSameObjectIdentity(previous_objects[i], next_objects[i])) {
      continue;
    }
    if (has_previous) {
      append_object_rect(previous_objects[i]);
    }
    if (has_next) {
      append_object_rect(next_objects[i]);
    }
  }
 
  if (change_ping_rects_.empty()) {
    change_ping_start_time_ = -1.0;
    return;
  }
 
  change_ping_start_time_ = ImGui::GetCurrentContext() ? ImGui::GetTime() : 0.0;
}
 
void DungeonCanvasViewer::ApplyTrackCollisionConfig() {
  auto apply_list = [](std::array<bool, 256>& dest,
                       const std::vector<uint16_t>& values) {
    dest.fill(false);
    for (uint16_t value : values) {
      if (value < 256) {
        dest[value] = true;
      }
    }
  };
  auto ids_valid = [](const std::vector<uint16_t>& values) {
    std::array<bool, 256> seen{};
    for (uint16_t value : values) {
      if (value >= seen.size() || seen[value]) {
        return false;
      }
      seen[value] = true;
    }
    return true;
  };
 
  std::vector<uint16_t> default_track_tile_list;
  for (uint16_t tile = 0xB0; tile <= 0xBE; ++tile) {
    default_track_tile_list.push_back(tile);
  }
  const std::vector<uint16_t> default_stop_tile_list = {0xB7, 0xB8, 0xB9, 0xBA};
  const std::vector<uint16_t> default_switch_tile_list = {0xD0, 0xD1, 0xD2,
                                                          0xD3};
 
  const auto& track_tiles =
      (project_ && !project_->dungeon_overlay.track_tiles.empty())
          ? project_->dungeon_overlay.track_tiles
          : default_track_tile_list;
  apply_list(track_collision_config_.track_tiles, track_tiles);
  track_tile_order_ = track_tiles;
 
  const auto& stop_tiles =
      (project_ && !project_->dungeon_overlay.track_stop_tiles.empty())
          ? project_->dungeon_overlay.track_stop_tiles
          : default_stop_tile_list;
  apply_list(track_collision_config_.stop_tiles, stop_tiles);
 
  const auto& switch_tiles =
      (project_ && !project_->dungeon_overlay.track_switch_tiles.empty())
          ? project_->dungeon_overlay.track_switch_tiles
          : default_switch_tile_list;
  apply_list(track_collision_config_.switch_tiles, switch_tiles);
  switch_tile_order_ = switch_tiles;
 
  track_direction_map_enabled_ =
      (track_tile_order_.size() == default_track_tile_list.size()) &&
      (switch_tile_order_.size() == default_switch_tile_list.size()) &&
      ids_valid(track_tile_order_) && ids_valid(switch_tile_order_);
 
  minecart_sprite_ids_.reset();
  std::vector<uint16_t> minecart_ids = {0xA3};
  if (project_ && !project_->dungeon_overlay.minecart_sprite_ids.empty()) {
    minecart_ids = project_->dungeon_overlay.minecart_sprite_ids;
  }
  for (uint16_t id : minecart_ids) {
    if (id < minecart_sprite_ids_.size()) {
      minecart_sprite_ids_[id] = true;
    }
  }
 
  collision_overlay_cache_.clear();
}
 
void DungeonCanvasViewer::Draw(int room_id) {
  DrawDungeonCanvas(room_id);
}
 
void DungeonCanvasViewer::RefreshRomBackedState(Rom* rom,
                                                zelda3::GameData* game_data,
                                                DungeonRoomStore* rooms,
                                                int room_id) {
  if (minecart_track_panel_)
    minecart_track_panel_->CancelNodePlacement();
  // Refresh can replace Room values in place while all backing pointers stay
  // identical. Discard presentation stamps before those replacements occur.
  CancelMinecartGesture();
  ResetRoomCompositeOutputs();
  connection_editor_state_ = {};
  room_transfer_state_ = {};
  chest_editor_state_ = {};
  chest_edit_dialog_state_ = {};
  InvalidateExternalSpriteResources();
  ClearPreviewObject();
  object_interaction_.CancelPlacement();
  object_interaction_.mode_manager().CancelCurrentMode();
  object_interaction_.ClearSelection();
  object_interaction_.entity_coordinator().ClearAllEntitySelections();
 
  SetRom(rom);
  SetGameData(game_data);
  SetRooms(rooms);
  current_room_id_ = room_id;
  object_interaction_.SetCurrentRoom(rooms, room_id);
 
  collision_overlay_cache_.clear();
  object_render_cache_.clear();
  room_layer_managers_.clear();
  last_palette_hash_ = 0;
  prev_blockset_ = -1;
  prev_palette_ = -1;
  prev_layout_ = -1;
  prev_spriteset_ = -1;
  last_connected_matrix_room_id_ = -1;
  change_ping_rects_.clear();
  change_ping_start_time_ = -1.0;
}
 
void DungeonCanvasViewer::ResetRoomCompositeOutputs() {
  primary_composite_output_.Retire();
  connected_composite_outputs_.clear();
  connected_composite_prune_frame_ = -1;
}
 
void DungeonCanvasViewer::PruneConnectedRoomCompositeOutputs() {
  if (ImGui::GetCurrentContext() == nullptr) {
    return;
  }
  const int frame = ImGui::GetFrameCount();
  if (connected_composite_prune_frame_ == frame) {
    return;
  }
  connected_composite_prune_frame_ = frame;
 
  // Keep one completed-frame grace period. This bounds the cache to the union
  // of recently visible rooms without retiring a texture still referenced by
  // another deferred ImGui draw in this frame.
  std::erase_if(connected_composite_outputs_, [frame](const auto& item) {
    return item.second.last_used_frame >= 0 &&
           item.second.last_used_frame < frame - 1;
  });
}
 
void DungeonCanvasViewer::DrawDungeonCanvas(int room_id) {
  current_room_id_ = room_id;
  if (!ValidateRoomCanvasRequest(room_id)) {
    return;
  }
  RecordVisitedRoom(room_id);
  PruneConnectedRoomCompositeOutputs();
 
  ImGui::BeginGroup();
  SyncCanvasConfigFromViewerState();
  zelda3::Room* active_room = PrepareActiveRoomForCanvasFrame(room_id);
  if (header_visible_)
    DrawCompactLayerToggles(room_id);
  if (header_visible_ && minecart_track_panel_ && object_interaction_enabled_) {
    bool tracks = minecart_track_panel_->canvas_editing();
    if (ImGui::Checkbox("Tracks##canvas_tracks", &tracks)) {
      object_interaction_.HandleMouseRelease();
      object_interaction_.CancelPlacement();
      object_interaction_.mode_manager().CancelCurrentMode();
      minecart_track_panel_->set_canvas_editing(tracks);
      if (tracks)
        crumble_floor_view_.Stop();
      CancelMinecartGesture();
    }
  }
  ImGui::EndGroup();
 
  // BeginCanvas renders context-menu callbacks before the room draw pass. Bind
  // this viewer's bitmap and palette first so issue capture cannot sample a
  // compare viewer or auxiliary preview left active by the previous frame.
  if (active_room != nullptr) {
    PrepareRoomCompositeBitmap(room_id);
  }
 
  if (show_crumble_floor_ && active_room != nullptr) {
    crumble_floor_view_.Sync(rom_, project_, *active_room);
    const bool was_rehearsing = crumble_floor_view_.rehearsing();
    crumble_floor_view_.DrawControls(object_interaction_enabled_);
    if (!was_rehearsing && crumble_floor_view_.rehearsing()) {
      object_interaction_.HandleMouseRelease();
      object_interaction_.CancelPlacement();
      object_interaction_.mode_manager().CancelCurrentMode();
      object_interaction_.ClearSelection();
      object_interaction_.entity_coordinator().ClearAllEntitySelections();
      CancelMinecartGesture();
      if (minecart_track_panel_) {
        minecart_track_panel_->set_canvas_editing(false);
        minecart_track_panel_->set_collision_stamping(false);
        minecart_track_panel_->CancelNodePlacement();
      }
    }
  }
 
  PopulateCanvasContextMenu(room_id);
 
  // Workbench, Standalone, and Compare share one fitted, centered viewport.
  // Free navigation belongs to Overview, not an ImGui bitmap scrollbar.
  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
  const bool viewport_visible = ImGui::BeginChild(
      "##DungeonRoomViewport", ImVec2(0, 0), false,
      ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
  ImGui::PopStyleVar();
  if (!viewport_visible) {
    ImGui::EndChild();
    return;
  }
  const auto frame_opts = BuildRoomCanvasFrameOptions();
  UpdateRoomCanvasViewport(*frame_opts.viewport_size);
  auto canvas_rt = gui::BeginCanvas(canvas_, frame_opts);
  const bool pointer_pressed = ImGui::IsMouseClicked(ImGuiMouseButton_Left) ||
                               ImGui::IsMouseClicked(ImGuiMouseButton_Right) ||
                               ImGui::IsMouseClicked(ImGuiMouseButton_Middle);
  UpdateRoomCanvasShortcutFocus(canvas_rt.hovered, pointer_pressed,
                                ImGui::GetFrameCount());
  SyncCanvasCaptureRegion(canvas_rt);
  ConsumePendingCanvasScroll(canvas_rt);
  object_interaction_.SetCurrentRoom(rooms_, room_id);
  HandleRoomCanvasNavigation(canvas_rt);
 
  touch_handler_.ProcessForCanvas(canvas_rt.canvas_p0, canvas_rt.canvas_sz,
                                  canvas_rt.hovered);
  touch_handler_.Update();
 
  DrawHeaderHiddenMetadataHud(room_id);
  DrawPersistentDebugWindows(room_id);
 
  if (active_room != nullptr) {
    DrawRoomCanvasContent(canvas_rt, *active_room, room_id);
    DrawRoomCanvasOverlays(canvas_rt, *active_room, room_id);
    DrawChangePingOverlay(canvas_rt, *active_room);
  }
 
  DrawCoordinateOverlayHud(room_id);
 
  gui::EndCanvas(canvas_, canvas_rt, frame_opts);
  ImGui::EndChild();
  SyncViewerStateFromCanvasConfig();
  DrawDungeonRoomTransferPopup(*this);
  DrawChestEditorPopup();
}
 
void DungeonCanvasViewer::UpdateRoomCanvasShortcutFocus(bool hovered,
                                                        bool pointer_pressed,
                                                        int frame_index) {
  room_canvas_last_draw_frame_ = frame_index;
  if (pointer_pressed) {
    room_canvas_shortcut_focus_ = hovered;
  }
}
 
bool DungeonCanvasViewer::HasRoomCanvasShortcutFocusForFrame(
    int frame_index) const {
  return object_interaction_enabled_ && !crumble_floor_view_.rehearsing() &&
         room_canvas_shortcut_focus_ &&
         room_canvas_last_draw_frame_ == frame_index;
}
 
void DungeonCanvasViewer::DrawChangePingOverlay(
    const gui::CanvasRuntime& canvas_rt, const zelda3::Room& room) {
  if (!canvas_rt.draw_list || change_ping_start_time_ < 0.0 ||
      !ImGui::GetCurrentContext()) {
    return;
  }
 
  const double elapsed = ImGui::GetTime() - change_ping_start_time_;
  if (elapsed >= kChangePingDurationSeconds) {
    change_ping_start_time_ = -1.0;
    change_ping_rects_.clear();
    return;
  }
 
  std::vector<ChangePingRect> rects = change_ping_rects_;
  if (rects.empty()) {
    const auto& objects = room.GetTileObjects();
    for (size_t index : object_interaction_.GetSelectedObjectIndices()) {
      if (index >= objects.size()) {
        continue;
      }
      const auto [x, y, w, h] =
          zelda3::DimensionService::Get().GetSelectionBoundsPixels(
              objects[index]);
      rects.push_back(ChangePingRect{x, y, std::max(w, 8), std::max(h, 8)});
    }
 
    auto selected_entities =
        object_interaction_.entity_coordinator().GetSelectedEntities();
    if (selected_entities.empty() && object_interaction_.HasEntitySelection()) {
      selected_entities.push_back(object_interaction_.GetSelectedEntity());
    }
    for (const SelectedEntity entity : selected_entities) {
      switch (entity.type) {
        case EntityType::Door: {
          const auto& doors = room.GetDoors();
          if (entity.index < doors.size()) {
            const auto [x, y, w, h] = doors[entity.index].GetEditorBounds();
            rects.push_back(
                ChangePingRect{x, y, std::max(w, 8), std::max(h, 8)});
          }
          break;
        }
        case EntityType::Sprite: {
          const auto& sprites = room.GetSprites();
          if (entity.index < sprites.size()) {
            rects.push_back(ChangePingRect{sprites[entity.index].x() * 16,
                                           sprites[entity.index].y() * 16, 16,
                                           16});
          }
          break;
        }
        case EntityType::Item: {
          const auto& pot_items = room.GetPotItems();
          if (entity.index < pot_items.size()) {
            rects.push_back(ChangePingRect{pot_items[entity.index].GetPixelX(),
                                           pot_items[entity.index].GetPixelY(),
                                           16, 16});
          }
          break;
        }
        case EntityType::Object:
        case EntityType::None:
          break;
      }
    }
  }
 
  if (rects.empty()) {
    rects.push_back(
        ChangePingRect{0, 0, kDungeonCanvasPixelSize, kDungeonCanvasPixelSize});
  }
 
  const float progress =
      static_cast<float>(elapsed / kChangePingDurationSeconds);
  const float remaining = std::clamp(1.0f - progress, 0.0f, 1.0f);
  const float expand = 4.0f + 12.0f * progress;
  const auto& theme = AgentUI::GetTheme();
  ImVec4 fill = theme.dungeon_selection_pulsing;
  fill.w = 0.18f * remaining;
  ImVec4 border = theme.dungeon_selection_primary;
  border.w = 0.95f * remaining;
  const ImU32 fill_color = ImGui::GetColorU32(fill);
  const ImU32 border_color = ImGui::GetColorU32(border);
 
  const ImVec2 viewport_min = canvas_rt.canvas_p0;
  const ImVec2 viewport_max(canvas_rt.canvas_p0.x + canvas_rt.canvas_sz.x,
                            canvas_rt.canvas_p0.y + canvas_rt.canvas_sz.y);
 
  for (const ChangePingRect& rect : rects) {
    const ImVec2 min(canvas_rt.canvas_p0.x + canvas_rt.scrolling.x +
                         static_cast<float>(rect.x) * canvas_rt.scale - expand,
                     canvas_rt.canvas_p0.y + canvas_rt.scrolling.y +
                         static_cast<float>(rect.y) * canvas_rt.scale - expand);
    const ImVec2 max(
        min.x + static_cast<float>(rect.w) * canvas_rt.scale + expand * 2.0f,
        min.y + static_cast<float>(rect.h) * canvas_rt.scale + expand * 2.0f);
 
    const bool visible = max.x >= viewport_min.x && min.x <= viewport_max.x &&
                         max.y >= viewport_min.y && min.y <= viewport_max.y;
    if (visible) {
      canvas_rt.draw_list->AddRectFilled(min, max, fill_color, 2.0f);
      canvas_rt.draw_list->AddRect(min, max, border_color, 2.0f,
                                   2.0f + 2.0f * remaining);
      continue;
    }
 
    const ImVec2 center(
        canvas_rt.canvas_p0.x + canvas_rt.scrolling.x +
            (static_cast<float>(rect.x) + static_cast<float>(rect.w) * 0.5f) *
                canvas_rt.scale,
        canvas_rt.canvas_p0.y + canvas_rt.scrolling.y +
            (static_cast<float>(rect.y) + static_cast<float>(rect.h) * 0.5f) *
                canvas_rt.scale);
    const float marker_min_x = viewport_min.x + 8.0f;
    const float marker_min_y = viewport_min.y + 8.0f;
    const float marker_max_x = std::max(marker_min_x, viewport_max.x - 8.0f);
    const float marker_max_y = std::max(marker_min_y, viewport_max.y - 8.0f);
    const ImVec2 clamped(std::clamp(center.x, marker_min_x, marker_max_x),
                         std::clamp(center.y, marker_min_y, marker_max_y));
    canvas_rt.draw_list->AddCircleFilled(clamped, 5.0f + 4.0f * remaining,
                                         fill_color);
    canvas_rt.draw_list->AddCircle(clamped, 7.0f + 6.0f * remaining,
                                   border_color, 18, 2.0f);
  }
}
 
}  // namespace yaze::editor