DtMath.h

Go to the documentation of this file.

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

#pragma once

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

#include <cmath>
#include <limits>

namespace makVrv {

    template <class T> class DtVector2;
    template <class T> class DtVector3;
    template <class T> class DtVector4;

   class DtRadians;
   class DT_DLL_VRVMATH DtDegrees
   {
   public:
      explicit DtDegrees(float32 fVal): myVal(fVal){}
      virtual ~DtDegrees(){}
      float32 val() const {return myVal;}
      bool isEqual(const DtDegrees& rhs) const;
      DtRadians toRadians(void) const;
   private:
      DtDegrees(){}
      float32 myVal;
   };

   class DT_DLL_VRVMATH DtRadians
   {
   public:
      explicit DtRadians(float32 fVal): myVal(fVal){}
      virtual ~DtRadians(){}
      float32 val() const {return myVal;}
      bool isEqual(const DtRadians& rhs) const;
      DtDegrees toDegrees(void) const;
   private:
      DtRadians(){}
      float32 myVal;
   };

   class DT_DLL_VRVMATH DtMath
   {
   public:
      template <class T> static T Sqrt(T val)    {return sqrt(val);}
      template <class T> static T Abs(T val)     {return fabs(val);}
      static int                  Abs(int val)   {if (val>0) return val; else return -val;}
      template <class T> static T Sin(T val)     {return sin(val);}
      template <class T> static T Cos(T val)     {return cos(val);}
      template <class T> static T Tan(T val)     {return tan(val);}

      static float Sin(const DtDegrees& val);
      static float Cos(const DtDegrees& val);
      static float Tan(const DtDegrees& val);

      template <class T> static T Squared(T val) {return val*val;}

      template <class T> static int    NumDigits(T val);
      template <class T> static double GetNormalizedValueRespectingLength(T val);

      static bool isEqual(int32 lhs, int32 rhs, int32 tolerance=std::numeric_limits<int32>::epsilon());
      static bool isEqual(uint32 lhs, uint32 rhs, uint32 tolerance=std::numeric_limits<uint32>::epsilon());
      static bool isEqual(float32 lhs, float32 rhs, float32 tolerance=std::numeric_limits<float32>::epsilon());
      static bool isEqual(float64 lhs, float64 rhs, float64 tolerance=std::numeric_limits<float64>::epsilon());

      static float32 unitRandom32(void);
      static float64 unitRandom64(void);

      static int     rangeRandom(int iLow, int iHigh);
      static float32 rangeRandom(float32 fLow, float32 fHigh);
      static float64 rangeRandom(float64 fLow, float64 fHigh);
      static bool    randomBool(void);

      static uint32     getUpperPowerOfTwo(uint32 val);
      static uint32     getLowerPowerOfTwo(uint32 val);

      static bool isPowerOf2(uint32 i);
   
      static uint32 nextPowerOf2(uint32 i);

      static std::string formatBytes(uint64_t sizeInBytes);

      template <class T> static T clamp(T val, T minval, T maxval);

      template <class T> static DtVector2<T> clamp(const DtVector2<T>& val, const DtVector2<T>& minval, const DtVector2<T>& maxval);
      template <class T> static DtVector3<T> clamp(const DtVector3<T>& val, const DtVector3<T>& minval, const DtVector3<T>& maxval);
      template <class T> static DtVector4<T> clamp(const DtVector4<T>& val, const DtVector4<T>& minval, const DtVector4<T>& maxval);


      template <class T> static T lerp( T a, T b, T t );

      template <class T> static DtVector2<T> lerp( const DtVector2<T>& va, const DtVector2<T>& vb, const T t );
      template <class T> static DtVector3<T> lerp( const DtVector3<T>& va, const DtVector3<T>& vb, const T t );
      template <class T> static DtVector4<T> lerp( const DtVector4<T>& va, const DtVector4<T>& vb, const T t );

      template <class T> static DtVector3<T> toCartesian(T thetaDegrees, T phiDegrees, bool flipYZ);

      template <class T> static bool linePlaneIntersection(const DtVector3<T>& linePoint1, const DtVector3<T>& linePoint2,
                                                           const DtVector3<T>& planePoint, const DtVector3<T>& planeNormal,
                                                           DtVector3<T>& intersect, float & w);

      template <class T> static bool isFinite(T n);

      template <class T> static T Min(T lhs, T rhs);
      template <class T> static T Max(T lhs, T rhs);

      static double fractional(double val);

      // This returns 0 for non-power-of-two numbers, or sizes out of reasonable light
      // grid range (<4, or >256).  Currently, a grid size of 32 (log2=5) is hardcoded
      // elsewhere.
      static unsigned int tilelog2(unsigned int x);

      template <class T> 
      static T rpmToRadiansPerSec(T rpm);

      template <class T>
      static T radiansPerSecToRpm(T radiansPerSec);

#undef max
#undef min
      template <class T> static T positiveInfinity(void) { return std::numeric_limits<T>::max();}
      template <class T> static T negativeInfinity(void) { return std::numeric_limits<T>::min();}

      static const float32 TWO_PI;
      static const float32 PI;
      static const float32 PI_BY_2;
      static const float32 PI_BY_3;
      static const float32 PI_BY_4;
      static const float32 PI_BY_6;
      static const float32 Gravity;
      static const float32 m_fConvertToRadians;
      static const float32 m_fConvertToDegrees;
   private:
   };

   template <class T>
   T DtMath::clamp(T val, T minval, T maxval)
   {
      Assert(minval <= maxval && "Invalid clamp range");
      return std::max(std::min(val, maxval), minval);
   }

   template <class T>
   DtVector2<T> DtMath::clamp(const DtVector2<T>& val, const DtVector2<T>& minval, const DtVector2<T>& maxval)
   {
      DtVector2<T> vClampedVal;
      vClampedVal.x = DtMath::clamp(val.x, minval.x, maxval.x);
      vClampedVal.y = DtMath::clamp(val.y, minval.y, maxval.y);
      return vClampedVal;
   }

   template <class T>
   DtVector3<T> DtMath::clamp(const DtVector3<T>& val, const DtVector3<T>& minval, const DtVector3<T>& maxval)
   {
      DtVector3<T> vClampedVal;
      vClampedVal.x = DtMath::clamp(val.x, minval.x, maxval.x);
      vClampedVal.y = DtMath::clamp(val.y, minval.y, maxval.y);
      vClampedVal.z = DtMath::clamp(val.z, minval.z, maxval.z);
      return vClampedVal;
   }

   template <class T>
   DtVector4<T> DtMath::clamp(const DtVector4<T>& val, const DtVector4<T>& minval, const DtVector4<T>& maxval)
   {
      DtVector4<T> vClampedVal;
      vClampedVal.x = DtMath::clamp(val.x, minval.x, maxval.x);
      vClampedVal.y = DtMath::clamp(val.y, minval.y, maxval.y);
      vClampedVal.z = DtMath::clamp(val.z, minval.z, maxval.z);
      vClampedVal.w = DtMath::clamp(val.w, minval.w, maxval.w);
      return vClampedVal;
   }

   template<class T>
   inline T DtMath::lerp( T va, T vb, T t )
   {
      if( t <= 0.0 )
      {
         return va;
      }

      if( t >= 1.0 )
      {
         return vb;
      }

      T vm = va + (vb - va) * t;
      return vm;
   }

   template<class T>
   inline DtVector2<T> DtMath::lerp( const DtVector2<T>& va, const DtVector2<T>& vb, const T t )
   {
      if( t <= 0.0 )
      {
         return va;
      }

      if( t >= 1.0 )
      {
         return vb;
      }

      DtVector2<T> vm;
      vm[0] = va[0] + (vb[0] - va[0]) * t;
      vm[1] = va[1] + (vb[1] - va[1]) * t;

      return vm;
   }

   template<class T>
   inline DtVector3<T> DtMath::lerp( const DtVector3<T>& va, const DtVector3<T>& vb, const T t )
   {
      if( t <= 0.0 )
      {
         return va;
      }

      if( t >= 1.0 )
      {
         return vb;
      }

      DtVector3<T> vm;
      vm[0] = va[0] + (vb[0] - va[0]) * t;
      vm[1] = va[1] + (vb[1] - va[1]) * t;
      vm[2] = va[2] + (vb[2] - va[2]) * t;

      return vm;
   }

   template<class T>
   inline DtVector4<T> DtMath::lerp( const DtVector4<T>& va, const DtVector4<T>& vb, const T t )
   {
      if( t <= 0.0 )
      {
         return va;
      }

      if( t >= 1.0 )
      {
         return vb;
      }

      DtVector4<T> vm;
      vm[0] = va[0] + (vb[0] - va[0]) * t;
      vm[1] = va[1] + (vb[1] - va[1]) * t;
      vm[2] = va[2] + (vb[2] - va[2]) * t;
      vm[3] = va[3] + (vb[3] - va[3]) * t;

      return vm;
   }

   template <class T>
   DtVector3<T> DtMath::toCartesian(T thetaDegrees, T phiDegrees, bool flipYZ)
   {
      T theta = toRadians(thetaDegrees);
      T phi   = toRadians(phiDegrees);

      DtVector3<T> vPosition;
      vPosition.x = DtMath::Cos(theta)*Cos(phi);
      vPosition.y = DtMath::Sin(theta)*Cos(phi);
      vPosition.z = DtMath::Sin(phi);

      if (flipYZ)
      {
         T temp = vPosition.y;
         vPosition.y = vPosition.z;
         vPosition.z = temp;
      }

      return vPosition;
   }

   template <class T>
   bool DtMath::linePlaneIntersection(const DtVector3<T>& linePoint1, const DtVector3<T>& linePoint2,
                                      const DtVector3<T>& planePoint, const DtVector3<T>& planeNormal,
                                      DtVector3<T>& intersect, float& w)
   {
      DtVector3<T> lineDir = linePoint2 - linePoint1;
      lineDir.normalize();

      DtVector3<T> pnorm = planeNormal;
      pnorm.normalize();

      float denom = lineDir.dotProduct(pnorm);
      if (denom == 0.0f)
      {
         return false;
      }

      DtVector3<T> pTolDelta = (planePoint - linePoint1);
      w = pTolDelta.dotProduct(pnorm) / denom;
      intersect = (lineDir * w) + linePoint1;
      return true;
   }

   template <class T> 
   int DtMath::NumDigits(T val)
   {
      int digits = 0;
      while (val) {
         val /= 10;
         digits++;
      }
      return digits;
   }

   template <class T>
   double DtMath::GetNormalizedValueRespectingLength(T val)
   {
      double normalizedValue = (double)(val)/(double)(std::numeric_limits<T>::max());
      return normalizedValue;
   }

   template <class T>
   bool DtMath::isFinite(T n)
   {
   return ((n == n)
        && (n != +std::numeric_limits<T>::infinity())
        && (n != -std::numeric_limits<T>::infinity())
        );
   }

   template <class T>
   T DtMath::Min(T lhs, T rhs)
   {
      if (lhs < rhs)
      {
         return lhs;
      }
      else
      {
         return rhs;
      }
   }

   template <class T>
   T DtMath::Max(T lhs, T rhs)
   {
      if (lhs > rhs)
      {
         return lhs;
      }
      else
      {
         return rhs;
      }
   }

   template <class T>
   T DtMath::rpmToRadiansPerSec(T rpm)
   {
      return (rpm / 60.0f) * 2.0f * DtMath::PI;
   }

   template <class T>
   T DtMath::radiansPerSecToRpm(T radiansPerSec)
   {
      return (radiansPerSec / (2.0f * DtMath::PI)) * 60.0f;
   }

} //namespace makVrv