Vector.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * 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
 
/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */
 
using System;
using AdvanceMath;
using System.Globalization;
using System.Collections.Generic;
 
using Matrix = Microsoft.Xna.Framework.Matrix;
 
namespace Jypeli
{
    // NOTES:
    //
    // TJ: In addition to the types Vector2 from XNA and Vector2D from AdvanceMath, we
    // have a vector type of our own!
    //
    // PROS:
    // * No need to have "using AdvanceMath" in games, keeps the interface clean and simple.
    // * Has less methods and properties, again keeping the interface clean and simple.
    // * Less typing in the name :P
    //
    // CONS:
    // * Does it add overhead in execution? I don't think so, if the compiler is smart at all.
    //   Since the vectors are struct types, their handling should be done entirely in the stack.
 
    // MR, 2021:
    // TODO: AdvancedMath paketista voisi hiljalleen alkaa luopumaan.
    // On hieman hämmentävää kun löytyy neljää eri vektoria (Jypeli, AdvancedMath, MonoGame sekä System.Numerics).
    // Nyt kuitenkin onnistuu kaikkien noiden konversiot Jypelin kanssa.
    // MonoGame on (ehkä joskus) vaihtamassa System.Numericsin vektoreihin ja matriiseihin.
 
    // Matriisit voisi myös tuoda suoraan Jypelin puolelle, niille löytyy kuitenkin käyttöä sieltä sun täältä.
 
 
    [Save]
    public struct Vector
    {
        public static readonly Vector Zero = new Vector( 0, 0 );
 
        public static readonly Vector One = new Vector( 1, 1 );
 
        public static readonly Vector UnitX = new Vector( 1.0, 0.0 );
 
        public static readonly Vector UnitY = new Vector( 0.0, 1.0 );
 
        public static readonly Vector Diagonal = Vector.One;
 
        public Vector LeftNormal
        {
            get { return new Vector( -Y, X ); }
        }
 
        public Vector RightNormal
        {
            get { return new Vector( Y, -X ); }
        }
 
        private static Vector FromLengthAndAngle( double length, double angle )
        {
            Vector result;
            result.X = length * Math.Cos( angle );
            result.Y = length * Math.Sin( angle );
            return result;
        }
 
        public static Vector FromLengthAndAngle( double length, Angle angle )
        {
            return FromLengthAndAngle( length, angle.Radians );
        }
 
        public static Vector FromAngle( Angle angle )
        {
            return FromLengthAndAngle( 1, angle.Radians );
        }
 
        public static double Distance( Vector p1, Vector p2 )
        {
            double x, y;
            x = p1.X - p2.X;
            y = p1.Y - p2.Y;
            return Math.Sqrt( (float)(x * x + y * y) );
        }
 
        public static double DotProduct( Vector left, Vector right )
        {
            return left.Y * right.Y + left.X * right.X;
        }
 
        public static double CrossProduct( Vector left, Vector right )
        {
            return left.Magnitude * right.Magnitude * ( right.Angle - left.Angle ).Sin;
        }
 
        public static Vector ComponentProduct( Vector a, Vector b )
        {
            return new Vector( a.X * b.X, a.Y * b.Y );
        }
 
        public double Distance(Vector vector)
        {
            return Distance(this, vector);
        }
 
        public double ScalarProjection(Vector vector)
        {
            return (Vector.DotProduct(this, vector) / vector.MagnitudeSquared);
        }
 
        public Vector Project( Vector to )
        {
            return ScalarProjection( to ) * to;
        }
 
        public Vector Normalize()
        {
            return this / this.Magnitude;
        }
 
        public Vector Transform( Matrix matrix )
        {
            return new Vector
            (
                ( X * matrix.M11 ) + ( Y * matrix.M21 ) + matrix.M41,
                ( X * matrix.M12 ) + ( Y * matrix.M22 ) + matrix.M42
            );
        }
 
        public Vector Transpose()
        {
            return new Vector( Y, X );
        }
 
        public static Vector Min( params Vector[] vectors )
        {
            int minIndex = 0;
            double minMagnitude = vectors[0].Magnitude;
 
            for ( int i = 1; i < vectors.Length; i++ )
            {
                double m = vectors[i].Magnitude;
                if ( m < minMagnitude )
                {
                    minIndex = i;
                    minMagnitude = m;
                }
            }
 
            return vectors[minIndex];
        }
 
        public static Vector Max( params Vector[] vectors )
        {
            int maxIndex = 0;
            double maxMagnitude = vectors[0].Magnitude;
 
            for ( int i = 1; i < vectors.Length; i++ )
            {
                double m = vectors[i].Magnitude;
                if ( m > maxMagnitude )
                {
                    maxIndex = i;
                    maxMagnitude = m;
                }
            }
 
            return vectors[maxIndex];
        }
 
        public static Vector Average( IEnumerable<Vector> vectors )
        {
            double sumX = 0;
            double sumY = 0;
            int count = 0;
 
            foreach ( var v in vectors )
            {
                sumX += v.X;
                sumY += v.Y;
                count++;
            }
 
            return count > 0 ? new Vector( sumX, sumY ) / count : Vector.Zero;
        }
 
        public static Vector Average( params Vector[] vectors )
        {
            double sumX = 0;
            double sumY = 0;
 
            foreach ( var v in vectors )
            {
                sumX += v.X;
                sumY += v.Y;
            }
 
            return vectors.Length > 0 ? new Vector( sumX, sumY ) / vectors.Length : Vector.Zero;
        }
 
        [Save] public double X;
 
        [Save] public double Y;
 
        public double Magnitude
        {
            get { return Math.Sqrt( MagnitudeSquared ); }
        }
 
        public double MagnitudeSquared
        {
            get { return X * X + Y * Y; }
        }
 
        public Vector( double X, double Y )
        {
            this.X = X;
            this.Y = Y;
        }
 
        public Angle Angle
        {
            get
            {
                double a = Math.Atan2( Y, X );
                if ( a < 0 )
                    a += 2 * Math.PI;
                return Angle.FromRadians( a );
            }
        }
 
        public override string ToString()
        {
            return ToString( NumberFormatInfo.InvariantInfo );
        }
 
        public string ToString( IFormatProvider formatProvider )
        {
            string x = X.ToString( formatProvider );
            string y = Y.ToString( formatProvider );
            return string.Format( "({0},{1})", x, y );
        }
 
        public static Vector Parse( string vectorStr )
        {
            return Parse( vectorStr, NumberFormatInfo.InvariantInfo );
        }
 
        public static Vector Parse( string vectorStr, IFormatProvider formatProvider )
        {
            string[] splitStr = vectorStr.Split( '(', ',', ')' );
 
            if ( splitStr.Length != 4 )
                throw new FormatException( "Not a vector string: " + vectorStr );
 
            double x = double.Parse( splitStr[1], formatProvider );
            double y = double.Parse( splitStr[2], formatProvider );
 
            return new Vector( x, y );
        }
 
        public override int GetHashCode()
        {
            return HashCode.Combine(X.GetHashCode(), Y.GetHashCode());
        }
 
        public override bool Equals(Object obj)
        {
            if (obj is not Vector) return false;
            
            Vector v = (Vector)obj;
 
            double x = v.X;
            double y = v.Y;
 
            return (Math.Abs(X - x) < double.Epsilon) && (Math.Abs(Y - y) < double.Epsilon);
        }
 
        #region operators
 
        public static Vector operator +(Vector left, Vector right)
        {
            Vector result;
            result.X = left.X + right.X;
            result.Y = left.Y + right.Y;
            return result;
        }
 
        public static Vector operator -(Vector left, Vector right)
        {
            Vector result;
            result.X = left.X - right.X;
            result.Y = left.Y - right.Y;
            return result;
        }
 
        public static Vector operator *(Vector source, double scalar)
        {
            Vector result;
            result.X = source.X * scalar;
            result.Y = source.Y * scalar;
            return result;
        }
 
        public static Vector operator *(double scalar, Vector source)
        {
            return source * scalar;
        }
 
        public static Vector operator /(Vector source, double scalar)
        {
            // TJ: Let's not implement this using operator* in order to
            // avoid rounding errors.
            Vector result;
            result.X = source.X / scalar;
            result.Y = source.Y / scalar;
            return result;
        }
 
        public static Vector operator -(Vector source)
        {
            Vector result;
            result.X = -source.X;
            result.Y = -source.Y;
            return result;
        }
 
        public static bool operator ==( Vector left, Vector right )
        {
            return ( Math.Abs( left.X - right.X ) < double.Epsilon ) && ( Math.Abs( left.Y - right.Y ) < double.Epsilon );
        }
 
        public static bool operator !=( Vector left, Vector right )
        {
            return !( left == right );
        }
 
        #region AdvMath conversions
 
        public static implicit operator Vector(Vector2D v)
        {
            return new Vector(v.X, v.Y);
        }
 
        public static implicit operator Vector2D(Vector v)
        {
            return new Vector2D(v.X, v.Y);
        }
 
        #endregion
        #region MonoGame conversions
 
        public static implicit operator Vector(Microsoft.Xna.Framework.Vector2 v)
        {
            return new Vector(v.X, v.Y);
        }
 
        public static implicit operator Microsoft.Xna.Framework.Vector2(Vector v)
        {
            return new Microsoft.Xna.Framework.Vector2((float)v.X, (float)v.Y);
        }
 
        public static implicit operator Vector(Microsoft.Xna.Framework.Vector3 v)
        {
            return new Vector(v.X, v.Y);
        }
 
        public static implicit operator Microsoft.Xna.Framework.Vector3(Vector v)
        {
            return new Microsoft.Xna.Framework.Vector3((float)v.X, (float)v.Y, 0);
        }
 
        public static implicit operator Vector(Microsoft.Xna.Framework.Vector4 v)
        {
            return new Vector(v.X, v.Y);
        }
 
        public static implicit operator Microsoft.Xna.Framework.Vector4(Vector v)
        {
            return new Microsoft.Xna.Framework.Vector4((float)v.X, (float)v.Y, 0, 0);
        }
 
        #endregion
        #region System.Numerics conversions
 
        public static implicit operator Vector(System.Numerics.Vector2 v)
        {
            return new Vector(v.X, v.Y);
        }
 
        public static implicit operator System.Numerics.Vector2(Vector v)
        {
            return new System.Numerics.Vector2((float)v.X, (float)v.Y);
        }
 
        public static implicit operator Vector(System.Numerics.Vector3 v)
        {
            return new Vector(v.X, v.Y);
        }
 
        public static implicit operator System.Numerics.Vector3(Vector v)
        {
            return new System.Numerics.Vector3((float)v.X, (float)v.Y, 0);
        }
 
        public static implicit operator Vector(System.Numerics.Vector4 v)
        {
            return new Vector(v.X, v.Y);
        }
 
        public static implicit operator System.Numerics.Vector4(Vector v)
        {
            return new System.Numerics.Vector4((float)v.X, (float)v.Y, 0, 0);
        }
        #endregion
        #endregion
    }
}