// Header

class CVector
{
private:
	void sub();

public:
		GLfloat	x;
		GLfloat	y;
		GLfloat	z;
		
		VERTEX3fv data;

	// ructors

	CVector(GLfloat x=0, GLfloat y=0, GLfloat z=0) : x(x), y(y), z(z) { sub(); }
	CVector(CVector &V) : x(V.x), y(V.y), z(V.z) { sub();}
	CVector& operator = (CVector& V);

	GLfloat *GetData();
	

	//	Boolean stuff

	bool operator == (CVector& Vector);
	bool operator != (CVector& Vector);
	
	//	Add & Substract, Positive & Negative

	CVector operator + (CVector& Vector);
	CVector operator + ();
	CVector& operator += (CVector& Vector);
	
	// minus vector 

	CVector operator - (CVector& Vector);
	CVector operator - ();
	CVector &operator -= (CVector& Vector);
	
	//	Multiply & Divide

	CVector operator * (CVector& Vector);
	CVector& operator *= (CVector& Vector);
	CVector operator * (GLfloat d);
	CVector& operator *= (GLfloat d);
	CVector operator / (CVector& Vector);
	CVector &operator /= (CVector& Vector);
	CVector operator / (GLfloat d);
	CVector& operator /= (GLfloat d);
	
	bool operator > (CVector& Vector);
	bool operator < (CVector& Vector);
	//	Dot Product

	GLfloat operator % (CVector& Vector);
	//	Cross Product

	 CVector operator ^ (CVector& Vector);
	CVector& operator ^= (CVector& Vector);
		
	//	Set length (Normalize if 1) or Magnitude of vector

	GLfloat operator ! ();
	CVector operator | (GLfloat dLength);
	CVector& operator |= (GLfloat dLength);
	
	void Normalize();
		
	void SetNormal(CVector vTriangle0, CVector vTriangle1, CVector vTriangle2 );
	
	//	The angle between two vectors in radians

	GLfloat Angle(CVector& Normal);
	
	//	Reflect in Normal Vector

	CVector Reflection(CVector& PlaneNormal);
	//	Rotate dAngle Degrees (radians) Around Normal

	CVector Rotate(GLfloat dAngle, CVector& Normal);
	
	//	More Advanced Functions

	GLfloat PlaneDistance(CVector Normal, CVector Point);
	
	// Is Plane intersected?

	bool IntersectedPlane(CVector vTriangle[], CVector vLine[]);
};





// Source

/* --------------------------------- VECTOR IMPLEMENTATION -------------------------------//
//----------------------------------------------------------------------------------------*/
CVector& CVector::operator = (CVector& V)
	{	x = V.x;
		y = V.y;
		z = V.z;
		sub();
		return *this;
	}

	//	Boolean stuff
bool CVector::operator == (CVector& Vector) 
	{	return (x == Vector.x && y == Vector.y && z == Vector.z);
	}
	bool CVector::operator != (CVector& Vector) 
	{	return !(*this == Vector);
	}

	//	Add & Substract, Positive & Negative
	CVector CVector::operator + (CVector& Vector) 
	{	return CVector(x + Vector.x, y + Vector.y, z + Vector.z);
	}
	CVector CVector::operator + () 
	{	return CVector(*this);
	}
	CVector& CVector::operator += (CVector& Vector)
	{	x += Vector.x;
		y += Vector.y;
		z += Vector.z;
		sub();
		return *this;
	}
	// minus vector 
	CVector CVector::operator - (CVector& Vector) 
	{	return CVector(x - Vector.x, y - Vector.y, z - Vector.z);
	}
	CVector CVector::operator - () 
	{	return CVector(-x, -y, -z);
	}
	CVector &CVector::operator -= (CVector& Vector)
	{	x -= Vector.x;
		y -= Vector.y;
		z -= Vector.z;
		sub();
		return *this;
	}

	//	Multiply & Divide
	CVector CVector::operator * (CVector& Vector) 
	{	return CVector(x * Vector.x, y * Vector.y, z * Vector.z);
	}
	CVector &CVector::operator *= (CVector& Vector)
	{	x *= Vector.x;
		y *= Vector.y;
		z *= Vector.z;
		sub();
		return *this;
	}
	CVector CVector::operator * (GLfloat d) 
	{	return CVector(x * d, y * d, z * d);
	}
	CVector &CVector::operator *= (GLfloat d)
	{	x *= d;
		y *= d;
		z *= d;
		sub();
		return *this;
	}
	CVector CVector::operator / (CVector& Vector) 
	{	return CVector(x / Vector.x, y / Vector.y, z / Vector.z);
	}
	
	CVector &CVector::operator /= (CVector& Vector)
	{	x /= Vector.x;
		y /= Vector.y;
		z /= Vector.z;
		sub();
		return *this;
	}
	CVector CVector::operator / (GLfloat d) 
	{	GLfloat _d = 1.0f / d;
		return CVector(x * _d, y * _d, z * _d);
	}
	CVector &CVector::operator /= (GLfloat d)
	{	GLfloat _d = 1.0f / d;
		x *= _d;
		y *= _d;
		z *= _d;
		sub();
		return *this;
	}
	
	//	Dot Product
	GLfloat CVector::operator % (CVector& Vector) 
	{	return x*Vector.x + y*Vector.y + z*Vector.z;
	}
	//	Cross Product
	 CVector CVector::operator ^ (CVector& Vector) 
	{	return CVector(
				y * Vector.z - Vector.y * z,
				z * Vector.x - Vector.z * x,
				x * Vector.y - Vector.x * y);
	}
	CVector &CVector::operator ^= (CVector& Vector)
	{	return *this = *this ^ Vector;
	}
	

	bool CVector::operator > (CVector& v)
	{
		return (x>v.x || y>v.y || z>v.z);
	}
	
	bool CVector::operator < (CVector& v)
	{
		return (x<v.x || y<v.y || z<v.z);
	}

	//	Set length (Normalize if 1) or Magnitude of vector
	GLfloat CVector::operator ! () 
	{	return sqrtf(x*x + y*y + z*z);
	}
	CVector CVector::operator | (GLfloat dLength) 
	{	return *this * (dLength / !*this);
	}
	CVector &CVector::operator |= (GLfloat dLength)
	{	return *this = *this | dLength;
	}
	
	void CVector::Normalize()
	{
		GLfloat magnitude=!*this;
		*this/=magnitude;
	}


	void CVector::SetNormal(CVector vTriangle0, CVector vTriangle1, CVector vTriangle2 )
	{
		*this = (vTriangle2-vTriangle0)^(vTriangle1-vTriangle0);				// Cross Product
		this->Normalize();						// Use our function we created to normalize the normal (Makes it a length of one)
	}

	//	The angle between two vectors in radians
	GLfloat CVector::Angle(CVector& Normal) 
	{	return acosf(*this % Normal);
	}
	//	Reflect in Normal Vector
	CVector CVector::Reflection(CVector& PlaneNormal) 
	{	return (*this - PlaneNormal * 2.0 * (*this % PlaneNormal)) * !*this;
	}
	//	Rotate dAngle Degrees (radians) Around Normal
	CVector CVector::Rotate(GLfloat dAngle, CVector& Normal) 
	{	GLfloat dCos = cosf(dAngle);
		GLfloat dSin = sinf(dAngle);
		return CVector(
				*this * dCos +
				((Normal * *this) * (1.0f - dCos)) * Normal +
				(*this ^ Normal) * dSin);
	}

	GLfloat *CVector::GetData()
	{	return data; }

	void CVector::sub() 
	{
		data[0] = x;
		data[1] = y;
		data[2] = z;
	}
/* -------------------------------END VECTOR IMPLEMENTATION ------------------------------//
//----------------------------------------------------------------------------------------*/

  union{struct{float x;float y;float z;};float data[3];}Thanks.