SDL3pp_surface.h

#ifndef SDL3PP_SURFACE_H_
#define SDL3PP_SURFACE_H_
 
#include <SDL3/SDL_surface.h>
#include <SDL3/SDL_version.h>
#include "SDL3pp_blendmode.h"
#include "SDL3pp_iostream.h"
#include "SDL3pp_pixels.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct SurfaceLock;
 
// Forward decl
struct SurfaceBase;
 
// Forward decl
struct SurfaceRef;
 
// Forward decl
struct Surface;
 
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;
 
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; 
 
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; 
 
struct SurfaceBase : Resource<SDL_Surface*>
{
  using Resource::Resource;
 
  SurfaceBase(StringParam file);
 
  SurfaceBase(IOStreamBase& src);
 
  SurfaceBase(const SDL_Point& size, PixelFormat format)
    : Resource(CheckError(SDL_CreateSurface(size.x, size.y, format)))
  {
  }
 
  SurfaceBase(const SDL_Point& size,
              PixelFormat format,
              void* pixels,
              int pitch)
    : Resource(CheckError(
        SDL_CreateSurfaceFrom(size.x, size.y, format, pixels, pitch)))
  {
  }
 
  PropertiesRef GetProperties() const
  {
    return PropertiesRef{SDL_GetSurfaceProperties(get())};
  }
 
  void SetColorspace(Colorspace colorspace)
  {
    CheckError(SDL_SetSurfaceColorspace(get(), colorspace));
  }
 
  Colorspace GetColorspace() const { return SDL_GetSurfaceColorspace(get()); }
 
  PaletteRef CreatePalette() { return SDL_CreateSurfacePalette(get()); }
 
  void SetPalette(PaletteBase& palette)
  {
    CheckError(SDL_SetSurfacePalette(get(), palette.get()));
  }
 
  PaletteRef GetPalette() const { return SDL_GetSurfacePalette(get()); }
 
  void AddAlternateImage(SurfaceBase& image)
  {
    CheckError(SDL_AddSurfaceAlternateImage(get(), image.get()));
  }
 
  bool HasAlternateImages() const
  {
    return SDL_SurfaceHasAlternateImages(get());
  }
 
  OwnArray<SurfaceRef> GetImages() const
  {
    int count = 0;
    auto data =
      reinterpret_cast<SurfaceRef*>(SDL_GetSurfaceImages(get(), &count));
    return OwnArray<SurfaceRef>{data, size_t(count)};
  }
 
  void RemoveAlternateImages() { SDL_RemoveSurfaceAlternateImages(get()); }
 
  constexpr bool MustLock() const { return SDL_MUSTLOCK(get()); }
 
  SurfaceLock Lock() &;
 
  void SetRLE(bool enabled) { CheckError(SDL_SetSurfaceRLE(get(), enabled)); }
 
  bool HasRLE() const { return SDL_SurfaceHasRLE(get()); }
 
  void SetColorKey(Color key) { SetColorKey(MapColor(key)); }
 
  void SetColorKey(std::optional<Uint32> key)
  {
    CheckError(SDL_SetSurfaceColorKey(get(), key.has_value(), key.value_or(0)));
  }
 
  void ClearColorKey() { CheckError(SDL_SetSurfaceColorKey(get(), false, 0)); }
 
  bool HasColorKey() const { return SDL_SurfaceHasColorKey(get()); }
 
  Color GetColorKey() const
  {
    Color color;
    GetColorKey(&color);
    return color;
  }
 
  void GetColorKey(Color* key) const
  {
    Uint32 color;
    GetColorKey(&color);
    *key = GetFormat().Get(color, GetPalette());
  }
 
  void GetColorKey(Uint32* key) const
  {
    CheckError(SDL_GetSurfaceColorKey(get(), key));
  }
 
  void SetColorMod(Uint8 r, Uint8 g, Uint8 b)
  {
    CheckError(SDL_SetSurfaceColorMod(get(), r, g, b));
  }
 
  void GetColorMod(Uint8* r, Uint8* g, Uint8* b) const
  {
    CheckError(SDL_GetSurfaceColorMod(get(), r, g, b));
  }
 
  void SetAlphaMod(Uint8 alpha)
  {
    CheckError(SDL_SetSurfaceAlphaMod(get(), alpha));
  }
 
  Uint8 GetAlphaMod() const
  {
    Uint8 alpha;
    CheckError(SDL_GetSurfaceAlphaMod(get(), &alpha));
    return alpha;
  }
 
  void SetMod(Color color)
  {
    SetColorMod(color.r, color.g, color.b);
    SetAlphaMod(color.a);
  }
 
  Color GetMod() const
  {
    Color c;
    GetColorMod(&c.r, &c.g, &c.b);
    c.a = GetAlphaMod();
    return c;
  }
 
  void SetBlendMode(BlendMode blendMode)
  {
    CheckError(SDL_SetSurfaceBlendMode(get(), blendMode));
  }
 
  BlendMode GetBlendMode() const
  {
    if (BlendMode blendMode; SDL_GetSurfaceBlendMode(get(), &blendMode)) {
      return blendMode;
    }
    return BLENDMODE_INVALID;
  }
 
  bool SetClipRect(OptionalRef<const SDL_Rect> rect)
  {
    return SDL_SetSurfaceClipRect(get(), rect);
  }
 
  void ResetClipRect() { SDL_SetSurfaceClipRect(get(), nullptr); }
 
  Rect GetClipRect() const
  {
    if (Rect r; SDL_GetSurfaceClipRect(get(), &r)) return r;
    return {};
  }
 
  void Flip(FlipMode flip) { CheckError(SDL_FlipSurface(get(), flip)); }
 
  Surface Duplicate() const;
 
  Surface Scale(int width, int height, ScaleMode scaleMode) const;
 
  Surface Convert(PixelFormat format) const;
 
  Surface Convert(PixelFormat format,
                  PaletteBase& palette,
                  Colorspace colorspace,
                  PropertiesBase& props) const;
 
  void PremultiplyAlpha(bool linear)
  {
    CheckError(SDL_PremultiplySurfaceAlpha(get(), linear));
  }
 
  // TODO SDL_ConvertSurfaceAndColorspace
 
  void Clear(SDL_FColor color)
  {
    CheckError(SDL_ClearSurface(get(), color.r, color.g, color.b, color.a));
  }
 
  void Fill(SDL_Color color) { return Fill(MapColor(color)); }
 
  void Fill(Uint32 color)
  {
    CheckError(SDL_FillSurfaceRect(get(), nullptr, color));
  }
 
  void FillRect(const SDL_Rect& rect, SDL_Color color)
  {
    FillRect(rect, MapColor(color));
  }
 
  void FillRect(const SDL_Rect& rect, Uint32 color)
  {
    CheckError(SDL_FillSurfaceRect(get(), &rect, color));
  }
 
  void FillRects(SpanRef<const SDL_Rect> rects, SDL_Color color)
  {
    FillRects(rects, MapColor(color));
  }
 
  void FillRects(SpanRef<const SDL_Rect> rects, Uint32 color)
  {
    SDL_assert_paranoid(rects.size() < SDL_MAX_UINT32);
    CheckError(SDL_FillSurfaceRects(get(), rects.data(), rects.size(), color));
  }
 
  void Blit(const SurfaceBase& src,
            OptionalRef<const SDL_Rect> srcrect,
            const SDL_Point& dstpos)
  {
    Blit(src, srcrect, Rect{dstpos, {}});
  }
 
  void Blit(const SurfaceBase& src,
            OptionalRef<const SDL_Rect> srcrect,
            OptionalRef<const SDL_Rect> dstrect)
  {
    CheckError(SDL_BlitSurface(src.get(), srcrect, get(), dstrect));
  }
 
  void BlitUnchecked(const SurfaceBase& src,
                     const SDL_Rect& srcrect,
                     const SDL_Rect& dstrect)
  {
    CheckError(SDL_BlitSurfaceUnchecked(src.get(), &srcrect, get(), &dstrect));
  }
 
  void BlitScaled(const SurfaceBase& src,
                  OptionalRef<const SDL_Rect> srcrect,
                  OptionalRef<const SDL_Rect> dstrect,
                  ScaleMode scaleMode)
  {
    CheckError(
      SDL_BlitSurfaceScaled(src.get(), srcrect, get(), dstrect, scaleMode));
  }
 
  void BlitUncheckedScaled(const SurfaceBase& src,
                           const SDL_Rect& srcrect,
                           const SDL_Rect& dstrect,
                           ScaleMode scaleMode)
  {
    CheckError(
      SDL_BlitSurfaceScaled(src.get(), &srcrect, get(), &dstrect, scaleMode));
  }
 
#if SDL_VERSION_ATLEAST(3, 2, 4)
 
  void Stretch(const SurfaceBase& src,
               const SDL_Rect& srcrect,
               const SDL_Rect& dstrect,
               ScaleMode scaleMode)
  {
    CheckError(
      SDL_StretchSurface(src.get(), &srcrect, get(), &dstrect, scaleMode));
  }
 
#endif // SDL_VERSION_ATLEAST(3, 2, 4)
 
  void BlitTiled(const SurfaceBase& src,
                 OptionalRef<const SDL_Rect> srcrect,
                 OptionalRef<const SDL_Rect> dstrect)
  {
    CheckError(SDL_BlitSurfaceTiled(src.get(), srcrect, get(), dstrect));
  }
 
  void BlitTiledWithScale(const SurfaceBase& src,
                          OptionalRef<const SDL_Rect> srcrect,
                          float scale,
                          SDL_ScaleMode scaleMode,
                          OptionalRef<const SDL_Rect> dstrect)
  {
    CheckError(SDL_BlitSurfaceTiledWithScale(
      src.get(), srcrect, scale, scaleMode, get(), dstrect));
  }
 
  void Blit9Grid(const SurfaceBase& src,
                 OptionalRef<const SDL_Rect> srcrect,
                 int left_width,
                 int right_width,
                 int top_height,
                 int bottom_height,
                 OptionalRef<const SDL_Rect> dstrect)
  {
    Blit9GridWithScale(src,
                       srcrect,
                       left_width,
                       right_width,
                       top_height,
                       bottom_height,
                       0.0,
                       SDL_SCALEMODE_NEAREST,
                       dstrect);
  }
 
  void Blit9GridWithScale(const SurfaceBase& src,
                          OptionalRef<const SDL_Rect> srcrect,
                          int left_width,
                          int right_width,
                          int top_height,
                          int bottom_height,
                          float scale,
                          SDL_ScaleMode scaleMode,
                          OptionalRef<const SDL_Rect> dstrect)
  {
    CheckError(SDL_BlitSurface9Grid(src.get(),
                                    srcrect,
                                    left_width,
                                    right_width,
                                    top_height,
                                    bottom_height,
                                    scale,
                                    scaleMode,
                                    get(),
                                    dstrect));
  }
 
  Uint32 MapColor(SDL_Color color) const
  {
    return MapColor(color.r, color.g, color.b, color.a);
  }
 
  Uint32 MapColor(Uint8 r, Uint8 g, Uint8 b) const
  {
    return SDL_MapSurfaceRGB(get(), r, g, b);
  }
 
  Uint32 MapColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a) const
  {
    return SDL_MapSurfaceRGBA(get(), r, g, b, a);
  }
 
  Color ReadPixel(const SDL_Point& p) const
  {
    Color c;
    ReadPixel(p, &c);
    return c;
  }
 
  void ReadPixel(const SDL_Point& p, SDL_Color* c) const
  {
    ReadPixel(p, &c->r, &c->g, &c->b, &c->a);
  }
 
  void ReadPixel(const SDL_Point& p, SDL_FColor* c) const
  {
    return ReadPixel(p, &c->r, &c->g, &c->b, &c->a);
  }
 
  void ReadPixel(const SDL_Point& p,
                 Uint8* r,
                 Uint8* g,
                 Uint8* b,
                 Uint8* a) const
  {
    CheckError(SDL_ReadSurfacePixel(get(), p.x, p.y, r, g, b, a));
  }
 
  void ReadPixel(const SDL_Point& p,
                 float* r,
                 float* g,
                 float* b,
                 float* a) const
  {
    CheckError(SDL_ReadSurfacePixelFloat(get(), p.x, p.y, r, g, b, a));
  }
 
  void WritePixel(const SDL_Point& p, SDL_Color c)
  {
    CheckError(SDL_WriteSurfacePixel(get(), p.x, p.y, c.r, c.g, c.b, c.a));
  }
 
  void WritePixel(const SDL_Point& p, SDL_FColor c)
  {
    CheckError(SDL_WriteSurfacePixelFloat(get(), p.x, p.y, c.r, c.g, c.b, c.a));
  }
 
  int GetWidth() const { return get()->w; }
 
  int GetHeight() const { return get()->h; }
 
  Point GetSize() const { return Point(GetWidth(), GetHeight()); }
 
  PixelFormat GetFormat() const { return get()->format; }
};
 
struct SurfaceRef : SurfaceBase
{
  using SurfaceBase::SurfaceBase;
 
  constexpr SurfaceRef(const SurfaceRef& other)
    : SurfaceBase(other.get())
  {
  }
 
  constexpr SurfaceRef(SurfaceRef&& other)
    : SurfaceBase(other.release())
  {
  }
 
  constexpr ~SurfaceRef() = default;
 
  SurfaceRef& operator=(SurfaceRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Surface* newResource = {})
  {
    SDL_DestroySurface(release(newResource));
  }
};
 
struct Surface : SurfaceRef
{
  using SurfaceRef::SurfaceRef;
 
  constexpr explicit Surface(SDL_Surface* resource = {})
    : SurfaceRef(resource)
  {
  }
 
  constexpr Surface(const Surface& other) = delete;
 
  constexpr Surface(Surface&& other) = default;
 
  ~Surface() { reset(); }
 
  Surface& operator=(Surface other)
  {
    reset(other.release());
    return *this;
  }
};
 
class SurfaceLock
{
  SurfaceRef surface;
 
  explicit SurfaceLock(SurfaceRef surface)
    : surface(std::move(surface))
  {
    if (!SDL_LockSurface(this->surface.get())) this->surface.reset();
  }
 
public:
  // default ctor
  SurfaceLock()
    : surface(nullptr)
  {
  }
 
  SurfaceLock(const SurfaceLock& other) = delete;
 
  SurfaceLock(SurfaceLock&& other)
    : surface(other.surface.release())
  {
  }
 
  ~SurfaceLock() { Unlock(); }
 
  SurfaceLock& operator=(SurfaceLock other)
  {
    std::swap(surface, other.surface);
    return *this;
  }
 
  constexpr operator bool() const { return bool(surface); }
 
  void Unlock() { return SDL_UnlockSurface(surface.release()); }
 
  void* GetPixels() const { return surface->pixels; }
 
  int GetPitch() const { return surface->pitch; }
 
  PixelFormat GetFormat() const { return surface->format; }
 
  friend class SurfaceBase;
};
 
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;
 
constexpr auto HOTSPOT_X_NUMBER = SDL_PROP_SURFACE_HOTSPOT_X_NUMBER;
 
constexpr auto HOTSPOT_Y_NUMBER = SDL_PROP_SURFACE_HOTSPOT_Y_NUMBER;
 
} // namespace prop::Surface
 
inline Surface LoadBMP(IOStreamBase& src)
{
  return Surface{SDL_LoadBMP_IO(src.get(), false)};
}
 
inline Surface LoadBMP(StringParam file) { return Surface{SDL_LoadBMP(file)}; }
 
inline void SaveBMP(SurfaceBase& surface, IOStreamBase& dst)
{
  CheckError(SDL_SaveBMP_IO(surface.get(), dst.get(), false));
}
 
inline void SaveBMP(SurfaceBase& surface, StringParam file)
{
  CheckError(SDL_SaveBMP(surface.get(), file));
}
 
inline Surface SurfaceBase::Duplicate() const
{
  return Surface{SDL_DuplicateSurface(get())};
}
 
inline Surface SurfaceBase::Scale(int width,
                                  int height,
                                  ScaleMode scaleMode) const
{
  return Surface{SDL_ScaleSurface(get(), width, height, scaleMode)};
}
 
inline Surface SurfaceBase::Convert(PixelFormat format) const
{
  return Surface{SDL_ConvertSurface(get(), format)};
}
 
inline Surface SurfaceBase::Convert(PixelFormat format,
                                    PaletteBase& palette,
                                    Colorspace colorspace,
                                    PropertiesBase& props) const
{
  return Surface{SDL_ConvertSurfaceAndColorspace(
    get(), format, palette.get(), colorspace, props.get())};
}
 
inline void ConvertPixels(int width,
                          int height,
                          PixelFormat src_format,
                          const void* src,
                          int src_pitch,
                          PixelFormat dst_format,
                          void* dst,
                          int dst_pitch)
{
  CheckError(SDL_ConvertPixels(
    width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch));
}
 
inline void ConvertPixelsAndColorspace(int width,
                                       int height,
                                       PixelFormat src_format,
                                       Colorspace src_colorspace,
                                       PropertiesBase& src_properties,
                                       const void* src,
                                       int src_pitch,
                                       PixelFormat dst_format,
                                       Colorspace dst_colorspace,
                                       PropertiesBase& dst_properties,
                                       void* dst,
                                       int dst_pitch)
{
  CheckError(SDL_ConvertPixelsAndColorspace(width,
                                            height,
                                            src_format,
                                            src_colorspace,
                                            src_properties.get(),
                                            src,
                                            src_pitch,
                                            dst_format,
                                            dst_colorspace,
                                            dst_properties.get(),
                                            dst,
                                            dst_pitch));
}
 
inline void PremultiplyAlpha(int width,
                             int height,
                             PixelFormat src_format,
                             const void* src,
                             int src_pitch,
                             PixelFormat dst_format,
                             void* dst,
                             int dst_pitch,
                             bool linear)
{
  CheckError(SDL_PremultiplyAlpha(width,
                                  height,
                                  src_format,
                                  src,
                                  src_pitch,
                                  dst_format,
                                  dst,
                                  dst_pitch,
                                  linear));
}
 
 
#pragma region impl
 
inline SurfaceLock SurfaceBase::Lock() & { return SurfaceLock{get()}; }
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_SURFACE_H_ */