Extras/HACD/hacdVector.inl

   1 #pragma once\r
   2 #ifndef HACD_VECTOR_INL\r
   3 #define HACD_VECTOR_INL\r
   4 namespace HACD\r
   5 {\r
   6         template <typename T> \r
   7         inline Vec3<T> operator*(T lhs, const Vec3<T> & rhs)\r
   8         {\r
   9                 return Vec3<T>(lhs * rhs.X(), lhs * rhs.Y(), lhs * rhs.Z());\r
  10         }\r
  11         template <typename T> \r
  12         inline T & Vec3<T>::X() \r
  13         {\r
  14                 return m_data[0];\r
  15         }\r
  16         template <typename T>   \r
  17         inline  T &     Vec3<T>::Y() \r
  18         {\r
  19                 return m_data[1];\r
  20         }\r
  21         template <typename T>   \r
  22         inline  T &     Vec3<T>::Z() \r
  23         {\r
  24                 return m_data[2];\r
  25         }\r
  26         template <typename T>   \r
  27         inline  const T & Vec3<T>::X() const \r
  28         {\r
  29                 return m_data[0];\r
  30         }\r
  31         template <typename T>   \r
  32         inline  const T & Vec3<T>::Y() const \r
  33         {\r
  34                 return m_data[1];\r
  35         }\r
  36         template <typename T>   \r
  37         inline  const T & Vec3<T>::Z() const \r
  38         {\r
  39                 return m_data[2];\r
  40         }\r
  41         template <typename T>   \r
  42         inline  void Vec3<T>::Normalize()\r
  43         {\r
  44                 T n = sqrt(m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2]);\r
  45                 if (n != 0.0) (*this) /= n;\r
  46         }\r
  47         template <typename T>   \r
  48         inline  T Vec3<T>::GetNorm() const \r
  49         { \r
  50                 return sqrt(m_data[0]*m_data[0]+m_data[1]*m_data[1]+m_data[2]*m_data[2]);\r
  51         }\r
  52         template <typename T>   \r
  53         inline  void Vec3<T>::operator= (const Vec3 & rhs)\r
  54         { \r
  55                 this->m_data[0] = rhs.m_data[0]; \r
  56                 this->m_data[1] = rhs.m_data[1]; \r
  57                 this->m_data[2] = rhs.m_data[2]; \r
  58         }\r
  59         template <typename T>   \r
  60         inline  void Vec3<T>::operator+=(const Vec3 & rhs)\r
  61         { \r
  62                 this->m_data[0] += rhs.m_data[0]; \r
  63                 this->m_data[1] += rhs.m_data[1]; \r
  64                 this->m_data[2] += rhs.m_data[2]; \r
  65         }     \r
  66         template <typename T>  \r
  67         inline void Vec3<T>::operator-=(const Vec3 & rhs)\r
  68         { \r
  69                 this->m_data[0] -= rhs.m_data[0]; \r
  70                 this->m_data[1] -= rhs.m_data[1]; \r
  71                 this->m_data[2] -= rhs.m_data[2]; \r
  72         }\r
  73         template <typename T>  \r
  74         inline void Vec3<T>::operator-=(T a)\r
  75         { \r
  76                 this->m_data[0] -= a; \r
  77                 this->m_data[1] -= a; \r
  78                 this->m_data[2] -= a; \r
  79         }\r
  80         template <typename T>  \r
  81         inline void Vec3<T>::operator+=(T a)\r
  82         { \r
  83                 this->m_data[0] += a; \r
  84                 this->m_data[1] += a; \r
  85                 this->m_data[2] += a; \r
  86         }\r
  87         template <typename T>  \r
  88         inline void Vec3<T>::operator/=(T a)\r
  89         { \r
  90                 this->m_data[0] /= a; \r
  91                 this->m_data[1] /= a; \r
  92                 this->m_data[2] /= a; \r
  93         }\r
  94         template <typename T>  \r
  95         inline void Vec3<T>::operator*=(T a)\r
  96         { \r
  97                 this->m_data[0] *= a; \r
  98                 this->m_data[1] *= a; \r
  99                 this->m_data[2] *= a; \r
 100         }  \r
 101         template <typename T>   \r
 102         inline Vec3<T> Vec3<T>::operator^ (const Vec3<T> & rhs) const\r
 103         {\r
 104                 return Vec3<T>(m_data[1] * rhs.m_data[2] - m_data[2] * rhs.m_data[1],\r
 105                                            m_data[2] * rhs.m_data[0] - m_data[0] * rhs.m_data[2],\r
 106                                            m_data[0] * rhs.m_data[1] - m_data[1] * rhs.m_data[0]);\r
 107         }\r
 108         template <typename T>\r
 109         inline T Vec3<T>::operator*(const Vec3<T> & rhs) const\r
 110         {\r
 111                 return (m_data[0] * rhs.m_data[0] + m_data[1] * rhs.m_data[1] + m_data[2] * rhs.m_data[2]);\r
 112         }        \r
 113         template <typename T>\r
 114         inline Vec3<T> Vec3<T>::operator+(const Vec3<T> & rhs) const\r
 115         {\r
 116                 return Vec3<T>(m_data[0] + rhs.m_data[0],m_data[1] + rhs.m_data[1],m_data[2] + rhs.m_data[2]);\r
 117         }\r
 118         template <typename T> \r
 119         inline  Vec3<T> Vec3<T>::operator-(const Vec3<T> & rhs) const\r
 120         {\r
 121                 return Vec3<T>(m_data[0] - rhs.m_data[0],m_data[1] - rhs.m_data[1],m_data[2] - rhs.m_data[2]) ;\r
 122         }     \r
 123         template <typename T> \r
 124         inline  Vec3<T> Vec3<T>::operator-() const\r
 125         {\r
 126                 return Vec3<T>(-m_data[0],-m_data[1],-m_data[2]) ;\r
 127         }     \r
 128 \r
 129         template <typename T> \r
 130         inline Vec3<T> Vec3<T>::operator*(T rhs) const\r
 131         {\r
 132                 return Vec3<T>(rhs * this->m_data[0], rhs * this->m_data[1], rhs * this->m_data[2]);\r
 133         }\r
 134         template <typename T>\r
 135         inline Vec3<T> Vec3<T>::operator/ (T rhs) const\r
 136         {\r
 137                 return Vec3<T>(m_data[0] / rhs, m_data[1] / rhs, m_data[2] / rhs);\r
 138         }\r
 139         template <typename T>\r
 140         inline Vec3<T>::Vec3(T a) \r
 141         { \r
 142                 m_data[0] = m_data[1] = m_data[2] = a; \r
 143         }\r
 144         template <typename T>\r
 145         inline Vec3<T>::Vec3(T x, T y, T z)\r
 146         {\r
 147                 m_data[0] = x;\r
 148                 m_data[1] = y;\r
 149                 m_data[2] = z;\r
 150         }\r
 151         template <typename T>\r
 152         inline Vec3<T>::Vec3(const Vec3 & rhs)\r
 153         {               \r
 154                 m_data[0] = rhs.m_data[0];\r
 155                 m_data[1] = rhs.m_data[1];\r
 156                 m_data[2] = rhs.m_data[2];\r
 157         }\r
 158         template <typename T>\r
 159         inline Vec3<T>::~Vec3(void){};\r
 160 \r
 161         template <typename T>\r
 162         inline Vec3<T>::Vec3() {}\r
 163     \r
 164     template<typename T>\r
 165     inline const bool Colinear(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c)\r
 166     {\r
 167         return  ((c.Z() - a.Z()) * (b.Y() - a.Y()) - (b.Z() - a.Z()) * (c.Y() - a.Y()) == 0.0 /*EPS*/) &&\r
 168                 ((b.Z() - a.Z()) * (c.X() - a.X()) - (b.X() - a.X()) * (c.Z() - a.Z()) == 0.0 /*EPS*/) &&\r
 169                 ((b.X() - a.X()) * (c.Y() - a.Y()) - (b.Y() - a.Y()) * (c.X() - a.X()) == 0.0 /*EPS*/);\r
 170     }\r
 171     \r
 172     template<typename T>\r
 173     inline const T Volume(const Vec3<T> & a, const Vec3<T> & b, const Vec3<T> & c, const Vec3<T> & d)\r
 174     {\r
 175         return (a-d) * ((b-d) ^ (c-d));\r
 176     }\r
 177 }\r
 178 #endif //HACD_VECTOR_INL