128 lines
4.3 KiB
C++
128 lines
4.3 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include <cmath>
|
|
#include <cfloat>
|
|
#include "math/nmath.h"
|
|
|
|
using namespace GS;
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
Math::rOrder Math::ReverserRotationOrder(rOrder r)
|
|
{
|
|
switch (r)
|
|
{
|
|
case rOrder_ZYX: return rOrder_XYZ;
|
|
case rOrder_YZX: return rOrder_XZY;
|
|
case rOrder_ZXY: return rOrder_YXZ;
|
|
case rOrder_XZY: return rOrder_YZX;
|
|
case rOrder_YXZ: return rOrder_ZXY;
|
|
case rOrder_XYZ: return rOrder_ZYX;
|
|
default: return rOrder_Default;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
float Math::Sqrt(float v)
|
|
{ return sqrtf(v); }
|
|
|
|
float Math::TestEqual(float a, float b, float e)
|
|
{ return Types::Abs(b - a) < e ? true : false; }
|
|
bool Math::EqualZero(float v, float e)
|
|
{ return (v < -e) || (v > e) ? false : true; }
|
|
|
|
float Math::Pow(float v, float e)
|
|
{ return pow(v, e); }
|
|
|
|
float Math::Ceil(float v)
|
|
{ return (v < 0) ? (float)((int)v) : (float)((int)(v + 1)); }
|
|
float Math::Floor(float v)
|
|
{ return (v < 0) ? (float)((int)(v - 1)) : (float)((int)v); }
|
|
float Math::Mod(float v)
|
|
{
|
|
double integral;
|
|
return (float)modf(v, &integral);
|
|
}
|
|
float Math::RangeAdjust(float v, float old_min, float old_max, float new_min, float new_max)
|
|
{ return Types::Clamp((v - old_min) / (old_max - old_min) * (new_max - new_min) + new_min, new_min, new_max); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
bool Math::IsFinite(float v) { return (v <= FLT_MAX && v >= -FLT_MAX); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
#define __USE_LUT_BASED_TRIG__ 0
|
|
|
|
#if (__USE_LUT_BASED_TRIG__ == 0)
|
|
|
|
void Math::Init() {}
|
|
|
|
//------------------------------------------------------------------------------
|
|
float Math::Quantize(float v, float q) { return Floor(v / q) * q; }
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
float Math::Sin(float v) { return sin(v); }
|
|
float Math::ASin(float v) { return asin(Types::Clamp(v, -1.f, 1.f)); }
|
|
float Math::Cos(float v) { return cos(v); }
|
|
float Math::ACos(float v) { return acos(Types::Clamp(v, -1.f, 1.f)); }
|
|
float Math::Tan(float v) { return tan(v); }
|
|
float Math::ATan(float v) { return atan(v); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
#else
|
|
|
|
#include "container/narray.h"
|
|
|
|
// keep as power of 2
|
|
#define __LUT_PRECISION 64
|
|
|
|
static nArray <float> lCos, lSin, lTan, lACos, lASin, lAtan;
|
|
|
|
//------------------------------------------------------------------------------
|
|
void Math::Init()
|
|
{
|
|
lCos.Allocate(__LUT_PRECISION);
|
|
lSin.Allocate(__LUT_PRECISION);
|
|
lTan.Allocate(__LUT_PRECISION);
|
|
lACos.Allocate(__LUT_PRECISION);
|
|
lASin.Allocate(__LUT_PRECISION);
|
|
|
|
for (int v = 0; v < __LUT_PRECISION; ++v)
|
|
{
|
|
const float deg = ((float)v / __LUT_PRECISION) * (Pi * 2.f);
|
|
|
|
lSin[v] = sin(deg);
|
|
lCos[v] = cos(deg);
|
|
lTan[v] = tan(deg);
|
|
|
|
const float inv = ((float)v / __LUT_PRECISION) * 2.f - 1.f;
|
|
|
|
lASin[v] = asin(inv);
|
|
lACos[v] = acos(inv);
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
float Math::Sin(float v)
|
|
{ return lSin[int(v * (__LUT_PRECISION / (Pi * 2.f))) & (__LUT_PRECISION - 1)]; }
|
|
float Math::ASin(float v)
|
|
{ return lASin[int((v + 1.f) * (__LUT_PRECISION / 2)) & (__LUT_PRECISION - 1)]; }
|
|
float Math::Cos(float v)
|
|
{ return lCos[int(v * (__LUT_PRECISION / (Pi * 2.f))) & (__LUT_PRECISION - 1)]; }
|
|
float Math::ACos(float v)
|
|
{ return lACos[int((v + 1.f) * (__LUT_PRECISION / 2)) & (__LUT_PRECISION - 1)]; }
|
|
float Math::Tan(float v)
|
|
{ return lTan[int(v * (__LUT_PRECISION / (Pi * 2.f))) & (__LUT_PRECISION - 1)]; }
|
|
float Math::ATan(float v)
|
|
{ return atan(v); }
|
|
//------------------------------------------------------------------------------
|
|
|
|
#endif
|