ParaMath.h

#pragma once
#include <limits>
#include <stdint.h>
#include "ParaAngle.h"
#include "ParaMathUtility.h"

#if !defined(WIN32) && !defined(INT64_C)
#  define INT64_C(c) static_cast<long long>(c ## LL)     /* signed 64 bit constant */
#  define UINT64_C(c) static_cast<unsigned long long>(c ## ULL) /* unsigned 64 bit constant */
#endif

namespace ParaEngine
{
    class CShapeBox;
    class CShapeSphere;
    class Matrix4;
    class DVector3;
    class Vector3;

    class Math 
    {
   public:
       enum AngleUnit
       {
           AU_DEGREE,
           AU_RADIAN
       };

       static const float POS_INFINITY;
       static const float NEG_INFINITY;
       static const float PI;
       static const float TWO_PI;
       static const float HALF_PI;
       static const float fDeg2Rad;
       static const float fRad2Deg;

    protected:
        // angle units used by the api
        static AngleUnit msAngleUnit;

        static int mTrigTableSize;

        static float mTrigTableFactor;
        static float* mSinTable;
        static float* mTanTable;

        void buildTrigTables();

        static float SinTable (float fValue);
        static float TanTable (float fValue);
    public:
        Math(unsigned int trigTableSize = 4096);

        ~Math();

        static inline int IAbs (int iValue) { return ( iValue >= 0 ? iValue : -iValue ); }
        static inline int ICeil (float fValue) { return int(ceil(fValue)); }
        static inline int IFloor (float fValue) { return int(floor(fValue)); }
        static int ISign (int iValue);

        static inline float Abs (float fValue) { return float(fabs(fValue)); }
        static inline double Abs(double fValue) { return fabs(fValue); }
        static inline int Abs(int nValue) { return nValue >= 0 ? nValue : -nValue; }
        static inline Degree Abs (const Degree& dValue) { return Degree(fabs(dValue.valueDegrees())); }
        static inline Radian Abs (const Radian& rValue) { return Radian(fabs(rValue.valueRadians())); }
        static Radian ACos (float fValue);
        static Radian ASin (float fValue);
        static inline Radian ATan (float fValue) { return Radian(atan(fValue)); }
        static inline Radian ATan2 (float fY, float fX) { return Radian(atan2(fY,fX)); }
        static inline float Ceil (float fValue) { return float(ceil(fValue)); }

        static inline float Cos (const Radian& fValue, bool useTables = false) {
            return (!useTables) ? float(cos(fValue.valueRadians())) : SinTable(fValue.valueRadians() + HALF_PI);
        }
        static inline float Cos (float fValue, bool useTables = false) {
            return (!useTables) ? float(cos(fValue)) : SinTable(fValue + HALF_PI);
        }

        static inline float Exp (float fValue) { return float(exp(fValue)); }

        static inline float Floor (float fValue) { return float(floor(fValue)); }

        static inline float Log (float fValue) { return float(log(fValue)); }

        static inline float Pow (float fBase, float fExponent) { return float(pow(fBase,fExponent)); }

        static float Sign (float fValue);
        static inline Radian Sign ( const Radian& rValue )
        {
            return Radian(Sign(rValue.valueRadians()));
        }
        static inline Degree Sign ( const Degree& dValue )
        {
            return Degree(Sign(dValue.valueDegrees()));
        }

        static inline float Sin (const Radian& fValue, bool useTables = false) {
            return (!useTables) ? float(sin(fValue.valueRadians())) : SinTable(fValue.valueRadians());
        }
        static inline float Sin (float fValue, bool useTables = false) {
            return (!useTables) ? float(sin(fValue)) : SinTable(fValue);
        }

        static inline float Sqr (float fValue) { return fValue*fValue; }
        static inline float Sqrt (float fValue) { return float(sqrt(fValue)); }

        static inline double Sqr(double fValue) { return fValue*fValue; }
        static inline double Sqrt(double fValue) { return sqrt(fValue); }

        static inline Radian Sqrt (const Radian& fValue) { return Radian(sqrt(fValue.valueRadians())); }

        static inline Degree Sqrt (const Degree& fValue) { return Degree(sqrt(fValue.valueDegrees())); }

        static float InvSqrt(float fValue);

        static float UnitRandom ();  // in [0,1]

        static float RangeRandom (float fLow, float fHigh);  // in [fLow,fHigh]

        static float SymmetricRandom ();  // in [-1,1]

        static inline float Tan (const Radian& fValue, bool useTables = false) {
            return (!useTables) ? float(tan(fValue.valueRadians())) : TanTable(fValue.valueRadians());
        }
        static inline float Tan (float fValue, bool useTables = false) {
            return (!useTables) ? float(tan(fValue)) : TanTable(fValue);
        }

        static inline float DegreesToRadians(float degrees) { return degrees * fDeg2Rad; }
        static inline float RadiansToDegrees(float radians) { return radians * fRad2Deg; }

       static void setAngleUnit(AngleUnit unit);
       static AngleUnit getAngleUnit(void);

       static float AngleUnitsToRadians(float units);
       static float RadiansToAngleUnits(float radians);
       static float AngleUnitsToDegrees(float units);
       static float DegreesToAngleUnits(float degrees);

        static bool pointInTri2D(const Vector2& p, const Vector2& a, 
            const Vector2& b, const Vector2& c);

        static bool pointInTri3D(const Vector3& p, const Vector3& a, 
            const Vector3& b, const Vector3& c, const Vector3& normal);
        static std::pair<bool, float> intersects(const Ray& ray, const Plane& plane);

        static std::pair<bool, float> intersects(const Ray& ray, const Sphere& sphere, 
            bool discardInside = true);
        
        static std::pair<bool, float> intersects(const Ray& ray, const AxisAlignedBox& box);

        static bool intersects(const Ray& ray, const AxisAlignedBox& box,
            float* d1, float* d2);

        static std::pair<bool, float> intersects(const Ray& ray, const Vector3& a,
            const Vector3& b, const Vector3& c, const Vector3& normal,
            bool positiveSide = true, bool negativeSide = true);

        static std::pair<bool, float> intersects(const Ray& ray, const Vector3& a,
            const Vector3& b, const Vector3& c,
            bool positiveSide = true, bool negativeSide = true);

        static bool intersects(const Sphere& sphere, const AxisAlignedBox& box);
        static bool intersects(const CShapeSphere& sphere, const CShapeBox& box);
        static bool intersects(const Plane& plane, const AxisAlignedBox& box);

        static std::pair<bool, float> intersects(
            const Ray& ray, const std::vector<Plane>& planeList, 
            bool normalIsOutside);
        static std::pair<bool, float> intersects(
            const Ray& ray, const std::list<Plane>& planeList, 
            bool normalIsOutside);

        static bool intersects(const Sphere& sphere, const Plane& plane);

        static bool RealEqual(float a, float b,
            float tolerance = std::numeric_limits<float>::epsilon());

        static Vector3 calculateTangentSpaceVector(
            const Vector3& position1, const Vector3& position2, const Vector3& position3,
            float u1, float v1, float u2, float v2, float u3, float v3);

        static Matrix4 buildReflectionMatrix(const Plane& p);
        static Vector4 calculateFaceNormal(const Vector3& v1, const Vector3& v2, const Vector3& v3);
        static Vector3 calculateBasicFaceNormal(const Vector3& v1, const Vector3& v2, const Vector3& v3);
        static Vector4 calculateFaceNormalWithoutNormalize(const Vector3& v1, const Vector3& v2, const Vector3& v3);
        static Vector3 calculateBasicFaceNormalWithoutNormalize(const Vector3& v1, const Vector3& v2, const Vector3& v3);

        static float gaussianDistribution(float x, float offset = 0.0f, float scale = 1.0f);

        template< class T >
        static inline T Clamp(const T X, const T Min, const T Max)
        {
            return X < Min ? Min : X < Max ? X : Max;
        }

        static Matrix4 makeViewMatrix(const Vector3& position, const Quaternion& orientation, 
            const Matrix4* reflectMatrix = 0);

        static inline bool IsEquivalent(float f1, float f2) { return f1 - f2 < FLT_TOLERANCE && f2 - f1 < FLT_TOLERANCE; }

        static inline bool IsEquivalent(float f1, float f2, float tolerance) { return f1 - f2 < tolerance && f2 - f1 < tolerance; }

        static inline bool IsEquivalent(double f1, double f2) { return f1 - f2 < DBL_TOLERANCE && f2 - f1 < DBL_TOLERANCE; }

        static inline bool IsEquivalent(double f1, double f2, double tolerance) { return f1 - f2 < tolerance && f2 - f1 < tolerance; }

        template <class T>
        static inline bool IsEquivalent(const T* al, size_t acount, const T* bl, size_t bcount)
        {
            if (acount != bcount) return false;
            bool equivalent = true;
            for (size_t i = 0; i < acount && equivalent; ++i)
            {
                equivalent = IsEquivalent(al[i], bl[i]);
            }
            return equivalent;
        }

        static int log2 (unsigned int x);

        static int log2_ceil(unsigned int x) {return (log2(x-1) + 1);}

        template< class T >
        static inline T Max(const T A, const T B)
        {
            return (A >= B) ? A : B;
        }
        template< class T >
        static inline T Min(const T A, const T B)
        {
            return (A <= B) ? A : B;
        }

        static inline int32 Trunc(float F)
        {
            return (int32)F;
        }
        static inline float TruncFloat(float F)
        {
            return (float)Trunc(F);
        }

        static inline float Fractional(float Value)
        {
            return Value - TruncFloat(Value);
        }

        static inline float GridSnap(float Location, float Grid)
        {
            if (Grid == 0.f)    return Location;
            else
            {
                return Floor((Location + 0.5f*Grid) / Grid)*Grid;
            }
        }
    

        template <class T>
        static inline T DivideAndRoundUp(T Dividend, T Divisor)
        {
            return (Dividend + Divisor - 1) / Divisor;
        }

        template< class T >
        static inline T Max3(const T A, const T B, const T C)
        {
            return Max(Max(A, B), C);
        }

        template< class T >
        static inline T Min3(const T A, const T B, const T C)
        {
            return Min(Min(A, B), C);
        }

        template< class T, class U >
        static inline T Lerp(const T& A, const T& B, const U& Alpha)
        {
            return (T)(A + Alpha * (B - A));
        }

        static inline int32 Rand() { return rand(); }

        static inline void RandInit(int32 Seed) { srand(Seed); }

        static inline float FRand() { return rand() / (float)RAND_MAX; }

        static void SRandInit(int32 Seed);

        static float SRand();

        static inline float FloatSelect(float Comparand, float ValueGEZero, float ValueLTZero)
        {
            return Comparand >= 0.f ? ValueGEZero : ValueLTZero;
        }

        static bool SmoothMoveFloat1(float& src, const float dest, const float fMaxStep);

        static bool SmoothMoveAngle1(float& src, const float dest, const float fMaxStep);

        static bool SmoothMoveVec3(Vector3* result, const Vector3& vPosTarget, const Vector3& vPos, FLOAT fIncrease, FLOAT fTolerance/*=0*/);

        static float ToStandardAngle(float fAngle);
        static double ToStandardAngle(double fAngle);

        static bool MatchString(const std::string& matchPattern, const std::string& matchStr);

        static bool ComputeFacingTarget(const Vector3& target, const Vector3& source, FLOAT& fFacing);
        static bool ComputeFacingTarget(const DVector3& target, const DVector3& source, float& fFacing);
        static inline int Round(float fValue){
            return int(fValue > 0.0f ? fValue + 0.5f : fValue - 0.5f);
        }

        static float MinVec3(const Vector3& v);
        static float MaxVec3(const Vector3& v);

        template <class T>
        static inline bool CompareXZ(const T& a, const T& b)
        {
            return (a.x == b.x && a.z == b.z);
        }

        template <class T>
        static bool CompareXZ(const T& a, const T& b, float epsilon)
        {
            return (fabs(a.x - b.x) + fabs(a.z - b.z)) < epsilon;
        }

        static inline bool FuzzyCompare(double p1, double p2)
        {
            return (Math::Abs(p1 - p2) * 1000000000000. <= Math::Min(Math::Abs(p1), Math::Abs(p2)));
        }

        static bool FuzzyCompare(float p1, float p2)
        {
            return (Math::Abs(p1 - p2) * 100000.f <= Math::Min(Math::Abs(p1), Math::Abs(p2)));
        }

        static inline bool FuzzyIsNull(double d)
        {
            return Math::Abs(d) <= 0.000000000001;
        }

        static inline bool FuzzyIsNull(float f)
        {
            return Math::Abs(f) <= 0.00001f;
        }

        static inline bool IsNull(double d)
        {
            union U {
                double d;
                uint64 u;
            };
            U val;
            val.d = d;
            return (val.u & UINT64_C(0x7fffffffffffffff)) == 0;
        }

        /*
        This function tests a float for a null value. It doesn't
        check whether the actual value is 0 or close to 0, but whether
        it is binary 0, disregarding sign.
        */
        static bool IsNull(float f)
        {
            union U {
                float f;
                uint32 u;
            };
            U val;
            val.f = f;
            return (val.u & 0x7fffffff) == 0;
        }

        template<typename T>
        static inline bool is_nan(T value)
        {
            return value != value;
        }

        template<typename T>
        static inline bool is_infinity(T value)
        {
            return std::numeric_limits<T>::has_infinity &&
                value == std::numeric_limits<T>::infinity();
        }

        static void GetMatrixScaling(const Matrix4& globalMat, float* fScalingX, float* fScalingY, float* fScalingZ);

        static Matrix4* CreateBillboardMatrix(Matrix4* pOut, const Matrix4* matModelview, const Vector3* vBillboardPos, bool bAxisAligned = false);

        // Make a rotation matrix based on the camera's yaw & pitch
        static void CameraRotMatrixYawPitch(Matrix4& out, float fYaw, float fPitch);

        static int NextPowerOf2(int x);
    };
}