SFML/DSFML/import/dsfml/system/vector3.d

/*
*	DSFML - SFML Library wrapper for the D programming language.
*	Copyright (C) 2008 Julien Dagorn (sirjulio13@gmail.com)
*	Copyright (C) 2010 Andreas Hollandt
*
*	This software is provided 'as-is', without any express or
*	implied warranty. In no event will the authors be held
*	liable for any damages arising from the use of this software.
*
*	Permission is granted to anyone to use this software for any purpose,
*	including commercial applications, and to alter it and redistribute
*	it freely, subject to the following restrictions:
*
*	1.  The origin of this software must not be misrepresented;
*		you must not claim that you wrote the original software.
*		If you use this software in a product, an acknowledgment
*		in the product documentation would be appreciated but
*		is not required.
*
*	2.  Altered source versions must be plainly marked as such,
*		and must not be misrepresented as being the original software.
*
*	3.  This notice may not be removed or altered from any
*		source distribution.
*/

module dsfml.system.vector3;

/**
*	Vector3 is an utility class for manipulating 3 dimensional
*	vectors. Template parameter defines the type of coordinates
*	(integer, float, ...)
*/
struct Vector3(T)
{
	T x;
	T y;
	T z;

	static Vector3 opCall(T x, T y, T z)
	{
		Vector3!(T) ret;
		
		ret.x = x;
		ret.y = y;
		ret.z = z;
		
		return ret;
	}

	/// unary (-) overload
	Vector3 opNeg()
	{
		return Vector3!(T)(-x, -y, -z);
	}

	/// (+=) overload
	Vector3 opAddAssign(Vector3 other)
	{
		x += other.x;
		y += other.y;
		z += other.z;
		return this;
	}

	/// (-=) overload
	Vector3 opSubAssign(Vector3 other)
	{
		x -= other.x;
		y -= other.y;
		z -= other.z;
		return this;
	}

	/// (+) overload
	Vector3 opAdd(Vector3 other)
	{
		return Vector3!(T)( (x + other.x), (y + other.y), (z + other.z) );
	}

	/// (-) overload
	Vector3 opSub(Vector3 other)
	{
		return Vector3!(T) ( (x - other.x), (y - other.y), (z - other.z) );
	}

	/// (*) overload
	Vector3 opMul(int i)
	{
		return Vector3!(T) ( (x * i), (y * i), (z * i) );
	}

	/// (*=) overload
	Vector3 opMulAssign(int i)
	{
		x *= i;
		y *= i;
		z *= i;
		return this;
	}

	/// (/) overload
	Vector3 opDiv(int i)
	{
		return Vector3!(T) ( (x / i), (y / i), (z / i) );
	}

	/// (/=) overload
	Vector3 opDivAssign(int i)
	{
		x /= i;
		y /= i;
		z /= i;
		return this;
	}

	///
	const bool opEquals(ref const(Vector3) other)
	{
		return (x == other.x) && (y == other.y) && (z == other.z) ;
	}
}

version (UnitTest)
{
	unittest
	{
		Vector3f main = Vector3f(10f, 10f, 10.f);
		Vector3f other = Vector3f(10f, 10f, 10.f);
		Vector3f result;
		
		result = -main;
		assert (result == Vector3f(-10.f, -10.f, -10.f) );
		
		result = main;
		result += other;
		assert (result == Vector3f(20.f, 20.f, 20.f));
		
		result = main;
		result -= other;
		assert (result == Vector3f(0.f, 0.f, 0.f));
		
		result = main + other;
		assert (result == Vector3f(20.f, 20.f, 20.f));
		
		result = main - other;
		assert (result == Vector3f(0.f, 0.f, 0.f));
		
		result = main * 10;
		assert (result == Vector3f(100.f, 100.f, 100.f));
		
		result *= 2;
		assert (result == Vector3f(200.f, 200.f, 200.f));
		
		result = main / 2;
		assert (result == Vector3f(5.f, 5.f, 5.f));
		
		result = main;
		result /= 2;
		assert (result == Vector3f(5.f, 5.f, 5.f));
	}
}

/// Aliases
alias Vector3!(float) Vector3f;
/// ditto
alias Vector3!(int) Vector3i;