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=(const TVector3D& v) noexcept;

    TVector3D& operator=(TVector3D&& v) noexcept;

    TVector3D& operator^=(const TMatrix44<T>& mtx);

    TVector3D& operator*=(const TMatrix44<T>& mtx);

    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 isEqual(const TVector3D& v, const TVector3D& tol) 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(int digits = 0) const;

    TVector3D& fromString(const std::string& s, bool ignore_err = false) 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);

template<typename T>
TVector3D<T> operator*(const TVector3D<T>& v, T c);

template<typename T>
TVector3D<T> operator/(T c, const TVector3D<T>& v);

template<typename T>
TVector3D<T> operator/(const TVector3D<T>& num, const TVector3D<T>& den);

template<typename T>
TVector3D<T> operator/(const TVector3D<T>& v, T c);

template<typename T>
std::istream& operator>>(std::istream& is, TVector3D<T>& v) noexcept(false);

template<typename T>
std::ostream& operator<<(std::ostream& os, const TVector3D<T>& v)
{
  return os << v.toString();
}
 
}// namespace sf
 
#ifndef __JETBRAINS_IDE__
  // Include all inlined functions and template implementations.
  #include <math/TVector3D.hpp>
#endif