dungeon_canvas_room_render.cc

Go to the documentation of this file.

#include "app/editor/dungeon/ui/window/minecart_track_editor_panel.h"
#include "dungeon_canvas_viewer.h"
 
#include <algorithm>
#include <cstdio>
 
#include "absl/strings/str_format.h"
#include "app/editor/dungeon/dungeon_canvas_transform.h"
#include "app/editor/dungeon/dungeon_project_labels.h"
#include "app/gfx/resource/arena.h"
#include "app/gui/core/agent_theme.h"
#include "app/gui/core/drag_drop.h"
#include "app/gui/widgets/themed_widgets.h"
#include "imgui/imgui.h"
 
namespace yaze::editor {
 
namespace {
 
ImVec4 WithAlpha(ImVec4 color, float alpha) {
  color.w = alpha;
  return color;
}
 
void DrawRoomRenderFallback(const gui::CanvasRuntime& canvas_rt) {
  if (!canvas_rt.draw_list) {
    return;
  }
 
  const auto& theme = AgentUI::GetTheme();
  const float scale = std::max(canvas_rt.scale, 0.01f);
  const ImVec2 room_min(canvas_rt.canvas_p0.x + canvas_rt.scrolling.x,
                        canvas_rt.canvas_p0.y + canvas_rt.scrolling.y);
  const ImVec2 room_max(room_min.x + (512.0f * scale),
                        room_min.y + (512.0f * scale));
  const ImVec2 canvas_max(canvas_rt.canvas_p0.x + canvas_rt.canvas_sz.x,
                          canvas_rt.canvas_p0.y + canvas_rt.canvas_sz.y);
 
  canvas_rt.draw_list->PushClipRect(canvas_rt.canvas_p0, canvas_max, true);
  canvas_rt.draw_list->AddRectFilled(
      room_min, room_max,
      ImGui::GetColorU32(WithAlpha(theme.editor_background, 0.92f)));
  canvas_rt.draw_list->AddRect(room_min, room_max,
                               ImGui::GetColorU32(theme.panel_border_color),
                               0.0f, 0, 1.5f);
  canvas_rt.draw_list->AddText(ImVec2(room_min.x + 12.0f, room_min.y + 12.0f),
                               ImGui::GetColorU32(theme.text_secondary_gray),
                               "Room image pending");
  canvas_rt.draw_list->PopClipRect();
}
 
}  // namespace
 
void DungeonCanvasViewer::SyncCanvasCaptureRegion(
    const gui::CanvasRuntime& canvas_rt) {
  has_canvas_capture_region_ =
      canvas_rt.canvas_sz.x > 1.0f && canvas_rt.canvas_sz.y > 1.0f;
  if (!has_canvas_capture_region_) {
    return;
  }
 
  canvas_capture_x_ = static_cast<int>(canvas_rt.canvas_p0.x);
  canvas_capture_y_ = static_cast<int>(canvas_rt.canvas_p0.y);
  canvas_capture_width_ = static_cast<int>(canvas_rt.canvas_sz.x);
  canvas_capture_height_ = static_cast<int>(canvas_rt.canvas_sz.y);
}
 
void DungeonCanvasViewer::ConsumePendingCanvasScroll(
    const gui::CanvasRuntime& canvas_rt) {
  if (!pending_scroll_target_.has_value()) {
    return;
  }
 
  constexpr int kRoomPixelWidth = 512;
  constexpr int kRoomPixelHeight = 512;
  constexpr int kDungeonTileSize = 8;
 
  const auto [target_x, target_y] = pending_scroll_target_.value();
  float scale = canvas_.global_scale();
  if (scale <= 0.0f) {
    scale = 1.0f;
  }
 
  const float pixel_x = static_cast<float>(target_x * kDungeonTileSize) * scale;
  const float pixel_y = static_cast<float>(target_y * kDungeonTileSize) * scale;
  const ImVec2 view_size = canvas_rt.canvas_sz;
  const ImVec2 content_size(static_cast<float>(kRoomPixelWidth) * scale,
                            static_cast<float>(kRoomPixelHeight) * scale);
 
  const ImVec2 desired_scroll((view_size.x * 0.5f) - pixel_x,
                              (view_size.y * 0.5f) - pixel_y);
  canvas_.set_scrolling(
      gui::ClampScroll(desired_scroll, content_size, view_size));
  pending_scroll_target_.reset();
}
 
void DungeonCanvasViewer::DrawHeaderHiddenMetadataHud(int room_id) {
  // Room tags are edited in Inspect; they must not cover canvas objects.
  if (header_visible_ || !show_header_hidden_metadata_hud_) {
    return;
  }
  const auto* room = rooms_ ? rooms_->GetIfLoaded(room_id) : nullptr;
  if (!room) {
    return;
  }
 
  const auto label = dungeon_project_labels::GetRoomLabel(project_, room_id);
  char text1[160];
  snprintf(text1, sizeof(text1), "[%03X] %s", room_id, label.c_str());
 
  const auto metadata =
      absl::StrFormat("B:%02X P:%02X L:%02X S:%02X%s", room->blockset(),
                      room->palette(), room->layout_id(), room->spriteset(),
                      object_interaction_enabled_ ? "" : " RO");
  const float pad = 10.0f;
  const ImVec2 hud_pos(canvas_.zero_point().x + pad,
                       canvas_.zero_point().y + pad);
  const float content_width = std::max(ImGui::CalcTextSize(text1).x,
                                       ImGui::CalcTextSize(metadata.c_str()).x);
  const float width = std::min(
      {560.0f, canvas_.canvas_size().x - pad * 2, content_width + 16.0f});
  if (width <= 16.0f) {
    return;
  }
  const ImVec2 hud_size(width, 0);
  // A window ID must distinguish the editable and comparison viewers.
  const auto hud_id = absl::StrFormat("##MetadataHUD_%p", this);
 
  gui::DrawCanvasHUD(hud_id.c_str(), hud_pos, hud_size, [&]() {
    ImGui::TextWrapped("%s", text1);
    ImGui::PushTextWrapPos(0);
    ImGui::TextDisabled("%s", metadata.c_str());
    ImGui::PopTextWrapPos();
  });
}
 
void DungeonCanvasViewer::PrepareRoomStateForCanvas(zelda3::Room& room,
                                                    int room_id) {
  object_interaction_.SetCurrentRoom(rooms_, room_id);
 
  if (!room.AreObjectsLoaded()) {
    room.LoadObjects();
  }
 
  if (!room.AreSpritesLoaded()) {
    room.LoadSprites();
  }
 
  if (!room.ArePotItemsLoaded()) {
    room.LoadPotItems();
  }
 
  // Existing room buffers can still be stale after palette, object, or layout
  // edits. Let Room's dirty-state-aware preparation decide whether the cached
  // graphics need to be rebuilt instead of treating an allocated BG1 surface
  // as proof that the room is current.
  room.PrepareForRender(current_entrance_blockset_);
 
  if (rom_ && rom_->is_loaded()) {
    gfx::Arena::Get().ProcessTextureQueue(renderer_);
  }
}
 
void DungeonCanvasViewer::HandleRoomCanvasDropTargets(zelda3::Room& room,
                                                      int room_id) {
  gui::RoomObjectDragPayload obj_drop;
  if (gui::AcceptRoomObjectDrop(&obj_drop)) {
    const DungeonCanvasTransform transform(
        canvas_.zero_point(), canvas_.scrolling(), canvas_.global_scale());
    auto [tile_x, tile_y] = transform.ScreenToRoomTiles(
        ImGui::GetMousePos(), dungeon_coords::kTileSize);
    if (tile_x >= 0 && tile_x < 64 && tile_y >= 0 && tile_y < 64) {
      const uint8_t object_size = obj_drop.size;
      zelda3::RoomObject new_obj(static_cast<int16_t>(obj_drop.object_id),
                                 static_cast<uint8_t>(tile_x),
                                 static_cast<uint8_t>(tile_y), object_size, 0);
      const size_t before = room.GetTileObjects().size();
      object_interaction_.entity_coordinator().tile_handler().PlaceObjectAt(
          room_id, new_obj, tile_x, tile_y);
      if (room.GetTileObjects().size() > before) {
        object_interaction_.SetSelectedObjects({before});
      }
    }
  }
 
  gui::SpriteDragPayload sprite_drop;
  if (gui::AcceptSpriteDrop(&sprite_drop)) {
    const DungeonCanvasTransform transform(
        canvas_.zero_point(), canvas_.scrolling(), canvas_.global_scale());
    const auto [room_x, room_y] =
        transform.ScreenToRoomPixelCoordinates(ImGui::GetMousePos());
    if (dungeon_coords::IsWithinBounds(room_x, room_y)) {
      const int sprite_x = room_x / dungeon_coords::kSpriteTileSize;
      const int sprite_y = room_y / dungeon_coords::kSpriteTileSize;
      zelda3::Sprite new_sprite(static_cast<uint8_t>(sprite_drop.sprite_id),
                                static_cast<uint8_t>(sprite_x),
                                static_cast<uint8_t>(sprite_y), 0, 0);
      if (auto* ctx = object_interaction_.entity_coordinator()
                          .sprite_handler()
                          .context()) {
        ctx->NotifyMutation(MutationDomain::kSprites);
      }
      room.GetSprites().push_back(new_sprite);
      room.MarkSpritesDirty();
      if (auto* ctx = object_interaction_.entity_coordinator()
                          .sprite_handler()
                          .context()) {
        ctx->NotifyInvalidateCache(MutationDomain::kSprites);
      }
    }
  }
}
 
bool DungeonCanvasViewer::DrawMinecartCanvas(const gui::CanvasRuntime& rt,
                                             zelda3::Room& room, int room_id) {
  if (!minecart_track_panel_) {
    minecart_canvas_tool_.Cancel();
    return false;
  }
  auto* panel = minecart_track_panel_;
  if ((panel->canvas_editing() || panel->collision_stamping()) &&
      minecart_owned_input_ && object_interaction_enabled_ &&
      !object_interaction_.mode_manager().IsSelectMode()) {
    // Choosing another placement/paint tool ends cart editing immediately.
    panel->set_canvas_editing(false);
    panel->set_collision_stamping(false);
  }
  const bool owns_input =
      (panel->canvas_editing() || panel->collision_stamping()) &&
      object_interaction_enabled_;
  if (owns_input && !minecart_owned_input_) {
    object_interaction_.HandleMouseRelease();
    object_interaction_.CancelPlacement();
    object_interaction_.mode_manager().CancelCurrentMode();
    object_interaction_.ClearSelection();
    object_interaction_.entity_coordinator().ClearAllEntitySelections();
  }
  minecart_owned_input_ = owns_input;
  if (object_interaction_enabled_)
    panel->SetActiveRoom(room_id);
  if (panel->collision_stamping() && object_interaction_enabled_) {
    minecart_canvas_tool_.Cancel();
    if (room_canvas_shortcut_focus_ && ImGui::IsKeyPressed(ImGuiKey_Escape)) {
      panel->set_collision_stamping(false);
      return true;
    }
    show_custom_collision_overlay_ = true;
    minecart_collision_tool_.Draw(
        rt, room.custom_collision(), room_id, panel->collision_stamp_value(),
        panel->collision_stamp_size(), panel->collision_stamp_callback());
    return true;
  }
  const MinecartCanvasBinding binding{
      .tracks = panel->GetTracks(),
      .selected = panel->selected_track(),
      .picking = panel->GetPickingTrackIndex(),
      .revision = panel->canvas_revision(),
      .enabled = panel->canvas_editing(),
      .select = [panel](int id) { panel->SelectTrack(id); },
      .move =
          [panel](const MinecartTrack& before, const MinecartTrack& after) {
            return panel->MoveCartStart(before, after);
          },
      .cancel_pick = [panel]() { panel->CancelPick(); }};
  return minecart_canvas_tool_.Draw(rt, room, room_id,
                                    object_interaction_enabled_,
                                    room_canvas_shortcut_focus_, binding);
}
 
bool DungeonCanvasViewer::DrawCrumbleCanvas(const gui::CanvasRuntime& rt) {
  if (!object_interaction_.mode_manager().IsSelectMode() ||
      (minecart_track_panel_ &&
       (minecart_track_panel_->canvas_editing() ||
        minecart_track_panel_->collision_stamping()))) {
    crumble_floor_view_.Stop();
  }
  return show_crumble_floor_ &&
         crumble_floor_view_.DrawCanvas(rt, object_interaction_enabled_,
                                        room_canvas_shortcut_focus_);
}
 
void DungeonCanvasViewer::DrawRoomCanvasContent(
    const gui::CanvasRuntime& canvas_rt, zelda3::Room& room, int room_id) {
  PrepareRoomStateForCanvas(room, room_id);
 
  const bool drew_background = DrawRoomBackgroundLayers(room_id);
  if (!drew_background) {
    DrawRoomRenderFallback(canvas_rt);
  }
 
  if (object_interaction_.IsMaskModeActive()) {
    DrawMaskHighlights(canvas_rt, room);
  }
 
  RenderEntityOverlay(canvas_rt, room);
 
  const bool crumble_owns_input = DrawCrumbleCanvas(canvas_rt);
  const bool tool_owns_input =
      crumble_owns_input || DrawMinecartCanvas(canvas_rt, room, room_id);
  if (object_interaction_enabled_ && !tool_owns_input) {
    object_interaction_.HandleCanvasMouseInput();
    object_interaction_.CheckForObjectSelection();
    object_interaction_.DrawSelectionHighlights();
    object_interaction_.DrawEntitySelectionHighlights();
    object_interaction_.DrawGhostPreview();
 
    const auto selected = object_interaction_.GetSelectedObjectIndices();
    if (selected.size() == 1) {
      const auto& objects = room.GetTileObjects();
      const size_t idx = selected.front();
      if (idx < objects.size()) {
        const auto& obj = objects[idx];
        gui::BeginRoomObjectDragSource(static_cast<uint16_t>(obj.id_), room_id,
                                       obj.x_, obj.y_, obj.size_);
      }
    }
 
    if (object_interaction_.HasEntitySelection()) {
      const auto sel = object_interaction_.GetSelectedEntity();
      if (sel.type == EntityType::Sprite) {
        const auto& sprites = room.GetSprites();
        if (sel.index < sprites.size()) {
          const auto& sprite = sprites[sel.index];
          gui::BeginSpriteDragSource(sprite.id(), room_id);
        }
      }
    }
 
    HandleTouchLongPressContextMenu(canvas_rt, room);
  }
 
  if (object_interaction_enabled_ && !tool_owns_input) {
    HandleRoomCanvasDropTargets(room, room_id);
  }
}
 
}  // namespace yaze::editor