SDL3pp_pixels.h

#ifndef SDL3PP_PIXELS_H_
#define SDL3PP_PIXELS_H_
 
#include <SDL3/SDL_pixels.h>
#include "SDL3pp_error.h"
#include "SDL3pp_spanRef.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 Palette;
 
using PaletteRaw = SDL_Palette*;
 
// Forward decl
struct PaletteRef;
 
struct PaletteParam
{
  PaletteRaw value; 
 
  constexpr PaletteParam(PaletteRaw value)
    : value(value)
  {
  }
 
  constexpr PaletteParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const PaletteParam& other) const = default;
 
  constexpr operator PaletteRaw() const { return value; }
 
  constexpr auto operator->() { return value; }
};
 
struct PaletteConstParam
{
  const PaletteRaw value; 
 
  constexpr PaletteConstParam(const PaletteRaw value)
    : value(value)
  {
  }
 
  constexpr PaletteConstParam(PaletteParam value)
    : value(value.value)
  {
  }
 
  constexpr PaletteConstParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const PaletteConstParam& other) const = default;
 
  constexpr operator const PaletteRaw() const { return value; }
 
  constexpr auto operator->() { return value; }
};
 
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)
    : m_format(PixelFormatRaw(
        SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, 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, PaletteConstParam palette = {}) const;
 
  Color Get(Uint32 pixel, PaletteConstParam 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 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)
    : m_cspace(ColorspaceRaw(SDL_DEFINE_COLORSPACE(type,
                                                   range,
                                                   primaries,
                                                   transfer,
                                                   matrix,
                                                   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 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, PaletteConstParam palette) const;
 
  static Color Get(Uint32 pixel,
                   const PixelFormatDetails& format,
                   PaletteConstParam 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 Palette
{
  PaletteRaw m_resource = nullptr;
 
public:
  constexpr Palette(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Palette(const PaletteRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Palette(const Palette& other)
    : m_resource(other.m_resource)
  {
    ++m_resource->refcount;
  }
 
  constexpr Palette(Palette&& other) noexcept
    : Palette(other.release())
  {
  }
 
  Palette(int ncolors)
    : m_resource(CheckError(SDL_CreatePalette(ncolors)))
  {
  }
 
  static constexpr Palette Borrow(PaletteParam resource)
  {
    if (resource) {
      ++resource.value->refcount;
      return Palette(resource.value);
    }
    return {};
  }
 
  constexpr const PaletteRaw operator->() const noexcept { return m_resource; }
 
  constexpr PaletteRaw operator->() noexcept { return m_resource; }
 
  ~Palette() { SDL_DestroyPalette(m_resource); }
 
  constexpr Palette& operator=(Palette&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr Palette& operator=(const Palette& other) noexcept = default;
 
  constexpr PaletteRaw get() const noexcept { return m_resource; }
 
  constexpr PaletteRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Palette& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator PaletteParam() const noexcept { return {m_resource}; }
 
  void Destroy();
 
  constexpr const ColorRaw* data() const { return m_resource->colors; }
 
  constexpr int size() const { return m_resource->ncolors; }
 
  constexpr ColorRaw operator[](int index) const
  {
    return m_resource->colors[index];
  }
 
  void SetColors(SpanRef<const ColorRaw> colors, int firstcolor = 0);
};
 
struct PaletteRef : Palette
{
  using Palette::Palette;
 
  PaletteRef(PaletteRaw resource) noexcept
    : Palette(Borrow(resource))
  {
  }
 
  PaletteRef(Palette resource) noexcept
    : Palette(std::move(resource))
  {
  }
};
 
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 void SetPaletteColors(PaletteParam palette,
                             SpanRef<const ColorRaw> colors,
                             int firstcolor = 0)
{
  CheckError(
    SDL_SetPaletteColors(palette, colors.data(), firstcolor, colors.size()));
}
 
inline void Palette::SetColors(SpanRef<const ColorRaw> colors, int firstcolor)
{
  SDL::SetPaletteColors(m_resource, colors, firstcolor);
}
 
inline void DestroyPalette(PaletteRaw palette) { SDL_DestroyPalette(palette); }
 
inline void Palette::Destroy() { DestroyPalette(release()); }
 
inline Uint32 MapRGB(const PixelFormatDetails& format,
                     PaletteConstParam 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,
                      PaletteConstParam palette = {})
{
  return SDL_MapRGBA(&format, palette, r, g, b, a);
}
 
inline Uint32 MapColor(const PixelFormatDetails& format,
                       ColorRaw c,
                       PaletteConstParam palette = {})
{
  return SDL_MapRGBA(&format, palette, c.r, c.g, c.b, c.a);
}
 
inline Uint32 Color::Map(const PixelFormatDetails& format,
                         PaletteConstParam palette) const
{
  return MapColor(format, *this, palette);
}
 
inline Uint32 PixelFormat::Map(ColorRaw c, PaletteConstParam palette) const
{
  return MapColor(GetDetails(), c, palette);
}
 
inline void GetRGB(Uint32 pixelvalue,
                   const PixelFormatDetails& format,
                   PaletteConstParam palette,
                   Uint8* r,
                   Uint8* g,
                   Uint8* b)
{
  SDL_GetRGB(pixelvalue, &format, palette, r, g, b);
}
 
inline void GetRGBA(Uint32 pixelvalue,
                    const PixelFormatDetails& format,
                    PaletteConstParam 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,
                      PaletteConstParam 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,
                        PaletteConstParam palette)
{
  return GetColor(pixel, format, palette);
}
 
inline Color PixelFormat::Get(Uint32 pixel, PaletteConstParam palette) const
{
  return GetColor(pixel, GetDetails(), palette);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_PIXELS_H_ */