SDL3pp_image.h

#ifndef SDL3PP_IMAGE_H_
#define SDL3PP_IMAGE_H_
 
#include "SDL3pp_error.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; }
};
 
#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 LoadSurfaceTyped(IOStreamParam src,
                                StringParam type,
                                bool closeio = false)
{
  return Surface(IMG_LoadTyped_IO(src, closeio, type));
}
 
inline Surface LoadSurface(StringParam file) { return Surface(IMG_Load(file)); }
 
inline Surface LoadSurface(IOStreamParam src, bool closeio = false)
{
  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 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));
}
 
inline bool isAVIF(IOStreamParam src) { return IMG_isAVIF(src); }
 
inline bool isICO(IOStreamParam src) { return IMG_isICO(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 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 isSVG(IOStreamParam src) { return IMG_isSVG(src); }
 
inline bool isQOI(IOStreamParam src) { return IMG_isQOI(src); }
 
inline bool isTIF(IOStreamParam src) { return IMG_isTIF(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 bool isWEBP(IOStreamParam src) { return IMG_isWEBP(src); }
 
inline Surface LoadAVIF(IOStreamParam src)
{
  return Surface(IMG_LoadAVIF_IO(src));
}
 
inline Surface LoadICO(IOStreamParam src)
{
  return Surface{IMG_LoadICO_IO(src)};
}
 
inline Surface LoadCUR(IOStreamParam src)
{
  return Surface{IMG_LoadCUR_IO(src)};
}
 
inline Surface LoadBMP(IOStreamParam src)
{
  return Surface{IMG_LoadBMP_IO(src)};
}
 
inline Surface LoadGIF(IOStreamParam src)
{
  return Surface{IMG_LoadGIF_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 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 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 LoadWEBP(IOStreamParam src)
{
  return Surface{IMG_LoadWEBP_IO(src)};
}
 
inline Surface LoadSizedSVG(IOStreamParam src, const PointRaw& size)
{
  return Surface(IMG_LoadSizedSVG_IO(src, size.x, size.y));
}
 
inline Surface ReadXPMFromArray(char** xpm)
{
  return Surface{IMG_ReadXPMFromArray(xpm)};
}
 
inline Surface ReadXPMFromArrayToRGB888(char** xpm)
{
  return Surface{IMG_ReadXPMFromArrayToRGB888(xpm)};
}
 
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));
}
 
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));
}
 
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));
}
 
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;
};
 
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));
}
 
inline void FreeAnimation(AnimationRaw anim) { IMG_FreeAnimation(anim); }
 
inline void Animation::Free() { FreeAnimation(release()); }
 
inline Animation LoadGIFAnimation(IOStreamParam src)
{
  return Animation(IMG_LoadGIFAnimation_IO(src));
}
 
inline Animation LoadWEBPAnimation(IOStreamParam src)
{
  return Animation{IMG_LoadWEBPAnimation_IO(src)};
}
 
 
} // 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_ */