Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/ScriptableController/src/libraries/util/Math.h @ 10012

Last change on this file since 10012 was 9939, checked in by jo, 11 years ago

presentationHS13 branch merged into trunk

  • Property svn:eol-style set to native
File size: 11.5 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 *      Wolfgang Roenninger
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::Vector2 get3DProjection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle, const float detectionlimit);
95    _UtilExport bool isObjectHigherThanShipOnMap(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle);
96    _UtilExport int determineMap3DZOrder(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float detectionlimit);
97    _UtilExport orxonox::Vector3 getTransformedVector(const orxonox::Vector3& distance, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& myside);
98    _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
99
100    /**
101        @brief Returns the sign of the given value.
102        @param x The value
103        @return 1 if the value is positive or zero, -1 if the value is negative
104    */
105    template <typename T>
106    inline T sgn(T x)
107    {
108        return (x >= 0) ? (T)1 : (T)-1;
109    }
110
111    /**
112        @brief Keeps a value between a lower and an upper limit. Values beyond these limits are limited to either @a min or @a max.
113        @param x The value
114        @param min The lower limit
115        @param max The upper limit
116    */
117    template <typename T>
118    inline T clamp(T x, T min, T max)
119    {
120        if (x < min)
121            return min;
122
123        if (x > max)
124            return max;
125
126        return x;
127    }
128
129    /**
130        @brief Returns the squared value (x^2).
131    */
132    template <typename T>
133    inline T square(T x)
134    {
135        return x*x;
136    }
137
138    /**
139        @brief Returns the cubed value (x^3).
140    */
141    template <typename T>
142    inline T cube(T x)
143    {
144        return x*x*x;
145    }
146
147    /**
148        @brief The modulo operation, enhanced to work properly with negative values.
149        @param x The value
150        @param max The operand
151
152        The built in modulo operator % yields a strange behavior with negative values.
153        This function corrects this - the result is guaranteed to lie always between
154        zero and (max-1).
155
156        Example:
157        @code
158        int var = 11 % 10;      //  1
159        int var = -1 % 10;      // -1
160
161        int var = mod(11, 10);  //  1
162        int var = mod(-1, 10);  //  9
163        @endcode
164    */
165    template <typename T>
166    inline int mod(T x, int max)
167    {
168        if (x >= 0)
169            return (x % max);
170        else
171        {
172            T temp = x % max;
173            return (temp < 0) ? (temp + max) : temp;
174        }
175    }
176
177    /**
178        @brief Returns a "zero" value for the given type.
179        @note This is the default template of the zeroise() function. The template is spezialized for each supported type.
180
181        The exact return value of the function depends on the type. For @c int this is 0,
182        for @c float it's 0.0f. For a @c std::string the function returns "" and for
183        @c Vector3 you get <tt>Vector3(0, 0, 0)</tt>.
184    */
185    template <typename T>
186    inline T zeroise()
187    {
188        // Default, raise a compiler error without including large boost header cascade.
189        T temp();
190        *********temp; // If you reach this code, you abused zeroise()!
191        return temp;
192    }
193
194    template <> inline char                 zeroise<char>()                 { return 0; }
195    template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
196    template <> inline short                zeroise<short>()                { return 0; }
197    template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
198    template <> inline int                  zeroise<int>()                  { return 0; }
199    template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
200    template <> inline long                 zeroise<long>()                 { return 0; }
201    template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
202    template <> inline long long            zeroise<long long>()            { return 0; }
203    template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
204    template <> inline float                zeroise<float>()                { return 0; }
205    template <> inline double               zeroise<double>()               { return 0; }
206    template <> inline long double          zeroise<long double>()          { return 0; }
207    template <> inline bool                 zeroise<bool>()                 { return 0; }
208    template <> inline void*                zeroise<void*>()                { return 0; }
209    template <> inline std::string          zeroise<std::string>()          { return std::string(); }
210    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
211    template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
212    template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
213    template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
214    template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
215    template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
216    template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
217
218    /**
219        @brief Provides zero value symbols that can be returned as reference
220        @see zeroise()
221    */
222    template <typename T>
223    struct NilValue
224    {
225        inline operator const T&() const
226        {
227            return value;
228        }
229        static T value;
230    };
231    template <typename T>
232    T NilValue<T>::value = zeroise<T>();
233
234    /**
235        @brief Interpolates between two values for a time between 0 and 1.
236        @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.
237        @param start The value at @a time = 0
238        @param end The value at @a time = 1
239        @return The interpolated value at a given time
240    */
241    template <typename T>
242    inline T interpolate(float time, const T& start, const T& end)
243    {
244        return static_cast<T>(time * (end - start) + start);
245    }
246
247    /**
248        @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
249        @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.
250        @param start The value at @a time = 0
251        @param end The value at @a time = 1
252        @return The interpolated value at a given time
253    */
254    template <typename T>
255    inline T interpolateSmooth(float time, const T& start, const T& end)
256    {
257        return static_cast<T>((-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start);
258    }
259
260    /**
261        @brief Returns a random number between 0 and almost 1: <tt>0 <= rnd < 1</tt>.
262    */
263    inline float rnd()
264    {
265        return rand() / (RAND_MAX + 1.0f);
266    }
267
268    /**
269        @brief Returns a random number between 0 and almost @a max: <tt>0 <= rnd < max</tt>.
270        @param max The maximum
271    */
272    inline float rnd(float max)
273    {
274        return rnd() * max;
275    }
276
277    /**
278        @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
279        @param min The minimum
280        @param max The maximum
281    */
282    inline float rnd(float min, float max)
283    {
284        return rnd(max - min) + min;
285    }
286
287    /**
288        @brief Returns randomly 1 or -1 with equal probability.
289    */
290    inline float rndsgn()
291    {
292        return static_cast<float>((rand() & 0x2) - 1); // rand() & 0x2 is either 2 or 0
293    }
294
295    _UtilExport unsigned long getUniqueNumber();
296}
297
298#endif /* _Util_Math_H__ */
Note: See TracBrowser for help on using the repository browser.