DtVector3.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>
#include <limits>
#include <iostream>

namespace makVrv
{

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

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

      ~DtVector3() {}

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

      DtVector3 operator-(void) const {return DtVector3(-x,-y,-z);}

      bool isEqual(const DtVector3& rhs, T tolerance=std::numeric_limits<T>::min()) const;

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

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

      DtVector3& operator+=(T fScalar);
      DtVector3& operator-=(T fScalar);
      DtVector3& operator*=(T fScalar);
      DtVector3& operator/=(T fScalar);

      bool operator>(const DtVector3& rhs) const;
      bool operator<(const DtVector3& rhs) const;

      void              normalize(void);
      T                 length(void) const;
      T                 squaredLength(void) const;
      T                 getDistance(const DtVector3& rhs) const;

      DtVector3 crossProduct(const DtVector3& rhs) const;
      T         dotProduct(const DtVector3& rhs) const;
      T         absDotProduct(const DtVector3& rhs) const;

      DtVector3 midPoint(const DtVector3& rhs) const;

      void makeCeil(const DtVector3& rhs);

      void makeFloor(const DtVector3& rhs);

      T operator[](size_t index) const;
      T& operator[](size_t index);

      T x, y, z;

      static DtVector3 ZERO_VECTOR;
      static DtVector3 UNIT_SCALE;
      static DtVector3 X_AXIS;
      static DtVector3 Y_AXIS;
      static DtVector3 Z_AXIS;

      static DtVector3 POSITIVE_INFINITY;

      static size_t sizeInBytes(void);
   };

   typedef DtVector3<float32> Vector3_32;
   typedef std::list<Vector3_32> Vector3_32_List;
   typedef std::vector<Vector3_32> Vector3_32_Vector;

   template <class T>
   DtVector3<T> DtVector3<T>::ZERO_VECTOR = DtVector3<T>(0,0,0);
   template <class T>
   DtVector3<T> DtVector3<T>::UNIT_SCALE = DtVector3<T>(1,1,1);
   template <class T>
   DtVector3<T> DtVector3<T>::X_AXIS = DtVector3<T>(1,0,0);
   template <class T>
   DtVector3<T> DtVector3<T>::Y_AXIS = DtVector3<T>(0,1,0);
   template <class T>
   DtVector3<T> DtVector3<T>::Z_AXIS = DtVector3<T>(0,0,1);

   template <class T>
   DtVector3<T> DtVector3<T>::POSITIVE_INFINITY = DtVector3<T>(std::numeric_limits<T>::max()
                                                               ,std::numeric_limits<T>::max()
                                                               ,std::numeric_limits<T>::max());

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

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

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


   template <class T>
   T DtVector3<T>::getDistance(const DtVector3& rhs) const
   {
      return (*this-rhs).length();
   }

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

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

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

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

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

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

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

   template <class T>
   DtVector3<T> DtVector3<T>::crossProduct(const DtVector3<T>& rhs) const
   {
      //    i          j            k
      //    x          y            z
      //    rhs.x      rhs.y        rhs.z
      return DtVector3<T>(
         y*rhs.z - z*rhs.y
         , z*rhs.x - x*rhs.z
         , x*rhs.y - y*rhs.x
         );
   }

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

   template <class T>
   T DtVector3<T>::absDotProduct(const DtVector3<T>& rhs) const
   {
      return DtMath::Abs(x*rhs.x) + DtMath::Abs(y*rhs.y) + DtMath::Abs(z*rhs.z);
   }

   template <class T>
   DtVector3<T> DtVector3<T>::midPoint(const DtVector3& rhs) const
   {
      return DtVector3<T>( (x+rhs.x)*static_cast<T>(0.5)
                           , (y+rhs.y)*static_cast<T>(0.5)
                           , (z+rhs.z)*static_cast<T>(0.5)
         );

   }

   template <class T>
   T DtVector3<T>::operator[](size_t index) const
   {
      ASSERT_PREDICATE_RETURN_DEFAULT_CONSTRUCTOR(DtVector3<T>, index<=2);
      const T* ptrT = static_cast<const T*>(ptr());
      return ptrT[index];
   }

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

   template <class T>
   void DtVector3<T>::makeCeil(const DtVector3<T>& rhs)
   {
      if( rhs.x > x ) x = rhs.x;
      if( rhs.y > y ) y = rhs.y;
      if( rhs.z > z ) z = rhs.z;
   }
   template <class T>
   void DtVector3<T>::makeFloor(const DtVector3<T>& rhs)
   {
      if( rhs.x < x ) x = rhs.x;
      if( rhs.y < y ) y = rhs.y;
      if( rhs.z < z ) z = rhs.z;
   }

   template <class T>
   DtVector3<T>& DtVector3<T>::operator+=(T fScalar)
   {
      x += fScalar;
      y += fScalar;
      z += fScalar;
      return *this;
   }

   template <class T>
   DtVector3<T>& DtVector3<T>::operator-=(T fScalar)
   {
      x -= fScalar;
      y -= fScalar;
      z -= fScalar;
      return *this;
   }

   template <class T>
   DtVector3<T>& DtVector3<T>::operator*=(T fScalar)
   {
      x *= fScalar;
      y *= fScalar;
      z *= fScalar;
      return *this;
   }

   template <class T>
   DtVector3<T>& DtVector3<T>::operator/=(T fScalar)
   {
      return this->operator*=(T(1.0)/fScalar);
   }

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

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

} //namespace makVrv