Irrlicht 3D Engine: irrMath.h Source File

| Irrlicht 3D Engine |

irrMath.h
Go to the documentation of this file.

    00001 // Copyright (C) 2002-2012 Nikolaus Gebhardt
    00002 // This file is part of the "Irrlicht Engine".
    00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
    00004
    00005 #ifndef __IRR_MATH_H_INCLUDED__
    00006 #define __IRR_MATH_H_INCLUDED__
    00007
    00008 #include "IrrCompileConfig.h"
    00009 #include "irrTypes.h"
    00010 #include <math.h>
    00011 #include <float.h>
    00012 #include <stdlib.h> // for abs() etc.
    00013 #include <limits.h> // For INT_MAX / UINT_MAX
    00014
    00015 #if defined(_IRR_SOLARIS_PLATFORM_) || defined(__BORLANDC__) || defined (__BCPLUSPLUS__) || defined (_WIN32_WCE)
    00016     #define sqrtf(X) (irr::f32)sqrt((irr::f64)(X))
    00017     #define sinf(X) (irr::f32)sin((irr::f64)(X))
    00018     #define cosf(X) (irr::f32)cos((irr::f64)(X))
    00019     #define asinf(X) (irr::f32)asin((irr::f64)(X))
    00020     #define acosf(X) (irr::f32)acos((irr::f64)(X))
    00021     #define atan2f(X,Y) (irr::f32)atan2((irr::f64)(X),(irr::f64)(Y))
    00022     #define ceilf(X) (irr::f32)ceil((irr::f64)(X))
    00023     #define floorf(X) (irr::f32)floor((irr::f64)(X))
    00024     #define powf(X,Y) (irr::f32)pow((irr::f64)(X),(irr::f64)(Y))
    00025     #define fmodf(X,Y) (irr::f32)fmod((irr::f64)(X),(irr::f64)(Y))
    00026     #define fabsf(X) (irr::f32)fabs((irr::f64)(X))
    00027     #define logf(X) (irr::f32)log((irr::f64)(X))
    00028 #endif
    00029
    00030 #ifndef FLT_MAX
    00031 #define FLT_MAX 3.402823466E+38F
    00032 #endif
    00033
    00034 #ifndef FLT_MIN
    00035 #define FLT_MIN 1.17549435e-38F
    00036 #endif
    00037
    00038 namespace irr
    00039 {
    00040 namespace core
    00041 {
    00042
    00044
    00045     const s32 ROUNDING_ERROR_S32 = 0;
    00046 #ifdef __IRR_HAS_S64
    00047     const s64 ROUNDING_ERROR_S64 = 0;
    00048 #endif
    00049     const f32 ROUNDING_ERROR_f32 = 0.000001f;
    00050     const f64 ROUNDING_ERROR_f64 = 0.00000001;
    00051
    00052 #ifdef PI // make sure we don't collide with a define
    00053 #undef PI
    00054 #endif
    00055
    00056     const f32 PI        = 3.14159265359f;
    00057
    00059     const f32 RECIPROCAL_PI = 1.0f/PI;
    00060
    00062     const f32 HALF_PI   = PI/2.0f;
    00063
    00064 #ifdef PI64 // make sure we don't collide with a define
    00065 #undef PI64
    00066 #endif
    00067
    00068     const f64 PI64      = 3.1415926535897932384626433832795028841971693993751;
    00069
    00071     const f64 RECIPROCAL_PI64 = 1.0/PI64;
    00072
    00074     const f32 DEGTORAD = PI / 180.0f;
    00075
    00077     const f32 RADTODEG   = 180.0f / PI;
    00078
    00080     const f64 DEGTORAD64 = PI64 / 180.0;
    00081
    00083     const f64 RADTODEG64 = 180.0 / PI64;
    00084
    00086
    00089     inline f32 radToDeg(f32 radians)
    00090     {
    00091         return RADTODEG * radians;
    00092     }
    00093
    00095
    00098     inline f64 radToDeg(f64 radians)
    00099     {
    00100         return RADTODEG64 * radians;
    00101     }
    00102
    00104
    00107     inline f32 degToRad(f32 degrees)
    00108     {
    00109         return DEGTORAD * degrees;
    00110     }
    00111
    00113
    00116     inline f64 degToRad(f64 degrees)
    00117     {
    00118         return DEGTORAD64 * degrees;
    00119     }
    00120
    00122     template<class T>
    00123     inline const T& min_(const T& a, const T& b)
    00124     {
    00125         return a < b ? a : b;
    00126     }
    00127
    00129     template<class T>
    00130     inline const T& min_(const T& a, const T& b, const T& c)
    00131     {
    00132         return a < b ? min_(a, c) : min_(b, c);
    00133     }
    00134
    00136     template<class T>
    00137     inline const T& max_(const T& a, const T& b)
    00138     {
    00139         return a < b ? b : a;
    00140     }
    00141
    00143     template<class T>
    00144     inline const T& max_(const T& a, const T& b, const T& c)
    00145     {
    00146         return a < b ? max_(b, c) : max_(a, c);
    00147     }
    00148
    00150     template<class T>
    00151     inline T abs_(const T& a)
    00152     {
    00153         return a < (T)0 ? -a : a;
    00154     }
    00155
    00158     template<class T>
    00159     inline T lerp(const T& a, const T& b, const f32 t)
    00160     {
    00161         return (T)(a*(1.f-t)) + (b*t);
    00162     }
    00163
    00165     template <class T>
    00166     inline const T clamp (const T& value, const T& low, const T& high)
    00167     {
    00168         return min_ (max_(value,low), high);
    00169     }
    00170
    00172     // Note: We use the same trick as boost and use two template arguments to
    00173     // avoid ambiguity when swapping objects of an Irrlicht type that has not
    00174     // it's own swap overload. Otherwise we get conflicts with some compilers
    00175     // in combination with stl.
    00176     template <class T1, class T2>
    00177     inline void swap(T1& a, T2& b)
    00178     {
    00179         T1 c(a);
    00180         a = b;
    00181         b = c;
    00182     }
    00183
    00185     inline bool equals(const f64 a, const f64 b, const f64 tolerance = ROUNDING_ERROR_f64)
    00186     {
    00187         return (a + tolerance >= b) && (a - tolerance <= b);
    00188     }
    00189
    00191     inline bool equals(const f32 a, const f32 b, const f32 tolerance = ROUNDING_ERROR_f32)
    00192     {
    00193         return (a + tolerance >= b) && (a - tolerance <= b);
    00194     }
    00195
    00196     union FloatIntUnion32
    00197     {
    00198         FloatIntUnion32(float f1 = 0.0f) : f(f1) {}
    00199         // Portable sign-extraction
    00200         bool sign() const { return (i >> 31) != 0; }
    00201
    00202         irr::s32 i;
    00203         irr::f32 f;
    00204     };
    00205
    00207     //\result true when numbers have a ULP <= maxUlpDiff AND have the same sign.
    00208     inline bool equalsByUlp(f32 a, f32 b, int maxUlpDiff)
    00209     {
    00210         // Based on the ideas and code from Bruce Dawson on
    00211         // http://www.altdevblogaday.com/2012/02/22/comparing-floating-point-numbers-2012-edition/
    00212         // When floats are interpreted as integers the two nearest possible float numbers differ just
    00213         // by one integer number. Also works the other way round, an integer of 1 interpreted as float
    00214         // is for example the smallest possible float number.
    00215
    00216         FloatIntUnion32 fa(a);
    00217         FloatIntUnion32 fb(b);
    00218
    00219         // Different signs, we could maybe get difference to 0, but so close to 0 using epsilons is better.
    00220         if ( fa.sign() != fb.sign() )
    00221         {
    00222             // Check for equality to make sure +0==-0
    00223             if (fa.i == fb.i)
    00224                 return true;
    00225             return false;
    00226         }
    00227
    00228         // Find the difference in ULPs.
    00229         int ulpsDiff = abs_(fa.i- fb.i);
    00230         if (ulpsDiff <= maxUlpDiff)
    00231             return true;
    00232
    00233         return false;
    00234     }
    00235
    00236 #if 0
    00237
    00238     inline bool equals(const s32 a, const s32 b)
    00239     {
    00240         return (a == b);
    00241     }
    00242
    00244     inline bool equals(const u32 a, const u32 b)
    00245     {
    00246         return (a == b);
    00247     }
    00248 #endif
    00249
    00250     inline bool equals(const s32 a, const s32 b, const s32 tolerance = ROUNDING_ERROR_S32)
    00251     {
    00252         return (a + tolerance >= b) && (a - tolerance <= b);
    00253     }
    00254
    00256     inline bool equals(const u32 a, const u32 b, const s32 tolerance = ROUNDING_ERROR_S32)
    00257     {
    00258         return (a + tolerance >= b) && (a - tolerance <= b);
    00259     }
    00260
    00261 #ifdef __IRR_HAS_S64
    00262
    00263     inline bool equals(const s64 a, const s64 b, const s64 tolerance = ROUNDING_ERROR_S64)
    00264     {
    00265         return (a + tolerance >= b) && (a - tolerance <= b);
    00266     }
    00267 #endif
    00268
    00270     inline bool iszero(const f64 a, const f64 tolerance = ROUNDING_ERROR_f64)
    00271     {
    00272         return fabs(a) <= tolerance;
    00273     }
    00274
    00276     inline bool iszero(const f32 a, const f32 tolerance = ROUNDING_ERROR_f32)
    00277     {
    00278         return fabsf(a) <= tolerance;
    00279     }
    00280
    00282     inline bool isnotzero(const f32 a, const f32 tolerance = ROUNDING_ERROR_f32)
    00283     {
    00284         return fabsf(a) > tolerance;
    00285     }
    00286
    00288     inline bool iszero(const s32 a, const s32 tolerance = 0)
    00289     {
    00290         return ( a & 0x7ffffff ) <= tolerance;
    00291     }
    00292
    00294     inline bool iszero(const u32 a, const u32 tolerance = 0)
    00295     {
    00296         return a <= tolerance;
    00297     }
    00298
    00299 #ifdef __IRR_HAS_S64
    00300
    00301     inline bool iszero(const s64 a, const s64 tolerance = 0)
    00302     {
    00303         return abs_(a) <= tolerance;
    00304     }
    00305 #endif
    00306
    00307     inline s32 s32_min(s32 a, s32 b)
    00308     {
    00309         const s32 mask = (a - b) >> 31;
    00310         return (a & mask) | (b & ~mask);
    00311     }
    00312
    00313     inline s32 s32_max(s32 a, s32 b)
    00314     {
    00315         const s32 mask = (a - b) >> 31;
    00316         return (b & mask) | (a & ~mask);
    00317     }
    00318
    00319     inline s32 s32_clamp (s32 value, s32 low, s32 high)
    00320     {
    00321         return s32_min(s32_max(value,low), high);
    00322     }
    00323
    00324     /*
    00325         float IEEE-754 bit represenation
    00326
    00327         0      0x00000000
    00328         1.0    0x3f800000
    00329         0.5    0x3f000000
    00330         3      0x40400000
    00331         +inf   0x7f800000
    00332         -inf   0xff800000
    00333         +NaN   0x7fc00000 or 0x7ff00000
    00334         in general: number = (sign ? -1:1) * 2^(exponent) * 1.(mantissa bits)
    00335     */
    00336
    00337     typedef union { u32 u; s32 s; f32 f; } inttofloat;
    00338
    00339     #define F32_AS_S32(f)       (*((s32 *) &(f)))
    00340     #define F32_AS_U32(f)       (*((u32 *) &(f)))
    00341     #define F32_AS_U32_POINTER(f)   ( ((u32 *) &(f)))
    00342
    00343     #define F32_VALUE_0     0x00000000
    00344     #define F32_VALUE_1     0x3f800000
    00345     #define F32_SIGN_BIT        0x80000000U
    00346     #define F32_EXPON_MANTISSA  0x7FFFFFFFU
    00347
    00350 #ifdef IRRLICHT_FAST_MATH
    00351     #define IR(x)                           ((u32&)(x))
    00352 #else
    00353     inline u32 IR(f32 x) {inttofloat tmp; tmp.f=x; return tmp.u;}
    00354 #endif
    00355
    00357     #define AIR(x)              (IR(x)&0x7fffffff)
    00358
    00360 #ifdef IRRLICHT_FAST_MATH
    00361     #define FR(x)                           ((f32&)(x))
    00362 #else
    00363     inline f32 FR(u32 x) {inttofloat tmp; tmp.u=x; return tmp.f;}
    00364     inline f32 FR(s32 x) {inttofloat tmp; tmp.s=x; return tmp.f;}
    00365 #endif
    00366
    00368     #define IEEE_1_0            0x3f800000
    00369
    00370     #define IEEE_255_0          0x437f0000
    00371
    00372 #ifdef IRRLICHT_FAST_MATH
    00373     #define F32_LOWER_0(f)      (F32_AS_U32(f) >  F32_SIGN_BIT)
    00374     #define F32_LOWER_EQUAL_0(f)    (F32_AS_S32(f) <= F32_VALUE_0)
    00375     #define F32_GREATER_0(f)    (F32_AS_S32(f) >  F32_VALUE_0)
    00376     #define F32_GREATER_EQUAL_0(f)  (F32_AS_U32(f) <= F32_SIGN_BIT)
    00377     #define F32_EQUAL_1(f)      (F32_AS_U32(f) == F32_VALUE_1)
    00378     #define F32_EQUAL_0(f)      ( (F32_AS_U32(f) & F32_EXPON_MANTISSA ) == F32_VALUE_0)
    00379
    00380     // only same sign
    00381     #define F32_A_GREATER_B(a,b)    (F32_AS_S32((a)) > F32_AS_S32((b)))
    00382
    00383 #else
    00384
    00385     #define F32_LOWER_0(n)      ((n) <  0.0f)
    00386     #define F32_LOWER_EQUAL_0(n)    ((n) <= 0.0f)
    00387     #define F32_GREATER_0(n)    ((n) >  0.0f)
    00388     #define F32_GREATER_EQUAL_0(n)  ((n) >= 0.0f)
    00389     #define F32_EQUAL_1(n)      ((n) == 1.0f)
    00390     #define F32_EQUAL_0(n)      ((n) == 0.0f)
    00391     #define F32_A_GREATER_B(a,b)    ((a) > (b))
    00392 #endif
    00393
    00394
    00395 #ifndef REALINLINE
    00396     #ifdef _MSC_VER
    00397         #define REALINLINE __forceinline
    00398     #else
    00399         #define REALINLINE inline
    00400     #endif
    00401 #endif
    00402
    00403 #if defined(__BORLANDC__) || defined (__BCPLUSPLUS__)
    00404
    00405     // 8-bit bools in borland builder
    00406
    00408     REALINLINE u32 if_c_a_else_b ( const c8 condition, const u32 a, const u32 b )
    00409     {
    00410         return ( ( -condition >> 7 ) & ( a ^ b ) ) ^ b;
    00411     }
    00412
    00414     REALINLINE u32 if_c_a_else_0 ( const c8 condition, const u32 a )
    00415     {
    00416         return ( -condition >> 31 ) & a;
    00417     }
    00418 #else
    00419
    00421     REALINLINE u32 if_c_a_else_b ( const s32 condition, const u32 a, const u32 b )
    00422     {
    00423         return ( ( -condition >> 31 ) & ( a ^ b ) ) ^ b;
    00424     }
    00425
    00427     REALINLINE u16 if_c_a_else_b ( const s16 condition, const u16 a, const u16 b )
    00428     {
    00429         return ( ( -condition >> 15 ) & ( a ^ b ) ) ^ b;
    00430     }
    00431
    00433     REALINLINE u32 if_c_a_else_0 ( const s32 condition, const u32 a )
    00434     {
    00435         return ( -condition >> 31 ) & a;
    00436     }
    00437 #endif
    00438
    00439     /*
    00440         if (condition) state |= m; else state &= ~m;
    00441     */
    00442     REALINLINE void setbit_cond ( u32 &state, s32 condition, u32 mask )
    00443     {
    00444         // 0, or any postive to mask
    00445         //s32 conmask = -condition >> 31;
    00446         state ^= ( ( -condition >> 31 ) ^ state ) & mask;
    00447     }
    00448
    00449     inline f32 round_( f32 x )
    00450     {
    00451         return floorf( x + 0.5f );
    00452     }
    00453
    00454     REALINLINE void clearFPUException ()
    00455     {
    00456 #ifdef IRRLICHT_FAST_MATH
    00457         return;
    00458 #ifdef feclearexcept
    00459         feclearexcept(FE_ALL_EXCEPT);
    00460 #elif defined(_MSC_VER)
    00461         __asm fnclex;
    00462 #elif defined(__GNUC__) && defined(__x86__)
    00463         __asm__ __volatile__ ("fclex \n\t");
    00464 #else
    00465 #  warn clearFPUException not supported.
    00466 #endif
    00467 #endif
    00468     }
    00469
    00470     // calculate: sqrt ( x )
    00471     REALINLINE f32 squareroot(const f32 f)
    00472     {
    00473         return sqrtf(f);
    00474     }
    00475
    00476     // calculate: sqrt ( x )
    00477     REALINLINE f64 squareroot(const f64 f)
    00478     {
    00479         return sqrt(f);
    00480     }
    00481
    00482     // calculate: sqrt ( x )
    00483     REALINLINE s32 squareroot(const s32 f)
    00484     {
    00485         return static_cast<s32>(squareroot(static_cast<f32>(f)));
    00486     }
    00487
    00488 #ifdef __IRR_HAS_S64
    00489     // calculate: sqrt ( x )
    00490     REALINLINE s64 squareroot(const s64 f)
    00491     {
    00492         return static_cast<s64>(squareroot(static_cast<f64>(f)));
    00493     }
    00494 #endif
    00495
    00496     // calculate: 1 / sqrt ( x )
    00497     REALINLINE f64 reciprocal_squareroot(const f64 x)
    00498     {
    00499         return 1.0 / sqrt(x);
    00500     }
    00501
    00502     // calculate: 1 / sqrtf ( x )
    00503     REALINLINE f32 reciprocal_squareroot(const f32 f)
    00504     {
    00505 #if defined ( IRRLICHT_FAST_MATH )
    00506     #if defined(_MSC_VER)
    00507         // SSE reciprocal square root estimate, accurate to 12 significant
    00508         // bits of the mantissa
    00509         f32 recsqrt;
    00510         __asm rsqrtss xmm0, f           // xmm0 = rsqrtss(f)
    00511         __asm movss recsqrt, xmm0       // return xmm0
    00512         return recsqrt;
    00513
    00514 /*
    00515         // comes from Nvidia
    00516         u32 tmp = (u32(IEEE_1_0 << 1) + IEEE_1_0 - *(u32*)&x) >> 1;
    00517         f32 y = *(f32*)&tmp;
    00518         return y * (1.47f - 0.47f * x * y * y);
    00519 */
    00520     #else
    00521         return 1.f / sqrtf(f);
    00522     #endif
    00523 #else // no fast math
    00524         return 1.f / sqrtf(f);
    00525 #endif
    00526     }
    00527
    00528     // calculate: 1 / sqrtf( x )
    00529     REALINLINE s32 reciprocal_squareroot(const s32 x)
    00530     {
    00531         return static_cast<s32>(reciprocal_squareroot(static_cast<f32>(x)));
    00532     }
    00533
    00534     // calculate: 1 / x
    00535     REALINLINE f32 reciprocal( const f32 f )
    00536     {
    00537 #if defined (IRRLICHT_FAST_MATH)
    00538
    00539         // SSE Newton-Raphson reciprocal estimate, accurate to 23 significant
    00540         // bi ts of the mantissa
    00541         // One Newtown-Raphson Iteration:
    00542         // f(i+1) = 2 * rcpss(f) - f * rcpss(f) * rcpss(f)
    00543         f32 rec;
    00544         __asm rcpss xmm0, f               // xmm0 = rcpss(f)
    00545         __asm movss xmm1, f               // xmm1 = f
    00546         __asm mulss xmm1, xmm0            // xmm1 = f * rcpss(f)
    00547         __asm mulss xmm1, xmm0            // xmm2 = f * rcpss(f) * rcpss(f)
    00548         __asm addss xmm0, xmm0            // xmm0 = 2 * rcpss(f)
    00549         __asm subss xmm0, xmm1            // xmm0 = 2 * rcpss(f)
    00550                                           //        - f * rcpss(f) * rcpss(f)
    00551         __asm movss rec, xmm0             // return xmm0
    00552         return rec;
    00553
    00554
    00556         // instead set f to a high value to get a return value near zero..
    00557         // -1000000000000.f.. is use minus to stay negative..
    00558         // must test's here (plane.normal dot anything ) checks on <= 0.f
    00559         //u32 x = (-(AIR(f) != 0 ) >> 31 ) & ( IR(f) ^ 0xd368d4a5 ) ^ 0xd368d4a5;
    00560         //return 1.f / FR ( x );
    00561
    00562 #else // no fast math
    00563         return 1.f / f;
    00564 #endif
    00565     }
    00566
    00567     // calculate: 1 / x
    00568     REALINLINE f64 reciprocal ( const f64 f )
    00569     {
    00570         return 1.0 / f;
    00571     }
    00572
    00573
    00574     // calculate: 1 / x, low precision allowed
    00575     REALINLINE f32 reciprocal_approxim ( const f32 f )
    00576     {
    00577 #if defined( IRRLICHT_FAST_MATH)
    00578
    00579         // SSE Newton-Raphson reciprocal estimate, accurate to 23 significant
    00580         // bi ts of the mantissa
    00581         // One Newtown-Raphson Iteration:
    00582         // f(i+1) = 2 * rcpss(f) - f * rcpss(f) * rcpss(f)
    00583         f32 rec;
    00584         __asm rcpss xmm0, f               // xmm0 = rcpss(f)
    00585         __asm movss xmm1, f               // xmm1 = f
    00586         __asm mulss xmm1, xmm0            // xmm1 = f * rcpss(f)
    00587         __asm mulss xmm1, xmm0            // xmm2 = f * rcpss(f) * rcpss(f)
    00588         __asm addss xmm0, xmm0            // xmm0 = 2 * rcpss(f)
    00589         __asm subss xmm0, xmm1            // xmm0 = 2 * rcpss(f)
    00590                                           //        - f * rcpss(f) * rcpss(f)
    00591         __asm movss rec, xmm0             // return xmm0
    00592         return rec;
    00593
    00594
    00595 /*
    00596         // SSE reciprocal estimate, accurate to 12 significant bits of
    00597         f32 rec;
    00598         __asm rcpss xmm0, f             // xmm0 = rcpss(f)
    00599         __asm movss rec , xmm0          // return xmm0
    00600         return rec;
    00601 */
    00602 /*
    00603         register u32 x = 0x7F000000 - IR ( p );
    00604         const f32 r = FR ( x );
    00605         return r * (2.0f - p * r);
    00606 */
    00607 #else // no fast math
    00608         return 1.f / f;
    00609 #endif
    00610     }
    00611
    00612
    00613     REALINLINE s32 floor32(f32 x)
    00614     {
    00615 #ifdef IRRLICHT_FAST_MATH
    00616         const f32 h = 0.5f;
    00617
    00618         s32 t;
    00619
    00620 #if defined(_MSC_VER)
    00621         __asm
    00622         {
    00623             fld x
    00624             fsub    h
    00625             fistp   t
    00626         }
    00627 #elif defined(__GNUC__)
    00628         __asm__ __volatile__ (
    00629             "fsub %2 \n\t"
    00630             "fistpl %0"
    00631             : "=m" (t)
    00632             : "t" (x), "f" (h)
    00633             : "st"
    00634             );
    00635 #else
    00636 #  warn IRRLICHT_FAST_MATH not supported.
    00637         return (s32) floorf ( x );
    00638 #endif
    00639         return t;
    00640 #else // no fast math
    00641         return (s32) floorf ( x );
    00642 #endif
    00643     }
    00644
    00645
    00646     REALINLINE s32 ceil32 ( f32 x )
    00647     {
    00648 #ifdef IRRLICHT_FAST_MATH
    00649         const f32 h = 0.5f;
    00650
    00651         s32 t;
    00652
    00653 #if defined(_MSC_VER)
    00654         __asm
    00655         {
    00656             fld x
    00657             fadd    h
    00658             fistp   t
    00659         }
    00660 #elif defined(__GNUC__)
    00661         __asm__ __volatile__ (
    00662             "fadd %2 \n\t"
    00663             "fistpl %0 \n\t"
    00664             : "=m"(t)
    00665             : "t"(x), "f"(h)
    00666             : "st"
    00667             );
    00668 #else
    00669 #  warn IRRLICHT_FAST_MATH not supported.
    00670         return (s32) ceilf ( x );
    00671 #endif
    00672         return t;
    00673 #else // not fast math
    00674         return (s32) ceilf ( x );
    00675 #endif
    00676     }
    00677
    00678
    00679
    00680     REALINLINE s32 round32(f32 x)
    00681     {
    00682 #if defined(IRRLICHT_FAST_MATH)
    00683         s32 t;
    00684
    00685 #if defined(_MSC_VER)
    00686         __asm
    00687         {
    00688             fld   x
    00689             fistp t
    00690         }
    00691 #elif defined(__GNUC__)
    00692         __asm__ __volatile__ (
    00693             "fistpl %0 \n\t"
    00694             : "=m"(t)
    00695             : "t"(x)
    00696             : "st"
    00697             );
    00698 #else
    00699 #  warn IRRLICHT_FAST_MATH not supported.
    00700         return (s32) round_(x);
    00701 #endif
    00702         return t;
    00703 #else // no fast math
    00704         return (s32) round_(x);
    00705 #endif
    00706     }
    00707
    00708     inline f32 f32_max3(const f32 a, const f32 b, const f32 c)
    00709     {
    00710         return a > b ? (a > c ? a : c) : (b > c ? b : c);
    00711     }
    00712
    00713     inline f32 f32_min3(const f32 a, const f32 b, const f32 c)
    00714     {
    00715         return a < b ? (a < c ? a : c) : (b < c ? b : c);
    00716     }
    00717
    00718     inline f32 fract ( f32 x )
    00719     {
    00720         return x - floorf ( x );
    00721     }
    00722
    00723 } // end namespace core
    00724 } // end namespace irr
    00725
    00726 #ifndef IRRLICHT_FAST_MATH
    00727     using irr::core::IR;
    00728     using irr::core::FR;
    00729 #endif
    00730
    00731 #endif
    00732