VirtualRenderingSystem: vec.h Source File

00001 /******************************************************************************
00002  * VRS - The Virtual Rendering System
00003  * Copyright (C) 2000-2008 Computer Graphics Systems Group at the 
00004  * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
00005  *
00006  * This  library  is  free  software; you can redistribute it and/or  modify it
00007  * under the terms of the GNU Lesser General Public  License  as  published  by
00008  * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
00009  * your option) any later version. This library  is  distributed  in  the  hope
00010  * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
00011  * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
00012  * GNU Lesser General Public License for more details. You should have received
00013  * a copy of the GNU Lesser+ General Public License along with this library; if
00014  * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
00015  * Boston, MA, 02111-1307, USA.
00016  ******************************************************************************/
00017 
00018 #ifndef VRS_VEC_H
00019 #define VRS_VEC_H
00020 
00021 // for serializationmanager
00022 #include <vrs/sharedobj.h>
00023 
00024 #include <cmath>
00025 #include <iostream>
00026 
00027 namespace VRS {
00028 
00031     template<unsigned int DIM, typename T>
00032     class Vec {
00033     public:
00035         typedef T value_type;
00036 
00037     public:
00039         explicit Vec(T all = T(0)) { for(size_t i = 0; i < DIM; ++i) { m_data[i] = all; } }
00040 
00043         template<unsigned int DIM2, typename S>
00044         explicit Vec(Vec<DIM2, S> const& other) { for(size_t i = 0; i < DIM; ++i) { m_data[i] = static_cast<T>(other[i]); } VRS_STATIC_ASSERT(DIM2 >= DIM); }
00045 
00046     public:
00048         Vec(T x, T y, T z, T w) { m_data[0] = x; m_data[1] = y; m_data[2] = z; m_data[3] = w; VRS_STATIC_ASSERT(DIM == 4); }
00050         Vec(Vec<3, T> const& xyz, T w) { m_data[0] = xyz[0]; m_data[1] = xyz[1]; m_data[2] = xyz[2]; m_data[3] = w; VRS_STATIC_ASSERT(DIM == 4); }
00052         Vec(T x, Vec<3, T> const& yzw) { m_data[0] = x; m_data[1] = yzw[0]; m_data[2] = yzw[1]; m_data[3] = yzw[2]; VRS_STATIC_ASSERT(DIM == 4); }
00054         Vec(Vec<2, T> const& xy, T z, T w) { m_data[0] = xy[0]; m_data[1] = xy[1]; m_data[2] = z; m_data[3] = w; VRS_STATIC_ASSERT(DIM == 4); }
00056         Vec(Vec<2, T> const& xy, Vec<2, T> const& zw) { m_data[0] = xy[0]; m_data[1] = xy[1]; m_data[2] = zw[0]; m_data[3] = zw[1]; VRS_STATIC_ASSERT(DIM == 4); }
00058         Vec(T x, T y, Vec<2, T> const& zw) { m_data[0] = x; m_data[1] = y; m_data[2] = zw[0]; m_data[3] = zw[1]; VRS_STATIC_ASSERT(DIM == 4); }
00060         Vec(T x, Vec<2, T> const& yz, T w) { m_data[0] = x; m_data[1] = yz[0]; m_data[2] = yz[1]; m_data[3] = w; VRS_STATIC_ASSERT(DIM == 4); }
00061 
00062     public:
00064         Vec(T x, T y, T z) { m_data[0] = x; m_data[1] = y; m_data[2] = z; VRS_STATIC_ASSERT(DIM == 3); }
00066         Vec(Vec<2, T> const& xy, T z) { m_data[0] = xy[0]; m_data[1] = xy[1]; m_data[2] = z; VRS_STATIC_ASSERT(DIM == 3); }
00068         Vec(T x, Vec<2, T> const& yz) { m_data[0] = x; m_data[1] = yz[0]; m_data[2] = yz[1]; VRS_STATIC_ASSERT(DIM == 3); }
00069 
00070     public:
00072         Vec(T x, T y) { m_data[0] = x; m_data[1] = y; VRS_STATIC_ASSERT(DIM == 2); }
00073 
00074     public:
00076         T const& operator[](size_t index) const { assert(index < DIM); return m_data[index]; }
00078         T&       operator[](size_t index)       { assert(index < DIM); return m_data[index]; }
00079 
00081         T const& x() const { return m_data[0]; VRS_STATIC_ASSERT(DIM >= 1); }
00083         T      & x()       { return m_data[0]; VRS_STATIC_ASSERT(DIM >= 1); }
00085         T const& y() const { return m_data[1]; VRS_STATIC_ASSERT(DIM >= 2); }
00087         T      & y()       { return m_data[1]; VRS_STATIC_ASSERT(DIM >= 2); }
00089         T const& z() const { return m_data[2]; VRS_STATIC_ASSERT(DIM >= 3); }
00091         T      & z()       { return m_data[2]; VRS_STATIC_ASSERT(DIM >= 3); }
00093         T const& w() const { return m_data[3]; VRS_STATIC_ASSERT(DIM >= 4); }
00095         T      & w()       { return m_data[3]; VRS_STATIC_ASSERT(DIM >= 4); }
00096 
00098         Vec<2, T> xy() const { return Vec<2, T>(m_data[0], m_data[1]); VRS_STATIC_ASSERT(DIM >= 2); }
00100         Vec<3, T> xyz() const { return Vec<3, T>(m_data[0], m_data[1], m_data[2]); VRS_STATIC_ASSERT(DIM >= 3); }
00102         Vec<4, T> xyzw() const { return Vec<4, T>(m_data[0], m_data[1], m_data[2], m_data[3]); VRS_STATIC_ASSERT(DIM >= 4); }
00103 
00104         // add some more of the swizzling operators?
00105 
00106     public:
00108         bool operator==(Vec<DIM, T> const& other) const { for(size_t i = 0; i < DIM; ++i) { if(m_data[i] != other[i]) { return false; } } return true; }
00110         bool operator<(Vec<DIM, T> const& other) const { for(size_t i = 0; i < DIM; ++i) { if(m_data[i] < other[i]) { return true; } if(m_data[i] > other[i]) { return false; } } return false; }
00111 
00112     public:
00114         Vec<DIM, T>& operator+=(Vec<DIM, T> const& other) { for(size_t i = 0; i < DIM; ++i) { m_data[i] += other[i]; } return *this; }
00116         Vec<DIM, T>& operator-=(Vec<DIM, T> const& other) { for(size_t i = 0; i < DIM; ++i) { m_data[i] -= other[i]; } return *this; }
00118         Vec<DIM, T>& operator*=(Vec<DIM, T> const& other) { for(size_t i = 0; i < DIM; ++i) { m_data[i] *= other[i]; } return *this; }
00120         Vec<DIM, T>& operator/=(Vec<DIM, T> const& other) { for(size_t i = 0; i < DIM; ++i) { m_data[i] /= other[i]; } return *this; }
00121 
00122     public:
00124         Vec<DIM, T>& operator+=(T s) { for(size_t i = 0; i < DIM; ++i) { m_data[i] += s; } return *this; }
00126         Vec<DIM, T>& operator-=(T s) { for(size_t i = 0; i < DIM; ++i) { m_data[i] -= s; } return *this; }
00128         Vec<DIM, T>& operator*=(T s) { for(size_t i = 0; i < DIM; ++i) { m_data[i] *= s; } return *this; }
00130         Vec<DIM, T>& operator/=(T s) { for(size_t i = 0; i < DIM; ++i) { m_data[i] /= s; } return *this; }
00131 
00132     private:
00133         T m_data[DIM];
00134     }; // class Vec<DIM, T>
00135 
00137     template<unsigned int DIM, typename T>
00138     inline std::ostream& operator<<(std::ostream& out, const Vec<DIM, T>& vec) {
00139         for(size_t i = 0; i < DIM; ++i) {
00140             out << ((i > 0) ? ", " : "") << vec[i];
00141         }
00142         return out;
00143     }
00144 
00146     template<unsigned int DIM, typename T>
00147     bool operator!=(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { return !(v0 == v1); }
00148 
00150     template<unsigned int DIM, typename T>
00151     bool operator>(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { return (v1 < v0); }
00153     template<unsigned int DIM, typename T>
00154     bool operator<=(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { return !(v0 > v1); }
00156     template<unsigned int DIM, typename T>
00157     bool operator>=(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { return !(v0 < v1); }
00158 
00160     template<unsigned int DIM, typename T>
00161     inline Vec<DIM, T> operator+(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { Vec<DIM, T> result = v0; return (result += v1); }
00163     template<unsigned int DIM, typename T>
00164     inline Vec<DIM, T> operator-(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { Vec<DIM, T> result = v0; return (result -= v1); }
00166     template<unsigned int DIM, typename T>
00167     inline Vec<DIM, T> operator*(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { Vec<DIM, T> result = v0; return (result *= v1); }
00169     template<unsigned int DIM, typename T>
00170     inline Vec<DIM, T> operator/(Vec<DIM, T> const& v0, Vec<DIM, T> const& v1) { Vec<DIM, T> result = v0; return (result /= v1); }
00171 
00173     template<unsigned int DIM, typename T>
00174     inline Vec<DIM, T> operator+(Vec<DIM, T> const& v0, T s1) { return (v0 + Vec<DIM, T>(s1)); }
00176     template<unsigned int DIM, typename T>
00177     inline Vec<DIM, T> operator-(Vec<DIM, T> const& v0, T s1) { return (v0 - Vec<DIM, T>(s1)); }
00179     template<unsigned int DIM, typename T>
00180     inline Vec<DIM, T> operator*(Vec<DIM, T> const& v0, T s1) { return (v0 * Vec<DIM, T>(s1)); }
00182     template<unsigned int DIM, typename T>
00183     inline Vec<DIM, T> operator/(Vec<DIM, T> const& v0, T s1) { return (v0 / Vec<DIM, T>(s1)); }
00184 
00186     template<unsigned int DIM, typename T>
00187     inline Vec<DIM, T> operator+(T s0, Vec<DIM, T> const& v1) { return (Vec<DIM, T>(s0) + v1); }
00189     template<unsigned int DIM, typename T>
00190     inline Vec<DIM, T> operator-(T s0, Vec<DIM, T> const& v1) { return (Vec<DIM, T>(s0) - v1); }
00192     template<unsigned int DIM, typename T>
00193     inline Vec<DIM, T> operator*(T s0, Vec<DIM, T> const& v1) { return (Vec<DIM, T>(s0) * v1); }
00195     template<unsigned int DIM, typename T>
00196     inline Vec<DIM, T> operator/(T s0, Vec<DIM, T> const& v1) { return (Vec<DIM, T>(s0) / v1); }
00197 
00199     template<unsigned int DIM, typename T>
00200     inline Vec<DIM, T> operator-(Vec<DIM, T> const& v) { return (T(-1) * v); }
00201 
00203     template<unsigned int DIM, typename T>
00204     inline Vec<DIM, T>& operator++(Vec<DIM, T>& v) { return (v += T(1)); }
00206     template<unsigned int DIM, typename T>
00207     inline Vec<DIM, T> operator++(Vec<DIM, T>& v, int) { const Vec<DIM, T> result = v; v += T(1); return result; }
00209     template<unsigned int DIM, typename T>
00210     inline Vec<DIM, T>& operator--(Vec<DIM, T>& v) { return (v -= T(1)); }
00212     template<unsigned int DIM, typename T>
00213     inline Vec<DIM, T> operator--(Vec<DIM, T>& v, int) { const Vec<DIM, T> result = v; v -= T(1); return result; }
00214 
00215 } // namespace VRS
00216 
00217 #include <vrs/vec_mat_ops.h>
00218 
00219 #endif // VRS_VEC_H