Main Page Modules C++ Classes Compound List File List Index Related Pages What is the Nebula Device? Features Downloads License Contact Us Blogroll enlight's blog Floh's Blog Documentation FAQ Getting Started Script Docs Links forums Bugs Nebula2 on Sourceforge Radon Labs Categories News Images changes Search Archives September 2008 July 2008 May 2008 April 2007 March 2007 August 2006 June 2006 March 2006 October 2005 August 2005 July 2005 Meta Login RSS Comments RSS nmath.h Go to the documentation of this file. #ifndef N_MATH_H #define N_MATH_H //------------------------------------------------------------------------------ #include <math.h> #include <stdlib.h> #include "kernel/ntypes.h" #ifdef _MSC_VER #define isnan _isnan #define isinf _isinf #endif #ifndef PI #define PI (3.1415926535897932384626433832795028841971693993751f) #endif #define N_PI PI #ifndef TINY #define TINY (0.0000001f) #endif #define N_TINY TINY #define n_max(a,b) (((a) > (b)) ? (a) : (b)) #define n_min(a,b) (((a) < (b)) ? (a) : (b)) #define n_abs(a) (((a)<0.0f) ? (-(a)) : (a)) #define n_sgn(a) (((a)<0.0f) ? (-1) : (1)) #define n_deg2rad(d) (((d)*PI)/180.0f) #define n_rad2deg(r) (((r)*180.0f)/PI) #define n_sin(x) (float(sin(x))) #define n_cos(x) (float(cos(x))) #define n_tan(x) (float(tan(x))) #define n_atan(x) (float(atan(x))) #define n_atan2(x,y) (float(atan2(x,y))) #define n_exp(x) (float(exp(x))) #define n_floor(x) (float(floor(x))) #define n_ceil(x) (float(ceil(x))) #define n_pow(x,y) (float(pow(x,y))) //------------------------------------------------------------------------------ const float LN_2 = 0.693147180559945f; inline float n_log2(float f) { return logf(f) / LN_2; } //------------------------------------------------------------------------------ inline int n_iclamp(int val, int minVal, int maxVal) { if (val < minVal) return minVal; else if (val > maxVal) return maxVal; else return val; } //------------------------------------------------------------------------------ inline float n_acos(float x) { if (x > 1.0f) x = 1.0f; if (x < -1.0f) x = -1.0f; return (float)acos(x); } //------------------------------------------------------------------------------ inline float n_asin(float x) { if (x > 1.0f) x = 1.0f; if (x < -1.0f) x = -1.0f; return (float)asin(x); } //------------------------------------------------------------------------------ inline float n_sqrt(float x) { if (x < 0.0f) x = (float) 0.0f; return (float) sqrt(x); } //------------------------------------------------------------------------------ inline bool n_fequal(float f0, float f1, float tol) { float f = f0-f1; if ((f>(-tol)) && (f<tol)) return true; else return false; } //------------------------------------------------------------------------------ inline bool n_fless(float f0, float f1, float tol) { if ((f0-f1)<tol) return true; else return false; } //------------------------------------------------------------------------------ inline bool n_fgreater(float f0, float f1, float tol) { if ((f0-f1)>tol) return true; else return false; } //------------------------------------------------------------------------------ inline long n_ftol(float val) { double v = double(val) + (68719476736.0*1.5); return ((long*)&v)[0] >> 16; } //------------------------------------------------------------------------------ inline float n_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; } //------------------------------------------------------------------------------ inline float n_clamp(float val, float lower, float upper) { if (val < lower) return lower; else if (val > upper) return upper; else return val; } //------------------------------------------------------------------------------ inline float n_saturate(float val) { if (val < 0.0f) return 0.0f; else if (val > 1.0f) return 1.0f; else return val; } //------------------------------------------------------------------------------ inline float n_rand() { return float(rand()) / float(RAND_MAX); } //------------------------------------------------------------------------------ inline float n_rand(float min, float max) { float unit = float(rand()) / RAND_MAX; float diff = max - min; return min + unit * diff; } //------------------------------------------------------------------------------ inline int n_fchop(float f) { // FIXME! return int(f); } //------------------------------------------------------------------------------ inline int n_frnd(float f) { return n_fchop(floorf(f + 0.5f)); } //------------------------------------------------------------------------------ inline float n_lerp(float x, float y, float l) { return x + l * (y - x); } //------------------------------------------------------------------------------ inline float n_fmod(float x, float y) { return fmodf(x, y); } //------------------------------------------------------------------------------ template<class TYPE> inline void lerp(TYPE & result, const TYPE & val0, const TYPE & val1, float lerpVal) { n_error("Unimplemented lerp function!"); } //------------------------------------------------------------------------------ template<> inline void lerp<int>(int & result, const int & val0, const int & val1, float lerpVal) { result = n_frnd((float)val0 + (((float)val1 - (float)val0) * lerpVal)); } //------------------------------------------------------------------------------ template<> inline void lerp<float>(float & result, const float & val0, const float & val1, float lerpVal) { result = val0 + ((val1 - val0) * lerpVal); } //------------------------------------------------------------------------------ inline float n_normangle(float a) { while (a < 0.0f) { a += n_deg2rad(360.0f); } if (a >= n_deg2rad(360.0f)) { a = n_fmod(a, n_deg2rad(360.0f)); } return a; } //------------------------------------------------------------------------------ inline float n_angulardistance(float from, float to) { float normFrom = n_normangle(from); float normTo = n_normangle(to); float dist = normTo - normFrom; if (dist < n_deg2rad(-180.0f)) { dist += n_deg2rad(360.0f); } else if (dist > n_deg2rad(180.0f)) { dist -= n_deg2rad(360.0f); } return dist; } //------------------------------------------------------------------------------ #endif Nebula Device 2 documentation generated by doxygen at Sun Apr 8 20:04:55 2007