SDL3pp_image.h

#ifndef SDL3PP_IMAGE_H_
#define SDL3PP_IMAGE_H_
 
#include "SDL3pp_error.h"
#include "SDL3pp_gpu.h"
#include "SDL3pp_mouse.h"
#include "SDL3pp_render.h"
#include "SDL3pp_surface.h"
#include "SDL3pp_version.h"
#include "SDL3pp_video.h"
 
#if defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
#include <SDL3_image/SDL_image.h>
 
namespace SDL {
 
// Forward decl
struct Animation;
 
using AnimationRaw = IMG_Animation*;
 
// Forward decl
struct AnimationRef;
 
struct AnimationParam
{
  AnimationRaw value; 
 
  constexpr AnimationParam(AnimationRaw value)
    : value(value)
  {
  }
 
  constexpr AnimationParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AnimationParam& other) const = default;
 
  constexpr operator AnimationRaw() const { return value; }
 
  constexpr auto operator->() { return value; }
};
 
struct AnimationConstParam
{
  const AnimationRaw value; 
 
  constexpr AnimationConstParam(const AnimationRaw value)
    : value(value)
  {
  }
 
  constexpr AnimationConstParam(AnimationParam value)
    : value(value.value)
  {
  }
 
  constexpr AnimationConstParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AnimationConstParam& other) const = default;
 
  constexpr operator const AnimationRaw() const { return value; }
 
  constexpr auto operator->() { return value; }
};
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
// Forward decl
struct AnimationEncoder;
 
using AnimationEncoderRaw = IMG_AnimationEncoder*;
 
// Forward decl
struct AnimationEncoderRef;
 
struct AnimationEncoderParam
{
  AnimationEncoderRaw value; 
 
  constexpr AnimationEncoderParam(AnimationEncoderRaw value)
    : value(value)
  {
  }
 
  constexpr AnimationEncoderParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AnimationEncoderParam& other) const =
    default;
 
  constexpr operator AnimationEncoderRaw() const { return value; }
};
 
// Forward decl
struct AnimationDecoder;
 
using AnimationDecoderRaw = IMG_AnimationDecoder*;
 
// Forward decl
struct AnimationDecoderRef;
 
struct AnimationDecoderParam
{
  AnimationDecoderRaw value; 
 
  constexpr AnimationDecoderParam(AnimationDecoderRaw value)
    : value(value)
  {
  }
 
  constexpr AnimationDecoderParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const AnimationDecoderParam& other) const =
    default;
 
  constexpr operator AnimationDecoderRaw() const { return value; }
};
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
#ifdef SDL3PP_DOC
 
#define SDL_IMAGE_MAJOR_VERSION
 
#define SDL_IMAGE_MINOR_VERSION
 
#define SDL_IMAGE_MICRO_VERSION
 
 
#define SDL_IMAGE_VERSION                                                      \
  SDL_VERSIONNUM(                                                              \
    SDL_IMAGE_MAJOR_VERSION, SDL_IMAGE_MINOR_VERSION, SDL_IMAGE_MICRO_VERSION)
 
#define SDL_IMAGE_VERSION_ATLEAST(X, Y, Z)                                     \
  ((SDL_IMAGE_MAJOR_VERSION >= X) &&                                           \
   (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION >= Y) &&            \
   (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION > Y ||              \
    SDL_IMAGE_MICRO_VERSION >= Z))
 
#endif // SDL3PP_DOC
 
namespace IMG {
 
inline int Version() { return IMG_Version(); }
 
} // namespace IMG
 
inline Surface LoadSurface(StringParam file) { return Surface{IMG_Load(file)}; }
 
inline Surface LoadSurface(IOStreamParam src, bool closeio)
{
  return Surface{IMG_Load_IO(src, closeio)};
}
 
inline Surface::Surface(StringParam file)
  : m_resource(IMG_Load(file))
{
}
 
inline Surface::Surface(IOStreamParam src, bool closeio)
  : m_resource(IMG_Load_IO(src, closeio))
{
}
 
inline Surface LoadSurfaceTyped(IOStreamParam src,
                                StringParam type,
                                bool closeio = false)
{
  return Surface(IMG_LoadTyped_IO(src, closeio, type));
}
 
inline Texture LoadTexture(RendererParam renderer, StringParam file)
{
  return Texture(IMG_LoadTexture(renderer, file));
}
 
inline Texture LoadTexture(RendererParam renderer,
                           IOStreamParam src,
                           bool closeio = false)
{
  return Texture(IMG_LoadTexture_IO(renderer, src, closeio));
}
 
inline Texture::Texture(RendererParam renderer, StringParam file)
  : m_resource(IMG_LoadTexture(renderer, file))
{
}
 
inline Texture::Texture(RendererParam renderer, IOStreamParam src, bool closeio)
  : m_resource(IMG_LoadTexture_IO(renderer, src, closeio))
{
}
 
inline Texture LoadTextureTyped(RendererParam renderer,
                                IOStreamParam src,
                                StringParam type,
                                bool closeio = false)
{
  return Texture(IMG_LoadTextureTyped_IO(renderer, src, closeio, type));
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline GPUTexture LoadGPUTexture(GPUDeviceParam device,
                                 GPUCopyPass copy_pass,
                                 StringParam file,
                                 int* width = nullptr,
                                 int* height = nullptr)
{
  return IMG_LoadGPUTexture(device, copy_pass, file, width, height);
}
 
inline GPUTexture LoadGPUTexture(GPUDeviceParam device,
                                 GPUCopyPass copy_pass,
                                 IOStreamParam src,
                                 bool closeio = false,
                                 int* width = nullptr,
                                 int* height = nullptr)
{
  return IMG_LoadGPUTexture_IO(device, copy_pass, src, closeio, width, height);
}
 
inline GPUTexture LoadGPUTextureTyped(GPUDeviceParam device,
                                      GPUCopyPass copy_pass,
                                      IOStreamParam src,
                                      StringParam type,
                                      bool closeio = false,
                                      int* width = nullptr,
                                      int* height = nullptr)
{
  return IMG_LoadGPUTextureTyped_IO(
    device, copy_pass, src, closeio, type, width, height);
}
 
inline Surface GetClipboardImage() { return Surface{IMG_GetClipboardImage()}; }
 
inline bool isANI(IOStreamParam src) { return IMG_isANI(src); }
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline bool isAVIF(IOStreamParam src) { return IMG_isAVIF(src); }
 
inline bool isCUR(IOStreamParam src) { return IMG_isCUR(src); }
 
inline bool isBMP(IOStreamParam src) { return IMG_isBMP(src); }
 
inline bool isGIF(IOStreamParam src) { return IMG_isGIF(src); }
 
inline bool isICO(IOStreamParam src) { return IMG_isICO(src); }
 
inline bool isJPG(IOStreamParam src) { return IMG_isJPG(src); }
 
inline bool isJXL(IOStreamParam src) { return IMG_isJXL(src); }
 
inline bool isLBM(IOStreamParam src) { return IMG_isLBM(src); }
 
inline bool isPCX(IOStreamParam src) { return IMG_isPCX(src); }
 
inline bool isPNG(IOStreamParam src) { return IMG_isPNG(src); }
 
inline bool isPNM(IOStreamParam src) { return IMG_isPNM(src); }
 
inline bool isQOI(IOStreamParam src) { return IMG_isQOI(src); }
 
inline bool isSVG(IOStreamParam src) { return IMG_isSVG(src); }
 
inline bool isTIF(IOStreamParam src) { return IMG_isTIF(src); }
 
inline bool isWEBP(IOStreamParam src) { return IMG_isWEBP(src); }
 
inline bool isXCF(IOStreamParam src) { return IMG_isXCF(src); }
 
inline bool isXPM(IOStreamParam src) { return IMG_isXPM(src); }
 
inline bool isXV(IOStreamParam src) { return IMG_isXV(src); }
 
inline Surface LoadAVIF(IOStreamParam src)
{
  return Surface(IMG_LoadAVIF_IO(src));
}
 
inline Surface LoadBMP(IOStreamParam src)
{
  return Surface{IMG_LoadBMP_IO(src)};
}
 
inline Surface LoadCUR(IOStreamParam src)
{
  return Surface{IMG_LoadCUR_IO(src)};
}
 
inline Surface LoadGIF(IOStreamParam src)
{
  return Surface{IMG_LoadGIF_IO(src)};
}
 
inline Surface LoadICO(IOStreamParam src)
{
  return Surface{IMG_LoadICO_IO(src)};
}
 
inline Surface LoadJPG(IOStreamParam src)
{
  return Surface{IMG_LoadJPG_IO(src)};
}
 
inline Surface LoadJXL(IOStreamParam src)
{
  return Surface{IMG_LoadJXL_IO(src)};
}
 
inline Surface LoadLBM(IOStreamParam src)
{
  return Surface{IMG_LoadLBM_IO(src)};
}
 
inline Surface LoadPCX(IOStreamParam src)
{
  return Surface{IMG_LoadPCX_IO(src)};
}
 
inline Surface LoadPNG(IOStreamParam src)
{
  return Surface{IMG_LoadPNG_IO(src)};
}
 
inline Surface LoadPNM(IOStreamParam src)
{
  return Surface{IMG_LoadPNM_IO(src)};
}
 
inline Surface LoadSVG(IOStreamParam src)
{
  return Surface{IMG_LoadSVG_IO(src)};
}
 
inline Surface LoadSizedSVG(IOStreamParam src, const PointRaw& size)
{
  return Surface{IMG_LoadSizedSVG_IO(src, size.x, size.y)};
}
 
inline Surface LoadQOI(IOStreamParam src)
{
  return Surface{IMG_LoadQOI_IO(src)};
}
 
inline Surface LoadTGA(IOStreamParam src)
{
  return Surface{IMG_LoadTGA_IO(src)};
}
 
inline Surface LoadTIF(IOStreamParam src)
{
  return Surface{IMG_LoadTIF_IO(src)};
}
 
inline Surface LoadWEBP(IOStreamParam src)
{
  return Surface{IMG_LoadWEBP_IO(src)};
}
 
inline Surface LoadXCF(IOStreamParam src)
{
  return Surface{IMG_LoadXCF_IO(src)};
}
 
inline Surface LoadXPM(IOStreamParam src)
{
  return Surface{IMG_LoadXPM_IO(src)};
}
 
inline Surface LoadXV(IOStreamParam src) { return Surface{IMG_LoadXV_IO(src)}; }
 
inline Surface ReadXPMFromArray(char** xpm)
{
  return Surface{IMG_ReadXPMFromArray(xpm)};
}
 
inline Surface ReadXPMFromArrayToRGB888(char** xpm)
{
  return Surface{IMG_ReadXPMFromArrayToRGB888(xpm)};
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline void Save(SurfaceParam surface, StringParam file)
{
  CheckError(IMG_Save(surface, file));
}
 
inline void SaveTyped(SurfaceParam surface,
                      IOStreamParam dst,
                      StringParam type,
                      bool closeio = false)
{
  CheckError(IMG_SaveTyped_IO(surface, dst, closeio, type));
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline void SaveAVIF(SurfaceParam surface, StringParam file, int quality)
{
  CheckError(IMG_SaveAVIF(surface, file, quality));
}
 
inline void SaveAVIF(SurfaceParam surface,
                     IOStreamParam dst,
                     int quality,
                     bool closeio = false)
{
  CheckError(IMG_SaveAVIF_IO(surface, dst, closeio, quality));
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline void SaveBMP(SurfaceParam surface, StringParam file)
{
  CheckError(IMG_SaveBMP(surface, file));
}
 
inline void SaveBMP(SurfaceParam surface,
                    IOStreamParam dst,
                    bool closeio = false)
{
  CheckError(IMG_SaveBMP_IO(surface, dst, closeio));
}
 
inline void SaveCUR(SurfaceParam surface, StringParam file)
{
  CheckError(IMG_SaveCUR(surface, file));
}
 
inline void SaveCUR(SurfaceParam surface,
                    IOStreamParam dst,
                    bool closeio = false)
{
  CheckError(IMG_SaveCUR_IO(surface, dst, closeio));
}
 
inline void SaveGIF(SurfaceParam surface, StringParam file)
{
  CheckError(IMG_SaveGIF(surface, file));
}
 
inline void SaveGIF(SurfaceParam surface,
                    IOStreamParam dst,
                    bool closeio = false)
{
  CheckError(IMG_SaveGIF_IO(surface, dst, closeio));
}
 
inline void SaveICO(SurfaceParam surface, StringParam file)
{
  CheckError(IMG_SaveICO(surface, file));
}
 
inline void SaveICO(SurfaceParam surface,
                    IOStreamParam dst,
                    bool closeio = false)
{
  CheckError(IMG_SaveICO_IO(surface, dst, closeio));
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline void SaveJPG(SurfaceParam surface, StringParam file, int quality)
{
  CheckError(IMG_SaveJPG(surface, file, quality));
}
 
inline void SaveJPG(SurfaceParam surface,
                    IOStreamParam dst,
                    int quality,
                    bool closeio = false)
{
  CheckError(IMG_SaveJPG_IO(surface, dst, closeio, quality));
}
 
inline void SavePNG(SurfaceParam surface, StringParam file)
{
  CheckError(IMG_SavePNG(surface, file));
}
 
inline void SavePNG(SurfaceParam surface,
                    IOStreamParam dst,
                    bool closeio = false)
{
  CheckError(IMG_SavePNG_IO(surface, dst, closeio));
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline void SaveTGA(SurfaceParam surface, StringParam file)
{
  CheckError(IMG_SaveTGA(surface, file));
}
 
inline void SaveTGA(SurfaceParam surface,
                    IOStreamParam dst,
                    bool closeio = false)
{
  CheckError(IMG_SaveTGA_IO(surface, dst, closeio));
}
 
inline void SaveWEBP(SurfaceParam surface, StringParam file, float quality)
{
  CheckError(IMG_SaveWEBP(surface, file, quality));
}
 
inline void SaveWEBP(SurfaceParam surface,
                     IOStreamParam dst,
                     float quality,
                     bool closeio = false)
{
  CheckError(IMG_SaveWEBP_IO(surface, dst, closeio, quality));
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
class Animation
{
  AnimationRaw m_resource = nullptr;
 
public:
  constexpr Animation(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Animation(const AnimationRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Animation(const Animation& other) noexcept = default;
 
public:
  constexpr Animation(Animation&& other) noexcept
    : Animation(other.release())
  {
  }
 
  constexpr Animation(const AnimationRef& other) = delete;
 
  constexpr Animation(AnimationRef&& other) = delete;
 
  Animation(StringParam file)
    : m_resource(IMG_LoadAnimation(file))
  {
  }
 
  Animation(IOStreamParam src, bool closeio = false)
    : m_resource(IMG_LoadAnimation_IO(src, closeio))
  {
  }
 
  constexpr const AnimationRaw operator->() const noexcept
  {
    return m_resource;
  }
 
  constexpr AnimationRaw operator->() noexcept { return m_resource; }
 
  ~Animation() { IMG_FreeAnimation(m_resource); }
 
  constexpr Animation& operator=(Animation&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Animation& operator=(const Animation& other) noexcept = default;
 
public:
  constexpr AnimationRaw get() const noexcept { return m_resource; }
 
  constexpr AnimationRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Animation& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator AnimationParam() const noexcept { return {m_resource}; }
 
  void Free();
 
  int GetWidth() const;
 
  int GetHeight() const;
 
  Point GetSize() const;
 
  int GetCount() const;
 
  Surface GetFrame(int index) const;
 
  int GetDelay(int index) const;
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
  void Save(StringParam file);
 
  void SaveTyped(IOStreamParam dst, StringParam type, bool closeio = false);
 
  void SaveANI(IOStreamParam dst, bool closeio = false);
 
  void SaveAPNG(IOStreamParam dst, bool closeio = false);
 
  void SaveAVIF(IOStreamParam dst, int quality, bool closeio = false);
 
  void SaveGIF(IOStreamParam dst, bool closeio = false);
 
  void SaveWEBP(IOStreamParam dst, int quality, bool closeio = false);
 
  Cursor CreateCursor(const PointRaw& hotspot);
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
};
 
struct AnimationRef : Animation
{
  using Animation::Animation;
 
  AnimationRef(AnimationParam resource) noexcept
    : Animation(resource.value)
  {
  }
 
  AnimationRef(AnimationRaw resource) noexcept
    : Animation(resource)
  {
  }
 
  constexpr AnimationRef(const AnimationRef& other) noexcept = default;
 
  ~AnimationRef() { release(); }
};
 
inline int GetAnimationWidth(AnimationConstParam anim) { return anim->w; }
 
inline int Animation::GetWidth() const
{
  return SDL::GetAnimationWidth(m_resource);
}
 
inline int GetAnimationHeight(AnimationConstParam anim) { return anim->h; }
 
inline int Animation::GetHeight() const
{
  return SDL::GetAnimationHeight(m_resource);
}
 
inline Point GetAnimationSize(AnimationConstParam anim)
{
  return {anim->w, anim->h};
}
 
inline Point Animation::GetSize() const
{
  return SDL::GetAnimationSize(m_resource);
}
 
inline int GetAnimationCount(AnimationConstParam anim) { return anim->count; }
 
inline int Animation::GetCount() const
{
  return SDL::GetAnimationCount(m_resource);
}
 
inline Surface GetAnimationFrame(AnimationConstParam anim, int index)
{
  return Surface::Borrow(anim->frames[index]);
}
 
inline Surface Animation::GetFrame(int index) const
{
  return SDL::GetAnimationFrame(m_resource, index);
}
 
inline int GetAnimationDelay(AnimationConstParam anim, int index)
{
  return anim->delays[index];
}
 
inline int Animation::GetDelay(int index) const
{
  return SDL::GetAnimationDelay(m_resource, index);
}
 
inline Animation LoadAnimation(StringParam file)
{
  return Animation(std::move(file));
}
 
inline Animation LoadAnimation(IOStreamParam src, bool closeio = false)
{
  return Animation(src, closeio);
}
 
inline Animation LoadAnimationTyped(IOStreamParam src,
                                    StringParam type,
                                    bool closeio = false)
{
  return Animation(IMG_LoadAnimationTyped_IO(src, closeio, type));
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline Animation LoadANIAnimation(IOStreamParam src)
{
  return Animation(IMG_LoadANIAnimation_IO(src));
}
 
inline Animation LoadAPNGAnimation(IOStreamParam src)
{
  return Animation(IMG_LoadAPNGAnimation_IO(src));
}
 
inline Animation LoadAVIFAnimation(IOStreamParam src)
{
  return Animation(IMG_LoadAVIFAnimation_IO(src));
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline Animation LoadGIFAnimation(IOStreamParam src)
{
  return Animation(IMG_LoadGIFAnimation_IO(src));
}
 
inline Animation LoadWEBPAnimation(IOStreamParam src)
{
  return Animation{IMG_LoadWEBPAnimation_IO(src)};
}
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline void SaveAnimation(AnimationParam anim, StringParam file)
{
  CheckError(IMG_SaveAnimation(anim, file));
}
 
inline void Animation::Save(StringParam file)
{
  SDL::SaveAnimation(m_resource, std::move(file));
}
 
inline void SaveAnimationTyped(AnimationParam anim,
                               IOStreamParam dst,
                               StringParam type,
                               bool closeio = false)
{
  CheckError(IMG_SaveAnimationTyped_IO(anim, dst, closeio, type));
}
 
inline void Animation::SaveTyped(IOStreamParam dst,
                                 StringParam type,
                                 bool closeio)
{
  SDL::SaveAnimationTyped(m_resource, dst, std::move(type), closeio);
}
 
inline void SaveANIAnimation(AnimationParam anim,
                             IOStreamParam dst,
                             bool closeio = false)
{
  CheckError(IMG_SaveANIAnimation_IO(anim, dst, closeio));
}
 
inline void Animation::SaveANI(IOStreamParam dst, bool closeio)
{
  SDL::SaveANIAnimation(m_resource, dst, closeio);
}
 
inline void SaveAPNGAnimation(AnimationParam anim,
                              IOStreamParam dst,
                              bool closeio = false)
{
  CheckError(IMG_SaveAPNGAnimation_IO(anim, dst, closeio));
}
 
inline void Animation::SaveAPNG(IOStreamParam dst, bool closeio)
{
  SDL::SaveAPNGAnimation(m_resource, dst, closeio);
}
 
inline void SaveAVIFAnimation(AnimationParam anim,
                              IOStreamParam dst,
                              int quality,
                              bool closeio = false)
{
  CheckError(IMG_SaveAVIFAnimation_IO(anim, dst, quality, closeio));
}
 
inline void Animation::SaveAVIF(IOStreamParam dst, int quality, bool closeio)
{
  SDL::SaveAVIFAnimation(m_resource, dst, quality, closeio);
}
 
inline void SaveGIFAnimation(AnimationParam anim,
                             IOStreamParam dst,
                             bool closeio = false)
{
  CheckError(IMG_SaveGIFAnimation_IO(anim, dst, closeio));
}
 
inline void Animation::SaveGIF(IOStreamParam dst, bool closeio)
{
  SDL::SaveGIFAnimation(m_resource, dst, closeio);
}
 
inline void SaveWEBPAnimation(AnimationParam anim,
                              IOStreamParam dst,
                              int quality,
                              bool closeio = false)
{
  CheckError(IMG_SaveWEBPAnimation_IO(anim, dst, quality, closeio));
}
 
inline void Animation::SaveWEBP(IOStreamParam dst, int quality, bool closeio)
{
  SDL::SaveWEBPAnimation(m_resource, dst, quality, closeio);
}
 
inline Cursor CreateAnimatedCursor(AnimationParam anim, const PointRaw& hotspot)
{
  return Cursor{
    CheckError(IMG_CreateAnimatedCursor(anim, hotspot.x, hotspot.y))};
}
 
inline Cursor Animation::CreateCursor(const PointRaw& hotspot)
{
  return SDL::CreateAnimatedCursor(m_resource, hotspot);
}
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
inline void FreeAnimation(AnimationRaw anim) { IMG_FreeAnimation(anim); }
 
inline void Animation::Free() { FreeAnimation(release()); }
 
#if SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
class AnimationEncoder
{
  AnimationEncoderRaw m_resource = nullptr;
 
public:
  constexpr AnimationEncoder(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit AnimationEncoder(
    const AnimationEncoderRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr AnimationEncoder(const AnimationEncoder& other) noexcept = default;
 
public:
  constexpr AnimationEncoder(AnimationEncoder&& other) noexcept
    : AnimationEncoder(other.release())
  {
  }
 
  constexpr AnimationEncoder(const AnimationEncoderRef& other) = delete;
 
  constexpr AnimationEncoder(AnimationEncoderRef&& other) = delete;
 
  AnimationEncoder(StringParam file)
    : m_resource(IMG_CreateAnimationEncoder(file))
  {
  }
 
  AnimationEncoder(IOStreamParam dst, StringParam type, bool closeio = false)
    : m_resource(IMG_CreateAnimationEncoder_IO(dst, closeio, type))
  {
  }
 
  AnimationEncoder(PropertiesParam props)
    : m_resource(IMG_CreateAnimationEncoderWithProperties(props))
  {
  }
 
  ~AnimationEncoder() { IMG_CloseAnimationEncoder(m_resource); }
 
  constexpr AnimationEncoder& operator=(AnimationEncoder&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr AnimationEncoder& operator=(
    const AnimationEncoder& other) noexcept = default;
 
public:
  constexpr AnimationEncoderRaw get() const noexcept { return m_resource; }
 
  constexpr AnimationEncoderRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const AnimationEncoder& other) const noexcept =
    default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator AnimationEncoderParam() const noexcept
  {
    return {m_resource};
  }
 
  void Close();
 
  void AddFrame(SurfaceParam surface, Uint64 duration);
};
 
struct AnimationEncoderRef : AnimationEncoder
{
  using AnimationEncoder::AnimationEncoder;
 
  AnimationEncoderRef(AnimationEncoderParam resource) noexcept
    : AnimationEncoder(resource.value)
  {
  }
 
  AnimationEncoderRef(AnimationEncoderRaw resource) noexcept
    : AnimationEncoder(resource)
  {
  }
 
  constexpr AnimationEncoderRef(const AnimationEncoderRef& other) noexcept =
    default;
 
  ~AnimationEncoderRef() { release(); }
};
 
inline AnimationEncoder CreateAnimationEncoder(StringParam file)
{
  return AnimationEncoder(std::move(file));
}
 
inline AnimationEncoder CreateAnimationEncoder(IOStreamParam dst,
                                               StringParam type,
                                               bool closeio = false)
{
  return AnimationEncoder(dst, std::move(type), closeio);
}
 
inline AnimationEncoder CreateAnimationEncoderWithProperties(
  PropertiesParam props)
{
  return AnimationEncoder(props);
}
 
namespace prop::AnimationEncoder {
 
constexpr auto CREATE_FILENAME_STRING =
  IMG_PROP_ANIMATION_ENCODER_CREATE_FILENAME_STRING;
 
constexpr auto CREATE_IOSTREAM_POINTER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_IOSTREAM_POINTER;
 
constexpr auto CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN =
  IMG_PROP_ANIMATION_ENCODER_CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN;
 
constexpr auto CREATE_TYPE_STRING =
  IMG_PROP_ANIMATION_ENCODER_CREATE_TYPE_STRING;
 
constexpr auto CREATE_QUALITY_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_QUALITY_NUMBER;
 
constexpr auto CREATE_TIMEBASE_NUMERATOR_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_TIMEBASE_NUMERATOR_NUMBER;
 
constexpr auto CREATE_TIMEBASE_DENOMINATOR_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_TIMEBASE_DENOMINATOR_NUMBER;
 
constexpr auto CREATE_AVIF_MAX_THREADS_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_AVIF_MAX_THREADS_NUMBER;
 
constexpr auto CREATE_AVIF_KEYFRAME_INTERVAL_NUMBER =
  IMG_PROP_ANIMATION_ENCODER_CREATE_AVIF_KEYFRAME_INTERVAL_NUMBER;
 
constexpr auto CREATE_GIF_USE_LUT_BOOLEAN =
  IMG_PROP_ANIMATION_ENCODER_CREATE_GIF_USE_LUT_BOOLEAN;
 
} // namespace prop::AnimationEncoder
 
inline void AddAnimationEncoderFrame(AnimationEncoderParam encoder,
                                     SurfaceParam surface,
                                     Uint64 duration)
{
  CheckError(IMG_AddAnimationEncoderFrame(encoder, surface, duration));
}
 
inline void AnimationEncoder::AddFrame(SurfaceParam surface, Uint64 duration)
{
  SDL::AddAnimationEncoderFrame(m_resource, surface, duration);
}
 
inline void CloseAnimationEncoder(AnimationEncoderRaw encoder)
{
  CheckError(IMG_CloseAnimationEncoder(encoder));
}
 
inline void AnimationEncoder::Close() { CloseAnimationEncoder(release()); }
 
using AnimationDecoderStatus = IMG_AnimationDecoderStatus;
 
constexpr AnimationDecoderStatus DECODER_STATUS_INVALID =
  IMG_DECODER_STATUS_INVALID; 
 
constexpr AnimationDecoderStatus DECODER_STATUS_OK =
  IMG_DECODER_STATUS_OK; 
 
constexpr AnimationDecoderStatus DECODER_STATUS_FAILED =
  IMG_DECODER_STATUS_FAILED;
 
constexpr AnimationDecoderStatus DECODER_STATUS_COMPLETE =
  IMG_DECODER_STATUS_COMPLETE; 
 
class AnimationDecoder
{
  AnimationDecoderRaw m_resource = nullptr;
 
public:
  constexpr AnimationDecoder(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit AnimationDecoder(
    const AnimationDecoderRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr AnimationDecoder(const AnimationDecoder& other) noexcept = default;
 
public:
  constexpr AnimationDecoder(AnimationDecoder&& other) noexcept
    : AnimationDecoder(other.release())
  {
  }
 
  constexpr AnimationDecoder(const AnimationDecoderRef& other) = delete;
 
  constexpr AnimationDecoder(AnimationDecoderRef&& other) = delete;
 
  AnimationDecoder(StringParam file)
    : m_resource(IMG_CreateAnimationDecoder(file))
  {
  }
 
  AnimationDecoder(IOStreamParam src, StringParam type, bool closeio = false)
    : m_resource(IMG_CreateAnimationDecoder_IO(src, closeio, type))
  {
  }
 
  AnimationDecoder(PropertiesParam props)
    : m_resource(IMG_CreateAnimationDecoderWithProperties(props))
  {
  }
 
  ~AnimationDecoder() { IMG_CloseAnimationDecoder(m_resource); }
 
  constexpr AnimationDecoder& operator=(AnimationDecoder&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr AnimationDecoder& operator=(
    const AnimationDecoder& other) noexcept = default;
 
public:
  constexpr AnimationDecoderRaw get() const noexcept { return m_resource; }
 
  constexpr AnimationDecoderRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const AnimationDecoder& other) const noexcept =
    default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator AnimationDecoderParam() const noexcept
  {
    return {m_resource};
  }
 
  void Close();
 
  PropertiesRef GetProperties();
 
  Surface GetFrame(Uint64* duration);
 
  AnimationDecoderStatus GetStatus();
 
  void Reset();
};
 
struct AnimationDecoderRef : AnimationDecoder
{
  using AnimationDecoder::AnimationDecoder;
 
  AnimationDecoderRef(AnimationDecoderParam resource) noexcept
    : AnimationDecoder(resource.value)
  {
  }
 
  AnimationDecoderRef(AnimationDecoderRaw resource) noexcept
    : AnimationDecoder(resource)
  {
  }
 
  constexpr AnimationDecoderRef(const AnimationDecoderRef& other) noexcept =
    default;
 
  ~AnimationDecoderRef() { release(); }
};
 
inline AnimationDecoder CreateAnimationDecoder(StringParam file)
{
  return AnimationDecoder(std::move(file));
}
 
inline AnimationDecoder CreateAnimationDecoder(IOStreamParam src,
                                               StringParam type,
                                               bool closeio = false)
{
  return AnimationDecoder(src, std::move(type), closeio);
}
 
inline AnimationDecoder CreateAnimationDecoderWithProperties(
  PropertiesParam props)
{
  return AnimationDecoder(props);
}
 
namespace prop::AnimationDecoder {
 
constexpr auto CREATE_FILENAME_STRING =
  IMG_PROP_ANIMATION_DECODER_CREATE_FILENAME_STRING;
 
constexpr auto CREATE_IOSTREAM_POINTER =
  IMG_PROP_ANIMATION_DECODER_CREATE_IOSTREAM_POINTER;
 
constexpr auto CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN =
  IMG_PROP_ANIMATION_DECODER_CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN;
 
constexpr auto CREATE_TYPE_STRING =
  IMG_PROP_ANIMATION_DECODER_CREATE_TYPE_STRING;
 
constexpr auto CREATE_TIMEBASE_NUMERATOR_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_TIMEBASE_NUMERATOR_NUMBER;
 
constexpr auto CREATE_TIMEBASE_DENOMINATOR_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_TIMEBASE_DENOMINATOR_NUMBER;
 
constexpr auto CREATE_AVIF_MAX_THREADS_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_AVIF_MAX_THREADS_NUMBER;
 
constexpr auto CREATE_AVIF_ALLOW_INCREMENTAL_BOOLEAN =
  IMG_PROP_ANIMATION_DECODER_CREATE_AVIF_ALLOW_INCREMENTAL_BOOLEAN;
 
constexpr auto CREATE_AVIF_ALLOW_PROGRESSIVE_BOOLEAN =
  IMG_PROP_ANIMATION_DECODER_CREATE_AVIF_ALLOW_PROGRESSIVE_BOOLEAN;
 
constexpr auto CREATE_GIF_TRANSPARENT_COLOR_INDEX_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_GIF_TRANSPARENT_COLOR_INDEX_NUMBER;
 
constexpr auto CREATE_GIF_NUM_COLORS_NUMBER =
  IMG_PROP_ANIMATION_DECODER_CREATE_GIF_NUM_COLORS_NUMBER;
 
} // namespace prop::AnimationDecoder
 
inline PropertiesRef GetAnimationDecoderProperties(
  AnimationDecoderParam decoder)
{
  return IMG_GetAnimationDecoderProperties(decoder);
}
 
inline PropertiesRef AnimationDecoder::GetProperties()
{
  return SDL::GetAnimationDecoderProperties(m_resource);
}
 
namespace prop::Metadata {
 
constexpr auto IGNORE_PROPS_BOOLEAN = IMG_PROP_METADATA_IGNORE_PROPS_BOOLEAN;
 
constexpr auto DESCRIPTION_STRING = IMG_PROP_METADATA_DESCRIPTION_STRING;
 
constexpr auto COPYRIGHT_STRING = IMG_PROP_METADATA_COPYRIGHT_STRING;
 
constexpr auto TITLE_STRING = IMG_PROP_METADATA_TITLE_STRING;
 
constexpr auto AUTHOR_STRING = IMG_PROP_METADATA_AUTHOR_STRING;
 
constexpr auto CREATION_TIME_STRING = IMG_PROP_METADATA_CREATION_TIME_STRING;
 
constexpr auto FRAME_COUNT_NUMBER = IMG_PROP_METADATA_FRAME_COUNT_NUMBER;
 
constexpr auto LOOP_COUNT_NUMBER = IMG_PROP_METADATA_LOOP_COUNT_NUMBER;
 
} // namespace prop::Metadata
 
inline Surface GetAnimationDecoderFrame(AnimationDecoderParam decoder,
                                        Uint64* duration)
{
  SDL_Surface* frame = nullptr;
  CheckError(IMG_GetAnimationDecoderFrame(decoder, &frame, duration));
  return Surface::Borrow(frame);
}
 
inline Surface AnimationDecoder::GetFrame(Uint64* duration)
{
  return SDL::GetAnimationDecoderFrame(m_resource, duration);
}
 
inline AnimationDecoderStatus GetAnimationDecoderStatus(
  AnimationDecoderParam decoder)
{
  return IMG_GetAnimationDecoderStatus(decoder);
}
 
inline AnimationDecoderStatus AnimationDecoder::GetStatus()
{
  return SDL::GetAnimationDecoderStatus(m_resource);
}
 
inline void ResetAnimationDecoder(AnimationDecoderParam decoder)
{
  CheckError(IMG_ResetAnimationDecoder(decoder));
}
 
inline void AnimationDecoder::Reset()
{
  SDL::ResetAnimationDecoder(m_resource);
}
 
inline void CloseAnimationDecoder(AnimationDecoderRaw decoder)
{
  CheckError(IMG_CloseAnimationDecoder(decoder));
}
 
inline void AnimationDecoder::Close() { CloseAnimationDecoder(release()); }
 
#endif // SDL_IMAGE_VERSION_ATLEAST(3, 4, 0)
 
 
} // namespace SDL
 
#else // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
namespace SDL {
 
inline Surface::Surface(StringParam file)
  : Surface(LoadBMP(std::move(file)))
{
}
 
inline Surface::Surface(IOStreamParam src, bool closeio)
  : Surface(LoadBMP(std::move(src), closeio))
{
}
 
inline Texture::Texture(RendererParam renderer, StringParam file)
  : Texture(std::move(renderer), Surface(std::move(file)))
{
}
 
inline Texture::Texture(RendererParam renderer, IOStreamParam src, bool closeio)
  : Texture(std::move(renderer), Surface(std::move(src), closeio))
{
}
 
} // namespace SDL
 
#endif // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
#endif /* SDL3PP_IMAGE_H_ */