vec3.h

Go to the documentation of this file.

/*
 * $Id: vec3.h,v 1.6 2003/10/09 08:27:51 jmk Exp $
 */
///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2002
///////////////////////////////////////////////////////////////////////////

// vec3.h

#ifndef vec3_h
#define vec3_h

#include "mm.h"

namespace gutz {

template <class T>
class vec2;

template <class T>
class vec4;

template <class T>
class mat3;

template <class T>
class vec3
{
public:  
        inline vec3 ();
    inline vec3 (const T );
    inline vec3 (const T, const T, const T);
    // inline vec3 (const vec3&); use default
    inline vec3 (const vec2<T>&, const T = 0);
    inline vec3 (const vec4<T>&);
    inline ~vec3 () {}
  
    // inline vec3& operator= (const vec3&); use default
    inline vec3& operator+= (const vec3&);
    inline vec3& operator-= (const vec3&);
    inline vec3& operator*= (const T);
    inline vec3& operator/= (const T);
    inline vec3& operator*= (const vec3&); // Component wise
    inline vec3& operator/= (const vec3&);
    inline vec3& operator*= (const mat3<T>&);
  
    inline vec3 operator+ (const vec3&) const;
    inline vec3 operator- (const vec3&) const;
    inline vec3 operator- () const;
    inline vec3 operator* (const T) const;
    inline vec3 operator/ (const T) const;
    inline vec3 operator* (const vec3&) const; // Component wise
    inline vec3 operator/ (const vec3&) const;

    inline bool operator== (const vec3&) const;
    inline bool operator!= (const vec3&) const;
    inline bool operator< (const vec3&) const;
    inline bool operator> (const vec3&) const;
    inline bool operator<= (const vec3&) const;
    inline bool operator>= (const vec3&) const;

    inline T* v ();
         inline const T* v () const;
    inline void set (const T, const T, const T);
    inline T& operator[] (const int);
         inline const T& operator[] (const int) const;

    inline T norm () const;
    inline T norm2 () const;
    inline T normalize ();

    inline vec3 abs () const;
    inline T dot (const vec3&) const;
    inline vec3 cross (const vec3&) const;

    inline bool equal (const vec3&, const T) const;

public:
        //data element names, (w) as in (w,h,d) is not allowed
        //   since "w" is taken by the (x,y,z,w) of vec4
    union { T x; T R; T s; T v0;};
    union { T y; T G; T t; T v1;};
    union { T z; T B; T r; T v2;};
};

//-----------------------------------------------------------------------------
// Usefull typedefs
//-----------------------------------------------------------------------------

typedef vec3<char> vec3c;
typedef vec3<uchar> vec3uc;
typedef vec3<char> vec3b;
typedef vec3<uchar> vec3ub;
typedef vec3<short> vec3s;
typedef vec3<ushort> vec3us;
typedef vec3<int> vec3i;
typedef vec3<uint> vec3ui;
typedef vec3<llong> vec3ll;
typedef vec3<ullong> vec3ull;
typedef vec3<float> vec3f;
typedef vec3<double> vec3d;

#define str2vec3c str2vec3<char>
#define str2vec3uc str2vec3<uchar>
#define str2vec3b str2vec3<char>
#define str2vec3ub str2vec3<uchar>
#define str2vec3s str2vec3<short>
#define str2vec3us str2vec3<ushort>
#define str2vec3i str2vec3<int>
#define str2vec3ui str2vec3<uint>
#define str2vec3l str2vec3<long>
#define str2vec3ul str2vec3<ulong>
#define str2vec3ll str2vec3<llong>
#define str2vec3ull str2vec3<ullong>
#define str2vec3f str2vec3<float>
#define str2vec3d str2vec3<double>

//-----------------------------------------------------------------------------
// external functions
//-----------------------------------------------------------------------------

template <class T>
inline vec3<T>
operator* (const T, const vec3<T>&); ///defined below

template <class T>
std::ostream&
operator<< (std::ostream& os, const vec3<T>& v)
{
    os << v.x << " " << v.y << " " << v.z;
    return os;
}

template <class T>
std::istream&
operator>> (std::istream& is, vec3<T>& v)
{
    is >> v.x;
    is >> v.y;
    is >> v.z;
    return is;
}

template <class T>
bool
str2vec3 (const std::string& s, vec3<T>& v)
{
    std::istringstream z(s);
    vec3<T> w;
    bool status = z.eof();
    z >> w.x;
    status = status || z.fail() || z.eof();
    z >> w.y;
    status = status || z.fail() || z.eof();
    z >> w.z;
    status = status || z.fail();
    if (!status) v = w;
    return status;
}

template <class T>
bool
str2vec3 (const std::string*, vec3<T>&);


//-----------------------------------------------------------------------------
// Implementation
//-----------------------------------------------------------------------------
template <class T>
vec3<T>::vec3 ()
    : x(0), y(0), z(0) {}

template <class T>
vec3<T>::vec3 (const T v0)
    : x(v0), y(v0), z(v0) {}

template <class T>
vec3<T>::vec3 (const T x0, const T y0, const T z0)
    : x(x0), y(y0), z(z0) {}

template <class T>
vec3<T>::vec3 (const vec2<T>& v, const T c)
    : x(v.x), y(v.y), z(c) {}

template <class T>
vec3<T>::vec3 (const vec4<T>& v)
    : x(v.x), y(v.y), z(v.z) {}

template <class T>
vec3<T>&
vec3<T>::operator+= (const vec3& v)
{
    x += v.x; y += v.y; z += v.z;
    return *this;
}

template <class T>
vec3<T>&
vec3<T>::operator-= (const vec3& v)
{
    x -= v.x; y -= v.y; z -= v.z;
    return *this;
}

template <class T>
vec3<T>&
vec3<T>::operator*= (const T c)
{
    x *= c; y *= c; z *= c;
    return *this;
}

template <class T>
vec3<T>&
vec3<T>::operator/= (const T c)
{
    x /= c; y /= c; z /= c;
    return *this;
}

template <class T>
vec3<T>&
vec3<T>::operator*= (const vec3<T>& v)
{
    x *= v.x; y *= v.y; z *= v.z;
    return *this;
}

template <class T>
vec3<T>&
vec3<T>::operator/= (const vec3<T>& v)
{
    x /= v.x; y /= v.y; z /= v.z;
    return *this;
}

template <class T>
vec3<T>&
vec3<T>::operator*= (const mat3<T>& M)
{
    vec3<T> temp(x, y, z);  
    x = M.m[0]*temp.x + M.m[3]*temp.y + M.m[6]*temp.z;
    y = M.m[1]*temp.x + M.m[4]*temp.y + M.m[7]*temp.z;
    z = M.m[2]*temp.x + M.m[5]*temp.y + M.m[8]*temp.z;
    return *this;
}

template <class T>
vec3<T>
vec3<T>::operator+ (const vec3& v) const
{
    return vec3(x + v.x, y + v.y, z + v.z);
}

template <class T>
vec3<T>
vec3<T>::operator- (const vec3& v) const
{
    return vec3(x - v.x, y - v.y, z - v.z);
}

template <class T>
vec3<T>
vec3<T>::operator- () const
{
    return vec3(-x, -y, -z);
}

template <class T>
vec3<T>
vec3<T>::operator* (const T c) const
{
    return vec3(c*x, c*y, c*z);
}

template <class T>
vec3<T>
vec3<T>::operator/ (const T c) const
{
    return vec3(x/c, y/c, z/c);
}

template <class T>
vec3<T>
vec3<T>::operator* (const vec3<T>& v) const
{
    return vec3(v.x*x, v.y*y, v.z*z);
}

template <class T>
vec3<T>
vec3<T>::operator/ (const vec3<T>& v) const
{
    return vec3(x/v.x, y/v.y, z/v.z);
}

template <class T>
bool
vec3<T>::operator== (const vec3<T>& v) const
{
    return (x == v.x && y == v.y && z == v.z);
}

template <class T>
bool
vec3<T>::operator!= (const vec3<T>& v) const
{
    return (x != v.x || y != v.y || z != v.z);
}

template <class T>
bool
vec3<T>::operator< (const vec3<T>& v) const
{
    return (x < v.x && y < v.y && z < v.z);
}

template <class T>
bool
vec3<T>::operator> (const vec3<T>& v) const
{
    return (x > v.x && y > v.y && z > v.z);
}

template <class T>
bool
vec3<T>::operator<= (const vec3<T>& v) const
{
    return (x <= v.x && y <= v.y && z <= v.z);
}

template <class T>
bool
vec3<T>::operator>= (const vec3<T>& v) const
{
    return (x >= v.x && y >= v.y && z >= v.z);
}

template <class T>
T*
vec3<T>::v ()
{
    return &x;
}

template <class T>
const T*
vec3<T>::v () const
{
    return &x;
}

template <class T>
void
vec3<T>::set (T x0, T y0, T z0)
{
    x = x0; y = y0; z = z0;
}

template <class T>
T&
vec3<T>::operator[] (const int i)
{
    return v()[i];
}

template <class T>
const T&
vec3<T>::operator[] (const int i) const
{
        return v()[i];
}

template <class T>
T
vec3<T>::normalize ()
{
    T norm = sqrt(x*x + y*y + z*z);
    T d = 1/norm;
    x *= d; y *= d; z *= d;
    return norm;
}

template <class T>
T
vec3<T>::norm () const
{
    return sqrt(x*x + y*y + z*z);
    //return (T)(sqrt(x*x + y*y + z*z));
}

template <class T>
T
vec3<T>::norm2 () const
{
    return x*x + y*y + z*z;
}

template <class T>
vec3<T>
vec3<T>::abs () const
{
    return vec3<T>(mm_abs(x), mm_abs(y), mm_abs(z));
}

template <class T>
T
vec3<T>::dot (const vec3<T>& v) const
{
    return x*v.x + y*v.y + z*v.z;
}

template <class T>
vec3<T>
vec3<T>::cross (const vec3<T>& v) const
{
    return vec3<T>(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x);
}

template <class T>
bool
vec3<T>::equal (const vec3& v, const T tol) const
{
    T dx = x - v.x;
    T dy = y - v.y;
    T dz = z - v.z;
    return (dx*dx + dy*dy + dz*dz) <= tol*tol;
}

template <class T>
vec3<T>
operator* (const T c, const vec3<T>& v)
{
    return vec3<T> (v.x*c, v.y*c, v.z*c);
}

template <class T>
bool
str2vec3 (const std::string* s, vec3<T>& v)
{
    if (!s) return true;
    return str2vec3(*s, v);
}



#if __win32
inline 
vec3i
mm_castf2i (vec3f v)
{
    return vec3i((int)v.x, (int)v.y, (int)v.z);
}

inline 
vec3d
mm_castf2d (vec3f v)
{
    return vec3d(v.x, v.y, v.z);
}

inline 
vec3f
mm_castd2f (vec3d v)
{
    return vec3f((float)v.x, (float)v.y, (float)v.z);
}
#else //__real_os
template <class T1, class T2>
vec3<T2>
mm_cast (vec3<T1> v)
{
    return vec3<T2>(v.x, v.y, v.z);
}
#endif
} // End if namespace gutz

#endif // vec3_h

---

Send questions, comments, and bug reports to: