src/base/vec.h

   1 /************************************************************************
   2     This file is part of NE.
   3
   4     NE is free software: you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation, either version 3 of the License, or
   7     (at your option) any later version.
   8
   9     NE is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with NE.  If not, see <http://www.gnu.org/licenses/>.
  16 ************************************************************************/
  17
  18 #ifndef VEC_H_
  19 #define VEC_H_
  20
  21 template<class T>
  22 class Vec
  23 {
  24 public:
  25         Vec(T v=0) : m_x(v), m_y(v), m_z(v) {}
  26         Vec(T x, T y, T z) : m_x(x), m_y(y), m_z(z) {}
  27
  28         ///////////////////////
  29         // Set/Get functions //
  30         ///////////////////////
  31         inline const Vec<T> set(T v)
  32         {
  33                 m_x = m_y = m_z = v;
  34                 return *this;
  35         }
  36         inline const Vec<T> &set(T x, T y, T z)
  37         {
  38                 m_x = x; m_y = y; m_z = z;
  39                 return *this;
  40         }
  41         inline const T* get()
  42         {
  43                 static T v[3];
  44                 v[0] = m_x;
  45                 v[1] = m_y;
  46                 v[2] = m_z;
  47                 return &v;
  48         }
  49         inline T x() { return m_x; }
  50         inline T y() { return m_y; }
  51         inline T z() { return m_z; }
  52
  53         ///////////////////////
  54         // Equality overload //
  55         ///////////////////////
  56         inline const Vec<T> &operator = (const Vec<T> &q)
  57         {
  58                 return set(q.m_x,q.m_y,q.m_z);
  59         }
  60         inline bool operator == (const Vec<T> &q)
  61         {
  62                 return m_x==q.m_x && m_y==q.m_y && m_z==q.m_z;
  63         }
  64
  65         /////////////////////
  66         // Vector overload //
  67         /////////////////////
  68         inline const Vec<T> &operator + (const Vec<T> &v) const
  69         {
  70                 return Vec<T>(m_x+v.m_x, m_y+v.m_y, m_z+v.m_z);
  71         }
  72         inline const Vec<T> &operator += (const Vec<T> &v)
  73         {
  74                 return set(m_x+v, m_y+v, m_z+v);
  75         }
  76
  77         inline const Vec<T> &operator - (const Vec<T> &v) const
  78         {
  79                 return Vec<T>(m_x-v.m_x, m_y-v.m_y, m_z-v.m_z);
  80         }
  81         inline const Vec<T> &operator -= (const Vec<T> &v)
  82         {
  83                 return set(m_x-v, m_y-v, m_z-v);
  84         }
  85
  86         inline const Vec<T> &operator * (const Vec<T> &v) const
  87         {
  88                 return Vec<T>(m_x*v.m_x, m_y*v.m_y, m_z*v.m_z);
  89         }
  90         inline const Vec<T> &operator *= (const Vec<T> &v)
  91         {
  92                 return set(m_x*v, m_y*v, m_z*v);
  93         }
  94
  95         inline const Vec<T> &operator / (const Vec<T> &v) const
  96         {
  97                 return Vec<T>(m_x/v.m_x, m_y/v.m_y, m_z/v.m_z);
  98         }
  99         inline const Vec<T> &operator /= (const Vec<T> &v)
 100         {
 101                 return set(m_x/v, m_y/v, m_z/v);
 102         }
 103
 104         /////////////////////
 105         // Scalar overload //
 106         /////////////////////
 107         inline const Vec<T> &operator + (T v) const
 108         {
 109                 return *this + Vec<T>(v);
 110         }
 111         inline const Vec<T> &operator += (T v)
 112         {
 113                 return *this += Vec<T>(v);
 114         }
 115
 116         inline const Vec<T> &operator - (T v) const
 117         {
 118                 return *this - Vec<T>(v);
 119         }
 120         inline const Vec<T> &operator -= (T v)
 121         {
 122                 return *this -= Vec<T>(v);
 123         }
 124
 125         inline const Vec<T> &operator * (T v) const
 126         {
 127                 return *this * Vec<T>(v);
 128         }
 129         inline const Vec<T> &operator *= (T v)
 130         {
 131                 return *this *= Vec<T>(v);
 132         }
 133
 134         inline const Vec<T> &operator / (T v) const
 135         {
 136                 return *this / Vec<T>(v);
 137         }
 138         inline const Vec<T> &operator /= (T v)
 139         {
 140                 return *this /= Vec<T>(v);
 141         }
 142
 143 protected:
 144         T m_x, m_y, m_z;
 145 };
 146
 147 typedef Vec<float> Vec3f;
 148 typedef Vec<double> Vec3d;
 149
 150 #endif /*VEC_H_*/