TVector3D.h

Go to the documentation of this file.

#pragma once
#include <limits>
#include <string>
 
namespace sf
{
 
// Forward declaration.
template<typename T>
class TMatrix44;
 
template<typename T>
class TVector3D
{
  public:
    typedef T value_type;
 
    TVector3D() = default;
 
    TVector3D(const TVector3D& v);
 
    TVector3D(TVector3D&&) noexcept;
 
    TVector3D(T xp, T yp, T zp);
 
    TVector3D& assign(T xp, T yp, T zp);
 
    TVector3D& assign(const TVector3D& v);
 
    TVector3D& operator=(TVector3D& v) noexcept;
 
    TVector3D& operator=(TVector3D&& v) noexcept;
 
    TVector3D& operator*=(const TMatrix44<T>& mtx);
 
    TVector3D operator*(const TMatrix44<T>& mtx);
 
    TVector3D operator-() const;
 
    TVector3D& operator+=(const TVector3D&);
 
    TVector3D& operator-=(const TVector3D&);
 
    TVector3D& operator*=(T c);
 
    TVector3D& operator/=(T);
 
    TVector3D operator+(const TVector3D&) const;
 
    TVector3D operator-(const TVector3D&) const;
 
    TVector3D operator/(T c) const;
 
    bool isEqual(const TVector3D& v, T tol = tolerance) const;
 
    bool operator==(const TVector3D&) const;
 
    bool operator!=(const TVector3D&) const;
 
    T& operator[](size_t);
 
    const T& operator[](size_t) const;
 
    constexpr T* data();
 
    constexpr const T* data() const;
 
    // ReSharper disable once CppNonExplicitConversionOperator
    constexpr operator T*();
 
    // ReSharper disable once CppNonExplicitConversionOperator
    constexpr operator const T*() const;
 
    constexpr T x() const;
 
    constexpr T& x();
 
    constexpr T y() const;
 
    constexpr T& y();
 
    constexpr T z() const;
 
    constexpr T& z();
 
    T length() const;
 
    T length2D() const;
 
    T lengthSqr() const;
 
    T lengthSqr2D() const;
 
    TVector3D& normalize();
 
    TVector3D normalized() const;
 
    TVector3D& scale(T factor);
 
    TVector3D scaled(T factor) const;
 
    TVector3D crossProduct(const TVector3D&) const;
 
    T dotProduct(const TVector3D&) const;
 
    T dotProduct2D(const TVector3D&) const;
 
    TVector3D operator*(const TVector3D& v) const;
 
    T angle(const TVector3D&) const;
 
    T angleNormalized() const;
 
    T distance(const TVector3D&) const;
 
    T distance2D(const TVector3D&) const;
 
    T distanceSqr(const TVector3D&) const;
 
    T distanceSqr2D(const TVector3D&) const;
 
    void updateMin(const TVector3D& vertex);
 
    void updateMax(const TVector3D& vertex);
 
    std::string toString() const;
 
    TVector3D& fromString(const std::string& s) noexcept(false);
 
    int dominantAxis();
 
    static constexpr auto tolerance = std::numeric_limits<T>::epsilon() * T(15.0);
 
    void copyTo(T fa[3]) const;
 
    template<typename F = T, size_t N = 3>
    std::array<F, N> array(F value = 1) const;
 
    template<typename F = float, size_t N = 4>
    const F* floatPtr(F value = 1) const;
 
  protected:
    union data_type
    {
        value_type array[3];
        struct point_type
        {
            value_type x;
            value_type y;
            value_type z;
        } coord;
    } _data{0, 0, 0};
};
 
template<typename T>
TVector3D<T> operator*(T c, const TVector3D<T>& v)
{
  return {v.x() * c, v.y() * c, v.z() * c};
}
 
template<typename T>
TVector3D<T> operator*(const TVector3D<T>& v, T c)
{
  return {v.x() * c, v.y() * c, v.z() * c};
}
 
template<typename T>
std::istream& operator>>(std::istream& is, TVector3D<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 TVector3D<T>& v)
{
  return os << v.toString();
}
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <math/TVector3D.hpp>