D:/Uni/8.Semester/InfoVis/Demo/source/Util/Math.h

#ifndef __MATH_H__
#define __MATH_H__

#include <stdlib.h>
#include <limits>
#include <math.h>
#include "Vector3.h"
#include "Matrix3.h"

class Ray;

class Math
{
public:
    static const float MAX_FLOAT;
    static const float EPSILON_FLOAT;
    static const float PI;
        static const float HALF_PI;
        static const float DOUBLE_PI;
    static const float DEG_TO_RAD;
        static const float RAD_TO_DEG;
        static const float EULER;
        static const float SQUARE_ROOT_TWO;

        static const float BAUCHSCHE_FAKE_CONST;

        static int NextPowerOf2Value(int val);
    static bool IsPowerOf2(int val);

        static float InterpolateAngle(float angle1,float angle2, float t);

        static Vector3 InterpolatePosition(const Vector3& a, const Vector3& b, const Vector3& tXYZ);

        static float InterpolateCoord(float a, float b, float t);

        static float GetAngleY(const Vector3& direction);

        static float GetAngleDifference(float angle1,float angle2);

        static Vector3 GetDirectionFromAngleY(float angle);

        template<class T>
        static T InterpolateCatmullRom(float t, const T& p1, const T& p2, const T& p3, const T& p4);

        template<class T>
        static T InterpolateCatmullRomDerivation(float t, const T& p1, const T& p2, const T& p3, const T& p4);

        template<class T>
        static T InterpolateCatmullRom(float t, const T& p1, const T& p2, const T& p3, const T& p4, T& derivation);

        template<class T>
        static T InterpolateCosine(T start, T end, float ratio);

        template<class T>
        static T Lerp(T start, T end, float ratio);

        template<class T>
        static T InterpolateCubic(const T preStart, const T start, const T end, const T postEnd, const float ratio);

        template<class T>
        static T InterpolateHermite(const T preStart, const T start, const T end, const T postEnd, const float ratio, const float tension = 0, const float bias = 0);

        static void GetBarycentric(const Vector3& p, const Vector3& a, const Vector3& b, const Vector3& c, float& b0, float& b1, float& b2);

        // Truncates a float to 0 decimal digits
        static float Trunc(float val);
    static float Frac(float val);

        static float Clamp(float val, float min, float max);

        static int Clamp(int val, int min, int max);

        static float Wrap(float val, float lower, float upper);

    static bool IsSmaller(float x, float y) { return x < (y-EPSILON_FLOAT); }
    static bool IsBigger(float x, float y) { return x > (y+EPSILON_FLOAT); }

    static bool IsEqual(float x, float y) { return !IsSmaller(x,y) && !IsBigger(x,y); }
    static bool IsNotEqual(float x, float y) { return IsSmaller(x,y) || IsBigger(x,y); }    
  
    static float Sin(float degree) { return sinf(degree); }
    static float ASin(float degree) { return asinf(degree); }
    static float Cos(float degree) { return cosf(degree); }
    static float ACos(float degree) { return acosf(degree); }
    static float Tan(float degree) { return tanf(degree); }
    static float ATan(float degree) { return atanf(degree); }
    static float ATan2(float x, float y) { return atan2f(x, y); }
    static float Cot(float degree) { return 1.0f/Tan(degree); }
    static float Sqrt(float value) { return sqrtf(value); }
        static float Log(float value);

        static float InvSqrt(float value);    
    static float Abs(float value) { return abs(value); }
    static int Abs(int value) { return abs(value); }
    static float Pow(float base, float exponent) { return powf(base, exponent); }
    static int Pow(int base, int exponent) { return (int)pow(base, exponent); }

    static int Max(int x, int y) { return((x)>(y)?(x):(y)); }
    static float Max(float x, float y) { return((x)>(y)?(x):(y)); }
    static int Min(int x, int y) { return((x)<(y)?(x):(y)); }
    static float Min(float x, float y) { return((x)<(y)?(x):(y)); }
    static float FMod(float x, float y) { return fmodf(x, y); }

        static bool IsReal(float f) { if (!(f==f) || (f == std::numeric_limits<float>::infinity()) || (f == -std::numeric_limits<float>::infinity())) return false; else return true; }

        //@TODO there should be intrinsics that do this much faster
        static float CopySign(float x, float sign) { return ((sign>=0.0f) ? (Math::Abs(x)) : (-Math::Abs(x))); }

        static float Round(float value, int digits = 0);

        static float RandomFloat(const float fMin, const float fMax) {return fMin + (fMax - fMin) * ((float)(rand() % 10001) / 10000.0f);}

        static Matrix3 MatrixFromVectorRotation(const Vector3& vector);
        static void AxisAngleFromVectorRotation(const Vector3& v1, const Vector3& target, Vector3& axis, float& angle);

        static void DirectionToPitchHeading(const Vector3& dir, float& pitch, float& heading);

        // shift angle between -pi, +pi
        static float ShiftAngle(float angle);

        static float GetYAngleBetweenDirections(const Vector3& dir1, const Vector3& dir2);
};

#define RAD2DEG(a) (((a)*180.0f)/(Math::PI))
#define DEG2RAD(a) (((a)*Math::PI)/180.0f)

#define DEG1 DEG2RAD(1.0f)
#define DEG45 DEG2RAD(45.0f)
#define DEG90 DEG2RAD(90.0f)
#define DEG180 DEG2RAD(180.0f)
#define DEG270 DEG2RAD(270.0f)
#define DEG360 DEG2RAD(360.0f)

#endif //__MATH_H__

---