include/math/orxMath.h

Go to the documentation of this file.

/* Orx - Portable Game Engine
 *
 * Copyright (c) 2008-2011 Orx-Project
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 *    1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 *
 *    2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 *
 *    3. This notice may not be removed or altered from any source
 *    distribution.
 */

#ifndef _orxMATH_H_
#define _orxMATH_H_


#include "orxInclude.h"

#include <math.h>


#define orxLERP(A, B, T)          ((A) + ((T) * ((B) - (A))))


#define orxMIN(A, B)              (((A) > (B)) ? (B) : (A))

#define orxMAX(A, B)              (((A) < (B)) ? (B) : (A))

#define orxCLAMP(V, MIN, MAX)     orxMAX(orxMIN(V, MAX), MIN)

#define orxCIRCULAR_CLAMP_INC_MIN(V, MIN, MAX)  \
do                                              \
{                                               \
  while((V) < (MIN))                            \
  {                                             \
    (V) += ((MAX) - (MIN));                     \
  }                                             \
  while((V) >= (MAX))                           \
  {                                             \
    (V) -= ((MAX) - (MIN));                     \
  }                                             \
} while(orxFALSE)

#define orxCIRCULAR_CLAMP_INC_MAX(V, MIN, MAX)  \
do                                              \
{                                               \
  while((V) <= (MIN))                           \
  {                                             \
    (V) += ((MAX) - (MIN));                     \
  }                                             \
  while((V) > (MAX))                            \
  {                                             \
    (V) -= ((MAX) - (MIN));                     \
  }                                             \
} while(orxFALSE)

#define orxF2U(V)                 ((orxU32)  (V))

#define orxF2S(V)                 ((orxS32)  (V))

#define orxU2F(V)                 ((orxFLOAT)(V))

#define orxS2F(V)                 ((orxFLOAT)(V))


/*** Module functions *** */

extern orxDLLAPI void orxFASTCALL     orxMath_InitRandom(orxS32 _s32Seed);

extern orxDLLAPI orxFLOAT orxFASTCALL orxMath_GetRandomFloat(orxFLOAT _fMin, orxFLOAT _fMax);

extern orxDLLAPI orxU32 orxFASTCALL   orxMath_GetRandomU32(orxU32 _u32Min, orxU32 _u32Max);

extern orxDLLAPI orxS32 orxFASTCALL   orxMath_GetRandomS32(orxS32 _s32Min, orxS32 _s32Max);


/*** Inlined functions *** */

static orxINLINE orxU32 orxMath_GetBitCount(orxU32 _u32Value)
{
  _u32Value -= ((_u32Value >> 1) & 0x55555555);
  _u32Value = (((_u32Value >> 2) & 0x33333333) + (_u32Value & 0x33333333));
  _u32Value = (((_u32Value >> 4) + _u32Value) & 0x0f0f0f0f);
  _u32Value += (_u32Value >> 8);
  _u32Value += (_u32Value >> 16);
  return(_u32Value & 0x0000003f);
}

static orxINLINE orxU32 orxMath_GetTrailingZeroCount(orxU32 _u32Value)
{
  /* De Bruijn multiply look up table */
  static const orxU32 sau32DeBruijnLUT[32] = 
  {
    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
  };

  /* Done! */
  return sau32DeBruijnLUT[((orxU32)(((orxS32)_u32Value & -(orxS32)_u32Value) * 0x077CB531U)) >> 27];
}

static orxINLINE orxBOOL orxMath_IsPowerOfTwo(orxU32 _u32Value)
{
  orxBOOL bResult;

  /* Updates result */
  bResult = ((_u32Value & (_u32Value - 1)) == 0) ? orxTRUE : orxFALSE;
  
  /* Done! */
  return bResult;
}

static orxINLINE orxU32 orxMath_GetNextPowerOfTwo(orxU32 _u32Value)
{
  orxU32 u32Result;

  /* Non-zero? */
  if(_u32Value != 0)
  {
    /* Updates result */
    u32Result = _u32Value - 1;
    u32Result = u32Result | (u32Result >> 1);
    u32Result = u32Result | (u32Result >> 2);
    u32Result = u32Result | (u32Result >> 4);
    u32Result = u32Result | (u32Result >> 8);
    u32Result = u32Result | (u32Result >> 16);
    u32Result++;
  }
  else
  {
    /* Updates result */
    u32Result = 1;
  }
  
  /* Done! */
  return u32Result;
}


/*** Math Definitions ***/

#define orxMATH_KF_SQRT_2         orx2F(1.414213562f)           
#define orxMATH_KF_EPSILON        orx2F(0.0001f)                
#define orxMATH_KF_2_PI           orx2F(6.283185307f)           
#define orxMATH_KF_PI             orx2F(3.141592654f)           
#define orxMATH_KF_PI_BY_2        orx2F(1.570796327f)           
#define orxMATH_KF_PI_BY_4        orx2F(0.785398163f)           
#define orxMATH_KF_DEG_TO_RAD     orx2F(3.141592654f / 180.0f)  
#define orxMATH_KF_RAD_TO_DEG     orx2F(180.0f / 3.141592654f)  
/*** Trigonometric function ***/

static orxINLINE orxFLOAT    orxMath_Cos(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = cosf(_fOp);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = cosf(_fOp);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Sin(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = sinf(_fOp);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = sinf(_fOp);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Tan(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = tanf(_fOp);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = tanf(_fOp);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_ACos(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = acosf(_fOp);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = acosf(_fOp);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_ASin(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = asinf(_fOp);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = asinf(_fOp);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_ATan(orxFLOAT _fOp1, orxFLOAT _fOp2)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = atan2f(_fOp1, _fOp2);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = atan2f(_fOp1, _fOp2);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}


/*** Misc functions ***/

static orxINLINE orxFLOAT    orxMath_Sqrt(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

  /* Updates result */
  fResult = sqrtf(_fOp);

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Floor(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = floorf(_fOp);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = floor(_fOp);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Ceil(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

  /* Updates result */
  fResult = ceilf(_fOp);

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Round(orxFLOAT _fOp)
{
  register orxFLOAT fResult;

#ifdef __orxMSVC__

  /* Updates result */
  fResult = (fmodf(_fOp, orxFLOAT_1) >= orx2F(0.5f)) ? ceilf(_fOp) : floorf(_fOp);

#else /* __orxMSVC__ */

  /* Updates result */
  fResult = rintf(_fOp);

#endif /* __orxMSVC__ */

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Mod(orxFLOAT _fOp1, orxFLOAT _fOp2)
{
  register orxFLOAT fResult;

  /* Updates result */
  fResult = fmodf(_fOp1, _fOp2);

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Pow(orxFLOAT _fOp, orxFLOAT _fExp)
{
  register orxFLOAT fResult;

  /* Updates result */
  fResult = powf(_fOp, _fExp);

  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT    orxMath_Abs(orxFLOAT _fOp)
{
  /* Done! */
  return fabsf(_fOp);
}

#endif /* _orxMATH_H_ */