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 SurfaceRef;
 
// Forward decl
struct Surface;
 
using SurfaceShared = ResourceShared<Surface>;
 
using SurfaceWeak = ResourceWeak<Surface>;
 
// 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;
 
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 SurfaceRef : Resource<SDL_Surface*>
{
  using Resource::Resource;
 
  PropertiesRef GetProperties() const
  {
    return CheckError(SDL_GetSurfaceProperties(get()));
  }
 
  void SetColorspace(Colorspace colorspace)
  {
    CheckError(SDL_SetSurfaceColorspace(get(), colorspace));
  }
 
  Colorspace GetColorspace() const { return SDL_GetSurfaceColorspace(get()); }
 
  PaletteRef CreatePalette()
  {
    return CheckError(SDL_CreateSurfacePalette(get()));
  }
 
  void SetPalette(PaletteRef palette)
  {
    CheckError(SDL_SetSurfacePalette(get(), palette.get()));
  }
 
  PaletteRef GetPalette() const { return SDL_GetSurfacePalette(get()); }
 
  void AddAlternateImage(SurfaceRef 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
  {
    Rect r;
    CheckError(SDL_GetSurfaceClipRect(get(), &r));
    return r;
  }
 
  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,
                  PaletteRef palette,
                  Colorspace colorspace,
                  PropertiesRef props) const;
 
  void PremultiplyAlpha(bool linear)
  {
    CheckError(SDL_PremultiplySurfaceAlpha(get(), linear));
  }
 
  void Clear(SDL_FColor color)
  {
    CheckError(SDL_ClearSurface(get(), color.r, color.g, color.b, color.a));
  }
 
  void Fill(SDL_Color color) { return FillRect({}, color); }
 
  void Fill(Uint32 color) { return FillRect({}, color); }
 
  void FillRect(OptionalRef<const SDL_Rect> rect, SDL_Color color)
  {
    FillRect(rect, MapColor(color));
  }
 
  void FillRect(OptionalRef<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(SurfaceRef src,
            OptionalRef<const SDL_Rect> srcrect,
            const SDL_Point& dstpos)
  {
    Blit(src, srcrect, Rect{dstpos, {}});
  }
 
  void Blit(SurfaceRef src,
            OptionalRef<const SDL_Rect> srcrect,
            OptionalRef<const SDL_Rect> dstrect)
  {
    CheckError(SDL_BlitSurface(src.get(), srcrect, get(), dstrect));
  }
 
  void BlitUnchecked(SurfaceRef src,
                     const SDL_Rect& srcrect,
                     const SDL_Rect& dstrect)
  {
    CheckError(SDL_BlitSurfaceUnchecked(src.get(), &srcrect, get(), &dstrect));
  }
 
  void BlitScaled(SurfaceRef src,
                  OptionalRef<const SDL_Rect> srcrect,
                  OptionalRef<const SDL_Rect> dstrect,
                  ScaleMode scaleMode)
  {
    CheckError(
      SDL_BlitSurfaceScaled(src.get(), srcrect, get(), dstrect, scaleMode));
  }
 
  void BlitUncheckedScaled(SurfaceRef 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(SurfaceRef src,
               OptionalRef<SDL_Rect> srcrect,
               OptionalRef<SDL_Rect> dstrect,
               ScaleMode scaleMode)
  {
    CheckError(
      SDL_StretchSurface(src.get(), srcrect, get(), dstrect, scaleMode));
  }
 
#endif // SDL_VERSION_ATLEAST(3, 2, 4)
 
  void BlitTiled(SurfaceRef src,
                 OptionalRef<const SDL_Rect> srcrect,
                 OptionalRef<const SDL_Rect> dstrect)
  {
    CheckError(SDL_BlitSurfaceTiled(src.get(), srcrect, get(), dstrect));
  }
 
  void BlitTiledWithScale(SurfaceRef 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(SurfaceRef 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(SurfaceRef 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));
  }
 
  constexpr int GetWidth() const { return get()->w; }
 
  constexpr int GetHeight() const { return get()->h; }
 
  constexpr Point GetSize() const { return Point(GetWidth(), GetHeight()); }
 
  constexpr int GetPitch() const { return get()->pitch; }
 
  constexpr PixelFormat GetFormat() const { return get()->format; }
 
  constexpr void* GetPixels() const { return get()->pixels; }
 
  static void reset(SDL_Surface* resource) { SDL_DestroySurface(resource); }
};
 
struct Surface : ResourceUnique<SurfaceRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Surface Load(StringParam file);
 
  static Surface Load(IOStreamRef src);
 
  static Surface LoadBMP(IOStreamRef src)
  {
    return Surface(SDL_LoadBMP_IO(src, false));
  }
 
  static Surface LoadBMP(StringParam file)
  {
    return Surface(SDL_LoadBMP(file));
  }
 
  static Surface Create(const SDL_Point& size, PixelFormat format)
  {
    return Surface(CheckError(SDL_CreateSurface(size.x, size.y, format)));
  }
 
  static Surface CreateFrom(const SDL_Point& size,
                            PixelFormat format,
                            void* pixels,
                            int pitch)
  {
    return Surface(
      CheckError(SDL_CreateSurfaceFrom(size.x, size.y, format, pixels, pitch)));
  }
 
  void Destroy() { reset(); }
  SurfaceShared share();
};
 
inline SurfaceShared Surface::share()
{
  return SurfaceShared(std::move(*this));
}
 
struct SurfaceUnsafe : ResourceUnsafe<SurfaceRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit SurfaceUnsafe(Surface&& other)
    : SurfaceUnsafe(other.release())
  {
  }
};
 
struct SurfaceLock : LockBase<SurfaceRef>
{
  constexpr SurfaceLock() = default;
 
  constexpr SurfaceLock(SurfaceLock&& other)
    : LockBase(other.release())
  {
  }
 
  SurfaceLock(SurfaceRef surface)
    : LockBase<SurfaceRef>(std::move(surface))
  {
    if (!SDL_LockSurface(get())) release();
  }
 
  ~SurfaceLock() { Unlock(); }
 
  void Unlock() { SDL_UnlockSurface(release()); }
 
  void reset() { Unlock(); }
};
 
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)
 
} // namespace prop::Surface
 
inline SurfaceLock SurfaceRef::Lock() & { return SurfaceLock{get()}; }
 
inline void SaveBMP(SurfaceRef surface, IOStreamRef dst)
{
  CheckError(SDL_SaveBMP_IO(surface.get(), dst.get(), false));
}
 
inline void SaveBMP(SurfaceRef surface, StringParam file)
{
  CheckError(SDL_SaveBMP(surface.get(), file));
}
 
inline Surface SurfaceRef::Duplicate() const
{
  return Surface{SDL_DuplicateSurface(get())};
}
 
inline Surface SurfaceRef::Scale(int width,
                                 int height,
                                 ScaleMode scaleMode) const
{
  return Surface{SDL_ScaleSurface(get(), width, height, scaleMode)};
}
 
inline Surface SurfaceRef::Convert(PixelFormat format) const
{
  return Surface{SDL_ConvertSurface(get(), format)};
}
 
inline Surface SurfaceRef::Convert(PixelFormat format,
                                   PaletteRef palette,
                                   Colorspace colorspace,
                                   PropertiesRef 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,
                                       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(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));
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_SURFACE_H_ */