point_3d_h.hpp

#pragma once

#include <cmath>

#include "global.hpp"

#include "angle.hpp"
#include "point_3d.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS

#pragma pack ( push, 4 )


template< class T, class ENABLE = void>
class Point3DH final
{

#ifndef CVB_DOXYGEN
  static_assert (std::is_arithmetic<T>::value, "CVB: Unsupported data type - must be arithmetic!");
};


template <class T>
class Point3DH<T,
  typename EnableIfArithmetic<T>::type> final
{

#endif

  public:

    using ValueType = T;


    Point3DH() noexcept = default;



    Point3DH(T x, T y, T z) noexcept
      : x_(x)
      , y_(y)
      , z_(z)
    {
    }


    Point3DH(T x, T y, T z, T w) noexcept
      : x_(x)
      , y_(y)
      , z_(z)
      , w_(w)
    {
    }



    Point3DH(Point3D<T> point3d) noexcept
      : Point3DH(point3d.X(), point3d.Y(), point3d.Z())
    {
    }


    template<std::size_t N>
    Point3DH(const T(&list)[N]) noexcept
    {
      static_assert(N == 4, "CVB: Point3DH must have 4 elements");
      std::copy(std::begin(list), std::end(list), &x_);
    }




    T X() const noexcept
    {
      return x_;
    }


    void SetX(T x) noexcept
    {
      x_ = x;
    }


    T Y() const noexcept
    {
      return y_;
    }


    void SetY(T y)
    {
      y_ = y;
    }


    T Z() const noexcept
    {
      return z_;
    }


    void SetZ(T z)
    {
      z_ = z;
    }


    T W() const noexcept
    {
      return w_;
    }


    void SetW(T w)
    {
      w_ = w;
    }



    void Normalize() noexcept
    {
      x_ /= w_;
      y_ /= w_;
      z_ /= w_;
      w_ = 1.0;
    }



    bool operator==(const Point3DH<T>& other) const noexcept
    {
      return (x_ == other.x_ && y_ == other.y_ && z_ == other.z_ && w_ == other.w_);
    }



    bool operator!=(const Point3DH<T>& other) const noexcept
    {
      return !(*this == other);
    }

    template <class C>
    explicit operator Point3DH<C>() const noexcept
    {
      static_assert(std::is_floating_point<C>::value, "CVB: Unsupported data type - must be floating point!");
      return Point3DH<C>(static_cast<C>(X()), static_cast<C>(Y()), static_cast<C>(Z()), static_cast<C>(W()));
    }


    Point3DH<T>& operator +=(const Point3DH<T> & point) noexcept
    {
      x_ += point.x_;
      y_ += point.y_;
      z_ += point.z_;
      w_ += point.w_;
      return *this;
    }


    Point3DH<T>& operator -=(const Point3DH<T> & point) noexcept
    {
      x_ -= point.x_;
      y_ -= point.y_;
      z_ -= point.z_;
      w_ -= point.w_;
      return *this;
    }


    Point3DH<T>& operator *=(const T & value) noexcept
    {
      x_ *= value;
      y_ *= value;
      z_ *= value;
      w_ *= value;
      return *this;
    }


    Point3DH<T>& operator /=(const T & value) noexcept
    {
      x_ /= value;
      y_ /= value;
      z_ /= value;
      w_ /= value;
      return *this;
    }



    const T& operator[](int index) const noexcept
    {
      assert(index < 4 && index >= 0);
      return *(&x_ + index);
    }


    T& operator[](int index) noexcept
    {
      assert(index < 4 && index >= 0);
      return *(&x_ + index);
    }

  private:

    T x_ = static_cast<T>(0.0);
    T y_ = static_cast<T>(0.0);
    T z_ = static_cast<T>(0.0);
    T w_ = static_cast<T>(1.0);


};


template <class T>
inline Point3DH<T> operator+(const Point3DH<T> & lhs, const Point3DH<T> & rhs)
{
  return Point3DH<T>(lhs.X() + rhs.X(), lhs.Y() + rhs.Y(), lhs.Z() + rhs.Z(), lhs.W() + rhs.W());
}


template <class T>
inline Point3DH<T> operator-(const Point3DH<T> & lhs, const Point3DH<T> & rhs)
{
  return Point3DH<T>(lhs.X() - rhs.X(), lhs.Y() - rhs.Y(), lhs.Z() - rhs.Z(), lhs.W() - rhs.W());
}


template <class T>
inline T operator*(const Point3DH<T> & lhs, const Point3DH<T> & rhs)
{
  return lhs.X() * rhs.X() + lhs.Y() * rhs.Y() + lhs.Z() * rhs.Z() + lhs.W() * rhs.W();
}


template <class T>
inline Point3DH<T> operator*(const Point3DH<T> & lhs, const T & rhs)
{
  return Point3DH<T>(lhs.X() * rhs, lhs.Y() * rhs, lhs.Z() * rhs, lhs.W() * rhs);
}


template <class T>
inline Point3DH<T> operator*(const T & lhs, const Point3DH<T> & rhs)
{
  return rhs * lhs;
}


template <class T>
inline Point3DH<T> operator/(const Point3DH<T> & lhs, const T & rhs)
{
  return Point3DH<T>(lhs.X() / rhs, lhs.Y() / rhs, lhs.Z() / rhs, lhs.W() / rhs);
}


template<class T>
using Vector3DH = Point3DH<T>;

#pragma pack ( pop )


CVB_END_INLINE_NS


}