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_DISABLE_IMAGE) && !defined(SDL3PP_ENABLE_IMAGE) &&         \
  __has_include(<SDL3_image/SDL_image.h>)
#define SDL3PP_ENABLE_IMAGE
#endif
 
#if defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
#include <SDL3_image/SDL_image.h>
 
namespace SDL {
 
// Forward decl
struct AnimationBase;
 
// Forward decl
struct AnimationRef;
 
// Forward decl
struct Animation;
 
#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
 
inline int IMG_Version() { return ::IMG_Version(); }
 
inline Surface LoadSurface(IOStreamBase& src, StringParam type)
{
  return Surface{IMG_LoadTyped_IO(src.get(), false, type)};
}
 
inline Surface LoadSurface(StringParam file) { return Surface{IMG_Load(file)}; }
 
inline Surface LoadSurface(IOStreamBase& src)
{
  return Surface{IMG_Load_IO(src.get(), false)};
}
 
inline Texture LoadTexture(RendererBase& renderer, StringParam file)
{
  return Texture{IMG_LoadTexture(renderer.get(), file)};
}
 
inline Texture LoadTexture(RendererBase& renderer, IOStreamBase& src)
{
  return Texture{IMG_LoadTexture_IO(renderer.get(), src.get(), false)};
}
 
inline Texture LoadTexture(RendererBase& renderer,
                           IOStreamBase& src,
                           StringParam type)
{
  return Texture{
    IMG_LoadTextureTyped_IO(renderer.get(), src.get(), false, type)};
}
 
inline bool isAVIF(IOStreamBase& src) { return IMG_isAVIF(src.get()); }
 
inline bool isICO(IOStreamBase& src) { return IMG_isICO(src.get()); }
 
inline bool isCUR(IOStreamBase& src) { return IMG_isCUR(src.get()); }
 
inline bool isBMP(IOStreamBase& src) { return IMG_isBMP(src.get()); }
 
inline bool isGIF(IOStreamBase& src) { return IMG_isGIF(src.get()); }
 
inline bool isJPG(IOStreamBase& src) { return IMG_isJPG(src.get()); }
 
inline bool isJXL(IOStreamBase& src) { return IMG_isJXL(src.get()); }
 
inline bool isLBM(IOStreamBase& src) { return IMG_isLBM(src.get()); }
 
inline bool isPCX(IOStreamBase& src) { return IMG_isPCX(src.get()); }
 
inline bool isPNG(IOStreamBase& src) { return IMG_isPNG(src.get()); }
 
inline bool isPNM(IOStreamBase& src) { return IMG_isPNM(src.get()); }
 
inline bool isSVG(IOStreamBase& src) { return IMG_isSVG(src.get()); }
 
inline bool isQOI(IOStreamBase& src) { return IMG_isQOI(src.get()); }
 
inline bool isTIF(IOStreamBase& src) { return IMG_isTIF(src.get()); }
 
inline bool isXCF(IOStreamBase& src) { return IMG_isXCF(src.get()); }
 
inline bool isXPM(IOStreamBase& src) { return IMG_isXPM(src.get()); }
 
inline bool isXV(IOStreamBase& src) { return IMG_isXV(src.get()); }
 
inline bool isWEBP(IOStreamBase& src) { return IMG_isWEBP(src.get()); }
 
inline Surface LoadAVIF(IOStreamBase& src)
{
  return Surface{IMG_LoadAVIF_IO(src.get())};
}
 
inline Surface LoadICO(IOStreamBase& src)
{
  return Surface{IMG_LoadICO_IO(src.get())};
}
 
inline Surface LoadCUR(IOStreamBase& src)
{
  return Surface{IMG_LoadCUR_IO(src.get())};
}
 
inline Surface LoadGIF(IOStreamBase& src)
{
  return Surface{IMG_LoadGIF_IO(src.get())};
}
 
inline Surface LoadJPG(IOStreamBase& src)
{
  return Surface{IMG_LoadJPG_IO(src.get())};
}
 
inline Surface LoadJXL(IOStreamBase& src)
{
  return Surface{IMG_LoadJXL_IO(src.get())};
}
 
inline Surface LoadLBM(IOStreamBase& src)
{
  return Surface{IMG_LoadLBM_IO(src.get())};
}
 
inline Surface LoadPCX(IOStreamBase& src)
{
  return Surface{IMG_LoadPCX_IO(src.get())};
}
 
inline Surface LoadPNG(IOStreamBase& src)
{
  return Surface{IMG_LoadPNG_IO(src.get())};
}
 
inline Surface LoadPNM(IOStreamBase& src)
{
  return Surface{IMG_LoadPNM_IO(src.get())};
}
 
inline Surface LoadSVG(IOStreamBase& src)
{
  return Surface{IMG_LoadSVG_IO(src.get())};
}
 
inline Surface LoadQOI(IOStreamBase& src)
{
  return Surface{IMG_LoadQOI_IO(src.get())};
}
 
inline Surface LoadTGA(IOStreamBase& src)
{
  return Surface{IMG_LoadTGA_IO(src.get())};
}
 
inline Surface LoadTIF(IOStreamBase& src)
{
  return Surface{IMG_LoadTIF_IO(src.get())};
}
 
inline Surface LoadXCF(IOStreamBase& src)
{
  return Surface{IMG_LoadXCF_IO(src.get())};
}
 
inline Surface LoadXPM(IOStreamBase& src)
{
  return Surface{IMG_LoadXPM_IO(src.get())};
}
 
inline Surface LoadXV(IOStreamBase& src)
{
  return Surface{IMG_LoadXV_IO(src.get())};
}
 
inline Surface LoadWEBP(IOStreamBase& src)
{
  return Surface{IMG_LoadWEBP_IO(src.get())};
}
 
inline Surface LoadSizedSVG(IOStreamBase& src, int width, int height)
{
  return Surface{IMG_LoadSizedSVG_IO(src.get(), width, height)};
}
 
inline Surface ReadXPMFromArray(char** xpm)
{
  return Surface{IMG_ReadXPMFromArray(xpm)};
}
 
inline Surface ReadXPMFromArrayToRGB888(char** xpm)
{
  return Surface{IMG_ReadXPMFromArrayToRGB888(xpm)};
}
 
inline void SaveAVIF(SurfaceBase& surface, StringParam file, int quality)
{
  CheckError(IMG_SaveAVIF(surface.get(), file, quality));
}
 
inline void SaveAVIF(SurfaceRef surface, IOStreamBase& dst, int quality)
{
  CheckError(IMG_SaveAVIF_IO(surface.get(), dst.get(), false, quality));
}
 
inline void SavePNG(SurfaceBase& surface, StringParam file)
{
  CheckError(IMG_SavePNG(surface.get(), file));
}
 
inline void SavePNG(SurfaceRef surface, IOStreamBase& dst)
{
  CheckError(IMG_SavePNG_IO(surface.get(), dst.get(), false));
}
 
inline void SaveJPG(SurfaceBase& surface, StringParam file, int quality)
{
  CheckError(IMG_SaveJPG(surface.get(), file, quality));
}
 
inline void SaveJPG(SurfaceRef surface, IOStreamBase& dst, int quality)
{
  CheckError(IMG_SaveJPG_IO(surface.get(), dst.get(), false, quality));
}
 
struct AnimationBase : Resource<IMG_Animation*>
{
  using Resource::Resource;
 
  AnimationBase(StringParam file)
    : Resource(IMG_LoadAnimation(file))
  {
  }
 
  AnimationBase(IOStreamBase& src)
    : Resource(IMG_LoadAnimation_IO(src.get(), false))
  {
  }
 
  AnimationBase(IOStreamBase& src, StringParam type)
    : Resource(IMG_LoadAnimationTyped_IO(src.get(), false, type))
  {
  }
 
  int GetWidth() const { return get()->w; }
 
  int GetHeight() const { return get()->h; }
 
  Point GetSize() const { return Point(GetWidth(), GetHeight()); }
 
  int GetCount() const { return get()->count; }
 
  SurfaceRef GetFrame(int index) const { return get()->frames[index]; }
 
  int GetDelay(int index) const { return get()->delays[index]; }
};
 
struct AnimationRef : AnimationBase
{
  using AnimationBase::AnimationBase;
 
  constexpr AnimationRef(const AnimationRef& other)
    : AnimationBase(other.get())
  {
  }
 
  constexpr AnimationRef(AnimationRef&& other)
    : AnimationBase(other.release())
  {
  }
 
  constexpr ~AnimationRef() = default;
 
  AnimationRef& operator=(AnimationRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(IMG_Animation* newResource = {})
  {
    IMG_FreeAnimation(release(newResource));
  }
};
 
struct Animation : AnimationRef
{
  using AnimationRef::AnimationRef;
 
  constexpr explicit Animation(IMG_Animation* resource = {}) {}
 
  constexpr Animation(const Animation& other) = delete;
 
  constexpr Animation(Animation&& other) = default;
 
  ~Animation() { reset(); }
 
  Animation& operator=(Animation other)
  {
    AnimationRef::operator=(other.release());
    return *this;
  }
};
 
inline Animation LoadGIFAnimation(IOStreamBase& src)
{
  return Animation{IMG_LoadGIFAnimation_IO(src.get())};
}
 
inline Animation LoadWEBPAnimation(IOStreamBase& src)
{
  return Animation{IMG_LoadWEBPAnimation_IO(src.get())};
}
 
#pragma region impl
 
 
inline SurfaceBase::SurfaceBase(StringParam file)
  : Resource(CheckError(IMG_Load(file)))
{
}
 
inline SurfaceBase::SurfaceBase(IOStreamBase& src)
  : Resource(CheckError(IMG_Load_IO(src.get(), false)))
{
}
 
inline TextureBase::TextureBase(RendererBase& renderer, StringParam file)
  : Resource(CheckError(IMG_LoadTexture(renderer.get(), file)))
{
}
 
inline TextureBase::TextureBase(RendererBase& renderer, IOStream& src)
  : Resource(CheckError(IMG_LoadTexture_IO(renderer.get(), src.get(), false)))
{
}
 
#pragma endregion impl
 
} // namespace SDL
 
#else // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
namespace SDL {
 
inline SurfaceBase::SurfaceBase(StringParam file)
  : Resource(CheckError(SDL_LoadBMP(file)))
{
}
 
inline SurfaceBase::SurfaceBase(IOStreamBase& src)
  : Resource(CheckError(SDL_LoadBMP_IO(src.get(), false)))
{
}
 
inline TextureBase::TextureBase(RendererBase& renderer, StringParam file)
  : Resource(CheckError(LoadTextureBMP(renderer, file).release()))
{
}
 
inline TextureBase::TextureBase(RendererBase& renderer, IOStream& src)
  : Resource(CheckError(LoadTextureBMP(renderer, src).release()))
{
}
 
}
 
#endif // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
#endif /* SDL3PP_IMAGE_H_ */