MathLib.h

#pragma once

#ifndef EPSILON
#define EPSILON 0.00001f
#endif

#ifndef FLOAT_POS_INFINITY
#define FLOAT_POS_INFINITY 999999999.0f
#endif

namespace ParaEngine
{

    class CMath
    {
    public:
        CMath(void);
        ~CMath(void);
    public:
        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 bool MatchString(const std::string& matchPattern, const std::string& matchStr);

        static bool ComputeFacingTarget(const Vector3& target, const Vector3& source, FLOAT& fFacing);
        static inline int Round(float fValue);

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

    inline int Math::Round(float fValue)
    {
        return int(fValue > 0.0f ? fValue + 0.5f : fValue - 0.5f);
        /*if(fValue>=0)
            return (((fValue-(int)fValue)>0.5f)?((int)fValue+1):(int)fValue);
        else
            return -ToInt(-fValue);*/
    }
}