using System;
using UnityEngine.Scripting;

namespace UnityEngine
{
	// Token: 0x0200048F RID: 1167
	[UsedByNativeCode]
	public struct Vector4
	{
		// Token: 0x06003A4D RID: 14925 RVA: 0x00066208 File Offset: 0x00064408
		public Vector4(float x, float y, float z, float w)
		{
			this.x = x;
			this.y = y;
			this.z = z;
			this.w = w;
		}

		// Token: 0x06003A4E RID: 14926 RVA: 0x00066228 File Offset: 0x00064428
		public Vector4(float x, float y, float z)
		{
			this.x = x;
			this.y = y;
			this.z = z;
			this.w = 0f;
		}

		// Token: 0x06003A4F RID: 14927 RVA: 0x0006624C File Offset: 0x0006444C
		public Vector4(float x, float y)
		{
			this.x = x;
			this.y = y;
			this.z = 0f;
			this.w = 0f;
		}

		// Token: 0x17000D4B RID: 3403
		public float this[int index]
		{
			get
			{
				float num;
				switch (index)
				{
				case 0:
					num = this.x;
					break;
				case 1:
					num = this.y;
					break;
				case 2:
					num = this.z;
					break;
				case 3:
					num = this.w;
					break;
				default:
					throw new IndexOutOfRangeException("Invalid Vector4 index!");
				}
				return num;
			}
			set
			{
				switch (index)
				{
				case 0:
					this.x = value;
					break;
				case 1:
					this.y = value;
					break;
				case 2:
					this.z = value;
					break;
				case 3:
					this.w = value;
					break;
				default:
					throw new IndexOutOfRangeException("Invalid Vector4 index!");
				}
			}
		}

		// Token: 0x06003A52 RID: 14930 RVA: 0x00066340 File Offset: 0x00064540
		public void Set(float newX, float newY, float newZ, float newW)
		{
			this.x = newX;
			this.y = newY;
			this.z = newZ;
			this.w = newW;
		}

		// Token: 0x06003A53 RID: 14931 RVA: 0x00066360 File Offset: 0x00064560
		public static Vector4 Lerp(Vector4 a, Vector4 b, float t)
		{
			t = Mathf.Clamp01(t);
			return new Vector4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
		}

		// Token: 0x06003A54 RID: 14932 RVA: 0x000663E8 File Offset: 0x000645E8
		public static Vector4 LerpUnclamped(Vector4 a, Vector4 b, float t)
		{
			return new Vector4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
		}

		// Token: 0x06003A55 RID: 14933 RVA: 0x00066468 File Offset: 0x00064668
		public static Vector4 MoveTowards(Vector4 current, Vector4 target, float maxDistanceDelta)
		{
			Vector4 vector = target - current;
			float magnitude = vector.magnitude;
			Vector4 vector2;
			if (magnitude <= maxDistanceDelta || magnitude == 0f)
			{
				vector2 = target;
			}
			else
			{
				vector2 = current + vector / magnitude * maxDistanceDelta;
			}
			return vector2;
		}

		// Token: 0x06003A56 RID: 14934 RVA: 0x000664BC File Offset: 0x000646BC
		public static Vector4 Scale(Vector4 a, Vector4 b)
		{
			return new Vector4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
		}

		// Token: 0x06003A57 RID: 14935 RVA: 0x00066514 File Offset: 0x00064714
		public void Scale(Vector4 scale)
		{
			this.x *= scale.x;
			this.y *= scale.y;
			this.z *= scale.z;
			this.w *= scale.w;
		}

		// Token: 0x06003A58 RID: 14936 RVA: 0x00066574 File Offset: 0x00064774
		public override int GetHashCode()
		{
			return this.x.GetHashCode() ^ (this.y.GetHashCode() << 2) ^ (this.z.GetHashCode() >> 2) ^ (this.w.GetHashCode() >> 1);
		}

		// Token: 0x06003A59 RID: 14937 RVA: 0x000665D8 File Offset: 0x000647D8
		public override bool Equals(object other)
		{
			bool flag;
			if (!(other is Vector4))
			{
				flag = false;
			}
			else
			{
				Vector4 vector = (Vector4)other;
				flag = this.x.Equals(vector.x) && this.y.Equals(vector.y) && this.z.Equals(vector.z) && this.w.Equals(vector.w);
			}
			return flag;
		}

		// Token: 0x06003A5A RID: 14938 RVA: 0x00066660 File Offset: 0x00064860
		public static Vector4 Normalize(Vector4 a)
		{
			float num = Vector4.Magnitude(a);
			Vector4 vector;
			if (num > 1E-05f)
			{
				vector = a / num;
			}
			else
			{
				vector = Vector4.zero;
			}
			return vector;
		}

		// Token: 0x06003A5B RID: 14939 RVA: 0x0006669C File Offset: 0x0006489C
		public void Normalize()
		{
			float num = Vector4.Magnitude(this);
			if (num > 1E-05f)
			{
				this /= num;
			}
			else
			{
				this = Vector4.zero;
			}
		}

		// Token: 0x17000D4C RID: 3404
		// (get) Token: 0x06003A5C RID: 14940 RVA: 0x000666E4 File Offset: 0x000648E4
		public Vector4 normalized
		{
			get
			{
				return Vector4.Normalize(this);
			}
		}

		// Token: 0x06003A5D RID: 14941 RVA: 0x00066704 File Offset: 0x00064904
		public static float Dot(Vector4 a, Vector4 b)
		{
			return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
		}

		// Token: 0x06003A5E RID: 14942 RVA: 0x00066758 File Offset: 0x00064958
		public static Vector4 Project(Vector4 a, Vector4 b)
		{
			return b * Vector4.Dot(a, b) / Vector4.Dot(b, b);
		}

		// Token: 0x06003A5F RID: 14943 RVA: 0x00066788 File Offset: 0x00064988
		public static float Distance(Vector4 a, Vector4 b)
		{
			return Vector4.Magnitude(a - b);
		}

		// Token: 0x06003A60 RID: 14944 RVA: 0x000667AC File Offset: 0x000649AC
		public static float Magnitude(Vector4 a)
		{
			return Mathf.Sqrt(Vector4.Dot(a, a));
		}

		// Token: 0x17000D4D RID: 3405
		// (get) Token: 0x06003A61 RID: 14945 RVA: 0x000667D0 File Offset: 0x000649D0
		public float magnitude
		{
			get
			{
				return Mathf.Sqrt(Vector4.Dot(this, this));
			}
		}

		// Token: 0x17000D4E RID: 3406
		// (get) Token: 0x06003A62 RID: 14946 RVA: 0x000667FC File Offset: 0x000649FC
		public float sqrMagnitude
		{
			get
			{
				return Vector4.Dot(this, this);
			}
		}

		// Token: 0x06003A63 RID: 14947 RVA: 0x00066824 File Offset: 0x00064A24
		public static Vector4 Min(Vector4 lhs, Vector4 rhs)
		{
			return new Vector4(Mathf.Min(lhs.x, rhs.x), Mathf.Min(lhs.y, rhs.y), Mathf.Min(lhs.z, rhs.z), Mathf.Min(lhs.w, rhs.w));
		}

		// Token: 0x06003A64 RID: 14948 RVA: 0x0006688C File Offset: 0x00064A8C
		public static Vector4 Max(Vector4 lhs, Vector4 rhs)
		{
			return new Vector4(Mathf.Max(lhs.x, rhs.x), Mathf.Max(lhs.y, rhs.y), Mathf.Max(lhs.z, rhs.z), Mathf.Max(lhs.w, rhs.w));
		}

		// Token: 0x17000D4F RID: 3407
		// (get) Token: 0x06003A65 RID: 14949 RVA: 0x000668F4 File Offset: 0x00064AF4
		public static Vector4 zero
		{
			get
			{
				return Vector4.zeroVector;
			}
		}

		// Token: 0x17000D50 RID: 3408
		// (get) Token: 0x06003A66 RID: 14950 RVA: 0x00066910 File Offset: 0x00064B10
		public static Vector4 one
		{
			get
			{
				return Vector4.oneVector;
			}
		}

		// Token: 0x17000D51 RID: 3409
		// (get) Token: 0x06003A67 RID: 14951 RVA: 0x0006692C File Offset: 0x00064B2C
		public static Vector4 positiveInfinity
		{
			get
			{
				return Vector4.positiveInfinityVector;
			}
		}

		// Token: 0x17000D52 RID: 3410
		// (get) Token: 0x06003A68 RID: 14952 RVA: 0x00066948 File Offset: 0x00064B48
		public static Vector4 negativeInfinity
		{
			get
			{
				return Vector4.negativeInfinityVector;
			}
		}

		// Token: 0x06003A69 RID: 14953 RVA: 0x00066964 File Offset: 0x00064B64
		public static Vector4 operator +(Vector4 a, Vector4 b)
		{
			return new Vector4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
		}

		// Token: 0x06003A6A RID: 14954 RVA: 0x000669BC File Offset: 0x00064BBC
		public static Vector4 operator -(Vector4 a, Vector4 b)
		{
			return new Vector4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
		}

		// Token: 0x06003A6B RID: 14955 RVA: 0x00066A14 File Offset: 0x00064C14
		public static Vector4 operator -(Vector4 a)
		{
			return new Vector4(-a.x, -a.y, -a.z, -a.w);
		}

		// Token: 0x06003A6C RID: 14956 RVA: 0x00066A50 File Offset: 0x00064C50
		public static Vector4 operator *(Vector4 a, float d)
		{
			return new Vector4(a.x * d, a.y * d, a.z * d, a.w * d);
		}

		// Token: 0x06003A6D RID: 14957 RVA: 0x00066A90 File Offset: 0x00064C90
		public static Vector4 operator *(float d, Vector4 a)
		{
			return new Vector4(a.x * d, a.y * d, a.z * d, a.w * d);
		}

		// Token: 0x06003A6E RID: 14958 RVA: 0x00066AD0 File Offset: 0x00064CD0
		public static Vector4 operator /(Vector4 a, float d)
		{
			return new Vector4(a.x / d, a.y / d, a.z / d, a.w / d);
		}

		// Token: 0x06003A6F RID: 14959 RVA: 0x00066B10 File Offset: 0x00064D10
		public static bool operator ==(Vector4 lhs, Vector4 rhs)
		{
			return Vector4.SqrMagnitude(lhs - rhs) < 9.9999994E-11f;
		}

		// Token: 0x06003A70 RID: 14960 RVA: 0x00066B38 File Offset: 0x00064D38
		public static bool operator !=(Vector4 lhs, Vector4 rhs)
		{
			return !(lhs == rhs);
		}

		// Token: 0x06003A71 RID: 14961 RVA: 0x00066B58 File Offset: 0x00064D58
		public static implicit operator Vector4(Vector3 v)
		{
			return new Vector4(v.x, v.y, v.z, 0f);
		}

		// Token: 0x06003A72 RID: 14962 RVA: 0x00066B8C File Offset: 0x00064D8C
		public static implicit operator Vector3(Vector4 v)
		{
			return new Vector3(v.x, v.y, v.z);
		}

		// Token: 0x06003A73 RID: 14963 RVA: 0x00066BBC File Offset: 0x00064DBC
		public static implicit operator Vector4(Vector2 v)
		{
			return new Vector4(v.x, v.y, 0f, 0f);
		}

		// Token: 0x06003A74 RID: 14964 RVA: 0x00066BF0 File Offset: 0x00064DF0
		public static implicit operator Vector2(Vector4 v)
		{
			return new Vector2(v.x, v.y);
		}

		// Token: 0x06003A75 RID: 14965 RVA: 0x00066C18 File Offset: 0x00064E18
		public override string ToString()
		{
			return UnityString.Format("({0:F1}, {1:F1}, {2:F1}, {3:F1})", new object[] { this.x, this.y, this.z, this.w });
		}

		// Token: 0x06003A76 RID: 14966 RVA: 0x00066C78 File Offset: 0x00064E78
		public string ToString(string format)
		{
			return UnityString.Format("({0}, {1}, {2}, {3})", new object[]
			{
				this.x.ToString(format),
				this.y.ToString(format),
				this.z.ToString(format),
				this.w.ToString(format)
			});
		}

		// Token: 0x06003A77 RID: 14967 RVA: 0x00066CDC File Offset: 0x00064EDC
		public static float SqrMagnitude(Vector4 a)
		{
			return Vector4.Dot(a, a);
		}

		// Token: 0x06003A78 RID: 14968 RVA: 0x00066CF8 File Offset: 0x00064EF8
		public float SqrMagnitude()
		{
			return Vector4.Dot(this, this);
		}

		// Token: 0x040011A6 RID: 4518
		public const float kEpsilon = 1E-05f;

		// Token: 0x040011A7 RID: 4519
		public float x;

		// Token: 0x040011A8 RID: 4520
		public float y;

		// Token: 0x040011A9 RID: 4521
		public float z;

		// Token: 0x040011AA RID: 4522
		public float w;

		// Token: 0x040011AB RID: 4523
		private static readonly Vector4 zeroVector = new Vector4(0f, 0f, 0f, 0f);

		// Token: 0x040011AC RID: 4524
		private static readonly Vector4 oneVector = new Vector4(1f, 1f, 1f, 1f);

		// Token: 0x040011AD RID: 4525
		private static readonly Vector4 positiveInfinityVector = new Vector4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);

		// Token: 0x040011AE RID: 4526
		private static readonly Vector4 negativeInfinityVector = new Vector4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
	}
}