Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/sound5/src/libraries/util/Math.h @ 7155

Last change on this file since 7155 was 6502, checked in by rgrieder, 15 years ago

Removed a ton of msvc warnings revealed with OGRE v1.7 (they removed the warning suppressors in OgrePrerequisites.h).
All of them are conversions from one type to another that might be lossy (mostly double to float, please always use "3.7f" instead of "3.7" as constants when using floats).

  • Property svn:eol-style set to native
File size: 9.2 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    @file
31    @brief Declaration and implementation of several math-functions, typedefs of some Ogre::Math classes to the orxonox namespace.
32*/
33
34#ifndef _Util_Math_H__
35#define _Util_Math_H__
36
37#include "UtilPrereqs.h"
38
39#include <string>
40#include <cmath>
41
42#include <OgreMath.h>
43#include <OgreVector2.h>
44#include <OgreVector3.h>
45#include <OgreVector4.h>
46#include <OgreQuaternion.h>
47#include <OgreColourValue.h>
48
49// Certain headers might define unwanted macros...
50#undef max
51#undef min
52#undef sgn
53#undef clamp
54#undef sqrt
55#undef square
56#undef mod
57#undef rnd
58
59namespace orxonox
60{
61#if OGRE_VERSION < 0x010603
62    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
63    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
64#endif
65    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
66    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
67
68    _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
69    _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
70    _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
71    _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
72
73    /**
74        @brief Returns the sign of the given value.
75        @param x The value
76        @return 1 if the value is positive or zero, -1 if the value is negative
77    */
78    template <typename T>
79    inline T sgn(T x)
80    {
81        return (x >= 0) ? (T)1 : (T)-1;
82    }
83
84    /**
85        @brief Keeps a value between a lower and an upper limit.
86        @param x The value
87        @param min The lower limit
88        @param max The upper limit
89    */
90    template <typename T>
91    inline T clamp(T x, T min, T max)
92    {
93        if (x < min)
94            return min;
95
96        if (x > max)
97            return max;
98
99        return x;
100    }
101
102    /**
103        @brief Returns the square value (x^2).
104    */
105    template <typename T>
106    inline T square(T x)
107    {
108        return x*x;
109    }
110
111    /**
112        @brief Returns the cube value (x^3).
113    */
114    template <typename T>
115    inline T cube(T x)
116    {
117        return x*x*x;
118    }
119
120    /**
121        @brief Rounds the value.
122    */
123    template <typename T>
124    inline int round(T x)
125    {
126        return static_cast<int>(x + 0.5);
127    }
128
129    /**
130        @brief The modulo operation, enhanced to work properly with negative values.
131        @param x The value
132        @param max The operand
133    */
134    template <typename T>
135    inline int mod(T x, int max)
136    {
137        if (x >= 0)
138            return (x % max);
139        else
140            return ((x % max) + max);
141    }
142
143    template <typename T>
144    inline T zeroise()
145    {
146        // Default, raise a compiler error without including large boost header cascade.
147        T temp();
148        *********temp; // If you reach this code, you abused zeroise()!
149        return temp;
150    }
151
152    template <> inline char                 zeroise<char>()                 { return 0; }
153    template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
154    template <> inline short                zeroise<short>()                { return 0; }
155    template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
156    template <> inline int                  zeroise<int>()                  { return 0; }
157    template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
158    template <> inline long                 zeroise<long>()                 { return 0; }
159    template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
160    template <> inline long long            zeroise<long long>()            { return 0; }
161    template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
162    template <> inline float                zeroise<float>()                { return 0; }
163    template <> inline double               zeroise<double>()               { return 0; }
164    template <> inline long double          zeroise<long double>()          { return 0; }
165    template <> inline bool                 zeroise<bool>()                 { return 0; }
166    template <> inline void*                zeroise<void*>()                { return 0; }
167    template <> inline std::string          zeroise<std::string>()          { return std::string(); }
168    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
169    template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
170    template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
171    template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
172    template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
173    template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
174    template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
175
176    //! Provides zero value symbols that can be returned as reference
177    template <typename T>
178    struct NilValue
179    {
180        inline operator const T&() const
181        {
182            return value;
183        }
184        static T value;
185    };
186    template <typename T>
187    T NilValue<T>::value = zeroise<T>();
188
189    /**
190        @brief Interpolates between two values for a time between 0 and 1.
191        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
192        @param start The value at time = 0
193        @param end The value at time = 1
194        @return The interpolation at a given time
195    */
196    template <typename T>
197    inline T interpolate(float time, const T& start, const T& end)
198    {
199        return time * (end - start) + start;
200    }
201
202    /**
203        @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
204        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
205        @param start The value at time = 0
206        @param end The value at time = 1
207        @return The smoothed interpolation at a given time
208    */
209    template <typename T>
210    inline T interpolateSmooth(float time, const T& start, const T& end)
211    {
212        return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
213    }
214
215    /**
216        @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
217    */
218    inline float rnd()
219    {
220        return rand() / (RAND_MAX + 1.0f);
221    }
222
223    /**
224        @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
225        @param max The maximum
226    */
227    inline float rnd(float max)
228    {
229        return rnd() * max;
230    }
231
232    /**
233        @brief Returns a random number between min and almost max: min <= rnd < max.
234        @param min The minimum
235        @param max The maximum
236    */
237    inline float rnd(float min, float max)
238    {
239        return rnd(max - min) + min;
240    }
241
242    /**
243        @brief Returns randomly 1 or -1 with equal probability.
244    */
245    inline float rndsgn()
246    {
247        return static_cast<float>((rand() & 0x2) - 1); // rand() & 0x2 is either 2 or 0
248    }
249
250    _UtilExport unsigned long getUniqueNumber();
251
252    class IntVector2
253    {
254    public:
255        IntVector2() : x(0), y(0) { }
256        IntVector2(int _x, int _y) : x(_x), y(_y) { }
257        int x;
258        int y;
259    };
260
261    class IntVector3
262    {
263    public:
264        IntVector3() : x(0), y(0), z(0) { }
265        IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
266        int x;
267        int y;
268        int z;
269    };
270}
271
272#endif /* _Util_Math_H__ */
Note: See TracBrowser for help on using the repository browser.