Vector3.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 __Vector3T_HPP
#define __Vector3T_HPP

#include <iostream>

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 (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; }
  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*= (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); 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 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; 

#endif

---