point.h

小型的3D游戏引擎

#ifndef _POINT_H_
#define _POINT_H_

typedef float pointType;

class GcPoint2
{
public:

	/* Everyting is declared in the header (for inlining) since */
	/*          speed is vital to point calculation				*/

	// Default constructor
	GcPoint2(): x(0), y(0){}

	// Overloaded constructor allowing initialazion
	GcPoint2(pointType sX, pointType sY): x(sX), y(sY) {}

	// Destructor
	~GcPoint2() {}

	/* Overload the standard math operators to work with the pointor */

	// Negation
	GcPoint2 operator-()
	{
		return GcPoint2(-x, -y);
	}

	// Addition (point1 + point2)
	GcPoint2 operator+(const GcPoint2 point)
	{
		return GcPoint2(x + point.x, y + point.y);
	}

	// Addition (point1 += point2)
	void operator+=(const GcPoint2 point)
	{
		x += point.x; 
		y += point.y; 
	}

	// Substraction (point1 - point2)
	GcPoint2 operator-(const GcPoint2 point)
	{
		return GcPoint2(x - point.x, y - point.y);
	}

	// Substraction (point1 -= point2)
	void operator-=(const GcPoint2 point)
	{
		x -= point.x;
		y -= point.y; 
	}

	// Scalar multiplication (point * scal)
	GcPoint2 operator*(pointType scalar)
	{
		return GcPoint2(x * scalar, y * scalar);
	}

	// Scalar multiplication (point *= scal)
	void operator*=(pointType scalar)
	{
		x *= scalar;
		y *= scalar; 
	}

	// Scalar division (point / scal)
	GcPoint2 operator/(pointType scalar)
	{
		return GcPoint2(x / scalar, y / scalar);
	}

	// Scalar division (point /= scal)
	void operator/=(pointType scalar)
	{
		x /= scalar;
		y /= scalar;
	}


	/* Overload the standard comperation operator */

	// Equal too
	bool operator==(const GcPoint2 point)
	{
		return ((x == point.x) && (y == point.y));
		
	}

	/* The variables are public for easier access */
	union 
	{
		struct 
		{
			pointType x, y;
        };

		pointType array[2];
	};
};

class GcPoint3
{
public:

	/* Everyting is declared in the header (for inlining) since */
	/*          speed is vital to pointor calculation			*/

	// Default constructor
	GcPoint3(): x(0), y(0), z(0) {}

	// Overloaded constructor allowing initialazion
	GcPoint3(pointType sX, pointType sY, pointType sZ): x(sX), y(sY), z(sZ) {}

	// Destructor
	~GcPoint3() {}

	/* Overload the standard math operators to work with the pointor */

	// Negation
	GcPoint3 operator-()
	{
		return GcPoint3(-x, -y, -z);
	}

	// Addition (point1 + point2)
	GcPoint3 operator+(const GcPoint3 point)
	{
		return GcPoint3(x + point.x, y + point.y, z +  point.z);
	}

	// Addition (point1 += point2)
	void operator+=(const GcPoint3 point)
	{
		x += point.x; 
		y += point.y; 
		z +=  point.z;
	}

	// Substraction (point1 - point2)
	GcPoint3 operator-(const GcPoint3 point)
	{
		return GcPoint3(x - point.x, y - point.y, z - point.z);
	}

	// Substraction (point1 -= point2)
	void operator-=(const GcPoint3 point)
	{
		x -= point.x;
		y -= point.y; 
		z -= point.z;
	}

	// Scalar multiplication (point * scal)
	GcPoint3 operator*(pointType scalar)
	{
		return GcPoint3(x * scalar, y * scalar, z * scalar);
	}

	// Scalar multiplication (point *= scal)
	void operator*=(pointType scalar)
	{
		x *= scalar;
		y *= scalar; 
		z *= scalar;
	}

	// Scalar division (point / scal)
	GcPoint3 operator/(pointType scalar)
	{
		return GcPoint3(x / scalar, y / scalar, z / scalar);
	}

	// Scalar division (point /= scal)
	void operator/=(pointType scalar)
	{
		x /= scalar;
		y /= scalar;
		z /= scalar;
	}


	/* Overload the standard comperation operator */

	// Equal too
	bool operator==(const GcPoint3 point)
	{
		return ((x == point.x) && (y == point.y) && (z == point.z));
		
	}

	/* The variables are public for easier access */
	union 
	{
		struct 
		{
			pointType x, y, z;
        };

		pointType array[3];
	};
};

#endif