orxMath.h

Go to the documentation of this file.

/* Orx - Portable Game Engine
 *
 * Copyright (c) 2008- 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 "debug/orxDebug.h"

#include <math.h>
#ifdef __orxMSVC__
  #include <intrin.h>
#endif /* __orxMSVC__ */
 


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

#define orxREMAP(A1, B1, A2, B2, V) (((V) - (A1)) / ((B1) - (A1)) * ((B2) - (A2)) + (A2))

#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 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(orxU32 _u32Seed);

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

extern orxDLLAPI orxFLOAT orxFASTCALL orxMath_GetSteppedRandomFloat(orxFLOAT _fMin, orxFLOAT _fMax, orxFLOAT _fStep);

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

extern orxDLLAPI orxU32 orxFASTCALL   orxMath_GetSteppedRandomU32(orxU32 _u32Min, orxU32 _u32Max, orxU32 _u32Step);

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

extern orxDLLAPI orxS32 orxFASTCALL   orxMath_GetSteppedRandomS32(orxS32 _s32Min, orxS32 _s32Max, orxS32 _s32Step);

extern orxDLLAPI orxU64 orxFASTCALL   orxMath_GetRandomU64(orxU64 _u64Min, orxU64 _u64Max);

extern orxDLLAPI orxU64 orxFASTCALL   orxMath_GetSteppedRandomU64(orxU64 _u64Min, orxU64 _u64Max, orxU64 _u64Step);

extern orxDLLAPI orxS64 orxFASTCALL   orxMath_GetRandomS64(orxS64 _s64Min, orxS64 _s64Max);

extern orxDLLAPI orxS64 orxFASTCALL   orxMath_GetSteppedRandomS64(orxS64 _s64Min, orxS64 _s64Max, orxS64 _s64Step);

extern orxDLLAPI void orxFASTCALL     orxMath_GetRandomSeeds(orxU32 _au32Seeds[4]);

extern orxDLLAPI void orxFASTCALL     orxMath_SetRandomSeeds(const orxU32 _au32Seeds[4]);
 
 
/*** Inlined functions *** */

static orxINLINE orxU32               orxMath_GetBitCount(orxU32 _u32Value)
{
  orxU32 u32Result;
 
#ifdef __orxMSVC__
 
  /* Uses intrinsic */
  u32Result = __popcnt(_u32Value);
 
#else /* __orxMSVC__ */
 
  /* Uses intrinsic */
  u32Result = (orxU32)__builtin_popcount(_u32Value);
 
#endif /* __orxMSVC__ */
 
  /* Done! */
  return u32Result;
}

static orxINLINE orxU32               orxMath_GetTrailingZeroCount(orxU32 _u32Value)
{
  orxU32 u32Result;
 
  /* Checks */
  orxASSERT(_u32Value != 0);
 
#ifdef __orxMSVC__
 
  /* Uses intrinsic */
  _BitScanForward((unsigned long *)&u32Result, _u32Value);
 
#else /* __orxMSVC__ */
 
  /* Uses intrinsic */
  u32Result = (orxU32)__builtin_ctz(_u32Value);
 
#endif /* __orxMSVC__ */
 
  /* Done! */
  return u32Result;
}

static orxINLINE orxU32               orxMath_GetTrailingZeroCount64(orxU64 _u64Value)
{
  orxU32 u32Result;
 
  /* Checks */
  orxASSERT(_u64Value != 0);
 
#ifdef __orxMSVC__
 
  #ifdef __orx64__
 
  /* Uses intrinsic */
  _BitScanForward64((unsigned long *)&u32Result, _u64Value);
 
  #else /* __orx64__ */
 
  /* Updates result */
  u32Result = ((_u64Value & 0xFFFFFFFFULL) == 0) ? orxMath_GetTrailingZeroCount((orxU32)(_u64Value >> 32)) + 32 : orxMath_GetTrailingZeroCount((orxU32)_u64Value);
 
  #endif /* __orx64__ */
 
#else /* __orxMSVC__ */
 
  /* Uses intrinsic */
  u32Result = (orxU32)__builtin_ctzll(_u64Value);
 
#endif /* __orxMSVC__ */
 
  /* Done! */
  return u32Result;
}

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

static orxINLINE orxFLOAT             orxMath_SmoothStep(orxFLOAT _fMin, orxFLOAT _fMax, orxFLOAT _fValue)
{
  orxFLOAT fTemp, fResult;
 
  /* Gets normalized and clamped value */
  fTemp = (_fValue - _fMin) / (_fMax - _fMin);
  fTemp = orxCLAMP(fTemp, orxFLOAT_0, orxFLOAT_1);
 
  /* Gets smoothed result */
  fResult = fTemp * fTemp * (orx2F(3.0f) - (orx2F(2.0f) * fTemp));
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_SmootherStep(orxFLOAT _fMin, orxFLOAT _fMax, orxFLOAT _fValue)
{
  orxFLOAT fTemp, fResult;
 
  /* Gets normalized and clamped value */
  fTemp = (_fValue - _fMin) / (_fMax - _fMin);
  fTemp = orxCLAMP(fTemp, orxFLOAT_0, orxFLOAT_1);
 
  /* Gets smoothed result */
  fResult = fTemp * fTemp * fTemp * (fTemp * ((fTemp * orx2F(6.0f)) - orx2F(15.0f)) + orx2F(10.0f));
 
  /* Done! */
  return fResult;
}
 
 
/*** Math Definitions ***/
 
#define orxMATH_KF_SQRT_2             orx2F(1.414213562f)           
#define orxMATH_KF_EPSILON            orx2F(0.0001f)                
#define orxMATH_KF_TINY_EPSILON       orx2F(1.0e-037f)              
#define orxMATH_KF_MAX                orx2F(3.402823466e+38F)       
#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_Sin(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = sinf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Cos(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = cosf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Tan(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = tanf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_ACos(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = acosf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_ASin(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = asinf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_ATan(orxFLOAT _fOp1, orxFLOAT _fOp2)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = atan2f(_fOp1, _fOp2);
 
  /* Done! */
  return fResult;
}
 
 
/*** Misc functions ***/

static orxINLINE orxFLOAT             orxMath_Sqrt(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = sqrtf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Floor(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = floorf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Ceil(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = ceilf(_fOp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Round(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
#ifdef __orxMSVC__
 
  /* Updates result */
  fResult = floorf(_fOp + orx2F(0.5f));
 
#else /* __orxMSVC__ */
 
  /* Updates result */
  fResult = rintf(_fOp);
 
#endif /* __orxMSVC__ */
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Mod(orxFLOAT _fOp1, orxFLOAT _fOp2)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = fmodf(_fOp1, _fOp2);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Pow(orxFLOAT _fOp, orxFLOAT _fExp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = powf(_fOp, _fExp);
 
  /* Done! */
  return fResult;
}

static orxINLINE orxFLOAT             orxMath_Abs(orxFLOAT _fOp)
{
  orxFLOAT fResult;
 
  /* Updates result */
  fResult = fabsf(_fOp);
 
  /* Done! */
  return fResult;
}
 
#endif /* _orxMATH_H_ */