color.cc

Go to the documentation of this file.

#include "color.h"
#include "util/i18n/tr.h"
 
#include <algorithm>
 
#include "absl/strings/str_format.h"
#include "app/gfx/types/snes_color.h"
#include "app/gfx/types/snes_palette.h"
#include "app/gui/core/icons.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace gui {
 
ImVec4 ConvertSnesColorToImVec4(const gfx::SnesColor& color) {
  // SnesColor stores RGB as 0-255 in ImVec4, convert to standard 0-1 range
  ImVec4 rgb_255 = color.rgb();
  return ImVec4(rgb_255.x / 255.0f, rgb_255.y / 255.0f, rgb_255.z / 255.0f,
                1.0f);
}
 
gfx::SnesColor ConvertImVec4ToSnesColor(const ImVec4& color) {
  // SnesColor constructor expects 0-1 range and handles conversion internally
  return gfx::SnesColor(color);
}
 
std::string SnesColorToSnesString(const gfx::SnesColor& color) {
  return absl::StrFormat("$%04X", color.snes());
}
 
std::string SnesColorToRgbString(const gfx::SnesColor& color) {
  // rgb() is already in the 0-255 range.
  const auto rgb = color.rgb();
  return absl::StrFormat("(%d,%d,%d)", static_cast<int>(rgb.x),
                         static_cast<int>(rgb.y), static_cast<int>(rgb.z));
}
 
std::string SnesColorToHexString(const gfx::SnesColor& color) {
  const auto rgb = color.rgb();
  return absl::StrFormat("#%02X%02X%02X", static_cast<int>(rgb.x),
                         static_cast<int>(rgb.y), static_cast<int>(rgb.z));
}
 
void SnesColorCopyMenuItems(const gfx::SnesColor& color) {
  const std::string snes = SnesColorToSnesString(color);
  const std::string rgb = SnesColorToRgbString(color);
  const std::string hex = SnesColorToHexString(color);
  const std::string snes_label =
      std::string(ICON_MD_CONTENT_COPY " ") + tr("Copy as SNES");
  if (ImGui::MenuItem(snes_label.c_str(), snes.c_str())) {
    ImGui::SetClipboardText(snes.c_str());
  }
  const std::string rgb_label =
      std::string(ICON_MD_CONTENT_COPY " ") + tr("Copy as RGB");
  if (ImGui::MenuItem(rgb_label.c_str(), rgb.c_str())) {
    ImGui::SetClipboardText(rgb.c_str());
  }
  const std::string hex_label =
      std::string(ICON_MD_CONTENT_COPY " ") + tr("Copy as Hex");
  if (ImGui::MenuItem(hex_label.c_str(), hex.c_str())) {
    ImGui::SetClipboardText(hex.c_str());
  }
}
 
IMGUI_API bool SnesColorButton(absl::string_view id, gfx::SnesColor& color,
                               ImGuiColorEditFlags flags,
                               const ImVec2& size_arg) {
  // Convert the SNES color values to ImGui color values
  ImVec4 displayColor = ConvertSnesColorToImVec4(color);
 
  // Call the original ImGui::ColorButton with the converted color
  bool pressed = ImGui::ColorButton(id.data(), displayColor, flags, size_arg);
  // Add the SNES color representation to the tooltip
  if (ImGui::IsItemHovered()) {
    ImGui::BeginTooltip();
    ImGui::Text(tr("SNES: $%04X"), color.snes());
    ImGui::EndTooltip();
  }
  return pressed;
}
 
IMGUI_API bool SnesColorEdit4(absl::string_view label, gfx::SnesColor* color,
                              ImGuiColorEditFlags flags) {
  // Convert from internal 0-255 storage to 0-1 for ImGui
  ImVec4 displayColor = ConvertSnesColorToImVec4(*color);
 
  // Call the original ImGui::ColorEdit4 with the converted color
  bool changed =
      ImGui::ColorEdit4(label.data(), (float*)&displayColor.x, flags);
 
  // Only update if the user actually changed the color
  if (changed) {
    // set_rgb() handles conversion from 0-1 (ImGui) to 0-255 (internal)
    // and automatically calculates snes_ value - no need to call set_snes
    // separately
    color->set_rgb(displayColor);
  }
 
  return changed;
}
 
// ============================================================================
// New Standardized Palette Widgets
// ============================================================================
 
IMGUI_API bool InlinePaletteSelector(gfx::SnesPalette& palette, int num_colors,
                                     int* selected_index) {
  bool selection_made = false;
  int colors_to_show = std::min(num_colors, static_cast<int>(palette.size()));
 
  ImGui::BeginGroup();
  for (int n = 0; n < colors_to_show; n++) {
    ImGui::PushID(n);
    if (n > 0 && (n % 8) != 0) {
      ImGui::SameLine(0.0f, ImGui::GetStyle().ItemSpacing.y);
    }
 
    bool is_selected = selected_index && (*selected_index == n);
    if (is_selected) {
      ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.0f, 1.0f, 0.0f, 1.0f));
      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 2.0f);
    }
 
    if (SnesColorButton(
            "##palettesel", palette[n],
            ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
            ImVec2(20, 20))) {
      if (selected_index) {
        *selected_index = n;
        selection_made = true;
      }
    }
 
    if (is_selected) {
      ImGui::PopStyleVar();
      ImGui::PopStyleColor();
    }
 
    ImGui::PopID();
  }
  ImGui::EndGroup();
 
  return selection_made;
}
 
IMGUI_API absl::Status InlinePaletteEditor(gfx::SnesPalette& palette,
                                           const std::string& title,
                                           ImGuiColorEditFlags flags) {
  if (!title.empty()) {
    ImGui::Text("%s", title.c_str());
  }
 
  static int selected_color = 0;
  static ImVec4 current_color = ImVec4(0, 0, 0, 1.0f);
 
  // Color picker
  ImGui::Separator();
  if (ImGui::ColorPicker4("##colorpicker", (float*)&current_color,
                          ImGuiColorEditFlags_NoSidePreview |
                              ImGuiColorEditFlags_NoSmallPreview)) {
    gfx::SnesColor snes_color(current_color);
    palette.UpdateColor(selected_color, snes_color);
  }
 
  ImGui::Separator();
 
  // Palette grid
  ImGui::BeginGroup();
  for (int n = 0; n < palette.size(); n++) {
    ImGui::PushID(n);
    if ((n % 8) != 0) {
      ImGui::SameLine(0.0f, ImGui::GetStyle().ItemSpacing.y);
    }
 
    if (flags == 0) {
      flags = ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker;
    }
 
    if (SnesColorButton("##palettedit", palette[n], flags, ImVec2(20, 20))) {
      selected_color = n;
      current_color = ConvertSnesColorToImVec4(palette[n]);
    }
 
    // Context menu
    if (ImGui::BeginPopupContextItem()) {
      SnesColorCopyMenuItems(palette[n]);
      ImGui::EndPopup();
    }
 
    ImGui::PopID();
  }
  ImGui::EndGroup();
 
  return absl::OkStatus();
}
 
IMGUI_API bool PopupPaletteEditor(const char* popup_id,
                                  gfx::SnesPalette& palette,
                                  ImGuiColorEditFlags flags) {
  bool modified = false;
 
  if (ImGui::BeginPopup(popup_id)) {
    static int selected_color = 0;
    static ImVec4 current_color = ImVec4(0, 0, 0, 1.0f);
 
    // Compact color picker
    if (ImGui::ColorPicker4("##popuppicker", (float*)&current_color,
                            ImGuiColorEditFlags_NoSidePreview |
                                ImGuiColorEditFlags_NoSmallPreview)) {
      gfx::SnesColor snes_color(current_color);
      palette.UpdateColor(selected_color, snes_color);
      modified = true;
    }
 
    ImGui::Separator();
 
    // Palette grid
    ImGui::BeginGroup();
    for (int n = 0; n < palette.size() && n < 64;
         n++) {  // Limit to 64 for popup
      ImGui::PushID(n);
      if ((n % 8) != 0) {
        ImGui::SameLine(0.0f, ImGui::GetStyle().ItemSpacing.y);
      }
 
      if (SnesColorButton(
              "##popuppal", palette[n],
              ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker,
              ImVec2(20, 20))) {
        selected_color = n;
        current_color = ConvertSnesColorToImVec4(palette[n]);
      }
 
      ImGui::PopID();
    }
    ImGui::EndGroup();
 
    ImGui::EndPopup();
  }
 
  return modified;
}
 
// ============================================================================
// Legacy Functions (for compatibility)
// ============================================================================
 
IMGUI_API bool DisplayPalette(gfx::SnesPalette& palette, bool loaded) {
  static ImVec4 color = ImVec4(0, 0, 0, 1.0f);
  ImGuiColorEditFlags misc_flags = ImGuiColorEditFlags_AlphaPreview |
                                   ImGuiColorEditFlags_NoDragDrop |
                                   ImGuiColorEditFlags_NoOptions;
 
  // Generate a default palette. The palette will persist and can be edited.
  static ImVec4 saved_palette[32] = {};
  const int max_colors =
      std::min<int>(static_cast<int>(palette.size()),
                    static_cast<int>(IM_ARRAYSIZE(saved_palette)));
  if (loaded) {
    for (int n = 0; n < max_colors; n++) {
      auto color = palette[n];
      saved_palette[n].x = color.rgb().x / 255.0f;
      saved_palette[n].y = color.rgb().y / 255.0f;
      saved_palette[n].z = color.rgb().z / 255.0f;
      saved_palette[n].w = 1.0f;
    }
  }
 
  static ImVec4 backup_color;
  ImGui::Text(tr("Current ==>"));
  ImGui::SameLine();
  ImGui::Text(tr("Previous"));
 
  ImGui::ColorButton(
      "##current", color,
      ImGuiColorEditFlags_NoPicker | ImGuiColorEditFlags_AlphaPreviewHalf,
      ImVec2(60, 40));
  ImGui::SameLine();
 
  if (ImGui::ColorButton(
          "##previous", backup_color,
          ImGuiColorEditFlags_NoPicker | ImGuiColorEditFlags_AlphaPreviewHalf,
          ImVec2(60, 40)))
    color = backup_color;
  ImGui::Separator();
 
  ImGui::BeginGroup();  // Lock X position
  ImGui::Text(tr("Palette"));
  for (int n = 0; n < max_colors; n++) {
    ImGui::PushID(n);
    if ((n % 4) != 0)
      ImGui::SameLine(0.0f, ImGui::GetStyle().ItemSpacing.y);
 
    ImGuiColorEditFlags palette_button_flags = ImGuiColorEditFlags_NoAlpha |
                                               ImGuiColorEditFlags_NoPicker |
                                               ImGuiColorEditFlags_NoTooltip;
    if (ImGui::ColorButton("##palette", saved_palette[n], palette_button_flags,
                           ImVec2(20, 20)))
      color = ImVec4(saved_palette[n].x, saved_palette[n].y, saved_palette[n].z,
                     color.w);  // Preserve alpha!
 
    if (ImGui::BeginDragDropTarget()) {
      if (const ImGuiPayload* payload =
              ImGui::AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_3F))
        memcpy((float*)&saved_palette[n], payload->Data, sizeof(float) * 3);
      if (const ImGuiPayload* payload =
              ImGui::AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_4F))
        memcpy((float*)&saved_palette[n], payload->Data, sizeof(float) * 4);
      ImGui::EndDragDropTarget();
    }
 
    ImGui::PopID();
  }
  ImGui::EndGroup();
  ImGui::SameLine();
 
  ImGui::ColorPicker4("##picker", (float*)&color,
                      misc_flags | ImGuiColorEditFlags_NoSidePreview |
                          ImGuiColorEditFlags_NoSmallPreview);
  return true;
}
 
void SelectablePalettePipeline(uint64_t& palette_id, bool& refresh_graphics,
                               gfx::SnesPalette& palette) {
  const auto palette_row_size = 7;
  if (ImGuiID child_id = ImGui::GetID((void*)(intptr_t)100);
      ImGui::BeginChild(child_id, ImGui::GetContentRegionAvail(), true,
                        ImGuiWindowFlags_AlwaysVerticalScrollbar)) {
    ImGui::BeginGroup();  // Lock X position
    ImGui::Text(tr("Palette"));
    for (int n = 0; n < palette.size(); n++) {
      ImGui::PushID(n);
      if ((n % palette_row_size) != 0)
        ImGui::SameLine(0.0f, ImGui::GetStyle().ItemSpacing.y);
 
      // Check if the current row is selected
      bool is_selected = (palette_id == n / palette_row_size);
 
      // Add outline rectangle to the selected row
      if (is_selected) {
        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.0f, 1.0f, 0.0f, 1.0f));
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 2.0f);
      }
 
      if (gui::SnesColorButton("##palette", palette[n],
                               ImGuiColorEditFlags_NoAlpha |
                                   ImGuiColorEditFlags_NoPicker |
                                   ImGuiColorEditFlags_NoTooltip,
                               ImVec2(20, 20))) {
        palette_id = n / palette_row_size;
        refresh_graphics = true;
      }
 
      if (is_selected) {
        ImGui::PopStyleColor();
        ImGui::PopStyleVar();
      }
 
      ImGui::PopID();
    }
    ImGui::EndGroup();
  }
  ImGui::EndChild();
}
 
absl::Status DisplayEditablePalette(gfx::SnesPalette& palette,
                                    const std::string& title,
                                    bool show_color_picker, int colors_per_row,
                                    ImGuiColorEditFlags flags) {
  // Default flags if none provided
  if (flags == 0) {
    flags = ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoPicker |
            ImGuiColorEditFlags_NoTooltip;
  }
 
  // Display title if provided
  if (!title.empty()) {
    ImGui::Text("%s", title.c_str());
  }
  static int selected_color = 0;
 
  if (show_color_picker) {
    ImGui::Separator();
    static ImVec4 current_color = ImVec4(0, 0, 0, 1.0f);
 
    if (ImGui::ColorPicker4("Color Picker", (float*)&current_color,
                            ImGuiColorEditFlags_NoSidePreview |
                                ImGuiColorEditFlags_NoSmallPreview)) {
      // Convert the selected color to SNES format and add it to the palette
      gfx::SnesColor snes_color(current_color);
      palette.UpdateColor(selected_color, snes_color);
    }
  }
 
  // Display the palette colors in a grid
  ImGui::BeginGroup();  // Lock X position
  for (int n = 0; n < palette.size(); n++) {
    ImGui::PushID(n);
    if ((n % colors_per_row) != 0) {
      ImGui::SameLine(0.0f, ImGui::GetStyle().ItemSpacing.y);
    }
 
    // Create a unique ID for this color button
    std::string button_id = "##palette_" + std::to_string(n);
 
    // Display the color button
    if (SnesColorButton(button_id, palette[n], flags, ImVec2(20, 20))) {
      // Color was clicked, could be used to select this color
      selected_color = n;
    }
 
    // OpenPopup must run at this window's ID stack level, not inside the
    // context popup, or BeginPopup below never finds it.
    bool open_edit_color = false;
    if (ImGui::BeginPopupContextItem()) {
      if (ImGui::MenuItem(tr("Edit Color..."))) {
        open_edit_color = true;
      }
      ImGui::Separator();
      SnesColorCopyMenuItems(palette[n]);
      ImGui::EndPopup();
    }
    if (open_edit_color) {
      ImGui::OpenPopup(("Edit Color##" + std::to_string(n)).c_str());
    }
 
    // Color picker popup
    if (ImGui::BeginPopup(("Edit Color##" + std::to_string(n)).c_str())) {
      ImGuiColorEditFlags picker_flags = ImGuiColorEditFlags_NoSidePreview |
                                         ImGuiColorEditFlags_NoSmallPreview;
 
      ImVec4 color = ConvertSnesColorToImVec4(palette[n]);
      if (ImGui::ColorPicker4("##picker", (float*)&color, picker_flags)) {
        // Update the SNES color when the picker changes
        palette[n] = ConvertImVec4ToSnesColor(color);
      }
 
      ImGui::EndPopup();
    }
 
    ImGui::PopID();
  }
  ImGui::EndGroup();
 
  return absl::OkStatus();
}
 
IMGUI_API bool PaletteColorButton(const char* id, const gfx::SnesColor& color,
                                  bool is_selected, bool is_modified,
                                  const ImVec2& size,
                                  ImGuiColorEditFlags flags) {
  ImVec4 display_color = ConvertSnesColorToImVec4(color);
 
  // Add visual indicators for selection and modification
  ImGui::PushID(id);
 
  // Selection border
  if (is_selected) {
    ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.0f, 0.8f, 0.0f, 1.0f));
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 2.0f);
  }
 
  bool clicked = ImGui::ColorButton(id, display_color, flags, size);
 
  if (is_selected) {
    ImGui::PopStyleVar();
    ImGui::PopStyleColor();
  }
 
  // Modification indicator (small dot in corner)
  if (is_modified) {
    ImVec2 pos = ImGui::GetItemRectMin();
    ImVec2 dot_pos = ImVec2(pos.x + size.x - 6, pos.y + 2);
    ImGui::GetWindowDrawList()->AddCircleFilled(dot_pos, 3.0f,
                                                IM_COL32(255, 128, 0, 255));
  }
 
  // Tooltip with color info
  if (ImGui::IsItemHovered()) {
    ImGui::BeginTooltip();
    ImGui::Text(tr("SNES: $%04X"), color.snes());
    auto rgb = color.rgb();
    ImGui::Text(tr("RGB: (%d, %d, %d)"), static_cast<int>(rgb.x),
                static_cast<int>(rgb.y), static_cast<int>(rgb.z));
    if (is_modified) {
      ImGui::TextColored(ImVec4(1.0f, 0.6f, 0.0f, 1.0f), tr("Modified"));
    }
    ImGui::EndTooltip();
  }
 
  ImGui::PopID();
  return clicked;
}
 
}  // namespace gui
}  // namespace yaze