snes_color.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_SNES_COLOR_H_
#define YAZE_APP_GFX_SNES_COLOR_H_
 
#include <yaze.h>
 
#include <cstdint>
#include <vector>
 
#include "imgui/imgui.h"
 
namespace yaze {
namespace gfx {
 
constexpr int NumberOfColors = 3143;
 
// ============================================================================
// SNES Color Conversion Functions
// ============================================================================
//
// Color Format Guide:
// - SNES Color (uint16_t): 15-bit BGR format (0bbbbbgggggrrrrr)
// - snes_color struct: RGB values in 0-255 range
// - ImVec4: RGBA values in 0.0-1.0 range (standard for ImGui)
// - SDL_Color: RGBA values in 0-255 range
//
// Conversion paths:
// 1. SNES (uint16_t) <-> snes_color (0-255) <-> ImVec4 (0.0-1.0)
// 2. Use these functions to convert between formats explicitly
// ============================================================================
 
snes_color ConvertSnesToRgb(uint16_t snes_color);
 
uint16_t ConvertRgbToSnes(const snes_color& color);
 
uint16_t ConvertRgbToSnes(const ImVec4& color);
 
inline ImVec4 SnesColorToImVec4(const snes_color& color) {
  return ImVec4(color.red / 255.0f, color.green / 255.0f, color.blue / 255.0f,
                1.0f);
}
 
inline snes_color ImVec4ToSnesColor(const ImVec4& color) {
  snes_color result;
  result.red = static_cast<uint16_t>(color.x * 255.0f);
  result.green = static_cast<uint16_t>(color.y * 255.0f);
  result.blue = static_cast<uint16_t>(color.z * 255.0f);
  return result;
}
 
inline ImVec4 SnesTo8bppColor(uint16_t color_value) {
  snes_color rgb = ConvertSnesToRgb(color_value);
  return SnesColorToImVec4(rgb);
}
 
std::vector<snes_color> Extract(const char* data, unsigned int offset,
                                unsigned int palette_size);
 
std::vector<char> Convert(const std::vector<snes_color>& palette);
 
constexpr uint8_t kColorByteMax = 255;
constexpr float kColorByteMaxF = 255.f;
 
class SnesColor {
 public:
  constexpr SnesColor()
      : rgb_({0.f, 0.f, 0.f, 255.f}), snes_(0), rom_color_({0, 0, 0}) {}
 
  explicit SnesColor(const ImVec4 val) {
    // Convert from ImGui's 0-1 range to internal 0-255 storage
    rgb_.x = val.x * kColorByteMax;
    rgb_.y = val.y * kColorByteMax;
    rgb_.z = val.z * kColorByteMax;
    rgb_.w = kColorByteMaxF;  // Alpha always 255
 
    snes_color color;
    color.red = static_cast<uint16_t>(rgb_.x);
    color.green = static_cast<uint16_t>(rgb_.y);
    color.blue = static_cast<uint16_t>(rgb_.z);
    rom_color_ = color;
    snes_ = ConvertRgbToSnes(color);
  }
 
  explicit SnesColor(const uint16_t val) : snes_(val) {
    snes_color color = ConvertSnesToRgb(val);  // Returns 0-255 RGB
    // Store 0-255 values in ImVec4 (unconventional but internal)
    rgb_ = ImVec4(color.red, color.green, color.blue, kColorByteMaxF);
    rom_color_ = color;
  }
 
  explicit SnesColor(const snes_color val)
      : rgb_(val.red, val.green, val.blue, kColorByteMaxF),
        snes_(ConvertRgbToSnes(val)),
        rom_color_(val) {}
 
  SnesColor(uint8_t r, uint8_t g, uint8_t b) {
    rgb_ = ImVec4(r, g, b, kColorByteMaxF);
    snes_color color;
    color.red = r;
    color.green = g;
    color.blue = b;
    snes_ = ConvertRgbToSnes(color);
    rom_color_ = color;
  }
 
  void set_rgb(const ImVec4 val);
 
  void set_snes(uint16_t val);
 
  constexpr ImVec4 rgb() const { return rgb_; }
 
  constexpr snes_color rom_color() const { return rom_color_; }
 
  constexpr uint16_t snes() const { return snes_; }
 
  constexpr bool is_modified() const { return modified; }
  constexpr bool is_transparent() const { return transparent; }
  constexpr void set_transparent(bool t) { transparent = t; }
  constexpr void set_modified(bool m) { modified = m; }
 
 private:
  ImVec4 rgb_;            // Stores 0-255 values (unconventional!)
  uint16_t snes_;         // 15-bit SNES format
  snes_color rom_color_;  // 0-255 RGB struct
  bool modified = false;
  bool transparent = false;
};
 
SnesColor ReadColorFromRom(int offset, const uint8_t* rom);
 
SnesColor GetCgxColor(uint16_t color);
std::vector<SnesColor> GetColFileData(uint8_t* data);
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_SNES_COLOR_H_