glmath.h

00001 /*
00002 Copyright (c) 2000-2003 Lee Thomason (www.grinninglizard.com)
00003 Grinning Lizard Utilities.
00004 
00005 This software is provided 'as-is', without any express or implied 
00006 warranty. In no event will the authors be held liable for any 
00007 damages arising from the use of this software.
00008 
00009 Permission is granted to anyone to use this software for any 
00010 purpose, including commercial applications, and to alter it and 
00011 redistribute it freely, subject to the following restrictions:
00012 
00013 1. The origin of this software must not be misrepresented; you must 
00014 not claim that you wrote the original software. If you use this 
00015 software in a product, an acknowledgment in the product documentation 
00016 would be appreciated but is not required.
00017 
00018 2. Altered source versions must be plainly marked as such, and 
00019 must not be misrepresented as being the original software.
00020 
00021 3. This notice may not be removed or altered from any source 
00022 distribution.
00023 */
00024 
00025 
00026 #ifndef GRINLIZ_MATH_INCLUDED
00027 #define GRINLIZ_MATH_INCLUDED
00028 
00029 #include "glutil.h"
00030 
00031 namespace grinliz
00032 {
00033 const float  PI = 3.1415926535897932384626433832795f;
00034 const double PI_D = 3.1415926535897932384626433832795;
00035 
00036 const float RAD_TO_DEG = (float)( 360.0 / ( 2.0 * PI ) );
00037 const float DEG_TO_RAD = (float)( ( 2.0 * PI ) / 360.0 );
00038 const float SQRT2 = 1.4142135623730950488016887242097f;
00039 const float SQRT2OVER2 = float( 1.4142135623730950488016887242097 / 2.0 );
00040 
00041 inline float ToDegree( float radian ) { return radian * RAD_TO_DEG; }
00042 inline float ToRadian( float degree ) { return degree * DEG_TO_RAD; }
00043 
00044 void SinCosDegree( float degreeTheta, float* sinTheta, float* cosTheta );
00045 
00046 const float EPSILON = 0.000001f;
00047 
00048 inline float NormalizeAngleDegrees( float alpha ) {
00049         while ( alpha < 0.0f )
00050                 alpha += 360.0f;
00051         while ( alpha >= 360.0f )
00052                 alpha -= 360.0f;
00053         return alpha;
00054 }
00055 
00057 inline bool Equal( float x, float y, float epsilon )
00058 {
00059         //return fabs( (double)(x - y) ) <= (double)epsilon;
00060         return fabsf( x - y ) <= epsilon;
00061 }
00062 inline bool Equal( double x, double y, double epsilon )
00063 {
00064         return fabs( x - y ) <= epsilon;
00065 }
00066 
00073 void DegDelta( float angle0, float angle1, float* distance, float* bias );
00074 
00076 inline float Length( float x, float y )
00077 {
00078         // It's worth some time here:
00079         //              http://www.azillionmonkeys.com/qed/sqroot.html
00080         // to make this (perhaps) better. 
00081 
00082         // Use the much faster "f" version.
00083         return sqrtf( x*x + y*y );
00084 }
00085 
00086 inline double Length( double x, double y ) 
00087 { 
00088         // The more accurate double version.
00089         return sqrt( x*x + y*y ); 
00090 }
00091 
00093 inline float Length( float x, float y, float z )
00094 {
00095         return sqrtf( x*x + y*y + z*z );
00096 }
00097 
00098 inline double Length( double x, double y, double z ) 
00099 { 
00100         return sqrt( x*x + y*y + z*z ); 
00101 }
00102 
00104 inline float Length( float x, float y, float z, float w )
00105 {
00106         return sqrtf( x*x + y*y + z*z + w*w );
00107 }
00108 
00109 
00111 template <class T> inline T FastLength( T x, T y, T z )
00112 {
00113         float a = (float) fabs( x );
00114         float b = (float) fabs( y );
00115         float c = (float) fabs( z );
00116 
00117         if ( b > a ) Swap( &b, &a );
00118         if ( c > a ) Swap( &c, &a );
00119 
00120         // a, b, and c are now meaningless, but
00121         // a is the max.
00122 
00123         float ret = a + ( b + c ) / 4;
00124         return ret;
00125 }
00126 
00127 
00129 template <class T> inline T FastLength( T x, T y )
00130 {
00131         float a = (float) fabs( x );
00132         float b = (float) fabs( y );
00133 
00134         if ( b > a ) grinliz::Swap( &b, &a );
00135 
00136         // a and b are now meaningless, but
00137         // a is the max.
00138 
00139         float ret = a + b / 4;
00140         return ret;
00141 }
00142 
00144 template <class T> inline T Average( T y0, T y1 )
00145 {
00146         return ( y0 + y1 ) / T( 2 );
00147 }
00148 
00149 
00150 
00151 };      // namespace grinliz
00152 
00153 #endif

Generated on Thu Jul 20 20:45:31 2006 for Kyra by  doxygen 1.4.7