Vector2.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.                                                  //
//                                                                           //

// Two dimensional vector template

#ifndef __Vector2T_HPP
#define __Vector2T_HPP

#include <iostream>

template <class T>
class Vector2T
{
public:
      T   x;                    // x-component of the vector
      T   y;                    // y-component of the vector

            Vector2T  ()                  {}
            Vector2T  (float cx, float cy)        { x = (T)cx;  y = (T)cy;                }
            Vector2T  (double cx, double cy)        { x = (T)(cx);  y = (T)(cy);              }
template <class S>    Vector2T  (const Vector2T<S>& v)        { x = (T)v.x; y = (T)v.y; }
template <class S>    Vector2T& operator=	(const Vector2T<S>& v)  { x = (T)v.x; y = (T)v.y; return *this;     }
      
      Vector2T& clear   (void)              { x = (T)(0);  y = (T)(0);  return *this; }
      Vector2T& make    (double cx, double cy)      { x = (T)(cx); y = (T)(cy); return *this; }
      Vector2T& make    (double xy)           { x = (T)(xy); y = (T)(xy); return *this; }
      bool    operator==  (const Vector2T& src) const   { return (x == src.x && y == src.y);      }
      bool    operator!=  (const Vector2T& src) const   { return !(x == src.x && y == src.y);     }
          Vector2T& operator+=	(const Vector2T& v)        { x += v.x, y += v.y; return *this;       }   
          Vector2T& operator-=	(const Vector2T& v)        { x -= v.x, y -= v.y; return *this;       }
          Vector2T& operator*=	(double s)           { x = (T)(x*s), y = (T)(y*s); return *this; }
      Vector2T& operator/=	(double s)           { s = 1.0/s; x = (T)(x*s), y = (T)(y*s); return *this; }
      bool    isOne   (void) const          { return (x == 1.0f && y == 1.0f); }
      bool    isZero    (void) const          { return (x == 0.0f && y == 0.0f); }
      bool    isValid   (void) const          { return _finite(x) && _finite(y);  }
      double    length    (void) const          { return sqrt(x*x+y*y); }
      double    lengthSqr (void) const          { return x*x+y*y; }
          Vector2T& negate    (void)              { x=-x; y=-y; return *this; }
          Vector2T& normalize (double len = 1.0)        { double l = length(); if (l!=0.0) *this *= (len/l); return *this; }
          Vector2T& scale   (const Vector2T& v)       { x *= v.x, y *= v.y; return *this; }
          Vector2T& descale   (const Vector2T& v)       { x /= v.x, y /= v.y; return *this; }
          Vector2T& rotate    (double s, double c)      { T t = x; x = (T)(x*c+y*-s); y = (T)(t*s+y*c); return *this; }
          Vector2T& rotate    (double angle)          { return rotate(sin(angle), cos(angle)); }
      double    angle   (void) const          { return atan2(y, x); }
      Vector2T& 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; return *this; }
  const T&      operator[]	(int i) const          { return ((T*)this)[i]; }
      T&      operator[]	(int i)              { return ((T*)this)[i]; }
};

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

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

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

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

typedef Vector2T<float> Vector2; 

#endif

---