SDL3pp_stdinc.h

#ifndef SDL3PP_STDINC_H_
#define SDL3PP_STDINC_H_
 
#include <chrono>
#include <SDL3/SDL_stdinc.h>
#include "SDL3pp_callbackWrapper.h"
#include "SDL3pp_error.h"
#include "SDL3pp_lockBase.h"
#include "SDL3pp_optionalRef.h"
#include "SDL3pp_ownPtr.h"
#include "SDL3pp_resource.h"
#include "SDL3pp_spanRef.h"
#include "SDL3pp_strings.h"
 
namespace SDL {
 
// Forward decl
struct EnvironmentBase;
 
// Forward decl
struct EnvironmentRef;
 
// Forward decl
struct Environment;
 
// Forward decl
struct IConvBase;
 
// Forward decl
struct IConvRef;
 
// Forward decl
struct IConv;
 
#ifdef SDL3PP_DOC
 
#define SDL_NOLONGLONG 1
 
#define SDL_SIZE_MAX SIZE_MAX
 
#endif // SDL3PP_DOC
 
template<class T, std::size_t N>
constexpr std::size_t arraysize(const T (&array)[N])
{
  return SDL_arraysize(array);
}
 
#ifdef SDL3PP_DOC
 
#define SDL_STRINGIFY_ARG(arg) #arg
 
#endif // SDL3PP_DOC
 
constexpr Uint32 FourCC(Uint8 a, Uint8 b, Uint8 c, Uint8 d)
{
  return SDL_FOURCC(a, b, c, d);
}
 
#ifdef SDL3PP_DOC
 
#define SDL_SINT64_C(c) c##LL /* or whatever the current compiler uses. */
 
#define SDL_UINT64_C(c) c##ULL /* or whatever the current compiler uses. */
 
#endif // SDL3PP_DOC
 
constexpr Sint8 MAX_SINT8 = SDL_MAX_SINT8;
 
constexpr Sint8 MIN_SINT8 = SDL_MIN_SINT8;
 
constexpr Uint8 MAX_UINT8 = SDL_MAX_UINT8;
 
constexpr Uint8 MIN_UINT8 = SDL_MIN_UINT8;
 
constexpr Sint16 MAX_SINT16 = SDL_MAX_SINT16;
 
constexpr Sint16 MIN_SINT16 = SDL_MIN_SINT16;
 
constexpr Uint16 MAX_UINT16 = SDL_MAX_UINT16;
 
constexpr Uint16 MIN_UINT16 = SDL_MIN_UINT16;
 
constexpr Sint32 MAX_SINT32 = SDL_MAX_SINT32;
 
constexpr Sint32 MIN_SINT32 = SDL_MIN_SINT32;
 
constexpr Uint32 MAX_UINT32 = SDL_MAX_UINT32;
 
constexpr Uint8 MIN_UINT32 = SDL_MIN_UINT32;
 
constexpr Sint64 MAX_SINT64 = SDL_MAX_SINT64;
 
constexpr Sint64 MIN_SINT64 = SDL_MIN_SINT64;
 
constexpr Uint64 MAX_UINT64 = SDL_MAX_UINT64;
 
constexpr Uint8 MIN_UINT64 = SDL_MIN_UINT64;
 
using Seconds = std::chrono::duration<float>;
 
using Nanoseconds = std::chrono::nanoseconds;
 
constexpr float ToSeconds(Seconds duration) { return duration.count(); }
 
constexpr Seconds FromSeconds(float duration) { return Seconds(duration); }
 
constexpr Sint64 ToNS(std::chrono::nanoseconds duration)
{
  return duration.count();
}
 
constexpr Nanoseconds FromNS(Sint64 duration) { return Nanoseconds{duration}; }
 
class Time
{
  std::chrono::nanoseconds m_value;
 
public:
  constexpr Time() = default;
 
  constexpr Time(std::chrono::nanoseconds time)
    : m_value(time)
  {
  }
 
  constexpr explicit Time(SDL_Time time)
    : m_value(FromNS(time))
  {
  }
 
  constexpr explicit operator bool() const
  {
    return m_value != std::chrono::nanoseconds{};
  }
 
  constexpr operator std::chrono::nanoseconds() const { return m_value; }
 
  static Time Current();
 
  static constexpr Time FromNS(Sint64 time)
  {
    return Time{std::chrono::nanoseconds{time}};
  }
 
  constexpr Sint64 ToNS() const { return m_value.count(); }
 
  static constexpr Time FromPosix(Sint64 time);
 
  constexpr Sint64 ToPosix() const;
 
  static Time FromWindows(Uint32 dwLowDateTime, Uint32 dwHighDateTime);
 
  void ToWindows(Uint32* dwLowDateTime, Uint32* dwHighDateTime) const;
 
  constexpr float ToSeconds() const { return Seconds(m_value).count(); }
 
  static constexpr Time FromSeconds(float interval)
  {
    return std::chrono::duration_cast<std::chrono::nanoseconds>(
      Seconds(interval));
  }
 
  constexpr Time& operator+=(std::chrono::nanoseconds interval)
  {
    m_value += interval;
    return *this;
  }
 
  constexpr Time& operator-=(std::chrono::nanoseconds interval)
  {
    m_value -= interval;
    return *this;
  }
};
 
constexpr Time MAX_TIME = Time::FromNS(SDL_MAX_TIME);
 
constexpr Time MIN_TIME = Time::FromNS(SDL_MIN_TIME);
 
#ifdef SDL3PP_DOC
 
#define SDL_FLT_EPSILON 1.1920928955078125e-07F /* 0x0.000002p0 */
 
#define SDL_INIT_INTERFACE(iface)                                              \
  do {                                                                         \
    SDL_zerop(iface);                                                          \
    (iface)->version = sizeof(*(iface));                                       \
  } while (0)
 
#endif // SDL3PP_DOC
 
inline void* malloc(size_t size) { return SDL_malloc(size); }
 
inline void* calloc(size_t nmemb, size_t size)
{
  return SDL_calloc(nmemb, size);
}
 
inline void* realloc(void* mem, size_t size) { return SDL_realloc(mem, size); }
 
inline void free(void* mem) { SDL_free(mem); }
 
using malloc_func = SDL_malloc_func;
 
using calloc_func = SDL_calloc_func;
 
using realloc_func = SDL_realloc_func;
 
using free_func = SDL_free_func;
 
inline void GetOriginalMemoryFunctions(malloc_func* malloc_func,
                                       calloc_func* calloc_func,
                                       realloc_func* realloc_func,
                                       free_func* free_func)
{
  SDL_GetOriginalMemoryFunctions(
    malloc_func, calloc_func, realloc_func, free_func);
}
 
inline void GetMemoryFunctions(malloc_func* malloc_func,
                               calloc_func* calloc_func,
                               realloc_func* realloc_func,
                               free_func* free_func)
{
  SDL_GetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func);
}
 
inline void SetMemoryFunctions(malloc_func malloc_func,
                               calloc_func calloc_func,
                               realloc_func realloc_func,
                               free_func free_func)
{
  CheckError(
    SDL_SetMemoryFunctions(malloc_func, calloc_func, realloc_func, free_func));
}
 
inline void* aligned_alloc(size_t alignment, size_t size)
{
  return SDL_aligned_alloc(alignment, size);
}
 
inline void aligned_free(void* mem) { SDL_aligned_free(mem); }
 
inline int GetNumAllocations() { return SDL_GetNumAllocations(); }
 
struct EnvironmentBase : Resource<SDL_Environment*>
{
  using Resource::Resource;
 
  EnvironmentBase(bool populated)
    : Resource(CheckError(SDL_CreateEnvironment(populated)))
  {
  }
 
  const char* GetVariable(StringParam name)
  {
    return SDL_GetEnvironmentVariable(get(), name);
  }
 
  inline OwnArray<char*> GetVariables()
  {
    return OwnArray<char*>{CheckError(SDL_GetEnvironmentVariables(get()))};
  }
 
  inline Uint64 GetVariableCount()
  {
    Uint64 count = 0;
    for (auto& var : GetVariables()) count += 1;
    return count;
  }
 
  void SetVariable(StringParam name, StringParam value, bool overwrite)
  {
    CheckError(SDL_SetEnvironmentVariable(get(), name, value, overwrite));
  }
 
  void UnsetVariable(StringParam name)
  {
    CheckError(SDL_UnsetEnvironmentVariable(get(), name));
  }
};
 
struct EnvironmentRef : EnvironmentBase
{
  using EnvironmentBase::EnvironmentBase;
 
  constexpr EnvironmentRef(const EnvironmentRef& other)
    : EnvironmentBase(other.get())
  {
  }
 
  constexpr EnvironmentRef(EnvironmentRef&& other)
    : EnvironmentBase(other.release())
  {
  }
 
  constexpr ~EnvironmentRef() = default;
 
  EnvironmentRef& operator=(EnvironmentRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Environment* newResource = {})
  {
    SDL_DestroyEnvironment(release(newResource));
  }
};
 
struct Environment : EnvironmentRef
{
  using EnvironmentRef::EnvironmentRef;
 
  constexpr explicit Environment(SDL_Environment* resource = {})
    : EnvironmentRef(resource)
  {
  }
 
  constexpr Environment(const Environment& other) = delete;
 
  constexpr Environment(Environment&& other) = default;
 
  ~Environment() { reset(); }
 
  Environment& operator=(Environment other)
  {
    reset(other.release());
    return *this;
  }
};
 
inline EnvironmentRef GetEnvironment() { return SDL_GetEnvironment(); }
 
inline const char* getenv(StringParam name) { return SDL_getenv(name); }
 
inline const char* getenv_unsafe(StringParam name)
{
  return SDL_getenv_unsafe(name);
}
 
inline int setenv_unsafe(StringParam name, StringParam value, int overwrite)
{
  return SDL_setenv_unsafe(name, value, overwrite);
}
 
inline int unsetenv_unsafe(StringParam name)
{
  return SDL_unsetenv_unsafe(name);
}
 
using CompareCallback = SDL_CompareCallback;
 
inline void qsort(void* base,
                  size_t nmemb,
                  size_t size,
                  CompareCallback compare)
{
  SDL_qsort(base, nmemb, size, compare);
}
 
inline void* bsearch(const void* key,
                     const void* base,
                     size_t nmemb,
                     size_t size,
                     CompareCallback compare)
{
  return SDL_bsearch(key, base, nmemb, size, compare);
}
 
using CompareCallback_r = SDL_CompareCallback_r;
 
using CompareCB = std::function<int(const void*, const void*)>;
 
inline void qsort_r(void* base,
                    size_t nmemb,
                    size_t size,
                    CompareCallback_r compare,
                    void* userdata)
{
  SDL_qsort_r(base, nmemb, size, compare, userdata);
}
 
inline void qsort_r(void* base, size_t nmemb, size_t size, CompareCB compare)
{
  return qsort_r(
    base,
    nmemb,
    size,
    [](void* userdata, const void* a, const void* b) {
      auto& cb = *static_cast<CompareCB*>(userdata);
      return cb(a, b);
    },
    &compare);
}
 
inline void* bsearch_r(const void* key,
                       const void* base,
                       size_t nmemb,
                       size_t size,
                       CompareCallback_r compare,
                       void* userdata)
{
  return SDL_bsearch_r(key, base, nmemb, size, compare, userdata);
}
 
inline void* bsearch_r(const void* key,
                       const void* base,
                       size_t nmemb,
                       size_t size,
                       CompareCB compare)
{
  return bsearch_r(
    key,
    base,
    nmemb,
    size,
    [](void* userdata, const void* a, const void* b) {
      auto& cb = *static_cast<CompareCB*>(userdata);
      return cb(a, b);
    },
    &compare);
}
 
inline int abs(int x) { return SDL_abs(x); }
 
inline double abs(double x) { return SDL_fabs(x); }
 
inline float abs(float x) { return SDL_fabsf(x); }
 
template<class T, class U>
constexpr T min(T x, U y)
{
  return SDL_min(x, y);
}
 
template<class T, class U>
constexpr T max(T x, U y)
{
  return SDL_max(x, y);
}
 
template<class T, class U, class V>
constexpr T clamp(T x, U a, V b)
{
  return SDL_clamp(x, a, b);
}
 
inline int isalpha(int x) { return SDL_isalpha(x); }
 
inline int isalnum(int x) { return SDL_isalnum(x); }
 
inline int isblank(int x) { return SDL_isblank(x); }
 
inline int iscntrl(int x) { return SDL_iscntrl(x); }
 
inline int isdigit(int x) { return SDL_isdigit(x); }
 
inline int isxdigit(int x) { return SDL_isxdigit(x); }
 
inline int ispunct(int x) { return SDL_ispunct(x); }
 
inline int isspace(int x) { return SDL_isspace(x); }
 
inline int isupper(int x) { return SDL_isupper(x); }
 
inline int islower(int x) { return SDL_islower(x); }
 
inline int isprint(int x) { return SDL_isprint(x); }
 
inline int isgraph(int x) { return SDL_isgraph(x); }
 
inline int toupper(int x) { return SDL_toupper(x); }
 
inline int tolower(int x) { return SDL_tolower(x); }
 
inline Uint16 crc16(Uint16 crc, const void* data, size_t len)
{
  return SDL_crc16(crc, data, len);
}
 
inline Uint32 crc32(Uint32 crc, const void* data, size_t len)
{
  return SDL_crc32(crc, data, len);
}
 
inline Uint32 murmur3_32(const void* data, size_t len, Uint32 seed)
{
  return SDL_murmur3_32(data, len, seed);
}
 
inline void* memcpy(void* dst, const void* src, size_t len)
{
#ifdef SDL_SLOW_MEMCPY
  return SDL_memcpy(dst, src, len);
#else
  return ::memcpy(dst, src, len);
#endif // SDL_SLOW_MEMCPY
}
 
#ifdef SDL3PP_DOC
 
#define SDL_copyp(dst, src)                                                    \
  {                                                                            \
    SDL_COMPILE_TIME_ASSERT(SDL_copyp, sizeof(*(dst)) == sizeof(*(src)));      \
  }                                                                            \
  SDL_memcpy((dst), (src), sizeof(*(src)))
 
#endif // SDL3PP_DOC
 
inline void* memmove(void* dst, const void* src, size_t len)
{
#ifdef SDL_SLOW_MEMMOVE
  return SDL_memmove(dst, src, len);
#else
  return ::memmove(dst, src, len);
#endif // SDL_SLOW_MEMMOVE
}
 
inline void* memset(void* dst, int c, size_t len)
{
#ifdef SDL_SLOW_MEMSET
  return SDL_memset(dst, c, len);
#else
  return ::memset(dst, c, len);
#endif // SDL_SLOW_MEMSET
}
 
inline void* memset4(void* dst, Uint32 val, size_t dwords)
{
  return SDL_memset4(dst, val, dwords);
}
 
template<class T>
inline void zero(T& x)
{
  SDL_zero(x);
}
 
template<class T>
inline void zerop(T* x)
{
  SDL_zerop(x);
}
 
template<class T, std::size_t N>
inline void zeroa(T (&x)[N])
{
  SDL_zeroa(x);
}
 
inline int memcmp(const void* s1, const void* s2, size_t len)
{
  return SDL_memcmp(s1, s2, len);
}
 
inline size_t wcslen(const wchar_t* wstr) { return SDL_wcslen(wstr); }
 
inline size_t wcsnlen(const wchar_t* wstr, size_t maxlen)
{
  return SDL_wcsnlen(wstr, maxlen);
}
 
inline size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t maxlen)
{
  return SDL_wcslcpy(dst, src, maxlen);
}
 
inline size_t wcslcat(wchar_t* dst, const wchar_t* src, size_t maxlen)
{
  return SDL_wcslcat(dst, src, maxlen);
}
 
inline wchar_t* wcsdup(const wchar_t* wstr) { return SDL_wcsdup(wstr); }
 
inline wchar_t* wcsstr(const wchar_t* haystack, const wchar_t* needle)
{
  return SDL_wcsstr(haystack, needle);
}
 
inline wchar_t* wcsnstr(const wchar_t* haystack,
                        const wchar_t* needle,
                        size_t maxlen)
{
  return SDL_wcsnstr(haystack, needle, maxlen);
}
 
inline int wcscmp(const wchar_t* str1, const wchar_t* str2)
{
  return SDL_wcscmp(str1, str2);
}
 
inline int wcsncmp(const wchar_t* str1, const wchar_t* str2, size_t maxlen)
{
  return SDL_wcsncmp(str1, str2, maxlen);
}
 
inline int wcscasecmp(const wchar_t* str1, const wchar_t* str2)
{
  return SDL_wcscasecmp(str1, str2);
}
 
inline int wcsncasecmp(const wchar_t* str1, const wchar_t* str2, size_t maxlen)
{
  return SDL_wcsncasecmp(str1, str2, maxlen);
}
 
inline long wcstol(const wchar_t* str, wchar_t** endp, int base)
{
  return SDL_wcstol(str, endp, base);
}
 
inline size_t strlen(StringParam str) { return SDL_strlen(str); }
 
inline size_t strnlen(StringParam str, size_t maxlen)
{
  return SDL_strnlen(str, maxlen);
}
 
inline size_t strlcpy(char* dst, StringParam src, size_t maxlen)
{
  return SDL_strlcpy(dst, src, maxlen);
}
 
inline size_t utf8strlcpy(char* dst, StringParam src, size_t dst_bytes)
{
  return SDL_utf8strlcpy(dst, src, dst_bytes);
}
 
inline size_t strlcat(char* dst, StringParam src, size_t maxlen)
{
  return SDL_strlcat(dst, src, maxlen);
}
 
inline char* strdup(StringParam str) { return SDL_strdup(str); }
 
inline char* strndup(StringParam str, size_t maxlen)
{
  return SDL_strndup(str, maxlen);
}
 
inline char* strrev(char* str) { return SDL_strrev(str); }
 
inline char* strupr(char* str) { return SDL_strupr(str); }
 
inline char* strlwr(char* str) { return SDL_strlwr(str); }
 
inline char* strchr(StringParam str, int c) { return SDL_strchr(str, c); }
 
inline char* strrchr(StringParam str, int c) { return SDL_strrchr(str, c); }
 
inline char* strstr(StringParam haystack, StringParam needle)
{
  return SDL_strstr(haystack, needle);
}
 
inline char* strnstr(StringParam haystack, StringParam needle, size_t maxlen)
{
  return SDL_strnstr(haystack, needle, maxlen);
}
 
inline char* strcasestr(StringParam haystack, StringParam needle)
{
  return SDL_strcasestr(haystack, needle);
}
 
inline char* strtok_r(char* str, StringParam delim, char** saveptr)
{
  return SDL_strtok_r(str, delim, saveptr);
}
 
inline size_t utf8strlen(StringParam str) { return SDL_utf8strlen(str); }
 
inline size_t utf8strnlen(StringParam str, size_t bytes)
{
  return SDL_utf8strnlen(str, bytes);
}
 
inline char* itoa(int value, char* str, int radix)
{
  return SDL_itoa(value, str, radix);
}
 
inline char* uitoa(unsigned int value, char* str, int radix)
{
  return SDL_uitoa(value, str, radix);
}
 
inline char* ltoa(long value, char* str, int radix)
{
  return SDL_ltoa(value, str, radix);
}
 
inline char* ultoa(unsigned long value, char* str, int radix)
{
  return SDL_ultoa(value, str, radix);
}
 
inline int atoi(StringParam str) { return SDL_atoi(str); }
 
inline double atof(StringParam str) { return SDL_atof(str); }
 
inline long strtol(StringParam str, char** endp, int base)
{
  return SDL_strtol(str, endp, base);
}
 
inline unsigned long strtoul(StringParam str, char** endp, int base)
{
  return SDL_strtoul(str, endp, base);
}
 
inline double strtod(StringParam str, char** endp)
{
  return SDL_strtod(str, endp);
}
 
inline int strcmp(StringParam str1, StringParam str2)
{
  return SDL_strcmp(str1, str2);
}
 
inline int strncmp(StringParam str1, StringParam str2, size_t maxlen)
{
  return SDL_strncmp(str1, str2, maxlen);
}
 
inline int strcasecmp(StringParam str1, StringParam str2)
{
  return SDL_strcasecmp(str1, str2);
}
 
inline int strncasecmp(StringParam str1, StringParam str2, size_t maxlen)
{
  return SDL_strncasecmp(str1, str2, maxlen);
}
 
inline char* strpbrk(StringParam str, StringParam breakset)
{
  return SDL_strpbrk(str, breakset);
}
 
constexpr Uint32 INVALID_UNICODE_CODEPOINT = SDL_INVALID_UNICODE_CODEPOINT;
 
inline Uint32 StepUTF8(const char** pstr, size_t* pslen)
{
  return SDL_StepUTF8(pstr, pslen);
}
 
inline Uint32 StepBackUTF8(StringParam start, const char** pstr)
{
  return SDL_StepBackUTF8(start, pstr);
}
 
inline char* UCS4ToUTF8(Uint32 codepoint, char* dst)
{
  return SDL_UCS4ToUTF8(codepoint, dst);
}
 
inline int sscanf(StringParam text,
                  SDL_SCANF_FORMAT_STRING const char* fmt,
                  ...)
{
  int rc;
  va_list ap;
  va_start(ap, fmt);
  rc = SDL_vsscanf(text, fmt, ap);
  va_end(ap);
  return rc;
}
 
inline int vsscanf(StringParam text,
                   SDL_SCANF_FORMAT_STRING const char* fmt,
                   va_list ap)
{
  return SDL_vsscanf(text, fmt, ap);
}
 
inline int snprintf(char* text,
                    size_t maxlen,
                    SDL_PRINTF_FORMAT_STRING const char* fmt,
                    ...)
{
  va_list ap;
  int result;
 
  va_start(ap, fmt);
  result = SDL_vsnprintf(text, maxlen, fmt, ap);
  va_end(ap);
 
  return result;
}
 
inline int swprintf(wchar_t* text,
                    size_t maxlen,
                    SDL_PRINTF_FORMAT_STRING const wchar_t* fmt,
                    ...)
{
  va_list ap;
  int result;
 
  va_start(ap, fmt);
  result = SDL_vswprintf(text, maxlen, fmt, ap);
  va_end(ap);
 
  return result;
}
 
inline int vsnprintf(char* text,
                     size_t maxlen,
                     SDL_PRINTF_FORMAT_STRING const char* fmt,
                     va_list ap)
{
  return SDL_vsnprintf(text, maxlen, fmt, ap);
}
 
inline int vswprintf(wchar_t* text,
                     size_t maxlen,
                     SDL_PRINTF_FORMAT_STRING const wchar_t* fmt,
                     va_list ap)
{
  return SDL_vswprintf(text, maxlen, fmt, ap);
}
 
inline int asprintf(char** strp, SDL_PRINTF_FORMAT_STRING const char* fmt, ...)
{
  va_list ap;
  int result;
 
  va_start(ap, fmt);
  result = SDL_vasprintf(strp, fmt, ap);
  va_end(ap);
 
  return result;
}
 
inline int vasprintf(char** strp,
                     SDL_PRINTF_FORMAT_STRING const char* fmt,
                     va_list ap)
{
  return SDL_vasprintf(strp, fmt, ap);
}
 
inline void srand(Uint64 seed) { SDL_srand(seed); }
 
inline Sint32 rand(Sint32 n) { return SDL_rand(n); }
 
inline float randf() { return SDL_randf(); }
 
inline Uint32 rand_bits() { return SDL_rand_bits(); }
 
class Random
{
  Uint64 m_state;
 
public:
  constexpr Random(Uint64 state)
    : m_state(state)
  {
  }
 
  constexpr operator Uint64() { return m_state; }
 
  Sint32 rand(Sint32 n) { return SDL_rand_r(&m_state, n); }
 
  float randf() { return SDL_randf_r(&m_state); }
 
  Uint32 rand_bits() { return SDL_rand_bits_r(&m_state); }
};
 
constexpr double PI_D = SDL_PI_D;
 
constexpr float PI_F = SDL_PI_F;
 
inline double acos(double x) { return SDL_acos(x); }
 
inline float acos(float x) { return SDL_acosf(x); }
 
inline double asin(double x) { return SDL_asin(x); }
 
inline float asin(float x) { return SDL_asinf(x); }
 
inline double atan(double x) { return SDL_atan(x); }
 
inline float atan(float x) { return SDL_atanf(x); }
 
inline double atan2(double y, double x) { return SDL_atan2(y, x); }
 
inline float atan2(float y, float x) { return SDL_atan2f(y, x); }
 
inline double ceil(double x) { return SDL_ceil(x); }
 
inline float ceil(float x) { return SDL_ceilf(x); }
 
inline double copysign(double x, double y) { return SDL_copysign(x, y); }
 
inline float copysign(float x, float y) { return SDL_copysignf(x, y); }
 
inline double cos(double x) { return SDL_cos(x); }
 
inline float cos(float x) { return SDL_cosf(x); }
 
inline double exp(double x) { return SDL_exp(x); }
 
inline float exp(float x) { return SDL_expf(x); }
 
inline double floor(double x) { return SDL_floor(x); }
 
inline float floor(float x) { return SDL_floorf(x); }
 
inline double trunc(double x) { return SDL_trunc(x); }
 
inline float trunc(float x) { return SDL_truncf(x); }
 
inline double fmod(double x, double y) { return SDL_fmod(x, y); }
 
inline float fmod(float x, float y) { return SDL_fmodf(x, y); }
 
inline int isinf(double x) { return SDL_isinf(x); }
 
inline int isinf(float x) { return SDL_isinff(x); }
 
inline int isnan(double x) { return SDL_isnan(x); }
 
inline int isnan(float x) { return SDL_isnanf(x); }
 
inline double log(double x) { return SDL_log(x); }
 
inline float log(float x) { return SDL_logf(x); }
 
inline double log10(double x) { return SDL_log10(x); }
 
inline float log10(float x) { return SDL_log10f(x); }
 
inline double modf(double x, double* y) { return SDL_modf(x, y); }
 
inline float modf(float x, float* y) { return SDL_modff(x, y); }
 
inline double pow(double x, double y) { return SDL_pow(x, y); }
 
inline float pow(float x, float y) { return SDL_powf(x, y); }
 
inline double round(double x) { return SDL_round(x); }
 
inline float round(float x) { return SDL_roundf(x); }
 
inline long lround(double x) { return SDL_lround(x); }
 
inline long lround(float x) { return SDL_lroundf(x); }
 
inline double scalbn(double x, int n) { return SDL_scalbn(x, n); }
 
inline float scalbn(float x, int n) { return SDL_scalbnf(x, n); }
 
inline double sin(double x) { return SDL_sin(x); }
 
inline float sin(float x) { return SDL_sinf(x); }
 
inline double sqrt(double x) { return SDL_sqrt(x); }
 
inline float sqrt(float x) { return SDL_sqrtf(x); }
 
inline double tan(double x) { return SDL_tan(x); }
 
inline float tan(float x) { return SDL_tanf(x); }
 
struct IConvBase : Resource<SDL_iconv_data_t*>
{
  using Resource::Resource;
 
  IConvBase(StringParam tocode, StringParam fromcode)
    : Resource(SDL_iconv_open(tocode, fromcode))
  {
  }
 
  size_t iconv(const char** inbuf,
               size_t* inbytesleft,
               char** outbuf,
               size_t* outbytesleft)
  {
    return SDL_iconv(get(), inbuf, inbytesleft, outbuf, outbytesleft);
  }
};
 
struct IConvRef : IConvBase
{
  using IConvBase::IConvBase;
 
  constexpr IConvRef(const IConvRef& other)
    : IConvBase(other.get())
  {
  }
 
  constexpr IConvRef(IConvRef&& other)
    : IConvBase(other.release())
  {
  }
 
  constexpr ~IConvRef() = default;
 
  IConvRef& operator=(IConvRef other)
  {
    release(other.release());
    return *this;
  }
 
  int reset(SDL_iconv_data_t* newResource = {})
  {
    return SDL_iconv_close(release(newResource));
  }
};
 
struct IConv : IConvRef
{
  using IConvRef::IConvRef;
 
  constexpr explicit IConv(SDL_iconv_data_t* resource = {})
    : IConvRef(resource)
  {
  }
 
  constexpr IConv(const IConv& other) = delete;
 
  constexpr IConv(IConv&& other) = default;
 
  ~IConv() { reset(); }
 
  IConv& operator=(IConv other)
  {
    reset(other.release());
    return *this;
  }
};
 
#ifdef SDL3PP_DOC
 
#define SDL_ICONV_ERROR (size_t)-1
 
#define SDL_ICONV_E2BIG (size_t)-2
 
#define SDL_ICONV_EILSEQ (size_t)-3
 
#define SDL_ICONV_EINVAL (size_t)-4
 
#endif // SDL3PP_DOC
 
inline OwnPtr<char> iconv_string(StringParam tocode,
                                 StringParam fromcode,
                                 StringParam inbuf,
                                 size_t inbytesleft)
{
  return OwnPtr<char>{SDL_iconv_string(tocode, fromcode, inbuf, inbytesleft)};
}
 
#ifdef SDL3PP_DOC
 
#define SDL_iconv_utf8_locale(S)                                               \
  SDL_iconv_string("", "UTF-8", S, SDL_strlen(S) + 1)
 
#define SDL_iconv_utf8_ucs2(S)                                                 \
  (Uint16*)SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S) + 1)
 
#define SDL_iconv_utf8_ucs4(S)                                                 \
  (Uint32*)SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S) + 1)
 
#define SDL_iconv_wchar_utf8(S)                                                \
  SDL_iconv_string(                                                            \
    "UTF-8", "WCHAR_T", (char*)S, (SDL_wcslen(S) + 1) * sizeof(wchar_t))
 
#endif // SDL3PP_DOC
 
inline bool size_mul_check_overflow(size_t a, size_t b, size_t* ret)
{
  return SDL_size_mul_check_overflow(a, b, ret);
}
 
inline bool size_add_check_overflow(size_t a, size_t b, size_t* ret)
{
  return SDL_size_add_check_overflow(a, b, ret);
}
 
using FunctionPointer = SDL_FunctionPointer;
 
#pragma region impl
 
inline void PtrDeleter::operator()(void* ptr) const { SDL_free(ptr); }
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_STDINC_H_ */