SDL3pp_rect.h

#ifndef SDL3PP_RECT_H_
#define SDL3PP_RECT_H_
 
#include <optional>
#include <span>
#include <SDL3/SDL_rect.h>
#include "SDL3pp_error.h"
#include "SDL3pp_optionalRef.h"
#include "SDL3pp_spanRef.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct FPoint;
 
// Forward decl
struct Rect;
 
// Forward decl
struct FRect;
 
struct Point : SDL_Point
{
  constexpr Point(const SDL_Point& p = {})
    : SDL_Point(p)
  {
  }
 
  constexpr Point(int x, int y)
    : SDL_Point{x, y}
  {
  }
 
  constexpr explicit Point(const SDL_FPoint& p)
    : SDL_Point{int(p.x), int(p.y)}
  {
  }
 
  constexpr bool operator==(const Point& other) const
  {
    return x == other.x && y == other.y;
  }
 
  constexpr bool operator==(const SDL_Point& p) const
  {
    return operator==(Point(p));
  }
  constexpr explicit operator bool() const { return x != 0 && y != 0; }
 
  constexpr int GetX() const { return x; }
 
  constexpr Point& SetX(int newX)
  {
    x = newX;
    return *this;
  }
 
  constexpr int GetY() const { return y; }
 
  constexpr Point& SetY(int newY)
  {
    y = newY;
    return *this;
  }
 
  constexpr bool IsInRect(const Rect& r) const;
 
  constexpr Point operator-() const { return Point(-x, -y); }
 
  constexpr Point operator+(const Point& other) const
  {
    return Point(x + other.x, y + other.y);
  }
 
  constexpr Point operator-(const Point& other) const
  {
    return Point(x - other.x, y - other.y);
  }
 
  constexpr Point operator/(int value) const
  {
    return Point(x / value, y / value);
  }
 
  constexpr FPoint operator/(float value) const;
 
  constexpr Point operator/(const Point& other) const
  {
    return Point(x / other.x, y / other.y);
  }
 
  constexpr Point operator%(int value) const
  {
    return Point(x % value, y % value);
  }
 
  constexpr Point operator%(const Point& other) const
  {
    return Point(x % other.x, y % other.y);
  }
 
  constexpr Point operator*(int value) const
  {
    return Point(x * value, y * value);
  }
 
  constexpr FPoint operator*(float value) const;
 
  constexpr Point operator*(const Point& other) const
  {
    return Point(x * other.x, y * other.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/=(int value)
  {
    x /= value;
    y /= value;
    return *this;
  }
 
  constexpr Point& operator/=(const Point& other)
  {
    x /= other.x;
    y /= other.y;
    return *this;
  }
 
  constexpr Point& operator%=(int value)
  {
    x %= value;
    y %= value;
    return *this;
  }
 
  constexpr Point& operator%=(const Point& other)
  {
    x %= other.x;
    y %= other.y;
    return *this;
  }
 
  constexpr Point& operator*=(int value)
  {
    x *= value;
    y *= value;
    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;
};
 
struct FPoint : SDL_FPoint
{
  constexpr FPoint(const SDL_FPoint& p = {})
    : SDL_FPoint(p)
  {
  }
 
  constexpr FPoint(float x, float y)
    : SDL_FPoint{x, y}
  {
  }
 
  constexpr bool operator==(const FPoint& other) const
  {
    return x == other.x && y == other.y;
  }
 
  constexpr bool operator==(const SDL_FPoint& p) const
  {
    return operator==(FPoint(p));
  }
 
  constexpr explicit operator bool() const { return x != 0 && y != 0; }
 
  constexpr float GetX() const { return x; }
 
  constexpr FPoint& SetX(float newX)
  {
    x = newX;
    return *this;
  }
 
  constexpr float GetY() const { return y; }
 
  constexpr FPoint& SetY(float newY)
  {
    y = newY;
    return *this;
  }
 
  constexpr bool IsInRect(const FRect& r) const;
 
  constexpr FPoint operator-() const { return FPoint(-x, -y); }
 
  constexpr FPoint operator+(const FPoint& other) const
  {
    return FPoint(x + other.x, y + other.y);
  }
 
  constexpr FPoint operator-(const FPoint& other) const
  {
    return FPoint(x - other.x, y - other.y);
  }
 
  constexpr FPoint operator/(float value) const
  {
    return FPoint(x / value, y / value);
  }
 
  constexpr FPoint operator/(const FPoint& other) const
  {
    return FPoint(x / other.x, y / other.y);
  }
 
  constexpr FPoint operator*(float value) const
  {
    return FPoint(x * value, y * value);
  }
 
  constexpr FPoint operator*(const FPoint& other) const
  {
    return FPoint(x * other.x, y * other.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/=(float value)
  {
    x /= value;
    y /= value;
    return *this;
  }
 
  constexpr FPoint& operator/=(const FPoint& other)
  {
    x /= other.x;
    y /= other.y;
    return *this;
  }
 
  constexpr FPoint& operator*=(float value)
  {
    x *= value;
    y *= value;
    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);
};
 
struct Rect : SDL_Rect
{
  constexpr Rect(const SDL_Rect& r = {})
    : SDL_Rect(r)
  {
  }
 
  constexpr Rect(int x, int y, int w, int h)
    : SDL_Rect({x, y, w, h})
  {
  }
 
  constexpr Rect(const SDL_Point& corner, const SDL_Point& size)
    : Rect{corner.x, corner.y, size.x, size.y}
  {
  }
 
  constexpr bool operator==(const Rect& other) const { return Equal(other); }
 
  constexpr bool operator==(const SDL_Rect& r) const
  {
    return operator==(Rect(r));
  }
 
  constexpr operator bool() const { return !Empty(); }
 
  constexpr int GetX() const { return x; }
 
  constexpr Rect& SetX(int newX)
  {
    x = newX;
    return *this;
  }
 
  constexpr int GetY() const { return y; }
 
  constexpr Rect& SetY(int newY)
  {
    y = newY;
    return *this;
  }
 
  constexpr int GetW() const { return w; }
 
  constexpr Rect& SetW(int newW)
  {
    w = newW;
    return *this;
  }
 
  constexpr int GetH() const { return h; }
 
  constexpr Rect& SetH(int newH)
  {
    h = newH;
    return *this;
  }
 
  static Rect GetEnclosingPoints(
    SpanRef<const SDL_Point> points,
    OptionalRef<const SDL_Rect> clip = std::nullopt)
  {
    Rect result;
    if (SDL_GetRectEnclosingPoints(
          points.data(), points.size(), clip, &result)) {
      return result;
    }
    return {};
  }
 
  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(const Point& center, const 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(const Point& p1, const 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 GetSize() const { return Point(w, h); }
 
  constexpr Point GetCentroid() const { return Point(x + w / 2, y + h / 2); }
 
  bool IntersectLine(int* X1, int* Y1, int* X2, int* Y2) const
  {
    return SDL_GetRectAndLineIntersection(this, X1, Y1, X2, Y2);
  }
 
  bool IntersectLine(Point* p1, Point* p2) const
  {
    return IntersectLine(p1 ? &p1->x : nullptr,
                         p1 ? &p1->y : nullptr,
                         p2 ? &p2->x : nullptr,
                         p2 ? &p2->y : nullptr);
  }
 
  constexpr operator FRect() const;
 
  constexpr operator SDL_FRect() const
  {
    return {float(x), float(y), float(w), float(h)};
  }
 
  constexpr bool Empty() const { return SDL_RectEmpty(this); }
 
  constexpr bool Equal(const Rect& other) const
  {
    return SDL_RectsEqual(this, &other);
  }
 
  constexpr bool Contains(const Point& p) const
  {
    return SDL_PointInRect(&p, this);
  }
 
  constexpr bool Contains(const Rect& other) const
  {
    return GetUnion(other) == *this;
  }
 
  bool HasIntersection(const Rect& other) const
  {
    return SDL_HasRectIntersection(this, &other);
  }
 
  constexpr std::optional<Rect> GetIntersection(const Rect& other) const
  {
    if (Rect result; SDL_GetRectIntersection(this, &other, &result)) {
      return result;
    }
    return std::nullopt;
  }
 
  constexpr Rect GetUnion(const Rect& other) const
  {
    Rect result;
    CheckError(SDL_GetRectUnion(this, &other, &result));
    return result;
  }
 
  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 : SDL_FRect
{
  constexpr FRect(const SDL_FRect& r = {})
    : SDL_FRect{r}
  {
  }
 
  constexpr FRect(float x, float y, float w, float h)
    : SDL_FRect{x, y, w, h}
  {
  }
 
  constexpr FRect(const SDL_FPoint& corner, const SDL_FPoint& size)
    : FRect{corner.x, corner.y, size.x, size.y}
  {
  }
 
  constexpr bool operator==(const FRect& other) const { return Equal(other); }
 
  constexpr bool operator==(const SDL_FRect& r) const
  {
    return operator==(FRect(r));
  }
 
  constexpr operator bool() const { return !Empty(); }
 
  constexpr float GetX() const { return x; }
 
  constexpr FRect& SetX(float newX)
  {
    x = newX;
    return *this;
  }
 
  constexpr float GetY() const { return y; }
 
  constexpr FRect& SetY(float newY)
  {
    y = newY;
    return *this;
  }
 
  constexpr float GetW() const { return w; }
 
  constexpr FRect& SetW(float newW)
  {
    w = newW;
    return *this;
  }
 
  constexpr float GetH() const { return h; }
 
  constexpr FRect& SetH(float newH)
  {
    h = newH;
    return *this;
  }
 
  static FRect GetEnclosingPoints(
    SpanRef<const SDL_FPoint> points,
    OptionalRef<const SDL_FRect> clip = std::nullopt)
  {
    if (FRect result; SDL_GetRectEnclosingPointsFloat(
          points.data(), points.size(), clip, &result)) {
      return result;
    }
    return {};
  }
 
  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(const FPoint& center, const 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(const FPoint& p1, const 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 GetSize() const { return FPoint(w, h); }
 
  constexpr FPoint GetCentroid() const { return FPoint(x + w / 2, y + h / 2); }
 
  bool IntersectLine(float* X1, float* Y1, float* X2, float* Y2) const
  {
    return SDL_GetRectAndLineIntersectionFloat(this, X1, Y1, X2, Y2);
  }
 
  bool IntersectLine(FPoint* p1, FPoint* p2) const
  {
    return IntersectLine(p1 ? &p1->x : nullptr,
                         p1 ? &p1->y : nullptr,
                         p2 ? &p2->x : nullptr,
                         p2 ? &p2->y : nullptr);
  }
 
  constexpr bool Empty() const { return SDL_RectEmptyFloat(this); }
 
  constexpr bool EqualEpsilon(const FRect& other, const float epsilon) const
  {
    return SDL_RectsEqualEpsilon(this, &other, epsilon);
  }
 
  constexpr bool Equal(const FRect& other) const
  {
    return SDL_RectsEqualFloat(this, &other);
  }
 
  constexpr bool Contains(const FPoint& p) const
  {
    return SDL_PointInRectFloat(&p, this);
  }
 
  constexpr bool Contains(const FRect& other) const
  {
    return GetUnion(other) == *this;
  }
 
  bool HasIntersection(const FRect& other) const
  {
    return SDL_HasRectIntersectionFloat(this, &other);
  }
 
  FRect GetIntersection(const FRect& other) const
  {
    if (FRect result; SDL_GetRectIntersectionFloat(this, &other, &result)) {
      return result;
    }
    return {};
  }
 
  FRect GetUnion(const FRect& other) const
  {
    FRect result;
    CheckError(SDL_GetRectUnionFloat(this, &other, &result));
    return result;
  }
 
  constexpr FRect GetExtension(unsigned int amount) const
  {
    FRect r = *this;
    r.Extend(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;
  }
};
 
constexpr bool Point::IsInRect(const Rect& r) const
{
  return r.Contains(*this);
}
 
constexpr bool FPoint::IsInRect(const FRect& r) const
{
  return r.Contains(*this);
}
 
#pragma region impl
 
constexpr Point::operator FPoint() const { return {float(x), float(y)}; }
 
constexpr FPoint Point::operator/(float value) const
{
  return FPoint(*this) / value;
}
constexpr FPoint Point::operator*(float value) const
{
  return FPoint(*this) * value;
}
 
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 - fmod(rect.x - x + rect.w - 1, rect.w);
  else if (x >= rect.x + rect.w)
    x = rect.x + fmod(x - rect.x - rect.w, rect.w);
 
  if (y < rect.y)
    y = rect.y + rect.h - 1 - fmod(rect.y - y + rect.h - 1, rect.h);
  else if (y >= rect.y + rect.h)
    y = rect.y + fmod(y - rect.y - rect.h, rect.h);
 
  return *this;
}
 
constexpr Rect::operator FRect() const
{
  return {float(x), float(y), float(w), float(h)};
}
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_RECT_H_ */