#ifndef _ENGINE_VECTOR_HPP_
#define _ENGINE_VECTOR_HPP_
#ifndef _ENGINE_POINT3D_HPP_
#include <engine/point3d.hpp>
#endif

class Vector
{
public:
  Vector(void);
	Vector(const Vector &vector);
	Vector(int xScalar,int yScalar,int zScalar);
	Vector(const Point3D &firstPoint,const Point3D &secondPoint);
	virtual ~Vector();
	Vector &operator=(const Vector &vector);
	BOOL operator==(const Vector &vector);
	Vector operator+(const Vector &vector);
  Vector operator*(const Vector &vector);
	int xScalar(void)const;
	void xScalar(int xScalar);
	int yScalar(void)const;
	void yScalar(int yScalar);
	int zScalar(void)const;
	void zScalar(int zScalar);
	void vector(const Point3D &firstPoint,const Point3D &secondPoint);
	int length(void)const;
	int magnitude(void)const;
	void normal(Vector &vector)const;
	void normal(void);
	int dot(const Vector &vector)const;
private:
  int mxScalar;
	int myScalar;
	int mzScalar;
};

inline
Vector::Vector(void)
: mxScalar(0), myScalar(0), mzScalar(0)
{
}

inline
Vector::Vector(int xScalar,int yScalar,int zScalar)
: mxScalar(xScalar), myScalar(yScalar), mzScalar(zScalar)
{
}

inline
Vector::Vector(const Point3D &firstPoint,const Point3D &secondPoint)
{
  vector(firstPoint,secondPoint);
}

inline
Vector::Vector(const Vector &vector)
{
  *this=vector;
}

inline
Vector::~Vector()
{
}

inline
Vector &Vector::operator=(const Vector &vector)
{
  xScalar(vector.xScalar());
	yScalar(vector.yScalar());
	zScalar(vector.zScalar());
	return *this;
}

inline
BOOL Vector::operator==(const Vector &vector)
{
  return (xScalar()==vector.xScalar()&&
	        yScalar()==vector.yScalar()&&
					zScalar()==vector.zScalar());
}

inline
Vector Vector::operator+(const Vector &vector)
{
  return Vector(xScalar()+vector.xScalar(),yScalar()+vector.yScalar(),zScalar()+vector.zScalar());
}

inline
Vector Vector::operator*(const Vector &vector)
{
  return Vector((yScalar()*vector.zScalar()-zScalar()*vector.yScalar()),zScalar()*vector.xScalar()-xScalar()*vector.zScalar(),xScalar()*vector.yScalar()-yScalar()*vector.xScalar());
}

inline
int Vector::xScalar(void)const
{
  return mxScalar;
}

inline
void Vector::xScalar(int xScalar)
{
  mxScalar=xScalar;
}

inline
int Vector::yScalar(void)const
{
  return myScalar;
}

inline
void Vector::yScalar(int yScalar)
{
  myScalar=yScalar;
}

inline
int Vector::zScalar(void)const
{
  return mzScalar;
}

inline
void Vector::zScalar(int zScalar)
{
  mzScalar=zScalar;
}

inline
void Vector::vector(const Point3D &firstPoint,const Point3D &secondPoint)
{
  xScalar(secondPoint.x()-firstPoint.x());
	yScalar(secondPoint.y()-firstPoint.y());
	zScalar(secondPoint.z()-firstPoint.z());
}

inline
int Vector::length(void)const
{
  int vLength(.5*(xScalar()*xScalar())+(yScalar()*yScalar())+(zScalar()*zScalar()));
	if(vLength<0)vLength=-vLength;
	return vLength;
}

inline
int Vector::magnitude(void)const
{
  return length();
}
																		 
inline
void Vector::normal(Vector &vector)const
{
  int vLength(length());
	if(!vLength)
	{
	  vector.xScalar(0);
		vector.yScalar(0);
		vector.zScalar(0);
	}
	else
	{
	  vector.xScalar(xScalar()/vLength);
		vector.yScalar(yScalar()/vLength);
		vector.zScalar(zScalar()/vLength);
	}
}

inline
void Vector::normal(void)
{
  normal(*this);
}

inline
int Vector::dot(const Vector &vector)const
{
  return (xScalar()*vector.xScalar())+(yScalar()*vector.yScalar())+(zScalar()*vector.zScalar());
}
#endif