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