Rect.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Math/Vec2.h>
 
template <typename Type>
class plRectTemplate
{
public:
  // Means this object can be copied using memcpy instead of copy construction.
  PL_DECLARE_POD_TYPE();
 
  // *** Data ***
public:
  Type x;
  Type y;
 
  Type width;
  Type height;
 
  // *** Constructors ***
public:
  plRectTemplate();
 
  plRectTemplate(Type x, Type y, Type width, Type height);
 
  plRectTemplate(Type width, Type height);
 
  plRectTemplate<Type>(const plVec2Template<Type>& vTopLeftPosition, const plVec2Template<Type>& vSize);
 
  [[nodiscard]] static plRectTemplate<Type> MakeInvalid();
 
  [[nodiscard]] static plRectTemplate<Type> MakeIntersection(const plRectTemplate<Type>& r0, const plRectTemplate<Type>& r1);
 
  [[nodiscard]] static plRectTemplate<Type> MakeUnion(const plRectTemplate<Type>& r0, const plRectTemplate<Type>& r1);
 
  Type Left() const { return x; }
 
  Type Right() const { return x + width; }
 
  Type Top() const { return y; }
 
  Type Bottom() const { return y + height; }
 
  Type GetX1() const { return x; }
 
  Type GetX2() const { return x + width; }
 
  Type GetY1() const { return y; }
 
  Type GetY2() const { return y + height; }
 
  plVec2Template<Type> GetMinCorner() const { return plVec2Template<Type>(x, y); }
 
  plVec2Template<Type> GetMaxCorner() const { return plVec2Template<Type>(x + width, y + height); }
 
  plVec2Template<Type> GetTopLeft() const { return plVec2Template<Type>(x, y); }
 
  plVec2Template<Type> GetTopRight() const { return plVec2Template<Type>(x + width, y); }
 
  plVec2Template<Type> GetBottomLeft() const { return plVec2Template<Type>(x, y + height); }
 
  plVec2Template<Type> GetBottomRight() const { return plVec2Template<Type>(x + width, y + height); }
 
  plVec2Template<Type> GetCenter() const { return plVec2Template<Type>(x + width / 2, y + height / 2); }
 
  plVec2Template<Type> GetExtents() const { return plVec2Template<Type>(width, height); }
 
  plVec2Template<Type> GetHalfExtents() const { return plVec2Template<Type>(width / 2, height / 2); }
 
  void Grow(Type xy);
 
  // *** Common Functions ***
public:
  [[nodiscard]] bool operator==(const plRectTemplate<Type>& rhs) const;
  [[nodiscard]] bool operator!=(const plRectTemplate<Type>& rhs) const;
 
  [[nodiscard]] bool IsValid() const;
 
  [[nodiscard]] bool HasNonZeroArea() const;
 
  [[nodiscard]] bool Contains(const plVec2Template<Type>& vPoint) const;
 
  [[nodiscard]] bool Contains(const plRectTemplate<Type>& r) const;
 
  [[nodiscard]] bool Overlaps(const plRectTemplate<Type>& other) const;
 
  void ExpandToInclude(const plRectTemplate<Type>& other);
 
  void ExpandToInclude(const plVec2Template<Type>& other);
 
  void Clip(const plRectTemplate<Type>& clipRect);
 
  [[nodiscard]] const plVec2Template<Type> GetClampedPoint(const plVec2Template<Type>& vPoint) const;
 
  [[nodiscard]] const plRectTemplate<Type> GetClampedRect(const plRectTemplate<Type>& r) const
  {
    const plVec2Template<Type> vNewMin = GetClampedPoint(r.GetMinCorner());
    const plVec2Template<Type> vNewMax = GetClampedPoint(r.GetMaxCorner());
    return plRectTemplate<Type>(vNewMin, vNewMax - vNewMin);
  }
 
  void SetCenter(Type tX, Type tY);
 
  void Translate(Type tX, Type tY);
 
  void Scale(Type sX, Type sY);
};
 
#include <Foundation/Math/Implementation/Rect_inl.h>
 
using plRectU32 = plRectTemplate<plUInt32>;
using plRectU16 = plRectTemplate<plUInt16>;
using plRectI32 = plRectTemplate<plInt32>;
using plRectI16 = plRectTemplate<plInt16>;
using plRectFloat = plRectTemplate<float>;
using plRectDouble = plRectTemplate<double>;