OGRE  1.9
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
OgreMath.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4  (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2014 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __Math_H__
29 #define __Math_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreHeaderPrefix.h"
33 
34 namespace Ogre
35 {
47  class Radian
48  {
50 
51  public:
52  explicit Radian ( Real r=0 ) : mRad(r) {}
53  Radian ( const Degree& d );
54  Radian& operator = ( const Real& f ) { mRad = f; return *this; }
55  Radian& operator = ( const Radian& r ) { mRad = r.mRad; return *this; }
56  Radian& operator = ( const Degree& d );
57 
58  Real valueDegrees() const; // see bottom of this file
59  Real valueRadians() const { return mRad; }
60  Real valueAngleUnits() const;
61 
62  const Radian& operator + () const { return *this; }
63  Radian operator + ( const Radian& r ) const { return Radian ( mRad + r.mRad ); }
64  Radian operator + ( const Degree& d ) const;
65  Radian& operator += ( const Radian& r ) { mRad += r.mRad; return *this; }
66  Radian& operator += ( const Degree& d );
67  Radian operator - () const { return Radian(-mRad); }
68  Radian operator - ( const Radian& r ) const { return Radian ( mRad - r.mRad ); }
69  Radian operator - ( const Degree& d ) const;
70  Radian& operator -= ( const Radian& r ) { mRad -= r.mRad; return *this; }
71  Radian& operator -= ( const Degree& d );
72  Radian operator * ( Real f ) const { return Radian ( mRad * f ); }
73  Radian operator * ( const Radian& f ) const { return Radian ( mRad * f.mRad ); }
74  Radian& operator *= ( Real f ) { mRad *= f; return *this; }
75  Radian operator / ( Real f ) const { return Radian ( mRad / f ); }
76  Radian& operator /= ( Real f ) { mRad /= f; return *this; }
77 
78  bool operator < ( const Radian& r ) const { return mRad < r.mRad; }
79  bool operator <= ( const Radian& r ) const { return mRad <= r.mRad; }
80  bool operator == ( const Radian& r ) const { return mRad == r.mRad; }
81  bool operator != ( const Radian& r ) const { return mRad != r.mRad; }
82  bool operator >= ( const Radian& r ) const { return mRad >= r.mRad; }
83  bool operator > ( const Radian& r ) const { return mRad > r.mRad; }
84 
85  inline _OgreExport friend std::ostream& operator <<
86  ( std::ostream& o, const Radian& v )
87  {
88  o << "Radian(" << v.valueRadians() << ")";
89  return o;
90  }
91  };
92 
98  class Degree
99  {
100  Real mDeg; // if you get an error here - make sure to define/typedef 'Real' first
101 
102  public:
103  explicit Degree ( Real d=0 ) : mDeg(d) {}
104  Degree ( const Radian& r ) : mDeg(r.valueDegrees()) {}
105  Degree& operator = ( const Real& f ) { mDeg = f; return *this; }
106  Degree& operator = ( const Degree& d ) { mDeg = d.mDeg; return *this; }
107  Degree& operator = ( const Radian& r ) { mDeg = r.valueDegrees(); return *this; }
108 
109  Real valueDegrees() const { return mDeg; }
110  Real valueRadians() const; // see bottom of this file
111  Real valueAngleUnits() const;
112 
113  const Degree& operator + () const { return *this; }
114  Degree operator + ( const Degree& d ) const { return Degree ( mDeg + d.mDeg ); }
115  Degree operator + ( const Radian& r ) const { return Degree ( mDeg + r.valueDegrees() ); }
116  Degree& operator += ( const Degree& d ) { mDeg += d.mDeg; return *this; }
117  Degree& operator += ( const Radian& r ) { mDeg += r.valueDegrees(); return *this; }
118  Degree operator - () const { return Degree(-mDeg); }
119  Degree operator - ( const Degree& d ) const { return Degree ( mDeg - d.mDeg ); }
120  Degree operator - ( const Radian& r ) const { return Degree ( mDeg - r.valueDegrees() ); }
121  Degree& operator -= ( const Degree& d ) { mDeg -= d.mDeg; return *this; }
122  Degree& operator -= ( const Radian& r ) { mDeg -= r.valueDegrees(); return *this; }
123  Degree operator * ( Real f ) const { return Degree ( mDeg * f ); }
124  Degree operator * ( const Degree& f ) const { return Degree ( mDeg * f.mDeg ); }
125  Degree& operator *= ( Real f ) { mDeg *= f; return *this; }
126  Degree operator / ( Real f ) const { return Degree ( mDeg / f ); }
127  Degree& operator /= ( Real f ) { mDeg /= f; return *this; }
128 
129  bool operator < ( const Degree& d ) const { return mDeg < d.mDeg; }
130  bool operator <= ( const Degree& d ) const { return mDeg <= d.mDeg; }
131  bool operator == ( const Degree& d ) const { return mDeg == d.mDeg; }
132  bool operator != ( const Degree& d ) const { return mDeg != d.mDeg; }
133  bool operator >= ( const Degree& d ) const { return mDeg >= d.mDeg; }
134  bool operator > ( const Degree& d ) const { return mDeg > d.mDeg; }
135 
136  inline _OgreExport friend std::ostream& operator <<
137  ( std::ostream& o, const Degree& v )
138  {
139  o << "Degree(" << v.valueDegrees() << ")";
140  return o;
141  }
142  };
143 
150  class Angle
151  {
153  public:
154  explicit Angle ( Real angle ) : mAngle(angle) {}
155  operator Radian() const;
156  operator Degree() const;
157  };
158 
159  // these functions could not be defined within the class definition of class
160  // Radian because they required class Degree to be defined
161  inline Radian::Radian ( const Degree& d ) : mRad(d.valueRadians()) {
162  }
163  inline Radian& Radian::operator = ( const Degree& d ) {
164  mRad = d.valueRadians(); return *this;
165  }
166  inline Radian Radian::operator + ( const Degree& d ) const {
167  return Radian ( mRad + d.valueRadians() );
168  }
169  inline Radian& Radian::operator += ( const Degree& d ) {
170  mRad += d.valueRadians();
171  return *this;
172  }
173  inline Radian Radian::operator - ( const Degree& d ) const {
174  return Radian ( mRad - d.valueRadians() );
175  }
176  inline Radian& Radian::operator -= ( const Degree& d ) {
177  mRad -= d.valueRadians();
178  return *this;
179  }
180 
192  {
193  public:
200  {
202  AU_RADIAN
203  };
204 
205 
209  {
210  public:
211  virtual ~RandomValueProvider() {}
213  virtual Real getRandomUnit() = 0;
214  };
215 
216  protected:
219 
221  static int mTrigTableSize;
222 
225  static Real* mSinTable;
226  static Real* mTanTable;
227 
230 
233  void buildTrigTables();
234 
235  static Real SinTable (Real fValue);
236  static Real TanTable (Real fValue);
237  public:
243  Math(unsigned int trigTableSize = 4096);
244 
247  ~Math();
248 
249  static inline int IAbs (int iValue) { return ( iValue >= 0 ? iValue : -iValue ); }
250  static inline int ICeil (float fValue) { return int(ceil(fValue)); }
251  static inline int IFloor (float fValue) { return int(floor(fValue)); }
252  static int ISign (int iValue);
253 
258  static inline Real Abs (Real fValue) { return Real(fabs(fValue)); }
259 
264  static inline Degree Abs (const Degree& dValue) { return Degree(fabs(dValue.valueDegrees())); }
265 
270  static inline Radian Abs (const Radian& rValue) { return Radian(fabs(rValue.valueRadians())); }
271 
276  static Radian ACos (Real fValue);
277 
282  static Radian ASin (Real fValue);
283 
288  static inline Radian ATan (Real fValue) { return Radian(atan(fValue)); }
289 
296  static inline Radian ATan2 (Real fY, Real fX) { return Radian(atan2(fY,fX)); }
297 
304  static inline Real Ceil (Real fValue) { return Real(ceil(fValue)); }
305  static inline bool isNaN(Real f)
306  {
307  // std::isnan() is C99, not supported by all compilers
308  // However NaN always fails this next test, no other number does.
309  return f != f;
310  }
311 
319  static inline Real Cos (const Radian& fValue, bool useTables = false) {
320  return (!useTables) ? Real(cos(fValue.valueRadians())) : SinTable(fValue.valueRadians() + HALF_PI);
321  }
329  static inline Real Cos (Real fValue, bool useTables = false) {
330  return (!useTables) ? Real(cos(fValue)) : SinTable(fValue + HALF_PI);
331  }
332 
333  static inline Real Exp (Real fValue) { return Real(exp(fValue)); }
334 
341  static inline Real Floor (Real fValue) { return Real(floor(fValue)); }
342 
343  static inline Real Log (Real fValue) { return Real(log(fValue)); }
344 
346  static const Real LOG2;
347 
348  static inline Real Log2 (Real fValue) { return Real(log(fValue)/LOG2); }
349 
350  static inline Real LogN (Real base, Real fValue) { return Real(log(fValue)/log(base)); }
351 
352  static inline Real Pow (Real fBase, Real fExponent) { return Real(pow(fBase,fExponent)); }
353 
354  static Real Sign (Real fValue);
355  static inline Radian Sign ( const Radian& rValue )
356  {
357  return Radian(Sign(rValue.valueRadians()));
358  }
359  static inline Degree Sign ( const Degree& dValue )
360  {
361  return Degree(Sign(dValue.valueDegrees()));
362  }
363 
364  //Simulate the shader function saturate that clamps a parameter value between 0 and 1
365  static inline float saturate(float t) { return (t < 0) ? 0 : ((t > 1) ? 1 : t); }
366  static inline double saturate(double t) { return (t < 0) ? 0 : ((t > 1) ? 1 : t); }
367 
368  //Simulate the shader function lerp which performers linear interpolation
369  //given 3 parameters v0, v1 and t the function returns the value of (1 t)* v0 + t * v1.
370  //where v0 and v1 are matching vector or scalar types and t can be either a scalar or a vector of the same type as a and b.
371  template<typename V, typename T> static V lerp(const V& v0, const V& v1, const T& t) {
372  return v0 * (1 - t) + v1 * t; }
373 
381  static inline Real Sin (const Radian& fValue, bool useTables = false) {
382  return (!useTables) ? Real(sin(fValue.valueRadians())) : SinTable(fValue.valueRadians());
383  }
391  static inline Real Sin (Real fValue, bool useTables = false) {
392  return (!useTables) ? Real(sin(fValue)) : SinTable(fValue);
393  }
394 
399  static inline Real Sqr (Real fValue) { return fValue*fValue; }
400 
405  static inline Real Sqrt (Real fValue) { return Real(sqrt(fValue)); }
406 
413  static inline Radian Sqrt (const Radian& fValue) { return Radian(sqrt(fValue.valueRadians())); }
414 
421  static inline Degree Sqrt (const Degree& fValue) { return Degree(sqrt(fValue.valueDegrees())); }
422 
428  static Real InvSqrt (Real fValue);
429 
434  static Real UnitRandom ();
435 
444  static Real RangeRandom (Real fLow, Real fHigh);
445 
450  static Real SymmetricRandom ();
451 
452  static void SetRandomValueProvider(RandomValueProvider* provider);
453 
461  static inline Real Tan (const Radian& fValue, bool useTables = false) {
462  return (!useTables) ? Real(tan(fValue.valueRadians())) : TanTable(fValue.valueRadians());
463  }
471  static inline Real Tan (Real fValue, bool useTables = false) {
472  return (!useTables) ? Real(tan(fValue)) : TanTable(fValue);
473  }
474 
475  static inline Real DegreesToRadians(Real degrees) { return degrees * fDeg2Rad; }
476  static inline Real RadiansToDegrees(Real radians) { return radians * fRad2Deg; }
477 
484  static void setAngleUnit(AngleUnit unit);
486  static AngleUnit getAngleUnit(void);
487 
489  static Real AngleUnitsToRadians(Real units);
491  static Real RadiansToAngleUnits(Real radians);
493  static Real AngleUnitsToDegrees(Real units);
495  static Real DegreesToAngleUnits(Real degrees);
496 
518  static bool pointInTri2D(const Vector2& p, const Vector2& a,
519  const Vector2& b, const Vector2& c);
520 
545  static bool pointInTri3D(const Vector3& p, const Vector3& a,
546  const Vector3& b, const Vector3& c, const Vector3& normal);
548  static std::pair<bool, Real> intersects(const Ray& ray, const Plane& plane);
549 
551  static std::pair<bool, Real> intersects(const Ray& ray, const Sphere& sphere,
552  bool discardInside = true);
553 
555  static std::pair<bool, Real> intersects(const Ray& ray, const AxisAlignedBox& box);
556 
579  static bool intersects(const Ray& ray, const AxisAlignedBox& box,
580  Real* d1, Real* d2);
581 
606  static std::pair<bool, Real> intersects(const Ray& ray, const Vector3& a,
607  const Vector3& b, const Vector3& c, const Vector3& normal,
608  bool positiveSide = true, bool negativeSide = true);
609 
630  static std::pair<bool, Real> intersects(const Ray& ray, const Vector3& a,
631  const Vector3& b, const Vector3& c,
632  bool positiveSide = true, bool negativeSide = true);
633 
635  static bool intersects(const Sphere& sphere, const AxisAlignedBox& box);
636 
638  static bool intersects(const Plane& plane, const AxisAlignedBox& box);
639 
645  static std::pair<bool, Real> intersects(
646  const Ray& ray, const vector<Plane>::type& planeList,
647  bool normalIsOutside);
653  static std::pair<bool, Real> intersects(
654  const Ray& ray, const list<Plane>::type& planeList,
655  bool normalIsOutside);
656 
660  static bool intersects(const Sphere& sphere, const Plane& plane);
661 
664  static bool RealEqual(Real a, Real b,
665  Real tolerance = std::numeric_limits<Real>::epsilon());
666 
668  static Vector3 calculateTangentSpaceVector(
669  const Vector3& position1, const Vector3& position2, const Vector3& position3,
670  Real u1, Real v1, Real u2, Real v2, Real u3, Real v3);
671 
673  static Matrix4 buildReflectionMatrix(const Plane& p);
675  static Vector4 calculateFaceNormal(const Vector3& v1, const Vector3& v2, const Vector3& v3);
677  static Vector3 calculateBasicFaceNormal(const Vector3& v1, const Vector3& v2, const Vector3& v3);
679  static Vector4 calculateFaceNormalWithoutNormalize(const Vector3& v1, const Vector3& v2, const Vector3& v3);
681  static Vector3 calculateBasicFaceNormalWithoutNormalize(const Vector3& v1, const Vector3& v2, const Vector3& v3);
682 
686  static Real gaussianDistribution(Real x, Real offset = 0.0f, Real scale = 1.0f);
687 
689  template <typename T>
690  static T Clamp(T val, T minval, T maxval)
691  {
692  assert (minval <= maxval && "Invalid clamp range");
693  return std::max(std::min(val, maxval), minval);
694  }
695 
696  static Matrix4 makeViewMatrix(const Vector3& position, const Quaternion& orientation,
697  const Matrix4* reflectMatrix = 0);
698 
700  static Real boundingRadiusFromAABB(const AxisAlignedBox& aabb);
701 
702 
703 
704  static const Real POS_INFINITY;
705  static const Real NEG_INFINITY;
706  static const Real PI;
707  static const Real TWO_PI;
708  static const Real HALF_PI;
709  static const Real fDeg2Rad;
710  static const Real fRad2Deg;
711 
712  };
713 
714  // these functions must be defined down here, because they rely on the
715  // angle unit conversion functions in class Math:
716 
717  inline Real Radian::valueDegrees() const
718  {
719  return Math::RadiansToDegrees ( mRad );
720  }
721 
723  {
724  return Math::RadiansToAngleUnits ( mRad );
725  }
726 
727  inline Real Degree::valueRadians() const
728  {
729  return Math::DegreesToRadians ( mDeg );
730  }
731 
733  {
734  return Math::DegreesToAngleUnits ( mDeg );
735  }
736 
737  inline Angle::operator Radian() const
738  {
739  return Radian(Math::AngleUnitsToRadians(mAngle));
740  }
741 
742  inline Angle::operator Degree() const
743  {
744  return Degree(Math::AngleUnitsToDegrees(mAngle));
745  }
746 
747  inline Radian operator * ( Real a, const Radian& b )
748  {
749  return Radian ( a * b.valueRadians() );
750  }
751 
752  inline Radian operator / ( Real a, const Radian& b )
753  {
754  return Radian ( a / b.valueRadians() );
755  }
756 
757  inline Degree operator * ( Real a, const Degree& b )
758  {
759  return Degree ( a * b.valueDegrees() );
760  }
761 
762  inline Degree operator / ( Real a, const Degree& b )
763  {
764  return Degree ( a / b.valueDegrees() );
765  }
769 }
770 
771 #include "OgreHeaderSuffix.h"
772 
773 #endif
Representation of a ray in space, i.e.
Definition: OgreRay.h:46
Radian & operator+=(const Radian &r)
Definition: OgreMath.h:65
static Real LogN(Real base, Real fValue)
Definition: OgreMath.h:350
static float saturate(float t)
Definition: OgreMath.h:365
static Radian Sign(const Radian &rValue)
Definition: OgreMath.h:355
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Degree & operator+=(const Degree &d)
Definition: OgreMath.h:116
float Real
Software floating point type.
static const Real LOG2
Stored value of log(2) for frequent use.
Definition: OgreMath.h:346
static const Real HALF_PI
Definition: OgreMath.h:708
#define _OgreExport
Definition: OgrePlatform.h:260
static T Clamp(T val, T minval, T maxval)
Clamp a value within an inclusive range.
Definition: OgreMath.h:690
static Degree Abs(const Degree &dValue)
Absolute value function.
Definition: OgreMath.h:264
AngleUnit
The angular units used by the API.
Definition: OgreMath.h:199
static Real Log(Real fValue)
Definition: OgreMath.h:343
static const Real fDeg2Rad
Definition: OgreMath.h:709
static RandomValueProvider * mRandProvider
A random value provider. overriding the default random number generator.
Definition: OgreMath.h:229
static Real Cos(Real fValue, bool useTables=false)
Cosine function.
Definition: OgreMath.h:329
Defines a plane in 3D space.
Definition: OgrePlane.h:61
Degree & operator=(const Real &f)
Definition: OgreMath.h:105
static Radian ATan(Real fValue)
Arc tangent function.
Definition: OgreMath.h:288
bool operator<=(const Radian &r) const
Definition: OgreMath.h:79
Real valueRadians() const
Definition: OgreMath.h:727
static Real RadiansToAngleUnits(Real radians)
Convert from radians to the current AngleUnit .
static Radian Sqrt(const Radian &fValue)
Square root function.
Definition: OgreMath.h:413
static Radian Abs(const Radian &rValue)
Absolute value function.
Definition: OgreMath.h:270
Real mRad
Definition: OgreMath.h:49
static Real Exp(Real fValue)
Definition: OgreMath.h:333
static Real Log2(Real fValue)
Definition: OgreMath.h:348
bool operator<(const Degree &d) const
Definition: OgreMath.h:129
Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAn...
Definition: OgreMath.h:150
static const Real TWO_PI
Definition: OgreMath.h:707
A 3D box aligned with the x/y/z axes.
Radian & operator/=(Real f)
Definition: OgreMath.h:76
std::list< T, A > type
bool operator!=(const Degree &d) const
Definition: OgreMath.h:132
static Real Tan(Real fValue, bool useTables=false)
Tangent function.
Definition: OgreMath.h:471
Class to provide access to common mathematical functions.
Definition: OgreMath.h:191
Degree & operator/=(Real f)
Definition: OgreMath.h:127
bool operator>(const Radian &r) const
Definition: OgreMath.h:83
bool operator!=(const Radian &r) const
Definition: OgreMath.h:81
Radian & operator-=(const Radian &r)
Definition: OgreMath.h:70
static Real Cos(const Radian &fValue, bool useTables=false)
Cosine function.
Definition: OgreMath.h:319
Radian operator*(Real a, const Radian &b)
Definition: OgreMath.h:747
Radian operator/(Real a, const Radian &b)
Definition: OgreMath.h:752
Implementation of a Quaternion, i.e.
Angle(Real angle)
Definition: OgreMath.h:154
Radian operator/(Real f) const
Definition: OgreMath.h:75
static const Real POS_INFINITY
Definition: OgreMath.h:704
Degree & operator*=(Real f)
Definition: OgreMath.h:125
Real valueAngleUnits() const
Definition: OgreMath.h:732
static const Real PI
Definition: OgreMath.h:706
static V lerp(const V &v0, const V &v1, const T &t)
Definition: OgreMath.h:371
static Real Tan(const Radian &fValue, bool useTables=false)
Tangent function.
Definition: OgreMath.h:461
static Real Sin(Real fValue, bool useTables=false)
Sine function.
Definition: OgreMath.h:391
static Real AngleUnitsToDegrees(Real units)
Convert from the current AngleUnit to degrees.
static Real DegreesToRadians(Real degrees)
Definition: OgreMath.h:475
static Real * mTanTable
Definition: OgreMath.h:226
static Real Abs(Real fValue)
Absolute value function.
Definition: OgreMath.h:258
Degree & operator-=(const Degree &d)
Definition: OgreMath.h:121
static Real mTrigTableFactor
Radian -> index factor value ( mTrigTableSize / 2 * PI )
Definition: OgreMath.h:224
static Radian ATan2(Real fY, Real fX)
Arc tangent between two values function.
Definition: OgreMath.h:296
static Real Sin(const Radian &fValue, bool useTables=false)
Sine function.
Definition: OgreMath.h:381
bool operator>=(const Degree &d) const
Definition: OgreMath.h:133
Degree(const Radian &r)
Definition: OgreMath.h:104
static Real Sqrt(Real fValue)
Square root function.
Definition: OgreMath.h:405
static Real Ceil(Real fValue)
Ceiling function Returns the smallest following integer.
Definition: OgreMath.h:304
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:51
static Real AngleUnitsToRadians(Real units)
Convert from the current AngleUnit to radians.
Standard 2-dimensional vector.
Definition: OgreVector2.h:51
static Real Floor(Real fValue)
Floor function Returns the largest previous integer.
Definition: OgreMath.h:341
Wrapper class which indicates a given angle value is in Degrees.
Definition: OgreMath.h:98
static int IAbs(int iValue)
Definition: OgreMath.h:249
static Degree Sqrt(const Degree &fValue)
Square root function.
Definition: OgreMath.h:421
Degree operator/(Real f) const
Definition: OgreMath.h:126
static Real Sqr(Real fValue)
Squared function.
Definition: OgreMath.h:399
Real valueRadians() const
Definition: OgreMath.h:59
static int mTrigTableSize
Size of the trig tables as determined by constructor.
Definition: OgreMath.h:221
Degree operator*(Real f) const
Definition: OgreMath.h:123
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
static Real Pow(Real fBase, Real fExponent)
Definition: OgreMath.h:352
static AngleUnit msAngleUnit
Angle units used by the api.
Definition: OgreMath.h:218
Degree(Real d=0)
Definition: OgreMath.h:103
static int IFloor(float fValue)
Definition: OgreMath.h:251
Radian & operator=(const Real &f)
Definition: OgreMath.h:54
bool operator<(const Radian &r) const
Definition: OgreMath.h:78
static const Real NEG_INFINITY
Definition: OgreMath.h:705
static double saturate(double t)
Definition: OgreMath.h:366
static Real * mSinTable
Definition: OgreMath.h:225
static Real DegreesToAngleUnits(Real degrees)
Convert from degrees to the current AngleUnit.
const Degree & operator+() const
Definition: OgreMath.h:113
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:47
const Radian & operator+() const
Definition: OgreMath.h:62
This class is used to provide an external random value provider.
Definition: OgreMath.h:208
static int ICeil(float fValue)
Definition: OgreMath.h:250
bool operator==(const Degree &d) const
Definition: OgreMath.h:131
bool operator>=(const Radian &r) const
Definition: OgreMath.h:82
Real valueDegrees() const
Definition: OgreMath.h:717
static bool isNaN(Real f)
Definition: OgreMath.h:305
bool operator>(const Degree &d) const
Definition: OgreMath.h:134
Radian & operator*=(Real f)
Definition: OgreMath.h:74
4-dimensional homogeneous vector.
Definition: OgreVector4.h:45
static Real RadiansToDegrees(Real radians)
Definition: OgreMath.h:476
bool operator==(const Radian &r) const
Definition: OgreMath.h:80
bool operator<=(const Degree &d) const
Definition: OgreMath.h:130
Real mAngle
Definition: OgreMath.h:152
Radian operator-() const
Definition: OgreMath.h:67
Radian operator*(Real f) const
Definition: OgreMath.h:72
Real valueAngleUnits() const
Definition: OgreMath.h:722
Degree operator-() const
Definition: OgreMath.h:118
Radian(Real r=0)
Definition: OgreMath.h:52
static const Real fRad2Deg
Definition: OgreMath.h:710
Real valueDegrees() const
Definition: OgreMath.h:109
static Degree Sign(const Degree &dValue)
Definition: OgreMath.h:359