dungeon_canvas_overlays.cc

Go to the documentation of this file.

#include <algorithm>
#include <array>
#include <cstdint>
#include <span>
#include <string>
#include <string_view>
#include <vector>
#include "util/i18n/tr.h"
 
#include "absl/strings/str_format.h"
#include "app/editor/dungeon/dungeon_canvas_transform.h"
#include "app/editor/dungeon/dungeon_coordinates.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/resource/bitmap_texture_queue.h"
#include "app/gui/core/agent_theme.h"
#include "app/gui/core/layout_helpers.h"
#include "dungeon_canvas_viewer.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/custom_collision.h"
#include "zelda3/dungeon/dimension_service.h"
#include "zelda3/dungeon/object_layer_semantics.h"
#include "zelda3/dungeon/palette_debug.h"
#include "zelda3/resource_labels.h"
#include "zelda3/sprite/sprite.h"
#include "zelda3/sprite/sprite_oam_tables.h"
 
namespace yaze::editor {
 
namespace {
 
bool DrawSpritePreviewPixels(const gui::CanvasRuntime& rt,
                             const std::vector<uint8_t>& preview,
                             const SDL_Rect& bounds, int room_x, int room_y,
                             const std::array<SDL_Color, 256>& color_table) {
  if (!rt.draw_list || bounds.w <= 0 || bounds.h <= 0) {
    return false;
  }
  const size_t row_stride = static_cast<size_t>(bounds.w);
  if (static_cast<size_t>(bounds.h) > preview.size() / row_stride) {
    return false;
  }
 
  const float scale = std::max(rt.scale, 0.01f);
  const ImVec2 origin(rt.canvas_p0.x + rt.scrolling.x,
                      rt.canvas_p0.y + rt.scrolling.y);
  const ImVec2 canvas_max(rt.canvas_p0.x + rt.canvas_sz.x,
                          rt.canvas_p0.y + rt.canvas_sz.y);
  bool drew_any_pixel = false;
 
  rt.draw_list->PushClipRect(rt.canvas_p0, canvas_max, true);
  for (int y = 0; y < bounds.h; ++y) {
    int x = 0;
    while (x < bounds.w) {
      const uint8_t palette_index =
          preview[static_cast<size_t>(y) * row_stride + x];
      const SDL_Color& palette_color = color_table[palette_index];
      // RenderPreviewGraphics reserves index 0 for transparency. Unlike the
      // former 0xFF sentinel, index 0 cannot collide with a visible dungeon
      // sprite pixel: the preview encoder emits CGRAM indices 0x71..0xFF.
      if (palette_index == 0 || palette_color.a == 0) {
        ++x;
        continue;
      }
      const ImU32 color = IM_COL32(palette_color.r, palette_color.g,
                                   palette_color.b, palette_color.a);
 
      const int start_x = x;
      while (x < bounds.w && preview[static_cast<size_t>(y) * row_stride + x] ==
                                 palette_index) {
        ++x;
      }
 
      const ImVec2 min(origin.x + (room_x + start_x) * scale,
                       origin.y + (room_y + y) * scale);
      const ImVec2 max(origin.x + (room_x + x) * scale,
                       origin.y + (room_y + y + 1) * scale);
      rt.draw_list->AddRectFilled(min, max, color);
      drew_any_pixel = true;
    }
  }
  rt.draw_list->PopClipRect();
 
  return drew_any_pixel;
}
 
const char* GetStoredPlacementLabel(const zelda3::RoomObject& object) {
  const int layer_value = object.GetLayerValue();
  if (!zelda3::UsesRoomObjectStream(object)) {
    if (layer_value == 0) {
      return "Upper BG1";
    }
    return layer_value == 1 ? "Lower BG2" : "Invalid selector";
  }
  switch (layer_value) {
    case 0:
      return "Primary";
    case 1:
      return "BG2 overlay";
    case 2:
      return "BG1 overlay";
    default:
      return "Unknown";
  }
}
 
}  // namespace
 
void DungeonCanvasViewer::RenderSprites(const gui::CanvasRuntime& rt,
                                        const zelda3::Room& room) {
  if (!entity_visibility_.show_sprites) {
    return;
  }
 
  const auto& theme = AgentUI::GetTheme();
  const bool is_touch = gui::LayoutHelpers::IsTouchDevice();
  const int entity_size = is_touch ? 24 : 16;
  const auto sprite_colors =
      zelda3::BuildDungeonSpriteRenderPalette(room, game_data_);
  const std::string_view hack_name =
      project_ != nullptr && project_->hack_manifest.loaded()
          ? std::string_view(project_->hack_manifest.hack_name())
          : std::string_view{};
  if (sprite_preview_resources_.SetContext(
          project_ ? project_->filepath : std::string{},
          project_ ? project_->GetAbsolutePath(project_->assets_folder)
                   : std::string{},
          hack_name)) {
    sprite_preview_cache_.Clear();
  }
  const auto& room_gfx = room.get_gfx_buffer();
  const std::span<const uint8_t> room_gfx_span(room_gfx.data(),
                                               room_gfx.size());
 
  for (const auto& sprite : room.GetSprites()) {
    const int canvas_x = sprite.x() * 16;
    const int canvas_y = sprite.y() * 16;
 
    if (canvas_x >= -entity_size && canvas_y >= -entity_size &&
        canvas_x < 512 + entity_size && canvas_y < 512 + entity_size) {
      ImVec4 sprite_color = sprite.layer() == 0 ? theme.dungeon_sprite_layer0
                                                : theme.dungeon_sprite_layer1;
 
      const auto* preview_layout =
          zelda3::SpriteOamRegistry::GetPreviewOverride(sprite.id(), hack_name);
      const SpritePreviewKey preview_key{room.graphics_revision(), sprite.id(),
                                         sprite.subtype(), sprite.IsOverlord()};
      // Revision zero means the room has not assembled its graphics yet and
      // is not a reusable graphics identity.
      auto* preview = room.graphics_revision() != 0
                          ? sprite_preview_cache_.Get(preview_key)
                          : nullptr;
      CachedSpritePreview uncached_preview;
      if (preview == nullptr) {
        zelda3::Sprite preview_sprite = sprite;
        preview_sprite.RenderPreviewGraphics(
            room_gfx_span, preview_layout,
            sprite_preview_resources_.GetGraphics(preview_layout));
        CachedSpritePreview rendered{*preview_sprite.preview_graphics(),
                                     preview_sprite.preview_bounds()};
        if (room.graphics_revision() != 0) {
          preview =
              sprite_preview_cache_.Insert(preview_key, std::move(rendered));
        } else {
          uncached_preview = std::move(rendered);
          preview = &uncached_preview;
        }
      }
      const SDL_Rect preview_bounds = preview->bounds;
      const bool drew_preview = DrawSpritePreviewPixels(
          rt, preview->pixels, preview_bounds, canvas_x + preview_bounds.x,
          canvas_y + preview_bounds.y, sprite_colors);
 
      if (drew_preview) {
        gui::DrawOutline(rt, canvas_x, canvas_y, entity_size, entity_size,
                         ImGui::GetColorU32(sprite_color));
      } else {
        gui::DrawRect(rt, canvas_x, canvas_y, entity_size, entity_size,
                      sprite_color);
      }
 
      std::string full_name = preview_layout != nullptr
                                  ? preview_layout->name
                                  : zelda3::GetSpriteLabel(sprite.id());
      std::string sprite_text;
      if (full_name.length() > 12) {
        sprite_text = absl::StrFormat("%02X %s..", sprite.id(),
                                      full_name.substr(0, 8).c_str());
      } else {
        sprite_text =
            absl::StrFormat("%02X %s", sprite.id(), full_name.c_str());
      }
 
      gui::DrawText(rt, sprite_text, canvas_x, canvas_y);
    }
  }
}
 
void DungeonCanvasViewer::RenderPotItems(const gui::CanvasRuntime& rt,
                                         const zelda3::Room& room) {
  if (!entity_visibility_.show_pot_items) {
    return;
  }
 
  const auto& pot_items = room.GetPotItems();
  if (pot_items.empty()) {
    return;
  }
 
  static const char* kPotItemNames[] = {
      "Nothing",       "Green Rupee", "Rock",         "Bee",        "Health",
      "Bomb",          "Heart",       "Blue Rupee",   "Key",        "Arrow",
      "Bomb",          "Heart",       "Magic",        "Full Magic", "Cucco",
      "Green Soldier", "Bush Stal",   "Blue Soldier", "Landmine",   "Heart",
      "Fairy",         "Heart",       "Nothing",      "Hole",       "Warp",
      "Staircase",     "Bombable",    "Switch"};
  constexpr size_t kPotItemNameCount =
      sizeof(kPotItemNames) / sizeof(kPotItemNames[0]);
 
  for (const auto& pot_item : pot_items) {
    const int pixel_x = pot_item.GetPixelX();
    const int pixel_y = pot_item.GetPixelY();
    auto [canvas_x, canvas_y] =
        DungeonRenderingHelpers::RoomToCanvasCoordinates(pixel_x / 8,
                                                         pixel_y / 8);
 
    const bool is_touch = gui::LayoutHelpers::IsTouchDevice();
    const int entity_size = is_touch ? 24 : 16;
 
    if (canvas_x >= -entity_size && canvas_y >= -entity_size &&
        canvas_x < 512 + entity_size && canvas_y < 512 + entity_size) {
      const auto& theme = AgentUI::GetTheme();
      ImVec4 pot_item_color;
      if (pot_item.item == 0) {
        pot_item_color = theme.status_inactive;
        pot_item_color.w = 0.4f;
      } else {
        pot_item_color = theme.item_color;
        pot_item_color.w = 0.75f;
      }
 
      gui::DrawRect(rt, canvas_x, canvas_y, entity_size, entity_size,
                    pot_item_color);
 
      std::string item_name;
      if (pot_item.item < kPotItemNameCount) {
        item_name = kPotItemNames[pot_item.item];
      } else {
        item_name = absl::StrFormat("Unk%02X", pot_item.item);
      }
 
      std::string item_text =
          absl::StrFormat("%02X %s", pot_item.item, item_name.c_str());
      gui::DrawText(rt, item_text, canvas_x, canvas_y - 10);
    }
  }
}
 
void DungeonCanvasViewer::RenderEntityOverlay(const gui::CanvasRuntime& rt,
                                              const zelda3::Room& room) {
  RenderSprites(rt, room);
  RenderPotItems(rt, room);
}
 
void DungeonCanvasViewer::HandleTouchLongPressContextMenu(
    const gui::CanvasRuntime& rt, const zelda3::Room& room) {
  constexpr const char* kPopupId = "##TouchEntityContextMenu";
  const ImGuiIO& io = ImGui::GetIO();
  const bool touch_context_click =
      rt.hovered && io.MouseSource == ImGuiMouseSource_TouchScreen &&
      ImGui::IsMouseClicked(ImGuiMouseButton_Right);
  const bool gesture_long_press = touch_handler_.WasLongPressed();
  const bool should_open_context = gesture_long_press || touch_context_click;
 
  if (should_open_context) {
    const ImVec2 gesture_pos = gesture_long_press
                                   ? touch_handler_.GetGesturePosition()
                                   : ImGui::GetMousePos();
    const DungeonCanvasTransform transform(rt.canvas_p0, rt.scrolling,
                                           rt.scale);
    const ImVec2 room_pos = transform.ScreenToRoomPixels(gesture_pos);
    const auto [room_x, room_y] =
        transform.ScreenToRoomPixelCoordinates(gesture_pos);
    if (!dungeon_coords::IsWithinBounds(room_x, room_y)) {
      return;
    }
    const float rel_x = room_pos.x;
    const float rel_y = room_pos.y;
    const bool is_touch = gui::LayoutHelpers::IsTouchDevice();
    const int hit_size = is_touch ? 24 : 16;
 
    const auto& sprites = room.GetSprites();
    for (size_t idx = 0; idx < sprites.size(); ++idx) {
      const int sprite_px = sprites[idx].x() * 16;
      const int sprite_py = sprites[idx].y() * 16;
      if (rel_x >= sprite_px && rel_x < sprite_px + hit_size &&
          rel_y >= sprite_py && rel_y < sprite_py + hit_size) {
        object_interaction_.SelectEntity(EntityType::Sprite, idx);
        ImGui::OpenPopup(kPopupId);
        break;
      }
    }
 
    if (!ImGui::IsPopupOpen(kPopupId)) {
      const auto& pot_items = room.GetPotItems();
      for (size_t idx = 0; idx < pot_items.size(); ++idx) {
        const int item_px = pot_items[idx].GetPixelX();
        const int item_py = pot_items[idx].GetPixelY();
        if (rel_x >= item_px && rel_x < item_px + hit_size &&
            rel_y >= item_py && rel_y < item_py + hit_size) {
          object_interaction_.SelectEntity(EntityType::Item, idx);
          ImGui::OpenPopup(kPopupId);
          break;
        }
      }
    }
 
    if (!ImGui::IsPopupOpen(kPopupId)) {
      const auto object_index =
          object_interaction_.entity_coordinator()
              .tile_handler()
              .GetEntityAtPosition(static_cast<int>(rel_x),
                                   static_cast<int>(rel_y));
      if (object_index.has_value()) {
        object_interaction_.SetSelectedObjects({*object_index});
        ImGui::OpenPopup(kPopupId);
      }
    }
  }
 
  if (ImGui::BeginPopup(kPopupId)) {
    if (object_interaction_.HasEntitySelection()) {
      auto sel = object_interaction_.GetSelectedEntity();
      if (sel.type == EntityType::Sprite) {
        const auto& sprites = room.GetSprites();
        if (sel.index < sprites.size()) {
          std::string label = zelda3::GetSpriteLabel(sprites[sel.index].id());
          ImGui::TextDisabled(tr("Sprite: %02X %s"), sprites[sel.index].id(),
                              label.c_str());
          ImGui::Separator();
        }
        if (ImGui::MenuItem(tr("Delete Sprite"))) {
          object_interaction_.entity_coordinator().DeleteSelectedEntity();
        }
      } else if (sel.type == EntityType::Item) {
        ImGui::TextDisabled(tr("Pot Item"));
        ImGui::Separator();
        if (ImGui::MenuItem(tr("Delete Item"))) {
          object_interaction_.entity_coordinator().DeleteSelectedEntity();
        }
      }
    } else if (object_interaction_.GetSelectionCount() > 0) {
      const auto indices = object_interaction_.GetSelectedObjectIndices();
      if (indices.size() == 1) {
        const auto& objects = room.GetTileObjects();
        if (indices[0] < objects.size()) {
          std::string name = zelda3::GetObjectName(objects[indices[0]].id_);
          ImGui::TextDisabled(tr("Object: %03X %s"), objects[indices[0]].id_,
                              name.c_str());
          ImGui::Separator();
        }
      } else {
        ImGui::TextDisabled(tr("%zu objects selected"),
                            object_interaction_.GetSelectionCount());
        ImGui::Separator();
      }
      if (ImGui::MenuItem(tr("Delete"))) {
        object_interaction_.HandleDeleteSelected();
      }
      if (ImGui::MenuItem(tr("Copy"))) {
        object_interaction_.HandleCopySelected();
      }
      ImGui::Separator();
      if (ImGui::MenuItem(tr("Send to Front"))) {
        object_interaction_.SendSelectedToFront();
      }
      if (ImGui::MenuItem(tr("Send to Back"))) {
        object_interaction_.SendSelectedToBack();
      }
    }
    ImGui::EndPopup();
  }
}
 
void DungeonCanvasViewer::DrawObjectPositionOutlines(
    const gui::CanvasRuntime& rt, const zelda3::Room& room) {
  const auto& theme = AgentUI::GetTheme();
  const auto& objects = room.GetTileObjects();
 
  for (const auto& obj : objects) {
    bool show_this_type = true;
    if (obj.id_ < 0x100) {
      show_this_type = object_outline_toggles_.show_type1_objects;
    } else if (obj.id_ >= 0x100 && obj.id_ < 0x200) {
      show_this_type = object_outline_toggles_.show_type2_objects;
    } else if (obj.id_ >= 0xF00) {
      show_this_type = object_outline_toggles_.show_type3_objects;
    }
 
    bool show_this_layer = true;
    if (obj.GetLayerValue() == 0) {
      show_this_layer = object_outline_toggles_.show_layer0_objects;
    } else if (obj.GetLayerValue() == 1) {
      show_this_layer = object_outline_toggles_.show_layer1_objects;
    } else if (obj.GetLayerValue() == 2) {
      show_this_layer = object_outline_toggles_.show_layer2_objects;
    }
 
    if (!show_this_type || !show_this_layer) {
      continue;
    }
 
    auto [canvas_x, canvas_y, width, height] =
        zelda3::DimensionService::Get().GetSelectionBoundsPixels(obj);
    width = std::min(width, 512);
    height = std::min(height, 512);
 
    ImVec4 outline_color;
    if (obj.GetLayerValue() == 0) {
      outline_color = theme.dungeon_outline_layer0;
    } else if (obj.GetLayerValue() == 1) {
      outline_color = theme.dungeon_outline_layer1;
    } else {
      outline_color = theme.dungeon_outline_layer2;
    }
 
    gui::DrawRect(rt, canvas_x, canvas_y, width, height, outline_color);
 
    std::string name = zelda3::GetObjectName(obj.id_);
    if (name.length() > 12) {
      name = name.substr(0, 10) + "..";
    }
    std::string label;
    if (obj.id_ >= 0x100) {
      label = absl::StrFormat("0x%03X\n%s\n%s  [%dx%d]", obj.id_, name.c_str(),
                              GetStoredPlacementLabel(obj), width, height);
    } else {
      label = absl::StrFormat("0x%02X\n%s\n%s  [%dx%d]", obj.id_, name.c_str(),
                              GetStoredPlacementLabel(obj), width, height);
    }
    gui::DrawText(rt, label, canvas_x + 1, canvas_y + 1);
  }
}
 
const DungeonRenderingHelpers::CollisionOverlayCache&
DungeonCanvasViewer::GetCollisionOverlayCache(int room_id) {
  auto it = collision_overlay_cache_.find(room_id);
  if (it != collision_overlay_cache_.end()) {
    return it->second;
  }
 
  DungeonRenderingHelpers::CollisionOverlayCache cache;
  cache.entries.clear();
 
  if (!rom_ || !rom_->is_loaded()) {
    collision_overlay_cache_.emplace(room_id, cache);
    return collision_overlay_cache_.at(room_id);
  }
 
  auto map_or = zelda3::LoadCustomCollisionMap(rom_, room_id);
  if (!map_or.ok()) {
    collision_overlay_cache_.emplace(room_id, cache);
    return collision_overlay_cache_.at(room_id);
  }
 
  const auto& map = map_or.value();
  cache.has_data = map.has_data;
  if (cache.has_data && !track_collision_config_.IsEmpty()) {
    for (int y = 0; y < 64; ++y) {
      for (int x = 0; x < 64; ++x) {
        const uint8_t tile = map.tiles[static_cast<size_t>(y * 64 + x)];
        if (tile < 256 && (track_collision_config_.track_tiles[tile] ||
                           track_collision_config_.stop_tiles[tile] ||
                           track_collision_config_.switch_tiles[tile])) {
          cache.entries.push_back(
              DungeonRenderingHelpers::CollisionOverlayEntry{
                  static_cast<uint8_t>(x), static_cast<uint8_t>(y), tile});
        }
      }
    }
  }
 
  collision_overlay_cache_.emplace(room_id, std::move(cache));
  return collision_overlay_cache_.at(room_id);
}
 
gfx::Bitmap* DungeonCanvasViewer::PrepareRoomCompositeBitmap(int room_id) {
  gfx::Bitmap* composite =
      PrepareRoomCompositeWithOutput(room_id, primary_composite_output_);
  zelda3::Room* room = rooms_ ? rooms_->GetIfMaterialized(room_id) : nullptr;
  if (composite != nullptr && room != nullptr) {
    zelda3::PaletteDebugger::Get().SetCurrentPresentation(
        composite, room->rendered_dungeon_palette(), room->rendered_palette());
  }
  return composite;
}
 
gfx::Bitmap* DungeonCanvasViewer::PrepareConnectedRoomCompositeBitmap(
    int room_id) {
  auto& entry = connected_composite_outputs_[room_id];
  if (!entry.output) {
    entry.output = std::make_unique<RoomCompositeOutput>();
  }
  entry.last_used_frame =
      ImGui::GetCurrentContext() != nullptr ? ImGui::GetFrameCount() : 0;
  return PrepareRoomCompositeWithOutput(room_id, *entry.output);
}
 
gfx::Bitmap* DungeonCanvasViewer::PrepareRoomCompositeWithOutput(
    int room_id, RoomCompositeOutput& output) {
  if (room_id < 0 || room_id >= zelda3::kNumberOfRooms || !rooms_ || !rom_ ||
      !rom_->is_loaded()) {
    return nullptr;
  }
 
  auto* room_ptr = rooms_->TryEnsureRoom(room_id);
  if (!room_ptr) {
    return nullptr;
  }
  auto& room = *room_ptr;
  auto& layer_mgr = GetRoomLayerManager(room_id);
  auto& composite = output.Prepare(room, layer_mgr);
  if (!composite.is_active() || composite.width() <= 0) {
    return nullptr;
  }
 
  // Closes the A3 first-frame race for the dungeon room composite, mirroring
  // the title-screen path (A4). The helper queues CREATE on first sight,
  // queues UPDATE when RoomLayerManager::CompositeToOutput marked the bitmap
  // modified, and stamps metadata().purpose so canvas_rendering's diagnostic
  // log can identify the bitmap.
  gfx::EnsureCompositeBitmapTextureQueued(composite);
  return &composite;
}
 
bool DungeonCanvasViewer::DrawRoomBackgroundLayers(int room_id) {
  if (room_id < 0 || room_id >= zelda3::kNumberOfRooms || !rooms_) {
    return false;
  }
 
  const float scale = canvas_.global_scale();
  gfx::Bitmap* composite = PrepareRoomCompositeBitmap(room_id);
  if (!composite) {
    return false;
  }
 
  // Single-room canvas rendering prepares the composite after the normal room
  // state upload pass. Flush here too so workbench mode can draw the freshly
  // queued room texture in the same frame.
  gfx::Arena::Get().ProcessTextureQueue(renderer_);
 
  if (composite->texture()) {
    canvas_.DrawBitmap(*composite, 0, 0, scale, 255);
    return true;
  }
 
  return false;
}
 
void DungeonCanvasViewer::DrawMaskHighlights(const gui::CanvasRuntime& rt,
                                             const zelda3::Room& room) {
  const auto& objects = room.GetTileObjects();
  const ImVec4 mask_color(0.2f, 0.6f, 1.0f, 0.4f);
 
  for (const auto& obj : objects) {
    if (obj.GetLayerValue() != 1) {
      continue;
    }
 
    auto [canvas_x, canvas_y] =
        DungeonRenderingHelpers::RoomToCanvasCoordinates(obj.x(), obj.y());
    auto [width, height] =
        zelda3::DimensionService::Get().GetPixelDimensions(obj);
    width = std::min(width, 512);
    height = std::min(height, 512);
    gui::DrawRect(rt, canvas_x, canvas_y, width, height, mask_color);
  }
}
 
}  // namespace yaze::editor