DtVector3.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 <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() 
      {
         //intentional nop   
      }

   public:
      //pointer to the data directly
      const void* ptr(void) const 
      { 
         return &x; 
      }

      const T* typePtr(void) const { return &x; }

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

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

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

      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+=(const DtVector3& rhs);
      DtVector3& operator-=(const DtVector3& rhs);

      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);
   public:
      static size_t sizeInBytes(void);
   public:
      T x, y, z;
   public:
      static const DtVector3 theZeroVector;
      static const DtVector3 theUnitScale;
      static const DtVector3 X_AXIS;
      static const DtVector3 Y_AXIS;
      static const DtVector3 Z_AXIS;

      static DtVector3 POSITIVE_INFINITY;
   };

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

   template <class T>
   const DtVector3<T> DtVector3<T>::theZeroVector = DtVector3<T>(0, 0, 0);
   template <class T>
   const DtVector3<T> DtVector3<T>::theUnitScale = DtVector3<T>(1, 1, 1);
   template <class T>
   const DtVector3<T> DtVector3<T>::X_AXIS = DtVector3<T>(1, 0, 0);
   template <class T>
   const DtVector3<T> DtVector3<T>::Y_AXIS = DtVector3<T>(0, 1, 0);
   template <class T>
   const 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+=(const DtVector3<T>& rhs)
   {
      x += rhs.x;
      y += rhs.y;
      z += rhs.z;
      return *this;
   }

   template <class T>
   DtVector3<T>& DtVector3<T>::operator-=(const DtVector3<T>& rhs)
   {
      x -= rhs.x;
      y -= rhs.y;
      z -= rhs.z;
      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>
   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
   {
      const DtVector3<T>& lhs = *this;
      return !(lhs == rhs);
   }

   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);
   }

   typedef DtVector3<int32> Vector3_int;
   typedef DtVector3<float32> Vector3_32;
   typedef DtVector3<uint32> Vector3_uint32;
   typedef std::list<Vector3_32> Vector3_32_List;
   typedef std::vector<Vector3_32> Vector3_32_Vector;


   typedef DtVector3<float64> Vector3_64;
   typedef std::list<Vector3_64> Vector3_64_List;
   typedef std::vector<Vector3_64> Vector3_64_Vector;


} //namespace makVrv