using System;

using System.ComponentModel;

using System.Diagnostics;

using System.IO;

using System.Runtime.InteropServices;

using Delta.Utilities.Helpers;

using Delta.Utilities.Profiling;

using NUnit.Framework;





// Disable warnings for some tests where we don't use created values

#pragma warning disable 219



namespace Delta.Utilities.Datatypes

{

	/// <summary>

	/// Vector class, will be automatically merged with XNA, OpenTK and SlimDx

	/// vector classes by the build system for quick access and optimized code

	/// paths (as it turns out however it seems most of our own methods are

	/// faster than those from XNA, OpenTK or SlimDx, see results below in the

	/// VectorPerformance class or more importantly MatrixPerformance).

	/// </summary>

	[Serializable]

	[StructLayout(LayoutKind.Explicit)]

	[DebuggerDisplay("Vector=({X}, {Y}, {Z})")]

	[Description("Expand to edit this Vector")]

	[TypeConverter(typeof(ExpandableObjectConverter))]

	public struct Vector : ISaveLoadBinary, IEquatable<Vector>

	{

		#region Constants

		/// <summary>

		/// Represents the size in bytes of a Vector (3 * 4 = 12 bytes).

		/// </summary>

		public const int DataSize = 3 * 4;



		/// <summary>

		/// Returns a Vector with every value set to 0

		/// </summary>

		public static readonly Vector Zero =

			new Vector(0, 0, 0);



		/// <summary>

		/// Returns a Vector with every value set to 0.5

		/// </summary>

		public static readonly Vector Half =

			new Vector(0.5f, 0.5f, 0.5f);



		/// <summary>

		/// Returns a Vector with every value set to 1

		/// </summary>

		public static readonly Vector One =

			new Vector(1, 1, 1);



		/// <summary>

		/// Returns a unit vector on the X axis (1, 0, 0)

		/// </summary>

		public static readonly Vector UnitX =

			new Vector(1, 0, 0);



		/// <summary>

		/// Returns a unit vector on the Y axis (0, 1, 0)

		/// </summary>

		public static readonly Vector UnitY =

			new Vector(0, 1, 0);



		/// <summary>

		/// Returns a unit vector on the Z axis (0, 0, 1)

		/// </summary>

		public static readonly Vector UnitZ =

			new Vector(0, 0, 1);

		#endregion



		#region Add (Static)

		/// <summary>

		/// Add the components two vectors

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>

		/// New vector with X, Y and Z added from value1 and value2.

		/// </returns>

		public static Vector Add(Vector value1, Vector value2)

		{

			return new Vector(value1.X + value2.X, value1.Y + value2.Y,

				value1.Z + value2.Z);

		}



		/// <summary>

		/// Add the components two vectors

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <param name="result">

		/// New vector with X, Y and Z added from value1 and value2.

		/// </param>

		public static void Add(ref Vector value1, ref Vector value2,

			out Vector result)

		{

			result = new Vector

			{

				X = value1.X + value2.X,

				Y = value1.Y + value2.Y,

				Z = value1.Z + value2.Z

			};

		}

		#endregion



		#region Subtract (Static)

		/// <summary>

		/// Subtract

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <param name="result">

		/// New vector with X, Y and Z value2 values subtracted from value1.

		/// </param>

		public static void Subtract(ref Vector value1, ref Vector value2,

			out Vector result)

		{

			result = new Vector

			{

				X = value1.X - value2.X,

				Y = value1.Y - value2.Y,

				Z = value1.Z - value2.Z

			};

		}

		#endregion



		#region Multiply (Static)

		/// <summary>

		/// Multiply the components of a vector with the specified factor.

		/// </summary>

		/// <param name="scaleFactor">scale factor</param>

		/// <param name="value1">value 1</param>

		/// <returns>Multiplied vector</returns>

		public static Vector Multiply(Vector value1, float scaleFactor)

		{

			return new Vector

			{

				X = value1.X * scaleFactor,

				Y = value1.Y * scaleFactor,

				Z = value1.Z * scaleFactor

			};

		}



		/// <summary>

		/// Multiply the components of a vector with the specified factor.

		/// </summary>

		/// <param name="value">Vector value</param>

		/// <param name="scaleFactor">scale factor</param>

		/// <param name="result">Multiplied vector</param>

		public static void Multiply(ref Vector value, float scaleFactor,

			ref Vector result)

		{

			result.X = value.X * scaleFactor;

			result.Y = value.Y * scaleFactor;

			result.Z = value.Z * scaleFactor;

		}



		/// <summary>

		/// Multiply the components of two vectors

		/// </summary>

		/// <param name="value1">value 1</param>

		/// <param name="value2">value 2</param>

		/// <returns>Multiplied vector</returns>

		public static Vector Multiply(Vector value1, Vector value2)

		{

			return new Vector(value1.X * value2.X, value1.Y * value2.Y,

				value1.Z * value2.Z);

		}

		#endregion



		#region Divide (Static)

		/// <summary>

		/// Divide vector through a value

		/// </summary>

		/// <param name="value1">value 1</param>

		/// <param name="value2">value 2</param>

		/// <param name="result">Divided vector</param>

		public static void Divide(ref Vector value1, float value2,

			ref Vector result)

		{

			float num = 1.0f / value2;

			result.X = value1.X * num;

			result.Y = value1.Y * num;

			result.Z = value1.Z * num;

		}

		#endregion



		#region Negate (Static)

		/// <summary>

		/// Negate

		/// </summary>

		/// <param name="value">Vector value to negate</param>

		/// <param name="result">Negated vector</param>

		public static void Negate(ref Vector value, ref Vector result)

		{

			result.X = -value.X;

			result.Y = -value.Y;

			result.Z = -value.Z;

		}

		#endregion



		#region Min (Static)

		/// <summary>

		/// Return minimum values from 2 vectors (x, y, and z are checked

		/// separately). If you use XNA, SlimDX or Delta's fallback code than a

		/// vector containing the smallest values will be returned.

		/// OpenTK would return the vector with the smallest DistanceSquared,

		/// which is wrong for us and won't be used!

		/// </summary>

		/// <param name="value1">value 1</param>

		/// <param name="value2">value 2</param>

		/// <returns>minimum values from 2 vectors</returns>

		public static Vector Min(Vector value1, Vector value2)

		{

			return new Vector(

				value1.X < value2.X

					? value1.X

					: value2.X,

				value1.Y < value2.Y

					? value1.Y

					: value2.Y,

				value1.Z < value2.Z

					? value1.Z

					: value2.Z);

		}



		/// <summary>

		/// Minimum

		/// </summary>

		/// <param name="result">result</param>

		/// <param name="value1">value 1</param>

		/// <param name="value2">value 2</param>

		public static void Min(ref Vector value1, ref Vector value2,

			ref Vector result)

		{

			result.X = (value1.X < value2.X)

			           	? value1.X

			           	: value2.X;

			result.Y = (value1.Y < value2.Y)

			           	? value1.Y

			           	: value2.Y;

			result.Z = (value1.Z < value2.Z)

			           	? value1.Z

			           	: value2.Z;

		}

		#endregion



		#region Max (Static)

		/// <summary>

		/// Return maximum values from 2 vectors (largest x, y and z values).

		/// If you use XNA, SlimDX or Delta's fallback code than a vector

		/// containing the largest values will be returned.

		/// OpenTK would return the vector with the biggest DistanceSquared,

		/// which is wrong for us and won't be used!

		/// </summary>

		/// <param name="value1">value 1</param>

		/// <param name="value2">value 2</param>

		/// <returns>maximum values from 2 vectors</returns>

		public static Vector Max(Vector value1, Vector value2)

		{

			return new Vector(

				value1.X > value2.X

					? value1.X

					: value2.X,

				value1.Y > value2.Y

					? value1.Y

					: value2.Y,

				value1.Z > value2.Z

					? value1.Z

					: value2.Z);

		}



		/// <summary>

		/// Maximum

		/// </summary>

		/// <param name="result">result</param>

		/// <param name="value1">value 1</param>

		/// <param name="value2">value 2</param>

		public static void Max(ref Vector value1, ref Vector value2,

			ref Vector result)

		{

			result.X = (value1.X > value2.X)

			           	? value1.X

			           	: value2.X;

			result.Y = (value1.Y > value2.Y)

			           	? value1.Y

			           	: value2.Y;

			result.Z = (value1.Z > value2.Z)

			           	? value1.Z

			           	: value2.Z;

		}

		#endregion



		#region Dot (Static)

		/// <summary>

		/// Dot product of 2 vectors, will return 1 if vectors are equal,

		/// and 0 if vectors are orthogonal (90 degrees) and -1 if vectors

		/// pointing into opposite directions.

		/// </summary>

		/// <param name="vector1">Vector 1</param>

		/// <param name="vector2">Vector 2</param>

		/// <returns>Dot product</returns>

		public static float Dot(Vector vector1, Vector vector2)

		{

			return

				vector1.X * vector2.X +

				vector1.Y * vector2.Y +

				vector1.Z * vector2.Z;

		}



		/// <summary>

		/// Dot product of 2 vectors, will return 1 if vectors are equal,

		/// and 0 if vectors are orthogonal (90 degrees) and -1 if vectors

		/// pointing into opposite directions.

		/// </summary>

		/// <param name="vector1">Vector 1</param>

		/// <param name="vector2">Vector 2</param>

		/// <param name="result">Dot product</param>

		public static void Dot(ref Vector vector1, ref Vector vector2,

			out float result)

		{

			result = (vector1.X * vector2.X) + (vector1.Y * vector2.Y) +

			         (vector1.Z * vector2.Z);

		}

		#endregion



		#region Clamp (Static)

		/// <summary>

		/// Clamp. Computing the closest point in an bounding box to a point.

		/// Notice that if the point is already inside the box, then this code

		/// returns the original point.

		/// </summary>

		/// <param name="value1">Vector value to clamp</param>

		/// <param name="max">

		/// Maximum vector (each component is checked individually)

		/// </param>

		/// <param name="min">

		/// Minimum vector (each component is checked individually)

		/// </param>

		/// <returns>

		/// Clamped vector that has all components between min and max.

		/// </returns>

		public static Vector Clamp(Vector value1, Vector min, Vector max)

		{

			float x = value1.X;

			x = (x > max.X)

			    	? max.X

			    	: x;

			x = (x < min.X)

			    	? min.X

			    	: x;

			float y = value1.Y;

			y = (y > max.Y)

			    	? max.Y

			    	: y;

			y = (y < min.Y)

			    	? min.Y

			    	: y;

			float z = value1.Z;

			z = (z > max.Z)

			    	? max.Z

			    	: z;

			z = (z < min.Z)

			    	? min.Z

			    	: z;



			return new Vector(x, y, z);

		}



		/// <summary>

		/// Clamp. Computing the closest point in an bounding box to a point.

		/// Notice that if the point is already inside the box, then this code

		/// returns the original point.

		/// </summary>

		/// <param name="value1">Vector value to clamp</param>

		/// <param name="max">

		/// Maximum vector (each component is checked individually)

		/// </param>

		/// <param name="min">

		/// Minimum vector (each component is checked individually)

		/// </param>

		/// <param name="result">

		/// Clamped vector that has all components between min and max.

		/// </param>

		public static void Clamp(ref Vector value1, ref Vector min,

			ref Vector max, ref Vector result)

		{

			float x = value1.X;

			x = (x > max.X)

			    	? max.X

			    	: x;

			x = (x < min.X)

			    	? min.X

			    	: x;

			float y = value1.Y;

			y = (y > max.Y)

			    	? max.Y

			    	: y;

			y = (y < min.Y)

			    	? min.Y

			    	: y;

			float z = value1.Z;

			z = (z > max.Z)

			    	? max.Z

			    	: z;

			z = (z < min.Z)

			    	? min.Z

			    	: z;

			result.X = x;

			result.Y = y;

			result.Z = z;

		}

		#endregion



		#region Cross (Static)

		/// <summary>

		/// Cross product of vector1 and vector2. Please note that if your vectors

		/// are not normalized or they are not orthogonal to each other, you should

		/// normalize the result if it is used for other calculations requiring

		/// normalized vectors (e.g. camera code or for billboards).

		/// </summary>

		/// <param name="vector1">Vector 1</param>

		/// <param name="vector2">Vector 2</param>

		/// <returns>Cross product between vector 1 and 2</returns>

		public static Vector Cross(Vector vector1, Vector vector2)

		{

			return new Vector(

				vector1.Y * vector2.Z - vector1.Z * vector2.Y,

				vector1.Z * vector2.X - vector1.X * vector2.Z,

				vector1.X * vector2.Y - vector1.Y * vector2.X);

		}



		/// <summary>

		/// Cross product of vector1 and vector2. Please note that if your vectors

		/// are not normalized or they are not orthogonal to each other, you should

		/// normalize the result if it is used for other calculations requiring

		/// normalized vectors (e.g. camera code or for billboards).

		/// </summary>

		/// <param name="vector1">Vector 1</param>

		/// <param name="vector2">Vector 2</param>

		/// <param name="result">Cross product between vector 1 and 2</param>

		public static void Cross(ref Vector vector1, ref Vector vector2,

			ref Vector result)

		{

			result.X = (vector1.Y * vector2.Z) - (vector1.Z * vector2.Y);

			result.Y = (vector1.Z * vector2.X) - (vector1.X * vector2.Z);

			result.Z = (vector1.X * vector2.Y) - (vector1.Y * vector2.X);

		}

		#endregion



		#region Distance (Static)

		/// <summary>

		/// Distance between two points (DistanceSquared is faster)

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>Distance between vectors</returns>

		public static float Distance(Vector value1, Vector value2)

		{

			float distX = value1.X - value2.X;

			float distY = value1.Y - value2.Y;

			float distZ = value1.Z - value2.Z;

			float distSquared = distX * distX + distY * distY + distZ * distZ;

			return MathHelper.Sqrt(distSquared);

		}



		/// <summary>

		/// Distance between two points (DistanceSquared is faster)

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <param name="result">Distance between vectors</param>

		public static void Distance(ref Vector value1, ref Vector value2,

			out float result)

		{

			float distX = value1.X - value2.X;

			float distY = value1.Y - value2.Y;

			float distZ = value1.Z - value2.Z;

			float distSquared = distX * distX + distY * distY + distZ * distZ;

			result = MathHelper.Sqrt(distSquared);

		}

		#endregion



		#region DistanceSquared (Static)

		/// <summary>

		/// Distance squared

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>Squared distance between vectors</returns>

		public static float DistanceSquared(Vector value1, Vector value2)

		{

			float distX = value1.X - value2.X;

			float distY = value1.Y - value2.Y;

			float distZ = value1.Z - value2.Z;

			return distX * distX + distY * distY + distZ * distZ;

		}



		/// <summary>

		/// Distance squared

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <param name="result">Squared distance between vectors</param>

		public static void DistanceSquared(ref Vector value1, ref Vector value2,

			out float result)

		{

			float distX = value1.X - value2.X;

			float distY = value1.Y - value2.Y;

			float distZ = value1.Z - value2.Z;

			result = (distX * distX) + (distY * distY) + (distZ * distZ);

		}

		#endregion



		#region Normalize (Static)

		/// <summary>

		/// Normalize the given vector and return the normalized version of it.

		/// </summary>

		/// <param name="value">Vector to normalize</param>

		/// <returns>Normalized vector</returns>

		public static Vector Normalize(Vector value)

		{

			float lengthSquared = value.LengthSquared;

			if (lengthSquared == 0)

			{

				return value;

			}



			float distanceInverse = 1.0f / MathHelper.Sqrt(lengthSquared);



			return new Vector(

				value.X * distanceInverse,

				value.Y * distanceInverse,

				value.Z * distanceInverse);

		}



		/// <summary>

		/// Normalize the given vector.

		/// </summary>

		/// <param name="value">

		/// Vector to normalize, will be normalized after calling this method.

		/// </param>

		public static void Normalize(ref Vector value)

		{

			float distanceSquared = value.LengthSquared;



			if (distanceSquared != 0.0f)

			{

				float distanceInverse = 1.0f / MathHelper.Sqrt(distanceSquared);

				value.X *= distanceInverse;

				value.Y *= distanceInverse;

				value.Z *= distanceInverse;

			}

		}

		#endregion



		#region TransformNormal (Static)

		/// <summary>

		/// Transform normal (a Vector3 version of Transform, that won't use the

		/// translation part of the matrix).

		/// </summary>

		/// <param name="normal">Normal to transform</param>

		/// <param name="matrix">Matrix for the transformation</param>

		/// <returns>Transformed normal vector</returns>

		public static Vector TransformNormal(Vector normal, Matrix matrix)

		{

			//Check performance difference again:



			return new Vector(

				// X

				(normal.X * matrix.M11) +

				(normal.Y * matrix.M21) +

				(normal.Z * matrix.M31),

				// Y

				(normal.X * matrix.M12) +

				(normal.Y * matrix.M22) +

				(normal.Z * matrix.M32),

				// Z

				(normal.X * matrix.M13) +

				(normal.Y * matrix.M23) +

				(normal.Z * matrix.M33));

		}



		/// <summary>

		/// Transform normal (a Vector3 version of Transform, that won't use the

		/// translation part of the matrix).

		/// </summary>

		/// <param name="normal">

		/// The normal vector which will be transformed by the matrix.

		/// </param>

		/// <param name="matrix">

		/// The matrix used for transforming the provided vector.

		/// </param>

		/// <param name="result">The resulting transformed normal vector.</param>

		public static void TransformNormal(ref Vector normal, ref Matrix matrix,

			ref Vector result)

		{

			//Check performance difference again:



			result.X =

				(normal.X * matrix.M11) +

				(normal.Y * matrix.M21) +

				(normal.Z * matrix.M31);



			result.Y =

				(normal.X * matrix.M12) +

				(normal.Y * matrix.M22) +

				(normal.Z * matrix.M32);



			result.Z =

				(normal.X * matrix.M13) +

				(normal.Y * matrix.M23) +

				(normal.Z * matrix.M33);

		}

		#endregion



		#region Transform (Static)

		/// <summary>

		/// Transform the given vector by the matrix. Note: This method is slower

		/// than the ref version, which should be used for performance critical

		/// code!

		/// </summary>

		/// <param name="position">Position vector to transform</param>

		/// <param name="matrix">Matrix for the transformation</param>

		/// <returns>Transformed vector</returns>

		public static Vector Transform(Vector position, Matrix matrix)

		{

			//Check performance difference again:



			return new Vector(

				// X

				(position.X * matrix.M11) + (position.Y * matrix.M21) +

				(position.Z * matrix.M31) + matrix.M41,

				// Y

				(position.X * matrix.M12) + (position.Y * matrix.M22) +

				(position.Z * matrix.M32) + matrix.M42,

				// Z

				(position.X * matrix.M13) + (position.Y * matrix.M23) +

				(position.Z * matrix.M33) + matrix.M43);

		}



		/// <summary>

		/// Transform the given vector by the matrix (faster ref version).

		/// </summary>

		/// <param name="position">Position vector to transform</param>

		/// <param name="matrix">Matrix for the transformation</param>

		/// <param name="result">Transformed vector</param>

		public static void Transform(ref Vector position, ref Matrix matrix,

			out Vector result)

		{

			//Check performance difference again:



			result.X =

				(position.X * matrix.M11) +

				(position.Y * matrix.M21) +

				(position.Z * matrix.M31) +

				matrix.M41;



			result.Y =

				(position.X * matrix.M12) +

				(position.Y * matrix.M22) +

				(position.Z * matrix.M32) +

				matrix.M42;



			result.Z =

				(position.X * matrix.M13) +

				(position.Y * matrix.M23) +

				(position.Z * matrix.M33) +

				matrix.M43;

		}

		#endregion



		#region AngleBetweenVectors (Static)

		/// <summary>

		/// Angle between vectors in degrees.

		/// http://www.euclideanspace.com/maths/algebra/vectors/angleBetween/index.htm

		/// RadiansToDegrees(atan2(a.y,a.x) - atan2(b.y,b.x)) would only give

		/// you 0-180 degrees, but we want full 0-360 degrees with Acos :)

		/// <para />

		/// Note: If one of the vectors is zero the method we will return 0.0f.

		/// </summary>

		/// <param name="a">First vector.</param>

		/// <param name="b">Second vector.</param>

		/// <returns>Angle between the two vectors in the range [0, 360]</returns>

		public static float AngleBetweenVectors(Vector a, Vector b)

		{

			#region Validation

			// Having a single zero vector in this method will cause the calculation

			// to return 90 degrees which is not right. So we simply return 0f.

			if (a == Zero ||

			    b == Zero)

			{

				return 0f;

			}

			#endregion



			// We need to normalize the vectors so we get the cos from 0 to 1

			// the cos is the dot product of the vectors a and b

			float cos = Dot(Normalize(a), Normalize(b));

			cos = MathHelper.Clamp(cos, -1.0f, 1.0f);



			// NOTE: Special way for 2D vector handling of this

			// RadiansToDegrees(atan2(a.y,a.x) - atan2(b.y,b.x))

			Vector cross = Cross(a, b);

			return cross.Z < 0.0f

			       	? // cross products directory is upwards

			       360 - MathHelper.Acos(cos)

			       	: // else

			       MathHelper.Acos(cos);

		}

		#endregion



		#region Lerp (Static)

		/// <summary>

		/// Performs a linear interpolation between two vectors. 

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <param name="amount">Interpolation amount</param>

		/// <returns>Interpolated vector between vector 1 and 2</returns>

		public static Vector Lerp(Vector value1, Vector value2, float amount)

		{

			return new Vector(

				MathHelper.Lerp(value1.X, value2.X, amount),

				MathHelper.Lerp(value1.Y, value2.Y, amount),

				MathHelper.Lerp(value1.Z, value2.Z, amount));

		}



		/// <summary>

		/// Performs a linear interpolation between two vectors. 

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <param name="amount">Interpolation amount</param>

		/// <param name="result">Interpolated vector between vector 1 and 2</param>

		public static void Lerp(ref Vector value1, ref Vector value2,

			float amount, out Vector result)

		{

			result = new Vector(

				MathHelper.Lerp(value1.X, value2.X, amount),

				MathHelper.Lerp(value1.Y, value2.Y, amount),

				MathHelper.Lerp(value1.Z, value2.Z, amount));

		}

		#endregion



		#region GetByIndex (Static)

		/// <summary>

		/// Get a vector side (X, Y or Z) by index (0, 1 or 2).

		/// </summary>

		/// <param name="index">

		/// Index, 0 for X, 1 for Y, 2 for Z, all other values will thrown an

		/// IndexOutOfRangeException

		/// </param>

		/// <param name="vec">Vector for the X, Y or Z values.</param>

		/// <exception cref="IndexOutOfRangeException">

		/// If index is outside of 0-2.

		/// </exception>

		/// <returns>X, Y or Z value depending on the index.</returns>

		/// <exception cref="IndexOutOfRangeException">

		/// Throws index out of range exception if index is not 0, 1 or 2.

		/// </exception>

		public static float GetByIndex(ref Vector vec, int index)

		{

			switch (index)

			{

				case 0:

					return vec.X;



				case 1:

					return vec.Y;



				case 2:

					return vec.Z;



				default:

					throw new IndexOutOfRangeException();

			}

		}

		#endregion



		#region FromString (Static)

		/// <summary>

		/// Convert a string to a Vector. The expected format is (x.x, y.y, z.z)

		/// </summary>

		/// <param name="vectorString">The string containing the values in the

		/// correct format.</param>

		/// <returns>Vector from string if possible, otherwise Zero</returns>

		public static Vector FromString(string vectorString)

		{

			// Remove the brackets and split the string up into separate values.

			vectorString = vectorString.Replace("(", "");

			vectorString = vectorString.Replace(")", "");

			string[] vectorStrings = vectorString.Split(new[]

			{

				',', ' '

			},

				StringSplitOptions.RemoveEmptyEntries);



			// Then check if the length is 3 for 3 values and return the new vector.

			// If the length is not 3 than return Vector.Zero.

			if (vectorStrings.Length == 3)

			{

				return new Vector(

					vectorStrings[0].FromInvariantString(0.0f),

					vectorStrings[1].FromInvariantString(0.0f),

					vectorStrings[2].FromInvariantString(0.0f));

			}



			return Zero;

		}

		#endregion



		#region Framework Union Defines (Public)

		#endregion



		#region X (Public)

		/// <summary>

		/// X coordinate. FieldOffset means that we use the defined float in our

		/// union vector and value 0 means the first float

		/// </summary>

		[FieldOffset(0)]

		public float X;

		#endregion



		#region Y (Public)

		/// <summary>

		/// Y coordinate. FieldOffset means that we use the defined float in our

		/// union vector and value 4 means the second float (4 bytes per float).

		/// </summary>

		[FieldOffset(4)]

		public float Y;

		#endregion



		#region Z (Public)

		/// <summary>

		/// Z coordinate. FieldOffset means that we use the defined float in our

		/// union vector and value 8 means the third float (4 bytes per float).

		/// </summary>

		[FieldOffset(8)]

		public float Z;

		#endregion



		#region XProperty (Public)

		/// <summary>

		/// Property-wrapper for using the X field in the editor.

		/// </summary>

		[Browsable(true)]

		[DisplayName("X")]

		public float XProperty

		{

			get

			{

				return X;

			}

			set

			{

				X = value;

			}

		}

		#endregion



		#region YProperty (Public)

		/// <summary>

		/// Property-wrapper for using the Y field in the editor

		/// </summary>

		[Browsable(true)]

		[DisplayName("Y")]

		public float YProperty

		{

			get

			{

				return Y;

			}

			set

			{

				Y = value;

			}

		}

		#endregion



		#region ZProperty (Public)

		/// <summary>

		/// Property-wrapper for using the Z field in the editor

		/// </summary>

		[Browsable(true)]

		[DisplayName("Z")]

		public float ZProperty

		{

			get

			{

				return Z;

			}

			set

			{

				Z = value;

			}

		}

		#endregion



		#region Length (Public)

		/// <summary>

		/// The length of the vector. This takes the square root and thus is

		/// slower than using LengthSquared.

		/// </summary>

		[Browsable(false)]

		public float Length

		{

			get

			{

				return MathHelper.Sqrt(X * X + Y * Y + Z * Z);

			}

		}

		#endregion



		#region LengthSquared (Public)

		/// <summary>

		/// Length squared, much faster than using Length because we do not

		/// have to take the square root.

		/// </summary>

		[Browsable(false)]

		public float LengthSquared

		{

			get

			{

				return X * X + Y * Y + Z * Z;

			}

		}

		#endregion



		#region IsNormalized (Public)

		/// <summary>

		/// Is normalized? Will return true if the vector length is 1.0

		/// </summary>

		[Browsable(false)]

		public bool IsNormalized

		{

			get

			{

				return MathHelper.Abs(LengthSquared - 1.0f) <

				       MathHelper.Epsilon * MathHelper.Epsilon;

			}

		}

		#endregion



		#region Constructors

		/// <summary>

		/// Create vector

		/// </summary>

		/// <param name="value">value</param>

		/// <param name="z">z</param>

		public Vector(Point value, float z)

			: this()

		{

			X = value.X;

			Y = value.Y;

			Z = z;

		}



		/// <summary>

		/// Create vector

		/// </summary>

		/// <param name="setX">Set x</param>

		/// <param name="setY">Set y</param>

		/// <param name="setZ">Set z</param>

		public Vector(float setX, float setY, float setZ)

			: this()

		{

			X = setX;

			Y = setY;

			Z = setZ;

		}



		/// <summary>

		/// Create vector

		/// </summary>

		/// <param name="reader">reader</param>

		public Vector(BinaryReader reader)

			: this()

		{

			Load(reader);

		}

		#endregion



		#region IEquatable<Vector> Members

		/// <summary>

		/// Equals

		/// </summary>

		/// <param name="other">Other</param>

		/// <returns>Value indicating the equality of two vectors</returns>

		public bool Equals(Vector other)

		{

			return X == other.X &&

			       Y == other.Y &&

			       Z == other.Z;

		}

		#endregion



		#region ISaveLoadBinary Members

		/// <summary>

		/// Load all vector values from a stream (reads 12 bytes, 3 floats)

		/// </summary>

		/// <param name="reader">The stream that will be used.</param>

		public void Load(BinaryReader reader)

		{

			X = reader.ReadSingle();

			Y = reader.ReadSingle();

			Z = reader.ReadSingle();

		}



		/// <summary>

		/// Saves this vector to a stream (12 bytes, 3 floats).

		/// </summary>

		/// <param name="writer">The stream that will be used.</param>

		public void Save(BinaryWriter writer)

		{

			writer.Write(X);

			writer.Write(Y);

			writer.Write(Z);

		}

		#endregion



		#region op_Equality (Operator)

		/// <summary>

		/// Check for equality

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>True if the vectors are equal</returns>

		public static bool operator ==(Vector value1, Vector value2)

		{

			return

				value1.X == value2.X &&

				value1.Y == value2.Y &&

				value1.Z == value2.Z;

		}

		#endregion



		#region op_Inequality (Operator)

		/// <summary>

		/// Check for inequality

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>True if the vectors are not equal.</returns>

		public static bool operator !=(Vector value1, Vector value2)

		{

			return

				value1.X != value2.X ||

				value1.Y != value2.Y ||

				value1.Z != value2.Z;

		}

		#endregion



		#region op_Addition (Operator)

		/// <summary>

		/// Operator for addition

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>

		/// New vector with X, Y and Z values added from value1 and value2.

		/// </returns>

		public static Vector operator +(Vector value1, Vector value2)

		{

			return new Vector(

				value1.X + value2.X,

				value1.Y + value2.Y,

				value1.Z + value2.Z);

		}

		#endregion



		#region op_UnaryNegation (Operator)

		/// <summary>

		/// Operator for unary negation

		/// </summary>

		/// <param name="value">Vector value</param>

		/// <returns>Negated vector</returns>

		public static Vector operator -(Vector value)

		{

			return new Vector(-value.X, -value.Y, -value.Z);

		}

		#endregion



		#region op_Subtraction (Operator)

		/// <summary>

		/// Operator for subtraction

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>X, Y and Z of value2 subtracted from value1</returns>

		public static Vector operator -(Vector value1, Vector value2)

		{

			return new Vector(

				value1.X - value2.X,

				value1.Y - value2.Y,

				value1.Z - value2.Z);

		}

		#endregion



		#region op_Multiply (Operator)

		/// <summary>

		/// Operator for multiplication

		/// </summary>

		/// <param name="value1">Vector 1</param>

		/// <param name="value2">Vector 2</param>

		/// <returns>Dot product, which is the multiplication result</returns>

		public static float operator *(Vector value1, Vector value2)

		{

			float result;

			Dot(ref value1, ref value2, out result);

			return result;

		}



		/// <summary>

		/// Operator for multiplication

		/// </summary>

		/// <param name="value">Vector value</param>

		/// <param name="scaleFactor">Scale factor</param>

		/// <returns>Multiplication result</returns>

		public static Vector operator *(Vector value, float scaleFactor)

		{

			return new Vector(

				value.X * scaleFactor,

				value.Y * scaleFactor,

				value.Z * scaleFactor);

		}



		/// <summary>

		/// Operator for multiplication

		/// </summary>

		/// <param name="scaleFactor">Scale factor</param>

		/// <param name="value">Vector value</param>

		/// <returns>Multiplication result</returns>

		public static Vector operator *(float scaleFactor, Vector value)

		{

			return value * scaleFactor;

		}



		/// <summary>

		/// Operator for multiplication

		/// </summary>

		/// <param name="value">Vector value</param>

		/// <param name="transformMatrix">Transformation matrix</param>

		/// <returns>Multiplication result</returns>

		public static Vector operator *(Vector value, Matrix transformMatrix)

		{

			Vector rotatedVector = TransformNormal(value, transformMatrix);

			return transformMatrix.Translation + rotatedVector;

		}

		#endregion



		#region op_Division (Operator)

		/// <summary>

		/// Operator for division

		/// </summary>

		/// <param name="value">Vector value</param>

		/// <param name="scaleFactor">Scale factor</param>

		/// <returns>Division result</returns>

		public static Vector operator /(Vector value, float scaleFactor)

		{

			return new Vector(

				value.X / scaleFactor,

				value.Y / scaleFactor,

				value.Z / scaleFactor);

		}



		/// <summary>

		/// Op multiply

		/// </summary>

		/// <param name="scaleFactor">Scale factor</param>

		/// <param name="value">Vector value</param>

		/// <returns>Division result</returns>

		public static Vector operator /(float scaleFactor, Vector value)

		{

			return value / scaleFactor;

		}

		#endregion



		#region Normalize (Public)

		/// <summary>

		/// Normalize this vector.

		/// </summary>

		public void Normalize()

		{

			float distanceSquared = LengthSquared;

			if (distanceSquared != 0)

			{

				float distanceInverse = 1.0f / MathHelper.Sqrt(distanceSquared);

				X *= distanceInverse;

				Y *= distanceInverse;

				Z *= distanceInverse;

			}

		}

		#endregion



		#region GetByIndex (Public)

		/// <summary>

		/// Get a vector side (X, Y or Z) by index (0, 1 or 2).

		/// </summary>

		/// <param name="index">

		/// Index, 0 for X, 1 for Y, 2 for Z, all other values will thrown an

		/// IndexOutOfRangeException

		/// </param>

		/// <exception cref="IndexOutOfRangeException">

		/// If index is outside of 0-2.

		/// </exception>

		/// <returns>X, Y or Z value depending on the index.</returns>

		/// <exception cref="IndexOutOfRangeException">Unsupported index</exception>

		public float GetByIndex(int index)

		{

			switch (index)

			{

				case 0:

					return X;

				case 1:

					return Y;

				case 2:

					return Z;

				default:

					throw new IndexOutOfRangeException();

			}

		}

		#endregion



		#region GetHashCode (Public)

		/// <summary>

		/// Get hash code

		/// </summary>

		/// <returns>Hash code from X, Y and Z</returns>

		public override int GetHashCode()

		{

			return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();

		}

		#endregion



		#region NearlyEquals (Public)

		/// <summary>

		/// Equals

		/// </summary>

		/// <param name="other">Other</param>

		/// <param name="epsilon">Epsilon difference we allow for

		/// floating imprecission</param>

		/// <returns>Value indicating the equality of two vectors</returns>

		public bool NearlyEquals(Vector other, float epsilon)

		{

			return

				// Allow a difference of the Epsilon (in both directions)

				// for the X value range

				X - epsilon <= other.X &&

				X + epsilon >= other.X &&

				// and Y value range

				Y - epsilon <= other.Y &&

				Y + epsilon >= other.Y &&

				// and Z value range

				Z - epsilon <= other.Z &&

				Z + epsilon >= other.Z;

		}

		#endregion



		#region Equals (Public)

		/// <summary>

		/// Equals

		/// </summary>

		/// <param name="obj">Object to check against</param>

		/// <returns>True if obj is a Vector and is equal to this vector.</returns>

		public override bool Equals(object obj)

		{

			if (obj is Vector)

			{

				return Equals((Vector)obj);

			}

			return base.Equals(obj);

		}

		#endregion



		#region ToPoint (Public)

		/// <summary>

		/// Creates a Point from the X and Y values

		/// </summary>

		/// <returns>Point created from X and Y values of this vector.</returns>

		public Point ToPoint()

		{

			return new Point(X, Y);

		}

		#endregion



		#region ToArray (Public)

		/// <summary>

		/// Returns the vector as float array (X, Y, Z)

		/// </summary>

		/// <returns>

		/// Array with just X, Y and Z float values created from this Vector.

		/// </returns>

		public float[] ToArray()

		{

			return new[]

			{

				X, Y, Z

			};

		}

		#endregion



		#region ToString (Public)

		/// <summary>

		/// To string, also used for the old ToColladaString method, this

		/// is precise enough to be used for saving collada files.

		/// </summary>

		/// <returns>

		/// Text string with the vector in braces, e.g. "(0.4, 2.8)"

		/// </returns>

		public override string ToString()

		{

			return ToString("(", ")");

		}



		/// <summary>

		/// To string, also used for the old ToColladaString method, this

		/// is precise enough to be used for saving collada files.

		/// </summary>

		/// <param name="openBrace">Add open brace string, e.g. "("</param>

		/// <param name="closeBrace">Add close brace string, e.g. ")"</param>

		/// <returns>String with X, Y and Z values with the format 0.0000</returns>

		public string ToString(string openBrace, string closeBrace)

		{

			return

				openBrace + X.ToInvariantString("0.0000") +

				", " + Y.ToInvariantString("0.0000") +

				", " + Z.ToInvariantString("0.0000") + closeBrace;

		}

		#endregion



		/// <summary>

		/// Tests

		/// </summary>

		internal class VectorTests

		{

			#region SizeOf (Static)

			/// <summary>

			/// Checks if the size of Point is exactly 8 bytes (2 floats: X and Y)

			/// </summary>

			[Test]

			public static void SizeOf()

			{

				// Vector consists of 3 floats: X, Y and Z

				Assert.Equal(3 * 4, Marshal.SizeOf(typeof(Vector)));

			}

			#endregion



			#region Length (Static)

			/// <summary>

			/// Length

			/// </summary>

			[Test]

			public static void Length()

			{

				Assert.Equal(5, new Vector(0, 0, 5).Length);

				Assert.Equal(1, new Vector(0, 1, 0).Length);

				Assert.Equal(4, new Vector(4, 0, 0).Length);



				Assert.Equal(MathHelper.Sqrt(18), new Vector(3, 3, 0).Length);

			}

			#endregion



			#region LengthSquared (Static)

			/// <summary>

			/// Length squared

			/// </summary>

			[Test]

			public static void LengthSquared()

			{

				Assert.Equal(25, new Vector(0, 0, 5).LengthSquared);

				Assert.Equal(1, new Vector(0, 1, 0).LengthSquared);

				Assert.Equal(16, new Vector(4, 0, 0).LengthSquared);

				Assert.Equal(18, new Vector(3, 3, 0).LengthSquared);

			}

			#endregion



			#region AngleBetweenVectors (Static)

			/// <summary>

			/// Angle between vectors

			/// </summary>

			[Test]

			public static void AngleBetweenVectors()

			{

				Assert.NearlyEqual(0,

					Vector.AngleBetweenVectors(UnitX, UnitX));



				Assert.NearlyEqual(180,

					Vector.AngleBetweenVectors(UnitX, -UnitX));



				Assert.NearlyEqual(90,

					Vector.AngleBetweenVectors(UnitX, UnitY));



				Assert.NearlyEqual(270,

					Vector.AngleBetweenVectors(UnitX, -UnitY));



				Assert.NearlyEqual(225,

					Vector.AngleBetweenVectors(UnitX, new Vector(-1, -1, 0)));



				// Special cases with zero vectors!

				Assert.NearlyEqual(0,

					Vector.AngleBetweenVectors(Zero, UnitX));



				Assert.NearlyEqual(0,

					Vector.AngleBetweenVectors(Zero, Zero));

			}

			#endregion



			#region NearlyEqual (Static)

			/// <summary>

			/// Nearly equal

			/// </summary>

			[Test]

			public static void NearlyEqual()

			{

				// We need here for testing a smaller epsilon, because of the float

				// incorrectness

				const float testEpsilon = MathHelper.Epsilon * 0.01f;



				Vector testVector = new Vector(5, 12, 5);

				//test the equality normally

				Assert.True(new Vector(5, 12, 5).Equals(testVector));

				//test the vector as "object"

				Assert.True(new Vector(5, 12, 5).Equals((object)testVector));



				//check the vectors with epsilon as allowed difference

				Assert.True(testVector.NearlyEquals(

					new Vector(5 + testEpsilon, 12, 5 - testEpsilon), testEpsilon));



				//check the bad case

				Assert.False(testVector.NearlyEquals(

					new Vector(5 + (2 * testEpsilon), 12, 5 - testEpsilon),

					testEpsilon));

			}

			#endregion



			#region ToPoint (Static)

			/// <summary>

			/// To string

			/// </summary>

			[Test]

			public static void ToPoint()

			{

				Assert.Equal(new Point(23, 45),

					new Vector(23, 45, 14).ToPoint());

			}

			#endregion



			#region Equality

			/// <summary>

			/// Equality

			/// </summary>

			[Test]

			public void Equality()

			{

				Vector testVector = new Vector(32, 65, 32);



				Assert.Equal(new Vector(32, 65, 32), testVector);

				Assert.NotEqual(testVector, new Vector(0, 65, 32));

			}

			#endregion



			#region Addition

			/// <summary>

			/// Addition

			/// </summary>

			[Test]

			public void Addition()

			{

				Vector testVector = new Vector(32, 65, 32);

				Assert.Equal(new Vector(64, 130, 64), testVector + testVector);

				Assert.Equal(new Vector(32, 66.45f, 34),

					testVector + new Vector(0, 1.45f, 2f));

			}

			#endregion



			#region Substraction

			/// <summary>

			/// Substraction

			/// </summary>

			[Test]

			public void Substraction()

			{

				Vector testVector = new Vector(32, 65, 32);

				Assert.Equal(new Vector(0, 0, 0), testVector - testVector);

				Assert.Equal(new Vector(32, 63.55f, 30),

					testVector - new Vector(0, 1.45f, 2f));

			}

			#endregion



			#region Multiplication

			/// <summary>

			/// Multiplication

			/// </summary>

			[Test]

			public void Multiplication()

			{

				Assert.Equal(Vector.Dot(new Vector(5, 5, 5), new Vector(2, 2.5f, 4)),

					new Vector(5, 5, 5) * new Vector(2, 2.5f, 4));



				//check with vector and scale factor

				Assert.Equal(new Vector(5, 2.5f, 16), new Vector(10, 5, 32) * 0.5f);

				//check with vector and scale factor

				Assert.Equal(new Vector(5, 2.5f, 16), 0.5f * new Vector(10, 5, 32));

			}

			#endregion



			#region Division

			/// <summary>

			/// Multiplication

			/// </summary>

			[Test]

			public void Division()

			{

				//check with vector and scale factor

				Assert.Equal(new Vector(20, 10, 64), new Vector(10, 5, 32) / 0.5f);

				//check with vector and scale factor

				Assert.Equal(new Vector(20, 10, 64), 0.5f / new Vector(10, 5, 32));

			}

			#endregion



			#region Min

			/// <summary>

			/// Minimum

			/// </summary>

			[Test]

			public void Min()

			{

				Assert.Equal(new Vector(43, 0, 32),

					Vector.Min(new Vector(43, 3, 32), new Vector(50, 0, 40)));

			}

			#endregion



			#region Max

			/// <summary>

			/// Maximum

			/// </summary>

			[Test]

			public void Max()

			{

				Assert.Equal(new Vector(50, 3, 40),

					Vector.Max(new Vector(43, 3, 32), new Vector(50, 0, 40)));

			}

			#endregion



			#region Dot

			/// <summary>

			/// Dot

			/// </summary>

			[Test]

			public void Dot()

			{

				Assert.Equal(42.5f,

					Vector.Dot(new Vector(5, 5, 5), new Vector(2, 2.5f, 4)));

			}

			#endregion



			#region Clamp

			/// <summary>

			/// Clamp

			/// </summary>

			[Test]

			public void Clamp()

			{

				Assert.Equal(new Vector(6, 2.6f, 86),

					Vector.Clamp(new Vector(5, 3, 86), new Vector(6, 2, 50),

						new Vector(10, 2.6f, 86)));

			}

			#endregion



			#region Cross

			/// <summary>

			/// Cross

			/// </summary>

			[Test]

			public void Cross()

			{

				Assert.Equal(new Vector(-11, -7, 20),

					Vector.Cross(new Vector(4, 8, 5), new Vector(1, 7, 3)));

			}

			#endregion



			#region Distance

			/// <summary>

			/// Distance

			/// </summary>

			[Test]

			public void Distance()

			{

				Vector testVector1 = new Vector(5, 10, 4);

				Vector testVector2 = new Vector(1, 5, 3);

				Assert.Equal(MathHelper.Sqrt(42), Vector.Distance(testVector1, testVector2));

			}

			#endregion



			#region DistanceSquared

			/// <summary>

			/// Distance squared

			/// </summary>

			[Test]

			public void DistanceSquared()

			{

				Vector testVector1 = new Vector(5, 10, 4);

				Vector testVector2 = new Vector(1, 5, 3);

				Assert.Equal(42, Vector.DistanceSquared(testVector1, testVector2));

			}

			#endregion



			#region Normalize

			/// <summary>

			/// Normalize

			/// </summary>

			[Test]

			public void Normalize()

			{

				Vector testVector = new Vector(1, 5, 3);



				testVector.Normalize();

				Assert.NotEqual(new Vector(1, 5, 3), testVector);

				testVector = new Vector(0, 0, -100);

				testVector.Normalize();

				Assert.Equal(new Vector(0, 0, -1), testVector);

			}

			#endregion



			#region TransformNormal

			/// <summary>

			/// Transform normal

			/// </summary>

			[Test]

			public void TransformNormal()

			{

				Matrix testMatrix = new Matrix(

					4, 7, 2, 0,

					4, 3, 8, 5,

					4, 2, 8, 4,

					2, 1, 8, 4);

				Vector testVector = new Vector(4, 8, 1);

				Assert.Equal(new Vector(52, 54, 80),

					Vector.TransformNormal(testVector, testMatrix));

			}

			#endregion



			#region VectorToString

			/// <summary>

			/// To string

			/// </summary>

			[Test]

			public void VectorToString()

			{

				Assert.Equal("(23.0000, 45.0000, 5.0000)",

					new Vector(23, 45, 5).ToString());

			}

			#endregion

		}



		/// <summary>

		/// Vector performance class to figure out performance differences between

		/// different implementations of Vector methods available on different

		/// platforms and in different frameworks.

		/// </summary>

		[NUnit.Framework.Category("LongRunning")]

		public class VectorPerformance

		{

			#region TestLength Performance

			/// <summary>

			/// Test the length property of the Vector class.

			/// </summary>

			[Test]

			public static void TestLength()

			{

				Vector testVector = new Vector(10, 20, 30);



				// Results (Release)

				// -------

				// 2010-04-08

				//  Delta:	x ms

				//	XNA:		350 ms

				//	OpenTK:	x ms

				//  SlimDx: x ms



				float length = 0;

				PerformanceTester.Profile10MilionTimes("Vector.Length", delegate

				{

					length = testVector.Length;

				});

				Assert.Equal(length, testVector.Length);



				// Results (Release)

				// -------

				// 2010-04-08

				//  Delta:	x ms

				//	XNA:		350 ms

				//	OpenTK:	x ms

				//  SlimDx: x ms



				float lengthSquared = 0;

				PerformanceTester.Profile10MilionTimes("Vector.LengthSquared", delegate

				{

					lengthSquared = testVector.LengthSquared;

				});

				Assert.Equal(lengthSquared, testVector.LengthSquared);

			}

			#endregion



			#region TestDot Performance

			/// <summary>

			/// Test the dot method of the vector struct.

			/// </summary>

			[Test]

			public static void TestDot()

			{

				Vector testVector1 = new Vector(10, 20, 30);

				Vector testVector2 = new Vector(3, 2, 1);



				// Results (Release)

				// -------

				// 2010-04-08

				//  Delta:	x ms

				//	XNA:		350 ms

				//	OpenTK:	x ms

				//  SlimDx: x ms



				float dot = 0;

				PerformanceTester.Profile10MilionTimes("Vector.Dot", delegate

				{

					dot = Dot(testVector1, testVector2);

				});

				Assert.Equal(dot, Dot(testVector1, testVector2));

			}

			#endregion



			#region TestCross Performance

			/// <summary>

			/// Test the cross method of the vector struct.

			/// </summary>

			[Test]

			public static void TestCross()

			{

				Vector testVector1 = new Vector(10, 20, 30);

				Vector testVector2 = new Vector(3, 2, 1);



				// Results (Release)

				// -------

				// 2010-04-08

				//  Delta:	x ms

				//	XNA:		350 ms

				//	OpenTK:	x ms

				//  SlimDx: x ms



				Vector cross = Zero;

				PerformanceTester.Profile10MilionTimes("Vector.Cross", delegate

				{

					cross = Cross(testVector1, testVector2);

				});

				Assert.Equal(cross, Cross(testVector1, testVector2));

			}

			#endregion



			#region TestDistance Performance

			/// <summary>

			/// Test the distance method of the vector struct.

			/// </summary>

			[Test]

			public static void TestDistance()

			{

				Vector testVector1 = new Vector(10, 20, 30);

				Vector testVector2 = new Vector(3, 2, 1);



				// Results (Release)

				// -------

				// 2010-04-08

				//  Delta:	x ms

				//	XNA:		350 ms

				//	OpenTK:	x ms

				//  SlimDx: x ms



				float distance = 0;

				PerformanceTester.Profile10MilionTimes("Vector.Distance", delegate

				{

					distance = Distance(testVector1, testVector2);

				});

				Assert.Equal(distance, Distance(testVector1, testVector2));

			}

			#endregion



			#region TestNormalize Performance

			/// <summary>

			/// Test the normalize method of the vector struct.

			/// </summary>

			[Test]

			public static void TestNormalize()

			{

				Vector testVector1 = new Vector(10, 20, 30);



				// Results (Release)

				// -------

				// 2010-04-08

				//  Delta:	x ms

				//	XNA:		350 ms

				//	OpenTK:	x ms

				//  SlimDx: x ms



				Vector vector = Zero;

				PerformanceTester.Profile10MilionTimes("Vector.Normalize", delegate

				{

					vector = Normalize(testVector1);

				});

				Assert.Equal(vector, Normalize(testVector1));

			}

			#endregion



			#region TestTransformNormal Performance

			/// <summary>

			/// Test the transform…