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/editor/dungeon/inspectors/dungeon_entity_inspector.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);
      // PrimRect instead of AddRectFilled: since 1.93, AddRectFilled
      // anti-aliases rects with fractional corners (any non-integer zoom or
      // pan), which insets the solid color 0.5px and leaves seams between
      // adjacent pixel runs. Sprite art needs hard edges.
      rt.draw_list->PrimReserve(6, 4);
      rt.draw_list->PrimRect(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;
  }
 
  const auto sprite_colors =
      zelda3::BuildDungeonSpriteRenderPalette(room, game_data_);
  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;
      }
 
      const ItemPreviewKey preview_key{room.graphics_revision(), pot_item.item};
      auto* preview = room.graphics_revision() != 0
                          ? item_preview_cache_.Get(preview_key)
                          : nullptr;
      CachedSpritePreview uncached_preview;
      if (preview == nullptr) {
        CachedSpritePreview rendered;
        if (DungeonRenderingHelpers::BuildPotItemPreview(
                pot_item.item, room, rendered.pixels, rendered.bounds)) {
          if (room.graphics_revision() != 0) {
            preview =
                item_preview_cache_.Insert(preview_key, std::move(rendered));
          } else {
            uncached_preview = std::move(rendered);
            preview = &uncached_preview;
          }
        }
      }
 
      bool drew_preview = false;
      if (preview != nullptr && preview->bounds.w > 0 &&
          preview->bounds.h > 0 && !preview->pixels.empty()) {
        const SDL_Rect preview_bounds = preview->bounds;
        const int offset_x = (entity_size > preview_bounds.w)
                                 ? (entity_size - preview_bounds.w) / 2
                                 : 0;
        const int offset_y = (entity_size > preview_bounds.h)
                                 ? (entity_size - preview_bounds.h) / 2
                                 : 0;
        drew_preview = DrawSpritePreviewPixels(
            rt, preview->pixels, preview_bounds,
            canvas_x + preview_bounds.x + offset_x,
            canvas_y + preview_bounds.y + offset_y, sprite_colors);
      }
 
      const bool is_selected = std::any_of(
          selected.begin(), selected.end(), [index](const auto& entity) {
            return entity.type == EntityType::Item && entity.index == index;
          });
      const bool show_label = ShowEntityLabel(
          rt, canvas_x, canvas_y, entity_size, entity_size, is_selected);
 
      if (drew_preview && (show_label || is_selected)) {
        gui::DrawOutline(rt, canvas_x, canvas_y, entity_size, entity_size,
                         ImGui::GetColorU32(pot_item_color));
      } else if (!drew_preview) {
        gui::DrawRect(rt, canvas_x, canvas_y, entity_size, entity_size,
                      pot_item_color);
      }
 
      std::string item_name;
      if (pot_item.item < kDungeonPotItemCount) {
        item_name = GetDungeonPotItemName(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 (show_label) {
        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