Vector2D.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2005-2008 Jonathan Mark Porter. http://physics2d.googlepages.com/
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy 
 * of this software and associated documentation files (the "Software"), to deal 
 * in the Software without restriction, including without limitation the rights to 
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
 * the Software, and to permit persons to whom the Software is furnished to do so, 
 * subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
#endregion
 
 
 
#if UseDouble
using Scalar = System.Double;
#else
using Scalar = System.Single;
#endif
using System;
using System.Runtime.InteropServices;
using AdvanceMath.Design;
using System.Xml.Serialization;
 
namespace AdvanceMath
{
 
    [StructLayout(LayoutKind.Sequential, Size = Vector2D.Size)]
    [AdvBrowsableOrder("X,Y")]
#if !CompactFramework && !WindowsCE && !PocketPC && !XBOX360 && !SILVERLIGHT && !WINDOWS_PHONE && !NETFX_CORE
    [Serializable]
    [System.ComponentModel.TypeConverter(typeof(AdvTypeConverter<Vector2D>))]
#endif
    public struct Vector2D : IVector<Vector2D>
    {
        #region const fields
        public const int Count = 2;
        public const int Size = sizeof(Scalar) * Count;
        #endregion
        #region readonly fields
        public static readonly Vector2D One = new Vector2D(1,1);
        public static readonly Vector2D Zero = new Vector2D();
        public static readonly Vector2D XAxis = new Vector2D(1, 0);
        public static readonly Vector2D YAxis = new Vector2D(0, 1);
        public static readonly Vector2D XYAxis = new Vector2D((Scalar)0.7071067811865475244008443621052, (Scalar)0.7071067811865475244008443621052);
 
 
        private static readonly string FormatString = MatrixHelper.CreateVectorFormatString(Count);
        private readonly static string FormatableString = MatrixHelper.CreateVectorFormatableString(Count);
        #endregion
        #region static methods
        public static void Copy(ref Vector2D vector, Scalar[] destArray)
        {
            Copy(ref vector, destArray, 0);
        }
        public static void Copy(ref Vector2D vector, Scalar[] destArray, int index)
        {
            ThrowHelper.CheckCopy(destArray, index, Count);
 
            destArray[index] = vector.X;
            destArray[++index] = vector.Y;
        }
        public static void Copy(Scalar[] sourceArray, out Vector2D result)
        {
            Copy(sourceArray, 0, out result);
        }
        public static void Copy(Scalar[] sourceArray, int index, out Vector2D result)
        {
            ThrowHelper.CheckCopy(sourceArray, index, Count);
 
            result.X = sourceArray[index];
            result.Y = sourceArray[++index];
        }
        public static void Copy(ref Vector4D source, out Vector2D dest)
        {
            dest.X = source.X;
            dest.Y = source.Y;
        }
        public static void Copy(ref Vector3D source, out Vector2D dest)
        {
            dest.X = source.X;
            dest.Y = source.Y;
        }
 
        public static Vector2D Clamp(Vector2D value, Vector2D min, Vector2D max)
        {
            Vector2D result;
            MathHelper.Clamp(ref value.X, ref  min.X, ref  max.X, out result.X);
            MathHelper.Clamp(ref value.Y, ref  min.Y, ref  max.Y, out result.Y);
            return result;
        }
        public static void Clamp(ref Vector2D value, ref Vector2D min, ref Vector2D max, out Vector2D result)
        {
            MathHelper.Clamp(ref value.X, ref  min.X, ref  max.X, out result.X);
            MathHelper.Clamp(ref value.Y, ref  min.Y, ref  max.Y, out result.Y);
        }
 
        public static Vector2D Lerp(Vector2D left, Vector2D right, Scalar amount)
        {
            Vector2D result;
            Lerp(ref left, ref right, ref amount, out result);
            return result;
        }
        public static void Lerp(ref Vector2D left, ref Vector2D right, ref Scalar amount, out Vector2D result)
        {
            result.X = (right.X - left.X) * amount + left.X;
            result.Y = (right.Y - left.Y) * amount + left.Y;
        }
        public static Vector2D Lerp(Vector2D left, Vector2D right, Vector2D amount)
        {
            Vector2D result;
            Lerp(ref left, ref right, ref amount, out result);
            return result;
        }
        public static void Lerp(ref Vector2D left, ref Vector2D right, ref Vector2D amount, out Vector2D result)
        {
            result.X = (right.X - left.X) * amount.X + left.X;
            result.Y = (right.Y - left.Y) * amount.Y + left.Y;
        }
 
        public static Scalar Distance(Vector2D left, Vector2D right)
        {
            Scalar x, y;
            x = left.X - right.X;
            y = left.Y - right.Y;
            return MathHelper.Sqrt(x * x + y * y);
        }
        public static void Distance(ref Vector2D left, ref Vector2D right, out Scalar result)
        {
            Scalar x, y;
            x = left.X - right.X;
            y = left.Y - right.Y;
            result = MathHelper.Sqrt(x * x + y * y);
        }
        public static Scalar DistanceSq(Vector2D left, Vector2D right)
        {
            Scalar x, y;
            x = left.X - right.X;
            y = left.Y - right.Y;
            return x * x + y * y;
        }
        public static void DistanceSq(ref Vector2D left, ref Vector2D right, out Scalar result)
        {
            Scalar x, y;
            x = left.X - right.X;
            y = left.Y - right.Y;
            result = x * x + y * y;
        }
        public static Vector2D FromLengthAndAngle(Scalar length, Scalar radianAngle)
        {
            Vector2D result;
            result.X = length * MathHelper.Cos(radianAngle);
            result.Y = length * MathHelper.Sin(radianAngle);
            return result;
        }
        public static void FromLengthAndAngle(ref Scalar length, ref  Scalar radianAngle, out Vector2D result)
        {
            result.X = length * MathHelper.Cos(radianAngle);
            result.Y = length * MathHelper.Sin(radianAngle);
        }
        public static Vector2D Rotate(Scalar radianAngle, Vector2D source)
        {
            Scalar negradianAngle = -radianAngle;
            Scalar cos = MathHelper.Cos(negradianAngle);
            Scalar sin = MathHelper.Sin(negradianAngle);
            Vector2D result;
            result.X = source.X * cos + source.Y * sin;
            result.Y = source.Y * cos - source.X * sin;
            return result;
        }
        public static void Rotate(ref Scalar radianAngle, ref Vector2D source, out Vector2D result)
        {
            Scalar negradianAngle = -radianAngle;
            Scalar cos = MathHelper.Cos(negradianAngle);
            Scalar sin = MathHelper.Sin(negradianAngle);
            result.X = source.X * cos + source.Y * sin;
            result.Y = source.Y * cos - source.X * sin;
        }
        public static Vector2D SetAngle(Vector2D source, Scalar radianAngle)
        {
            Scalar magnitude;
            GetMagnitude(ref source, out magnitude);
            Vector2D result;
            result.X = magnitude * MathHelper.Cos(radianAngle);
            result.Y = magnitude * MathHelper.Sin(radianAngle);
            return result;
        }
        public static void SetAngle(ref Vector2D source, ref Scalar radianAngle, out Vector2D result)
        {
            Scalar magnitude;
            GetMagnitude(ref source, out magnitude);
            result.X = magnitude * MathHelper.Cos(radianAngle);
            result.Y = magnitude * MathHelper.Sin(radianAngle);
        }
        public static Scalar GetAngle(Vector2D source)
        {
            Scalar result = MathHelper.Atan2(source.Y, source.X);
            if (result < 0) { result += MathHelper.TwoPi; }
            return result;
        }
        public static void GetAngle(ref Vector2D source, out Scalar result)
        {
            result = MathHelper.Atan2(source.Y, source.X);
            if (result < 0) { result += MathHelper.TwoPi; }
        }
        public static Vector2D Add(Vector2D left, Vector2D right)
        {
            Vector2D result;
            result.X = left.X + right.X;
            result.Y = left.Y + right.Y;
            return result;
        }
        public static void Add(ref Vector2D left, ref  Vector2D right, out Vector2D result)
        {
            result.X = left.X + right.X;
            result.Y = left.Y + right.Y;
        }
        public static Vector2D Subtract(Vector2D left, Vector2D right)
        {
            Vector2D result;
            result.X = left.X - right.X;
            result.Y = left.Y - right.Y;
            return result;
        }
        public static void Subtract(ref Vector2D left, ref  Vector2D right, out Vector2D result)
        {
            result.X = left.X - right.X;
            result.Y = left.Y - right.Y;
        }
        public static Vector2D Transform(Matrix3x3 matrix, Vector2D source)
        {
            Scalar inverseZ = 1 / (source.X * matrix.m20 + source.Y * matrix.m21 + matrix.m22);
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01 + matrix.m02) * inverseZ;
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11 + matrix.m12) * inverseZ;
            return result;
        }
        public static void Transform(ref Matrix3x3 matrix, ref Vector2D source, out Vector2D result)
        {
            Scalar X = source.X;
            Scalar inverseZ = 1 / (X * matrix.m20 + source.Y * matrix.m21 + matrix.m22);
            result.X = (X * matrix.m00 + source.Y * matrix.m01 + matrix.m02) * inverseZ;
            result.Y = (X * matrix.m10 + source.Y * matrix.m11 + matrix.m12) * inverseZ;
        }
        public static Vector2D TransformNormal(Matrix3x3 matrix, Vector2D source)
        {
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01);
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11);
            return result;
        }
        public static void TransformNormal(ref Matrix3x3 matrix, ref Vector2D source, out Vector2D result)
        {
            Scalar X = source.X;
            result.X = (X * matrix.m00 + source.Y * matrix.m01);
            result.Y = (X * matrix.m10 + source.Y * matrix.m11);
        }
        public static Vector2D Transform(Matrix2x3 matrix, Vector2D source)
        {
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01 + matrix.m02);
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11 + matrix.m12);
            return result;
        }
        public static void Transform(ref Matrix2x3 matrix, ref Vector2D source, out Vector2D result)
        {
            Scalar X = source.X;
            result.X = (X * matrix.m00 + source.Y * matrix.m01 + matrix.m02);
            result.Y = (X * matrix.m10 + source.Y * matrix.m11 + matrix.m12);
        }
        public static Vector2D TransformNormal(Matrix2x3 matrix, Vector2D source)
        {
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01);
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11);
            return result;
        }
        public static void TransformNormal(ref Matrix2x3 matrix, ref Vector2D source, out Vector2D result)
        {
            Scalar X = source.X;
            result.X = (X * matrix.m00 + source.Y * matrix.m01);
            result.Y = (X * matrix.m10 + source.Y * matrix.m11);
        }
        public static Vector2D Transform(Matrix2x2 matrix, Vector2D source)
        {
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01);
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11);
            return result;
        }
        public static void Transform(ref Matrix2x2 matrix, ref Vector2D source, out Vector2D result)
        {
            Scalar X = source.X;
            result.X = (X * matrix.m00 + source.Y * matrix.m01);
            result.Y = (X * matrix.m10 + source.Y * matrix.m11);
        }
        public static Vector2D Multiply(Vector2D source, Scalar scalar)
        {
            Vector2D result;
            result.X = source.X * scalar;
            result.Y = source.Y * scalar;
            return result;
        }
        public static void Multiply(ref Vector2D source, ref  Scalar scalar, out Vector2D result)
        {
            result.X = source.X * scalar;
            result.Y = source.Y * scalar;
        }
 
        public static Vector2D Multiply(Scalar scalar, Vector2D source)
        {
            Vector2D result;
            result.X = scalar * source.X;
            result.Y = scalar * source.Y;
            return result;
        }
        public static void Multiply(ref Scalar scalar, ref  Vector2D source, out Vector2D result)
        {
            result.X = scalar * source.X;
            result.Y = scalar * source.Y;
        }
        public static Scalar Dot(Vector2D left, Vector2D right)
        {
            return left.Y * right.Y + left.X * right.X;
        }
        public static void Dot(ref Vector2D left, ref Vector2D right, out Scalar result)
        {
            result = left.X * right.X + left.Y * right.Y;
        }
        public static Scalar ZCross(Vector2D left, Vector2D right)
        {
            return left.X * right.Y - left.Y * right.X;
        }
        public static void ZCross(ref Vector2D left, ref Vector2D right, out Scalar result)
        {
            result = left.X * right.Y - left.Y * right.X;
        }
        public static Vector2D ZCross(Scalar leftZ, Vector2D right)
        {
            Vector2D result;
            result.X = -leftZ * right.Y;
            result.Y = leftZ * right.X;
            return result;
        }
        public static void ZCross(ref Scalar leftZ, ref Vector2D right, out Vector2D result)
        {
            Scalar rightX = right.X;
            result.X = -leftZ * right.Y;
            result.Y = leftZ * rightX;
        }
        public static Vector2D ZCross(Vector2D left, Scalar rightZ)
        {
            Vector2D result;
            result.X = left.Y * rightZ;
            result.Y = -left.X * rightZ;
            return result;
        }
        public static void ZCross(ref Vector2D left, ref Scalar rightZ, out Vector2D result)
        {
            Scalar leftX = left.X;
            result.X = left.Y * rightZ;
            result.Y = -leftX * rightZ;
        }
        public static Scalar GetMagnitudeSq(Vector2D source)
        {
            return source.X * source.X + source.Y * source.Y;
        }
        public static void GetMagnitudeSq(ref Vector2D source, out Scalar result)
        {
            result = source.X * source.X + source.Y * source.Y;
        }
        public static Scalar GetMagnitude(Vector2D source)
        {
            return MathHelper.Sqrt(source.X * source.X + source.Y * source.Y);
        }
        public static void GetMagnitude(ref Vector2D source, out Scalar result)
        {
            result = MathHelper.Sqrt(source.X * source.X + source.Y * source.Y);
        }
        public static Vector2D SetMagnitude(Vector2D source, Scalar magnitude)
        {
            Vector2D result;
            SetMagnitude(ref source, ref magnitude, out result);
            return result;
        }
        public static void SetMagnitude(ref Vector2D source, ref Scalar magnitude, out Vector2D result)
        {
            if (magnitude == 0) { result = Zero; return; }
            Scalar oldmagnitude = MathHelper.Sqrt(source.X * source.X + source.Y * source.Y);
            if (oldmagnitude == 0) { result = Zero; return; }
            oldmagnitude = (magnitude / oldmagnitude);
            result.X = source.X * oldmagnitude;
            result.Y = source.Y * oldmagnitude;
        }
        public static Vector2D Negate(Vector2D source)
        {
            Vector2D result;
            result.X = -source.X;
            result.Y = -source.Y;
            return result;
        }
        public static void Negate(ref Vector2D source)
        {
            Negate(ref source, out source);
        }
        public static void Negate(ref Vector2D source, out Vector2D result)
        {
            result.X = -source.X;
            result.Y = -source.Y;
        }
        public static Vector2D Normalize(Vector2D source)
        {
            Scalar oldmagnitude;
            GetMagnitude(ref source, out oldmagnitude);
            if (oldmagnitude == 0) { return Vector2D.Zero; }
            oldmagnitude = (1 / oldmagnitude);
            Vector2D result;
            result.X = source.X * oldmagnitude;
            result.Y = source.Y * oldmagnitude;
            return result;
        }
        public static void Normalize(ref Vector2D source, out Vector2D result)
        {
            Scalar oldmagnitude;
            GetMagnitude(ref source, out oldmagnitude);
            if (oldmagnitude == 0) { result = Zero; return; }
            oldmagnitude = (1 / oldmagnitude);
            result.X = source.X * oldmagnitude;
            result.Y = source.Y * oldmagnitude;
        }
        public static void Normalize(ref Vector2D source)
        {
            Normalize(ref source, out source);
        }
        public static Vector2D Normalize(Vector2D source, out Scalar magnitude)
        {
            Vector2D result;
            Normalize(ref source, out magnitude, out result);
            return result;
        }
        public static void Normalize(ref Vector2D source, out Scalar magnitude, out Vector2D result)
        {
            GetMagnitude(ref source, out magnitude);
            if (magnitude > 0)
            {
                Scalar magnitudeInv = (1 / magnitude);
                result.X = source.X * magnitudeInv;
                result.Y = source.Y * magnitudeInv;
            }
            else
            {
                result = Zero;
            }
        }
        public static Vector2D Project(Vector2D left, Vector2D right)
        {
            Vector2D result;
            Project(ref left, ref right, out result);
            return result;
        }
        public static void Project(ref Vector2D left, ref Vector2D right, out Vector2D result)
        {
            Scalar tmp, magsq;
            Dot(ref left, ref  right, out tmp);
            GetMagnitudeSq(ref right, out magsq);
            tmp /= magsq;
            Multiply(ref right, ref tmp, out result);
        }
        public static Vector2D GetRightHandNormal(Vector2D source)
        {
            Vector2D result;
            result.X = -source.Y;
            result.Y = source.X;
            return result;
        }
        public static void GetRightHandNormal(ref Vector2D source, out Vector2D result)
        {
            Scalar sourceX = source.X;
            result.X = -source.Y;
            result.Y = sourceX;
        }
        public static Vector2D GetLeftHandNormal(Vector2D source)
        {
            Vector2D result;
            result.X = source.Y;
            result.Y = -source.X;
            return result;
        }
        public static void GetLeftHandNormal(ref Vector2D source, out Vector2D result)
        {
            Scalar sourceX = source.X;
            result.X = source.Y;
            result.Y = -sourceX;
        }
 
        public static Vector2D Hermite(Vector2D value1, Vector2D tangent1, Vector2D value2, Vector2D tangent2, Scalar amount)
        {
            Vector2D result;
            Hermite(ref value1, ref tangent1, ref value2, ref tangent2, amount, out result);
            return result;
        }
        public static void Hermite(ref  Vector2D value1, ref Vector2D tangent1, ref Vector2D value2, ref Vector2D tangent2, Scalar amount, out Vector2D result)
        {
            Scalar h1, h2, h3, h4;
            MathHelper.HermiteHelper(amount, out h1, out h2, out h3, out h4);
            result.X = h1 * value1.X + h2 * value2.X + h3 * tangent1.X + h4 * tangent2.X;
            result.Y = h1 * value1.Y + h2 * value2.Y + h3 * tangent1.Y + h4 * tangent2.Y;
        }
 
        public static Vector2D CatmullRom(Vector2D value1, Vector2D value2, Vector2D value3, Vector2D value4, Scalar amount)
        {
            Vector2D result;
            CatmullRom(ref value1, ref value2, ref value3, ref value4, amount, out result);
            return result;
        }
        public static void CatmullRom(ref Vector2D value1, ref Vector2D value2, ref Vector2D value3, ref Vector2D value4, Scalar amount, out Vector2D result)
        {
            Scalar amountSq = amount * amount;
            Scalar amountCu = amountSq * amount;
            result.X =
                0.5f * ((2 * value2.X) +
                (-value1.X + value3.X) * amount +
                (2 * value1.X - 5 * value2.X + 4 * value3.X - value4.X) * amountSq +
                (-value1.X + 3 * value2.X - 3 * value3.X + value4.X) * amountCu);
            result.Y =
                0.5f * ((2 * value2.Y) +
                (-value1.Y + value3.Y) * amount +
                (2 * value1.Y - 5 * value2.Y + 4 * value3.Y - value4.Y) * amountSq +
                (-value1.Y + 3 * value2.Y - 3 * value3.Y + value4.Y) * amountCu);
        }
 
        public static Vector2D Max(Vector2D value1, Vector2D value2)
        {
            Vector2D result;
            Max(ref value1, ref value2, out result);
            return result;
        }
        public static void Max(ref Vector2D value1, ref Vector2D value2, out Vector2D result)
        {
            result.X = (value1.X < value2.X) ? (value2.X) : (value1.X);
            result.Y = (value1.Y < value2.Y) ? (value2.Y) : (value1.Y);
        }
 
        public static Vector2D Min(Vector2D value1, Vector2D value2)
        {
            Vector2D result;
            Min(ref value1, ref value2, out result);
            return result;
        }
        public static void Min(ref Vector2D value1, ref Vector2D value2, out Vector2D result)
        {
            result.X = (value1.X > value2.X) ? (value2.X) : (value1.X);
            result.Y = (value1.Y > value2.Y) ? (value2.Y) : (value1.Y);
        }
 
        #endregion
        #region fields
        [AdvBrowsable]
        [XmlAttribute]
#if !WINDOWS_STOREAPP
        [System.ComponentModel.Description("The Magnitude on the X-Axis")]
#endif
        public Scalar X;
        [AdvBrowsable]
        [XmlAttribute]
#if !WINDOWS_STOREAPP
        [System.ComponentModel.Description("The Magnitude on the Y-Axis")]
#endif
        public Scalar Y;
        #endregion
        #region constructors
        [InstanceConstructor("X,Y")]
        public Vector2D(Scalar X, Scalar Y)
        {
            this.X = X;
            this.Y = Y;
        }
        public Vector2D(Scalar[] vals) : this(vals, 0) { }
        public Vector2D(Scalar[] vals, int index)
        {
            Copy(vals, index, out this);
        }
        #endregion
        #region indexers
#if UNSAFE
        public Scalar this[int index]
        {
            get
            {
                ThrowHelper.CheckIndex("index", index, Count);
                unsafe
                {
                    fixed (Scalar* ptr = &this.X)
                    {
                        return ptr[index];
                    }
                }
            }
            set
            {
                ThrowHelper.CheckIndex("index", index, Count);
                unsafe
                {
                    fixed (Scalar* ptr = &this.X)
                    {
                        ptr[index] = value;
                    }
                }
            }
        }
#endif
        #endregion
        #region public properties
        public Vector2D RightHandNormal
        {
            get
            {
                return GetRightHandNormal(this);
            }
        }
        public Vector2D LeftHandNormal
        {
            get
            {
                return GetLeftHandNormal(this);
            }
        }
        [XmlIgnore]
        public Scalar Magnitude
        {
            get
            {
                return MathHelper.Sqrt(this.X * this.X + this.Y * this.Y);
            }
            set
            {
                SetMagnitude(ref this, ref value, out this);
            }
        }
        public Scalar MagnitudeSq
        {
            get
            {
                return this.X * this.X + this.Y * this.Y;
            }
        }
        [XmlIgnore]
        public Scalar Angle
        {
            get
            {
                Scalar result;
                GetAngle(ref this, out result);
                return result;
            }
            set
            {
                SetAngle(ref this, ref value, out this);
            }
        }
        public Vector2D Normalized
        {
            get
            {
                return Normalize(this);
            }
        }
        int IAdvanceValueType.Count { get { return Count; } }
        #endregion
        #region public methods
        public Scalar[] ToArray()
        {
            Scalar[] array = new Scalar[Count];
            Copy(ref this, array, 0);
            return array;
        }
        public void CopyFrom(Scalar[] array, int index)
        {
            Copy(array, index, out this);
        }
        public void CopyTo(Scalar[] array, int index)
        {
            Copy(ref this, array, index);
        }
        public Vector3D ToVector3D(Scalar Z)
        {
            Vector3D rv;
            rv.X = this.X;
            rv.Y = this.Y;
            rv.Z = Z;
            return rv;
        }
        #endregion
        #region operators
        public static Vector2D operator +(Vector2D left, Vector2D right)
        {
            Vector2D result;
            result.X = left.X + right.X;
            result.Y = left.Y + right.Y;
            return result;
        }
        public static Vector2D operator -(Vector2D left, Vector2D right)
        {
            Vector2D result;
            result.X = left.X - right.X;
            result.Y = left.Y - right.Y;
            return result;
        }
        public static Vector2D operator *(Vector2D source, Scalar scalar)
        {
            Vector2D result;
            result.X = source.X * scalar;
            result.Y = source.Y * scalar;
            return result;
        }
        public static Vector2D operator *(Scalar scalar, Vector2D source)
        {
            Vector2D result;
            result.X = scalar * source.X;
            result.Y = scalar * source.Y;
            return result;
        }
        public static Scalar operator *(Vector2D left, Vector2D right)
        {
            return left.Y * right.Y + left.X * right.X;
        }
        public static Vector2D operator *(Matrix2x3 matrix, Vector2D source)
        {
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01 + matrix.m02);
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11 + matrix.m12);
            return result;
        }
        public static Vector2D operator *(Matrix3x3 matrix, Vector2D source)
        {
            Scalar inverseZ = 1 / (source.X * matrix.m20 + source.Y * matrix.m21 + matrix.m22);
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01 + matrix.m02) * inverseZ;
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11 + matrix.m12) * inverseZ;
            return result;
        }
        public static Vector2D operator *(Matrix2x2 matrix, Vector2D source)
        {
            Vector2D result;
            result.X = (source.X * matrix.m00 + source.Y * matrix.m01);
            result.Y = (source.X * matrix.m10 + source.Y * matrix.m11);
            return result;
        }
        public static Vector2D operator -(Vector2D source)
        {
            Vector2D result;
            result.X = -source.X;
            result.Y = -source.Y;
            return result;
        }
        public static Scalar operator ^(Vector2D left, Vector2D right)
        {
            return left.X * right.Y - left.Y * right.X;
        }
        public static Vector2D operator ^(Scalar leftZ, Vector2D right)
        {
            Vector2D result;
            result.X = -leftZ * right.Y;
            result.Y = leftZ * right.X;
            return result;
        }
        public static Vector2D operator ^(Vector2D left, Scalar rightZ)
        {
            Vector2D result;
            result.X = left.Y * rightZ;
            result.Y = -left.X * rightZ;
            return result;
        }
        public static bool operator ==(Vector2D left, Vector2D right)
        {
            return left.X == right.X && left.Y == right.Y;
        }
        public static bool operator !=(Vector2D left, Vector2D right)
        {
            return !(left.X == right.X && left.Y == right.Y);
        }
 
 
 
        public static explicit operator Vector2D(Vector3D source)
        {
            Vector2D result;
            result.X = source.X;
            result.Y = source.Y;
            return result;
        }
 
        #endregion
        #region overrides
        private string ToStringInternal(string FormatString)
        {
            return string.Format(FormatString, X, Y);
        }
        public string ToString(string format)
        {
            return ToStringInternal(string.Format(FormatableString, format));
        }
        public override string ToString()
        {
            return ToStringInternal(FormatString);
        }
 
#if !CompactFramework && !WindowsCE && !PocketPC && !XBOX360 && !SILVERLIGHT 
        public static bool TryParse(string s, out Vector2D result)
        {
            if (s == null)
            {
                result = Zero;
                return false;
            }
            string[] vals = ParseHelper.SplitStringVector(s);
            if (vals.Length != Count)
            {
                result = Zero;
                return false;
            }
            if (Scalar.TryParse(vals[0], out result.X) &&
                Scalar.TryParse(vals[1], out result.Y))
            {
                return true;
            }
            else
            {
                result = Zero;
                return false;
            }
        }
#endif
        [ParseMethod]
        public static Vector2D Parse(string s)
        {
            if (s == null)
            {
                throw new ArgumentNullException("s");
            }
            string[] vals = ParseHelper.SplitStringVector(s);
            if (vals.Length != Count)
            {
                ThrowHelper.ThrowVectorFormatException(s, Count, FormatString);
            }
            Vector2D value;
            value.X = Scalar.Parse(vals[0]);
            value.Y = Scalar.Parse(vals[1]);
            return value;
        }
 
        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode();
        }
        public override bool Equals(object obj)
        {
            return (obj is Vector2D) && Equals((Vector2D)obj);
        }
        public bool Equals(Vector2D other)
        {
            return Equals(ref this, ref other);
        }
        public static bool Equals(Vector2D left, Vector2D right)
        {
            return
                left.X == right.X &&
                left.Y == right.Y;
        }
        public static bool Equals(ref Vector2D left, ref Vector2D right)
        {
            return
                left.X == right.X &&
                left.Y == right.Y;
        }
        #endregion
    }
}