Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 2, 2008, 12:38:26 PM (16 years ago)
Author:
rgrieder
Message:

Moved all util classes and functions to orxonox namespace.
Converted all code to 4 spaces/tab in util.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/objecthierarchy/src/util/Math.h

    r2019 r2111  
    4949#include <OgreQuaternion.h>
    5050#include <OgreColourValue.h>
    51 
    52 namespace orxonox
    53 {
    54   typedef Ogre::Radian Radian;
    55   typedef Ogre::Degree Degree;
    56   typedef Ogre::Vector2 Vector2;
    57   typedef Ogre::Vector3 Vector3;
    58   typedef Ogre::Vector4 Vector4;
    59   typedef Ogre::Matrix3 Matrix3;
    60   typedef Ogre::Matrix4 Matrix4;
    61   typedef Ogre::Quaternion Quaternion;
    62   typedef Ogre::ColourValue ColourValue;
    63 }
    64 
    65 _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
    66 _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
    67 _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
    68 _UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
    69 
    70 _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
    71 _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
    72 _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
    73 _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
    7451
    7552//Get around Windows hackery
    … …  
    8360#endif
    8461
    85 /**
    86     @brief Returns the sign of the given value.
    87     @param x The value
    88     @return 1 if the value is positive or zero, -1 if the value is negative
    89 */
    90 template <typename T>
    91 inline T sgn(T x)
     62namespace orxonox
    9263{
    93     return (x >= 0) ? 1 : -1;
     64    typedef Ogre::Radian Radian;
     65    typedef Ogre::Degree Degree;
     66    typedef Ogre::Vector2 Vector2;
     67    typedef Ogre::Vector3 Vector3;
     68    typedef Ogre::Vector4 Vector4;
     69    typedef Ogre::Matrix3 Matrix3;
     70    typedef Ogre::Matrix4 Matrix4;
     71    typedef Ogre::Quaternion Quaternion;
     72    typedef Ogre::ColourValue ColourValue;
     73
     74    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
     75    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
     76    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
     77    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
     78
     79    _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
     80    _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
     81    _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
     82    _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
     83
     84    /**
     85        @brief Returns the sign of the given value.
     86        @param x The value
     87        @return 1 if the value is positive or zero, -1 if the value is negative
     88    */
     89    template <typename T>
     90    inline T sgn(T x)
     91    {
     92        return (x >= 0) ? 1 : -1;
     93    }
     94
     95    /**
     96        @brief Returns the smaller of two values.
     97    */
     98    template <typename T>
     99    inline T min(T a, T b)
     100    {
     101        return (a <= b) ? a : b;
     102    }
     103
     104    /**
     105        @brief Returns the greater of two values.
     106    */
     107    template <typename T>
     108    inline T max(T a, T b)
     109    {
     110        return (a >= b) ? a : b;
     111    }
     112
     113    /**
     114        @brief Keeps a value between a lower and an upper limit.
     115        @param x The value
     116        @param min The lower limit
     117        @param max The upper limit
     118    */
     119    template <typename T>
     120    inline T clamp(T x, T min, T max)
     121    {
     122        if (x < min)
     123            return min;
     124
     125        if (x > max)
     126            return max;
     127
     128        return x;
     129    }
     130
     131    /**
     132        @brief Returns the square value (x^2).
     133    */
     134    template <typename T>
     135    inline T square(T x)
     136    {
     137        return x*x;
     138    }
     139
     140    /**
     141        @brief Returns the cube value (x^3).
     142    */
     143    template <typename T>
     144    inline T cube(T x)
     145    {
     146        return x*x*x;
     147    }
     148
     149    /**
     150        @brief Rounds the value down.
     151    */
     152    template <typename T>
     153    inline int floor(T x)
     154    {
     155        return (int)(x);
     156    }
     157
     158    /**
     159        @brief Rounds the value up.
     160    */
     161    template <typename T>
     162    inline int ceil(T x)
     163    {
     164        int temp = floor(x);
     165        return (temp != x) ? (temp + 1) : temp;
     166    }
     167
     168    /**
     169        @brief Rounds the value.
     170    */
     171    template <typename T>
     172    inline int round(T x)
     173    {
     174        return (int)(x + 0.5);
     175    }
     176
     177    /**
     178        @brief The modulo operation, enhanced to work properly with negative values.
     179        @param x The value
     180        @param max The operand
     181    */
     182    template <typename T>
     183    inline int mod(T x, int max)
     184    {
     185        if (x >= 0)
     186            return (x % max);
     187        else
     188            return ((x % max) + max);
     189    }
     190
     191    template <typename T>
     192    inline T zeroise()
     193    {
     194        BOOST_STATIC_ASSERT(sizeof(T) == 0);
     195        return T();
     196    }
     197
     198    template <> inline char                 zeroise<char>()                 { return 0; }
     199    template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
     200    template <> inline short                zeroise<short>()                { return 0; }
     201    template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
     202    template <> inline int                  zeroise<int>()                  { return 0; }
     203    template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
     204    template <> inline long                 zeroise<long>()                 { return 0; }
     205    template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
     206    template <> inline long long            zeroise<long long>()            { return 0; }
     207    template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
     208    template <> inline float                zeroise<float>()                { return 0; }
     209    template <> inline double               zeroise<double>()               { return 0; }
     210    template <> inline long double          zeroise<long double>()          { return 0; }
     211    template <> inline bool                 zeroise<bool>()                 { return 0; }
     212    template <> inline void*                zeroise<void*>()                { return 0; }
     213    template <> inline std::string          zeroise<std::string>()          { return ""; }
     214    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
     215    template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
     216    template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
     217    template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
     218    template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
     219    template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
     220    template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
     221
     222    /**
     223        @brief Interpolates between two values for a time between 0 and 1.
     224        @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.
     225        @param start The value at time = 0
     226        @param end The value at time = 1
     227        @return The interpolation at a given time
     228    */
     229    template <typename T>
     230    T interpolate(float time, const T& start, const T& end)
     231    {
     232        return time * (end - start) + start;
     233    }
     234
     235    /**
     236        @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
     237        @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.
     238        @param start The value at time = 0
     239        @param end The value at time = 1
     240        @return The smoothed interpolation at a given time
     241    */
     242    template <typename T>
     243    T interpolateSmooth(float time, const T& start, const T& end)
     244    {
     245        return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
     246    }
     247
     248    /**
     249        @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
     250    */
     251    inline float rnd()
     252    {
     253        return rand() / (RAND_MAX + 1.0);
     254    }
     255
     256    /**
     257        @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
     258        @param max The maximum
     259    */
     260    inline float rnd(float max)
     261    {
     262        return rnd() * max;
     263    }
     264
     265    /**
     266        @brief Returns a random number between min and almost max: min <= rnd < max.
     267        @param min The minimum
     268        @param max The maximum
     269    */
     270    inline float rnd(float min, float max)
     271    {
     272        return rnd(max - min) + min;
     273    }
     274
     275    _UtilExport unsigned long getUniqueNumber();
     276
     277    class IntVector2
     278    {
     279    public:
     280      IntVector2() : x(0), y(0) { }
     281      IntVector2(int _x, int _y) : x(_x), y(_y) { }
     282      int x;
     283      int y;
     284    };
     285
     286    class IntVector3
     287    {
     288    public:
     289      IntVector3() : x(0), y(0), z(0) { }
     290      IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
     291      int x;
     292      int y;
     293      int z;
     294    };
    94295}
    95296
    96 /**
    97     @brief Returns the smaller of two values.
    98 */
    99 template <typename T>
    100 inline T min(T a, T b)
    101 {
    102     return (a <= b) ? a : b;
    103 }
    104 
    105 /**
    106     @brief Returns the greater of two values.
    107 */
    108 template <typename T>
    109 inline T max(T a, T b)
    110 {
    111     return (a >= b) ? a : b;
    112 }
    113 
    114 /**
    115     @brief Keeps a value between a lower and an upper limit.
    116     @param x The value
    117     @param min The lower limit
    118     @param max The upper limit
    119 */
    120 template <typename T>
    121 inline T clamp(T x, T min, T max)
    122 {
    123     if (x < min)
    124         return min;
    125 
    126     if (x > max)
    127         return max;
    128 
    129     return x;
    130 }
    131 
    132 /**
    133     @brief Returns the square value (x^2).
    134 */
    135 template <typename T>
    136 inline T square(T x)
    137 {
    138     return x*x;
    139 }
    140 
    141 /**
    142     @brief Returns the cube value (x^3).
    143 */
    144 template <typename T>
    145 inline T cube(T x)
    146 {
    147     return x*x*x;
    148 }
    149 
    150 /**
    151     @brief Rounds the value down.
    152 */
    153 template <typename T>
    154 inline int floor(T x)
    155 {
    156     return (int)(x);
    157 }
    158 
    159 /**
    160     @brief Rounds the value up.
    161 */
    162 template <typename T>
    163 inline int ceil(T x)
    164 {
    165     int temp = floor(x);
    166     return (temp != x) ? (temp + 1) : temp;
    167 }
    168 
    169 /**
    170     @brief Rounds the value.
    171 */
    172 template <typename T>
    173 inline int round(T x)
    174 {
    175     return (int)(x + 0.5);
    176 }
    177 
    178 /**
    179     @brief The modulo operation, enhanced to work properly with negative values.
    180     @param x The value
    181     @param max The operand
    182 */
    183 template <typename T>
    184 inline int mod(T x, int max)
    185 {
    186     if (x >= 0)
    187         return (x % max);
    188     else
    189         return ((x % max) + max);
    190 }
    191 
    192 template <typename T>
    193 inline T zeroise()
    194 {
    195     BOOST_STATIC_ASSERT(sizeof(T) == 0);
    196     return T();
    197 }
    198 
    199 template <> inline char                 zeroise<char>()                 { return 0; }
    200 template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
    201 template <> inline short                zeroise<short>()                { return 0; }
    202 template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
    203 template <> inline int                  zeroise<int>()                  { return 0; }
    204 template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
    205 template <> inline long                 zeroise<long>()                 { return 0; }
    206 template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
    207 template <> inline long long            zeroise<long long>()            { return 0; }
    208 template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
    209 template <> inline float                zeroise<float>()                { return 0; }
    210 template <> inline double               zeroise<double>()               { return 0; }
    211 template <> inline long double          zeroise<long double>()          { return 0; }
    212 template <> inline bool                 zeroise<bool>()                 { return 0; }
    213 template <> inline void*                zeroise<void*>()                { return 0; }
    214 template <> inline std::string          zeroise<std::string>()          { return ""; }
    215 template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
    216 template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
    217 template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
    218 template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
    219 template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
    220 template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
    221 template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
    222 
    223 /**
    224     @brief Interpolates between two values for a time between 0 and 1.
    225     @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.
    226     @param start The value at time = 0
    227     @param end The value at time = 1
    228     @return The interpolation at a given time
    229 */
    230 template <typename T>
    231 T interpolate(float time, const T& start, const T& end)
    232 {
    233     return time * (end - start) + start;
    234 }
    235 
    236 /**
    237     @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
    238     @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.
    239     @param start The value at time = 0
    240     @param end The value at time = 1
    241     @return The smoothed interpolation at a given time
    242 */
    243 template <typename T>
    244 T interpolateSmooth(float time, const T& start, const T& end)
    245 {
    246     return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
    247 }
    248 
    249 /**
    250     @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
    251 */
    252 inline _UtilExport float rnd()
    253 {
    254     return rand() / (RAND_MAX + 1.0);
    255 }
    256 
    257 /**
    258     @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
    259     @param max The maximum
    260 */
    261 inline _UtilExport float rnd(float max)
    262 {
    263     return rnd() * max;
    264 }
    265 
    266 /**
    267     @brief Returns a random number between min and almost max: min <= rnd < max.
    268     @param min The minimum
    269     @param max The maximum
    270 */
    271 inline _UtilExport float rnd(float min, float max)
    272 {
    273     return rnd(max - min) + min;
    274 }
    275 
    276 _UtilExport unsigned long getUniqueNumber();
    277 
    278 class _UtilExport IntVector2
    279 {
    280 public:
    281   IntVector2() : x(0), y(0) { }
    282   IntVector2(int _x, int _y) : x(_x), y(_y) { }
    283   int x;
    284   int y;
    285 };
    286 
    287 class _UtilExport IntVector3
    288 {
    289 public:
    290   IntVector3() : x(0), y(0), z(0) { }
    291   IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
    292   int x;
    293   int y;
    294   int z;
    295 };
    296 
    297297#endif /* _Util_Math_H__ */
Note: See TracChangeset for help on using the changeset viewer.