dungeon_canvas_room_render.cc

Go to the documentation of this file.

#include "dungeon_canvas_viewer.h"
 
#include <algorithm>
#include <cstdio>
 
#include "app/editor/dungeon/dungeon_canvas_transform.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) {
  if (header_visible_ || !show_header_hidden_metadata_hud_) {
    return;
  }
 
  const auto& label = zelda3::GetRoomLabel(room_id);
  char text1[160];
  snprintf(text1, sizeof(text1), "[%03X] %s", room_id, label.c_str());
 
  char text2[96] = {};
  bool show_meta = false;
  if (rooms_ && room_id >= 0 && room_id < static_cast<int>(rooms_->size())) {
    if (const auto* room = rooms_->TryEnsureRoom(room_id)) {
      if (!object_interaction_enabled_) {
        snprintf(text2, sizeof(text2), "B:%02X P:%02X L:%02X S:%02X  RO",
                 room->blockset(), room->palette(), room->layout_id(),
                 room->spriteset());
      } else {
        snprintf(text2, sizeof(text2), "B:%02X P:%02X L:%02X S:%02X",
                 room->blockset(), room->palette(), room->layout_id(),
                 room->spriteset());
      }
      show_meta = true;
    }
  } else if (!object_interaction_enabled_) {
    snprintf(text2, sizeof(text2), "Read-only");
    show_meta = true;
  }
 
  const float pad = 10.0f;
  const ImVec2 hud_pos(canvas_.zero_point().x + pad,
                       canvas_.zero_point().y + pad);
  const ImVec2 hud_size(0, 0);
 
  gui::DrawCanvasHUD("##MetadataHUD", hud_pos, hud_size, [&]() {
    ImGui::TextUnformatted(text1);
    if (show_meta) {
      ImGui::TextDisabled("%s", text2);
    }
  });
}
 
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);
      }
    }
  }
}
 
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);
 
  if (object_interaction_enabled_) {
    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);
  }
 
  HandleRoomCanvasDropTargets(room, room_id);
}
 
}  // namespace yaze::editor