DtVector2.h

Go to the documentation of this file.

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

#pragma once

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

#include <list>
#include <vector>

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() {}

      const void* ptr(void) const {return &x;}

      T operator[](size_t index) const;

      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+(T fScalar) const;
      DtVector2 operator-(T fScalar) const;
      DtVector2 operator*(T fScalar) const;
      DtVector2 operator/(T fScalar) const;

      DtVector2 operator/(const DtVector2& rhs) const;

      DtVector2 getNormalizedCopy(void) const;

      T getDotProduct(const DtVector2& rhs) const;

      T x, y;

      static DtVector2 ZERO_VECTOR;
      static DtVector2 UNIT_SCALE;

      static size_t sizeInBytes(void);
   };

   template <class T>
   DtVector2<T> DtVector2<T>::ZERO_VECTOR = DtVector2<T>(0,0);
   template <class T>
   DtVector2<T> DtVector2<T>::UNIT_SCALE = 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+(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>
   DtVector2<T> DtVector2<T>::getNormalizedCopy(void) const
   {
      T vecLength = length();
      if (vecLength<std::numeric_limits<T>::epsilon())
         return DtVector2::ZERO_VECTOR;

      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_RETURN_DEFAULT_CONSTRUCTOR(DtVector2<T>, index<=1);
      const T* ptrT = static_cast<const T*>(ptr());
      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);
   }

} //namespace makVrv