SDL3pp_pixels.h

#ifndef SDL3PP_PIXELS_H_
#define SDL3PP_PIXELS_H_
 
#include <SDL3/SDL_pixels.h>
#include "SDL3pp_assert.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_version.h"
 
namespace SDL {


using PixelFormatRaw = SDL_PixelFormat;
 
// Forward decl
struct PixelFormat;

using ColorspaceRaw = SDL_Colorspace;
 
// Forward decl
struct Colorspace;

using ColorRaw = SDL_Color;
 
// Forward decl
struct Color;

using FColorRaw = SDL_FColor;
 
// Forward decl
struct FColor;
 
// Forward decl
struct PaletteBase;
 
// Forward decl
struct Palette;

using PaletteRaw = SDL_Palette*;

using PaletteRawConst = const SDL_Palette*;

using PaletteRef = ResourceRefT<PaletteBase>;

using PaletteConstRef = ResourceConstRef<PaletteRaw, PaletteRawConst>;

using PixelFormatDetails = SDL_PixelFormatDetails;

constexpr Uint8 ALPHA_OPAQUE = SDL_ALPHA_OPAQUE;

constexpr float ALPHA_OPAQUE_FLOAT = SDL_ALPHA_OPAQUE_FLOAT;

constexpr Uint8 ALPHA_TRANSPARENT = SDL_ALPHA_TRANSPARENT;

constexpr float ALPHA_TRANSPARENT_FLOAT = SDL_ALPHA_TRANSPARENT_FLOAT;


using PixelType = SDL_PixelType;
 
constexpr PixelType PIXELTYPE_UNKNOWN = SDL_PIXELTYPE_UNKNOWN; 
 
constexpr PixelType PIXELTYPE_INDEX1 = SDL_PIXELTYPE_INDEX1; 
 
constexpr PixelType PIXELTYPE_INDEX4 = SDL_PIXELTYPE_INDEX4; 
 
constexpr PixelType PIXELTYPE_INDEX8 = SDL_PIXELTYPE_INDEX8; 
 
constexpr PixelType PIXELTYPE_PACKED8 = SDL_PIXELTYPE_PACKED8; 
 
constexpr PixelType PIXELTYPE_PACKED16 = SDL_PIXELTYPE_PACKED16; 
 
constexpr PixelType PIXELTYPE_PACKED32 = SDL_PIXELTYPE_PACKED32; 
 
constexpr PixelType PIXELTYPE_ARRAYU8 = SDL_PIXELTYPE_ARRAYU8; 
 
constexpr PixelType PIXELTYPE_ARRAYU16 = SDL_PIXELTYPE_ARRAYU16; 
 
constexpr PixelType PIXELTYPE_ARRAYU32 = SDL_PIXELTYPE_ARRAYU32; 
 
constexpr PixelType PIXELTYPE_ARRAYF16 = SDL_PIXELTYPE_ARRAYF16; 
 
constexpr PixelType PIXELTYPE_ARRAYF32 = SDL_PIXELTYPE_ARRAYF32; 
 
constexpr PixelType PIXELTYPE_INDEX2 = SDL_PIXELTYPE_INDEX2; 



using BitmapOrder = SDL_BitmapOrder;
 
constexpr BitmapOrder BITMAPORDER_NONE = SDL_BITMAPORDER_NONE; 
 
constexpr BitmapOrder BITMAPORDER_4321 = SDL_BITMAPORDER_4321; 
 
constexpr BitmapOrder BITMAPORDER_1234 = SDL_BITMAPORDER_1234; 



using PackedOrder = SDL_PackedOrder;
 
constexpr PackedOrder PACKEDORDER_NONE = SDL_PACKEDORDER_NONE; 
 
constexpr PackedOrder PACKEDORDER_XRGB = SDL_PACKEDORDER_XRGB; 
 
constexpr PackedOrder PACKEDORDER_RGBX = SDL_PACKEDORDER_RGBX; 
 
constexpr PackedOrder PACKEDORDER_ARGB = SDL_PACKEDORDER_ARGB; 
 
constexpr PackedOrder PACKEDORDER_RGBA = SDL_PACKEDORDER_RGBA; 
 
constexpr PackedOrder PACKEDORDER_XBGR = SDL_PACKEDORDER_XBGR; 
 
constexpr PackedOrder PACKEDORDER_BGRX = SDL_PACKEDORDER_BGRX; 
 
constexpr PackedOrder PACKEDORDER_ABGR = SDL_PACKEDORDER_ABGR; 
 
constexpr PackedOrder PACKEDORDER_BGRA = SDL_PACKEDORDER_BGRA; 



using ArrayOrder = SDL_ArrayOrder;
 
constexpr ArrayOrder ARRAYORDER_NONE = SDL_ARRAYORDER_NONE; 
 
constexpr ArrayOrder ARRAYORDER_RGB = SDL_ARRAYORDER_RGB; 
 
constexpr ArrayOrder ARRAYORDER_RGBA = SDL_ARRAYORDER_RGBA; 
 
constexpr ArrayOrder ARRAYORDER_ARGB = SDL_ARRAYORDER_ARGB; 
 
constexpr ArrayOrder ARRAYORDER_BGR = SDL_ARRAYORDER_BGR; 
 
constexpr ArrayOrder ARRAYORDER_BGRA = SDL_ARRAYORDER_BGRA; 
 
constexpr ArrayOrder ARRAYORDER_ABGR = SDL_ARRAYORDER_ABGR; 



using PackedLayout = SDL_PackedLayout;
 
constexpr PackedLayout PACKEDLAYOUT_NONE = SDL_PACKEDLAYOUT_NONE; 
 
constexpr PackedLayout PACKEDLAYOUT_332 = SDL_PACKEDLAYOUT_332; 
 
constexpr PackedLayout PACKEDLAYOUT_4444 = SDL_PACKEDLAYOUT_4444; 
 
constexpr PackedLayout PACKEDLAYOUT_1555 = SDL_PACKEDLAYOUT_1555; 
 
constexpr PackedLayout PACKEDLAYOUT_5551 = SDL_PACKEDLAYOUT_5551; 
 
constexpr PackedLayout PACKEDLAYOUT_565 = SDL_PACKEDLAYOUT_565; 
 
constexpr PackedLayout PACKEDLAYOUT_8888 = SDL_PACKEDLAYOUT_8888; 
 
constexpr PackedLayout PACKEDLAYOUT_2101010 =
  SDL_PACKEDLAYOUT_2101010; 
 
constexpr PackedLayout PACKEDLAYOUT_1010102 =
  SDL_PACKEDLAYOUT_1010102; 



class PixelFormat
{
  PixelFormatRaw m_format;
 
public:
  constexpr PixelFormat(PixelFormatRaw format = {}) noexcept
    : m_format(format)
  {
  }

  constexpr PixelFormat(PixelType type,
                        int order,
                        PackedLayout layout,
                        int bits,
                        int bytes);

  constexpr operator PixelFormatRaw() const noexcept { return m_format; }

  static PixelFormat ForMasks(int bpp,
                              Uint32 Rmask,
                              Uint32 Gmask,
                              Uint32 Bmask,
                              Uint32 Amask);

  constexpr Uint8 GetFlags() const;

  constexpr PixelType GetType() const;

  constexpr int GetOrder() const;

  constexpr PackedLayout GetLayout() const;

  constexpr int GetBitsPerPixel() const;

  constexpr int GetBytesPerPixel() const;

  constexpr bool IsIndexed() const;

  constexpr bool IsPacked() const;

  constexpr bool IsArray() const;

  constexpr bool Is10Bit() const;

  constexpr bool IsFloat() const;

  constexpr bool IsAlpha() const;

  constexpr bool IsFourCC() const;

  const char* GetName() const;

  void GetMasks(int* bpp,
                Uint32* Rmask,
                Uint32* Gmask,
                Uint32* Bmask,
                Uint32* Amask) const;

  const PixelFormatDetails& GetDetails() const;

  operator const PixelFormatDetails&() const;

  Uint32 Map(ColorRaw c, PaletteConstRef palette = {}) const;

  Color Get(Uint32 pixel, PaletteConstRef palette = {}) const;
};
 
constexpr PixelFormat PIXELFORMAT_UNKNOWN =
  SDL_PIXELFORMAT_UNKNOWN; 
 
constexpr PixelFormat PIXELFORMAT_INDEX1LSB =
  SDL_PIXELFORMAT_INDEX1LSB; 
 
constexpr PixelFormat PIXELFORMAT_INDEX1MSB =
  SDL_PIXELFORMAT_INDEX1MSB; 
 
constexpr PixelFormat PIXELFORMAT_INDEX2LSB =
  SDL_PIXELFORMAT_INDEX2LSB; 
 
constexpr PixelFormat PIXELFORMAT_INDEX2MSB =
  SDL_PIXELFORMAT_INDEX2MSB; 
 
constexpr PixelFormat PIXELFORMAT_INDEX4LSB =
  SDL_PIXELFORMAT_INDEX4LSB; 
 
constexpr PixelFormat PIXELFORMAT_INDEX4MSB =
  SDL_PIXELFORMAT_INDEX4MSB; 
 
constexpr PixelFormat PIXELFORMAT_INDEX8 = SDL_PIXELFORMAT_INDEX8; 
 
constexpr PixelFormat PIXELFORMAT_RGB332 = SDL_PIXELFORMAT_RGB332; 
 
constexpr PixelFormat PIXELFORMAT_XRGB4444 =
  SDL_PIXELFORMAT_XRGB4444; 
 
constexpr PixelFormat PIXELFORMAT_XBGR4444 =
  SDL_PIXELFORMAT_XBGR4444; 
 
constexpr PixelFormat PIXELFORMAT_XRGB1555 =
  SDL_PIXELFORMAT_XRGB1555; 
 
constexpr PixelFormat PIXELFORMAT_XBGR1555 =
  SDL_PIXELFORMAT_XBGR1555; 
 
constexpr PixelFormat PIXELFORMAT_ARGB4444 =
  SDL_PIXELFORMAT_ARGB4444; 
 
constexpr PixelFormat PIXELFORMAT_RGBA4444 =
  SDL_PIXELFORMAT_RGBA4444; 
 
constexpr PixelFormat PIXELFORMAT_ABGR4444 =
  SDL_PIXELFORMAT_ABGR4444; 
 
constexpr PixelFormat PIXELFORMAT_BGRA4444 =
  SDL_PIXELFORMAT_BGRA4444; 
 
constexpr PixelFormat PIXELFORMAT_ARGB1555 =
  SDL_PIXELFORMAT_ARGB1555; 
 
constexpr PixelFormat PIXELFORMAT_RGBA5551 =
  SDL_PIXELFORMAT_RGBA5551; 
 
constexpr PixelFormat PIXELFORMAT_ABGR1555 =
  SDL_PIXELFORMAT_ABGR1555; 
 
constexpr PixelFormat PIXELFORMAT_BGRA5551 =
  SDL_PIXELFORMAT_BGRA5551; 
 
constexpr PixelFormat PIXELFORMAT_RGB565 = SDL_PIXELFORMAT_RGB565; 
 
constexpr PixelFormat PIXELFORMAT_BGR565 = SDL_PIXELFORMAT_BGR565; 
 
constexpr PixelFormat PIXELFORMAT_RGB24 = SDL_PIXELFORMAT_RGB24; 
 
constexpr PixelFormat PIXELFORMAT_BGR24 = SDL_PIXELFORMAT_BGR24; 
 
constexpr PixelFormat PIXELFORMAT_XRGB8888 =
  SDL_PIXELFORMAT_XRGB8888; 
 
constexpr PixelFormat PIXELFORMAT_RGBX8888 =
  SDL_PIXELFORMAT_RGBX8888; 
 
constexpr PixelFormat PIXELFORMAT_XBGR8888 =
  SDL_PIXELFORMAT_XBGR8888; 
 
constexpr PixelFormat PIXELFORMAT_BGRX8888 =
  SDL_PIXELFORMAT_BGRX8888; 
 
constexpr PixelFormat PIXELFORMAT_ARGB8888 =
  SDL_PIXELFORMAT_ARGB8888; 
 
constexpr PixelFormat PIXELFORMAT_RGBA8888 =
  SDL_PIXELFORMAT_RGBA8888; 
 
constexpr PixelFormat PIXELFORMAT_ABGR8888 =
  SDL_PIXELFORMAT_ABGR8888; 
 
constexpr PixelFormat PIXELFORMAT_BGRA8888 =
  SDL_PIXELFORMAT_BGRA8888; 
 
constexpr PixelFormat PIXELFORMAT_XRGB2101010 =
  SDL_PIXELFORMAT_XRGB2101010; 
 
constexpr PixelFormat PIXELFORMAT_XBGR2101010 =
  SDL_PIXELFORMAT_XBGR2101010; 
 
constexpr PixelFormat PIXELFORMAT_ARGB2101010 =
  SDL_PIXELFORMAT_ARGB2101010; 
 
constexpr PixelFormat PIXELFORMAT_ABGR2101010 =
  SDL_PIXELFORMAT_ABGR2101010; 
 
constexpr PixelFormat PIXELFORMAT_RGB48 = SDL_PIXELFORMAT_RGB48; 
 
constexpr PixelFormat PIXELFORMAT_BGR48 = SDL_PIXELFORMAT_BGR48; 
 
constexpr PixelFormat PIXELFORMAT_RGBA64 = SDL_PIXELFORMAT_RGBA64; 
 
constexpr PixelFormat PIXELFORMAT_ARGB64 = SDL_PIXELFORMAT_ARGB64; 
 
constexpr PixelFormat PIXELFORMAT_BGRA64 = SDL_PIXELFORMAT_BGRA64; 
 
constexpr PixelFormat PIXELFORMAT_ABGR64 = SDL_PIXELFORMAT_ABGR64; 
 
constexpr PixelFormat PIXELFORMAT_RGB48_FLOAT =
  SDL_PIXELFORMAT_RGB48_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_BGR48_FLOAT =
  SDL_PIXELFORMAT_BGR48_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_RGBA64_FLOAT =
  SDL_PIXELFORMAT_RGBA64_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_ARGB64_FLOAT =
  SDL_PIXELFORMAT_ARGB64_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_BGRA64_FLOAT =
  SDL_PIXELFORMAT_BGRA64_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_ABGR64_FLOAT =
  SDL_PIXELFORMAT_ABGR64_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_RGB96_FLOAT =
  SDL_PIXELFORMAT_RGB96_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_BGR96_FLOAT =
  SDL_PIXELFORMAT_BGR96_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_RGBA128_FLOAT =
  SDL_PIXELFORMAT_RGBA128_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_ARGB128_FLOAT =
  SDL_PIXELFORMAT_ARGB128_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_BGRA128_FLOAT =
  SDL_PIXELFORMAT_BGRA128_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_ABGR128_FLOAT =
  SDL_PIXELFORMAT_ABGR128_FLOAT; 
 
constexpr PixelFormat PIXELFORMAT_YV12 =
  SDL_PIXELFORMAT_YV12; 
 
constexpr PixelFormat PIXELFORMAT_IYUV =
  SDL_PIXELFORMAT_IYUV; 
 
constexpr PixelFormat PIXELFORMAT_YUY2 =
  SDL_PIXELFORMAT_YUY2; 
 
constexpr PixelFormat PIXELFORMAT_UYVY =
  SDL_PIXELFORMAT_UYVY; 
 
constexpr PixelFormat PIXELFORMAT_YVYU =
  SDL_PIXELFORMAT_YVYU; 
 
constexpr PixelFormat PIXELFORMAT_NV12 =
  SDL_PIXELFORMAT_NV12; 
 
constexpr PixelFormat PIXELFORMAT_NV21 =
  SDL_PIXELFORMAT_NV21; 
 
constexpr PixelFormat PIXELFORMAT_P010 =
  SDL_PIXELFORMAT_P010; 
 
constexpr PixelFormat PIXELFORMAT_EXTERNAL_OES =
  SDL_PIXELFORMAT_EXTERNAL_OES; 
 
#if SDL_VERSION_ATLEAST(3, 2, 10)
 
constexpr PixelFormat PIXELFORMAT_MJPG = SDL_PIXELFORMAT_MJPG; 
 
#endif // SDL_VERSION_ATLEAST(3, 2, 10)
 
constexpr PixelFormat PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_RGBA32; 
 
constexpr PixelFormat PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_ARGB32; 
 
constexpr PixelFormat PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_BGRA32; 
 
constexpr PixelFormat PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_ABGR32; 
 
constexpr PixelFormat PIXELFORMAT_RGBX32 = SDL_PIXELFORMAT_RGBX32; 
 
constexpr PixelFormat PIXELFORMAT_XRGB32 = SDL_PIXELFORMAT_XRGB32; 
 
constexpr PixelFormat PIXELFORMAT_BGRX32 = SDL_PIXELFORMAT_BGRX32; 
 
constexpr PixelFormat PIXELFORMAT_XBGR32 = SDL_PIXELFORMAT_XBGR32; 


constexpr Uint32 DefinePixelFourCC(Uint8 A, Uint8 B, Uint8 C, Uint8 D)
{
  return SDL_DEFINE_PIXELFOURCC(A, B, C, D);
}

constexpr PixelFormat DefinePixelFormat(PixelType type,
                                        int order,
                                        PackedLayout layout,
                                        int bits,
                                        int bytes)
{
  return PixelFormat(type, order, layout, bits, bytes);
}
 
constexpr PixelFormat::PixelFormat(PixelType type,
                                   int order,
                                   PackedLayout layout,
                                   int bits,
                                   int bytes)
  : m_format(
      PixelFormatRaw(SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes)))
{
}

constexpr Uint8 PixelFormatFlags(PixelFormatRaw format)
{
  return SDL_PIXELFLAG(format);
}
 
constexpr Uint8 PixelFormat::GetFlags() const
{
  return SDL::PixelFormatFlags(m_format);
}

constexpr PixelType PixelFormatType(PixelFormatRaw format)
{
  return PixelType(SDL_PIXELTYPE(format));
}
 
constexpr PixelType PixelFormat::GetType() const
{
  return SDL::PixelFormatType(m_format);
}

constexpr int PixelFormatOrder(PixelFormatRaw format)
{
  return SDL_PIXELORDER(format);
}
 
constexpr int PixelFormat::GetOrder() const
{
  return SDL::PixelFormatOrder(m_format);
}

constexpr PackedLayout PixelFormatLayout(PixelFormatRaw format)
{
  return PackedLayout(SDL_PIXELLAYOUT(format));
}
 
constexpr PackedLayout PixelFormat::GetLayout() const
{
  return SDL::PixelFormatLayout(m_format);
}

constexpr int PixelFormatBitsPerPixel(PixelFormatRaw format)
{
  return SDL_BITSPERPIXEL(format);
}
 
constexpr int PixelFormat::GetBitsPerPixel() const
{
  return SDL::PixelFormatBitsPerPixel(m_format);
}

constexpr int PixelFormatBytesPerPixel(PixelFormatRaw format)
{
  return SDL_BYTESPERPIXEL(format);
}
 
constexpr int PixelFormat::GetBytesPerPixel() const
{
  return SDL::PixelFormatBytesPerPixel(m_format);
}

constexpr bool IsPixelFormatIndexed(PixelFormatRaw format)
{
  return SDL_ISPIXELFORMAT_INDEXED(format);
}
 
constexpr bool PixelFormat::IsIndexed() const
{
  return SDL::IsPixelFormatIndexed(m_format);
}

constexpr bool IsPixelFormatPacked(PixelFormatRaw format)
{
  return SDL_ISPIXELFORMAT_PACKED(format);
}
 
constexpr bool PixelFormat::IsPacked() const
{
  return SDL::IsPixelFormatPacked(m_format);
}

constexpr bool IsPixelFormatArray(PixelFormatRaw format)
{
  return SDL_ISPIXELFORMAT_ARRAY(format);
}
 
constexpr bool PixelFormat::IsArray() const
{
  return SDL::IsPixelFormatArray(m_format);
}

constexpr bool IsPixelFormat10Bit(PixelFormatRaw format)
{
  return SDL_ISPIXELFORMAT_10BIT(format);
}
 
constexpr bool PixelFormat::Is10Bit() const
{
  return SDL::IsPixelFormat10Bit(m_format);
}

constexpr bool IsPixelFormatFloat(PixelFormatRaw format)
{
  return SDL_ISPIXELFORMAT_FLOAT(format);
}
 
constexpr bool PixelFormat::IsFloat() const
{
  return SDL::IsPixelFormatFloat(m_format);
}


constexpr bool IsPixelFormatAlpha(PixelFormatRaw format)
{
  return SDL_ISPIXELFORMAT_ALPHA(format);
}
 
constexpr bool PixelFormat::IsAlpha() const
{
  return SDL::IsPixelFormatAlpha(m_format);
}

constexpr bool IsPixelFormatFourCC(PixelFormatRaw format)
{
  return SDL_ISPIXELFORMAT_FOURCC(format);
}
 
constexpr bool PixelFormat::IsFourCC() const
{
  return SDL::IsPixelFormatFourCC(m_format);
}

using ColorType = SDL_ColorType;
 
constexpr ColorType COLOR_TYPE_UNKNOWN =
  SDL_COLOR_TYPE_UNKNOWN; 
 
constexpr ColorType COLOR_TYPE_RGB = SDL_COLOR_TYPE_RGB; 
 
constexpr ColorType COLOR_TYPE_YCBCR =
  SDL_COLOR_TYPE_YCBCR; 



using ColorRange = SDL_ColorRange;
 
constexpr ColorRange COLOR_RANGE_UNKNOWN =
  SDL_COLOR_RANGE_UNKNOWN; 

constexpr ColorRange COLOR_RANGE_LIMITED = SDL_COLOR_RANGE_LIMITED;

constexpr ColorRange COLOR_RANGE_FULL = SDL_COLOR_RANGE_FULL;



using ColorPrimaries = SDL_ColorPrimaries;
 
constexpr ColorPrimaries COLOR_PRIMARIES_UNKNOWN =
  SDL_COLOR_PRIMARIES_UNKNOWN; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_BT709 =
  SDL_COLOR_PRIMARIES_BT709; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_UNSPECIFIED =
  SDL_COLOR_PRIMARIES_UNSPECIFIED; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_BT470M =
  SDL_COLOR_PRIMARIES_BT470M; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_BT470BG =
  SDL_COLOR_PRIMARIES_BT470BG; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_BT601 =
  SDL_COLOR_PRIMARIES_BT601; 

constexpr ColorPrimaries COLOR_PRIMARIES_SMPTE240 =
  SDL_COLOR_PRIMARIES_SMPTE240;
 
constexpr ColorPrimaries COLOR_PRIMARIES_GENERIC_FILM =
  SDL_COLOR_PRIMARIES_GENERIC_FILM; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_BT2020 =
  SDL_COLOR_PRIMARIES_BT2020; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_XYZ =
  SDL_COLOR_PRIMARIES_XYZ; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_SMPTE431 =
  SDL_COLOR_PRIMARIES_SMPTE431; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_SMPTE432 =
  SDL_COLOR_PRIMARIES_SMPTE432; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_EBU3213 =
  SDL_COLOR_PRIMARIES_EBU3213; 
 
constexpr ColorPrimaries COLOR_PRIMARIES_CUSTOM =
  SDL_COLOR_PRIMARIES_CUSTOM; 



using TransferCharacteristics = SDL_TransferCharacteristics;
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_UNKNOWN =
  SDL_TRANSFER_CHARACTERISTICS_UNKNOWN; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_BT709 =
  SDL_TRANSFER_CHARACTERISTICS_BT709; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_UNSPECIFIED =
  SDL_TRANSFER_CHARACTERISTICS_UNSPECIFIED; 

constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_GAMMA22 =
  SDL_TRANSFER_CHARACTERISTICS_GAMMA22;
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_GAMMA28 =
  SDL_TRANSFER_CHARACTERISTICS_GAMMA28; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_BT601 =
  SDL_TRANSFER_CHARACTERISTICS_BT601; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_SMPTE240 =
  SDL_TRANSFER_CHARACTERISTICS_SMPTE240; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_LINEAR =
  SDL_TRANSFER_CHARACTERISTICS_LINEAR; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_LOG100 =
  SDL_TRANSFER_CHARACTERISTICS_LOG100; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_LOG100_SQRT10 =
  SDL_TRANSFER_CHARACTERISTICS_LOG100_SQRT10; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_IEC61966 =
  SDL_TRANSFER_CHARACTERISTICS_IEC61966; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_BT1361 =
  SDL_TRANSFER_CHARACTERISTICS_BT1361; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_SRGB =
  SDL_TRANSFER_CHARACTERISTICS_SRGB; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_BT2020_10BIT =
  SDL_TRANSFER_CHARACTERISTICS_BT2020_10BIT; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_BT2020_12BIT =
  SDL_TRANSFER_CHARACTERISTICS_BT2020_12BIT; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_PQ =
  SDL_TRANSFER_CHARACTERISTICS_PQ; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_SMPTE428 =
  SDL_TRANSFER_CHARACTERISTICS_SMPTE428; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_HLG =
  SDL_TRANSFER_CHARACTERISTICS_HLG; 
 
constexpr TransferCharacteristics TRANSFER_CHARACTERISTICS_CUSTOM =
  SDL_TRANSFER_CHARACTERISTICS_CUSTOM; 



using MatrixCoefficients = SDL_MatrixCoefficients;
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_IDENTITY =
  SDL_MATRIX_COEFFICIENTS_IDENTITY; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_BT709 =
  SDL_MATRIX_COEFFICIENTS_BT709; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_UNSPECIFIED =
  SDL_MATRIX_COEFFICIENTS_UNSPECIFIED; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_FCC =
  SDL_MATRIX_COEFFICIENTS_FCC; 

constexpr MatrixCoefficients MATRIX_COEFFICIENTS_BT470BG =
  SDL_MATRIX_COEFFICIENTS_BT470BG;
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_BT601 =
  SDL_MATRIX_COEFFICIENTS_BT601; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_SMPTE240 =
  SDL_MATRIX_COEFFICIENTS_SMPTE240; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_YCGCO =
  SDL_MATRIX_COEFFICIENTS_YCGCO; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_BT2020_NCL =
  SDL_MATRIX_COEFFICIENTS_BT2020_NCL; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_BT2020_CL =
  SDL_MATRIX_COEFFICIENTS_BT2020_CL; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_SMPTE2085 =
  SDL_MATRIX_COEFFICIENTS_SMPTE2085; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL =
  SDL_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_CHROMA_DERIVED_CL =
  SDL_MATRIX_COEFFICIENTS_CHROMA_DERIVED_CL; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_ICTCP =
  SDL_MATRIX_COEFFICIENTS_ICTCP; 
 
constexpr MatrixCoefficients MATRIX_COEFFICIENTS_CUSTOM =
  SDL_MATRIX_COEFFICIENTS_CUSTOM; 



using ChromaLocation = SDL_ChromaLocation;
 
constexpr ChromaLocation CHROMA_LOCATION_NONE =
  SDL_CHROMA_LOCATION_NONE; 

constexpr ChromaLocation CHROMA_LOCATION_LEFT = SDL_CHROMA_LOCATION_LEFT;

constexpr ChromaLocation CHROMA_LOCATION_CENTER = SDL_CHROMA_LOCATION_CENTER;

constexpr ChromaLocation CHROMA_LOCATION_TOPLEFT = SDL_CHROMA_LOCATION_TOPLEFT;



class Colorspace
{
  ColorspaceRaw m_cspace;
 
public:
  constexpr Colorspace(ColorspaceRaw cspace = {}) noexcept
    : m_cspace(cspace)
  {
  }

  constexpr Colorspace(ColorType type,
                       ColorRange range,
                       ColorPrimaries primaries,
                       TransferCharacteristics transfer,
                       MatrixCoefficients matrix,
                       ChromaLocation chroma);

  constexpr operator ColorspaceRaw() const noexcept { return m_cspace; }

  constexpr ColorType GetType() const;

  constexpr ColorRange GetRange() const;

  constexpr ChromaLocation GetChroma() const;

  constexpr ColorPrimaries GetPrimaries() const;

  constexpr TransferCharacteristics GetTransfer() const;

  constexpr MatrixCoefficients GetMatrix() const;

  constexpr bool IsMatrixBT601() const;

  constexpr bool IsMatrixBT709() const;

  constexpr bool IsMatrixBT2020_NCL() const;

  constexpr bool IsLimitedRange() const;

  constexpr bool IsFullRange() const;
};
 
constexpr Colorspace COLORSPACE_UNKNOWN = SDL_COLORSPACE_UNKNOWN; 

constexpr Colorspace COLORSPACE_SRGB = SDL_COLORSPACE_SRGB;

constexpr Colorspace COLORSPACE_SRGB_LINEAR = SDL_COLORSPACE_SRGB_LINEAR;

constexpr Colorspace COLORSPACE_HDR10 = SDL_COLORSPACE_HDR10;

constexpr Colorspace COLORSPACE_JPEG = SDL_COLORSPACE_JPEG;

constexpr Colorspace COLORSPACE_BT601_LIMITED = SDL_COLORSPACE_BT601_LIMITED;

constexpr Colorspace COLORSPACE_BT601_FULL = SDL_COLORSPACE_BT601_FULL;

constexpr Colorspace COLORSPACE_BT709_LIMITED = SDL_COLORSPACE_BT709_LIMITED;

constexpr Colorspace COLORSPACE_BT709_FULL = SDL_COLORSPACE_BT709_FULL;

constexpr Colorspace COLORSPACE_BT2020_LIMITED = SDL_COLORSPACE_BT2020_LIMITED;

constexpr Colorspace COLORSPACE_BT2020_FULL = SDL_COLORSPACE_BT2020_FULL;

constexpr Colorspace COLORSPACE_RGB_DEFAULT = SDL_COLORSPACE_RGB_DEFAULT;

constexpr Colorspace COLORSPACE_YUV_DEFAULT = SDL_COLORSPACE_YUV_DEFAULT;


constexpr Colorspace DefineColorspace(ColorType type,
                                      ColorRange range,
                                      ColorPrimaries primaries,
                                      TransferCharacteristics transfer,
                                      MatrixCoefficients matrix,
                                      ChromaLocation chroma)
{
  return Colorspace(type, range, primaries, transfer, matrix, chroma);
}
 
constexpr Colorspace::Colorspace(ColorType type,
                                 ColorRange range,
                                 ColorPrimaries primaries,
                                 TransferCharacteristics transfer,
                                 MatrixCoefficients matrix,
                                 ChromaLocation chroma)
  : m_cspace(ColorspaceRaw(
      SDL_DEFINE_COLORSPACE(type, range, primaries, transfer, matrix, chroma)))
{
}

constexpr ColorType ColorspaceType(ColorspaceRaw cspace)
{
  return SDL_COLORSPACETYPE(cspace);
}
 
constexpr ColorType Colorspace::GetType() const
{
  return SDL::ColorspaceType(m_cspace);
}

constexpr ColorRange ColorspaceRange(ColorspaceRaw cspace)
{
  return SDL_COLORSPACERANGE(cspace);
}
 
constexpr ColorRange Colorspace::GetRange() const
{
  return SDL::ColorspaceRange(m_cspace);
}

constexpr ChromaLocation ColorspaceChroma(ColorspaceRaw cspace)
{
  return SDL_COLORSPACECHROMA(cspace);
}
 
constexpr ChromaLocation Colorspace::GetChroma() const
{
  return SDL::ColorspaceChroma(m_cspace);
}

constexpr ColorPrimaries ColorspacePrimaries(ColorspaceRaw cspace)
{
  return SDL_COLORSPACEPRIMARIES(cspace);
}
 
constexpr ColorPrimaries Colorspace::GetPrimaries() const
{
  return SDL::ColorspacePrimaries(m_cspace);
}

constexpr TransferCharacteristics ColorspaceTransfer(ColorspaceRaw cspace)
{
  return SDL_COLORSPACETRANSFER(cspace);
}
 
constexpr TransferCharacteristics Colorspace::GetTransfer() const
{
  return SDL::ColorspaceTransfer(m_cspace);
}

constexpr MatrixCoefficients ColorspaceMatrix(ColorspaceRaw cspace)
{
  return SDL_COLORSPACEMATRIX(cspace);
}
 
constexpr MatrixCoefficients Colorspace::GetMatrix() const
{
  return SDL::ColorspaceMatrix(m_cspace);
}

constexpr bool IsColorspaceMatrixBT601(ColorspaceRaw cspace)
{
  return SDL_ISCOLORSPACE_MATRIX_BT601(cspace);
}
 
constexpr bool Colorspace::IsMatrixBT601() const
{
  return SDL::IsColorspaceMatrixBT601(m_cspace);
}

constexpr bool IsColorspaceMatrixBT709(ColorspaceRaw cspace)
{
  return SDL_ISCOLORSPACE_MATRIX_BT709(cspace);
}
 
constexpr bool Colorspace::IsMatrixBT709() const
{
  return SDL::IsColorspaceMatrixBT709(m_cspace);
}

constexpr bool IsColorspaceMatrixBT2020_NCL(ColorspaceRaw cspace)
{
  return SDL_ISCOLORSPACE_MATRIX_BT2020_NCL(cspace);
}
 
constexpr bool Colorspace::IsMatrixBT2020_NCL() const
{
  return SDL::IsColorspaceMatrixBT2020_NCL(m_cspace);
}

constexpr bool IsColorspaceLimitedRange(ColorspaceRaw cspace)
{
  return SDL_ISCOLORSPACE_LIMITED_RANGE(cspace);
}
 
constexpr bool Colorspace::IsLimitedRange() const
{
  return SDL::IsColorspaceLimitedRange(m_cspace);
}

constexpr bool IsColorspaceFullRange(ColorspaceRaw cspace)
{
  return SDL_ISCOLORSPACE_FULL_RANGE(cspace);
}
 
constexpr bool Colorspace::IsFullRange() const
{
  return SDL::IsColorspaceFullRange(m_cspace);
}

constexpr bool operator==(ColorRaw lhs, ColorRaw rhs) noexcept
{
  return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && lhs.a == rhs.a;
}

constexpr bool operator==(const FColorRaw& lhs, const FColorRaw& rhs) noexcept
{
  return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && lhs.a == rhs.a;
}

constexpr auto operator<=>(ColorRaw lhs, ColorRaw rhs) noexcept
{
  if (lhs.r != rhs.r) return lhs.r <=> rhs.r;
  if (lhs.g != rhs.g) return lhs.g <=> rhs.g;
  if (lhs.b != rhs.b) return lhs.b <=> rhs.b;
  return lhs.a <=> rhs.a;
}

constexpr auto operator<=>(const FColorRaw& lhs, const FColorRaw& rhs) noexcept
{
  if (lhs.r != rhs.r) return lhs.r <=> rhs.r;
  if (lhs.g != rhs.g) return lhs.g <=> rhs.g;
  if (lhs.b != rhs.b) return lhs.b <=> rhs.b;
  return lhs.a <=> rhs.a;
}

struct Color : ColorRaw
{
  constexpr Color(ColorRaw color = {}) noexcept
    : ColorRaw(color)
  {
  }

  constexpr Color(Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255) noexcept
    : ColorRaw{r, g, b, a}
  {
  }

  constexpr Uint8 GetR() const noexcept { return r; }

  constexpr Color& SetR(Uint8 newR) noexcept
  {
    r = newR;
    return *this;
  }

  constexpr Uint8 GetG() const noexcept { return g; }

  constexpr Color& SetG(Uint8 newG) noexcept
  {
    g = newG;
    return *this;
  }

  constexpr Uint8 GetB() const noexcept { return b; }

  constexpr Color& SetB(Uint8 newB) noexcept
  {
    b = newB;
    return *this;
  }

  constexpr Uint8 GetA() const noexcept { return a; }

  constexpr Color& SetA(Uint8 newA) noexcept
  {
    a = newA;
    return *this;
  }

  Uint32 Map(const PixelFormatDetails& format, PaletteConstRef palette) const;

  static Color Get(Uint32 pixel,
                   const PixelFormatDetails& format,
                   PaletteConstRef palette = {});
};

struct FColor : FColorRaw
{
  constexpr FColor(const FColorRaw& color = {}) noexcept
    : FColorRaw(color)
  {
  }

  constexpr FColor(float r, float g, float b, float a = 1) noexcept
    : FColorRaw{r, g, b, a}
  {
  }

  constexpr float GetR() const noexcept { return r; }

  constexpr FColor& SetR(float newR) noexcept
  {
    r = newR;
    return *this;
  }

  constexpr float GetG() const noexcept { return g; }

  constexpr FColor& SetG(float newG) noexcept
  {
    g = newG;
    return *this;
  }

  constexpr float GetB() const noexcept { return b; }

  constexpr FColor& SetB(float newB) noexcept
  {
    b = newB;
    return *this;
  }

  constexpr float GetA() const noexcept { return a; }

  constexpr FColor& SetA(float newA) noexcept
  {
    a = newA;
    return *this;
  }
};

class PaletteIndex
{
  PaletteRaw m_palette;
 
  int m_index;
 
public:
  constexpr PaletteIndex(PaletteRaw palette, int index)
    : m_palette{palette}
    , m_index{index}
  {
  }

  constexpr explicit operator bool() const
  {
    return m_palette && m_index >= 0 && m_index < m_palette->ncolors;
  }

  constexpr operator ColorRaw() const
  {
    return *this ? m_palette->colors[m_index] : ColorRaw{};
  }

  PaletteIndex& operator=(ColorRaw color);
};

struct PaletteBase : ResourceBaseT<PaletteRaw, PaletteRawConst>
{
  using ResourceBaseT::ResourceBaseT;

  constexpr operator PaletteConstRef() const noexcept { return get(); }

  void Destroy();

  constexpr const ColorRaw* data() const { return get()->colors; }

  constexpr int size() const { return get()->ncolors; }

  constexpr ColorRaw operator[](int index) const
  {
    return get()->colors[index];
  }

  constexpr PaletteIndex operator[](int index)
  {
    return PaletteIndex{get(), index};
  }

  void SetColors(SpanRef<const ColorRaw> colors, int firstcolor = 0);
};

struct Palette : PaletteBase
{
  using PaletteBase::PaletteBase;

  constexpr explicit Palette(PaletteRaw resource) noexcept
    : PaletteBase(resource)
  {
  }

  constexpr Palette(const Palette& other)
    : Palette(borrow(other.get()))
  {
  }

  constexpr Palette(Palette&& other) noexcept
    : Palette(other.release())
  {
  }

  Palette(int ncolors);

  static Palette borrow(PaletteRaw resource)
  {
    if (resource) {
      ++resource->refcount;
      return Palette(resource);
    }
    return {};
  }

  ~Palette() { SDL_DestroyPalette(get()); }

  constexpr Palette& operator=(Palette&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  Palette& operator=(const Palette& other)
  {
    if (get() != other.get()) {
      Palette tmp(other);
      swap(*this, tmp);
    }
    return *this;
  }
};

inline const char* GetPixelFormatName(PixelFormatRaw format)
{
  return SDL_GetPixelFormatName(format);
}
 
inline const char* PixelFormat::GetName() const
{
  return SDL::GetPixelFormatName(m_format);
}

inline void GetMasksForPixelFormat(PixelFormatRaw format,
                                   int* bpp,
                                   Uint32* Rmask,
                                   Uint32* Gmask,
                                   Uint32* Bmask,
                                   Uint32* Amask)
{
  CheckError(
    SDL_GetMasksForPixelFormat(format, bpp, Rmask, Gmask, Bmask, Amask));
}
 
inline void PixelFormat::GetMasks(int* bpp,
                                  Uint32* Rmask,
                                  Uint32* Gmask,
                                  Uint32* Bmask,
                                  Uint32* Amask) const
{
  SDL::GetMasksForPixelFormat(m_format, bpp, Rmask, Gmask, Bmask, Amask);
}

inline PixelFormat GetPixelFormatForMasks(int bpp,
                                          Uint32 Rmask,
                                          Uint32 Gmask,
                                          Uint32 Bmask,
                                          Uint32 Amask)
{
  return SDL_GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask);
}
 
inline PixelFormat PixelFormat::ForMasks(int bpp,
                                         Uint32 Rmask,
                                         Uint32 Gmask,
                                         Uint32 Bmask,
                                         Uint32 Amask)
{
  return SDL::GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask);
}

inline const PixelFormatDetails& GetPixelFormatDetails(PixelFormatRaw format)
{
  return *CheckError(SDL_GetPixelFormatDetails(format));
}
 
inline const PixelFormatDetails& PixelFormat::GetDetails() const
{
  return SDL::GetPixelFormatDetails(m_format);
}
 
inline PixelFormat::operator const PixelFormatDetails&() const
{
  return GetDetails();
}

inline Palette CreatePalette(int ncolors) { return Palette(ncolors); }
 
inline Palette::Palette(int ncolors)
  : Palette(CheckError(SDL_CreatePalette(ncolors)))
{
}

inline void SetPaletteColors(PaletteRef palette,
                             SpanRef<const ColorRaw> colors,
                             int firstcolor = 0)
{
  CheckError(SDL_SetPaletteColors(
    palette, colors.data(), firstcolor, narrowS32(colors.size())));
}
 
inline void PaletteBase::SetColors(SpanRef<const ColorRaw> colors,
                                   int firstcolor)
{
  SDL::SetPaletteColors(get(), colors, firstcolor);
}
 
inline PaletteIndex& PaletteIndex::operator=(ColorRaw color)
{
  m_palette->colors[m_index] = color;
  return *this;
}

inline void DestroyPalette(PaletteRaw palette) { SDL_DestroyPalette(palette); }
 
inline void PaletteBase::Destroy() { DestroyPalette(release()); }

inline Uint32 MapRGB(const PixelFormatDetails& format,
                     PaletteConstRef palette,
                     Uint8 r,
                     Uint8 g,
                     Uint8 b)
{
  return SDL_MapRGB(&format, palette, r, g, b);
}

inline Uint32 MapRGBA(const PixelFormatDetails& format,
                      Uint8 r,
                      Uint8 g,
                      Uint8 b,
                      Uint8 a,
                      PaletteConstRef palette = {})
{
  return SDL_MapRGBA(&format, palette, r, g, b, a);
}

inline Uint32 MapColor(const PixelFormatDetails& format,
                       ColorRaw c,
                       PaletteConstRef palette = {})
{
  return SDL_MapRGBA(&format, palette, c.r, c.g, c.b, c.a);
}
 
inline Uint32 Color::Map(const PixelFormatDetails& format,
                         PaletteConstRef palette) const
{
  return MapColor(format, *this, palette);
}
 
inline Uint32 PixelFormat::Map(ColorRaw c, PaletteConstRef palette) const
{
  return MapColor(GetDetails(), c, palette);
}

inline void GetRGB(Uint32 pixelvalue,
                   const PixelFormatDetails& format,
                   PaletteConstRef palette,
                   Uint8* r,
                   Uint8* g,
                   Uint8* b)
{
  SDL_GetRGB(pixelvalue, &format, palette, r, g, b);
}

inline void GetRGBA(Uint32 pixelvalue,
                    const PixelFormatDetails& format,
                    PaletteConstRef palette,
                    Uint8* r,
                    Uint8* g,
                    Uint8* b,
                    Uint8* a)
{
  SDL_GetRGBA(pixelvalue, &format, palette, r, g, b, a);
}

inline Color GetColor(Uint32 pixel,
                      const PixelFormatDetails& format,
                      PaletteConstRef palette = {})
{
  Color c;
  GetRGBA(pixel, format, palette, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline Color Color::Get(Uint32 pixel,
                        const PixelFormatDetails& format,
                        PaletteConstRef palette)
{
  return GetColor(pixel, format, palette);
}
 
inline Color PixelFormat::Get(Uint32 pixel, PaletteConstRef palette) const
{
  return GetColor(pixel, GetDetails(), palette);
}

 
} // namespace SDL
 
#endif /* SDL3PP_PIXELS_H_ */