---

---

AI_Math.h

Go to the documentation of this file.

#ifndef AI_MATH_H
#define AI_MATH_H
//------------------------------------------------------------------------------
#include <math.h>
#include <stdlib.h>

#ifdef _MSC_VER
    #ifndef isnan
    #define isnan _isnan
    #endif
    
    #ifndef isinf
    #define isinf _isinf
    #endif
#endif

#ifndef PI
#define PI (3.1415926535897932384626433832795028841971693993751f)
#endif

#define AI_PI PI
#define AI_2PI 6.2831853f
#define AI_HALFPI 1.570796326f
#define AI_QUARTERPI 0.785398163f
#define AI_TINY 0.00001f //0.0000001
#define AI_INFINITY 3500000.0f
#define AI_SQRT2 1.414213562373f

#define ai_max(a,b)      (((a) > (b)) ? (a) : (b))
#define ai_min(a,b)      (((a) < (b)) ? (a) : (b))
#define ai_abs(a)        (((a)<0.0f) ? (-(a)) : (a))
#define ai_sgn(a)        (((a)<0.0f) ? (-1) : (1))
#define ai_deg2rad(d)    (((d)*AI_PI)/180.0f)
#define ai_rad2deg(r)    (((r)*180.0f)/AI_PI)
#define ai_sin(x)        (float(sin(x)))
#define ai_cos(x)        (float(cos(x)))
#define ai_tan(x)        (float(tan(x)))
#define ai_atan(x)       (float(atan(x)))

//------------------------------------------------------------------------------
const float AI_LN_2 = 0.693147180559945f;
static inline float ai_log2(float f)
{
    return logf(f) / AI_LN_2;
}

//------------------------------------------------------------------------------
static inline int ai_iclamp(int val, int minVal, int maxVal)
{
    if (val < minVal)      return minVal;
    else if (val > maxVal) return maxVal;
    else return val;
}

//------------------------------------------------------------------------------
static inline float ai_acos(float x)
{
    if(x >  1.0f) x =  1.0f;
    if(x < -1.0f) x = -1.0f;
    return (float)acos(x);
}

//------------------------------------------------------------------------------
static inline float ai_asin(float x)
{
    if(x >  1.0f) x =  1.0f;
    if(x < -1.0f) x = -1.0f;
    return (float)asin(x);
}

//------------------------------------------------------------------------------
static inline float ai_sqrt(float x)
{
    if (x < 0.0f) x = (float) 0.0f;
    return (float) sqrt(x);
}

//------------------------------------------------------------------------------
static inline bool ai_fequal(float f0, float f1, float tol) {
    float f = f0-f1;
    if ((f>(-tol)) && (f<tol)) return true;
    else                       return false;
}

//------------------------------------------------------------------------------
static inline bool ai_fless(float f0, float f1, float tol) {
    if ((f0-f1)<tol) return true;
    else             return false;
}

//------------------------------------------------------------------------------
static inline bool ai_fgreater(float f0, float f1, float tol) {
    if ((f0-f1)>tol) return true;
    else             return false;
}

//------------------------------------------------------------------------------
static inline long ai_ftol(float val)
{
    double v = double(val) + (68719476736.0*1.5);
    return ((long*)&v)[0] >> 16;
}

//------------------------------------------------------------------------------
static inline float ai_smooth(float newVal, float curVal, float maxChange)
{
    float diff = newVal - curVal;
    if (fabs(diff) > maxChange)
    {
        if (diff > 0.0f)
        {
            curVal += maxChange;
            if (curVal > newVal)
            {
                curVal = newVal;
            }
        }
        else if (diff < 0.0f)
        {
            curVal -= maxChange;
            if (curVal < newVal)
            {
                curVal = newVal;
            }
        }
    }
    else
    {
        curVal = newVal;
    }
    return curVal;
}

//------------------------------------------------------------------------------
static inline float ai_clamp(float val, float lower, float upper)
{
    if (val < lower)      return lower;
    else if (val > upper) return upper;
    else                  return val;
}

//------------------------------------------------------------------------------
static inline float ai_saturate(float val)
{
    if (val < 0.0f)      return 0.0f;
    else if (val > 1.0f) return 1.0f;
    else return val;
}

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

//------------------------------------------------------------------------------
static inline int ai_fchop(float f)
{
    // FIXME!
    return int(f);
}

//------------------------------------------------------------------------------
static inline int ai_frnd(float f)
{
    return ai_fchop(f + 0.5f);
}

//------------------------------------------------------------------------------
static inline float ai_lerp(float x, float y, float l)
{
    return x + l * (y - x);
}


static inline bool ai_isEqualFloat(const float f0, const float f1, const float tol) 
{
    float f = f0 - f1;
    return ((f>(-tol)) && (f<tol));
}


static inline int ai_random(const int i_sides)
{
    return (rand() % i_sides) + 1;
}


//------------------------------------------------------------------------------
template<class TYPE>
static inline
void
ai_lerp(TYPE & result, const TYPE & val0, const TYPE & val1, float lerpVal)
{
    n_error("Unimplemented lerp function!");
}

//------------------------------------------------------------------------------
template<>
static inline
void
ai_lerp<int>(int & result, const int & val0, const int & val1, float lerpVal)
{
    result = ai_fchop((float)val0 + (((float)val1 - (float)val0) * lerpVal));
}

//------------------------------------------------------------------------------
template<>
static inline
void
ai_lerp<float>(float & result, const float & val0, const float & val1, float lerpVal)
{
    result = val0 + ((val1 - val0) * lerpVal);
}

//------------------------------------------------------------------------------
#endif

---

InExIn pages are hosted by
InExIn documentation generated by doxygen at Tue Dec 18 12:55:27 2007