Vector.h

Go to the documentation of this file.

//
// Das Tank - Copyright (C) 2006, 2007 Windsor Schmidt <windsor@windsorworld.net>
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
// Place, Suite 330, Boston, MA 02111-1307 USA
//


const float NORMALIZE_TOLERANCE = 0.0001f;

class Vector
{
public:
       float x;
       float y;
       float z;

       Vector(void);
       Vector(float iX, float iY, float iZ);

       float Magnitude(void);
       void Normalize(void);
       void Reverse(void);

       Vector& operator+=(Vector u);
       Vector& operator-=(Vector u);
       Vector& operator*=(float s);
       Vector& operator/=(float s);

       Vector operator-(void);
};

inline Vector::Vector(void)
{
       x = 0;
       y = 0;
       z = 0;
}

inline Vector::Vector(float iX, float iY, float iZ)
{
       x = iX;
       y = iY;
       z = iZ;
}

inline float Vector::Magnitude(void)
{
       return (float) sqrt(x*x + y*y + z*z);
}

inline void Vector::Normalize(void)
{
       float m = (float) sqrt(x*x + y*y + z*z);
       if(m <= NORMALIZE_TOLERANCE) m = 1;
       
       x /= m;
       y /= m;
       z /= m;

       if (fabs(x) < NORMALIZE_TOLERANCE) x = 0.0f;
       if (fabs(y) < NORMALIZE_TOLERANCE) y = 0.0f;
       if (fabs(z) < NORMALIZE_TOLERANCE) z = 0.0f;
}

inline void Vector::Reverse(void)
{
       x = -x;
       y = -y;
       z = -z;
}

inline Vector& Vector::operator+=(Vector u)
{
       x += u.x;
       y += u.y;
       z += u.z;
       return *this;
}

inline Vector& Vector::operator-=(Vector u)
{
       x -= u.x;
       y -= u.y;
       z -= u.z;
       return *this;
}

inline Vector& Vector::operator*=(float s)
{
       x *= s;
       y *= s;
       z *= s;
       return *this;
}

inline Vector& Vector::operator/=(float s)
{
       x /= s;
       y /= s;
       z /= s;
       return *this;
}

inline Vector Vector::operator-(void)
{
       return Vector(-x, -y, -z);
}

inline Vector operator+(Vector u, Vector v)
{
       return Vector(u.x + v.x, u.y + v.y, u.z + v.z);
}

inline Vector operator-(Vector u, Vector v)
{
       return Vector(u.x - v.x, u.y - v.y, u.z - v.z);
}

inline Vector operator^(Vector u, Vector v)
{
       return Vector(u.y*v.z - u.z*v.y, -u.x*v.z + u.z*v.x, u.x*v.y - u.y*v.x);
}

inline float operator*(Vector u, Vector v)
{
       return (u.x*v.x + u.y*v.y + u.z*v.z);
}

inline Vector operator*(float s, Vector u)
{
       return Vector(u.x*s, u.y*s, u.z*s);
}

inline Vector operator*(Vector u, float s)
{
       return Vector(u.x*s, u.y*s, u.z*s);
}

inline Vector operator/(Vector u, float s)
{
       return Vector(u.x/s, u.y/s, u.z/s);
}

inline float TripleScalarProduct(Vector u, Vector v, Vector w)
{
       return (float(u.x*(v.y*w.z-v.z*w.y))+u.y*(-v.x*w.z+v.z*w.x))+(u.z*(v.x*w.y-v.y*w.x));
}

inline Vector VRotate2D( float angle, Vector u)
{
       float x,y;
       x = u.x * cos(-angle) + u.y * sin(-angle);
       y = -u.x * sin(-angle) + u.y * cos(-angle);
       return Vector( x, y, 0);
}

 

Copyright Windsor Schmidt 2006 - All rights reserved.