vec3d.h

#ifndef VEC3D_H
#define VEC3D_H

#include <iostream>
#include <cmath>

#define PI 3.1415926535897932384626433832795
#define PIOVER180 (PI/180.0)

class Vec3D {
public:
	float x,y,z;

	Vec3D(float x0 = 0.0f, float y0 = 0.0f, float z0 = 0.0f) : x(x0), y(y0), z(z0) {}

	Vec3D(const Vec3D& v) : x(v.x), y(v.y), z(v.z) {}

	void reset() {
		x = y = z = 0.0f;
	}

	Vec3D& operator= (const Vec3D &v) {
        x = v.x;
		y = v.y;
		z = v.z;
		return *this;
	}

	/*
	float[3] operator= (const Vec3D &v) {
		float f[3] = {v.x, v.y, v.z};
		return f;
	}
	*/

	Vec3D operator+ (const Vec3D &v) const
	{
		Vec3D r(x+v.x,y+v.y,z+v.z);
        return r;
	}

	Vec3D operator- (const Vec3D &v) const
	{
		Vec3D r(x-v.x,y-v.y,z-v.z);
		return r;
	}

	float operator* (const Vec3D &v) const
	{
        return x*v.x + y*v.y + z*v.z;
	}

	Vec3D operator* (float d) const
	{
		Vec3D r(x*d,y*d,z*d);
        return r;
	}

	Vec3D operator/ (float d) const
	{
		Vec3D r(x/d,y/d,z/d);
        return r;
	}

	friend Vec3D operator* (float d, const Vec3D& v)
	{
		return v * d;
	}

	// Cross Product
	Vec3D operator% (const Vec3D &v) const
	{
        Vec3D r(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x);
		return r;
	}

	Vec3D& operator+= (const Vec3D &v)
	{
		x += v.x;
		y += v.y;
		z += v.z;
		return *this;
	}

	Vec3D& operator-= (const Vec3D &v)
	{
		x -= v.x;
		y -= v.y;
		z -= v.z;
		return *this;
	}

	Vec3D& operator*= (float d)
	{
		x *= d;
		y *= d;
		z *= d;
		return *this;
	}

	float lengthSquared() const
	{
		return x*x+y*y+z*z;
	}

	float length() const
	{
        return sqrtf(x*x+y*y+z*z);
	}

	Vec3D& normalize()
	{
		this->operator*= (1.0f/length());
		return *this;
	}

	Vec3D operator~ () const
	{
		Vec3D r(*this);
        r.normalize();
		return r;
	}

	friend std::istream& operator>>(std::istream& in, Vec3D& v)
	{
		in >> v.x >> v.y >> v.z;
		return in;
	}

	operator float*()
	{
		return (float*)this;
	}

};

class Short4Vector {
public:
	short x,y,z, w;

	Short4Vector(short x0 = 0, short y0 = 0, short z0 = 0, short w0 = 0) : x(x0), y(y0), z(z0), w(w0) {}

	friend std::istream& operator>>(std::istream& in, Short4Vector& v)
	{
		in >> v.x >> v.y >> v.z >> v.w;
		return in;
	}

};

class Vec2D {
public:
	float x,y;
	
	Vec2D(float x0 = 0.0f, float y0 = 0.0f) : x(x0), y(y0) {}

	Vec2D(const Vec2D& v) : x(v.x), y(v.y) {}

	Vec2D& operator= (const Vec2D &v) {
        x = v.x;
		y = v.y;
		return *this;
	}

	Vec2D operator+ (const Vec2D &v) const
	{
		Vec2D r(x+v.x,y+v.y);
        return r;
	}

	Vec2D operator- (const Vec2D &v) const
	{
		Vec2D r(x-v.x,y-v.y);
		return r;
	}

	float operator* (const Vec2D &v) const
	{
        return x*v.x + y*v.y;
	}

	Vec2D operator* (float d) const
	{
		Vec2D r(x*d,y*d);
        return r;
	}

	friend Vec2D operator* (float d, const Vec2D& v)
	{
		return v * d;
	}

	Vec2D& operator+= (const Vec2D &v)
	{
		x += v.x;
		y += v.y;
		return *this;
	}

	Vec2D& operator-= (const Vec2D &v)
	{
		x -= v.x;
		y -= v.y;
		return *this;
	}

	Vec2D& operator*= (float d)
	{
		x *= d;
		y *= d;
		return *this;
	}

	float lengthSquared() const
	{
		return x*x+y*y;
	}

	float length() const
	{
        return sqrtf(x*x+y*y);
	}

	Vec2D& normalize()
	{
		this->operator*= (1.0f/length());
		return *this;
	}

	Vec2D operator~ () const
	{
		Vec2D r(*this);
        r.normalize();
		return r;
	}


	friend std::istream& operator>>(std::istream& in, Vec2D& v)
	{
        in >> v.x >> v.y;
		return in;
	}

	operator float*()
	{
		return (float*)this;
	}

};


inline void rotate(float x0, float y0, float *x, float *y, float angle)
{
	float xa = *x - x0, ya = *y - y0;
	*x = xa*cosf(angle) - ya*sinf(angle) + x0;
	*y = xa*sinf(angle) + ya*cosf(angle) + y0;
}



#endif