Vector3.hpp

Go to the documentation of this file.

// Three dimensional vector template

#ifndef __Vector3T_HPP
#define __Vector3T_HPP

#include <iostream>
#include "Math.hpp"

template <class T>
class Matrix3T;

template <class T>
class Vector3T
{
public:
  T   x;                    // x-component of the vector
  T   y;                    // y-component of the vector
  T   z;                    // z-component of the vector
  Vector3T  ()                  {}
  Vector3T  (float cx, float cy, float cz)    { x = (T)cx;  y = (T)cy;    z = (T)cz; }
  Vector3T  (int cx, int cy, int cz)        { x = (T)cx;  y = (T)cy;    z = (T)cz; }
  Vector3T  (double cx, double cy, float cz)  { x = (T)(cx);  y = (T)(cy);  z = (T)cz; }
  template <class S>    Vector3T  (const Vector3T<S>& v)        { x = (T)v.x; y = (T)v.y;   z = (T)v.z; }
  template <class S>    Vector3T& operator=	(const Vector3T<S>& v)    { x = (T)v.x; y = (T)v.y; z = (T)v.z; return *this;     }
  
  Vector3T& clear   (void)              { x = (T)(0);  y = (T)(0); z = (T)(0); return *this;  }
  Vector3T& make    (double cx, double cy, double cz) { x = (T)(cx); y = (T)(cy); z = (T)(cz); return *this;  }
  Vector3T& make    (double xyz)          { x = (T)(xyz); y = (T)(xyz); z = (T)(xyz); return *this; }
  //jussi compatibility:
  Vector3T& set   (double cx, double cy, double cz) { x = (T)(cx); y = (T)(cy); z = (T)(cz); return *this;  }
  Vector3T& set   (double xyz)          { x = (T)(xyz); y = (T)(xyz); z = (T)(xyz); return *this; }
  
  bool          operator==  (const Vector3T& src) const   { return (x == src.x && y == src.y && z == src.z);      }
  bool    operator!=  (const Vector3T& src) const   { return !(x == src.x && y == src.y && z == src.z);     }
  
  Vector3T& operator+=	(const Vector3T& v)        { x += v.x; y += v.y; z += v.z;  return *this; }    
  Vector3T& operator-=	(const Vector3T& v)        { x -= v.x; y -= v.y; z -= v.z;  return *this; }
  Vector3T&     operator*=      (const Matrix3T<T>& m);

  void   rotateAbout( const Vector3T<T> &v, const T &d );  
  Vector3T& operator*=	(double s)           { x = (T)(x*s), y = (T)(y*s); z = (T)(z*s); return *this; }
  Vector3T& operator/=	(double s)           { s = 1.0/s; x = (T)(x*s), y = (T)(y*s); z = (T)(z*s); return *this; }
  bool    isOne   (void) const          { return (x == 1.0f && y == 1.0f && z == 1.0f); }
  bool    isZero    (void) const          { return (x == 0.0f && y == 0.0f && z == 0.0f); }
  bool    isValid   (void) const          { return _finite(x) && _finite(y) && _finite(z);  }
  double    length    (void) const          { return sqrt(x*x+y*y+z*z); }
  double    lengthSqr (void) const          { return x*x+y*y+z*z; }
  Vector3T& negate    (void)              { x=-x; y=-y; z=-z; return *this; }
  Vector3T& normalize (double len = 1.0)        { double l = length(); if (l!=0.0) *this *= (len/l); else {x = 1; y = 0; z = 0;}  return *this; }
  Vector3T& scale   (const Vector3T& v)       { x *= v.x; y *= v.y; z *= v.z; return *this; }
  Vector3T& descale   (const Vector3T& v)       { x /= v.x, y /= v.y; z /= v.z; return *this; }
  Vector3T& clampUnit (void)              { if(x <= (T)0.0) x = (T)0.0; else if(x >= (T)1.0) x = (T)1.0; if(y <= (T)0.0) y = (T)0.0; else if(y >= (T)1.0) y = (T)1.0; if(z <= (T)0.0) z = (T)0.0; else if(z >= (T)1.0) z = (T)1.0; return *this; }
  const T&      operator[]	(int i) const          { return ((T*)this)[i]; }
  T&      operator[]	(int i)              { return ((T*)this)[i]; }
};


template<class T>
inline void Vector3T<T>::rotateAbout( const Vector3T<T> &v, const T &d )
{
    // see Graphics Gems I, Rotation Tools, Michael E. Pique (page 466)
    // s = sin( d ); c = cos( d ); t = 1 - cos( d ); v /= |v|;
    // x' = (t*vx*vx+c)    * x + (t*vx*vy-s*vz) * y + (t*vx*vz+s*vy) * z;
    // y' = (t*vx*vy+s*vz) * x + (t*vy*vy+c)    * y + (t*vy*vz-s*vx) * z;
    // z' = (t*vx*vz-s*vy) * x + (t*vy*vz+s*vx) * y + (t*vz*vz+c)    * z;
    T s, c, t;
    Vector3T<T> tmp( *this );
    Vector3T<T> vn( v );
    c = (T)cos( d );
    s = (T)sin( d );
    t = (T)1 - c;
    vn.normalize( );
    x = (t*vn.x*vn.x+c)      * tmp.x + (t*vn.x*vn.y-s*vn.z) * tmp.y
                                     + (t*vn.x*vn.z+s*vn.y) * tmp.z;
    y = (t*vn.x*vn.y+s*vn.z) * tmp.x + (t*vn.y*vn.y+c)      * tmp.y
                                     + (t*vn.y*vn.z-s*vn.x) * tmp.z;
    z = (t*vn.x*vn.z-s*vn.y) * tmp.x + (t*vn.y*vn.z+s*vn.x) * tmp.y
                                     + (t*vn.z*vn.z+c)      * tmp.z;
}


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

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

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

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

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

template <class T>
inline Vector3T<T> cross(const Vector3T<T>& a, const Vector3T<T>& b)
{
  Vector3T<T> v((a[1]*b[2])-(a[2]*b[1]),
       -(a[0]*b[2])+(a[2]*b[0]),
       (a[0]*b[1])-(a[1]*b[0]));
  return v;
}

typedef Vector3T<float> Vector3; 

inline Vector3 randOnSphere() 
{ 
  float d,x,y,z;
  do
  {
    x = 2.0*urand( )-1.0; y = 2.0*urand( )-1.0; z = 2.0*urand( )-1.0;
    d = x*x+y*y+z*z;
  }
  while( d > 1.0f || d == 0.0);
  return Vector3(x,y,z)/sqrt(d);
}

inline Vector3 randInSphere()
{
  float d,x,y,z;
  do
  {
    x = 2.0*urand( )-1.0; y = 2.0*urand( )-1.0; z = 2.0*urand( )-1.0;
    d = x*x+y*y+z*z;
  }
  while( d > 1.0f );
  return Vector3(x,y,z);
}

#endif

---