SDL3pp_rect.h

#ifndef SDL3PP_RECT_H_
#define SDL3PP_RECT_H_
 
#include <SDL3/SDL_rect.h>
#include "SDL3pp_error.h"
#include "SDL3pp_optionalRef.h"
#include "SDL3pp_spanRef.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {


using PointRaw = SDL_Point;
 
// Forward decl
struct Point;

using FPointRaw = SDL_FPoint;
 
// Forward decl
struct FPoint;

using RectRaw = SDL_Rect;
 
// Forward decl
struct Rect;

using FRectRaw = SDL_FRect;
 
// Forward decl
struct FRect;

constexpr bool operator==(const PointRaw& lhs, const PointRaw& rhs) noexcept
{
  return lhs.x == rhs.x && lhs.y == rhs.y;
}

constexpr bool operator==(const FPointRaw& lhs, const FPointRaw& rhs) noexcept
{
  return lhs.x == rhs.x && lhs.y == rhs.y;
}

inline bool operator==(const RectRaw& lhs, const RectRaw& rhs) noexcept
{
  return SDL_RectsEqual(&lhs, &rhs);
}

inline bool operator==(const FRectRaw& lhs, const FRectRaw& rhs) noexcept
{
  return SDL_RectsEqualFloat(&lhs, &rhs);
}

constexpr auto operator<=>(const PointRaw& lhs, const PointRaw& rhs) noexcept
{
  if (lhs.x != rhs.x) return lhs.x <=> rhs.x;
  return lhs.y <=> rhs.y;
}

constexpr auto operator<=>(const FPointRaw& lhs, const FPointRaw& rhs) noexcept
{
  if (lhs.x != rhs.x) return lhs.x <=> rhs.x;
  return lhs.y <=> rhs.y;
}

struct Point : PointRaw
{
  constexpr Point(const PointRaw& p = {}) noexcept
    : PointRaw(p)
  {
  }

  constexpr Point(int x, int y) noexcept
    : PointRaw{x, y}
  {
  }

  constexpr Point(int v) noexcept
    : PointRaw{v, v}
  {
  }

  constexpr explicit Point(const FPointRaw& p)
    : SDL_Point{int(p.x), int(p.y)}
  {
  }

  constexpr explicit operator bool() const noexcept
  {
    return *this != PointRaw{};
  }

  constexpr int GetX() const noexcept { return x; }

  constexpr Point& SetX(int newX) noexcept
  {
    x = newX;
    return *this;
  }

  constexpr int GetY() const noexcept { return y; }

  constexpr Point& SetY(int newY) noexcept
  {
    y = newY;
    return *this;
  }

  bool InRect(const RectRaw& r) const;

  constexpr Point operator-() const { return Point(-x, -y); }

  constexpr Point& operator+=(const Point& other)
  {
    x += other.x;
    y += other.y;
    return *this;
  }

  constexpr Point& operator-=(const Point& other)
  {
    x -= other.x;
    y -= other.y;
    return *this;
  }

  constexpr Point& operator/=(const Point& other)
  {
    x /= other.x;
    y /= other.y;
    return *this;
  }

  constexpr Point& operator%=(const Point& other)
  {
    x %= other.x;
    y %= other.y;
    return *this;
  }

  constexpr Point& operator*=(const Point& other)
  {
    x *= other.x;
    y *= other.y;
    return *this;
  }

  constexpr Point GetClamped(const Rect& rect) const;

  constexpr Point& Clamp(const Rect& rect);

  constexpr Point GetWrapped(const Rect& rect) const;

  constexpr Point& Wrap(const Rect& rect);

  constexpr operator FPoint() const;
};

constexpr Point operator+(const Point& lhs, const Point& rhs)
{
  return Point(lhs.x + rhs.x, lhs.y + rhs.y);
}

constexpr Point operator-(const Point& lhs, const Point& rhs)
{
  return Point(lhs.x - rhs.x, lhs.y - rhs.y);
}

constexpr Point operator/(const Point& lhs, const Point& rhs)
{
  return Point(lhs.x / rhs.x, lhs.y / rhs.y);
}

constexpr Point operator%(const Point& lhs, const Point& rhs)
{
  return Point(lhs.x % rhs.x, lhs.y % rhs.y);
}

constexpr Point operator*(const Point& lhs, const Point& rhs)
{
  return Point(lhs.x * rhs.x, lhs.y * rhs.y);
}

struct FPoint : FPointRaw
{
  constexpr FPoint(const FPointRaw& p = {}) noexcept
    : FPointRaw(p)
  {
  }

  constexpr FPoint(float x, float y) noexcept
    : FPointRaw{x, y}
  {
  }

  constexpr FPoint(float v) noexcept
    : FPointRaw{v, v}
  {
  }

  constexpr explicit operator bool() const noexcept
  {
    return *this != FPointRaw{};
  }

  constexpr float GetX() const noexcept { return x; }

  constexpr FPoint& SetX(float newX) noexcept
  {
    x = newX;
    return *this;
  }

  constexpr float GetY() const noexcept { return y; }

  constexpr FPoint& SetY(float newY) noexcept
  {
    y = newY;
    return *this;
  }

  bool InRect(const FRectRaw& r) const;

  constexpr FPoint operator-() const { return FPoint(-x, -y); }

  constexpr FPoint& operator+=(const FPoint& other)
  {
    x += other.x;
    y += other.y;
    return *this;
  }

  constexpr FPoint& operator-=(const FPoint& other)
  {
    x -= other.x;
    y -= other.y;
    return *this;
  }

  constexpr FPoint& operator/=(const FPoint& other)
  {
    x /= other.x;
    y /= other.y;
    return *this;
  }

  constexpr FPoint& operator*=(const FPoint& other)
  {
    x *= other.x;
    y *= other.y;
    return *this;
  }

  constexpr FPoint GetClamped(const FRect& rect) const;

  constexpr FPoint& Clamp(const FRect& rect);

  constexpr FPoint GetWrapped(const FRect& rect) const;

  constexpr FPoint& Wrap(const FRect& rect);
};

constexpr FPoint operator+(const FPoint& lhs, const FPoint& rhs)
{
  return FPoint(lhs.x + rhs.x, lhs.y + rhs.y);
}

constexpr FPoint operator-(const FPoint& lhs, const FPoint& rhs)
{
  return FPoint(lhs.x - rhs.x, lhs.y - rhs.y);
}

constexpr FPoint operator/(const FPoint& lhs, const FPoint& rhs)
{
  return FPoint(lhs.x / rhs.x, lhs.y / rhs.y);
}

constexpr FPoint operator*(const FPoint& lhs, const FPoint& rhs)
{
  return FPoint(lhs.x * rhs.x, lhs.y * rhs.y);
}

struct Rect : RectRaw
{
  constexpr Rect(const RectRaw& r = {}) noexcept
    : RectRaw(r)
  {
  }

  constexpr Rect(int x, int y, int w, int h) noexcept
    : RectRaw{x, y, w, h}
  {
  }

  constexpr explicit Rect(const FRectRaw& r)
    : RectRaw{int(r.x), int(r.y), int(r.w), int(r.h)}
  {
  }

  constexpr Rect(const Point& corner, const Point& size)
    : RectRaw{corner.x, corner.y, size.x, size.y}
  {
  }

  explicit operator bool() const { return !Empty(); }

  const Point& position() const { return reinterpret_cast<const Point&>(x); }

  Point& position() { return reinterpret_cast<Point&>(x); }

  const Point& size() const { return reinterpret_cast<const Point&>(w); }

  Point& size() { return reinterpret_cast<Point&>(w); }

  constexpr int GetX() const noexcept { return x; }

  constexpr Rect& SetX(int newX) noexcept
  {
    x = newX;
    return *this;
  }

  constexpr int GetY() const noexcept { return y; }

  constexpr Rect& SetY(int newY) noexcept
  {
    y = newY;
    return *this;
  }

  constexpr int GetW() const noexcept { return w; }

  constexpr Rect& SetW(int newW) noexcept
  {
    w = newW;
    return *this;
  }

  constexpr int GetH() const noexcept { return h; }

  constexpr Rect& SetH(int newH) noexcept
  {
    h = newH;
    return *this;
  }

  static Rect GetEnclosingPoints(
    SpanRef<const PointRaw> points,
    OptionalRef<const RectRaw> clip = std::nullopt);

  static constexpr Rect FromCenter(int cx, int cy, int w, int h)
  {
    return Rect(cx - w / 2, cy - h / 2, w, h);
  }

  static constexpr Rect FromCenter(Point center, Point size)
  {
    return Rect(center - size / 2, size);
  }

  static constexpr Rect FromCorners(int x1, int y1, int x2, int y2)
  {
    return Rect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
  }

  static constexpr Rect FromCorners(Point p1, Point p2)
  {
    return Rect(p1, p2 - p1 + Point(1, 1));
  }

  constexpr int GetX2() const { return x + w - 1; }

  constexpr Rect& SetX2(int x2)
  {
    w = x2 - x + 1;
    return *this;
  }

  constexpr int GetY2() const { return y + h - 1; }

  constexpr Rect& SetY2(int y2)
  {
    h = y2 - y + 1;
    return *this;
  }

  constexpr Point GetTopLeft() const { return Point(x, y); }

  constexpr Point GetTopRight() const { return Point(GetX2(), y); }

  constexpr Point GetBottomLeft() const { return Point(x, GetY2()); }

  constexpr Point GetBottomRight() const { return Point(GetX2(), GetY2()); }

  constexpr Point GetPosition() const { return GetTopLeft(); }

  constexpr Rect& SetPosition(const Point& position)
  {
    x = position.x;
    y = position.y;
    return *this;
  }

  constexpr Point GetSize() const { return Point(w, h); }

  constexpr Rect& SetSize(const Point& size)
  {
    w = size.x;
    h = size.y;
    return *this;
  }

  constexpr Point GetCentroid() const { return Point(x + w / 2, y + h / 2); }

  bool GetLineIntersection(PointRaw* p1, PointRaw* p2) const
  {
    return GetLineIntersection(p1 ? &p1->x : nullptr,
                               p1 ? &p1->y : nullptr,
                               p2 ? &p2->x : nullptr,
                               p2 ? &p2->y : nullptr);
  }

  bool GetLineIntersection(int* X1, int* Y1, int* X2, int* Y2) const;

  operator SDL_FRect() const;

  constexpr operator FRect() const;

  bool Empty() const;

  bool Equal(const RectRaw& other) const;

  bool Contains(const PointRaw& p) const { return SDL_PointInRect(&p, this); }

  bool Contains(const RectRaw& other) const { return GetUnion(other) == *this; }

  bool HasIntersection(const RectRaw& other) const;

  Rect GetIntersection(const RectRaw& other) const;

  constexpr Rect GetUnion(const RectRaw& other) const;

  constexpr Rect GetExtension(unsigned int amount) const
  {
    Rect r = *this;
    r.Extend(amount);
    return r;
  }

  constexpr Rect GetExtension(unsigned int hAmount, unsigned int vAmount) const
  {
    Rect r = *this;
    r.Extend(hAmount, vAmount);
    return r;
  }

  constexpr Rect& Extend(unsigned int amount) { return Extend(amount, amount); }

  constexpr Rect& Extend(unsigned int hAmount, unsigned int vAmount)
  {
    x -= hAmount;
    y -= vAmount;
    w += hAmount * 2;
    h += vAmount * 2;
    return *this;
  }

  constexpr Rect operator+(const Point& offset) const
  {
    return Rect(x + offset.x, y + offset.y, w, h);
  }

  constexpr Rect operator-(const Point& offset) const
  {
    return Rect(x - offset.x, y - offset.y, w, h);
  }

  constexpr Rect& operator+=(const Point& offset)
  {
    x += offset.x;
    y += offset.y;
    return *this;
  }

  constexpr Rect& operator-=(const Point& offset)
  {
    x -= offset.x;
    y -= offset.y;
    return *this;
  }
};

struct FRect : FRectRaw
{
  constexpr FRect(const FRectRaw& r = {}) noexcept
    : FRectRaw(r)
  {
  }

  constexpr FRect(float x, float y, float w, float h) noexcept
    : FRectRaw{x, y, w, h}
  {
  }

  constexpr FRect(const FPoint& corner, const FPoint& size)
    : FRect{corner.x, corner.y, size.x, size.y}
  {
  }

  operator bool() const { return !Empty(); }

  const FPoint& position() const { return reinterpret_cast<const FPoint&>(x); }

  FPoint& position() { return reinterpret_cast<FPoint&>(x); }

  const FPoint& size() const { return reinterpret_cast<const FPoint&>(w); }

  FPoint& size() { return reinterpret_cast<FPoint&>(w); }

  constexpr float GetX() const noexcept { return x; }

  constexpr FRect& SetX(float newX) noexcept
  {
    x = newX;
    return *this;
  }

  constexpr float GetY() const noexcept { return y; }

  constexpr FRect& SetY(float newY) noexcept
  {
    y = newY;
    return *this;
  }

  constexpr float GetW() const noexcept { return w; }

  constexpr FRect& SetW(float newW) noexcept
  {
    w = newW;
    return *this;
  }

  constexpr float GetH() const noexcept { return h; }

  constexpr FRect& SetH(float newH) noexcept
  {
    h = newH;
    return *this;
  }

  static FRect GetEnclosingPoints(
    SpanRef<const FPointRaw> points,
    OptionalRef<const FRectRaw> clip = std::nullopt);

  static constexpr FRect FromCenter(float cx, float cy, float w, float h)
  {
    return FRect(cx - w / 2, cy - h / 2, w, h);
  }

  static constexpr FRect FromCenter(FPoint center, FPoint size)
  {
    return FRect(center - size / 2, size);
  }

  static constexpr FRect FromCorners(float x1, float y1, float x2, float y2)
  {
    return FRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
  }

  static constexpr FRect FromCorners(FPoint p1, FPoint p2)
  {
    return FRect(p1, p2 - p1 + FPoint(1, 1));
  }

  constexpr float GetX2() const { return x + w - 1; }

  constexpr FRect& SetX2(float x2)
  {
    w = x2 - x + 1;
    return *this;
  }

  constexpr float GetY2() const { return y + h - 1; }

  constexpr FRect& SetY2(float y2)
  {
    h = y2 - y + 1;
    return *this;
  }

  constexpr FPoint GetTopLeft() const { return FPoint(x, y); }

  constexpr FPoint GetTopRight() const { return FPoint(GetX2(), y); }

  constexpr FPoint GetBottomLeft() const { return FPoint(x, GetY2()); }

  constexpr FPoint GetBottomRight() const { return FPoint(GetX2(), GetY2()); }

  constexpr FPoint GetPosition() const { return GetTopLeft(); }

  constexpr FRect& SetPosition(const FPoint& position)
  {
    x = position.x;
    y = position.y;
    return *this;
  }

  constexpr FPoint GetSize() const { return FPoint(w, h); }

  constexpr FRect& SetSize(const FPoint& size)
  {
    w = size.x;
    h = size.y;
    return *this;
  }

  constexpr FPoint GetCentroid() const { return FPoint(x + w / 2, y + h / 2); }

  bool GetLineIntersection(float* X1, float* Y1, float* X2, float* Y2) const;

  bool GetLineIntersection(FPoint* p1, FPoint* p2) const
  {
    return GetLineIntersection(p1 ? &p1->x : nullptr,
                               p1 ? &p1->y : nullptr,
                               p2 ? &p2->x : nullptr,
                               p2 ? &p2->y : nullptr);
  }

  bool Empty() const;

  bool EqualEpsilon(const FRectRaw& other, const float epsilon) const;

  bool Equal(const FRectRaw& other) const;

  bool Contains(const FPointRaw& p) const
  {
    return SDL_PointInRectFloat(&p, this);
  }

  bool Contains(const FRectRaw& other) const
  {
    return GetUnion(other) == *this;
  }

  bool HasIntersection(const FRectRaw& other) const;

  FRect GetIntersection(const FRectRaw& other) const;

  constexpr FRect GetUnion(const FRectRaw& other) const;

  constexpr FRect GetExtension(unsigned int amount) const
  {
    FRect r = *this;
    r.Extend(float(amount));
    return r;
  }

  constexpr FRect GetExtension(float hAmount, float vAmount) const
  {
    FRect r = *this;
    r.Extend(hAmount, vAmount);
    return r;
  }

  constexpr FRect& Extend(float amount) { return Extend(amount, amount); }

  constexpr FRect& Extend(float hAmount, float vAmount)
  {
    x -= hAmount;
    y -= vAmount;
    w += hAmount * 2;
    h += vAmount * 2;
    return *this;
  }

  constexpr FRect operator+(const FPoint& offset) const
  {
    return FRect(x + offset.x, y + offset.y, w, h);
  }

  constexpr FRect operator-(const FPoint& offset) const
  {
    return FRect(x - offset.x, y - offset.y, w, h);
  }

  constexpr FRect& operator+=(const FPoint& offset)
  {
    x += offset.x;
    y += offset.y;
    return *this;
  }

  constexpr FRect& operator-=(const FPoint& offset)
  {
    x -= offset.x;
    y -= offset.y;
    return *this;
  }
};

inline FRect RectToFRect(const RectRaw& rect)
{
  FRect frect;
  SDL_RectToFRect(&rect, &frect);
  return frect;
}
 
inline Rect::operator SDL_FRect() const { return SDL::RectToFRect(*this); }

inline bool PointInRect(const PointRaw& p, const RectRaw& r)
{
  return SDL_PointInRect(&p, &r);
}
 
inline bool Point::InRect(const RectRaw& r) const
{
  return SDL::PointInRect(*this, r);
}

inline bool RectEmpty(const RectRaw& r) { return SDL_RectEmpty(&r); }
 
inline bool Rect::Empty() const { return SDL::RectEmpty(*this); }

inline bool RectsEqual(const RectRaw& a, const RectRaw& b)
{
  return SDL_RectsEqual(&a, &b);
}
 
inline bool Rect::Equal(const RectRaw& other) const
{
  return SDL::RectsEqual(*this, other);
}

inline bool HasRectIntersection(const RectRaw& A, const RectRaw& B)
{
  return SDL_HasRectIntersection(&A, &B);
}
 
inline bool Rect::HasIntersection(const RectRaw& other) const
{
  return SDL::HasRectIntersection(*this, other);
}

inline Rect GetRectIntersection(const RectRaw& A, const RectRaw& B)
{
  if (Rect result; SDL_GetRectIntersection(&A, &B, &result)) return result;
  return {};
}
 
inline Rect Rect::GetIntersection(const RectRaw& other) const
{
  return SDL::GetRectIntersection(*this, other);
}

constexpr Rect GetRectUnion(const RectRaw& A, const RectRaw& B)
{
  Rect r;
  CheckError(SDL_GetRectUnion(&A, &B, &r));
  return r;
}
 
constexpr Rect Rect::GetUnion(const RectRaw& other) const
{
  return SDL::GetRectUnion(*this, other);
}

inline Rect GetRectEnclosingPoints(
  SpanRef<const PointRaw> points,
  OptionalRef<const RectRaw> clip = std::nullopt)
{
  if (Rect result; SDL_GetRectEnclosingPoints(
        points.data(), narrowS32(points.size()), clip, &result)) {
    return result;
  }
  return {};
}
 
inline Rect Rect::GetEnclosingPoints(SpanRef<const PointRaw> points,
                                     OptionalRef<const RectRaw> clip)
{
  return SDL::GetRectEnclosingPoints(points, clip);
}

inline bool GetRectAndLineIntersection(const RectRaw& rect,
                                       int* X1,
                                       int* Y1,
                                       int* X2,
                                       int* Y2)
{
  return SDL_GetRectAndLineIntersection(&rect, X1, Y1, X2, Y2);
}
 
inline bool Rect::GetLineIntersection(int* X1, int* Y1, int* X2, int* Y2) const
{
  return SDL::GetRectAndLineIntersection(*this, X1, Y1, X2, Y2);
}

inline bool PointInRectFloat(const FPointRaw& p, const FRectRaw& r)
{
  return SDL_PointInRectFloat(&p, &r);
}
 
inline bool FPoint::InRect(const FRectRaw& r) const
{
  return SDL::PointInRectFloat(*this, r);
}

inline bool RectEmptyFloat(const FRectRaw& r) { return SDL_RectEmptyFloat(&r); }
 
inline bool FRect::Empty() const { return SDL::RectEmptyFloat(*this); }

inline bool RectsEqualEpsilon(const FRectRaw& a,
                              const FRectRaw& b,
                              const float epsilon)
{
  return SDL_RectsEqualEpsilon(&a, &b, epsilon);
}
 
inline bool FRect::EqualEpsilon(const FRectRaw& other,
                                const float epsilon) const
{
  return SDL::RectsEqualEpsilon(*this, other, epsilon);
}

inline bool RectsEqualFloat(const FRectRaw& a, const FRectRaw& b)
{
  return SDL_RectsEqualFloat(&a, &b);
}
 
inline bool FRect::Equal(const FRectRaw& other) const
{
  return SDL::RectsEqualFloat(*this, other);
}

inline bool HasRectIntersectionFloat(const FRectRaw& A, const FRectRaw& B)
{
  return SDL_HasRectIntersectionFloat(&A, &B);
}
 
inline bool FRect::HasIntersection(const FRectRaw& other) const
{
  return SDL::HasRectIntersectionFloat(*this, other);
}

inline FRect GetRectIntersectionFloat(const FRectRaw& A, const FRectRaw& B)
{
  if (FRect r; SDL_GetRectIntersectionFloat(&A, &B, &r)) return r;
  return {};
}
 
inline FRect FRect::GetIntersection(const FRectRaw& other) const
{
  return SDL::GetRectIntersectionFloat(*this, other);
}

constexpr FRect GetRectUnionFloat(const FRectRaw& A, const FRectRaw& B)
{
  FRect r;
  CheckError(SDL_GetRectUnionFloat(&A, &B, &r));
  return r;
}
 
constexpr FRect FRect::GetUnion(const FRectRaw& other) const
{
  return SDL::GetRectUnionFloat(*this, other);
}

inline FRect GetRectEnclosingPointsFloat(
  SpanRef<const FPointRaw> points,
  OptionalRef<const FRectRaw> clip = std::nullopt)
{
  if (FRect result; SDL_GetRectEnclosingPointsFloat(
        points.data(), narrowS32(points.size()), clip, &result)) {
    return result;
  }
  return {};
}
 
inline FRect FRect::GetEnclosingPoints(SpanRef<const FPointRaw> points,
                                       OptionalRef<const FRectRaw> clip)
{
  return SDL::GetRectEnclosingPointsFloat(points, clip);
}

inline bool GetRectAndLineIntersectionFloat(const FRectRaw& rect,
                                            float* X1,
                                            float* Y1,
                                            float* X2,
                                            float* Y2)
{
  return SDL_GetRectAndLineIntersectionFloat(&rect, X1, Y1, X2, Y2);
}
 
inline bool FRect::GetLineIntersection(float* X1,
                                       float* Y1,
                                       float* X2,
                                       float* Y2) const
{
  return SDL::GetRectAndLineIntersectionFloat(*this, X1, Y1, X2, Y2);
}

 
constexpr Point::operator FPoint() const { return {float(x), float(y)}; }
 
constexpr Point Point::GetClamped(const Rect& rect) const
{
  Point p = *this;
  p.Clamp(rect);
  return p;
}
 
constexpr Point& Point::Clamp(const Rect& rect)
{
  if (x < rect.x) x = rect.x;
  if (x > rect.GetX2()) x = rect.GetX2();
  if (y < rect.y) y = rect.y;
  if (y > rect.GetY2()) y = rect.GetY2();
  return *this;
}
 
constexpr Point Point::GetWrapped(const Rect& rect) const
{
  Point p = *this;
  p.Wrap(rect);
  return p;
}
 
constexpr Point& Point::Wrap(const Rect& rect)
{
  if (x < rect.x)
    x = rect.x + rect.w - 1 - (rect.x - x + rect.w - 1) % rect.w;
  else if (x >= rect.x + rect.w)
    x = rect.x + (x - rect.x - rect.w) % rect.w;
 
  if (y < rect.y)
    y = rect.y + rect.h - 1 - (rect.y - y + rect.h - 1) % rect.h;
  else if (y >= rect.y + rect.h)
    y = rect.y + (y - rect.y - rect.h) % rect.h;
 
  return *this;
}
 
constexpr FPoint FPoint::GetClamped(const FRect& rect) const
{
  FPoint p = *this;
  p.Clamp(rect);
  return p;
}
 
constexpr FPoint& FPoint::Clamp(const FRect& rect)
{
  if (x < rect.x) x = rect.x;
  if (x > rect.GetX2()) x = rect.GetX2();
  if (y < rect.y) y = rect.y;
  if (y > rect.GetY2()) y = rect.GetY2();
  return *this;
}
 
constexpr FPoint FPoint::GetWrapped(const FRect& rect) const
{
  FPoint p = *this;
  p.Wrap(rect);
  return p;
}
 
constexpr FPoint& FPoint::Wrap(const FRect& rect)
{
  if (x < rect.x)
    x = rect.x + rect.w - 1 - SDL::fmod(rect.x - x + rect.w - 1, rect.w);
  else if (x >= rect.x + rect.w)
    x = rect.x + SDL::fmod(x - rect.x - rect.w, rect.w);
 
  if (y < rect.y)
    y = rect.y + rect.h - 1 - SDL::fmod(rect.y - y + rect.h - 1, rect.h);
  else if (y >= rect.y + rect.h)
    y = rect.y + SDL::fmod(y - rect.y - rect.h, rect.h);
 
  return *this;
}
 
constexpr Rect::operator FRect() const
{
  return {float(x), float(y), float(w), float(h)};
}
 
} // namespace SDL
 
#endif /* SDL3PP_RECT_H_ */