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 SurfaceBase;
 
// Forward decl
struct Surface;

using SurfaceRaw = SDL_Surface*;

using SurfaceRawConst = const SDL_Surface*;

using SurfaceRef = ResourceRefT<SurfaceBase>;

using SurfaceConstRef = ResourceConstRef<SurfaceRaw, SurfaceRawConst>;
 
// 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((static_cast<SurfaceRawConst>(S)));
}

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)

struct SurfaceBase : ResourceBaseT<SurfaceRaw, SurfaceRawConst>
{
  using ResourceBaseT::ResourceBaseT;

  constexpr operator SurfaceConstRef() const noexcept { return get(); }

  void Destroy();

  constexpr bool MustLock() const { return SDL::MustLock(get()); }

  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_IO(IOStreamRef dst, bool closeio = false) const;

  void SaveBMP(StringParam file) const;

  void SavePNG_IO(IOStreamRef dst, bool closeio = false) const;

  void SavePNG(StringParam file) const;

  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;

  void Save(StringParam filename) const;

  void SaveTyped_IO(IOStreamRef dst,
                    StringParam type,
                    bool closeio = false) const;
};

struct Surface : SurfaceBase
{
  using SurfaceBase::SurfaceBase;

  constexpr explicit Surface(SurfaceRaw resource) noexcept
    : SurfaceBase(resource)
  {
  }

  constexpr Surface(const Surface& other)
    : Surface(borrow(other.get()))
  {
  }

  constexpr Surface(Surface&& other) noexcept
    : Surface(other.release())
  {
  }

  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 Surface borrow(SurfaceRaw resource)
  {
    if (resource) {
      ++resource->refcount;
      return Surface(resource);
    }
    return {};
  }

  ~Surface() { SDL_DestroySurface(get()); }

  constexpr Surface& operator=(Surface&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  Surface& operator=(const Surface& other)
  {
    if (get() != other.get()) {
      Surface tmp(other);
      swap(*this, tmp);
    }
    return *this;
  }
};

class SurfaceLock
{
  Surface m_lock;
 
public:
  SurfaceLock(SurfaceRef resource);

  SurfaceLock(const SurfaceLock& other) = delete;

  SurfaceLock(SurfaceLock&& other) noexcept
    : m_lock(std::move(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 resource() const { 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)
  : Surface(CheckError(SDL_CreateSurface(size.x, size.y, format)))
{
}
 
inline Surface::Surface(const PointRaw& size,
                        PixelFormat format,
                        void* pixels,
                        int pitch)
  : Surface(
      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 SurfaceBase::Destroy() { DestroySurface(release()); }

inline PropertiesRef GetSurfaceProperties(SurfaceConstRef surface)
{
  return CheckError(SDL_GetSurfaceProperties(surface));
}
 
inline PropertiesRef SurfaceBase::GetProperties() const
{
  return SDL::GetSurfaceProperties(get());
}

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 SurfaceBase::SetColorspace(Colorspace colorspace)
{
  SDL::SetSurfaceColorspace(get(), colorspace);
}

inline Colorspace GetSurfaceColorspace(SurfaceConstRef surface)
{
  return SDL_GetSurfaceColorspace(surface);
}
 
inline Colorspace SurfaceBase::GetColorspace() const
{
  return SDL::GetSurfaceColorspace(get());
}

inline Palette CreateSurfacePalette(SurfaceRef surface)
{
  return Palette::borrow(CheckError(SDL_CreateSurfacePalette(surface)));
}
 
inline Palette SurfaceBase::CreatePalette()
{
  return SDL::CreateSurfacePalette(get());
}

inline void SetSurfacePalette(SurfaceRef surface, PaletteRef palette)
{
  CheckError(SDL_SetSurfacePalette(surface, palette));
}
 
inline void SurfaceBase::SetPalette(PaletteRef palette)
{
  SDL::SetSurfacePalette(get(), palette);
}

inline Palette GetSurfacePalette(SurfaceConstRef surface)
{
  return Palette::borrow(SDL_GetSurfacePalette(surface));
}
 
inline Palette SurfaceBase::GetPalette() const
{
  return SDL::GetSurfacePalette(get());
}

inline void AddSurfaceAlternateImage(SurfaceRef surface, SurfaceRef image)
{
  CheckError(SDL_AddSurfaceAlternateImage(surface, image));
}
 
inline void SurfaceBase::AddAlternateImage(SurfaceRef image)
{
  SDL::AddSurfaceAlternateImage(get(), image);
}

inline bool SurfaceHasAlternateImages(SurfaceConstRef surface)
{
  return SDL_SurfaceHasAlternateImages(surface);
}
 
inline bool SurfaceBase::HasAlternateImages() const
{
  return SDL::SurfaceHasAlternateImages(get());
}

inline OwnArray<SurfaceRaw> GetSurfaceImages(SurfaceConstRef surface)
{
  int count = 0;
  auto data = SDL_GetSurfaceImages(surface, &count);
  return OwnArray<SurfaceRaw>(CheckError(data), count);
}
 
inline OwnArray<SurfaceRaw> SurfaceBase::GetImages() const
{
  return SDL::GetSurfaceImages(get());
}

inline void RemoveSurfaceAlternateImages(SurfaceRef surface)
{
  SDL_RemoveSurfaceAlternateImages(surface);
}
 
inline void SurfaceBase::RemoveAlternateImages()
{
  SDL::RemoveSurfaceAlternateImages(get());
}

inline void LockSurface(SurfaceRef surface)
{
  CheckError(SDL_LockSurface(surface));
}
 
inline SurfaceLock SurfaceBase::Lock() { return {SurfaceRef(*this)}; }
 
inline SurfaceLock::SurfaceLock(SurfaceRef resource)
  : m_lock(resource)
{
  LockSurface(m_lock);
}

inline void UnlockSurface(SurfaceRef surface) { SDL_UnlockSurface(surface); }
 
inline void SurfaceBase::Unlock(SurfaceLock&& lock)
{
  SDL_assert_paranoid(lock.resource() == *this);
  std::move(lock).reset();
}
 
inline void SurfaceLock::reset()
{
  if (!m_lock) return;
  UnlockSurface(m_lock);
  m_lock = {};
}
 
#if !defined(SDL3PP_ENABLE_IMAGE) && !defined(SDL3PP_DOC) &&                   \
  SDL_VERSION_ATLEAST(3, 4, 0)

inline Surface LoadSurface_IO(IOStreamRef src, bool closeio = false)
{
  return Surface{SDL_LoadSurface_IO(src, closeio)};
}

inline Surface LoadSurface(StringParam file)
{
  return Surface{SDL_LoadSurface(file)};
}
 
#endif // !defined(SDL3PP_ENABLE_IMAGE) && SDL_VERSION_ATLEAST(3, 4, 0)

inline Surface LoadBMP_IO(IOStreamRef src, bool closeio = false)
{
  return Surface(SDL_LoadBMP_IO(src, closeio));
}

inline Surface LoadBMP(StringParam file) { return Surface(SDL_LoadBMP(file)); }

inline void SaveBMP_IO(SurfaceConstRef surface,
                       IOStreamRef dst,
                       bool closeio = false)
{
  CheckError(SDL_SaveBMP_IO(surface, dst, closeio));
}
 
inline void SurfaceBase::SaveBMP_IO(IOStreamRef dst, bool closeio) const
{
  SDL::SaveBMP_IO(get(), dst, closeio);
}

inline void SaveBMP(SurfaceConstRef surface, StringParam file)
{
  CheckError(SDL_SaveBMP(surface, file));
}
 
inline void SurfaceBase::SaveBMP(StringParam file) const
{
  SDL::SaveBMP(get(), std::move(file));
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline Surface LoadTrustedPNG_IO(IOStreamRef src, bool closeio = false)
{
  return Surface(SDL_LoadPNG_IO(src, closeio));
}

inline Surface LoadTrustedPNG(StringParam file)
{
  return Surface(SDL_LoadPNG(file));
}
 
#if !defined(SDL3PP_ENABLE_IMAGE) && !defined(SDL3PP_DOC)

inline Surface LoadPNG_IO(IOStreamRef src, bool closeio = false)
{
  return LoadTrustedPNG_IO(src, closeio);
}

inline Surface LoadPNG(StringParam file)
{
  return LoadTrustedPNG(std::move(file));
}
 
#endif // !defined(SDL3PP_ENABLE_IMAGE) && !defined(SDL3PP_DOC)

inline void SaveTrustedPNG_IO(SurfaceConstRef surface,
                              IOStreamRef dst,
                              bool closeio = false)
{
  CheckError(SDL_SavePNG_IO(surface, dst, closeio));
}
 
#if !defined(SDL3PP_ENABLE_IMAGE) && !defined(SDL3PP_DOC)
inline void Surface::SavePNG_IO(IOStreamRef dst, bool closeio) const
{
  SDL::SaveTrustedPNG_IO(get(), dst, closeio);
}
#endif // !defined(SDL3PP_ENABLE_IMAGE) && !defined(SDL3PP_DOC)

inline void SaveTrustedPNG(SurfaceConstRef surface, StringParam file)
{
  CheckError(SDL_SavePNG(surface, file));
}
 
#if !defined(SDL3PP_ENABLE_IMAGE) && !defined(SDL3PP_DOC)
inline void Surface::SavePNG(StringParam file) const
{
  SDL::SaveTrustedPNG(get(), std::move(file));
}
#endif // !defined(SDL3PP_ENABLE_IMAGE) && !defined(SDL3PP_DOC)
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline void SetSurfaceRLE(SurfaceRef surface, bool enabled)
{
  CheckError(SDL_SetSurfaceRLE(surface, enabled));
}
 
inline void SurfaceBase::SetRLE(bool enabled)
{
  SDL::SetSurfaceRLE(get(), enabled);
}

inline bool SurfaceHasRLE(SurfaceConstRef surface)
{
  return SDL_SurfaceHasRLE(surface);
}
 
inline bool SurfaceBase::HasRLE() const { return SDL::SurfaceHasRLE(get()); }

inline void SetSurfaceColorKey(SurfaceRef surface, std::optional<Uint32> key)
{
  CheckError(SDL_SetSurfaceColorKey(surface, key.has_value(), key.value_or(0)));
}
 
inline void SurfaceBase::SetColorKey(std::optional<Uint32> key)
{
  SDL::SetSurfaceColorKey(get(), key);
}

inline void ClearSurfaceColorKey(SurfaceRef surface)
{
  SetSurfaceColorKey(surface, std::nullopt);
}
 
inline void SurfaceBase::ClearColorKey() { SDL::ClearSurfaceColorKey(get()); }

inline bool SurfaceHasColorKey(SurfaceConstRef surface)
{
  return SDL_SurfaceHasColorKey(surface);
}
 
inline bool SurfaceBase::HasColorKey() const
{
  return SDL::SurfaceHasColorKey(get());
}

inline std::optional<Uint32> GetSurfaceColorKey(SurfaceConstRef surface)
{
  if (Uint32 key; SDL_GetSurfaceColorKey(surface, &key)) return key;
  return std::nullopt;
}
 
inline std::optional<Uint32> SurfaceBase::GetColorKey() const
{
  return SDL::GetSurfaceColorKey(get());
}

inline void SetSurfaceColorMod(SurfaceRef surface, Uint8 r, Uint8 g, Uint8 b)
{
  CheckError(SDL_SetSurfaceColorMod(surface, r, g, b));
}
 
inline void SurfaceBase::SetColorMod(Uint8 r, Uint8 g, Uint8 b)
{
  SDL::SetSurfaceColorMod(get(), r, g, b);
}

inline void GetSurfaceColorMod(SurfaceConstRef surface,
                               Uint8* r,
                               Uint8* g,
                               Uint8* b)
{
  CheckError(SDL_GetSurfaceColorMod(surface, r, g, b));
}
 
inline void SurfaceBase::GetColorMod(Uint8* r, Uint8* g, Uint8* b) const
{
  SDL::GetSurfaceColorMod(get(), r, g, b);
}

inline void SetSurfaceAlphaMod(SurfaceRef surface, Uint8 alpha)
{
  CheckError(SDL_SetSurfaceAlphaMod(surface, alpha));
}
 
inline void SurfaceBase::SetAlphaMod(Uint8 alpha)
{
  SDL::SetSurfaceAlphaMod(get(), alpha);
}

inline Uint8 GetSurfaceAlphaMod(SurfaceConstRef surface)
{
  Uint8 alpha;
  CheckError(SDL_GetSurfaceAlphaMod(surface, &alpha));
  return alpha;
}
 
inline Uint8 SurfaceBase::GetAlphaMod() const
{
  return SDL::GetSurfaceAlphaMod(get());
}

inline void SetSurfaceMod(SurfaceRef surface, Color color)
{
  SetSurfaceColorMod(surface, color.r, color.g, color.b);
  SetSurfaceAlphaMod(surface, color.a);
}
 
inline void SurfaceBase::SetMod(Color color) { SetSurfaceMod(get(), color); }

inline Color GetSurfaceMod(SurfaceConstRef surface)
{
  Color c;
  GetSurfaceColorMod(surface, &c.r, &c.g, &c.b);
  c.a = GetSurfaceAlphaMod(surface);
  return c;
}
 
inline Color SurfaceBase::GetMod() const { return GetSurfaceMod(get()); }

inline void SetSurfaceBlendMode(SurfaceRef surface, BlendMode blendMode)
{
  CheckError(SDL_SetSurfaceBlendMode(surface, blendMode));
}
 
inline void SurfaceBase::SetBlendMode(BlendMode blendMode)
{
  SDL::SetSurfaceBlendMode(get(), blendMode);
}

inline BlendMode GetSurfaceBlendMode(SurfaceConstRef surface)
{
  BlendMode blendmode;
  CheckError(SDL_GetSurfaceBlendMode(surface, &blendmode));
  return blendmode;
}
 
inline BlendMode SurfaceBase::GetBlendMode() const
{
  return SDL::GetSurfaceBlendMode(get());
}

inline bool SetSurfaceClipRect(SurfaceRef surface,
                               OptionalRef<const RectRaw> rect)
{
  return SDL_SetSurfaceClipRect(surface, rect);
}
 
inline bool SurfaceBase::SetClipRect(OptionalRef<const RectRaw> rect)
{
  return SDL::SetSurfaceClipRect(get(), rect);
}

inline void ResetSurfaceClipRect(SurfaceRef surface)
{
  SetSurfaceClipRect(surface, std::nullopt);
}
 
inline void SurfaceBase::ResetClipRect() { SDL::ResetSurfaceClipRect(get()); }

inline Rect GetSurfaceClipRect(SurfaceConstRef surface)
{
  Rect r;
  CheckError(SDL_GetSurfaceClipRect(surface, &r));
  return r;
}
 
inline Rect SurfaceBase::GetClipRect() const
{
  return SDL::GetSurfaceClipRect(get());
}

inline void FlipSurface(SurfaceRef surface, FlipMode flip)
{
  CheckError(SDL_FlipSurface(surface, flip));
}
 
inline void SurfaceBase::Flip(FlipMode flip) { SDL::FlipSurface(get(), flip); }
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline Surface RotateSurface(SurfaceRef surface, float angle)
{
  return Surface{SDL_RotateSurface(surface, angle)};
}
 
inline Surface SurfaceBase::Rotate(float angle)
{
  return SDL::RotateSurface(get(), angle);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline Surface DuplicateSurface(SurfaceConstRef surface)
{
  return Surface(SDL_DuplicateSurface(surface));
}
 
inline Surface SurfaceBase::Duplicate() const
{
  return SDL::DuplicateSurface(get());
}

inline Surface ScaleSurface(SurfaceConstRef surface,
                            const PointRaw& size,
                            ScaleMode scaleMode)
{
  return Surface(SDL_ScaleSurface(surface, size.x, size.y, scaleMode));
}
 
inline Surface SurfaceBase::Scale(const PointRaw& size,
                                  ScaleMode scaleMode) const
{
  return SDL::ScaleSurface(get(), size, scaleMode);
}

inline Surface ConvertSurface(SurfaceConstRef surface, PixelFormat format)
{
  return Surface(SDL_ConvertSurface(surface, format));
}
 
inline Surface SurfaceBase::Convert(PixelFormat format) const
{
  return SDL::ConvertSurface(get(), 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 SurfaceBase::Convert(PixelFormat format,
                                    PaletteRef palette,
                                    Colorspace colorspace,
                                    PropertiesRef props) const
{
  return SDL::ConvertSurfaceAndColorspace(
    get(), 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 SurfaceBase::PremultiplyAlpha(bool linear)
{
  SDL::PremultiplySurfaceAlpha(get(), linear);
}

inline void ClearSurface(SurfaceRef surface, const FColorRaw& c)
{
  CheckError(SDL_ClearSurface(surface, c.r, c.g, c.b, c.a));
}
 
inline void SurfaceBase::Clear(const FColorRaw& c) { ClearSurface(get(), c); }

inline void FillSurfaceRect(SurfaceRef dst,
                            OptionalRef<const RectRaw> rect,
                            Uint32 color)
{
  CheckError(SDL_FillSurfaceRect(dst, rect, color));
}
 
inline void SurfaceBase::FillRect(OptionalRef<const RectRaw> rect, Uint32 color)
{
  SDL::FillSurfaceRect(get(), rect, color);
}

inline void FillSurface(SurfaceRef dst, Uint32 color)
{
  FillSurfaceRect(dst, std::nullopt, color);
}
 
inline void SurfaceBase::Fill(Uint32 color) { FillSurface(get(), color); }

inline void FillSurfaceRects(SurfaceRef dst,
                             SpanRef<const RectRaw> rects,
                             Uint32 color)
{
  CheckError(
    SDL_FillSurfaceRects(dst, rects.data(), narrowS32(rects.size()), color));
}
 
inline void SurfaceBase::FillRects(SpanRef<const RectRaw> rects, Uint32 color)
{
  SDL::FillSurfaceRects(get(), 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 SurfaceBase::Blit(SurfaceRef src,
                              OptionalRef<const RectRaw> srcrect,
                              OptionalRef<const RectRaw> dstrect)
{
  SDL::BlitSurface(src, srcrect, get(), dstrect);
}
 
inline void SurfaceBase::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, 0, 0});
}

inline void BlitSurfaceUnchecked(SurfaceRef src,
                                 const RectRaw& srcrect,
                                 SurfaceRef dst,
                                 const RectRaw& dstrect)
{
  CheckError(SDL_BlitSurfaceUnchecked(src, &srcrect, dst, &dstrect));
}
 
inline void SurfaceBase::BlitUnchecked(SurfaceRef src,
                                       const RectRaw& srcrect,
                                       const RectRaw& dstrect)
{
  SDL::BlitSurfaceUnchecked(src, srcrect, get(), 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 SurfaceBase::BlitScaled(SurfaceRef src,
                                    OptionalRef<const RectRaw> srcrect,
                                    OptionalRef<const RectRaw> dstrect,
                                    ScaleMode scaleMode)
{
  SDL::BlitSurfaceScaled(src, srcrect, get(), 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 SurfaceBase::BlitUncheckedScaled(SurfaceRef src,
                                             const RectRaw& srcrect,
                                             const RectRaw& dstrect,
                                             ScaleMode scaleMode)
{
  SDL::BlitSurfaceUncheckedScaled(src, srcrect, get(), 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 SurfaceBase::Stretch(SurfaceRef src,
                                 OptionalRef<RectRaw> srcrect,
                                 OptionalRef<RectRaw> dstrect,
                                 ScaleMode scaleMode)
{
  SDL::StretchSurface(src, srcrect, get(), 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 SurfaceBase::BlitTiled(SurfaceRef src,
                                   OptionalRef<const RectRaw> srcrect,
                                   OptionalRef<const RectRaw> dstrect)
{
  SDL::BlitSurfaceTiled(src, srcrect, get(), 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 SurfaceBase::BlitTiledWithScale(SurfaceRef src,
                                            OptionalRef<const RectRaw> srcrect,
                                            float scale,
                                            ScaleMode scaleMode,
                                            OptionalRef<const RectRaw> dstrect)
{
  SDL::BlitSurfaceTiledWithScale(
    src, srcrect, scale, scaleMode, get(), 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 SurfaceBase::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,
                        get(),
                        dstrect,
                        scale,
                        scaleMode);
}

inline Uint32 MapSurfaceRGB(SurfaceConstRef surface, Uint8 r, Uint8 g, Uint8 b)
{
  return SDL_MapSurfaceRGB(surface, r, g, b);
}
 
inline Uint32 SurfaceBase::MapRGB(Uint8 r, Uint8 g, Uint8 b) const
{
  return SDL::MapSurfaceRGB(get(), r, g, b);
}

inline Uint32 MapSurfaceRGBA(SurfaceConstRef surface, ColorRaw c)
{
  return SDL_MapSurfaceRGBA(surface, c.r, c.g, c.b, c.a);
}
 
inline Uint32 SurfaceBase::MapRGBA(ColorRaw c) const
{
  return SDL::MapSurfaceRGBA(get(), 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 SurfaceBase::ReadPixel(const PointRaw& p,
                                   Uint8* r,
                                   Uint8* g,
                                   Uint8* b,
                                   Uint8* a) const
{
  SDL::ReadSurfacePixel(get(), p, r, g, b, a);
}
 
inline Color SurfaceBase::ReadPixel(const PointRaw& p) const
{
  return SDL::ReadSurfacePixel(get(), 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 SurfaceBase::ReadPixelFloat(const PointRaw& p,
                                        float* r,
                                        float* g,
                                        float* b,
                                        float* a) const
{
  SDL::ReadSurfacePixelFloat(get(), p, r, g, b, a);
}
 
inline FColor SurfaceBase::ReadPixelFloat(const PointRaw& p) const
{
  return SDL::ReadSurfacePixelFloat(get(), 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 SurfaceBase::WritePixel(const PointRaw& p, ColorRaw c)
{
  SDL::WriteSurfacePixel(get(), 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 SurfaceBase::WritePixelFloat(const PointRaw& p, const FColorRaw& c)
{
  SDL::WriteSurfacePixelFloat(get(), p, c);
}

constexpr int GetSurfaceWidth(SurfaceConstRef surface) { return surface->w; }

constexpr int GetSurfaceWidth(const SurfaceLock& lock)
{
  return lock.GetWidth();
}
 
constexpr int SurfaceBase::GetWidth() const { return GetSurfaceWidth(get()); }

constexpr int GetSurfaceHeight(SurfaceConstRef surface) { return surface->h; }

constexpr int GetSurfaceHeight(const SurfaceLock& lock)
{
  return lock.GetHeight();
}
 
constexpr int SurfaceBase::GetHeight() const { return GetSurfaceHeight(get()); }

constexpr Point GetSurfaceSize(SurfaceConstRef surface)
{
  return Point(surface->w, surface->h);
}

constexpr Point GetSurfaceSize(const SurfaceLock& lock)
{
  return lock.GetSize();
}
 
constexpr Point SurfaceBase::GetSize() const { return GetSurfaceSize(get()); }

constexpr int GetSurfacePitch(SurfaceConstRef surface)
{
  return surface->pitch;
}

constexpr int GetSurfacePitch(const SurfaceLock& lock)
{
  return lock.GetPitch();
}
 
constexpr int SurfaceBase::GetPitch() const { return GetSurfacePitch(get()); }

constexpr PixelFormat GetSurfaceFormat(SurfaceConstRef surface)
{
  return surface->format;
}

constexpr PixelFormat GetSurfaceFormat(const SurfaceLock& lock)
{
  return lock.GetFormat();
}
 
constexpr PixelFormat SurfaceBase::GetFormat() const
{
  return SDL::GetSurfaceFormat(get());
}

constexpr void* GetSurfacePixels(SurfaceConstRef surface)
{
  return surface->pixels;
}

constexpr void* GetSurfacePixels(const SurfaceLock& lock)
{
  return lock.GetPixels();
}
 
constexpr void* SurfaceBase::GetPixels() const
{
  return SDL::GetSurfacePixels(get());
}

 
} // namespace SDL
 
#endif /* SDL3PP_SURFACE_H_ */