SDL3pp_surface.h

#ifndef SDL3PP_SURFACE_H_
#define SDL3PP_SURFACE_H_
 
#include <SDL3/SDL_surface.h>
#include "SDL3pp_blendmode.h"
#include "SDL3pp_error.h"
#include "SDL3pp_iostream.h"
#include "SDL3pp_optionalRef.h"
#include "SDL3pp_pixels.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_spanRef.h"
#include "SDL3pp_strings.h"
#include "SDL3pp_version.h"
 
namespace SDL {
 
// Forward decl
struct Surface;
 
using SurfaceRaw = SDL_Surface*;
 
// Forward decl
struct SurfaceRef;
 
struct SurfaceConstRef
{
  const SurfaceRaw value; 
 
  constexpr SurfaceConstRef(const SurfaceRaw value)
    : value(value)
  {
  }
 
  constexpr SurfaceConstRef(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const SurfaceConstRef& other) const = default;
 
  constexpr operator const SurfaceRaw() const { return value; }
 
  constexpr auto operator->() { return value; }
};
 
// Forward decl
struct SurfaceLock;
 
using SurfaceFlags = Uint32;
 
constexpr SurfaceFlags SURFACE_PREALLOCATED =
  SDL_SURFACE_PREALLOCATED; 
 
constexpr SurfaceFlags SURFACE_LOCK_NEEDED =
  SDL_SURFACE_LOCK_NEEDED; 
 
constexpr SurfaceFlags SURFACE_LOCKED =
  SDL_SURFACE_LOCKED; 
 
constexpr SurfaceFlags SURFACE_SIMD_ALIGNED = SDL_SURFACE_SIMD_ALIGNED;
 
constexpr bool MustLock(SurfaceConstRef S) { return SDL_MUSTLOCK((S.value)); }
 
using ScaleMode = SDL_ScaleMode;
 
#if SDL_VERSION_ATLEAST(3, 2, 10)
 
constexpr ScaleMode SCALEMODE_INVALID = SDL_SCALEMODE_INVALID; 
 
#endif // SDL_VERSION_ATLEAST(3, 2, 10)
 
constexpr ScaleMode SCALEMODE_NEAREST =
  SDL_SCALEMODE_NEAREST; 
 
constexpr ScaleMode SCALEMODE_LINEAR =
  SDL_SCALEMODE_LINEAR; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr ScaleMode SCALEMODE_PIXELART = SDL_SCALEMODE_PIXELART;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
using FlipMode = SDL_FlipMode;
 
constexpr FlipMode FLIP_NONE = SDL_FLIP_NONE; 
 
constexpr FlipMode FLIP_HORIZONTAL = SDL_FLIP_HORIZONTAL; 
 
constexpr FlipMode FLIP_VERTICAL = SDL_FLIP_VERTICAL; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr FlipMode FLIP_HORIZONTAL_AND_VERTICAL =
  SDL_FLIP_HORIZONTAL_AND_VERTICAL;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
class Surface
{
  SurfaceRaw m_resource = nullptr;
 
public:
  constexpr Surface(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Surface(const SurfaceRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
  constexpr Surface(const Surface& other)
    : m_resource(other.m_resource)
  {
    if (m_resource) ++m_resource->refcount;
  }
 
  constexpr Surface(Surface&& other) noexcept
    : Surface(other.release())
  {
  }
 
  constexpr Surface(const SurfaceRef& other) = delete;
 
  constexpr Surface(SurfaceRef&& other) = delete;
 
  Surface(const PointRaw& size, PixelFormat format);
 
  Surface(const PointRaw& size, PixelFormat format, void* pixels, int pitch);
 
  Surface(StringParam file);
 
  Surface(IOStreamRef src, bool closeio = false);
 
  static constexpr Surface Borrow(SurfaceRaw resource)
  {
    if (resource) {
      ++resource->refcount;
      return Surface(resource);
    }
    return {};
  }
 
  static Surface LoadBMP(IOStreamRef src, bool closeio = false);
 
  static Surface LoadBMP(StringParam file);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  static Surface LoadPNG(IOStreamRef src, bool closeio = false);
 
  static Surface LoadPNG(StringParam file);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  constexpr const SurfaceRaw operator->() const noexcept { return m_resource; }
 
  constexpr SurfaceRaw operator->() noexcept { return m_resource; }
 
  constexpr operator SurfaceConstRef() const noexcept { return m_resource; }
 
  ~Surface() { SDL_DestroySurface(m_resource); }
 
  constexpr Surface& operator=(Surface&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr Surface& operator=(const Surface& other) noexcept = default;
 
  constexpr SurfaceRaw get() const noexcept { return m_resource; }
 
  constexpr SurfaceRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Surface& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  void Destroy();
 
  constexpr bool MustLock() const { return SDL::MustLock(m_resource); }
 
  PropertiesRef GetProperties() const;
 
  void SetColorspace(Colorspace colorspace);
 
  Colorspace GetColorspace() const;
 
  Palette CreatePalette();
 
  void SetPalette(PaletteRef palette);
 
  Palette GetPalette() const;
 
  void AddAlternateImage(SurfaceRef image);
 
  bool HasAlternateImages() const;
 
  OwnArray<SurfaceRaw> GetImages() const;
 
  void RemoveAlternateImages();
 
  SurfaceLock Lock();
 
  void Unlock(SurfaceLock&& lock);
 
  void SaveBMP(IOStreamRef dst, bool closeio = false) const;
 
  void SaveBMP(StringParam file) const;
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  void SavePNG(IOStreamRef dst, bool closeio = false) const;
 
  void SavePNG(StringParam file) const;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  void SetRLE(bool enabled);
 
  bool HasRLE() const;
 
  void SetColorKey(std::optional<Uint32> key);
 
  void ClearColorKey();
 
  bool HasColorKey() const;
 
  std::optional<Uint32> GetColorKey() const;
 
  void SetColorMod(Uint8 r, Uint8 g, Uint8 b);
 
  void GetColorMod(Uint8* r, Uint8* g, Uint8* b) const;
 
  void SetAlphaMod(Uint8 alpha);
 
  Uint8 GetAlphaMod() const;
 
  void SetMod(Color color);
 
  Color GetMod() const;
 
  void SetBlendMode(BlendMode blendMode);
 
  BlendMode GetBlendMode() const;
 
  bool SetClipRect(OptionalRef<const RectRaw> rect);
 
  void ResetClipRect();
 
  Rect GetClipRect() const;
 
  void Flip(FlipMode flip);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  Surface Rotate(float angle);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  Surface Duplicate() const;
 
  Surface Scale(const PointRaw& size, ScaleMode scaleMode) const;
 
  Surface Convert(PixelFormat format) const;
 
  Surface Convert(PixelFormat format,
                  PaletteRef palette,
                  Colorspace colorspace,
                  PropertiesRef props) const;
 
  void PremultiplyAlpha(bool linear);
 
  void Clear(const FColorRaw& c);
 
  void FillRect(OptionalRef<const RectRaw> rect, Uint32 color);
 
  void Fill(Uint32 color);
 
  void FillRects(SpanRef<const RectRaw> rects, Uint32 color);
 
  void Blit(SurfaceRef src,
            OptionalRef<const RectRaw> srcrect,
            OptionalRef<const RectRaw> dstrect);
 
  void BlitAt(SurfaceRef src,
              OptionalRef<const RectRaw> srcrect,
              const PointRaw& dstpos);
 
  void BlitUnchecked(SurfaceRef src,
                     const RectRaw& srcrect,
                     const RectRaw& dstrect);
 
  void BlitScaled(SurfaceRef src,
                  OptionalRef<const RectRaw> srcrect,
                  OptionalRef<const RectRaw> dstrect,
                  ScaleMode scaleMode);
 
  void BlitUncheckedScaled(SurfaceRef src,
                           const RectRaw& srcrect,
                           const RectRaw& dstrect,
                           ScaleMode scaleMode);
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
  void Stretch(SurfaceRef src,
               OptionalRef<RectRaw> srcrect,
               OptionalRef<RectRaw> dstrect,
               ScaleMode scaleMode);
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
  void BlitTiled(SurfaceRef src,
                 OptionalRef<const RectRaw> srcrect,
                 OptionalRef<const RectRaw> dstrect);
 
  void BlitTiledWithScale(SurfaceRef src,
                          OptionalRef<const RectRaw> srcrect,
                          float scale,
                          ScaleMode scaleMode,
                          OptionalRef<const RectRaw> dstrect);
 
  void Blit9Grid(SurfaceRef src,
                 OptionalRef<const RectRaw> srcrect,
                 int left_width,
                 int right_width,
                 int top_height,
                 int bottom_height,
                 OptionalRef<const RectRaw> dstrect,
                 float scale = 1,
                 ScaleMode scaleMode = SCALEMODE_NEAREST);
 
  Uint32 MapRGB(Uint8 r, Uint8 g, Uint8 b) const;
 
  Uint32 MapRGBA(ColorRaw c) const;
 
  void ReadPixel(const PointRaw& p,
                 Uint8* r,
                 Uint8* g,
                 Uint8* b,
                 Uint8* a) const;
 
  Color ReadPixel(const PointRaw& p) const;
 
  void ReadPixelFloat(const PointRaw& p,
                      float* r,
                      float* g,
                      float* b,
                      float* a) const;
 
  FColor ReadPixelFloat(const PointRaw& p) const;
 
  void WritePixel(const PointRaw& p, ColorRaw c);
 
  void WritePixelFloat(const PointRaw& p, const FColorRaw& c);
 
  constexpr int GetWidth() const;
 
  constexpr int GetHeight() const;
 
  constexpr Point GetSize() const;
 
  constexpr int GetPitch() const;
 
  constexpr PixelFormat GetFormat() const;
 
  constexpr void* GetPixels() const;
};
 
struct SurfaceRef : Surface
{
  using Surface::Surface;
 
  SurfaceRef(SurfaceRaw resource) noexcept
    : Surface(resource)
  {
  }
 
  constexpr SurfaceRef(const Surface& resource) noexcept
    : Surface(resource.get())
  {
  }
 
  constexpr SurfaceRef(const SurfaceRef& other) noexcept
    : Surface(other.get())
  {
  }
 
  constexpr SurfaceRef(SurfaceRef&& other) noexcept
    : Surface(other.release())
  {
  }
 
  ~SurfaceRef() { release(); }
 
  constexpr SurfaceRef& operator=(SurfaceRef other) noexcept
  {
    std::swap(*this, other);
    return *this;
  }
 
  constexpr operator SurfaceRaw() const noexcept { return get(); }
};
 
class SurfaceLock
{
  SurfaceRef m_lock;
 
public:
  SurfaceLock(SurfaceRef resource);
 
  SurfaceLock(const SurfaceLock& other) = delete;
 
  constexpr SurfaceLock(SurfaceLock&& other) noexcept
    : m_lock(other.m_lock)
  {
    other.m_lock = {};
  }
 
  ~SurfaceLock() { reset(); }
 
  SurfaceLock& operator=(const SurfaceLock& other) = delete;
 
  SurfaceLock& operator=(SurfaceLock&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    return *this;
  }
 
  constexpr operator bool() const { return bool(m_lock); }
 
  void ReadPixel(const PointRaw& p,
                 Uint8* r,
                 Uint8* g,
                 Uint8* b,
                 Uint8* a) const
  {
    m_lock.ReadPixel(p, r, g, b, a);
  }
 
  Color ReadPixel(const PointRaw& p) const { return m_lock.ReadPixel(p); }
 
  void ReadPixelFloat(const PointRaw& p,
                      float* r,
                      float* g,
                      float* b,
                      float* a) const
  {
    m_lock.ReadPixelFloat(p, r, g, b, a);
  }
 
  FColor ReadPixelFloat(const PointRaw& p) const
  {
    return m_lock.ReadPixelFloat(p);
  }
 
  void WritePixel(const PointRaw& p, ColorRaw c) { m_lock.WritePixel(p, c); }
 
  void WritePixelFloat(const PointRaw& p, const FColorRaw& c)
  {
    m_lock.WritePixelFloat(p, c);
  }
 
  constexpr int GetWidth() const { return m_lock.GetWidth(); }
 
  constexpr int GetHeight() const { return m_lock.GetHeight(); }
 
  constexpr Point GetSize() const { return m_lock.GetSize(); }
 
  constexpr int GetPitch() const { return m_lock.GetPitch(); }
 
  constexpr PixelFormat GetFormat() const { return m_lock.GetFormat(); }
 
  constexpr void* GetPixels() const { return m_lock.GetPixels(); }
 
  void reset();
 
  SurfaceRef get() { return m_lock; }
 
  void release() { m_lock.release(); }
};
 
inline Surface CreateSurface(const PointRaw& size, PixelFormat format)
{
  return Surface(size, format);
}
 
inline Surface::Surface(const PointRaw& size, PixelFormat format)
  : m_resource(CheckError(SDL_CreateSurface(size.x, size.y, format)))
{
}
 
inline Surface::Surface(const PointRaw& size,
                        PixelFormat format,
                        void* pixels,
                        int pitch)
  : m_resource(
      CheckError(SDL_CreateSurfaceFrom(size.x, size.y, format, pixels, pitch)))
{
}
 
inline Surface CreateSurfaceFrom(const PointRaw& size,
                                 PixelFormat format,
                                 void* pixels,
                                 int pitch)
{
  return Surface(size, format, pixels, pitch);
}
 
inline void DestroySurface(SurfaceRaw surface) { SDL_DestroySurface(surface); }
 
inline void Surface::Destroy() { DestroySurface(release()); }
 
inline PropertiesRef GetSurfaceProperties(SurfaceConstRef surface)
{
  return {CheckError(SDL_GetSurfaceProperties(surface))};
}
 
inline PropertiesRef Surface::GetProperties() const
{
  return SDL::GetSurfaceProperties(m_resource);
}
 
namespace prop::Surface {
 
constexpr auto SDR_WHITE_POINT_FLOAT = SDL_PROP_SURFACE_SDR_WHITE_POINT_FLOAT;
 
constexpr auto HDR_HEADROOM_FLOAT = SDL_PROP_SURFACE_HDR_HEADROOM_FLOAT;
 
constexpr auto TONEMAP_OPERATOR_STRING =
  SDL_PROP_SURFACE_TONEMAP_OPERATOR_STRING;
 
#if SDL_VERSION_ATLEAST(3, 2, 6)
 
constexpr auto HOTSPOT_X_NUMBER = SDL_PROP_SURFACE_HOTSPOT_X_NUMBER;
 
constexpr auto HOTSPOT_Y_NUMBER = SDL_PROP_SURFACE_HOTSPOT_Y_NUMBER;
 
#endif // SDL_VERSION_ATLEAST(3, 2, 6)
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto ROTATION_FLOAT = SDL_PROP_SURFACE_ROTATION_FLOAT;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
} // namespace prop::Surface
 
inline void SetSurfaceColorspace(SurfaceRef surface, Colorspace colorspace)
{
  CheckError(SDL_SetSurfaceColorspace(surface, colorspace));
}
 
inline void Surface::SetColorspace(Colorspace colorspace)
{
  SDL::SetSurfaceColorspace(m_resource, colorspace);
}
 
inline Colorspace GetSurfaceColorspace(SurfaceConstRef surface)
{
  return SDL_GetSurfaceColorspace(surface);
}
 
inline Colorspace Surface::GetColorspace() const
{
  return SDL::GetSurfaceColorspace(m_resource);
}
 
inline Palette CreateSurfacePalette(SurfaceRef surface)
{
  return Palette::Borrow(CheckError(SDL_CreateSurfacePalette(surface)));
}
 
inline Palette Surface::CreatePalette()
{
  return SDL::CreateSurfacePalette(m_resource);
}
 
inline void SetSurfacePalette(SurfaceRef surface, PaletteRef palette)
{
  CheckError(SDL_SetSurfacePalette(surface, palette));
}
 
inline void Surface::SetPalette(PaletteRef palette)
{
  SDL::SetSurfacePalette(m_resource, palette);
}
 
inline Palette GetSurfacePalette(SurfaceConstRef surface)
{
  return Palette::Borrow(SDL_GetSurfacePalette(surface));
}
 
inline Palette Surface::GetPalette() const
{
  return SDL::GetSurfacePalette(m_resource);
}
 
inline void AddSurfaceAlternateImage(SurfaceRef surface, SurfaceRef image)
{
  CheckError(SDL_AddSurfaceAlternateImage(surface, image));
}
 
inline void Surface::AddAlternateImage(SurfaceRef image)
{
  SDL::AddSurfaceAlternateImage(m_resource, image);
}
 
inline bool SurfaceHasAlternateImages(SurfaceConstRef surface)
{
  return SDL_SurfaceHasAlternateImages(surface);
}
 
inline bool Surface::HasAlternateImages() const
{
  return SDL::SurfaceHasAlternateImages(m_resource);
}
 
inline OwnArray<SurfaceRaw> GetSurfaceImages(SurfaceConstRef surface)
{
  int count = 0;
  auto data = SDL_GetSurfaceImages(surface, &count);
  return OwnArray<SurfaceRaw>(CheckError(data), count);
}
 
inline OwnArray<SurfaceRaw> Surface::GetImages() const
{
  return SDL::GetSurfaceImages(m_resource);
}
 
inline void RemoveSurfaceAlternateImages(SurfaceRef surface)
{
  SDL_RemoveSurfaceAlternateImages(surface);
}
 
inline void Surface::RemoveAlternateImages()
{
  SDL::RemoveSurfaceAlternateImages(m_resource);
}
 
inline void LockSurface(SurfaceRef surface)
{
  CheckError(SDL_LockSurface(surface));
}
 
inline SurfaceLock Surface::Lock() { return {SurfaceRef(*this)}; }
 
inline SurfaceLock::SurfaceLock(SurfaceRef resource)
  : m_lock(std::move(resource))
{
  LockSurface(m_lock);
}
 
inline void UnlockSurface(SurfaceRef surface) { SDL_UnlockSurface(surface); }
 
inline void Surface::Unlock(SurfaceLock&& lock)
{
  SDL_assert_paranoid(lock.get() == *this);
  lock.reset();
}
 
inline void SurfaceLock::reset()
{
  if (!m_lock) return;
  UnlockSurface(m_lock);
  m_lock = {};
}
 
#ifndef SDL3PP_ENABLE_IMAGE
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline Surface LoadSurface(IOStreamRef src, bool closeio = false)
{
  return Surface{SDL_LoadSurface_IO(src, closeio)};
}
 
inline Surface LoadSurface(StringParam file)
{
  return Surface{SDL_LoadSurface(file)};
}
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
#endif // SDL3PP_ENABLE_IMAGE
 
inline Surface LoadBMP(IOStreamRef src, bool closeio = false)
{
  return Surface(SDL_LoadBMP_IO(src, closeio));
}
 
inline Surface LoadBMP(StringParam file) { return Surface(SDL_LoadBMP(file)); }
 
inline Surface Surface::LoadBMP(IOStreamRef src, bool closeio)
{
  return SDL::LoadBMP(src, closeio);
}
 
inline Surface Surface::LoadBMP(StringParam file)
{
  return SDL::LoadBMP(std::move(file));
}
 
inline void SaveBMP(SurfaceConstRef surface,
                    IOStreamRef dst,
                    bool closeio = false)
{
  CheckError(SDL_SaveBMP_IO(surface, dst, closeio));
}
 
inline void SaveBMP(SurfaceConstRef surface, StringParam file)
{
  CheckError(SDL_SaveBMP(surface, file));
}
 
inline void Surface::SaveBMP(IOStreamRef dst, bool closeio) const
{
  SDL::SaveBMP(m_resource, dst, closeio);
}
 
inline void Surface::SaveBMP(StringParam file) const
{
  SDL::SaveBMP(m_resource, std::move(file));
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline Surface LoadPNG(IOStreamRef src, bool closeio = false)
{
  return Surface(SDL_LoadPNG_IO(src, closeio));
}
 
inline Surface LoadPNG(StringParam file) { return Surface(SDL_LoadPNG(file)); }
 
inline Surface Surface::LoadPNG(IOStreamRef src, bool closeio)
{
  return SDL::LoadPNG(src, closeio);
}
 
inline Surface Surface::LoadPNG(StringParam file)
{
  return SDL::LoadPNG(std::move(file));
}
 
inline void SavePNG(SurfaceConstRef surface,
                    IOStreamRef dst,
                    bool closeio = false)
{
  CheckError(SDL_SavePNG_IO(surface, dst, closeio));
}
 
inline void SavePNG(SurfaceConstRef surface, StringParam file)
{
  CheckError(SDL_SavePNG(surface, file));
}
 
inline void Surface::SavePNG(IOStreamRef dst, bool closeio) const
{
  SDL::SavePNG(m_resource, dst, closeio);
}
 
inline void Surface::SavePNG(StringParam file) const
{
  SDL::SavePNG(m_resource, std::move(file));
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void SetSurfaceRLE(SurfaceRef surface, bool enabled)
{
  CheckError(SDL_SetSurfaceRLE(surface, enabled));
}
 
inline void Surface::SetRLE(bool enabled)
{
  SDL::SetSurfaceRLE(m_resource, enabled);
}
 
inline bool SurfaceHasRLE(SurfaceConstRef surface)
{
  return SDL_SurfaceHasRLE(surface);
}
 
inline bool Surface::HasRLE() const { return SDL::SurfaceHasRLE(m_resource); }
 
inline void SetSurfaceColorKey(SurfaceRef surface, std::optional<Uint32> key)
{
  CheckError(SDL_SetSurfaceColorKey(surface, key.has_value(), key.value_or(0)));
}
 
inline void Surface::SetColorKey(std::optional<Uint32> key)
{
  SDL::SetSurfaceColorKey(m_resource, key);
}
 
inline void ClearSurfaceColorKey(SurfaceRef surface)
{
  SetSurfaceColorKey(surface, std::nullopt);
}
 
inline void Surface::ClearColorKey() { SDL::ClearSurfaceColorKey(m_resource); }
 
inline bool SurfaceHasColorKey(SurfaceConstRef surface)
{
  return SDL_SurfaceHasColorKey(surface);
}
 
inline bool Surface::HasColorKey() const
{
  return SDL::SurfaceHasColorKey(m_resource);
}
 
inline std::optional<Uint32> GetSurfaceColorKey(SurfaceConstRef surface)
{
  if (Uint32 key; SDL_GetSurfaceColorKey(surface, &key)) return key;
  return std::nullopt;
}
 
inline std::optional<Uint32> Surface::GetColorKey() const
{
  return SDL::GetSurfaceColorKey(m_resource);
}
 
inline void SetSurfaceColorMod(SurfaceRef surface, Uint8 r, Uint8 g, Uint8 b)
{
  CheckError(SDL_SetSurfaceColorMod(surface, r, g, b));
}
 
inline void Surface::SetColorMod(Uint8 r, Uint8 g, Uint8 b)
{
  SDL::SetSurfaceColorMod(m_resource, r, g, b);
}
 
inline void GetSurfaceColorMod(SurfaceConstRef surface,
                               Uint8* r,
                               Uint8* g,
                               Uint8* b)
{
  CheckError(SDL_GetSurfaceColorMod(surface, r, g, b));
}
 
inline void Surface::GetColorMod(Uint8* r, Uint8* g, Uint8* b) const
{
  SDL::GetSurfaceColorMod(m_resource, r, g, b);
}
 
inline void SetSurfaceAlphaMod(SurfaceRef surface, Uint8 alpha)
{
  CheckError(SDL_SetSurfaceAlphaMod(surface, alpha));
}
 
inline void Surface::SetAlphaMod(Uint8 alpha)
{
  SDL::SetSurfaceAlphaMod(m_resource, alpha);
}
 
inline Uint8 GetSurfaceAlphaMod(SurfaceConstRef surface)
{
  Uint8 alpha;
  CheckError(SDL_GetSurfaceAlphaMod(surface, &alpha));
  return alpha;
}
 
inline Uint8 Surface::GetAlphaMod() const
{
  return SDL::GetSurfaceAlphaMod(m_resource);
}
 
inline void SetSurfaceMod(SurfaceRef surface, Color color)
{
  SetSurfaceColorMod(surface, color.r, color.g, color.b);
  SetSurfaceAlphaMod(surface, color.a);
}
 
inline void Surface::SetMod(Color color) { SetSurfaceMod(m_resource, color); }
 
inline Color GetSurfaceMod(SurfaceConstRef surface)
{
  Color c;
  GetSurfaceColorMod(surface, &c.r, &c.g, &c.b);
  c.a = GetSurfaceAlphaMod(surface);
  return c;
}
 
inline Color Surface::GetMod() const { return SDL::GetSurfaceMod(m_resource); }
 
inline void SetSurfaceBlendMode(SurfaceRef surface, BlendMode blendMode)
{
  CheckError(SDL_SetSurfaceBlendMode(surface, blendMode));
}
 
inline void Surface::SetBlendMode(BlendMode blendMode)
{
  SDL::SetSurfaceBlendMode(m_resource, blendMode);
}
 
inline BlendMode GetSurfaceBlendMode(SurfaceConstRef surface)
{
  BlendMode blendmode;
  CheckError(SDL_GetSurfaceBlendMode(surface, &blendmode));
  return blendmode;
}
 
inline BlendMode Surface::GetBlendMode() const
{
  return SDL::GetSurfaceBlendMode(m_resource);
}
 
inline bool SetSurfaceClipRect(SurfaceRef surface,
                               OptionalRef<const RectRaw> rect)
{
  return SDL_SetSurfaceClipRect(surface, rect);
}
 
inline bool Surface::SetClipRect(OptionalRef<const RectRaw> rect)
{
  return SDL::SetSurfaceClipRect(m_resource, rect);
}
 
inline void ResetSurfaceClipRect(SurfaceRef surface)
{
  SetSurfaceClipRect(surface, std::nullopt);
}
 
inline void Surface::ResetClipRect() { SDL::ResetSurfaceClipRect(m_resource); }
 
inline Rect GetSurfaceClipRect(SurfaceConstRef surface)
{
  Rect r;
  CheckError(SDL_GetSurfaceClipRect(surface, &r));
  return r;
}
 
inline Rect Surface::GetClipRect() const
{
  return SDL::GetSurfaceClipRect(m_resource);
}
 
inline void FlipSurface(SurfaceRef surface, FlipMode flip)
{
  CheckError(SDL_FlipSurface(surface, flip));
}
 
inline void Surface::Flip(FlipMode flip) { SDL::FlipSurface(m_resource, flip); }
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline Surface RotateSurface(SurfaceRef surface, float angle)
{
  return Surface{SDL_RotateSurface(surface, angle)};
}
 
inline Surface Surface::Rotate(float angle)
{
  return SDL::RotateSurface(m_resource, angle);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline Surface DuplicateSurface(SurfaceConstRef surface)
{
  return Surface(SDL_DuplicateSurface(surface));
}
 
inline Surface Surface::Duplicate() const
{
  return SDL::DuplicateSurface(m_resource);
}
 
inline Surface ScaleSurface(SurfaceConstRef surface,
                            const PointRaw& size,
                            ScaleMode scaleMode)
{
  return Surface(SDL_ScaleSurface(surface, size.x, size.y, scaleMode));
}
 
inline Surface Surface::Scale(const PointRaw& size, ScaleMode scaleMode) const
{
  return SDL::ScaleSurface(m_resource, size, scaleMode);
}
 
inline Surface ConvertSurface(SurfaceConstRef surface, PixelFormat format)
{
  return Surface(SDL_ConvertSurface(surface, format));
}
 
inline Surface Surface::Convert(PixelFormat format) const
{
  return SDL::ConvertSurface(m_resource, format);
}
 
inline Surface ConvertSurfaceAndColorspace(SurfaceConstRef surface,
                                           PixelFormat format,
                                           PaletteRef palette,
                                           Colorspace colorspace,
                                           PropertiesRef props)
{
  return Surface{SDL_ConvertSurfaceAndColorspace(
    surface, format, palette, colorspace, props)};
}
 
inline Surface Surface::Convert(PixelFormat format,
                                PaletteRef palette,
                                Colorspace colorspace,
                                PropertiesRef props) const
{
  return SDL::ConvertSurfaceAndColorspace(
    m_resource, format, palette, colorspace, props);
}
 
inline void ConvertPixels(const PointRaw& size,
                          PixelFormat src_format,
                          const void* src,
                          int src_pitch,
                          PixelFormat dst_format,
                          void* dst,
                          int dst_pitch)
{
  CheckError(SDL_ConvertPixels(
    size.x, size.y, src_format, src, src_pitch, dst_format, dst, dst_pitch));
}
 
inline void ConvertPixelsAndColorspace(const PointRaw& size,
                                       PixelFormat src_format,
                                       Colorspace src_colorspace,
                                       PropertiesRef src_properties,
                                       const void* src,
                                       int src_pitch,
                                       PixelFormat dst_format,
                                       Colorspace dst_colorspace,
                                       PropertiesRef dst_properties,
                                       void* dst,
                                       int dst_pitch)
{
  CheckError(SDL_ConvertPixelsAndColorspace(size.x,
                                            size.y,
                                            src_format,
                                            src_colorspace,
                                            src_properties,
                                            src,
                                            src_pitch,
                                            dst_format,
                                            dst_colorspace,
                                            dst_properties,
                                            dst,
                                            dst_pitch));
}
 
inline void PremultiplyAlpha(const PointRaw& size,
                             PixelFormat src_format,
                             const void* src,
                             int src_pitch,
                             PixelFormat dst_format,
                             void* dst,
                             int dst_pitch,
                             bool linear)
{
  CheckError(SDL_PremultiplyAlpha(size.x,
                                  size.y,
                                  src_format,
                                  src,
                                  src_pitch,
                                  dst_format,
                                  dst,
                                  dst_pitch,
                                  linear));
}
 
inline void PremultiplySurfaceAlpha(SurfaceRef surface, bool linear)
{
  CheckError(SDL_PremultiplySurfaceAlpha(surface, linear));
}
 
inline void Surface::PremultiplyAlpha(bool linear)
{
  SDL::PremultiplySurfaceAlpha(m_resource, linear);
}
 
inline void ClearSurface(SurfaceRef surface, const FColorRaw& c)
{
  CheckError(SDL_ClearSurface(surface, c.r, c.g, c.b, c.a));
}
 
inline void Surface::Clear(const FColorRaw& c)
{
  SDL::ClearSurface(m_resource, c);
}
 
inline void FillSurfaceRect(SurfaceRef dst,
                            OptionalRef<const RectRaw> rect,
                            Uint32 color)
{
  CheckError(SDL_FillSurfaceRect(dst, rect, color));
}
 
inline void Surface::FillRect(OptionalRef<const RectRaw> rect, Uint32 color)
{
  SDL::FillSurfaceRect(m_resource, rect, color);
}
 
inline void FillSurface(SurfaceRef dst, Uint32 color)
{
  FillSurfaceRect(dst, std::nullopt, color);
}
 
inline void Surface::Fill(Uint32 color) { SDL::FillSurface(m_resource, color); }
 
inline void FillSurfaceRects(SurfaceRef dst,
                             SpanRef<const RectRaw> rects,
                             Uint32 color)
{
  CheckError(SDL_FillSurfaceRects(dst, rects.data(), rects.size(), color));
}
 
inline void Surface::FillRects(SpanRef<const RectRaw> rects, Uint32 color)
{
  SDL::FillSurfaceRects(m_resource, rects, color);
}
 
inline void BlitSurface(SurfaceRef src,
                        OptionalRef<const RectRaw> srcrect,
                        SurfaceRef dst,
                        OptionalRef<const RectRaw> dstrect)
{
  CheckError(SDL_BlitSurface(src, srcrect, dst, dstrect));
}
 
inline void Surface::Blit(SurfaceRef src,
                          OptionalRef<const RectRaw> srcrect,
                          OptionalRef<const RectRaw> dstrect)
{
  SDL::BlitSurface(src, srcrect, m_resource, dstrect);
}
 
inline void Surface::BlitAt(SurfaceRef src,
                            OptionalRef<const RectRaw> srcrect,
                            const PointRaw& dstpos)
{
  Blit(src, srcrect, Rect{dstpos, {}});
}
 
inline void BlitSurfaceAt(SurfaceRef src,
                          OptionalRef<const RectRaw> srcrect,
                          SurfaceRef dst,
                          const PointRaw& dstpos)
{
  BlitSurface(src, srcrect, dst, SDL_Rect{dstpos.x, dstpos.y});
}
 
inline void BlitSurfaceUnchecked(SurfaceRef src,
                                 const RectRaw& srcrect,
                                 SurfaceRef dst,
                                 const RectRaw& dstrect)
{
  CheckError(SDL_BlitSurfaceUnchecked(src, &srcrect, dst, &dstrect));
}
 
inline void Surface::BlitUnchecked(SurfaceRef src,
                                   const RectRaw& srcrect,
                                   const RectRaw& dstrect)
{
  SDL::BlitSurfaceUnchecked(src, srcrect, m_resource, dstrect);
}
 
inline void BlitSurfaceScaled(SurfaceRef src,
                              OptionalRef<const RectRaw> srcrect,
                              SurfaceRef dst,
                              OptionalRef<const RectRaw> dstrect,
                              ScaleMode scaleMode)
{
  CheckError(SDL_BlitSurfaceScaled(src, srcrect, dst, dstrect, scaleMode));
}
 
inline void Surface::BlitScaled(SurfaceRef src,
                                OptionalRef<const RectRaw> srcrect,
                                OptionalRef<const RectRaw> dstrect,
                                ScaleMode scaleMode)
{
  SDL::BlitSurfaceScaled(src, srcrect, m_resource, dstrect, scaleMode);
}
 
inline void BlitSurfaceUncheckedScaled(SurfaceRef src,
                                       const RectRaw& srcrect,
                                       SurfaceRef dst,
                                       const RectRaw& dstrect,
                                       ScaleMode scaleMode)
{
  CheckError(
    SDL_BlitSurfaceUncheckedScaled(src, &srcrect, dst, &dstrect, scaleMode));
}
 
inline void Surface::BlitUncheckedScaled(SurfaceRef src,
                                         const RectRaw& srcrect,
                                         const RectRaw& dstrect,
                                         ScaleMode scaleMode)
{
  SDL::BlitSurfaceUncheckedScaled(src, srcrect, m_resource, dstrect, scaleMode);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void StretchSurface(SurfaceRef src,
                           OptionalRef<RectRaw> srcrect,
                           SurfaceRef dst,
                           OptionalRef<RectRaw> dstrect,
                           ScaleMode scaleMode)
{
  CheckError(SDL_StretchSurface(src, srcrect, dst, dstrect, scaleMode));
}
 
inline void Surface::Stretch(SurfaceRef src,
                             OptionalRef<RectRaw> srcrect,
                             OptionalRef<RectRaw> dstrect,
                             ScaleMode scaleMode)
{
  SDL::StretchSurface(src, srcrect, m_resource, dstrect, scaleMode);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void BlitSurfaceTiled(SurfaceRef src,
                             OptionalRef<const RectRaw> srcrect,
                             SurfaceRef dst,
                             OptionalRef<const RectRaw> dstrect)
{
  CheckError(SDL_BlitSurfaceTiled(src, srcrect, dst, dstrect));
}
 
inline void Surface::BlitTiled(SurfaceRef src,
                               OptionalRef<const RectRaw> srcrect,
                               OptionalRef<const RectRaw> dstrect)
{
  SDL::BlitSurfaceTiled(src, srcrect, m_resource, dstrect);
}
 
inline void BlitSurfaceTiledWithScale(SurfaceRef src,
                                      OptionalRef<const RectRaw> srcrect,
                                      float scale,
                                      ScaleMode scaleMode,
                                      SurfaceRef dst,
                                      OptionalRef<const RectRaw> dstrect)
{
  CheckError(SDL_BlitSurfaceTiledWithScale(
    src, srcrect, scale, scaleMode, dst, dstrect));
}
 
inline void Surface::BlitTiledWithScale(SurfaceRef src,
                                        OptionalRef<const RectRaw> srcrect,
                                        float scale,
                                        ScaleMode scaleMode,
                                        OptionalRef<const RectRaw> dstrect)
{
  SDL::BlitSurfaceTiledWithScale(
    src, srcrect, scale, scaleMode, m_resource, dstrect);
}
 
inline void BlitSurface9Grid(SurfaceRef src,
                             OptionalRef<const RectRaw> srcrect,
                             int left_width,
                             int right_width,
                             int top_height,
                             int bottom_height,
                             SurfaceRef dst,
                             OptionalRef<const RectRaw> dstrect,
                             float scale = 1,
                             ScaleMode scaleMode = SCALEMODE_NEAREST)
{
  CheckError(SDL_BlitSurface9Grid(src,
                                  srcrect,
                                  left_width,
                                  right_width,
                                  top_height,
                                  bottom_height,
                                  scale,
                                  scaleMode,
                                  dst,
                                  dstrect));
}
 
inline void Surface::Blit9Grid(SurfaceRef src,
                               OptionalRef<const RectRaw> srcrect,
                               int left_width,
                               int right_width,
                               int top_height,
                               int bottom_height,
                               OptionalRef<const RectRaw> dstrect,
                               float scale,
                               ScaleMode scaleMode)
{
  SDL::BlitSurface9Grid(src,
                        srcrect,
                        left_width,
                        right_width,
                        top_height,
                        bottom_height,
                        m_resource,
                        dstrect,
                        scale,
                        scaleMode);
}
 
inline Uint32 MapSurfaceRGB(SurfaceConstRef surface, Uint8 r, Uint8 g, Uint8 b)
{
  return SDL_MapSurfaceRGB(surface, r, g, b);
}
 
inline Uint32 Surface::MapRGB(Uint8 r, Uint8 g, Uint8 b) const
{
  return SDL::MapSurfaceRGB(m_resource, r, g, b);
}
 
inline Uint32 MapSurfaceRGBA(SurfaceConstRef surface, ColorRaw c)
{
  return SDL_MapSurfaceRGBA(surface, c.r, c.g, c.b, c.a);
}
 
inline Uint32 Surface::MapRGBA(ColorRaw c) const
{
  return SDL::MapSurfaceRGBA(m_resource, c);
}
 
inline void ReadSurfacePixel(SurfaceConstRef surface,
                             const PointRaw& p,
                             Uint8* r,
                             Uint8* g,
                             Uint8* b,
                             Uint8* a)
{
  CheckError(SDL_ReadSurfacePixel(surface, p.x, p.y, r, g, b, a));
}
 
inline Color ReadSurfacePixel(SurfaceConstRef surface, const PointRaw& p)
{
  Color c;
  ReadSurfacePixel(surface, p, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void ReadSurfacePixel(const SurfaceLock& lock,
                             const PointRaw& p,
                             Uint8* r,
                             Uint8* g,
                             Uint8* b,
                             Uint8* a)
{
  lock.ReadPixel(p, r, g, b, a);
}
 
inline Color ReadSurfacePixel(const SurfaceLock& lock, const PointRaw& p)
{
  return lock.ReadPixel(p);
}
 
inline void Surface::ReadPixel(const PointRaw& p,
                               Uint8* r,
                               Uint8* g,
                               Uint8* b,
                               Uint8* a) const
{
  SDL::ReadSurfacePixel(m_resource, p, r, g, b, a);
}
 
inline Color Surface::ReadPixel(const PointRaw& p) const
{
  return SDL::ReadSurfacePixel(m_resource, p);
}
 
inline void ReadSurfacePixelFloat(SurfaceConstRef surface,
                                  const PointRaw& p,
                                  float* r,
                                  float* g,
                                  float* b,
                                  float* a)
{
  CheckError(SDL_ReadSurfacePixelFloat(surface, p.x, p.y, r, g, b, a));
}
 
inline FColor ReadSurfacePixelFloat(SurfaceConstRef surface, const PointRaw& p)
{
  FColor c;
  ReadSurfacePixelFloat(surface, p, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void ReadSurfacePixelFloat(const SurfaceLock& lock,
                                  const PointRaw& p,
                                  float* r,
                                  float* g,
                                  float* b,
                                  float* a)
{
  lock.ReadPixelFloat(p, r, g, b, a);
}
 
inline FColor ReadSurfacePixelFloat(const SurfaceLock& lock, const PointRaw& p)
{
  return lock.ReadPixelFloat(p);
}
 
inline void Surface::ReadPixelFloat(const PointRaw& p,
                                    float* r,
                                    float* g,
                                    float* b,
                                    float* a) const
{
  SDL::ReadSurfacePixelFloat(m_resource, p, r, g, b, a);
}
 
inline FColor Surface::ReadPixelFloat(const PointRaw& p) const
{
  return SDL::ReadSurfacePixelFloat(m_resource, p);
}
 
inline void WriteSurfacePixel(SurfaceRef surface, const PointRaw& p, ColorRaw c)
{
  CheckError(SDL_WriteSurfacePixel(surface, p.x, p.y, c.r, c.g, c.b, c.a));
}
 
inline void WriteSurfacePixel(SurfaceLock& lock, const PointRaw& p, ColorRaw c)
{
  lock.WritePixel(p, c);
}
 
inline void Surface::WritePixel(const PointRaw& p, ColorRaw c)
{
  SDL::WriteSurfacePixel(m_resource, p, c);
}
 
inline void WriteSurfacePixelFloat(SurfaceRef surface,
                                   const PointRaw& p,
                                   const FColorRaw& c)
{
  CheckError(SDL_WriteSurfacePixelFloat(surface, p.x, p.y, c.r, c.g, c.b, c.a));
}
 
inline void WriteSurfacePixelFloat(SurfaceLock& lock,
                                   const PointRaw& p,
                                   const FColorRaw& c)
{
  lock.WritePixelFloat(p, c);
}
 
inline void Surface::WritePixelFloat(const PointRaw& p, const FColorRaw& c)
{
  SDL::WriteSurfacePixelFloat(m_resource, p, c);
}
 
constexpr int GetSurfaceWidth(SurfaceConstRef surface) { return surface->w; }
 
constexpr int GetSurfaceWidth(const SurfaceLock& lock)
{
  return lock.GetWidth();
}
 
constexpr int Surface::GetWidth() const
{
  return SDL::GetSurfaceWidth(m_resource);
}
 
constexpr int GetSurfaceHeight(SurfaceConstRef surface) { return surface->h; }
 
constexpr int GetSurfaceHeight(const SurfaceLock& lock)
{
  return lock.GetHeight();
}
 
constexpr int Surface::GetHeight() const
{
  return SDL::GetSurfaceHeight(m_resource);
}
 
constexpr Point GetSurfaceSize(SurfaceConstRef surface)
{
  return Point(surface->w, surface->h);
}
 
constexpr Point GetSurfaceSize(const SurfaceLock& lock)
{
  return lock.GetSize();
}
 
constexpr Point Surface::GetSize() const
{
  return SDL::GetSurfaceSize(m_resource);
}
 
constexpr int GetSurfacePitch(SurfaceConstRef surface)
{
  return surface->pitch;
}
 
constexpr int GetSurfacePitch(const SurfaceLock& lock)
{
  return lock.GetPitch();
}
 
constexpr int Surface::GetPitch() const
{
  return SDL::GetSurfacePitch(m_resource);
}
 
constexpr PixelFormat GetSurfaceFormat(SurfaceConstRef surface)
{
  return surface->format;
}
 
constexpr PixelFormat GetSurfaceFormat(const SurfaceLock& lock)
{
  return lock.GetFormat();
}
 
constexpr PixelFormat Surface::GetFormat() const
{
  return SDL::GetSurfaceFormat(m_resource);
}
 
constexpr void* GetSurfacePixels(SurfaceConstRef surface)
{
  return surface->pixels;
}
 
constexpr void* GetSurfacePixels(const SurfaceLock& lock)
{
  return lock.GetPixels();
}
 
constexpr void* Surface::GetPixels() const
{
  return SDL::GetSurfacePixels(m_resource);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_SURFACE_H_ */