impeller::TPoint< T > Struct Template Reference

#include <point.h>

Public Types
using	Type = T

Public Member Functions
constexpr	TPoint ()=default
template<class U >
constexpr	TPoint (const TPoint< U > &other)
template<class U >
constexpr	TPoint (const TSize< U > &other)
constexpr	TPoint (Type x, Type y)
constexpr bool	operator== (const TPoint &p) const
constexpr bool	operator!= (const TPoint &p) const
template<class U >
TPoint	operator+= (const TPoint< U > &p)
template<class U >
TPoint	operator+= (const TSize< U > &s)
template<class U >
TPoint	operator-= (const TPoint< U > &p)
template<class U >
TPoint	operator-= (const TSize< U > &s)
template<class U >
TPoint	operator*= (const TPoint< U > &p)
template<class U >
TPoint	operator*= (const TSize< U > &s)
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
TPoint	operator*= (U scale)
template<class U >
TPoint	operator/= (const TPoint< U > &p)
template<class U >
TPoint	operator/= (const TSize< U > &s)
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
TPoint	operator/= (U scale)
constexpr TPoint	operator- () const
constexpr TPoint	operator+ (const TPoint &p) const
template<class U >
constexpr TPoint	operator+ (const TSize< U > &s) const
constexpr TPoint	operator- (const TPoint &p) const
template<class U >
constexpr TPoint	operator- (const TSize< U > &s) const
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TPoint	operator* (U scale) const
constexpr TPoint	operator* (const TPoint &p) const
template<class U >
constexpr TPoint	operator* (const TSize< U > &s) const
template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>
constexpr TPoint	operator/ (U d) const
constexpr TPoint	operator/ (const TPoint &p) const
template<class U >
constexpr TPoint	operator/ (const TSize< U > &s) const
constexpr Type	GetDistanceSquared (const TPoint &p) const
constexpr TPoint	Min (const TPoint &p) const
constexpr TPoint	Max (const TPoint &p) const
constexpr TPoint	Floor () const
constexpr TPoint	Ceil () const
constexpr TPoint	Round () const
constexpr Type	GetDistance (const TPoint &p) const
constexpr Type	GetLengthSquared () const
constexpr Type	GetLength () const
constexpr TPoint	Normalize () const
constexpr TPoint	Abs () const
constexpr Type	Cross (const TPoint &p) const
constexpr Type	Dot (const TPoint &p) const
constexpr TPoint	Reflect (const TPoint &axis) const
constexpr Radians	AngleTo (const TPoint &p) const
constexpr TPoint	Lerp (const TPoint &p, Scalar t) const
constexpr bool	IsZero () const
	IsFinite () const

Static Public Member Functions
static constexpr TPoint< Type >	MakeXY (Type x, Type y)
template<class U >
static constexpr TPoint	Round (const TPoint< U > &other)

Public Attributes
Type	x = {}
Type	y = {}

Detailed Description

template<class T>
struct impeller::TPoint< T >

Definition at line 27 of file point.h.

Member Typedef Documentation

Type

template<class T >

using impeller::TPoint< T >::Type = T

Definition at line 28 of file point.h.

Constructor & Destructor Documentation

TPoint() [1/4]

template<class T >

constexpr impeller::TPoint< T >::TPoint ( )

constexprdefault

TPoint() [2/4]

template<class T >

template<class U >

constexpr impeller::TPoint< T >::TPoint ( const TPoint< U > &  other )

inlineexplicitconstexpr

Definition at line 36 of file point.h.

      : TPoint(static_cast<Type>(other.x), static_cast<Type>(other.y)) {}

TPoint() [3/4]

template<class T >

template<class U >

constexpr impeller::TPoint< T >::TPoint ( const TSize< U > &  other )

inlineexplicitconstexpr

Definition at line 40 of file point.h.

      : TPoint(static_cast<Type>(other.width),
               static_cast<Type>(other.height)) {}

TPoint() [4/4]

template<class T >

constexpr impeller::TPoint< T >::TPoint ( Type  x, Type  y  )

inlineconstexpr

Definition at line 44 of file point.h.

: x(x), y(y) {}

Member Function Documentation

Abs()

template<class T >

constexpr TPoint impeller::TPoint< T >::Abs ( ) const

inlineconstexpr

Definition at line 216 of file point.h.

{ return {std::fabs(x), std::fabs(y)}; }

AngleTo()

template<class T >

constexpr Radians impeller::TPoint< T >::AngleTo ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 226 of file point.h.

                                                   {
    return Radians{std::atan2(this->Cross(p), this->Dot(p))};
  }

Ceil()

template<class T >

constexpr TPoint impeller::TPoint< T >::Ceil ( ) const

inlineconstexpr

Definition at line 196 of file point.h.

{ return {std::ceil(x), std::ceil(y)}; }

Cross()

template<class T >

constexpr Type impeller::TPoint< T >::Cross ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 218 of file point.h.

{ return (x * p.y) - (y * p.x); }

Dot()

template<class T >

constexpr Type impeller::TPoint< T >::Dot ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 220 of file point.h.

{ return (x * p.x) + (y * p.y); }

Floor()

template<class T >

constexpr TPoint impeller::TPoint< T >::Floor ( ) const

inlineconstexpr

Definition at line 194 of file point.h.

{ return {std::floor(x), std::floor(y)}; }

GetDistance()

template<class T >

constexpr Type impeller::TPoint< T >::GetDistance ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 200 of file point.h.

                                                    {
    return sqrt(GetDistanceSquared(p));
  }

GetDistanceSquared()

template<class T >

constexpr Type impeller::TPoint< T >::GetDistanceSquared ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 180 of file point.h.

                                                           {
    double dx = p.x - x;
    double dy = p.y - y;
    return dx * dx + dy * dy;
  }

GetLength()

template<class T >

constexpr Type impeller::TPoint< T >::GetLength ( ) const

inlineconstexpr

Definition at line 206 of file point.h.

{ return GetDistance({}); }

GetLengthSquared()

template<class T >

constexpr Type impeller::TPoint< T >::GetLengthSquared ( ) const

inlineconstexpr

Definition at line 204 of file point.h.

{ return GetDistanceSquared({}); }

IsFinite()

template<class T >

impeller::TPoint< T >::IsFinite ( ) const

inline

Definition at line 237 of file point.h.

{ return std::isfinite(x) && std::isfinite(y); }

IsZero()

template<class T >

constexpr bool impeller::TPoint< T >::IsZero ( ) const

inlineconstexpr

Definition at line 234 of file point.h.

{ return x == 0 && y == 0; }

Lerp()

template<class T >

constexpr TPoint impeller::TPoint< T >::Lerp ( const TPoint< T > &  p, Scalar  t  ) const

inlineconstexpr

Definition at line 230 of file point.h.

                                                         {
    return *this + (p - *this) * t;
  }

MakeXY()

template<class T >

static constexpr TPoint< Type > impeller::TPoint< T >::MakeXY ( Type  x, Type  y  )

inlinestaticconstexpr

Definition at line 46 of file point.h.

{ return {x, y}; }

Max()

template<class T >

constexpr TPoint impeller::TPoint< T >::Max ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 190 of file point.h.

                                              {
    return {std::max<Type>(x, p.x), std::max<Type>(y, p.y)};
  }

Min()

template<class T >

constexpr TPoint impeller::TPoint< T >::Min ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 186 of file point.h.

                                              {
    return {std::min<Type>(x, p.x), std::min<Type>(y, p.y)};
  }

Normalize()

template<class T >

constexpr TPoint impeller::TPoint< T >::Normalize ( ) const

inlineconstexpr

Definition at line 208 of file point.h.

                                     {
    const auto length = GetLength();
    if (length == 0) {
      return {1, 0};
    }
    return {x / length, y / length};
  }

operator!=()

template<class T >

constexpr bool impeller::TPoint< T >::operator!= ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 58 of file point.h.

                                                   {
    return p.x != x || p.y != y;
  }

operator*() [1/3]

template<class T >

constexpr TPoint impeller::TPoint< T >::operator* ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 157 of file point.h.

                                                    {
    return {x * p.x, y * p.y};
  }

operator*() [2/3]

template<class T >

template<class U >

constexpr TPoint impeller::TPoint< T >::operator* ( const TSize< U > &  s ) const

inlineconstexpr

Definition at line 162 of file point.h.

                                                      {
    return {x * static_cast<Type>(s.width), y * static_cast<Type>(s.height)};
  }

operator*() [3/3]

template<class T >

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

constexpr TPoint impeller::TPoint< T >::operator* ( U  scale ) const

inlineconstexpr

Definition at line 153 of file point.h.

                                            {
    return {static_cast<Type>(x * scale), static_cast<Type>(y * scale)};
  }

operator*=() [1/3]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator*= ( const TPoint< U > &  p )

inline

Definition at line 91 of file point.h.

                                               {
    x *= static_cast<Type>(p.x);
    y *= static_cast<Type>(p.y);
    return *this;
  }

operator*=() [2/3]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator*= ( const TSize< U > &  s )

inline

Definition at line 98 of file point.h.

                                              {
    x *= static_cast<Type>(s.width);
    y *= static_cast<Type>(s.height);
    return *this;
  }

operator*=() [3/3]

template<class T >

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

TPoint impeller::TPoint< T >::operator*= ( U  scale )

inline

Definition at line 105 of file point.h.

                                    {
    x *= static_cast<Type>(scale);
    y *= static_cast<Type>(scale);
    return *this;
  }

operator+() [1/2]

template<class T >

constexpr TPoint impeller::TPoint< T >::operator+ ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 134 of file point.h.

                                                    {
    return {x + p.x, y + p.y};
  }

operator+() [2/2]

template<class T >

template<class U >

constexpr TPoint impeller::TPoint< T >::operator+ ( const TSize< U > &  s ) const

inlineconstexpr

Definition at line 139 of file point.h.

                                                      {
    return {x + static_cast<Type>(s.width), y + static_cast<Type>(s.height)};
  }

operator+=() [1/2]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator+= ( const TPoint< U > &  p )

inline

Definition at line 63 of file point.h.

                                               {
    x += static_cast<Type>(p.x);
    y += static_cast<Type>(p.y);
    return *this;
  }

operator+=() [2/2]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator+= ( const TSize< U > &  s )

inline

Definition at line 70 of file point.h.

                                              {
    x += static_cast<Type>(s.width);
    y += static_cast<Type>(s.height);
    return *this;
  }

operator-() [1/3]

template<class T >

constexpr TPoint impeller::TPoint< T >::operator- ( ) const

inlineconstexpr

Definition at line 132 of file point.h.

{ return {-x, -y}; }

operator-() [2/3]

template<class T >

constexpr TPoint impeller::TPoint< T >::operator- ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 143 of file point.h.

                                                    {
    return {x - p.x, y - p.y};
  }

operator-() [3/3]

template<class T >

template<class U >

constexpr TPoint impeller::TPoint< T >::operator- ( const TSize< U > &  s ) const

inlineconstexpr

Definition at line 148 of file point.h.

                                                      {
    return {x - static_cast<Type>(s.width), y - static_cast<Type>(s.height)};
  }

operator-=() [1/2]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator-= ( const TPoint< U > &  p )

inline

Definition at line 77 of file point.h.

                                               {
    x -= static_cast<Type>(p.x);
    y -= static_cast<Type>(p.y);
    return *this;
  }

operator-=() [2/2]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator-= ( const TSize< U > &  s )

inline

Definition at line 84 of file point.h.

                                              {
    x -= static_cast<Type>(s.width);
    y -= static_cast<Type>(s.height);
    return *this;
  }

operator/() [1/3]

template<class T >

constexpr TPoint impeller::TPoint< T >::operator/ ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 171 of file point.h.

                                                    {
    return {x / p.x, y / p.y};
  }

operator/() [2/3]

template<class T >

template<class U >

constexpr TPoint impeller::TPoint< T >::operator/ ( const TSize< U > &  s ) const

inlineconstexpr

Definition at line 176 of file point.h.

                                                      {
    return {x / static_cast<Type>(s.width), y / static_cast<Type>(s.height)};
  }

operator/() [3/3]

template<class T >

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

constexpr TPoint impeller::TPoint< T >::operator/ ( U  d ) const

inlineconstexpr

Definition at line 167 of file point.h.

                                        {
    return {static_cast<Type>(x / d), static_cast<Type>(y / d)};
  }

operator/=() [1/3]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator/= ( const TPoint< U > &  p )

inline

Definition at line 112 of file point.h.

                                               {
    x /= static_cast<Type>(p.x);
    y /= static_cast<Type>(p.y);
    return *this;
  }

operator/=() [2/3]

template<class T >

template<class U >

TPoint impeller::TPoint< T >::operator/= ( const TSize< U > &  s )

inline

Definition at line 119 of file point.h.

                                              {
    x /= static_cast<Type>(s.width);
    y /= static_cast<Type>(s.height);
    return *this;
  }

operator/=() [3/3]

template<class T >

template<class U , class = std::enable_if_t<std::is_arithmetic_v<U>>>

TPoint impeller::TPoint< T >::operator/= ( U  scale )

inline

Definition at line 126 of file point.h.

                                    {
    x /= static_cast<Type>(scale);
    y /= static_cast<Type>(scale);
    return *this;
  }

operator==()

template<class T >

constexpr bool impeller::TPoint< T >::operator== ( const TPoint< T > &  p ) const

inlineconstexpr

Definition at line 54 of file point.h.

                                                   {
    return p.x == x && p.y == y;
  }

Reflect()

template<class T >

constexpr TPoint impeller::TPoint< T >::Reflect ( const TPoint< T > &  axis ) const

inlineconstexpr

Definition at line 222 of file point.h.

                                                     {
    return *this - axis * this->Dot(axis) * 2;
  }

Round() [1/2]

template<class T >

constexpr TPoint impeller::TPoint< T >::Round ( ) const

inlineconstexpr

Definition at line 198 of file point.h.

{ return {std::round(x), std::round(y)}; }

Round() [2/2]

template<class T >

template<class U >

static constexpr TPoint impeller::TPoint< T >::Round ( const TPoint< U > &  other )

inlinestaticconstexpr

Definition at line 49 of file point.h.

                                                        {
    return TPoint{static_cast<Type>(std::round(other.x)),
                  static_cast<Type>(std::round(other.y))};
  }

Member Data Documentation

x

template<class T >

Type impeller::TPoint< T >::x = {}

Definition at line 30 of file point.h.

{};

y

template<class T >

Type impeller::TPoint< T >::y = {}

Definition at line 31 of file point.h.

{};

---

The documentation for this struct was generated from the following file:

• impeller/geometry/point.h