233 lines
7.2 KiB
C++
233 lines
7.2 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
|
|
*
|
|
* This library is open source and may be redistributed and/or modified under
|
|
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
|
* (at your option) any later version. The full license is in LICENSE file
|
|
* included with this distribution, and on the openscenegraph.org website.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* OpenSceneGraph Public License for more details.
|
|
*/
|
|
|
|
#ifndef __OSG_MATH
|
|
#define __OSG_MATH
|
|
|
|
#include <math.h>
|
|
|
|
//certain math functions were not defined until 10.2
|
|
//so this code checks the version so it can add in workarounds for older versions.
|
|
#ifdef __APPLE__
|
|
// Using std::isnan will work for OS X, but use of <cmath>
|
|
// and std:: are not necessarily portible with other systems so
|
|
// the include of <cmath> is isolated here.
|
|
#include <cmath>
|
|
#include <AvailabilityMacros.h>
|
|
#if !defined(MAC_OS_X_VERSION_10_2) || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_2)
|
|
// One extra check to verify the gcc version.
|
|
// The assumption is that there is no possible way to use gcc 4+
|
|
// on anything less than 10.3.9. So if gcc 4 is in use, this means
|
|
// pre-10.2 support is not intended and we need not define APPLE_PRE_10_2.
|
|
// The reason for this extra check is that if the user relies on default
|
|
// settings, MAC_OS_X_VERSION_MIN_REQUIRED will be set to 1010 and hit
|
|
// this code path, but this is probably not what they want if using gcc 4+.
|
|
#if (__GNUC__ < 4)
|
|
#define APPLE_PRE_10_2
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(_MSC_VER)
|
|
#include <float.h>
|
|
#endif
|
|
|
|
#if defined (sun) || defined (__APPLE__)
|
|
|
|
#include <float.h>
|
|
|
|
#ifndef acosf
|
|
inline float acosf(float value) { return static_cast<float>(acos(value)); }
|
|
#endif
|
|
|
|
#ifndef asinf
|
|
inline float asinf(float value) { return static_cast<float>(asin(value)); }
|
|
#endif
|
|
|
|
#ifndef cosf
|
|
inline float cosf(float value) { return static_cast<float>(cos(value)); }
|
|
#endif
|
|
|
|
#ifndef sinf
|
|
inline float sinf(float value) { return static_cast<float>(sin(value)); }
|
|
#endif
|
|
|
|
#ifndef logf
|
|
inline float logf(float value) { return static_cast<float>(log(value)); }
|
|
#endif
|
|
|
|
#ifndef powf
|
|
inline float powf(float value1,float value2) { return static_cast<float>(pow(value1,value2)); }
|
|
#endif
|
|
|
|
#ifndef sqrtf
|
|
inline float sqrtf(float value) { return static_cast<float>(sqrt(value)); }
|
|
#endif
|
|
|
|
#ifndef fabsf
|
|
inline float fabsf(float value) { return static_cast<float>(fabs(value)); }
|
|
#endif
|
|
|
|
#ifndef atan2f
|
|
inline float atan2f(float value1, float value2) { return static_cast<float>(atan2(value1,value2)); }
|
|
#endif
|
|
|
|
#ifndef tanf
|
|
inline float tanf(float value) { return static_cast<float>(tan(value)); }
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
#if defined (sun) || \
|
|
defined (__hpux) || \
|
|
defined (APPLE_PRE_10_2)
|
|
|
|
#ifndef floorf
|
|
inline float floorf(float value) { return static_cast<float>(floor(value)); }
|
|
#endif
|
|
|
|
#ifndef ceilf
|
|
inline float ceilf(float value) { return static_cast<float>(ceil(value)); }
|
|
#endif
|
|
|
|
#endif
|
|
|
|
namespace osg {
|
|
|
|
// define the standard trig values
|
|
#ifdef PI
|
|
#undef PI
|
|
#undef PI_2
|
|
#undef PI_4
|
|
#endif
|
|
const double PI = 3.14159265358979323846;
|
|
const double PI_2 = 1.57079632679489661923;
|
|
const double PI_4 = 0.78539816339744830962;
|
|
const double LN_2 = 0.69314718055994530942;
|
|
const double INVLN_2 = 1.0 / LN_2;
|
|
|
|
|
|
/** return the minimum of two values, equivalent to std::min.
|
|
* std::min not used because of STL implementation under IRIX not
|
|
* containing std::min.
|
|
*/
|
|
template<typename T>
|
|
inline T absolute(T v) { return v<(T)0?-v:v; }
|
|
|
|
/** return true if float lhs and rhs are equivalent,
|
|
* meaning that the difference between them is less than an epsilon value
|
|
* which defaults to 1e-6.
|
|
*/
|
|
inline bool equivalent(float lhs,float rhs,float epsilon=1e-6)
|
|
{ float delta = rhs-lhs; return delta<0.0f?delta>=-epsilon:delta<=epsilon; }
|
|
|
|
/** return true if double lhs and rhs are equivalent,
|
|
* meaning that the difference between them is less than an epsilon value
|
|
* which defaults to 1e-6.
|
|
*/
|
|
inline bool equivalent(double lhs,double rhs,double epsilon=1e-6)
|
|
{ double delta = rhs-lhs; return delta<0.0?delta>=-epsilon:delta<=epsilon; }
|
|
|
|
/** return the minimum of two values, equivilent to std::min.
|
|
* std::min not used because of STL implementation under IRIX not containing
|
|
* std::min.
|
|
*/
|
|
template<typename T>
|
|
inline T minimum(T lhs,T rhs) { return lhs<rhs?lhs:rhs; }
|
|
|
|
/** return the maximum of two values, equivilent to std::max.
|
|
* std::max not used because of STL implementation under IRIX not containing
|
|
* std::max.
|
|
*/
|
|
template<typename T>
|
|
inline T maximum(T lhs,T rhs) { return lhs>rhs?lhs:rhs; }
|
|
|
|
template<typename T>
|
|
inline T clampTo(T v,T minimum,T maximum)
|
|
{ return v<minimum?minimum:v>maximum?maximum:v; }
|
|
|
|
template<typename T>
|
|
inline T clampAbove(T v,T minimum) { return v<minimum?minimum:v; }
|
|
|
|
template<typename T>
|
|
inline T clampBelow(T v,T maximum) { return v>maximum?maximum:v; }
|
|
|
|
template<typename T>
|
|
inline T clampBetween(T v,T minimum, T maximum)
|
|
{ return clampBelow(clampAbove(v,minimum),maximum); }
|
|
|
|
template<typename T>
|
|
inline T sign(T v) { return v<(T)0?(T)-1:(T)1; }
|
|
|
|
template<typename T>
|
|
inline T signOrZero(T v) { return v<(T)0 ? (T)-1 : ( v>(T)0 ? (T)1 : 0 ); }
|
|
|
|
template<typename T>
|
|
inline T square(T v) { return v*v; }
|
|
|
|
template<typename T>
|
|
inline T signedSquare(T v) { return v<(T)0?-v*v:v*v;; }
|
|
|
|
inline float inDegrees(float angle) { return angle*(float)PI/180.0f; }
|
|
inline double inDegrees(double angle) { return angle*PI/180.0; }
|
|
|
|
template<typename T>
|
|
inline T inRadians(T angle) { return angle; }
|
|
|
|
inline float DegreesToRadians(float angle) { return angle*(float)PI/180.0f; }
|
|
inline double DegreesToRadians(double angle) { return angle*PI/180.0; }
|
|
|
|
inline float RadiansToDegrees(float angle) { return angle*180.0f/(float)PI; }
|
|
inline double RadiansToDegrees(double angle) { return angle*180.0/PI; }
|
|
|
|
inline float round(float v) { return v>=0.0f?floorf(v+0.5f):ceilf(v-0.5f); }
|
|
inline double round(double v) { return v>=0.0?floor(v+0.5):ceil(v-0.5); }
|
|
|
|
#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MWERKS__)
|
|
inline bool isNaN(float v) { return _isnan(v)!=0; }
|
|
inline bool isNaN(double v) { return _isnan(v)!=0; }
|
|
#else
|
|
#if defined(__APPLE__)
|
|
inline bool isNaN(float v) { return std::isnan(v); }
|
|
inline bool isNaN(double v) { return std::isnan(v); }
|
|
#else
|
|
// Need to use to std::isnan to avoid undef problem from <cmath>
|
|
inline bool isNaN(float v) { return isnan(v); }
|
|
inline bool isNaN(double v) { return isnan(v); }
|
|
#endif
|
|
#endif
|
|
|
|
|
|
/** compute the volume of a tetrahedron. */
|
|
template<typename T>
|
|
inline float computeVolume(const T& a,const T& b,const T& c,const T& d)
|
|
{
|
|
return fabsf(((b-c)^(a-b))*(d-b));
|
|
}
|
|
|
|
/** compute the volume of a prism. */
|
|
template<typename T>
|
|
inline float computeVolume(const T& f1,const T& f2,const T& f3,
|
|
const T& b1,const T& b2,const T& b3)
|
|
{
|
|
return computeVolume(f1,f2,f3,b1)+
|
|
computeVolume(b1,b2,b3,f2)+
|
|
computeVolume(b1,b3,f2,f3);
|
|
}
|
|
|
|
}
|
|
|
|
#endif // __OSG_MATH
|
|
|