gfx_group_editor.cc

Go to the documentation of this file.

#include "gfx_group_editor.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
 
#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/str_join.h"
#include "app/editor/graphics/gfx_group_editor_internal.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gfx/types/snes_tile.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/color.h"
#include "app/gui/core/icons.h"
#include "app/gui/core/input.h"
#include "app/gui/core/layout_helpers.h"
#include "app/gui/widgets/themed_widgets.h"
#include "imgui/imgui.h"
#include "rom/rom.h"
#include "util/macro.h"
 
namespace yaze {
namespace editor {
 
using ImGui::BeginChild;
using ImGui::BeginCombo;
using ImGui::BeginGroup;
using ImGui::BeginTabItem;
using ImGui::BeginTable;
using ImGui::EndChild;
using ImGui::EndCombo;
using ImGui::EndGroup;
using ImGui::EndTabItem;
using ImGui::EndTable;
using ImGui::GetContentRegionAvail;
using ImGui::GetStyle;
using ImGui::IsItemClicked;
using ImGui::PopID;
using ImGui::PushID;
using ImGui::SameLine;
using ImGui::Selectable;
using ImGui::Separator;
using ImGui::SetNextItemWidth;
using ImGui::SliderFloat;
using ImGui::TableHeadersRow;
using ImGui::TableNextColumn;
using ImGui::TableNextRow;
using ImGui::TableSetupColumn;
using ImGui::Text;
 
using gfx::kPaletteGroupNames;
using gfx::PaletteCategory;
 
namespace {
 
// Constants for sheet display
constexpr int kSheetDisplayHeight = 64;  // 2x scale from 32px sheets
constexpr float kDefaultScale = 2.0f;
constexpr int kTileSize = 16;  // 8px tiles at 2x scale
 
// Width of a table column of "Slot N" hex inputs. The column is fixed and
// the sheet previews take the rest, so the inputs stay usable when the
// panel is narrower than the previews (a stretch column shrank to nothing).
float SlotInputsColumnWidth() {
  const ImGuiStyle& style = ImGui::GetStyle();
  return ImGui::CalcTextSize("Slot 00").x +
         gui::LayoutHelpers::GetSliderWidth() + 2 * ImGui::GetFrameHeight() +
         4 * style.ItemInnerSpacing.x + 2 * style.CellPadding.x;
}
 
// Draw a single sheet with proper scaling and unique ID
void DrawScaledSheet(gui::Canvas& canvas, gfx::Bitmap& sheet, int unique_id,
                     float scale = kDefaultScale) {
  PushID(unique_id);
 
  // Each sheet viewer is read-only; declare it so future canvas surfaces
  // (cursors, hover hints, context-menu items) can default appropriately
  // without the caller threading the policy through every frame.
  canvas.GetConfig().role = gui::CanvasRole::kPreviewOnly;
 
  // Calculate scaled dimensions
  int display_width = static_cast<int>(gfx::kTilesheetWidth * scale);
  int display_height = static_cast<int>(gfx::kTilesheetHeight * scale);
 
  // Draw canvas background
  canvas.DrawBackground(ImVec2(display_width + 1, display_height + 1));
  canvas.DrawContextMenu();
 
  // Draw bitmap with proper scale
  canvas.DrawBitmap(sheet, 2, scale);
 
  // Draw grid at scaled tile size
  canvas.DrawGrid(static_cast<int>(8 * scale));
  canvas.DrawOverlay();
 
  PopID();
}
 
}  // namespace
 
gfx::Bitmap* GfxGroupEditor::PrepareSheetPreview(int sheet_id,
                                                 gfx::SheetRole role,
                                                 gfx::Bitmap& preview) {
  UpdateCurrentPalette();
  if (!game_data_ || sheet_id < 0 ||
      sheet_id >= zelda3::GraphicsSheetStore::kSheetCount ||
      !game_data_->sheet_store.HasSheet(sheet_id)) {
    Text("Sheet 0x%02X is not loaded", sheet_id);
    return nullptr;
  }
  const auto pixels = game_data_->sheet_store.Sheet(sheet_id);
  const bool changed =
      !preview.surface() || preview.vector().size() != pixels.size() ||
      !std::equal(pixels.begin(), pixels.end(), preview.vector().begin());
  if (changed)
    preview.Create(128, 32, 8,
                   std::vector<uint8_t>(pixels.begin(), pixels.end()));
  const auto* palette = Ws().override_palette && current_palette_
                            ? current_palette_
                            : internal::ResolveRoleDefaultPalette(
                                  role, game_data_->palette_groups);
  if (palette && preview.palette() != *palette) {
    preview.SetPalette(*palette);
    if (preview.texture())
      preview.UpdateTexture();
  } else if (changed && preview.texture()) {
    preview.UpdateTexture();
  }
  internal::EnsureSheetTextureQueued(preview);
  return &preview;
}
 
absl::Status GfxGroupEditor::Update() {
  if (!host_surface_hint_.empty()) {
    ImGui::TextDisabled("%s", host_surface_hint_.c_str());
    Separator();
  }
 
  UpdateCurrentPalette();
 
  // Palette controls at top for all tabs
  DrawPaletteControls();
  Separator();
 
  if (gui::BeginThemedTabBar("##GfxGroupEditorTabs")) {
    if (BeginTabItem(tr("Blocksets"))) {
      gui::InputHexByte("Selected Blockset", &Ws().selected_blockset,
                        static_cast<uint8_t>(0x24));
      rom()->resource_label()->SelectableLabelWithNameEdit(
          false, "blockset", std::to_string(Ws().selected_blockset),
          absl::StrFormat("Blockset 0x%02X", Ws().selected_blockset));
      DrawBlocksetViewer();
      EndTabItem();
    }
 
    if (BeginTabItem(tr("Roomsets"))) {
      gui::InputHexByte("Selected Roomset", &Ws().selected_roomset,
                        static_cast<uint8_t>(81));
      rom()->resource_label()->SelectableLabelWithNameEdit(
          false, "roomset", std::to_string(Ws().selected_roomset),
          absl::StrFormat("Roomset 0x%02X", Ws().selected_roomset));
      DrawRoomsetViewer();
      EndTabItem();
    }
 
    if (BeginTabItem(tr("Spritesets"))) {
      gui::InputHexByte("Selected Spriteset", &Ws().selected_spriteset,
                        static_cast<uint8_t>(143));
      rom()->resource_label()->SelectableLabelWithNameEdit(
          false, "spriteset", std::to_string(Ws().selected_spriteset),
          absl::StrFormat("Spriteset 0x%02X", Ws().selected_spriteset));
      DrawSpritesetUsage(Ws().selected_spriteset);
      DrawSpritesetViewer();
      EndTabItem();
    }
 
    gui::EndThemedTabBar();
  }
 
  return absl::OkStatus();
}
 
void GfxGroupEditor::DrawSpritesetUsage(int id) {
  if (!ImGui::TreeNodeEx("Used by##SpritesetUsage",
                         ImGuiTreeNodeFlags_DefaultOpen)) {
    return;
  }
  const bool refresh = ImGui::SmallButton(ICON_MD_REFRESH " Refresh");
  HOVER_HINT("Re-read overworld areas and room headers from the ROM buffer");
  if (rom_ != nullptr && rom_->is_loaded() &&
      (refresh || usage_rom_ != rom_ || !usage_areas_.has_value())) {
    usage_areas_ = zelda3::CollectOverworldAreaGfx(*rom_, game_data_);
    usage_rooms_ = zelda3::CollectRoomGfx(*rom_);
    usage_rom_ = rom_;
  }
  if (!usage_areas_.has_value() || !usage_rooms_.has_value()) {
    ImGui::TextDisabled(tr("Load a ROM to see usage."));
    ImGui::TreePop();
    return;
  }
 
  auto hex_list = [](const std::vector<int>& ids) {
    return ids.empty() ? std::string("-")
                       : absl::StrJoin(ids, " ", [](std::string* out, int v) {
                           out->append(absl::StrFormat("%02X", v));
                         });
  };
  const auto usage =
      zelda3::FindSpritesetUsage(id, *usage_areas_, *usage_rooms_);
  static constexpr const char* kStates[] = {
      "OW areas, state 0 (start)", "OW areas, state 1", "OW areas, state 2"};
  for (int state = 0; state < 3; ++state) {
    ImGui::TextWrapped("%s (%zu): %s", kStates[state],
                       usage.ow_areas_by_state[state].size(),
                       hex_list(usage.ow_areas_by_state[state]).c_str());
  }
  ImGui::TextWrapped("Rooms, header 0x%02X (%zu): %s",
                     std::max(0, id - zelda3::kDungeonSpritesetBase),
                     usage.rooms.size(), hex_list(usage.rooms).c_str());
  if (id < zelda3::kDungeonSpritesetBase) {
    ImGui::TextDisabled(
        tr("Dungeon rooms use spritesets 0x40-0x8F (header + 0x40)."));
  }
  ImGui::TreePop();
}
 
void GfxGroupEditor::DrawBlocksetViewer(bool sheet_only) {
  if (!game_data()) {
    Text(tr("No game data loaded"));
    return;
  }
 
  if (Ws().selected_blockset >= game_data()->main_blockset_ids.size()) {
    Text("Main graphics group is unavailable");
    return;
  }
  PushID("BlocksetViewer");
  auto& ws = Ws();
 
  if (BeginTable("##BlocksetTable", sheet_only ? 1 : 2,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable,
                 ImVec2(0, 0))) {
    if (!sheet_only) {
      TableSetupColumn("Inputs", ImGuiTableColumnFlags_WidthFixed,
                       SlotInputsColumnWidth());
    }
 
    TableSetupColumn("Sheets", ImGuiTableColumnFlags_WidthStretch);
    TableHeadersRow();
    TableNextRow();
 
    if (!sheet_only) {
      TableNextColumn();
      BeginGroup();
      DrawAssignmentControls(GroupKind::kMain);
      EndGroup();
    }
 
    TableNextColumn();
    BeginGroup();
    for (int idx = 0; idx < 8; idx++) {
      int sheet_id = game_data()->main_blockset_ids[ws.selected_blockset][idx];
      auto* sheet = PrepareSheetPreview(sheet_id, gfx::RoleForBlocksetSlot(idx),
                                        blockset_previews_[idx]);
      if (!sheet)
        continue;
 
      // Unique ID combining blockset, slot, and sheet
      int unique_id = (ws.selected_blockset << 16) | (idx << 8) | sheet_id;
      DrawScaledSheet(blockset_canvases_[idx], *sheet, unique_id,
                      ws.view_scale);
    }
    EndGroup();
    EndTable();
  }
 
  PopID();
}
 
void GfxGroupEditor::DrawRoomsetViewer() {
  if (!game_data()) {
    Text(tr("No game data loaded"));
    return;
  }
 
  if (Ws().selected_roomset >= game_data()->room_blockset_ids.size()) {
    ImGui::TextUnformatted("Roomset is unavailable");
    return;
  }
  PushID("RoomsetViewer");
  auto& ws = Ws();
  Text(tr("Roomsets overwrite slots 3-6 of the main blockset"));
 
  if (BeginTable("##RoomsTable", 3,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable,
                 ImVec2(0, 0))) {
    TableSetupColumn("List", ImGuiTableColumnFlags_WidthFixed, 120);
    TableSetupColumn("Inputs", ImGuiTableColumnFlags_WidthFixed,
                     SlotInputsColumnWidth());
    TableSetupColumn("Sheets", ImGuiTableColumnFlags_WidthStretch);
    TableHeadersRow();
    TableNextRow();
 
    // Roomset list column
    TableNextColumn();
    if (BeginChild("##RoomsetListChild", ImVec2(0, 300))) {
      for (int idx = 0; idx < 0x52; idx++) {
        PushID(idx);
        std::string roomset_label = absl::StrFormat("0x%02X", idx);
        bool is_selected = (ws.selected_roomset == static_cast<uint8_t>(idx));
        if (Selectable(roomset_label.c_str(), is_selected)) {
          ws.selected_roomset = static_cast<uint8_t>(idx);
        }
        PopID();
      }
    }
    EndChild();
 
    TableNextColumn();
    DrawAssignmentControls(GroupKind::kRoomset);
 
    // Sheets column
    TableNextColumn();
    BeginGroup();
    for (int idx = 0; idx < 4; idx++) {
      int sheet_id = game_data()->room_blockset_ids[ws.selected_roomset][idx];
      if (sheet_id == 0) {
        Text("Slot %d: Inherit from main group", idx + 3);
        continue;
      }
      Text("Slot %d / Sheet %02X", idx + 3, sheet_id);
      auto* sheet = PrepareSheetPreview(sheet_id, gfx::RoleForRoomsetSlot(idx),
                                        roomset_previews_[idx]);
      if (!sheet)
        continue;
 
      // Unique ID combining roomset, slot, and sheet
      int unique_id =
          (0x1000) | (ws.selected_roomset << 8) | (idx << 4) | sheet_id;
      DrawScaledSheet(roomset_canvases_[idx], *sheet, unique_id, ws.view_scale);
    }
    EndGroup();
    EndTable();
  }
 
  PopID();
}
 
void GfxGroupEditor::DrawSpritesetViewer(bool sheet_only) {
  if (!game_data()) {
    Text(tr("No game data loaded"));
    return;
  }
 
  PushID("SpritesetViewer");
  auto& ws = Ws();
 
  if (BeginTable("##SpritesTable", sheet_only ? 1 : 2,
                 ImGuiTableFlags_Borders | ImGuiTableFlags_Resizable,
                 ImVec2(0, 0))) {
    if (!sheet_only) {
      TableSetupColumn("Inputs", ImGuiTableColumnFlags_WidthFixed,
                       SlotInputsColumnWidth());
    }
    TableSetupColumn("Sheets", ImGuiTableColumnFlags_WidthStretch);
    TableHeadersRow();
    TableNextRow();
 
    if (!sheet_only) {
      TableNextColumn();
      BeginGroup();
      Text(tr("Sprite sheet IDs (base 115+):"));
      for (int idx = 0; idx < 4; idx++) {
        SetNextItemWidth(gui::LayoutHelpers::GetSliderWidth());
        gui::InputHexByte(
            ("Slot " + std::to_string(idx)).c_str(),
            &game_data()->spriteset_ids[ws.selected_spriteset][idx]);
      }
      EndGroup();
    }
 
    TableNextColumn();
    BeginGroup();
    for (int idx = 0; idx < 4; idx++) {
      int sheet_offset = game_data()->spriteset_ids[ws.selected_spriteset][idx];
      int sheet_id = 115 + sheet_offset;
      auto* sheet = PrepareSheetPreview(
          sheet_id, gfx::RoleForSpritesetSlot(idx), spriteset_previews_[idx]);
      if (!sheet)
        continue;
 
      // Unique ID combining spriteset, slot, and sheet
      int unique_id =
          (0x2000) | (ws.selected_spriteset << 8) | (idx << 4) | sheet_offset;
      DrawScaledSheet(spriteset_canvases_[idx], *sheet, unique_id,
                      ws.view_scale);
    }
    EndGroup();
    EndTable();
  }
 
  PopID();
}
 
namespace {
void DrawPaletteFromPaletteGroup(gfx::SnesPalette& palette) {
  if (palette.empty()) {
    return;
  }
  for (size_t color_idx = 0; color_idx < palette.size(); color_idx++) {
    PushID(static_cast<int>(color_idx));
    if ((color_idx % 8) != 0) {
      SameLine(0.0f, GetStyle().ItemSpacing.y);
    }
 
    // Small icon of the color in the palette
    gui::SnesColorButton(absl::StrCat("Palette", color_idx), palette[color_idx],
                         ImGuiColorEditFlags_NoAlpha |
                             ImGuiColorEditFlags_NoPicker |
                             ImGuiColorEditFlags_NoTooltip);
 
    PopID();
  }
}
}  // namespace
 
void GfxGroupEditor::DrawPaletteControls() {
  if (!game_data()) {
    return;
  }
 
  auto& ws = Ws();
 
  // View scale control
  Text(ICON_MD_ZOOM_IN " View");
  SameLine();
  SetNextItemWidth(gui::LayoutHelpers::GetSliderWidth());
  SliderFloat("##ViewScale", &ws.view_scale, 1.0f, 4.0f, "%.1fx");
  SameLine();
 
  // Palette category selector
  Text(ICON_MD_PALETTE " Palette");
  SameLine();
  SetNextItemWidth(gui::LayoutHelpers::GetComboWidth());
 
  // Use the category names array for display
  static constexpr int kNumPaletteCategories = 14;
  if (BeginCombo(
          "##PaletteCategory",
          gfx::kPaletteCategoryNames[ws.selected_palette_category].data())) {
    for (int cat = 0; cat < kNumPaletteCategories; cat++) {
      auto category = static_cast<PaletteCategory>(cat);
      bool is_selected = (ws.selected_palette_category == category);
      if (Selectable(gfx::kPaletteCategoryNames[category].data(),
                     is_selected)) {
        ws.selected_palette_category = category;
        ws.selected_palette_index = 0;
        UpdateCurrentPalette();
      }
      if (is_selected) {
        ImGui::SetItemDefaultFocus();
      }
    }
    EndCombo();
  }
 
  SameLine();
  SetNextItemWidth(gui::LayoutHelpers::GetHexInputWidth());
  if (gui::InputHexByte("##PaletteIndex", &ws.selected_palette_index)) {
    UpdateCurrentPalette();
  }
 
  SameLine();
  ImGui::Checkbox(tr("Override palette"), &ws.override_palette);
  if (ImGui::IsItemHovered()) {
    ImGui::SetTooltip(
        tr("When off, each sheet renders against its slot's role-default "
           "palette (overworld main/aux/animated, sprites, hud, dungeon).\n"
           "When on, the palette picked above is forced onto every sheet."));
  }
 
  // Show current palette preview
  if (current_palette_ && !current_palette_->empty()) {
    SameLine();
    DrawPaletteFromPaletteGroup(*current_palette_);
  }
}
 
void GfxGroupEditor::UpdateCurrentPalette() {
  if (!game_data()) {
    current_palette_ = nullptr;
    return;
  }
 
  const auto& ws = Ws();
  auto& groups = game_data()->palette_groups;
  switch (ws.selected_palette_category) {
    case PaletteCategory::kSword:
      current_palette_ =
          groups.swords.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kShield:
      current_palette_ =
          groups.shields.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kClothes:
      current_palette_ =
          groups.armors.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kWorldColors:
      current_palette_ =
          groups.overworld_main.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kAreaColors:
      current_palette_ =
          groups.overworld_aux.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kGlobalSprites:
      current_palette_ =
          groups.global_sprites.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kSpritesAux1:
      current_palette_ =
          groups.sprites_aux1.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kSpritesAux2:
      current_palette_ =
          groups.sprites_aux2.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kSpritesAux3:
      current_palette_ =
          groups.sprites_aux3.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kDungeons:
      current_palette_ =
          groups.dungeon_main.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kWorldMap:
    case PaletteCategory::kDungeonMap:
      current_palette_ =
          groups.overworld_mini_map.mutable_palette(ws.selected_palette_index);
      break;
    case PaletteCategory::kTriforce:
    case PaletteCategory::kCrystal:
      current_palette_ =
          groups.object_3d.mutable_palette(ws.selected_palette_index);
      break;
    default:
      current_palette_ = nullptr;
      break;
  }
}
 
}  // namespace editor
}  // namespace yaze