OgreMath.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2013 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28#ifndef __Math_H__
29#define __Math_H__
30
31#include "OgrePrerequisites.h"
32#include "OgreHeaderPrefix.h"
33
34namespace 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:
213 virtual Real getRandomUnit() = 0;
214 };
215
216 protected:
219
221 static int mTrigTableSize;
222
227
230
234
235 static Real SinTable (Real fValue);
236 static Real TanTable (Real fValue);
237 public:
243 Math(unsigned int trigTableSize = 4096);
244
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
451
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);
487
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
669 const Vector3& position1, const Vector3& position2, const Vector3& position3,
670 Real u1, Real v1, Real u2, Real v2, Real u3, Real v3);
671
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);
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
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
718 {
719 return Math::RadiansToDegrees ( mRad );
720 }
721
723 {
725 }
726
728 {
729 return Math::DegreesToRadians ( mDeg );
730 }
731
733 {
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
#define _OgreExport
Definition: OgrePlatform.h:257
Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAn...
Definition: OgreMath.h:151
Real mAngle
Definition: OgreMath.h:152
Angle(Real angle)
Definition: OgreMath.h:154
A 3D box aligned with the x/y/z axes.
Wrapper class which indicates a given angle value is in Degrees.
Definition: OgreMath.h:99
bool operator<(const Degree &d) const
Definition: OgreMath.h:129
Degree operator*(Real f) const
Definition: OgreMath.h:123
Degree & operator+=(const Degree &d)
Definition: OgreMath.h:116
Degree operator/(Real f) const
Definition: OgreMath.h:126
Degree(const Radian &r)
Definition: OgreMath.h:104
Degree operator-() const
Definition: OgreMath.h:118
bool operator!=(const Degree &d) const
Definition: OgreMath.h:132
bool operator>(const Degree &d) const
Definition: OgreMath.h:134
Degree & operator*=(Real f)
Definition: OgreMath.h:125
bool operator==(const Degree &d) const
Definition: OgreMath.h:131
Degree(Real d=0)
Definition: OgreMath.h:103
bool operator>=(const Degree &d) const
Definition: OgreMath.h:133
const Degree & operator+() const
Definition: OgreMath.h:113
Degree & operator-=(const Degree &d)
Definition: OgreMath.h:121
bool operator<=(const Degree &d) const
Definition: OgreMath.h:130
Degree & operator/=(Real f)
Definition: OgreMath.h:127
Degree & operator=(const Real &f)
Definition: OgreMath.h:105
Real valueDegrees() const
Definition: OgreMath.h:109
This class is used to provide an external random value provider.
Definition: OgreMath.h:209
virtual Real getRandomUnit()=0
When called should return a random values in the range of [0,1].
Class to provide access to common mathematical functions.
Definition: OgreMath.h:192
static std::pair< bool, Real > intersects(const Ray &ray, const vector< Plane >::type &planeList, bool normalIsOutside)
Ray / convex plane list intersection test.
static Degree Sqrt(const Degree &fValue)
Square root function.
Definition: OgreMath.h:421
static Real Log(Real fValue)
Definition: OgreMath.h:343
static Real AngleUnitsToRadians(Real units)
Convert from the current AngleUnit to radians.
static bool intersects(const Sphere &sphere, const Plane &plane)
Sphere / plane intersection test.
static T Clamp(T val, T minval, T maxval)
Clamp a value within an inclusive range.
Definition: OgreMath.h:690
static Vector3 calculateTangentSpaceVector(const Vector3 &position1, const Vector3 &position2, const Vector3 &position3, Real u1, Real v1, Real u2, Real v2, Real u3, Real v3)
Calculates the tangent space vector for a given set of positions / texture coords.
static float saturate(float t)
Definition: OgreMath.h:365
static Real mTrigTableFactor
Radian -> index factor value ( mTrigTableSize / 2 * PI )
Definition: OgreMath.h:224
static AngleUnit getAngleUnit(void)
Get the unit being used for angles.
static Real UnitRandom()
Generate a random number of unit length.
static Real * mSinTable
Definition: OgreMath.h:225
static Radian ATan(Real fValue)
Arc tangent function.
Definition: OgreMath.h:288
static bool pointInTri3D(const Vector3 &p, const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &normal)
Checks whether a given 3D point is inside a triangle.
static double saturate(double t)
Definition: OgreMath.h:366
static bool pointInTri2D(const Vector2 &p, const Vector2 &a, const Vector2 &b, const Vector2 &c)
Checks whether a given point is inside a triangle, in a 2-dimensional (Cartesian) space.
static Real RangeRandom(Real fLow, Real fHigh)
Generate a random number within the range provided.
static Real Tan(const Radian &fValue, bool useTables=false)
Tangent function.
Definition: OgreMath.h:461
static Real Exp(Real fValue)
Definition: OgreMath.h:333
static Real LogN(Real base, Real fValue)
Definition: OgreMath.h:350
static std::pair< bool, Real > intersects(const Ray &ray, const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &normal, bool positiveSide=true, bool negativeSide=true)
Ray / triangle intersection, returns boolean result and distance.
static Degree Abs(const Degree &dValue)
Absolute value function.
Definition: OgreMath.h:264
void buildTrigTables()
Private function to build trig tables.
static Vector4 calculateFaceNormal(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
Calculate a face normal, including the w component which is the offset from the origin.
~Math()
Default destructor.
static Real AngleUnitsToDegrees(Real units)
Convert from the current AngleUnit to degrees.
static Real TanTable(Real fValue)
Math(unsigned int trigTableSize=4096)
Default constructor.
static Real InvSqrt(Real fValue)
Inverse square root i.e.
static Radian ACos(Real fValue)
Arc cosine function.
static Real gaussianDistribution(Real x, Real offset=0.0f, Real scale=1.0f)
Generates a value based on the Gaussian (normal) distribution function with the given offset and scal...
static const Real TWO_PI
Definition: OgreMath.h:707
static Real RadiansToAngleUnits(Real radians)
Convert from radians to the current AngleUnit .
static Real Sqr(Real fValue)
Squared function.
Definition: OgreMath.h:399
static bool intersects(const Ray &ray, const AxisAlignedBox &box, Real *d1, Real *d2)
Ray / box intersection, returns boolean result and two intersection distance.
static const Real fRad2Deg
Definition: OgreMath.h:710
static Radian Sqrt(const Radian &fValue)
Square root function.
Definition: OgreMath.h:413
static Real boundingRadiusFromAABB(const AxisAlignedBox &aabb)
Get a bounding radius value from a bounding box.
static AngleUnit msAngleUnit
Angle units used by the api.
Definition: OgreMath.h:218
static Real Sign(Real fValue)
static Vector4 calculateFaceNormalWithoutNormalize(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
Calculate a face normal without normalize, including the w component which is the offset from the ori...
static Real RadiansToDegrees(Real radians)
Definition: OgreMath.h:476
static std::pair< bool, Real > intersects(const Ray &ray, const Plane &plane)
Ray / plane intersection, returns boolean result and distance.
static Real SymmetricRandom()
Generate a random number in the range [-1,1].
static const Real NEG_INFINITY
Definition: OgreMath.h:705
static std::pair< bool, Real > intersects(const Ray &ray, const Vector3 &a, const Vector3 &b, const Vector3 &c, bool positiveSide=true, bool negativeSide=true)
Ray / triangle intersection, returns boolean result and distance.
static Real Sin(Real fValue, bool useTables=false)
Sine function.
Definition: OgreMath.h:391
static bool RealEqual(Real a, Real b, Real tolerance=std::numeric_limits< Real >::epsilon())
Compare 2 reals, using tolerance for inaccuracies.
static int mTrigTableSize
Size of the trig tables as determined by constructor.
Definition: OgreMath.h:221
static Real Cos(Real fValue, bool useTables=false)
Cosine function.
Definition: OgreMath.h:329
static Radian ATan2(Real fY, Real fX)
Arc tangent between two values function.
Definition: OgreMath.h:296
static int ISign(int iValue)
static bool isNaN(Real f)
Definition: OgreMath.h:305
static Real Cos(const Radian &fValue, bool useTables=false)
Cosine function.
Definition: OgreMath.h:319
static void SetRandomValueProvider(RandomValueProvider *provider)
static const Real POS_INFINITY
Definition: OgreMath.h:704
static const Real HALF_PI
Definition: OgreMath.h:708
static std::pair< bool, Real > intersects(const Ray &ray, const AxisAlignedBox &box)
Ray / box intersection, returns boolean result and distance.
static int ICeil(float fValue)
Definition: OgreMath.h:250
static Real DegreesToAngleUnits(Real degrees)
Convert from degrees to the current AngleUnit.
static Vector3 calculateBasicFaceNormalWithoutNormalize(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
Calculate a face normal without normalize, no w-information.
static Real Sin(const Radian &fValue, bool useTables=false)
Sine function.
Definition: OgreMath.h:381
static Real Ceil(Real fValue)
Ceiling function Returns the smallest following integer.
Definition: OgreMath.h:304
static RandomValueProvider * mRandProvider
A random value provider. overriding the default random number generator.
Definition: OgreMath.h:229
static V lerp(const V &v0, const V &v1, const T &t)
Definition: OgreMath.h:371
static Real Sqrt(Real fValue)
Square root function.
Definition: OgreMath.h:405
static Real Pow(Real fBase, Real fExponent)
Definition: OgreMath.h:352
static Real * mTanTable
Definition: OgreMath.h:226
static bool intersects(const Plane &plane, const AxisAlignedBox &box)
Plane / box intersection test.
static Radian Sign(const Radian &rValue)
Definition: OgreMath.h:355
static Real DegreesToRadians(Real degrees)
Definition: OgreMath.h:475
static Real Tan(Real fValue, bool useTables=false)
Tangent function.
Definition: OgreMath.h:471
static const Real LOG2
Stored value of log(2) for frequent use.
Definition: OgreMath.h:346
static Real Log2(Real fValue)
Definition: OgreMath.h:348
static const Real fDeg2Rad
Definition: OgreMath.h:709
AngleUnit
The angular units used by the API.
Definition: OgreMath.h:200
static std::pair< bool, Real > intersects(const Ray &ray, const list< Plane >::type &planeList, bool normalIsOutside)
Ray / convex plane list intersection test.
static Matrix4 buildReflectionMatrix(const Plane &p)
Build a reflection matrix for the passed in plane.
static Radian ASin(Real fValue)
Arc sine function.
static Real SinTable(Real fValue)
static bool intersects(const Sphere &sphere, const AxisAlignedBox &box)
Sphere / box intersection test.
static int IAbs(int iValue)
Definition: OgreMath.h:249
static Degree Sign(const Degree &dValue)
Definition: OgreMath.h:359
static Radian Abs(const Radian &rValue)
Absolute value function.
Definition: OgreMath.h:270
static Real Abs(Real fValue)
Absolute value function.
Definition: OgreMath.h:258
static int IFloor(float fValue)
Definition: OgreMath.h:251
static std::pair< bool, Real > intersects(const Ray &ray, const Sphere &sphere, bool discardInside=true)
Ray / sphere intersection, returns boolean result and distance.
static const Real PI
Definition: OgreMath.h:706
static Real Floor(Real fValue)
Floor function Returns the largest previous integer.
Definition: OgreMath.h:341
static Matrix4 makeViewMatrix(const Vector3 &position, const Quaternion &orientation, const Matrix4 *reflectMatrix=0)
static Vector3 calculateBasicFaceNormal(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3)
Calculate a face normal, no w-information.
static void setAngleUnit(AngleUnit unit)
These functions used to set the assumed angle units (radians or degrees) expected when using the Angl...
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:79
Defines a plane in 3D space.
Definition: OgrePlane.h:62
Implementation of a Quaternion, i.e.
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:48
Radian & operator+=(const Radian &r)
Definition: OgreMath.h:65
bool operator!=(const Radian &r) const
Definition: OgreMath.h:81
bool operator<(const Radian &r) const
Definition: OgreMath.h:78
bool operator<=(const Radian &r) const
Definition: OgreMath.h:79
bool operator>=(const Radian &r) const
Definition: OgreMath.h:82
Radian operator/(Real f) const
Definition: OgreMath.h:75
bool operator>(const Radian &r) const
Definition: OgreMath.h:83
Radian operator*(Real f) const
Definition: OgreMath.h:72
Radian operator-() const
Definition: OgreMath.h:67
Radian & operator-=(const Radian &r)
Definition: OgreMath.h:70
Radian & operator/=(Real f)
Definition: OgreMath.h:76
Radian & operator*=(Real f)
Definition: OgreMath.h:74
const Radian & operator+() const
Definition: OgreMath.h:62
Radian(Real r=0)
Definition: OgreMath.h:52
Real valueRadians() const
Definition: OgreMath.h:59
Radian & operator=(const Real &f)
Definition: OgreMath.h:54
bool operator==(const Radian &r) const
Definition: OgreMath.h:80
Real mRad
Definition: OgreMath.h:49
Representation of a ray in space, i.e.
Definition: OgreRay.h:47
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:52
Standard 2-dimensional vector.
Definition: OgreVector2.h:52
Standard 3-dimensional vector.
Definition: OgreVector3.h:52
4-dimensional homogeneous vector.
Definition: OgreVector4.h:46
Radian operator*(Real a, const Radian &b)
Definition: OgreMath.h:747
Radian operator/(Real a, const Radian &b)
Definition: OgreMath.h:752
Real valueDegrees() const
Definition: OgreMath.h:717
Real valueAngleUnits() const
Definition: OgreMath.h:722
Real valueAngleUnits() const
Definition: OgreMath.h:732
Real valueRadians() const
Definition: OgreMath.h:727
float Real
Software floating point type.
std::list< T, A > type

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.