Vector4.hpp

Go to the documentation of this file.

//                                                                           //
// Copyright 1998-2000 by Janne Kontkanen. All Rights reserved. Usage or     //
// redistribution of this material in source or binary form is prohibited    //
// unless otherwise agreed.                                                  //
//                                                                           //

// Three dimensional vector template

#ifndef __Vector4T_HPP
#define __Vector4T_HPP

#include <iostream>

template <class T>
class Vector4T
{
public:
      T   x;                    // x-component of the vector
      T   y;                    // y-component of the vector
      T   z;                    // z-component of the vector
      T       w;
            Vector4T  ()                  {}
            Vector4T  (float cx, float cy, float cz, float cw)    { x = (T)cx;  y = (T)cy;    z = (T)cz; w = (T) cw; }
            Vector4T  (double cx, double cy, double cz, double cw)  { x = (T)(cx);  y = (T)(cy);  z = (T)cz; w = (T) cw; }
template <class S>    Vector4T  (const Vector4T<S>& v)        { x = (T)v.x; y = (T)v.y;   z = (T)v.z; w = (T) v.w; }
template <class S>    Vector4T& operator=	(const Vector4T<S>& v)    { x = (T)v.x; y = (T)v.y; z = (T)v.z; w = (T) v.w; return *this;      }
      
      Vector4T& clear   (void)              { x = (T)(0);  y = (T)(0); z = (T)(0); w = (T)(0); return *this;  }
      bool    operator==  (const Vector4T& src) const   { return (x == src.x && y == src.y && z == src.z && w == src.w);  }
      bool    operator!=  (const Vector4T& src) const   { return !(x == src.x && y == src.y && z == src.z && w == src.w); }

          Vector4T& operator+=	(const Vector4T& v)        { x += v.x; y += v.y; z += v.z;  w += v.w; return *this;        }   
          Vector4T& operator-=	(const Vector4T& v)        { x -= v.x; y -= v.y; z -= v.z;  w -= v.w; return *this;        }

          Vector4T& operator*=	(double s)           { x = (T)(x*s), y = (T)(y*s); z = (T)(z*s); w = (T)(w*s); return *this; }
      Vector4T& operator/=	(double s)           { s = 1.0/s; x = (T)(x*s), y = (T)(y*s); z = (T)(z*s); w = (T) (w*s); return *this; }
      bool    isOne   (void) const          { return (x == 1.0f && y == 1.0f && z == 1.0f && w == 1.0f); }
      bool    isZero    (void) const          { return (x == 0.0f && y == 0.0f && z == 0.0f && w == 0.0f); }
  //      bool    isValid   (void) const          { return _finite(x) && _finite(y) && _finite(z); && _finite(w); }
      double    length    (void) const          { return sqrt(x*x+y*y+z*z+w*w); }
      double    lengthSqr (void) const          { return x*x+y*y+z*z+w*w; }
          Vector4T& normalize (double len = 1.0)        { double l = length(); if (l!=0.0) *this *= (len/l); return *this; }
          Vector4T& scale   (const Vector4T& v)       { x *= v.x; y *= v.y; z *= v.z; w *= v.w; return *this; }
          Vector4T& descale   (const Vector4T& v)       { x /= v.x, y /= v.y; z /= v.z; w /= v.w; return *this; }
  const T&      operator[]	(int i) const          { return ((T*)this)[i]; }
      T&      operator[]	(int i)              { return ((T*)this)[i]; }
};

template <class T> inline Vector4T<T> operator+	(const Vector4T<T>& v1, const Vector4T<T>& v2)  { Vector4T<T> t(v1); t+=v2; return t; }
template <class T> inline Vector4T<T> operator-	(const Vector4T<T>& v1, const Vector4T<T>& v2)  { Vector4T<T> t(v1); t-=v2; return t; }
template <class T> inline Vector4T<T> operator*	(const Vector4T<T>& v, const double s)    { Vector4T<T> t(v); t*=s; return t; }
template <class T> inline Vector4T<T> operator*	(const double s, const Vector4T<T>& v)    { return v*s; }
template <class T> inline Vector4T<T> operator/	(const Vector4T<T>& v, const double s)    { double r = 1.0/s; return v*r; }
template <class T> inline Vector4T<T> operator-	(const Vector4T<T>& v)            { return Vector4T<T>(-v.x, -v.y, -v.z, -v.w); }

template <class T>
inline float abs(Vector4T<T> t)
{
  return t.length();
}

template <class T>
inline float dot(const Vector4T<T>& a, const Vector4T<T>& b)
{
  return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3];
}

template <class T>
inline std::ostream &operator<<(std::ostream &os, const Vector4T<T> &t)
{
  os << t.x << ' ' << t.y << ' ' << t.z << ' ' << t.w;
  return os;
}

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

typedef Vector4T<float> Vector4; 

#endif

---