Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 8351 was 8351, checked in by rgrieder, 13 years ago

Merged kicklib2 branch back to trunk (includes former branches ois_update, mac_osx and kicklib).

Notes for updating

Linux:
You don't need an extra package for CEGUILua and Tolua, it's already shipped with CEGUI.
However you do need to make sure that the OgreRenderer is installed too with CEGUI 0.7 (may be a separate package).
Also, Orxonox now recognises if you install the CgProgramManager (a separate package available on newer Ubuntu on Debian systems).

Windows:
Download the new dependency packages versioned 6.0 and use these. If you have problems with that or if you don't like the in game console problem mentioned below, you can download the new 4.3 version of the packages (only available for Visual Studio 2005/2008).

Key new features:

  • *Support for Mac OS X*
  • Visual Studio 2010 support
  • Bullet library update to 2.77
  • OIS library update to 1.3
  • Support for CEGUI 0.7 —> Support for Arch Linux and even SuSE
  • Improved install target
  • Compiles now with GCC 4.6
  • Ogre Cg Shader plugin activated for Linux if available
  • And of course lots of bug fixes

There are also some regressions:

  • No support for CEGUI 0.5, Ogre 1.4 and boost 1.35 - 1.39 any more
  • In game console is not working in main menu for CEGUI 0.7
  • Tolua (just the C lib, not the application) and CEGUILua libraries are no longer in our repository. —> You will need to get these as well when compiling Orxonox
  • And of course lots of new bugs we don't yet know about
  • Property svn:eol-style set to native
File size: 11.3 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 Rounds the value to the nearest integer.
145    */
146    template <typename T>
147    inline int round(T x)
148    {
149        return static_cast<int>(x + 0.5);
150    }
151
152    /**
153        @brief The modulo operation, enhanced to work properly with negative values.
154        @param x The value
155        @param max The operand
156
157        The built in modulo operator % yields a strange behavior with negative values.
158        This function corrects this - the result is guaranteed to lie always between
159        zero and (max-1).
160
161        Example:
162        @code
163        int var = 11 % 10;      //  1
164        int var = -1 % 10;      // -1
165
166        int var = mod(11, 10);  //  1
167        int var = mod(-1, 10);  //  9
168        @endcode
169    */
170    template <typename T>
171    inline int mod(T x, int max)
172    {
173        if (x >= 0)
174            return (x % max);
175        else
176            return ((x % max) + max);
177    }
178
179    /**
180        @brief Returns a "zero" value for the given type.
181        @note This is the default template of the zeroise() function. The template is spezialized for each supported type.
182
183        The exact return value of the function depends on the type. For @c int this is 0,
184        for @c float it's 0.0f. For a @c std::string the function returns "" and for
185        @c Vector3 you get <tt>Vector3(0, 0, 0)</tt>.
186    */
187    template <typename T>
188    inline T zeroise()
189    {
190        // Default, raise a compiler error without including large boost header cascade.
191        T temp();
192        *********temp; // If you reach this code, you abused zeroise()!
193        return temp;
194    }
195
196    template <> inline char                 zeroise<char>()                 { return 0; }
197    template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
198    template <> inline short                zeroise<short>()                { return 0; }
199    template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
200    template <> inline int                  zeroise<int>()                  { return 0; }
201    template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
202    template <> inline long                 zeroise<long>()                 { return 0; }
203    template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
204    template <> inline long long            zeroise<long long>()            { return 0; }
205    template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
206    template <> inline float                zeroise<float>()                { return 0; }
207    template <> inline double               zeroise<double>()               { return 0; }
208    template <> inline long double          zeroise<long double>()          { return 0; }
209    template <> inline bool                 zeroise<bool>()                 { return 0; }
210    template <> inline void*                zeroise<void*>()                { return 0; }
211    template <> inline std::string          zeroise<std::string>()          { return std::string(); }
212    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
213    template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
214    template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
215    template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
216    template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
217    template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
218    template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
219
220    /**
221        @brief Provides zero value symbols that can be returned as reference
222        @see zeroise()
223    */
224    template <typename T>
225    struct NilValue
226    {
227        inline operator const T&() const
228        {
229            return value;
230        }
231        static T value;
232    };
233    template <typename T>
234    T NilValue<T>::value = zeroise<T>();
235
236    /**
237        @brief Interpolates between two values for a time between 0 and 1.
238        @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.
239        @param start The value at @a time = 0
240        @param end The value at @a time = 1
241        @return The interpolated value at a given time
242    */
243    template <typename T>
244    inline T interpolate(float time, const T& start, const T& end)
245    {
246        return time * (end - start) + start;
247    }
248
249    /**
250        @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
251        @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.
252        @param start The value at @a time = 0
253        @param end The value at @a time = 1
254        @return The interpolated value at a given time
255    */
256    template <typename T>
257    inline T interpolateSmooth(float time, const T& start, const T& end)
258    {
259        return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
260    }
261
262    /**
263        @brief Returns a random number between 0 and almost 1: <tt>0 <= rnd < 1</tt>.
264    */
265    inline float rnd()
266    {
267        return rand() / (RAND_MAX + 1.0f);
268    }
269
270    /**
271        @brief Returns a random number between 0 and almost @a max: <tt>0 <= rnd < max</tt>.
272        @param max The maximum
273    */
274    inline float rnd(float max)
275    {
276        return rnd() * max;
277    }
278
279    /**
280        @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
281        @param min The minimum
282        @param max The maximum
283    */
284    inline float rnd(float min, float max)
285    {
286        return rnd(max - min) + min;
287    }
288
289    /**
290        @brief Returns randomly 1 or -1 with equal probability.
291    */
292    inline float rndsgn()
293    {
294        return static_cast<float>((rand() & 0x2) - 1); // rand() & 0x2 is either 2 or 0
295    }
296
297    _UtilExport unsigned long getUniqueNumber();
298
299    /**
300        @brief A Vector class containing two integers @a x and @a y.
301    */
302    class IntVector2
303    {
304    public:
305        IntVector2() : x(0), y(0) { }
306        IntVector2(int _x, int _y) : x(_x), y(_y) { }
307        int x;
308        int y;
309    };
310
311    /**
312        @brief A Vector class containing three integers @a x, @a y, and @a z.
313    */
314    class IntVector3
315    {
316    public:
317        IntVector3() : x(0), y(0), z(0) { }
318        IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
319        int x;
320        int y;
321        int z;
322    };
323}
324
325#endif /* _Util_Math_H__ */
Note: See TracBrowser for help on using the repository browser.