SDL3pp_pixels.h

#ifndef SDL3PP_PIXELS_H_
#define SDL3PP_PIXELS_H_
 
#include <span>
#include <SDL3/SDL_assert.h>
#include <SDL3/SDL_pixels.h>
#include <SDL3/SDL_version.h>
#include "SDL3pp_spanRef.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct Color;
 
// Forward decl
struct PaletteBase;
 
// Forward decl
struct PaletteRef;
 
// Forward decl
struct Palette;
 
#ifdef SDL3PP_DOC
 
#define SDL_ALPHA_OPAQUE 255
 
#define SDL_ALPHA_OPAQUE_FLOAT 1.0f
 
#define SDL_ALPHA_TRANSPARENT 0
 
#define SDL_ALPHA_TRANSPARENT_FLOAT 0.0f
 
#endif // SDL3PP_DOC
 
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; 
 
 
using PixelFormatDetails = SDL_PixelFormatDetails;
 
#ifdef SDL3PP_DOC
 
#define SDL_DEFINE_PIXELFOURCC(A, B, C, D) SDL_FOURCC(A, B, C, D)
 
#define SDL_PIXELFLAG(format) (((format) >> 28) & 0x0F)
 
#endif // SDL3PP_DOC
 
class PixelFormat
{
  SDL_PixelFormat m_format;
 
public:
  constexpr PixelFormat(SDL_PixelFormat format = {})
    : m_format(format)
  {
  }
 
  constexpr PixelFormat(SDL_PixelType type,
                        int order,
                        SDL_PackedLayout layout,
                        int bits,
                        int bytes)
    : m_format(SDL_PixelFormat(
        SDL_DEFINE_PIXELFORMAT(type, order, layout, bits, bytes)))
  {
  }
 
  constexpr bool operator==(const PixelFormat& other) const = default;
 
  constexpr bool operator==(SDL_PixelFormat format) const
  {
    return operator==(PixelFormat(format));
  }
 
  constexpr operator SDL_PixelFormat() const { return m_format; }
 
  constexpr explicit operator bool() const { return m_format != 0; }
 
  constexpr PixelType GetType() const
  {
    return PixelType(SDL_PIXELTYPE(m_format));
  }
 
  constexpr int GetOrder() const { return SDL_PIXELORDER(m_format); }
 
  constexpr PackedLayout GetLayout() const
  {
    return PackedLayout(SDL_PIXELLAYOUT(m_format));
  }
 
  constexpr int GetBitsPerPixel() const { return SDL_BITSPERPIXEL(m_format); }
 
  constexpr int GetBytesPerPixel() const { return SDL_BYTESPERPIXEL(m_format); }
 
  constexpr bool IsIndexed() const
  {
    return SDL_ISPIXELFORMAT_INDEXED(m_format);
  }
 
  constexpr bool IsPacked() const { return SDL_ISPIXELFORMAT_PACKED(m_format); }
 
  constexpr bool IsArray() const { return SDL_ISPIXELFORMAT_ARRAY(m_format); }
 
  constexpr bool Is10Bit() const { return SDL_ISPIXELFORMAT_10BIT(m_format); }
 
  constexpr bool IsFloat() const { return SDL_ISPIXELFORMAT_FLOAT(m_format); }
 
  constexpr bool IsAlpha() const { return SDL_ISPIXELFORMAT_ALPHA(m_format); }
 
  constexpr bool IsFourCC() const { return SDL_ISPIXELFORMAT_FOURCC(m_format); }
 
  const char* GetName() const { return SDL_GetPixelFormatName(m_format); }
 
  void GetMasks(int* bpp,
                Uint32* Rmask,
                Uint32* Gmask,
                Uint32* Bmask,
                Uint32* Amask) const
  {
    CheckError(
      SDL_GetMasksForPixelFormat(m_format, bpp, Rmask, Gmask, Bmask, Amask));
  }
 
  static PixelFormat ForMasks(int bpp,
                              Uint32 Rmask,
                              Uint32 Gmask,
                              Uint32 Bmask,
                              Uint32 Amask)
  {
    return SDL_GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask);
  }
 
  const PixelFormatDetails* GetDetails() const
  {
    return SDL_GetPixelFormatDetails(m_format);
  }
 
  inline Uint32 Map(Color color, PaletteRef palette) const;
 
  inline Color Get(Uint32 pixel, PaletteRef palette) const;
};
 
constexpr SDL_PixelFormat PIXELFORMAT_UNKNOWN =
  SDL_PIXELFORMAT_UNKNOWN; 
 
constexpr SDL_PixelFormat PIXELFORMAT_INDEX1LSB =
  SDL_PIXELFORMAT_INDEX1LSB; 
 
constexpr SDL_PixelFormat PIXELFORMAT_INDEX1MSB =
  SDL_PIXELFORMAT_INDEX1MSB; 
 
constexpr SDL_PixelFormat PIXELFORMAT_INDEX2LSB =
  SDL_PIXELFORMAT_INDEX2LSB; 
 
constexpr SDL_PixelFormat PIXELFORMAT_INDEX2MSB =
  SDL_PIXELFORMAT_INDEX2MSB; 
 
constexpr SDL_PixelFormat PIXELFORMAT_INDEX4LSB =
  SDL_PIXELFORMAT_INDEX4LSB; 
 
constexpr SDL_PixelFormat PIXELFORMAT_INDEX4MSB =
  SDL_PIXELFORMAT_INDEX4MSB; 
 
constexpr SDL_PixelFormat PIXELFORMAT_INDEX8 =
  SDL_PIXELFORMAT_INDEX8; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGB332 =
  SDL_PIXELFORMAT_RGB332; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XRGB4444 =
  SDL_PIXELFORMAT_XRGB4444; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XBGR4444 =
  SDL_PIXELFORMAT_XBGR4444; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XRGB1555 =
  SDL_PIXELFORMAT_XRGB1555; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XBGR1555 =
  SDL_PIXELFORMAT_XBGR1555; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB4444 =
  SDL_PIXELFORMAT_ARGB4444; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBA4444 =
  SDL_PIXELFORMAT_RGBA4444; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR4444 =
  SDL_PIXELFORMAT_ABGR4444; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRA4444 =
  SDL_PIXELFORMAT_BGRA4444; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB1555 =
  SDL_PIXELFORMAT_ARGB1555; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBA5551 =
  SDL_PIXELFORMAT_RGBA5551; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR1555 =
  SDL_PIXELFORMAT_ABGR1555; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRA5551 =
  SDL_PIXELFORMAT_BGRA5551; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGB565 =
  SDL_PIXELFORMAT_RGB565; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGR565 =
  SDL_PIXELFORMAT_BGR565; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGB24 = SDL_PIXELFORMAT_RGB24; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGR24 = SDL_PIXELFORMAT_BGR24; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XRGB8888 =
  SDL_PIXELFORMAT_XRGB8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBX8888 =
  SDL_PIXELFORMAT_RGBX8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XBGR8888 =
  SDL_PIXELFORMAT_XBGR8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRX8888 =
  SDL_PIXELFORMAT_BGRX8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB8888 =
  SDL_PIXELFORMAT_ARGB8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBA8888 =
  SDL_PIXELFORMAT_RGBA8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR8888 =
  SDL_PIXELFORMAT_ABGR8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRA8888 =
  SDL_PIXELFORMAT_BGRA8888; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XRGB2101010 =
  SDL_PIXELFORMAT_XRGB2101010; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XBGR2101010 =
  SDL_PIXELFORMAT_XBGR2101010; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB2101010 =
  SDL_PIXELFORMAT_ARGB2101010; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR2101010 =
  SDL_PIXELFORMAT_ABGR2101010; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGB48 = SDL_PIXELFORMAT_RGB48; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGR48 = SDL_PIXELFORMAT_BGR48; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBA64 =
  SDL_PIXELFORMAT_RGBA64; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB64 =
  SDL_PIXELFORMAT_ARGB64; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRA64 =
  SDL_PIXELFORMAT_BGRA64; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR64 =
  SDL_PIXELFORMAT_ABGR64; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGB48_FLOAT =
  SDL_PIXELFORMAT_RGB48_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGR48_FLOAT =
  SDL_PIXELFORMAT_BGR48_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBA64_FLOAT =
  SDL_PIXELFORMAT_RGBA64_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB64_FLOAT =
  SDL_PIXELFORMAT_ARGB64_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRA64_FLOAT =
  SDL_PIXELFORMAT_BGRA64_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR64_FLOAT =
  SDL_PIXELFORMAT_ABGR64_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGB96_FLOAT =
  SDL_PIXELFORMAT_RGB96_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGR96_FLOAT =
  SDL_PIXELFORMAT_BGR96_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBA128_FLOAT =
  SDL_PIXELFORMAT_RGBA128_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB128_FLOAT =
  SDL_PIXELFORMAT_ARGB128_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRA128_FLOAT =
  SDL_PIXELFORMAT_BGRA128_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR128_FLOAT =
  SDL_PIXELFORMAT_ABGR128_FLOAT; 
 
constexpr SDL_PixelFormat PIXELFORMAT_YV12 =
  SDL_PIXELFORMAT_YV12; 
 
constexpr SDL_PixelFormat PIXELFORMAT_IYUV =
  SDL_PIXELFORMAT_IYUV; 
 
constexpr SDL_PixelFormat PIXELFORMAT_YUY2 =
  SDL_PIXELFORMAT_YUY2; 
 
constexpr SDL_PixelFormat PIXELFORMAT_UYVY =
  SDL_PIXELFORMAT_UYVY; 
 
constexpr SDL_PixelFormat PIXELFORMAT_YVYU =
  SDL_PIXELFORMAT_YVYU; 
 
constexpr SDL_PixelFormat PIXELFORMAT_NV12 =
  SDL_PIXELFORMAT_NV12; 
 
constexpr SDL_PixelFormat PIXELFORMAT_NV21 =
  SDL_PIXELFORMAT_NV21; 
 
constexpr SDL_PixelFormat PIXELFORMAT_P010 =
  SDL_PIXELFORMAT_P010; 
 
constexpr SDL_PixelFormat PIXELFORMAT_EXTERNAL_OES =
  SDL_PIXELFORMAT_EXTERNAL_OES; 
 
#if SDL_VERSION_ATLEAST(3, 2, 10)
 
constexpr SDL_PixelFormat PIXELFORMAT_MJPG =
  SDL_PIXELFORMAT_MJPG; 
 
#endif // SDL_VERSION_ATLEAST(3, 2, 10)
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBA32 =
  SDL_PIXELFORMAT_RGBA32; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ARGB32 =
  SDL_PIXELFORMAT_ARGB32; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRA32 =
  SDL_PIXELFORMAT_BGRA32; 
 
constexpr SDL_PixelFormat PIXELFORMAT_ABGR32 =
  SDL_PIXELFORMAT_ABGR32; 
 
constexpr SDL_PixelFormat PIXELFORMAT_RGBX32 =
  SDL_PIXELFORMAT_RGBX32; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XRGB32 =
  SDL_PIXELFORMAT_XRGB32; 
 
constexpr SDL_PixelFormat PIXELFORMAT_BGRX32 =
  SDL_PIXELFORMAT_BGRX32; 
 
constexpr SDL_PixelFormat PIXELFORMAT_XBGR32 =
  SDL_PIXELFORMAT_XBGR32; 
 
 
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
{
  SDL_Colorspace m_colorspace;
 
public:
  constexpr Colorspace(SDL_Colorspace colorspace = {})
    : m_colorspace(colorspace)
  {
  }
 
  constexpr Colorspace(ColorType type,
                       ColorRange range,
                       ColorPrimaries primaries,
                       TransferCharacteristics transfer,
                       MatrixCoefficients matrix,
                       ChromaLocation chroma)
    : m_colorspace(SDL_Colorspace(SDL_DEFINE_COLORSPACE(type,
                                                        range,
                                                        primaries,
                                                        transfer,
                                                        matrix,
                                                        chroma)))
  {
  }
 
  constexpr bool operator==(const Colorspace& other) const = default;
 
  constexpr bool operator==(SDL_Colorspace colorspace) const
  {
    return operator==(Colorspace(colorspace));
  }
 
 
  constexpr operator SDL_Colorspace() const { return m_colorspace; }
 
  constexpr explicit operator bool() const { return m_colorspace != 0; }
 
  constexpr ColorType GetType() const
  {
    return SDL_COLORSPACETYPE(m_colorspace);
  }
 
  constexpr ColorRange GetRange() const
  {
    return SDL_COLORSPACERANGE(m_colorspace);
  }
 
  constexpr ChromaLocation GetChroma() const
  {
    return SDL_COLORSPACECHROMA(m_colorspace);
  }
 
  constexpr ColorPrimaries GetPrimaries() const
  {
    return SDL_COLORSPACEPRIMARIES(m_colorspace);
  }
 
  constexpr TransferCharacteristics GetTransfer() const
  {
    return SDL_COLORSPACETRANSFER(m_colorspace);
  }
 
  constexpr MatrixCoefficients GetMatrix() const
  {
    return SDL_COLORSPACEMATRIX(m_colorspace);
  }
 
  constexpr bool IsMatrixBT601() const
  {
    return SDL_ISCOLORSPACE_MATRIX_BT601(m_colorspace);
  }
 
  constexpr bool IsMatrixBT709() const
  {
    return SDL_ISCOLORSPACE_MATRIX_BT709(m_colorspace);
  }
 
  constexpr bool IsMatrixBT2020_NCL() const
  {
    return SDL_ISCOLORSPACE_MATRIX_BT2020_NCL(m_colorspace);
  }
 
  constexpr bool IsLimitedRange() const
  {
    return SDL_ISCOLORSPACE_LIMITED_RANGE(m_colorspace);
  }
 
  constexpr bool IsFullRange() const
  {
    return SDL_ISCOLORSPACE_FULL_RANGE(m_colorspace);
  }
};
 
constexpr SDL_Colorspace COLORSPACE_UNKNOWN =
  SDL_COLORSPACE_UNKNOWN; 
 
constexpr SDL_Colorspace COLORSPACE_SRGB = SDL_COLORSPACE_SRGB;
 
constexpr SDL_Colorspace COLORSPACE_SRGB_LINEAR =
  SDL_COLORSPACE_SRGB_LINEAR; 
 
constexpr SDL_Colorspace COLORSPACE_HDR10 =
  SDL_COLORSPACE_HDR10; 
 
constexpr SDL_Colorspace COLORSPACE_JPEG = SDL_COLORSPACE_JPEG;
 
constexpr SDL_Colorspace COLORSPACE_BT601_LIMITED =
  SDL_COLORSPACE_BT601_LIMITED;
 
constexpr SDL_Colorspace COLORSPACE_BT601_FULL = SDL_COLORSPACE_BT601_FULL;
 
constexpr SDL_Colorspace COLORSPACE_BT709_LIMITED =
  SDL_COLORSPACE_BT709_LIMITED;
 
constexpr SDL_Colorspace COLORSPACE_BT709_FULL = SDL_COLORSPACE_BT709_FULL;
 
constexpr SDL_Colorspace COLORSPACE_BT2020_LIMITED =
  SDL_COLORSPACE_BT2020_LIMITED;
 
constexpr SDL_Colorspace COLORSPACE_BT2020_FULL = SDL_COLORSPACE_BT2020_FULL;
 
constexpr SDL_Colorspace COLORSPACE_RGB_DEFAULT = SDL_COLORSPACE_RGB_DEFAULT;
 
constexpr SDL_Colorspace COLORSPACE_YUV_DEFAULT = SDL_COLORSPACE_YUV_DEFAULT;
 
 
struct Color : SDL_Color
{
  constexpr Color(const SDL_Color& color = {})
    : SDL_Color(color)
  {
  }
 
  constexpr Color(Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255)
    : SDL_Color{r, g, b, a}
  {
  }
 
  constexpr auto operator<=>(const Color& other) const
  {
    auto c = r <=> other.r;
    if (c != std::strong_ordering::equal) return c;
    c = g <=> other.g;
    if (c != std::strong_ordering::equal) return c;
    c = b <=> other.b;
    if (c != std::strong_ordering::equal) return c;
    return a <=> other.a;
  }
 
  constexpr auto operator<=>(const SDL_Color& color) const
  {
    return operator<=>(Color(color));
  }
  constexpr Uint8 GetR() const { return r; }
 
  constexpr Color& SetR(Uint8 newR)
  {
    r = newR;
    return *this;
  }
 
  constexpr Uint8 GetG() const { return g; }
 
  constexpr Color& SetG(Uint8 newG)
  {
    g = newG;
    return *this;
  }
 
  constexpr Uint8 GetB() const { return b; }
 
  constexpr Color& SetB(Uint8 newB)
  {
    b = newB;
    return *this;
  }
 
  constexpr Uint8 GetA() const { return a; }
 
  constexpr Color& SetA(Uint8 newA)
  {
    a = newA;
    return *this;
  }
 
  Uint32 Map(const PixelFormatDetails& format, PaletteRef palette) const;
 
  static Color Get(Uint32 pixel,
                   const PixelFormatDetails& format,
                   PaletteRef palette);
};
 
struct FColor : SDL_FColor
{
  constexpr FColor(const SDL_FColor& color = {})
    : SDL_FColor(color)
  {
  }
 
  constexpr FColor(float r, float g, float b, float a = 1)
    : SDL_FColor{r, g, b, a}
  {
  }
 
  constexpr auto operator<=>(const FColor& other) const
  {
    auto c = r <=> other.r;
    if (c != std::partial_ordering::equivalent) return c;
    c = g <=> other.g;
    if (c != std::partial_ordering::equivalent) return c;
    c = b <=> other.b;
    if (c != std::partial_ordering::equivalent) return c;
    return a <=> other.a;
  }
 
  constexpr auto operator<=>(const SDL_FColor& color) const
  {
    return operator<=>(FColor(color));
  }
  constexpr float GetR() const { return r; }
 
  constexpr FColor& SetR(float newR)
  {
    r = newR;
    return *this;
  }
 
  constexpr float GetG() const { return g; }
 
  constexpr FColor& SetG(float newG)
  {
    g = newG;
    return *this;
  }
 
  constexpr float GetB() const { return b; }
 
  constexpr FColor& SetB(float newB)
  {
    b = newB;
    return *this;
  }
 
  constexpr float GetA() const { return a; }
 
  constexpr FColor& SetA(float newA)
  {
    a = newA;
    return *this;
  }
};
 
struct PaletteBase : Resource<SDL_Palette*>
{
  using Resource::Resource;
 
  PaletteBase(int ncolors)
    : Resource(CheckError(SDL_CreatePalette(ncolors)))
  {
  }
 
  constexpr int GetSize() const { return get()->ncolors; }
 
  constexpr Color operator[](int index) const { return get()->colors[index]; }
 
  void SetColors(std::span<const SDL_Color> colors, int firstcolor = 0)
  {
    CheckError(
      SDL_SetPaletteColors(get(), colors.data(), firstcolor, colors.size()));
  }
 
  bool SetColors(SpanRef<const SDL_Color> colors, int firstcolor = 0)
  {
    SDL_assert_paranoid(colors.size() < SDL_MAX_SINT32);
    return SDL_SetPaletteColors(
      get(), colors.data(), firstcolor, colors.size());
  }
};
 
struct PaletteRef : PaletteBase
{
  using PaletteBase::PaletteBase;
 
  constexpr PaletteRef(const PaletteRef& other)
    : PaletteBase(other.get())
  {
  }
 
  constexpr PaletteRef(PaletteRef&& other)
    : PaletteBase(other.release())
  {
  }
 
  constexpr ~PaletteRef() = default;
 
  PaletteRef& operator=(PaletteRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Palette* newResource = {})
  {
    SDL_DestroyPalette(release(newResource));
  }
};
 
struct Palette : PaletteRef
{
  using PaletteRef::PaletteRef;
 
  constexpr explicit Palette(SDL_Palette* resource = {})
    : PaletteRef(resource)
  {
  }
 
  constexpr Palette(const Palette& other) = delete;
 
  constexpr Palette(Palette&& other) = default;
 
  ~Palette() { reset(); }
 
  Palette& operator=(Palette other)
  {
    reset(other.release());
    return *this;
  }
};
 
inline Uint32 MapRGB(const PixelFormatDetails& format,
                     const PaletteBase& palette,
                     Uint8 r,
                     Uint8 g,
                     Uint8 b)
{
  return SDL_MapRGB(&format, palette.get(), r, g, b);
}
 
inline Uint32 MapRGBA(const PixelFormatDetails& format,
                      const PaletteBase& palette,
                      Uint8 r,
                      Uint8 g,
                      Uint8 b,
                      Uint8 a)
{
  return SDL_MapRGBA(&format, palette.get(), r, g, b, a);
}
 
inline void GetRGB(Uint32 pixel,
                   const PixelFormatDetails& format,
                   const PaletteBase& palette,
                   Uint8* r,
                   Uint8* g,
                   Uint8* b)
{
  SDL_GetRGB(pixel, &format, palette.get(), r, g, b);
}
 
inline void GetRGBA(Uint32 pixel,
                    const PixelFormatDetails& format,
                    const PaletteBase& palette,
                    Uint8* r,
                    Uint8* g,
                    Uint8* b,
                    Uint8* a)
{
  SDL_GetRGBA(pixel, &format, palette.get(), r, g, b, a);
}
 
#pragma region impl
 
inline Uint32 Color::Map(const PixelFormatDetails& format,
                         PaletteRef palette = nullptr) const
{
  return MapRGBA(format, palette.get(), r, g, b, a);
}
 
inline Color Color::Get(Uint32 pixel,
                        const PixelFormatDetails& format,
                        PaletteRef palette = nullptr)
{
  Color c;
  GetRGBA(pixel, format, palette, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline Uint32 PixelFormat::Map(Color color, PaletteRef palette = nullptr) const
{
  return color.Map(*GetDetails(), palette);
}
 
inline Color PixelFormat::Get(Uint32 pixel, PaletteRef palette = nullptr) const
{
  return Color::Get(pixel, *GetDetails(), palette);
}
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_PIXELS_H_ */