Horus C++ Reference

00001 /*
00002  *  Copyright (c) 1998, University of Amsterdam, The Netherlands.
00003  *  All rights reserved.
00004  *
00005  *
00006  *  Author(s):
00007  *  Dennis Koelma (koelma@wins.uva.nl)
00008  *  Edo Poll (poll@wins.uva.nl)
00009  */
00010 
00011 #ifndef HxVec3Tem_h
00012 #define HxVec3Tem_h
00013 
00014 #include <cstdlib>
00015 #include "HxMath.h"
00016 
00017 #include "HxVec3Int.h"
00018 #include "HxVec3Double.h"
00019 
00020 
00021 
00022 template<class T>
00023 class HxVec3Tem {
00024 public:
00025                             HxVec3Tem();
00026                             HxVec3Tem(T x, T y, T z);
00027                             HxVec3Tem(const HxVec3Tem<T>& v);
00028 
00029                             HxVec3Tem(int v);
00030                             HxVec3Tem(double v);
00031                             HxVec3Tem(const HxVec3Int& v);
00032                             HxVec3Tem(const HxVec3Double& v);
00033 
00034     void*                   operator new(size_t, void * = 0);
00035 
00036     T                       x() const;
00037     T                       y() const;
00038     T                       z() const;
00039     T&                      value(int dimension); // dimension: 1, 2 or 3
00040 
00041                             operator int() const;
00042                             operator double() const;
00043                             operator HxVec3Int() const;
00044                             operator HxVec3Double() const;
00045 
00046     HxVec3Tem<T>&           operator+=(const HxVec3Tem<T>& v);
00047     HxVec3Tem<T>&           operator-=(const HxVec3Tem<T>& v);
00048     HxVec3Tem<T>&           operator*=(const HxVec3Tem<T>& v);
00049     HxVec3Tem<T>&           operator/=(const HxVec3Tem<T>& v);
00050 
00051 #ifdef __GNUC__
00052     friend HxVec3Tem<T>  operator+ <>(  const HxVec3Tem<T>& v1,
00053                     const HxVec3Tem<T>& v2);
00054     friend HxVec3Tem<T>  operator- <>(  const HxVec3Tem<T>& v1,
00055                     const HxVec3Tem<T>& v2);
00056     friend HxVec3Tem<T>  operator* <>(  const HxVec3Tem<T>& v1,
00057                     const HxVec3Tem<T>& v2);
00058     friend HxVec3Tem<T>  operator/ <>(  const HxVec3Tem<T>& v1,
00059                     const HxVec3Tem<T>& v2);
00060 #else
00061     friend inline HxVec3Tem<T>  operator+(  const HxVec3Tem<T>& v1,
00062                                             const HxVec3Tem<T>& v2);
00063     friend inline HxVec3Tem<T>  operator-(  const HxVec3Tem<T>& v1,
00064                                             const HxVec3Tem<T>& v2);
00065     friend inline HxVec3Tem<T>  operator*(  const HxVec3Tem<T>& v1,
00066                                             const HxVec3Tem<T>& v2);
00067     friend inline HxVec3Tem<T>  operator/(  const HxVec3Tem<T>& v1,
00068                                             const HxVec3Tem<T>& v2);
00069 #endif
00070 
00071     STD_OSTREAM&            put(STD_OSTREAM& os) const;
00072 private:
00073     T                       _values[3];
00074 };
00075 
00076 
00077 // these operations need to be declared here otherwise they won't be
00078 // instantiated (friend declarations do not count)
00079 
00080 template<class T>
00081 inline HxVec3Tem<T>
00082 operator+(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2);
00083 
00084 template<class T>
00085 inline HxVec3Tem<T>
00086 operator-(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2);
00087 
00088 template<class T>
00089 inline HxVec3Tem<T>
00090 operator*(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2);
00091 
00092 template<class T>
00093 inline HxVec3Tem<T>
00094 operator/(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2);
00095 
00096 template<class T>
00097 inline STD_OSTREAM&
00098 operator<<(STD_OSTREAM &os, const HxVec3Tem<T> v)
00099 {
00100     return v.put(os);
00101 }
00102 
00103 template<class T>
00104 inline
00105 HxVec3Tem<T>::HxVec3Tem() 
00106 { 
00107 }
00108 
00109 template<class T>
00110 inline
00111 HxVec3Tem<T>::HxVec3Tem(T x, T y, T z)
00112 {
00113     _values[0] = x;
00114     _values[1] = y;
00115     _values[2] = z;
00116 }
00117 
00118 template<class T>
00119 inline
00120 HxVec3Tem<T>::HxVec3Tem(const HxVec3Tem<T>& v)
00121 {
00122     _values[0] = v._values[0];
00123     _values[1] = v._values[1];
00124     _values[2] = v._values[2];
00125 }
00126 
00127 template<class T>
00128 inline
00129 HxVec3Tem<T>::HxVec3Tem(int v)
00130 {
00131     _values[0] = T(v);
00132     _values[1] = T(v);
00133     _values[2] = T(v);
00134 }
00135 
00136 template<class T>
00137 inline
00138 HxVec3Tem<T>::HxVec3Tem(double v)
00139 {
00140     _values[0] = T(v);
00141     _values[1] = T(v);
00142     _values[2] = T(v);
00143 }
00144 
00145 template<class T>
00146 inline
00147 HxVec3Tem<T>::HxVec3Tem(const HxVec3Int& v)
00148 {
00149     _values[0] = T(v.x());
00150     _values[1] = T(v.y());
00151     _values[2] = T(v.z());
00152 }
00153 
00154 template<class T>
00155 inline
00156 HxVec3Tem<T>::HxVec3Tem(const HxVec3Double& v)
00157 {
00158     _values[0] = T(v.x());
00159     _values[1] = T(v.y());
00160     _values[2] = T(v.z());
00161 }
00162 
00163 template<class T>
00164 inline void*
00165 HxVec3Tem<T>::operator new(size_t size, void *m) 
00166 {
00167     return m ? m : new char[size];
00168 }
00169 
00170 template<class T>
00171 inline T
00172 HxVec3Tem<T>::x() const
00173 {
00174     return _values[0];
00175 }
00176 
00177 template<class T>
00178 inline T
00179 HxVec3Tem<T>::y() const
00180 {
00181     return _values[1];
00182 }
00183 
00184 template<class T>
00185 inline T
00186 HxVec3Tem<T>::z() const
00187 {
00188     return _values[2];
00189 }
00190 
00191 template<class T>
00192 inline T&
00193 HxVec3Tem<T>::value(int dimension)
00194 {
00195     return _values[dimension - 1];
00196 }
00197 
00198 template<class T>
00199 inline
00200 HxVec3Tem<T>::operator int() const
00201 {
00202     return sqrt(double(_values[0])*_values[0] +
00203                 double(_values[1])*_values[1] +
00204                 double(_values[2])*_values[2]);
00205 }
00206 
00207 template<class T>
00208 inline
00209 HxVec3Tem<T>::operator double() const
00210 {
00211     return sqrt(double(_values[0])*_values[0] +
00212                 double(_values[1])*_values[1] +
00213                 double(_values[2])*_values[2]);
00214 }
00215 
00216 template<class T>
00217 inline
00218 HxVec3Tem<T>::operator HxVec3Int() const
00219 {
00220     return HxVec3Int(int(_values[0]), int(_values[1]), int(_values[2]));
00221 }
00222 
00223 template<class T>
00224 inline
00225 HxVec3Tem<T>::operator HxVec3Double() const
00226 {
00227     return HxVec3Double(double(_values[0]),
00228                         double(_values[1]),
00229                         double(_values[2]));
00230 }
00231 
00232 template<class T>
00233 inline HxVec3Tem<T>&
00234 HxVec3Tem<T>::operator+=(const HxVec3Tem<T>& v)
00235 {
00236     _values[0] += v._values[0];
00237     _values[1] += v._values[1];
00238     _values[2] += v._values[2];
00239     return *this;
00240 }
00241 
00242 template<class T>
00243 inline HxVec3Tem<T>&
00244 HxVec3Tem<T>::operator-=(const HxVec3Tem<T>& v)
00245 {
00246     _values[0] -= v._values[0];
00247     _values[1] -= v._values[1];
00248     _values[2] -= v._values[2];
00249     return *this;
00250 }
00251 
00252 template<class T>
00253 inline HxVec3Tem<T>&
00254 HxVec3Tem<T>::operator*=(const HxVec3Tem<T>& v)
00255 {
00256     _values[0] *= v._values[0];
00257     _values[1] *= v._values[1];
00258     _values[2] *= v._values[2];
00259     return *this;
00260 }
00261 
00262 template<class T>
00263 inline HxVec3Tem<T>&
00264 HxVec3Tem<T>::operator/=(const HxVec3Tem<T>& v)
00265 {
00266     _values[0] /= v._values[0];
00267     _values[1] /= v._values[1];
00268     _values[2] /= v._values[2];
00269     return *this;
00270 }
00271 
00272 template<class T>
00273 inline HxVec3Tem<T>
00274 operator+(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2)
00275 {
00276     return HxVec3Tem<T>(v1._values[0] + v2._values[0],
00277                         v1._values[1] + v2._values[1],
00278                         v1._values[2] + v2._values[2]);
00279 }
00280 
00281 template<class T>
00282 inline HxVec3Tem<T>
00283 operator-(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2)
00284 {
00285     return HxVec3Tem<T>(v1._values[0] - v2._values[0],
00286                         v1._values[1] - v2._values[1],
00287                         v1._values[2] - v2._values[2]);
00288 }
00289 
00290 template<class T>
00291 inline HxVec3Tem<T>
00292 operator*(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2)
00293 {
00294     return HxVec3Tem<T>(v1._values[0] * v2._values[0],
00295                         v1._values[1] * v2._values[1],
00296                         v1._values[2] * v2._values[2]);
00297 }
00298 
00299 template<class T>
00300 inline HxVec3Tem<T>
00301 operator/(const HxVec3Tem<T>& v1, const HxVec3Tem<T>& v2)
00302 {
00303     return HxVec3Tem<T>(v1._values[0] / v2._values[0],
00304                         v1._values[1] / v2._values[1],
00305                         v1._values[2] / v2._values[2]);
00306 }
00307 
00308 #ifdef INC_TEMPLATE_SRC
00309 #include "HxVec3Tem.c"
00310 #endif
00311 
00312 #endif
HxVec3Tem.h
