using System;
using UnityEngine.Scripting;

namespace UnityEngine
{
	// Token: 0x0200048E RID: 1166
	[UsedByNativeCode]
	public struct Vector2
	{
		// Token: 0x06003A1E RID: 14878 RVA: 0x00065758 File Offset: 0x00063958
		public Vector2(float x, float y)
		{
			this.x = x;
			this.y = y;
		}

		// Token: 0x17000D3F RID: 3391
		public float this[int index]
		{
			get
			{
				float num;
				if (index != 0)
				{
					if (index != 1)
					{
						throw new IndexOutOfRangeException("Invalid Vector2 index!");
					}
					num = this.y;
				}
				else
				{
					num = this.x;
				}
				return num;
			}
			set
			{
				if (index != 0)
				{
					if (index != 1)
					{
						throw new IndexOutOfRangeException("Invalid Vector2 index!");
					}
					this.y = value;
				}
				else
				{
					this.x = value;
				}
			}
		}

		// Token: 0x06003A21 RID: 14881 RVA: 0x000657E8 File Offset: 0x000639E8
		public void Set(float newX, float newY)
		{
			this.x = newX;
			this.y = newY;
		}

		// Token: 0x06003A22 RID: 14882 RVA: 0x000657FC File Offset: 0x000639FC
		public static Vector2 Lerp(Vector2 a, Vector2 b, float t)
		{
			t = Mathf.Clamp01(t);
			return new Vector2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
		}

		// Token: 0x06003A23 RID: 14883 RVA: 0x00065850 File Offset: 0x00063A50
		public static Vector2 LerpUnclamped(Vector2 a, Vector2 b, float t)
		{
			return new Vector2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
		}

		// Token: 0x06003A24 RID: 14884 RVA: 0x0006589C File Offset: 0x00063A9C
		public static Vector2 MoveTowards(Vector2 current, Vector2 target, float maxDistanceDelta)
		{
			Vector2 vector = target - current;
			float magnitude = vector.magnitude;
			Vector2 vector2;
			if (magnitude <= maxDistanceDelta || magnitude == 0f)
			{
				vector2 = target;
			}
			else
			{
				vector2 = current + vector / magnitude * maxDistanceDelta;
			}
			return vector2;
		}

		// Token: 0x06003A25 RID: 14885 RVA: 0x000658F0 File Offset: 0x00063AF0
		public static Vector2 Scale(Vector2 a, Vector2 b)
		{
			return new Vector2(a.x * b.x, a.y * b.y);
		}

		// Token: 0x06003A26 RID: 14886 RVA: 0x00065928 File Offset: 0x00063B28
		public void Scale(Vector2 scale)
		{
			this.x *= scale.x;
			this.y *= scale.y;
		}

		// Token: 0x06003A27 RID: 14887 RVA: 0x00065954 File Offset: 0x00063B54
		public void Normalize()
		{
			float magnitude = this.magnitude;
			if (magnitude > 1E-05f)
			{
				this /= magnitude;
			}
			else
			{
				this = Vector2.zero;
			}
		}

		// Token: 0x17000D40 RID: 3392
		// (get) Token: 0x06003A28 RID: 14888 RVA: 0x00065998 File Offset: 0x00063B98
		public Vector2 normalized
		{
			get
			{
				Vector2 vector = new Vector2(this.x, this.y);
				vector.Normalize();
				return vector;
			}
		}

		// Token: 0x06003A29 RID: 14889 RVA: 0x000659C8 File Offset: 0x00063BC8
		public override string ToString()
		{
			return UnityString.Format("({0:F1}, {1:F1})", new object[] { this.x, this.y });
		}

		// Token: 0x06003A2A RID: 14890 RVA: 0x00065A0C File Offset: 0x00063C0C
		public string ToString(string format)
		{
			return UnityString.Format("({0}, {1})", new object[]
			{
				this.x.ToString(format),
				this.y.ToString(format)
			});
		}

		// Token: 0x06003A2B RID: 14891 RVA: 0x00065A50 File Offset: 0x00063C50
		public override int GetHashCode()
		{
			return this.x.GetHashCode() ^ (this.y.GetHashCode() << 2);
		}

		// Token: 0x06003A2C RID: 14892 RVA: 0x00065A8C File Offset: 0x00063C8C
		public override bool Equals(object other)
		{
			bool flag;
			if (!(other is Vector2))
			{
				flag = false;
			}
			else
			{
				Vector2 vector = (Vector2)other;
				flag = this.x.Equals(vector.x) && this.y.Equals(vector.y);
			}
			return flag;
		}

		// Token: 0x06003A2D RID: 14893 RVA: 0x00065AE8 File Offset: 0x00063CE8
		public static Vector2 Reflect(Vector2 inDirection, Vector2 inNormal)
		{
			return -2f * Vector2.Dot(inNormal, inDirection) * inNormal + inDirection;
		}

		// Token: 0x06003A2E RID: 14894 RVA: 0x00065B18 File Offset: 0x00063D18
		public static float Dot(Vector2 lhs, Vector2 rhs)
		{
			return lhs.x * rhs.x + lhs.y * rhs.y;
		}

		// Token: 0x17000D41 RID: 3393
		// (get) Token: 0x06003A2F RID: 14895 RVA: 0x00065B4C File Offset: 0x00063D4C
		public float magnitude
		{
			get
			{
				return Mathf.Sqrt(this.x * this.x + this.y * this.y);
			}
		}

		// Token: 0x17000D42 RID: 3394
		// (get) Token: 0x06003A30 RID: 14896 RVA: 0x00065B84 File Offset: 0x00063D84
		public float sqrMagnitude
		{
			get
			{
				return this.x * this.x + this.y * this.y;
			}
		}

		// Token: 0x06003A31 RID: 14897 RVA: 0x00065BB4 File Offset: 0x00063DB4
		public static float Angle(Vector2 from, Vector2 to)
		{
			return Mathf.Acos(Mathf.Clamp(Vector2.Dot(from.normalized, to.normalized), -1f, 1f)) * 57.29578f;
		}

		// Token: 0x06003A32 RID: 14898 RVA: 0x00065BF8 File Offset: 0x00063DF8
		public static float SignedAngle(Vector2 from, Vector2 to)
		{
			Vector2 normalized = from.normalized;
			Vector2 normalized2 = to.normalized;
			float num = Mathf.Acos(Mathf.Clamp(Vector2.Dot(normalized, normalized2), -1f, 1f)) * 57.29578f;
			float num2 = Mathf.Sign(normalized.x * normalized2.y - normalized.y * normalized2.x);
			return num * num2;
		}

		// Token: 0x06003A33 RID: 14899 RVA: 0x00065C6C File Offset: 0x00063E6C
		public static float Distance(Vector2 a, Vector2 b)
		{
			return (a - b).magnitude;
		}

		// Token: 0x06003A34 RID: 14900 RVA: 0x00065C90 File Offset: 0x00063E90
		public static Vector2 ClampMagnitude(Vector2 vector, float maxLength)
		{
			Vector2 vector2;
			if (vector.sqrMagnitude > maxLength * maxLength)
			{
				vector2 = vector.normalized * maxLength;
			}
			else
			{
				vector2 = vector;
			}
			return vector2;
		}

		// Token: 0x06003A35 RID: 14901 RVA: 0x00065CC8 File Offset: 0x00063EC8
		public static float SqrMagnitude(Vector2 a)
		{
			return a.x * a.x + a.y * a.y;
		}

		// Token: 0x06003A36 RID: 14902 RVA: 0x00065CFC File Offset: 0x00063EFC
		public float SqrMagnitude()
		{
			return this.x * this.x + this.y * this.y;
		}

		// Token: 0x06003A37 RID: 14903 RVA: 0x00065D2C File Offset: 0x00063F2C
		public static Vector2 Min(Vector2 lhs, Vector2 rhs)
		{
			return new Vector2(Mathf.Min(lhs.x, rhs.x), Mathf.Min(lhs.y, rhs.y));
		}

		// Token: 0x06003A38 RID: 14904 RVA: 0x00065D6C File Offset: 0x00063F6C
		public static Vector2 Max(Vector2 lhs, Vector2 rhs)
		{
			return new Vector2(Mathf.Max(lhs.x, rhs.x), Mathf.Max(lhs.y, rhs.y));
		}

		// Token: 0x06003A39 RID: 14905 RVA: 0x00065DAC File Offset: 0x00063FAC
		public static Vector2 SmoothDamp(Vector2 current, Vector2 target, ref Vector2 currentVelocity, float smoothTime, float maxSpeed, float deltaTime)
		{
			smoothTime = Mathf.Max(0.0001f, smoothTime);
			float num = 2f / smoothTime;
			float num2 = num * deltaTime;
			float num3 = 1f / (1f + num2 + 0.48f * num2 * num2 + 0.235f * num2 * num2 * num2);
			Vector2 vector = current - target;
			Vector2 vector2 = target;
			float num4 = maxSpeed * smoothTime;
			vector = Vector2.ClampMagnitude(vector, num4);
			target = current - vector;
			Vector2 vector3 = (currentVelocity + num * vector) * deltaTime;
			currentVelocity = (currentVelocity - num * vector3) * num3;
			Vector2 vector4 = target + (vector + vector3) * num3;
			if (Vector2.Dot(vector2 - current, vector4 - vector2) > 0f)
			{
				vector4 = vector2;
				currentVelocity = (vector4 - vector2) / deltaTime;
			}
			return vector4;
		}

		// Token: 0x06003A3A RID: 14906 RVA: 0x00065EB4 File Offset: 0x000640B4
		public static Vector2 operator +(Vector2 a, Vector2 b)
		{
			return new Vector2(a.x + b.x, a.y + b.y);
		}

		// Token: 0x06003A3B RID: 14907 RVA: 0x00065EEC File Offset: 0x000640EC
		public static Vector2 operator -(Vector2 a, Vector2 b)
		{
			return new Vector2(a.x - b.x, a.y - b.y);
		}

		// Token: 0x06003A3C RID: 14908 RVA: 0x00065F24 File Offset: 0x00064124
		public static Vector2 operator -(Vector2 a)
		{
			return new Vector2(-a.x, -a.y);
		}

		// Token: 0x06003A3D RID: 14909 RVA: 0x00065F50 File Offset: 0x00064150
		public static Vector2 operator *(Vector2 a, float d)
		{
			return new Vector2(a.x * d, a.y * d);
		}

		// Token: 0x06003A3E RID: 14910 RVA: 0x00065F7C File Offset: 0x0006417C
		public static Vector2 operator *(float d, Vector2 a)
		{
			return new Vector2(a.x * d, a.y * d);
		}

		// Token: 0x06003A3F RID: 14911 RVA: 0x00065FA8 File Offset: 0x000641A8
		public static Vector2 operator /(Vector2 a, float d)
		{
			return new Vector2(a.x / d, a.y / d);
		}

		// Token: 0x06003A40 RID: 14912 RVA: 0x00065FD4 File Offset: 0x000641D4
		public static bool operator ==(Vector2 lhs, Vector2 rhs)
		{
			return (lhs - rhs).sqrMagnitude < 9.9999994E-11f;
		}

		// Token: 0x06003A41 RID: 14913 RVA: 0x00066000 File Offset: 0x00064200
		public static bool operator !=(Vector2 lhs, Vector2 rhs)
		{
			return !(lhs == rhs);
		}

		// Token: 0x06003A42 RID: 14914 RVA: 0x00066020 File Offset: 0x00064220
		public static implicit operator Vector2(Vector3 v)
		{
			return new Vector2(v.x, v.y);
		}

		// Token: 0x06003A43 RID: 14915 RVA: 0x00066048 File Offset: 0x00064248
		public static implicit operator Vector3(Vector2 v)
		{
			return new Vector3(v.x, v.y, 0f);
		}

		// Token: 0x17000D43 RID: 3395
		// (get) Token: 0x06003A44 RID: 14916 RVA: 0x00066078 File Offset: 0x00064278
		public static Vector2 zero
		{
			get
			{
				return Vector2.zeroVector;
			}
		}

		// Token: 0x17000D44 RID: 3396
		// (get) Token: 0x06003A45 RID: 14917 RVA: 0x00066094 File Offset: 0x00064294
		public static Vector2 one
		{
			get
			{
				return Vector2.oneVector;
			}
		}

		// Token: 0x17000D45 RID: 3397
		// (get) Token: 0x06003A46 RID: 14918 RVA: 0x000660B0 File Offset: 0x000642B0
		public static Vector2 up
		{
			get
			{
				return Vector2.upVector;
			}
		}

		// Token: 0x17000D46 RID: 3398
		// (get) Token: 0x06003A47 RID: 14919 RVA: 0x000660CC File Offset: 0x000642CC
		public static Vector2 down
		{
			get
			{
				return Vector2.downVector;
			}
		}

		// Token: 0x17000D47 RID: 3399
		// (get) Token: 0x06003A48 RID: 14920 RVA: 0x000660E8 File Offset: 0x000642E8
		public static Vector2 left
		{
			get
			{
				return Vector2.leftVector;
			}
		}

		// Token: 0x17000D48 RID: 3400
		// (get) Token: 0x06003A49 RID: 14921 RVA: 0x00066104 File Offset: 0x00064304
		public static Vector2 right
		{
			get
			{
				return Vector2.rightVector;
			}
		}

		// Token: 0x17000D49 RID: 3401
		// (get) Token: 0x06003A4A RID: 14922 RVA: 0x00066120 File Offset: 0x00064320
		public static Vector2 positiveInfinity
		{
			get
			{
				return Vector2.positiveInfinityVector;
			}
		}

		// Token: 0x17000D4A RID: 3402
		// (get) Token: 0x06003A4B RID: 14923 RVA: 0x0006613C File Offset: 0x0006433C
		public static Vector2 negativeInfinity
		{
			get
			{
				return Vector2.negativeInfinityVector;
			}
		}

		// Token: 0x0400119B RID: 4507
		public float x;

		// Token: 0x0400119C RID: 4508
		public float y;

		// Token: 0x0400119D RID: 4509
		private static readonly Vector2 zeroVector = new Vector2(0f, 0f);

		// Token: 0x0400119E RID: 4510
		private static readonly Vector2 oneVector = new Vector2(1f, 1f);

		// Token: 0x0400119F RID: 4511
		private static readonly Vector2 upVector = new Vector2(0f, 1f);

		// Token: 0x040011A0 RID: 4512
		private static readonly Vector2 downVector = new Vector2(0f, -1f);

		// Token: 0x040011A1 RID: 4513
		private static readonly Vector2 leftVector = new Vector2(-1f, 0f);

		// Token: 0x040011A2 RID: 4514
		private static readonly Vector2 rightVector = new Vector2(1f, 0f);

		// Token: 0x040011A3 RID: 4515
		private static readonly Vector2 positiveInfinityVector = new Vector2(float.PositiveInfinity, float.PositiveInfinity);

		// Token: 0x040011A4 RID: 4516
		private static readonly Vector2 negativeInfinityVector = new Vector2(float.NegativeInfinity, float.NegativeInfinity);

		// Token: 0x040011A5 RID: 4517
		public const float kEpsilon = 1E-05f;
	}
}