DtVector2.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2021 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 

#pragma once

#include <vrvGraphicsUtils/DtCommonTypes.h>
#include <vrvGraphicsUtils/DtAssert.h>
#include <vrvGraphicsUtils/DtMath.h>

#include <list>
#include <vector>
#include <iostream>

namespace makVrv
{

   template <class T>
   class DtVector2
   {
   public:
      DtVector2() : x(0), y(0) {}
      DtVector2(T _x, T _y) : x(_x), y (_y) {}

      template <class T1>
      DtVector2(const T1& v) : x(v.x), y(v.y) {}

      ~DtVector2() 
      {
         //intentional nop
      }
   public:
      const void* ptr(void) const 
      {
         return &x;
      }

      T operator[](size_t index) const;

      T& operator[](size_t index);

      T length(void) const;
      T squaredLength(void) const;

      bool isEqual(const DtVector2& rhs, T tolerance) const;

      DtVector2 operator+(const DtVector2& rhs) const;
      DtVector2 operator-(const DtVector2& rhs) const;

      DtVector2& operator+=(const DtVector2& rhs);
      DtVector2& operator-=(const DtVector2& rhs);

      DtVector2 operator+(T fScalar) const;
      DtVector2 operator-(T fScalar) const;
      DtVector2 operator*(T fScalar) const;
      DtVector2 operator/(T fScalar) const;

      DtVector2 operator/(const DtVector2& rhs) const;

      void     normalize(void);

      DtVector2 getNormalizedCopy(void) const;

      T getDotProduct(const DtVector2& rhs) const;

      bool operator==(const DtVector2& rhs) const;

      bool operator!=(const DtVector2& rhs) const;

   public: 
      //Size of this class in bytes
      static size_t sizeInBytes(void);
   public:
      T x, y;

   public:
      static const DtVector2 theZeroVector;
      static const DtVector2 theUnitScale;
   };

   template <class T>
   const DtVector2<T> DtVector2<T>::theZeroVector = DtVector2<T>(0,0);
   template <class T>
   const DtVector2<T> DtVector2<T>::theUnitScale = DtVector2<T>(1,1);

   template <class T>
   DtVector2<T> DtVector2<T>::operator+(const DtVector2<T>& rhs) const
   {
      return DtVector2<T>(x+rhs.x, y+rhs.y);
   }

   template <class T>
   DtVector2<T> DtVector2<T>::operator-(const DtVector2<T>& rhs) const
   {
      return DtVector2<T>(x-rhs.x, y-rhs.y);
   }

   template <class T>
   DtVector2<T>& DtVector2<T>::operator+=(const DtVector2<T>& rhs)
   {
      x += rhs.x;
      y += rhs.y;
      return *this;
   }

   template <class T>
   DtVector2<T>& DtVector2<T>::operator-=(const DtVector2<T>& rhs)
   {
      x -= rhs.x;
      y -= rhs.y;
      return *this;
   }

   template <class T>
   DtVector2<T> DtVector2<T>::operator+(T fScalar) const
   {
      return DtVector2<T>(x+fScalar, y+fScalar);
   }

   template <class T>
   DtVector2<T> DtVector2<T>::operator-(T fScalar) const
   {
      return DtVector2<T>(x-fScalar, y-fScalar);
   }

   template <class T>
   DtVector2<T> DtVector2<T>::operator*(T fScalar) const
   {
      return DtVector2<T>(x*fScalar, y*fScalar);
   }

   template <class T>
   DtVector2<T> DtVector2<T>::operator/(T fScalar) const
   {
      T OneByfScalar = T(1.0)/fScalar;
      return DtVector2<T>(x*OneByfScalar, y*OneByfScalar);
   }

   template <class T>
   DtVector2<T> DtVector2<T>::operator/(const DtVector2<T>& rhs) const
   {
      return DtVector2<T>(x/rhs.x, y/rhs.y);
   }

   template <class T>
   bool DtVector2<T>::isEqual(const DtVector2<T>& rhs, T tolerance) const
   {
      return DtMath::isEqual(this->x, rhs.x,tolerance)
         && DtMath::isEqual(this->y, rhs.y,tolerance)
         ;
   }


   template <class T>
   T DtVector2<T>::getDotProduct(const DtVector2<T>& rhs) const
   {
      return x*rhs.x + y*rhs.y;
   }

   template <class T>
   void DtVector2<T>::normalize(void)
   {
      T fLength = DtMath::Sqrt(x * x + y * y);
      if (fLength > 0)
      {
         T fInvLength = 1.0f / fLength;
         x *= fInvLength;
         y *= fInvLength;
      }
   }

   template <class T>
   DtVector2<T> DtVector2<T>::getNormalizedCopy(void) const
   {
      T vecLength = length();
      if (vecLength<std::numeric_limits<T>::epsilon())
         return DtVector2::theZeroVector;

      T one_by_length = T(1.0)/vecLength;
      return (DtVector2<T>(x,y)*one_by_length);
   }

   template <class T>
   T DtVector2<T>::operator[](size_t index) const
   {
      ASSERT_PREDICATE(index <= 1);
      const T* ptrT = static_cast<const T*>(ptr());
      return ptrT[index];
   }

   template <class T>
   T& DtVector2<T>::operator[](size_t index)
   {
      ASSERT_PREDICATE(index <= 1);
      T* ptrT = &x;
      return ptrT[index];
   }

   template <class T>
   T DtVector2<T>::length(void) const
   {
      return DtMath::Sqrt(x*x+y*y);
   }

   template <class T>
   T DtVector2<T>::squaredLength(void) const
   {
      return x*x+y*y;
   }

   template <class T>
   size_t DtVector2<T>::sizeInBytes(void)
   {
      return 2*sizeof(T);
   }

   template <class T>
   bool DtVector2<T>::operator==(const DtVector2<T>& rhs) const
   {
      return x == rhs.x&&y == rhs.y;
   }

   template <class T>
   bool DtVector2<T>::operator!=(const DtVector2<T>& rhs) const
   {
      const DtVector2<T>& lhs = *this;
      return !(lhs == rhs);
   }

   template<class T>
   inline std::ostream& operator <<(std::ostream& o, const DtVector2<T>& v)
   {
      o << "Vector2(" << v.x << ", " << v.y << ")";
      return o;
   }

   // 32 bit
   typedef DtVector2<float32> Vector2_32;
   typedef std::list<Vector2_32> Vector2_32_List;
   typedef std::vector<Vector2_32> Vector2_32_Vector;

   typedef DtVector2<int32> Vector2_int;
   typedef DtVector2<uint32> Vector2_uint32;

   // 64 bit
   typedef DtVector2<float64> Vector2_64;
   typedef std::list<Vector2_64> Vector2_64_List;
   typedef std::vector<Vector2_64> Vector2_64_Vector;

} //namespace makVrv