Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/libraries/util/Math.h @ 9550

Last change on this file since 9550 was 9550, checked in by landauf, 11 years ago

merged testing branch back to trunk. unbelievable it took me 13 months to finish this chore…

  • Property svn:eol-style set to native
File size: 10.7 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @defgroup Math Mathematical functions
31    @ingroup Util
32*/
33
34/**
35    @file
36    @ingroup Math
37    @brief Declaration and implementation of several math-functions, typedefs of some Ogre::Math classes to the orxonox namespace.
38*/
39
40#ifndef _Util_Math_H__
41#define _Util_Math_H__
42
43#include "UtilPrereqs.h"
44
45#include <string>
46#include <cmath>
47#include <cstdlib>
48
49#include <OgreMath.h>
50#include <OgreVector2.h>
51#include <OgreVector3.h>
52#include <OgreVector4.h>
53#include <OgreQuaternion.h>
54#include <OgreColourValue.h>
55
56// Certain headers might define unwanted macros...
57#undef max
58#undef min
59#undef sgn
60#undef clamp
61#undef sqrt
62#undef square
63#undef mod
64#undef rnd
65
66namespace orxonox
67{
68    /** Often used numerical constants because C++ doesn't define any.
69    @note
70        The values here are decimal representations of the approximate floating
71        point value as it is stored according to the IEEE 754 standard.
72    */
73    namespace math
74    {
75        const float twoPi   = 6.283185482025146484375f;     ///< PI * 2
76        const float pi      = 3.1415927410125732421875f;    ///< PI
77        const float pi_2    = 1.57079637050628662109375f;   ///< PI / 2
78        const float pi_4    = 0.785398185253143310546875f;  ///< PI / 4
79        const float e       = 2.718281269073486328125f;     ///< e
80        const float sqrt2   = 1.41421353816986083984375f;   ///< sqrt(2)
81        const float sqrt2_2 = 0.707106769084930419921875f;  ///< sqrt(2) / 2
82    }
83
84#if OGRE_VERSION < 0x010603
85    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
86    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
87#endif
88    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
89    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
90
91    _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
92    _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
93    _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
94    _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
95
96    /**
97        @brief Returns the sign of the given value.
98        @param x The value
99        @return 1 if the value is positive or zero, -1 if the value is negative
100    */
101    template <typename T>
102    inline T sgn(T x)
103    {
104        return (x >= 0) ? (T)1 : (T)-1;
105    }
106
107    /**
108        @brief Keeps a value between a lower and an upper limit. Values beyond these limits are limited to either @a min or @a max.
109        @param x The value
110        @param min The lower limit
111        @param max The upper limit
112    */
113    template <typename T>
114    inline T clamp(T x, T min, T max)
115    {
116        if (x < min)
117            return min;
118
119        if (x > max)
120            return max;
121
122        return x;
123    }
124
125    /**
126        @brief Returns the squared value (x^2).
127    */
128    template <typename T>
129    inline T square(T x)
130    {
131        return x*x;
132    }
133
134    /**
135        @brief Returns the cubed value (x^3).
136    */
137    template <typename T>
138    inline T cube(T x)
139    {
140        return x*x*x;
141    }
142
143    /**
144        @brief The modulo operation, enhanced to work properly with negative values.
145        @param x The value
146        @param max The operand
147
148        The built in modulo operator % yields a strange behavior with negative values.
149        This function corrects this - the result is guaranteed to lie always between
150        zero and (max-1).
151
152        Example:
153        @code
154        int var = 11 % 10;      //  1
155        int var = -1 % 10;      // -1
156
157        int var = mod(11, 10);  //  1
158        int var = mod(-1, 10);  //  9
159        @endcode
160    */
161    template <typename T>
162    inline int mod(T x, int max)
163    {
164        if (x >= 0)
165            return (x % max);
166        else
167        {
168            T temp = x % max;
169            return (temp < 0) ? (temp + max) : temp;
170        }
171    }
172
173    /**
174        @brief Returns a "zero" value for the given type.
175        @note This is the default template of the zeroise() function. The template is spezialized for each supported type.
176
177        The exact return value of the function depends on the type. For @c int this is 0,
178        for @c float it's 0.0f. For a @c std::string the function returns "" and for
179        @c Vector3 you get <tt>Vector3(0, 0, 0)</tt>.
180    */
181    template <typename T>
182    inline T zeroise()
183    {
184        // Default, raise a compiler error without including large boost header cascade.
185        T temp();
186        *********temp; // If you reach this code, you abused zeroise()!
187        return temp;
188    }
189
190    template <> inline char                 zeroise<char>()                 { return 0; }
191    template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
192    template <> inline short                zeroise<short>()                { return 0; }
193    template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
194    template <> inline int                  zeroise<int>()                  { return 0; }
195    template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
196    template <> inline long                 zeroise<long>()                 { return 0; }
197    template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
198    template <> inline long long            zeroise<long long>()            { return 0; }
199    template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
200    template <> inline float                zeroise<float>()                { return 0; }
201    template <> inline double               zeroise<double>()               { return 0; }
202    template <> inline long double          zeroise<long double>()          { return 0; }
203    template <> inline bool                 zeroise<bool>()                 { return 0; }
204    template <> inline void*                zeroise<void*>()                { return 0; }
205    template <> inline std::string          zeroise<std::string>()          { return std::string(); }
206    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
207    template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
208    template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
209    template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
210    template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
211    template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
212    template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
213
214    /**
215        @brief Provides zero value symbols that can be returned as reference
216        @see zeroise()
217    */
218    template <typename T>
219    struct NilValue
220    {
221        inline operator const T&() const
222        {
223            return value;
224        }
225        static T value;
226    };
227    template <typename T>
228    T NilValue<T>::value = zeroise<T>();
229
230    /**
231        @brief Interpolates between two values for a time between 0 and 1.
232        @param time The time is a value between 0 and 1 - the function returns @a start if @a time is 0, @a end if @a time is 1, and interpolates if @a time is between 0 and 1.
233        @param start The value at @a time = 0
234        @param end The value at @a time = 1
235        @return The interpolated value at a given time
236    */
237    template <typename T>
238    inline T interpolate(float time, const T& start, const T& end)
239    {
240        return static_cast<T>(time * (end - start) + start);
241    }
242
243    /**
244        @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
245        @param time The time is a value between 0 and 1 - the function returns @a start if @a time is 0, @a end if @a time is 1, and interpolates if @a time is between 0 and 1.
246        @param start The value at @a time = 0
247        @param end The value at @a time = 1
248        @return The interpolated value at a given time
249    */
250    template <typename T>
251    inline T interpolateSmooth(float time, const T& start, const T& end)
252    {
253        return static_cast<T>((-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start);
254    }
255
256    /**
257        @brief Returns a random number between 0 and almost 1: <tt>0 <= rnd < 1</tt>.
258    */
259    inline float rnd()
260    {
261        return rand() / (RAND_MAX + 1.0f);
262    }
263
264    /**
265        @brief Returns a random number between 0 and almost @a max: <tt>0 <= rnd < max</tt>.
266        @param max The maximum
267    */
268    inline float rnd(float max)
269    {
270        return rnd() * max;
271    }
272
273    /**
274        @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
275        @param min The minimum
276        @param max The maximum
277    */
278    inline float rnd(float min, float max)
279    {
280        return rnd(max - min) + min;
281    }
282
283    /**
284        @brief Returns randomly 1 or -1 with equal probability.
285    */
286    inline float rndsgn()
287    {
288        return static_cast<float>((rand() & 0x2) - 1); // rand() & 0x2 is either 2 or 0
289    }
290
291    _UtilExport unsigned long getUniqueNumber();
292}
293
294#endif /* _Util_Math_H__ */
Note: See TracBrowser for help on using the repository browser.