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 AnimationRef;
 
// Forward decl
struct Animation;
 
using AnimationShared = ResourceShared<Animation>;
 
using AnimationWeak = ResourceWeak<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(IOStreamRef 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(IOStreamRef src)
{
  return Surface{IMG_Load_IO(src.get(), false)};
}
 
inline Texture LoadTexture(RendererRef renderer, StringParam file)
{
  return Texture{IMG_LoadTexture(renderer.get(), file)};
}
 
inline Texture LoadTexture(RendererRef renderer, IOStreamRef src)
{
  return Texture{IMG_LoadTexture_IO(renderer.get(), src.get(), false)};
}
 
inline Texture LoadTexture(RendererRef renderer,
                           IOStreamRef src,
                           StringParam type)
{
  return Texture{
    IMG_LoadTextureTyped_IO(renderer.get(), src.get(), false, type)};
}
 
inline bool isAVIF(IOStreamRef src) { return IMG_isAVIF(src.get()); }
 
inline bool isICO(IOStreamRef src) { return IMG_isICO(src.get()); }
 
inline bool isCUR(IOStreamRef src) { return IMG_isCUR(src.get()); }
 
inline bool isBMP(IOStreamRef src) { return IMG_isBMP(src.get()); }
 
inline bool isGIF(IOStreamRef src) { return IMG_isGIF(src.get()); }
 
inline bool isJPG(IOStreamRef src) { return IMG_isJPG(src.get()); }
 
inline bool isJXL(IOStreamRef src) { return IMG_isJXL(src.get()); }
 
inline bool isLBM(IOStreamRef src) { return IMG_isLBM(src.get()); }
 
inline bool isPCX(IOStreamRef src) { return IMG_isPCX(src.get()); }
 
inline bool isPNG(IOStreamRef src) { return IMG_isPNG(src.get()); }
 
inline bool isPNM(IOStreamRef src) { return IMG_isPNM(src.get()); }
 
inline bool isSVG(IOStreamRef src) { return IMG_isSVG(src.get()); }
 
inline bool isQOI(IOStreamRef src) { return IMG_isQOI(src.get()); }
 
inline bool isTIF(IOStreamRef src) { return IMG_isTIF(src.get()); }
 
inline bool isXCF(IOStreamRef src) { return IMG_isXCF(src.get()); }
 
inline bool isXPM(IOStreamRef src) { return IMG_isXPM(src.get()); }
 
inline bool isXV(IOStreamRef src) { return IMG_isXV(src.get()); }
 
inline bool isWEBP(IOStreamRef src) { return IMG_isWEBP(src.get()); }
 
inline Surface LoadAVIF(IOStreamRef src)
{
  return Surface{IMG_LoadAVIF_IO(src.get())};
}
 
inline Surface LoadICO(IOStreamRef src)
{
  return Surface{IMG_LoadICO_IO(src.get())};
}
 
inline Surface LoadCUR(IOStreamRef src)
{
  return Surface{IMG_LoadCUR_IO(src.get())};
}
 
inline Surface LoadBMP(IOStreamRef src)
{
  return Surface{IMG_LoadBMP_IO(src.get())};
}
 
inline Surface LoadGIF(IOStreamRef src)
{
  return Surface{IMG_LoadGIF_IO(src.get())};
}
 
inline Surface LoadJPG(IOStreamRef src)
{
  return Surface{IMG_LoadJPG_IO(src.get())};
}
 
inline Surface LoadJXL(IOStreamRef src)
{
  return Surface{IMG_LoadJXL_IO(src.get())};
}
 
inline Surface LoadLBM(IOStreamRef src)
{
  return Surface{IMG_LoadLBM_IO(src.get())};
}
 
inline Surface LoadPCX(IOStreamRef src)
{
  return Surface{IMG_LoadPCX_IO(src.get())};
}
 
inline Surface LoadPNG(IOStreamRef src)
{
  return Surface{IMG_LoadPNG_IO(src.get())};
}
 
inline Surface LoadPNM(IOStreamRef src)
{
  return Surface{IMG_LoadPNM_IO(src.get())};
}
 
inline Surface LoadSVG(IOStreamRef src)
{
  return Surface{IMG_LoadSVG_IO(src.get())};
}
 
inline Surface LoadQOI(IOStreamRef src)
{
  return Surface{IMG_LoadQOI_IO(src.get())};
}
 
inline Surface LoadTGA(IOStreamRef src)
{
  return Surface{IMG_LoadTGA_IO(src.get())};
}
 
inline Surface LoadTIF(IOStreamRef src)
{
  return Surface{IMG_LoadTIF_IO(src.get())};
}
 
inline Surface LoadXCF(IOStreamRef src)
{
  return Surface{IMG_LoadXCF_IO(src.get())};
}
 
inline Surface LoadXPM(IOStreamRef src)
{
  return Surface{IMG_LoadXPM_IO(src.get())};
}
 
inline Surface LoadXV(IOStreamRef src)
{
  return Surface{IMG_LoadXV_IO(src.get())};
}
 
inline Surface LoadWEBP(IOStreamRef src)
{
  return Surface{IMG_LoadWEBP_IO(src.get())};
}
 
inline Surface LoadSizedSVG(IOStreamRef 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(SurfaceRef surface, StringParam file, int quality)
{
  CheckError(IMG_SaveAVIF(surface.get(), file, quality));
}
 
inline void SaveAVIF(SurfaceRef surface, IOStreamRef dst, int quality)
{
  CheckError(IMG_SaveAVIF_IO(surface.get(), dst.get(), false, quality));
}
 
inline void SavePNG(SurfaceRef surface, StringParam file)
{
  CheckError(IMG_SavePNG(surface.get(), file));
}
 
inline void SavePNG(SurfaceRef surface, IOStreamRef dst)
{
  CheckError(IMG_SavePNG_IO(surface.get(), dst.get(), false));
}
 
inline void SaveJPG(SurfaceRef surface, StringParam file, int quality)
{
  CheckError(IMG_SaveJPG(surface.get(), file, quality));
}
 
inline void SaveJPG(SurfaceRef surface, IOStreamRef dst, int quality)
{
  CheckError(IMG_SaveJPG_IO(surface.get(), dst.get(), false, quality));
}
 
struct AnimationRef : Resource<IMG_Animation*>
{
  using Resource::Resource;
 
  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]; }
 
  static void reset(IMG_Animation* resource) { IMG_FreeAnimation(resource); }
};
 
struct Animation : ResourceUnique<AnimationRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Animation Load(StringParam file)
  {
    return Animation(IMG_LoadAnimation(file));
  }
 
  static Animation Load(IOStreamRef src)
  {
    return Animation(IMG_LoadAnimation_IO(src, false));
  }
 
  static Animation LoadTyped(IOStreamRef src, StringParam type)
  {
    return Animation(IMG_LoadAnimationTyped_IO(src, false, type));
  }
 
  void Free() { reset(); }
  AnimationShared share();
 
};
 
 
inline AnimationShared Animation::share()
{
  return AnimationShared(std::move(*this));
}
 
struct AnimationUnsafe : ResourceUnsafe<AnimationRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit AnimationUnsafe(Animation&& other)
    : AnimationUnsafe(other.release())
  {
  }
};
 
inline Animation LoadGIFAnimation(IOStreamRef src)
{
  return Animation{IMG_LoadGIFAnimation_IO(src)};
}
 
inline Animation LoadWEBPAnimation(IOStreamRef src)
{
  return Animation{IMG_LoadWEBPAnimation_IO(src)};
}
 
#pragma region impl
 
 
inline Surface Surface::Load(StringParam file)
{
  return Surface(IMG_Load(file));
}
 
inline Surface Surface::Load(IOStreamRef src)
{
  return Surface(IMG_Load_IO(src.get(), false));
}
 
inline Texture Texture::Load(RendererRef renderer, StringParam file)
{
  return Texture(IMG_LoadTexture(renderer.get(), file));
}
 
inline Texture Texture::Load(RendererRef renderer, IOStreamRef src)
{
  return Texture(IMG_LoadTexture_IO(renderer.get(), src.get(), false));
}
 
#pragma endregion impl
 
} // namespace SDL
 
#else // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
namespace SDL {
 
inline Surface Surface::Load(StringParam file)
{
  return Surface(SDL_LoadBMP(file));
}
 
inline Surface Surface::Load(IOStreamRef src)
{
  return Surface(SDL_LoadBMP_IO(src.get(), false));
}
 
inline Texture Texture::Load(RendererRef renderer, StringParam file)
{
  return Texture(LoadTextureBMP(renderer, std::move(file)));
}
 
inline Texture Texture::Load(RendererRef renderer, IOStreamRef src)
{
  return Texture(LoadTextureBMP(renderer, src));
}
 
}
 
#endif // defined(SDL3PP_ENABLE_IMAGE) || defined(SDL3PP_DOC)
 
#endif /* SDL3PP_IMAGE_H_ */