vec4.h

Go to the documentation of this file.

/*
 * $Id: vec4.h,v 1.5 2003/09/15 17:15:31 jmk Exp $
 */
///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2002
///////////////////////////////////////////////////////////////////////////

// vec4.h

#ifndef vec4_h
#define vec4_h

#include "mm.h"

namespace gutz {

template <class T>
class vec2;

template <class T>
class vec3;

template <class T>
class mat4;

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

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

    inline T* v ();
        inline const T* v () const;
    inline void set (const T, 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 vec4 abs () const;

    inline T dot (const vec4&) const;
    
    inline bool equal (const vec4&, T) const;

public:
    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;};
    union { T w; T A; T q; T v3;};
};

//-----------------------------------------------------------------------------
// typedefs
//-----------------------------------------------------------------------------

typedef vec4<char> vec4c;
typedef vec4<uchar> vec4uc;
typedef vec4<char> vec4b;
typedef vec4<uchar> vec4ub;
typedef vec4<short> vec4s;
typedef vec4<ushort> vec4us;
typedef vec4<int> vec4i;
typedef vec4<uint> vec4ui;
typedef vec4<llong> vec4ll;
typedef vec4<ullong> vec4ull;
typedef vec4<float> vec4f;
typedef vec4<double> vec4d;

#define str2vec4c str2vec4<char>
#define str2vec4uc str2vec4<uchar>
#define str2vec4b str2vec4<char>
#define str2vec4ub str2vec4<uchar>
#define str2vec4s str2vec4<short>
#define str2vec4us str2vec4<ushort>
#define str2vec4i str2vec4<int>
#define str2vec4ui str2vec4<uint>
#define str2vec4l str2vec4<long>
#define str2vec4ul str2vec4<ulong>
#define str2vec4ll str2vec4<llong>
#define str2vec4ull str2vec4<ullong>
#define str2vec4f str2vec4<float>
#define str2vec4d str2vec4<double>

//-----------------------------------------------------------------------------
// external functions
//-----------------------------------------------------------------------------
template <class T>
vec4<T>
operator* (const T, const vec4<T>&); /// defined below

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

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

template <class T>
bool
str2vec4 (const std::string& s, vec4<T>& v)
{
    std::istringstream z(s);
    vec4<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() || z.eof();
    z >> w.w;
    status = status || z.fail();
    if (!status) v = w;
    return status;
}


template <class T>
bool
str2vec4 (const std::string*, vec4<T>*);

//-----------------------------------------------------------------------------
// implementation
//-----------------------------------------------------------------------------

template <class T>
vec4<T>::vec4 ()
    : x(0), y(0), z(0), w(0) {}

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

template <class T>
vec4<T>::vec4 (T x0, T y0, T z0, T w0)
    : x(x0), y(y0), z(z0), w(w0) {}

template <class T>
vec4<T>::vec4 (const vec2<T>& v, const T c0, const T c1)
    : x(v.x), y(v.y), z(c0), w(c1) {}

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

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

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

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

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

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

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

template <class T>
vec4<T>&
vec4<T>::operator*= (const mat4<T>& M)
{
    vec4<T> temp(x, y, z, w);  
    x = M.m[ 0]*temp.x + M.m[ 4]*temp.y + M.m[ 8]*temp.z + M.m[12]*temp.w;
    y = M.m[ 1]*temp.x + M.m[ 5]*temp.y + M.m[ 9]*temp.z + M.m[13]*temp.w;
    z = M.m[ 2]*temp.x + M.m[ 6]*temp.y + M.m[10]*temp.z + M.m[14]*temp.w;
    w = M.m[ 3]*temp.x + M.m[ 7]*temp.y + M.m[11]*temp.z + M.m[15]*temp.w;
    return *this;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


#if __win32
inline 
vec4d
mm_castf2d (vec4f v)
{
    return vec4d(v.x, v.y, v.z, v.w);
}

inline 
vec4f
mm_castd2f (vec4d v)
{
    return vec4f((float)v.x, (float)v.y, (float)v.z, (float)v.w);
}
#else //__real_os
template <class T1, class T2>
vec4<T2>
mm_cast (vec4<T1> v)
{
    return vec4<T2>(v.x, v.y, v.z, v.w);
}
#endif

} // End of namespace gutz

#endif // vec4_h

---

Send questions, comments, and bug reports to: