DtVector4.h

Go to the documentation of this file.

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

#pragma once

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

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

namespace makVrv
{

    template <class T> class DtVector3;

   template <class T>
   class DtVector4
   {
   public:
      DtVector4() : x(0), y(0), z(0), w(0) {}
      DtVector4(T _x, T _y, T _z, T _w) : x(_x), y (_y), z (_z), w (_w) {}
      DtVector4(const DtVector3<T>& rhs, T _w)
         : x(rhs.x), y(rhs.y), z(rhs.z), w(_w) {}

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

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

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

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

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

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

      DtVector4& operator+=(const DtVector4& rhs);

      DtVector4 operator+(const DtVector4& rhs) const;

      DtVector4 operator-(const DtVector4& rhs) const;

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

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

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

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

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

      DtVector4 componentMultiply(const DtVector4& rhs) const;

      T  dotProduct(const DtVector4& rhs) const;

      void set(T x, T y, T z, T w);

   public:
      static size_t sizeInBytes(void);
   public:
      T x, y, z, w;
   public:
      static const DtVector4 theZeroVector;
      static const DtVector4 theUnitScale;
   };

   typedef DtVector4<float32> Vector4_32;
   typedef std::list<Vector4_32> Vector4_32_List;
   typedef std::vector<Vector4_32> Vector4_32_Vector;

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

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

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

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


   template <class T>
   bool DtVector4<T>::isEqual(const DtVector4<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)
         ;
      // PPP: What about the w component???
   }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   template <class T>
   DtVector4<T> DtVector4<T>::componentMultiply(const DtVector4& rhs) const
   {
      return DtVector4<T>(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w);
   }

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

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

   template <class T>
   void DtVector4<T>::set(T _x, T _y, T _z, T _w)
   {
       x = _x;
       y = _y;
       z = _z;
       w = _w;
   }

   typedef DtVector4<float32> Vector4_32;
   typedef DtVector4<int32> Vector4_int;
   typedef DtVector4<uint32> Vector4_uint32;
   typedef std::list<Vector4_32> Vector4_32_List;
   typedef std::vector<Vector4_32> Vector4_32_Vector;

   typedef DtVector4<float64> Vector4_64;
   typedef std::list<Vector4_64> Vector4_64_List;
   typedef std::vector<Vector4_64> Vector4_64_Vector;

} //namespace makVrv