TVector2D.h

Go to the documentation of this file.

// ReSharper disable file CppNonExplicitConversionOperator
#pragma once
 
#include <limits>
#include <string>
 
namespace sf
{
 
// Forward declaration.
template<typename T>
class TMatrix22;
 
// Forward declaration.
template<typename T>
class TRectangle2D;
 
template<typename T>
class TVector2D
{
  public:
    typedef T value_type;
 
    TVector2D() = default;
 
    TVector2D(const TVector2D& v);
 
    TVector2D(TVector2D&&) noexcept;
 
    TVector2D(T xp, T yp);
 
    TVector2D& assign(T xp, T yp);
 
    TVector2D& assign(const TVector2D& v);
 
    TVector2D& operator=(const TVector2D& v) noexcept;
 
    TVector2D& operator=(TVector2D&& v) noexcept;
 
    TVector2D& operator*=(const TMatrix22<T>& mtx);
 
    TVector2D operator-() const;
 
    TVector2D& operator+=(const TVector2D&);
 
    TVector2D& operator-=(const TVector2D&);
 
    TVector2D& operator*=(T c);
 
    TVector2D& operator/=(T);
 
    TVector2D operator+(const TVector2D&) const;
 
    TVector2D operator-(const TVector2D&) const;
 
    TVector2D operator/(T) const;
 
    bool isEqual(const TVector2D& v, T tol = tolerance) const;
 
    bool operator==(const TVector2D&) const;
 
    bool operator!=(const TVector2D&) const;
 
    T& operator[](size_t);
 
    const T& operator[](size_t) const;
 
    constexpr T* data();
 
    constexpr const T* data() const;
 
    constexpr operator T*();
 
    constexpr operator const T*() const;
 
    constexpr T x() const;
 
    constexpr T& x();
 
    constexpr T y() const;
 
    constexpr T& y();
 
    T length() const;
 
    T lengthSqr() const;
 
    TVector2D& normalize();
 
    TVector2D normalized() const;
 
    TVector2D& scale(T factor);
 
    TVector2D scaled(T factor) const;
 
    T crossProduct(const TVector2D&) const;
 
    T dotProduct(const TVector2D&) const;
 
    T operator*(const TVector2D& v) const;
 
    T angle(const TVector2D&) const;
 
    T angle() const;
 
    T angleNormalized() const;
 
    T slope() const;
 
    T distance(const TVector2D&) const;
 
    T distanceSqr(const TVector2D&) const;
 
    void updateMin(const TVector2D& vertex);
 
    void updateMax(const TVector2D& vertex);
 
    std::string toString() const;
 
    TVector2D& fromString(const std::string& s) noexcept(false);
 
    static constexpr auto tolerance = std::numeric_limits<T>::epsilon() * 10.0;
 
    static int areOnSameSide(const TVector2D& lp1, const TVector2D& lp2, const TVector2D& p1, const TVector2D& p2);
 
  protected:
    union data_type
    {
        T array[2];
        struct point_type
        {
            T x;
            T y;
        } coord;
    } _data{0, 0};
 
    friend class TRectangle2D<T>;
};
 
template<typename T>
TVector2D<T> operator*(T c, const TVector2D<T>& v)
{
  return {v.x() * c, v.y() * c};
}
 
template<typename T>
TVector2D<T> operator*(const TVector2D<T>& v, T c)
{
  return {v.x() * c, v.y() * c};
}
 
template<typename T>
std::istream& operator>>(std::istream& is, TVector2D<T>& v) noexcept(false)
{
  std::string s;
  constexpr auto delimiter = ')';
  std::getline(is, s, delimiter);
  v.fromString(s.append(1, delimiter));
  return is;
}
 
template<typename T>
std::ostream& operator<<(std::ostream& os, const TVector2D<T>& v)
{
  return os << v.toString();
}
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <math/TVector2D.hpp>