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 "core/project.h"
#include "dungeon_canvas_viewer.h"
#include "imgui/imgui.h"
#include "zelda3/dungeon/chest_edit.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 ShowEntityLabel(const gui::CanvasRuntime& rt, int x, int y, int width,
                     int height, bool selected) {
  if (selected)
    return true;
  if (!rt.hovered || !ImGui::IsWindowHovered())
    return false;
  const ImVec2 min(rt.canvas_p0.x + rt.scrolling.x + x * rt.scale,
                   rt.canvas_p0.y + rt.scrolling.y + y * rt.scale);
  return ImGui::IsMouseHoveringRect(
      min, ImVec2(min.x + width * rt.scale, min.y + height * rt.scale));
}
 
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());
 
  const auto& selected =
      object_interaction_.entity_coordinator().GetSelectedEntities();
  const auto& sprites = room.GetSprites();
  for (size_t index = 0; index < sprites.size(); ++index) {
    const auto& sprite = sprites[index];
    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);
 
      const bool show_label = ShowEntityLabel(
          rt, canvas_x, canvas_y, entity_size, entity_size,
          std::any_of(selected.begin(), selected.end(),
                      [index](const auto& entity) {
                        return entity.type == EntityType::Sprite &&
                               entity.index == index;
                      }));
      if (drew_preview && show_label) {
        gui::DrawOutline(rt, canvas_x, canvas_y, entity_size, entity_size,
                         ImGui::GetColorU32(sprite_color));
      } else if (!drew_preview) {
        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());
      }
 
      if (show_label)
        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]);
 
  const auto& selected =
      object_interaction_.entity_coordinator().GetSelectedEntities();
  for (size_t index = 0; index < pot_items.size(); ++index) {
    const auto& pot_item = pot_items[index];
    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());
      if (ShowEntityLabel(rt, canvas_x, canvas_y, entity_size, entity_size,
                          std::any_of(selected.begin(), selected.end(),
                                      [index](const auto& entity) {
                                        return entity.type ==
                                                   EntityType::Item &&
                                               entity.index == index;
                                      }))) {
        gui::DrawText(rt, item_text, canvas_x, canvas_y - 10);
      }
    }
  }
}
 
void DungeonCanvasViewer::RenderChestContents(const gui::CanvasRuntime& rt,
                                              const zelda3::Room& room) {
  if (!entity_visibility_.show_chests || !rt.draw_list ||
      !room.AreChestsLoaded() || rt.canvas_sz.x <= 16.0f) {
    return;
  }
  const auto& objects = room.GetTileObjects();
  const auto& chests = room.GetChests();
  // Residual records and mismatched small/big objects must not be presented as
  // a confident reward association. The chest inspector explains the mismatch.
  if (chests.empty() ||
      !zelda3::ValidateChestObjectMapping(objects, chests).ok()) {
    return;
  }
 
  const DungeonCanvasTransform transform(rt.canvas_p0, rt.scrolling, rt.scale);
  const ImVec2 canvas_max(rt.canvas_p0.x + rt.canvas_sz.x,
                          rt.canvas_p0.y + rt.canvas_sz.y);
  const auto& theme = AgentUI::GetTheme();
  const float padding = 4.0f;
  const float wrap_width = std::min(180.0f, rt.canvas_sz.x - padding * 4);
  rt.draw_list->PushClipRect(rt.canvas_p0, canvas_max, true);
  for (size_t i = 0; i < objects.size(); ++i) {
    const auto chest_index = zelda3::ChestIndexForObject(objects, i);
    if (!chest_index) {
      continue;
    }
    const auto& object = objects[i];
    const float chest_width = object.id_ == 0xFB1 ? 32.0f : 16.0f;
    const ImVec2 chest_min = transform.RoomPixelsToScreen(
        ImVec2(object.x_ * 8.0f, object.y_ * 8.0f));
    const ImVec2 chest_max = transform.RoomPixelsToScreen(
        ImVec2(object.x_ * 8.0f + chest_width,
               object.y_ * 8.0f + (object.id_ == 0xFB1 ? 24.0f : 16.0f)));
    if (chest_max.x < rt.canvas_p0.x || chest_min.x > canvas_max.x ||
        chest_max.y < rt.canvas_p0.y || chest_min.y > canvas_max.y) {
      continue;
    }
    const auto item_id = chests[*chest_index].id;
    const std::string text = absl::StrFormat(
        "$%02X %s", item_id,
        zelda3::GetItemReceiptLabel(
            item_id, project_ ? &project_->resource_labels : nullptr));
    const ImVec2 text_size =
        ImGui::CalcTextSize(text.c_str(), nullptr, false, wrap_width);
    const float width = text_size.x + padding * 2;
    const float height = text_size.y + padding * 2;
    const ImVec2 min(
        std::clamp((chest_min.x + chest_max.x - width) * 0.5f, rt.canvas_p0.x,
                   std::max(rt.canvas_p0.x, canvas_max.x - width)),
        std::max(rt.canvas_p0.y, chest_min.y - height - 3.0f));
    const ImVec2 max(min.x + width, min.y + height);
    rt.draw_list->AddRectFilled(min, max, IM_COL32(0, 0, 0, 200), 3.0f);
    rt.draw_list->AddRect(min, max, ImGui::GetColorU32(theme.item_color), 3.0f);
    rt.draw_list->AddText(ImGui::GetFont(), ImGui::GetFontSize(),
                          ImVec2(min.x + padding, min.y + padding),
                          ImGui::GetColorU32(ImGuiCol_Text), text.c_str(),
                          nullptr, wrap_width);
    // Draw-list annotations have no ImGui item and cannot take a placement,
    // selection, drag, or pan gesture away from the room canvas.
  }
  rt.draw_list->PopClipRect();
}
 
void DungeonCanvasViewer::RenderEntityOverlay(const gui::CanvasRuntime& rt,
                                              const zelda3::Room& room) {
  RenderSprites(rt, room);
  RenderPotItems(rt, room);
  RenderChestContents(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"))) {
          (void)object_interaction_.HandleDeleteSelected();
        }
      } else if (sel.type == EntityType::Item) {
        ImGui::TextDisabled(tr("Pot Item"));
        ImGui::Separator();
        if (ImGui::MenuItem(tr("Delete Item"))) {
          (void)object_interaction_.HandleDeleteSelected();
        }
      }
    } 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"))) {
        (void)object_interaction_.HandleDeleteSelected();
      }
      if (ImGui::MenuItem(tr("Copy"))) {
        (void)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) {
  const auto* working = rooms_ ? rooms_->GetIfLoaded(room_id) : nullptr;
  auto it = collision_overlay_cache_.find(room_id);
  if (!working && 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);
  }
 
  // A loaded room is the authoring source of truth. Rebuild its small overlay
  // from the model so edits, Undo and save-dirty clearing cannot leave ROM-era
  // pixels cached. Unloaded rooms still use the ROM-backed cache.
  auto map_or = working ? absl::StatusOr<zelda3::CustomCollisionMap>(
                              working->custom_collision())
                        : 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 (map.HasOverride(static_cast<size_t>(y * 64 + x)) &&
            (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_.insert_or_assign(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) {
  // Resolve Auto for each neighbor without changing the primary room's context.
  // Manual mode returns the same pinned entrance for every room.
  auto* room = EnsureRoomLoadedForConnectedView(room_id);
  if (!room) {
    return nullptr;
  }
  room->SetRenderEntranceBlockset(entrance_blockset_resolver_
                                      ? entrance_blockset_resolver_(room_id)
                                      : current_entrance_blockset_);
  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