using System;
using System.Runtime.CompilerServices;
using UnityEngine.Internal;
using UnityEngine.Scripting;

namespace UnityEngine
{
	// Token: 0x02000084 RID: 132
	[UsedByNativeCode]
	public struct Quaternion
	{
		// Token: 0x06000955 RID: 2389 RVA: 0x0000C13C File Offset: 0x0000A33C
		public Quaternion(float x, float y, float z, float w)
		{
			this.x = x;
			this.y = y;
			this.z = z;
			this.w = w;
		}

		// Token: 0x06000956 RID: 2390 RVA: 0x0000C15C File Offset: 0x0000A35C
		[ThreadAndSerializationSafe]
		public static Quaternion AngleAxis(float angle, Vector3 axis)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_AngleAxis(angle, ref axis, out quaternion);
			return quaternion;
		}

		// Token: 0x06000957 RID: 2391
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_AngleAxis(float angle, ref Vector3 axis, out Quaternion value);

		// Token: 0x06000958 RID: 2392 RVA: 0x0000C17C File Offset: 0x0000A37C
		public void ToAngleAxis(out float angle, out Vector3 axis)
		{
			Quaternion.Internal_ToAxisAngleRad(this, out axis, out angle);
			angle *= 57.29578f;
		}

		// Token: 0x06000959 RID: 2393 RVA: 0x0000C198 File Offset: 0x0000A398
		public static Quaternion FromToRotation(Vector3 fromDirection, Vector3 toDirection)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_FromToRotation(ref fromDirection, ref toDirection, out quaternion);
			return quaternion;
		}

		// Token: 0x0600095A RID: 2394
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_FromToRotation(ref Vector3 fromDirection, ref Vector3 toDirection, out Quaternion value);

		// Token: 0x0600095B RID: 2395 RVA: 0x0000C1BC File Offset: 0x0000A3BC
		public void SetFromToRotation(Vector3 fromDirection, Vector3 toDirection)
		{
			this = Quaternion.FromToRotation(fromDirection, toDirection);
		}

		// Token: 0x0600095C RID: 2396 RVA: 0x0000C1CC File Offset: 0x0000A3CC
		public static Quaternion LookRotation(Vector3 forward, [DefaultValue("Vector3.up")] Vector3 upwards)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_LookRotation(ref forward, ref upwards, out quaternion);
			return quaternion;
		}

		// Token: 0x0600095D RID: 2397 RVA: 0x0000C1F0 File Offset: 0x0000A3F0
		[ExcludeFromDocs]
		public static Quaternion LookRotation(Vector3 forward)
		{
			Vector3 up = Vector3.up;
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_LookRotation(ref forward, ref up, out quaternion);
			return quaternion;
		}

		// Token: 0x0600095E RID: 2398
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_LookRotation(ref Vector3 forward, ref Vector3 upwards, out Quaternion value);

		// Token: 0x0600095F RID: 2399 RVA: 0x0000C218 File Offset: 0x0000A418
		public static Quaternion Slerp(Quaternion a, Quaternion b, float t)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_Slerp(ref a, ref b, t, out quaternion);
			return quaternion;
		}

		// Token: 0x06000960 RID: 2400
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Slerp(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);

		// Token: 0x06000961 RID: 2401 RVA: 0x0000C23C File Offset: 0x0000A43C
		public static Quaternion SlerpUnclamped(Quaternion a, Quaternion b, float t)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_SlerpUnclamped(ref a, ref b, t, out quaternion);
			return quaternion;
		}

		// Token: 0x06000962 RID: 2402
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SlerpUnclamped(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);

		// Token: 0x06000963 RID: 2403 RVA: 0x0000C260 File Offset: 0x0000A460
		public static Quaternion Lerp(Quaternion a, Quaternion b, float t)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_Lerp(ref a, ref b, t, out quaternion);
			return quaternion;
		}

		// Token: 0x06000964 RID: 2404
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Lerp(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);

		// Token: 0x06000965 RID: 2405 RVA: 0x0000C284 File Offset: 0x0000A484
		public static Quaternion LerpUnclamped(Quaternion a, Quaternion b, float t)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_LerpUnclamped(ref a, ref b, t, out quaternion);
			return quaternion;
		}

		// Token: 0x06000966 RID: 2406
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_LerpUnclamped(ref Quaternion a, ref Quaternion b, float t, out Quaternion value);

		// Token: 0x06000967 RID: 2407 RVA: 0x0000C2A8 File Offset: 0x0000A4A8
		public static Quaternion RotateTowards(Quaternion from, Quaternion to, float maxDegreesDelta)
		{
			float num = Quaternion.Angle(from, to);
			Quaternion quaternion;
			if (num == 0f)
			{
				quaternion = to;
			}
			else
			{
				float num2 = Mathf.Min(1f, maxDegreesDelta / num);
				quaternion = Quaternion.SlerpUnclamped(from, to, num2);
			}
			return quaternion;
		}

		// Token: 0x06000968 RID: 2408 RVA: 0x0000C2F0 File Offset: 0x0000A4F0
		public static Quaternion Inverse(Quaternion rotation)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_Inverse(ref rotation, out quaternion);
			return quaternion;
		}

		// Token: 0x06000969 RID: 2409
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Inverse(ref Quaternion rotation, out Quaternion value);

		// Token: 0x17000241 RID: 577
		// (get) Token: 0x0600096A RID: 2410 RVA: 0x0000C310 File Offset: 0x0000A510
		// (set) Token: 0x0600096B RID: 2411 RVA: 0x0000C340 File Offset: 0x0000A540
		public Vector3 eulerAngles
		{
			get
			{
				return Quaternion.Internal_MakePositive(Quaternion.Internal_ToEulerRad(this) * 57.29578f);
			}
			set
			{
				this = Quaternion.Internal_FromEulerRad(value * 0.017453292f);
			}
		}

		// Token: 0x0600096C RID: 2412 RVA: 0x0000C35C File Offset: 0x0000A55C
		public static Quaternion Euler(float x, float y, float z)
		{
			return Quaternion.Internal_FromEulerRad(new Vector3(x, y, z) * 0.017453292f);
		}

		// Token: 0x0600096D RID: 2413 RVA: 0x0000C388 File Offset: 0x0000A588
		public static Quaternion Euler(Vector3 euler)
		{
			return Quaternion.Internal_FromEulerRad(euler * 0.017453292f);
		}

		// Token: 0x0600096E RID: 2414 RVA: 0x0000C3B0 File Offset: 0x0000A5B0
		private static Vector3 Internal_ToEulerRad(Quaternion rotation)
		{
			Vector3 vector;
			Quaternion.INTERNAL_CALL_Internal_ToEulerRad(ref rotation, out vector);
			return vector;
		}

		// Token: 0x0600096F RID: 2415
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_ToEulerRad(ref Quaternion rotation, out Vector3 value);

		// Token: 0x06000970 RID: 2416 RVA: 0x0000C3D0 File Offset: 0x0000A5D0
		private static Quaternion Internal_FromEulerRad(Vector3 euler)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_Internal_FromEulerRad(ref euler, out quaternion);
			return quaternion;
		}

		// Token: 0x06000971 RID: 2417
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_FromEulerRad(ref Vector3 euler, out Quaternion value);

		// Token: 0x06000972 RID: 2418 RVA: 0x0000C3F0 File Offset: 0x0000A5F0
		private static void Internal_ToAxisAngleRad(Quaternion q, out Vector3 axis, out float angle)
		{
			Quaternion.INTERNAL_CALL_Internal_ToAxisAngleRad(ref q, out axis, out angle);
		}

		// Token: 0x06000973 RID: 2419
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_ToAxisAngleRad(ref Quaternion q, out Vector3 axis, out float angle);

		// Token: 0x06000974 RID: 2420 RVA: 0x0000C3FC File Offset: 0x0000A5FC
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public static Quaternion EulerRotation(float x, float y, float z)
		{
			return Quaternion.Internal_FromEulerRad(new Vector3(x, y, z));
		}

		// Token: 0x06000975 RID: 2421 RVA: 0x0000C420 File Offset: 0x0000A620
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public static Quaternion EulerRotation(Vector3 euler)
		{
			return Quaternion.Internal_FromEulerRad(euler);
		}

		// Token: 0x06000976 RID: 2422 RVA: 0x0000C43C File Offset: 0x0000A63C
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public void SetEulerRotation(float x, float y, float z)
		{
			this = Quaternion.Internal_FromEulerRad(new Vector3(x, y, z));
		}

		// Token: 0x06000977 RID: 2423 RVA: 0x0000C454 File Offset: 0x0000A654
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public void SetEulerRotation(Vector3 euler)
		{
			this = Quaternion.Internal_FromEulerRad(euler);
		}

		// Token: 0x06000978 RID: 2424 RVA: 0x0000C464 File Offset: 0x0000A664
		[Obsolete("Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees")]
		public Vector3 ToEuler()
		{
			return Quaternion.Internal_ToEulerRad(this);
		}

		// Token: 0x06000979 RID: 2425 RVA: 0x0000C484 File Offset: 0x0000A684
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public static Quaternion EulerAngles(float x, float y, float z)
		{
			return Quaternion.Internal_FromEulerRad(new Vector3(x, y, z));
		}

		// Token: 0x0600097A RID: 2426 RVA: 0x0000C4A8 File Offset: 0x0000A6A8
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public static Quaternion EulerAngles(Vector3 euler)
		{
			return Quaternion.Internal_FromEulerRad(euler);
		}

		// Token: 0x0600097B RID: 2427 RVA: 0x0000C4C4 File Offset: 0x0000A6C4
		[Obsolete("Use Quaternion.ToAngleAxis instead. This function was deprecated because it uses radians instead of degrees")]
		public void ToAxisAngle(out Vector3 axis, out float angle)
		{
			Quaternion.Internal_ToAxisAngleRad(this, out axis, out angle);
		}

		// Token: 0x0600097C RID: 2428 RVA: 0x0000C4D4 File Offset: 0x0000A6D4
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public void SetEulerAngles(float x, float y, float z)
		{
			this.SetEulerRotation(new Vector3(x, y, z));
		}

		// Token: 0x0600097D RID: 2429 RVA: 0x0000C4E8 File Offset: 0x0000A6E8
		[Obsolete("Use Quaternion.Euler instead. This function was deprecated because it uses radians instead of degrees")]
		public void SetEulerAngles(Vector3 euler)
		{
			this = Quaternion.EulerRotation(euler);
		}

		// Token: 0x0600097E RID: 2430 RVA: 0x0000C4F8 File Offset: 0x0000A6F8
		[Obsolete("Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees")]
		public static Vector3 ToEulerAngles(Quaternion rotation)
		{
			return Quaternion.Internal_ToEulerRad(rotation);
		}

		// Token: 0x0600097F RID: 2431 RVA: 0x0000C514 File Offset: 0x0000A714
		[Obsolete("Use Quaternion.eulerAngles instead. This function was deprecated because it uses radians instead of degrees")]
		public Vector3 ToEulerAngles()
		{
			return Quaternion.Internal_ToEulerRad(this);
		}

		// Token: 0x06000980 RID: 2432 RVA: 0x0000C534 File Offset: 0x0000A734
		[Obsolete("Use Quaternion.AngleAxis instead. This function was deprecated because it uses radians instead of degrees")]
		public static Quaternion AxisAngle(Vector3 axis, float angle)
		{
			Quaternion quaternion;
			Quaternion.INTERNAL_CALL_AxisAngle(ref axis, angle, out quaternion);
			return quaternion;
		}

		// Token: 0x06000981 RID: 2433
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_AxisAngle(ref Vector3 axis, float angle, out Quaternion value);

		// Token: 0x06000982 RID: 2434 RVA: 0x0000C554 File Offset: 0x0000A754
		[Obsolete("Use Quaternion.AngleAxis instead. This function was deprecated because it uses radians instead of degrees")]
		public void SetAxisAngle(Vector3 axis, float angle)
		{
			this = Quaternion.AxisAngle(axis, angle);
		}

		// Token: 0x17000242 RID: 578
		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 Quaternion 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 Quaternion index!");
				}
			}
		}

		// Token: 0x06000985 RID: 2437 RVA: 0x0000C630 File Offset: 0x0000A830
		public void Set(float newX, float newY, float newZ, float newW)
		{
			this.x = newX;
			this.y = newY;
			this.z = newZ;
			this.w = newW;
		}

		// Token: 0x17000243 RID: 579
		// (get) Token: 0x06000986 RID: 2438 RVA: 0x0000C650 File Offset: 0x0000A850
		public static Quaternion identity
		{
			get
			{
				return Quaternion.identityQuaternion;
			}
		}

		// Token: 0x06000987 RID: 2439 RVA: 0x0000C66C File Offset: 0x0000A86C
		public static Quaternion operator *(Quaternion lhs, Quaternion rhs)
		{
			return new Quaternion(lhs.w * rhs.x + lhs.x * rhs.w + lhs.y * rhs.z - lhs.z * rhs.y, lhs.w * rhs.y + lhs.y * rhs.w + lhs.z * rhs.x - lhs.x * rhs.z, lhs.w * rhs.z + lhs.z * rhs.w + lhs.x * rhs.y - lhs.y * rhs.x, lhs.w * rhs.w - lhs.x * rhs.x - lhs.y * rhs.y - lhs.z * rhs.z);
		}

		// Token: 0x06000988 RID: 2440 RVA: 0x0000C784 File Offset: 0x0000A984
		public static Vector3 operator *(Quaternion rotation, Vector3 point)
		{
			float num = rotation.x * 2f;
			float num2 = rotation.y * 2f;
			float num3 = rotation.z * 2f;
			float num4 = rotation.x * num;
			float num5 = rotation.y * num2;
			float num6 = rotation.z * num3;
			float num7 = rotation.x * num2;
			float num8 = rotation.x * num3;
			float num9 = rotation.y * num3;
			float num10 = rotation.w * num;
			float num11 = rotation.w * num2;
			float num12 = rotation.w * num3;
			Vector3 vector;
			vector.x = (1f - (num5 + num6)) * point.x + (num7 - num12) * point.y + (num8 + num11) * point.z;
			vector.y = (num7 + num12) * point.x + (1f - (num4 + num6)) * point.y + (num9 - num10) * point.z;
			vector.z = (num8 - num11) * point.x + (num9 + num10) * point.y + (1f - (num4 + num5)) * point.z;
			return vector;
		}

		// Token: 0x06000989 RID: 2441 RVA: 0x0000C8CC File Offset: 0x0000AACC
		public static bool operator ==(Quaternion lhs, Quaternion rhs)
		{
			return Quaternion.Dot(lhs, rhs) > 0.999999f;
		}

		// Token: 0x0600098A RID: 2442 RVA: 0x0000C8F0 File Offset: 0x0000AAF0
		public static bool operator !=(Quaternion lhs, Quaternion rhs)
		{
			return !(lhs == rhs);
		}

		// Token: 0x0600098B RID: 2443 RVA: 0x0000C910 File Offset: 0x0000AB10
		public static float Dot(Quaternion a, Quaternion b)
		{
			return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
		}

		// Token: 0x0600098C RID: 2444 RVA: 0x0000C964 File Offset: 0x0000AB64
		[ExcludeFromDocs]
		public void SetLookRotation(Vector3 view)
		{
			Vector3 up = Vector3.up;
			this.SetLookRotation(view, up);
		}

		// Token: 0x0600098D RID: 2445 RVA: 0x0000C980 File Offset: 0x0000AB80
		public void SetLookRotation(Vector3 view, [DefaultValue("Vector3.up")] Vector3 up)
		{
			this = Quaternion.LookRotation(view, up);
		}

		// Token: 0x0600098E RID: 2446 RVA: 0x0000C990 File Offset: 0x0000AB90
		public static float Angle(Quaternion a, Quaternion b)
		{
			float num = Quaternion.Dot(a, b);
			return Mathf.Acos(Mathf.Min(Mathf.Abs(num), 1f)) * 2f * 57.29578f;
		}

		// Token: 0x0600098F RID: 2447 RVA: 0x0000C9D0 File Offset: 0x0000ABD0
		private static Vector3 Internal_MakePositive(Vector3 euler)
		{
			float num = -0.005729578f;
			float num2 = 360f + num;
			if (euler.x < num)
			{
				euler.x += 360f;
			}
			else if (euler.x > num2)
			{
				euler.x -= 360f;
			}
			if (euler.y < num)
			{
				euler.y += 360f;
			}
			else if (euler.y > num2)
			{
				euler.y -= 360f;
			}
			if (euler.z < num)
			{
				euler.z += 360f;
			}
			else if (euler.z > num2)
			{
				euler.z -= 360f;
			}
			return euler;
		}

		// Token: 0x06000990 RID: 2448 RVA: 0x0000CAC4 File Offset: 0x0000ACC4
		public override int GetHashCode()
		{
			return this.x.GetHashCode() ^ (this.y.GetHashCode() << 2) ^ (this.z.GetHashCode() >> 2) ^ (this.w.GetHashCode() >> 1);
		}

		// Token: 0x06000991 RID: 2449 RVA: 0x0000CB28 File Offset: 0x0000AD28
		public override bool Equals(object other)
		{
			bool flag;
			if (!(other is Quaternion))
			{
				flag = false;
			}
			else
			{
				Quaternion quaternion = (Quaternion)other;
				flag = this.x.Equals(quaternion.x) && this.y.Equals(quaternion.y) && this.z.Equals(quaternion.z) && this.w.Equals(quaternion.w);
			}
			return flag;
		}

		// Token: 0x06000992 RID: 2450 RVA: 0x0000CBB0 File Offset: 0x0000ADB0
		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: 0x06000993 RID: 2451 RVA: 0x0000CC10 File Offset: 0x0000AE10
		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: 0x040000DF RID: 223
		public float x;

		// Token: 0x040000E0 RID: 224
		public float y;

		// Token: 0x040000E1 RID: 225
		public float z;

		// Token: 0x040000E2 RID: 226
		public float w;

		// Token: 0x040000E3 RID: 227
		private static readonly Quaternion identityQuaternion = new Quaternion(0f, 0f, 0f, 1f);

		// Token: 0x040000E4 RID: 228
		public const float kEpsilon = 1E-06f;
	}
}