/*
   vector3f.h
   This file is part of the Project::OSiRiON world editor 
   and is distributed under the terms and conditions of 
   the GNU General Public License version 2
*/

#ifndef __INCLUDED_EDITOR_VECTOR3F__
#define __INCLUDED_EDITOR_VECTOR3F__

#include <cassert>

namespace editor
{

/** 
 * @brief a point or vector in 3D space
 * An instance of this class represents a point in 3D-space or a 3D-vector
 *  and forms the basic building block for all spatial calculations.
 */
class Vector3f
{

public:
	/**
	 * @brief default constructor, assigns (0,0,0)
	 * */
	Vector3f();

	/** 
	 * @brief copy constructor
	 * Create a new Vector3f that is a copy from an other
	 *  @param other the vector to copy values from
	 */
	Vector3f(const Vector3f &other);

	/** 
	 * @brief create a Vector3f with given coordinates
	 * @param x	the x-coordinate of the location
	 * @param y 	the y-coordinate of the location
	 * @param z	the z-coordinate of the location
	 */
	Vector3f(const float x, const float y, const float z);

	/// destructor
	~Vector3f();

	/* -- Assignment operators -- */
	/// assign (0, 0, 0)
	void clear();

	/// assignment
	void assign(const float x, const float y, const float z);

	/// assignment
	void assign(const Vector3f & other);
	
	/// assignment operator
	Vector3f& operator=(const Vector3f &other);

	/// scalar multiplication assignment
	/** @param scalar multiplication factor
	*/
	Vector3f& operator*=(const float scalar);

	/// scalar division assignment
	/** @param scalar divider
	*/
	Vector3f& operator/=(const float scalar);

	/// vector sum assignment
	Vector3f& operator+=(const Vector3f &other);

	/// vector difference assignment
	Vector3f& operator-=(const Vector3f &other);

	/* -- Mathematical operators -- */

	/// scalar multiplication
	inline Vector3f operator*(const float scalar) const {
		Vector3f v(coord[0] * scalar, coord[1] * scalar, coord[2] * scalar);
		return v;
	}

	/// scalar division
	Vector3f operator/(const float scalar) const {
		Vector3f v(coord[0] / scalar, coord[1] / scalar, coord[2] / scalar);
		return v;
	}

	/// vector sum
	inline Vector3f operator+(const Vector3f &other) const {
		Vector3f v(coord[0] + other.coord[0], coord[1] + other.coord[1], coord[2] + other.coord[2]);
		return v;
	}

	/// vector difference
	inline Vector3f operator-(const Vector3f &other) const {
		Vector3f v(coord[0] - other.coord[0], coord[1] - other.coord[1], coord[2] - other.coord[2]);
		return v;
	}

	/// comparison operator
	bool operator==(const Vector3f &other) const;

	/// assign a value to an element of this vector
	/*! range is not checked
	 *  @param index the index of the element to assign to ( 0 <= index < 3 )
	*/
	inline float& operator[](const int index) {
		assert ((0 <= index) && (index < 3));
		return coord[index];
	}

	/// returns the value of an element of this vector
	/*! range is not checked
	 *  @param index the index of the element to return ( 0 <= index < 3 )
	 */
	inline float operator[](const int index) const {
		assert ((0 <= index) && (index < 3));
		return coord[index];
	}

	/// x coordinate
	inline float x() const {
		return coord[0];
	}

	/// y coordinate
	inline float y() const {
		return coord[1];
	}

	/// z coordinate
	inline float z() const {
		return coord[2];
	}

	/// mutable reference to the x coordinate
	inline float & get_x() {
		return coord[0];
	}

	/// mutable reference to the y coordinate
	inline float & get_y() {
		return coord[1];
	}

	/// mutable reference to the z coordinate
	inline float & get_z() {
		return coord[2];
	}

	/// a pointer to the internal data
	inline float *ptr() const {
		return (float *) coord;
	}

	/// cartesian length
	float length() const;

	/// cartesian length squared
	float lengthsquared() const;

	/// divide this Vector by its length
	/// @see normalized()
	/// vector must not be (0, 0, 0)
	void normalize();

	/* static functions */

	/// Returns the unity vector on the X-axis
	static inline Vector3f Xaxis() {
		return Vector3f(1.0f, 0.0f, 0.0f);
	}

	/// Returns the unity vector on the Y-axis
	static inline Vector3f Yaxis() {
		return Vector3f(0.0f, 1.0f, 0.0f);
	}

	/// Returns the unity vector on the Z-axis
	static inline Vector3f Zaxis() {
		return Vector3f(0.0f, 0.0f, 1.0f);
	}

	/// cartesian lenght
	static inline float length(const Vector3f & vector) {
		return vector.length();
	}

	/// Return a vector divided by it's length
	/// @see normalize()
	/// WARNING: vector must not be (0, 0, 0)
	static inline Vector3f normalized(const Vector3f & vector) {
		return (vector / vector.length());
	}

private:
	float coord[3];
};

/// scalar * Vector3f operators
Vector3f operator*(float scalar, const Vector3f & vector);

/// vector cross product
const Vector3f crossproduct(const Vector3f & first, const Vector3f & second);

/// vector dot product
float dotproduct(const Vector3f& first, const Vector3f & second);

/// distance between two vectors
float distance(const Vector3f& first, const Vector3f& second);

/// distance between two vectors squared
float distancesquared(const Vector3f& first, const Vector3f& second);

/// calculate the normal of a plane defined by three vertices 
inline const Vector3f normal(const Vector3f & center, const Vector3f & u, const Vector3f & v) {
	Vector3f r = crossproduct(u - center, v - center);
	r.normalize();
	return r;
}

} // namespace math

#endif // __INCLUDED_EDITOR_VECTOR3F__