---

MyVector2x.h

//define classname and constructor, for example class VECTOR3f. define SCALAR, VECTOR
//Possible options
//
// #define VECTOR Vektor3f
// #define SCALAR float
// #define USEMATRIX
// #define VECTORMATRIX Matrix4f
// #define SCALARUNSIGNED

public:

  union
  {
    SCALAR array[2];
    struct { SCALAR x, y; };  //Anonymous structure
    struct { SCALAR u, v; };  //Anonymous structure
  };

  inline void set(SCALAR px, SCALAR py)
  {
    x = px;
    y = py;
  }

  inline void setNull()
  {
    x = y = 0;
  }


  //Operators for this VECTOR class
  SCALAR operator[](const long i)
  { //SCALAR array
    assert(i >= 0 && i < 2);
    return(array[i]);
  }

  SCALAR operator[](const unsigned long i)
  { //SCALAR array
    assert(i < 2);
    return(array[i]);
  }

  SCALAR operator[](const int i)
  { //SCALAR array
    assert(i >= 0 && i < 2);
    return(array[i]);
  }

  SCALAR operator[](const unsigned int i)
  { //SCALAR array
    assert(i < 2);
    return(array[i]);
  }

  SCALAR operator[](const short i)
  { //SCALAR array
    assert(i >= 0 && i < 2);
    return(array[i]);
  }

  SCALAR operator[](const unsigned short i)
  { //SCALAR array
    assert(i < 2);
    return(array[i]);
  }

  SCALAR operator[](const char i)
  { //SCALAR array
    assert(i >= 0 && i < 2);
    return(array[i]);
  }

  SCALAR operator[](const unsigned char i)
  { //SCALAR array
    assert(i < 2);
    return(array[i]);
  }



  inline bool operator==(VECTOR &pv)
  { //Are these VECTORs equal ?
    return(x == pv.x && y == pv.y);
  }

  bool nearlyEqual(VECTOR& pv, SCALAR e)
  {
    return(fabs(x-pv.x) < e && fabs(y-pv.y) < e);
  }



  inline bool operator!=(VECTOR &pv)
  { //Are these VECTORs different ?
    return(x != pv.x || y != pv.y);
  }

#ifndef SCALARUNSIGNED
  inline VECTOR operator-()
  { //negate
    return(VECTOR(-x, -y));
  }
#endif

  inline VECTOR& operator=(VECTOR &pv)
  {
    x = pv.x;
    y = pv.y;
    return(*this);
  }

  inline VECTOR& operator=(float &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(double &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(long &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(unsigned long &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(int &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(unsigned int &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(short &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(unsigned short &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(char &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }

  inline VECTOR& operator=(unsigned char &ps)
  {
    x = y = (SCALAR)ps;
    return(*this);
  }



  inline operator SCALAR*()
  {
    return(array);
  }


  //VECTOR x VECTOR operations

  inline VECTOR operator+(VECTOR &pv)
  { //VECTOR addition
    return(VECTOR(x + pv.x, y + pv.y));
  }

  inline VECTOR& operator+=(VECTOR &pv)
  { //self VECTOR addition
    x += pv.x;
    y += pv.y;
    return(*this);
  }

  inline VECTOR operator-(VECTOR &pv)
  { //VECTOR subtraction
    return(VECTOR(x - pv.x, y - pv.y));
  }

  inline VECTOR& operator-=(VECTOR &pv)
  { //self VECTOR subtraction
    x -= pv.x;
    y -= pv.y;
    return(*this);
  }


  inline VECTOR operator*(VECTOR &pv)
  { //VECTOR multiply
    return(VECTOR(x * pv.x, y * pv.y));
  }

  inline VECTOR& operator*=(VECTOR &pv)
  { //self VECTOR multiply
    x *= pv.x;
    y *= pv.y;
  }

  inline VECTOR operator/(VECTOR &pv)
  { //VECTOR division
    return(VECTOR(x / pv.x, y / pv.y));
  }

  inline VECTOR& operator/=(VECTOR &pv)
  { //self VECTOR division
    x /= pv.x;
    y /= pv.y;
  }


  // Skalar operations

  inline VECTOR operator+(SCALAR s)
  { //VECTOR + Scalar
    return(VECTOR(x + s, y + s));
  }

  inline VECTOR& operator+=(SCALAR s)
  { //VECTOR + Scalar
    x += s;
    y += s;
  }

  inline VECTOR operator-(SCALAR s)
  { //VECTOR - Scalar
    return(VECTOR(x - s, y - s));
  }

  inline VECTOR& operator-=(SCALAR s)
  { //VECTOR - Scalar
    x -= s;
    y -= s;
  }

  inline VECTOR operator*(SCALAR s)
  { //VECTOR * Scalar multiplication
    return(VECTOR(x * s, y * s));
  }

  inline VECTOR& operator*=(SCALAR s)
  { //VECTOR * Scalar multiplication
    x *= s;
    y *= s;
    return(*this);
  }

  friend inline VECTOR operator*(SCALAR& s, VECTOR& pv);

  inline VECTOR operator/(SCALAR s)
  { //VECTOR / Scalar division
    return(VECTOR(x / s, y / s));
  }

  inline VECTOR& operator/=(SCALAR s)
  { //VECTOR / Scalar division
    x /= s;
    y /= s;
    return(*this);
  }


  // Several helper methods

  inline void Normalize()
  {
    SCALAR f = getLength();
    x /= f;
    y /= f;
  }

  inline void unit()
  {
    Normalize();
  }


  inline SCALAR getLength()
  {
    // Calculate vector magnitude |pv| = sqrt(x*x + y*y + z*z);
    return((SCALAR)sqrt(x*x + y*y));
  }

  inline SCALAR len()
  {
    return(getLength());
  }

  inline SCALAR getQuadLength()
  {
    // Calculate quadratic vector magnitude |pv|² = x*x + y*y + z*z;
    return(x*x + y*y);
  }

  inline SCALAR quadlen()
  {
    return(getQuadLength());
  }

/*
  inline VECTOR getCrossProduct(VECTOR &pv)
  { //Calculates Cross product = Normal, //Computergraphics S.608
    return(VECTOR(y*pv.z - z*pv.y, z*pv.x - x*pv.z, x*pv.y - y*pv.x));
  }

  inline VECTOR cross(VECTOR &pv)
  {
    return(getCrossProduct(pv));
  }
*/

  //value examples (if normalized): angle = 0 --> 1, angle = 90 --> 0, angle = 180 --> -1 usw.
  inline SCALAR getDotProduct(VECTOR &pv)
  { //Calculates Dot product = |v1|*|v2|*cos(theta), //Computergraphics S.607
    return(x*pv.x + y*pv.y);  //= |v1|*|v2|*cos(theta)
  }

  inline SCALAR dot(VECTOR &pv)
  { 
    return(getDotProduct(pv));
  }
  

  inline SCALAR getAngle(VECTOR &pv)
  { //Calculates the angle between this two VECTORs
    return((SCALAR)(acos((double)getDotProduct(pv)) * (double)MUL_RAD_TO_DEG)); //convert from rad angle to deg angle
  }

  inline SCALAR angle(VECTOR &pv)
  {
    return(getAngle(pv));
  }


  inline SCALAR getDistance(VECTOR &pv)
  { //Calculates the distance between this two VECTORs
    VECTOR t(pv.x - x, pv.y - y);
    return(t.getLength());
  }

  inline SCALAR getQuadDistance(VECTOR &pv)
  { //Calculates the quadric distance between this two VECTORs
    VECTOR t(pv.x - x, pv.y - y);
    return(t.getQuadLength());
  }

/*
  inline void RotateX(SCALAR angle)
  { //Computergraphics S.410
    double a = (double)angle * (double)MUL_DEG_TO_RAD;  //convert from deg to rad
    double vsin = sin(a);
    double vcos = cos(a);
    VECTOR t(x, y, z);  //temporary VECTOR
    
    y = (SCALAR)(vcos * (double)t.y - vsin * (double)t.z);
    z = (SCALAR)(vsin * (double)t.y + vcos * (double)t.z);
  }

  inline void RotateY(SCALAR angle)
  { //Computergraphics S.410
    double a = (double)angle * (double)MUL_DEG_TO_RAD;  //convert from deg to rad
    double vsin = sin(a);
    double vcos = cos(a);
    VECTOR t(x, y, z);  //temporary VECTOR
    
    z = (SCALAR)(vcos * (double)t.z - vsin * (double)t.x);
    x = (SCALAR)(vsin * (double)t.z + vcos * (double)t.x);
  }

  inline void RotateZ(SCALAR angle)
  { //Computergraphics S.410
    double a = (double)angle * (double)MUL_DEG_TO_RAD;  //convert from deg to rad
    double vsin = sin(a);
    double vcos = cos(a);
    VECTOR t(x, y, z);  //temporary VECTOR
    
    x = (SCALAR)(vcos * (double)t.x - vsin * (double)t.y);
    y = (SCALAR)(vsin * (double)t.x + vcos * (double)t.y);
  }


#ifdef USEMATRIX
  inline void Rotate(SCALAR angle, VECTOR &pv)
  {
    VECTORMATRIX m;
    m.setRotate(angle, pv);
    *this = m * (*this);
  }

  inline void Rotate(SCALAR angle, SCALAR px, SCALAR py, SCALAR pz)
  {
    Rotate(angle, VECTOR(px, py, pz));
  }
#endif
*/

  inline void Translate(VECTOR &pv)
  {
    (*this) += pv;
  }

  inline void Translate(SCALAR px, SCALAR py)
  {
    x += px;
    y += py;
  }


  inline void Scale(VECTOR &pv)
  {
    (*this) *= pv;
  }

  inline void Scale(SCALAR sx, SCALAR sy)
  {
    x *= sx;
    y *= sy;
  }
};


VECTOR operator*(SCALAR& s, VECTOR& pv)
{
  return(pv * s);
}

---