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

namespace UnityEngine
{
	// Token: 0x02000083 RID: 131
	[UsedByNativeCode]
	public struct Vector3
	{
		// Token: 0x06000910 RID: 2320 RVA: 0x0000B1BC File Offset: 0x000093BC
		public Vector3(float x, float y, float z)
		{
			this.x = x;
			this.y = y;
			this.z = z;
		}

		// Token: 0x06000911 RID: 2321 RVA: 0x0000B1D4 File Offset: 0x000093D4
		public Vector3(float x, float y)
		{
			this.x = x;
			this.y = y;
			this.z = 0f;
		}

		// Token: 0x06000912 RID: 2322 RVA: 0x0000B1F0 File Offset: 0x000093F0
		[ThreadAndSerializationSafe]
		public static Vector3 Slerp(Vector3 a, Vector3 b, float t)
		{
			Vector3 vector;
			Vector3.INTERNAL_CALL_Slerp(ref a, ref b, t, out vector);
			return vector;
		}

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

		// Token: 0x06000914 RID: 2324 RVA: 0x0000B214 File Offset: 0x00009414
		public static Vector3 SlerpUnclamped(Vector3 a, Vector3 b, float t)
		{
			Vector3 vector;
			Vector3.INTERNAL_CALL_SlerpUnclamped(ref a, ref b, t, out vector);
			return vector;
		}

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

		// Token: 0x06000916 RID: 2326 RVA: 0x0000B238 File Offset: 0x00009438
		private static void Internal_OrthoNormalize2(ref Vector3 a, ref Vector3 b)
		{
			Vector3.INTERNAL_CALL_Internal_OrthoNormalize2(ref a, ref b);
		}

		// Token: 0x06000917 RID: 2327
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_OrthoNormalize2(ref Vector3 a, ref Vector3 b);

		// Token: 0x06000918 RID: 2328 RVA: 0x0000B244 File Offset: 0x00009444
		private static void Internal_OrthoNormalize3(ref Vector3 a, ref Vector3 b, ref Vector3 c)
		{
			Vector3.INTERNAL_CALL_Internal_OrthoNormalize3(ref a, ref b, ref c);
		}

		// Token: 0x06000919 RID: 2329
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_Internal_OrthoNormalize3(ref Vector3 a, ref Vector3 b, ref Vector3 c);

		// Token: 0x0600091A RID: 2330 RVA: 0x0000B250 File Offset: 0x00009450
		public static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent)
		{
			Vector3.Internal_OrthoNormalize2(ref normal, ref tangent);
		}

		// Token: 0x0600091B RID: 2331 RVA: 0x0000B25C File Offset: 0x0000945C
		public static void OrthoNormalize(ref Vector3 normal, ref Vector3 tangent, ref Vector3 binormal)
		{
			Vector3.Internal_OrthoNormalize3(ref normal, ref tangent, ref binormal);
		}

		// Token: 0x0600091C RID: 2332 RVA: 0x0000B268 File Offset: 0x00009468
		public static Vector3 RotateTowards(Vector3 current, Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta)
		{
			Vector3 vector;
			Vector3.INTERNAL_CALL_RotateTowards(ref current, ref target, maxRadiansDelta, maxMagnitudeDelta, out vector);
			return vector;
		}

		// Token: 0x0600091D RID: 2333
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_RotateTowards(ref Vector3 current, ref Vector3 target, float maxRadiansDelta, float maxMagnitudeDelta, out Vector3 value);

		// Token: 0x0600091E RID: 2334 RVA: 0x0000B28C File Offset: 0x0000948C
		[Obsolete("Use Vector3.ProjectOnPlane instead.")]
		public static Vector3 Exclude(Vector3 excludeThis, Vector3 fromThat)
		{
			return fromThat - Vector3.Project(fromThat, excludeThis);
		}

		// Token: 0x0600091F RID: 2335 RVA: 0x0000B2B0 File Offset: 0x000094B0
		public static Vector3 Lerp(Vector3 a, Vector3 b, float t)
		{
			t = Mathf.Clamp01(t);
			return new Vector3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
		}

		// Token: 0x06000920 RID: 2336 RVA: 0x0000B320 File Offset: 0x00009520
		public static Vector3 LerpUnclamped(Vector3 a, Vector3 b, float t)
		{
			return new Vector3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
		}

		// Token: 0x06000921 RID: 2337 RVA: 0x0000B388 File Offset: 0x00009588
		public static Vector3 MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta)
		{
			Vector3 vector = target - current;
			float magnitude = vector.magnitude;
			Vector3 vector2;
			if (magnitude <= maxDistanceDelta || magnitude < 1E-45f)
			{
				vector2 = target;
			}
			else
			{
				vector2 = current + vector / magnitude * maxDistanceDelta;
			}
			return vector2;
		}

		// Token: 0x06000922 RID: 2338 RVA: 0x0000B3DC File Offset: 0x000095DC
		[ExcludeFromDocs]
		public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed)
		{
			float deltaTime = Time.deltaTime;
			return Vector3.SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
		}

		// Token: 0x06000923 RID: 2339 RVA: 0x0000B404 File Offset: 0x00009604
		[ExcludeFromDocs]
		public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime)
		{
			float deltaTime = Time.deltaTime;
			float positiveInfinity = float.PositiveInfinity;
			return Vector3.SmoothDamp(current, target, ref currentVelocity, smoothTime, positiveInfinity, deltaTime);
		}

		// Token: 0x06000924 RID: 2340 RVA: 0x0000B430 File Offset: 0x00009630
		public static Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, [DefaultValue("Mathf.Infinity")] float maxSpeed, [DefaultValue("Time.deltaTime")] 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);
			Vector3 vector = current - target;
			Vector3 vector2 = target;
			float num4 = maxSpeed * smoothTime;
			vector = Vector3.ClampMagnitude(vector, num4);
			target = current - vector;
			Vector3 vector3 = (currentVelocity + num * vector) * deltaTime;
			currentVelocity = (currentVelocity - num * vector3) * num3;
			Vector3 vector4 = target + (vector + vector3) * num3;
			if (Vector3.Dot(vector2 - current, vector4 - vector2) > 0f)
			{
				vector4 = vector2;
				currentVelocity = (vector4 - vector2) / deltaTime;
			}
			return vector4;
		}

		// Token: 0x17000232 RID: 562
		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;
				default:
					throw new IndexOutOfRangeException("Invalid Vector3 index!");
				}
				return num;
			}
			set
			{
				switch (index)
				{
				case 0:
					this.x = value;
					break;
				case 1:
					this.y = value;
					break;
				case 2:
					this.z = value;
					break;
				default:
					throw new IndexOutOfRangeException("Invalid Vector3 index!");
				}
			}
		}

		// Token: 0x06000927 RID: 2343 RVA: 0x0000B5E4 File Offset: 0x000097E4
		public void Set(float newX, float newY, float newZ)
		{
			this.x = newX;
			this.y = newY;
			this.z = newZ;
		}

		// Token: 0x06000928 RID: 2344 RVA: 0x0000B5FC File Offset: 0x000097FC
		public static Vector3 Scale(Vector3 a, Vector3 b)
		{
			return new Vector3(a.x * b.x, a.y * b.y, a.z * b.z);
		}

		// Token: 0x06000929 RID: 2345 RVA: 0x0000B644 File Offset: 0x00009844
		public void Scale(Vector3 scale)
		{
			this.x *= scale.x;
			this.y *= scale.y;
			this.z *= scale.z;
		}

		// Token: 0x0600092A RID: 2346 RVA: 0x0000B684 File Offset: 0x00009884
		public static Vector3 Cross(Vector3 lhs, Vector3 rhs)
		{
			return new Vector3(lhs.y * rhs.z - lhs.z * rhs.y, lhs.z * rhs.x - lhs.x * rhs.z, lhs.x * rhs.y - lhs.y * rhs.x);
		}

		// Token: 0x0600092B RID: 2347 RVA: 0x0000B6FC File Offset: 0x000098FC
		public override int GetHashCode()
		{
			return this.x.GetHashCode() ^ (this.y.GetHashCode() << 2) ^ (this.z.GetHashCode() >> 2);
		}

		// Token: 0x0600092C RID: 2348 RVA: 0x0000B74C File Offset: 0x0000994C
		public override bool Equals(object other)
		{
			bool flag;
			if (!(other is Vector3))
			{
				flag = false;
			}
			else
			{
				Vector3 vector = (Vector3)other;
				flag = this.x.Equals(vector.x) && this.y.Equals(vector.y) && this.z.Equals(vector.z);
			}
			return flag;
		}

		// Token: 0x0600092D RID: 2349 RVA: 0x0000B7C0 File Offset: 0x000099C0
		public static Vector3 Reflect(Vector3 inDirection, Vector3 inNormal)
		{
			return -2f * Vector3.Dot(inNormal, inDirection) * inNormal + inDirection;
		}

		// Token: 0x0600092E RID: 2350 RVA: 0x0000B7F0 File Offset: 0x000099F0
		public static Vector3 Normalize(Vector3 value)
		{
			float num = Vector3.Magnitude(value);
			Vector3 vector;
			if (num > 1E-05f)
			{
				vector = value / num;
			}
			else
			{
				vector = Vector3.zero;
			}
			return vector;
		}

		// Token: 0x0600092F RID: 2351 RVA: 0x0000B82C File Offset: 0x00009A2C
		public void Normalize()
		{
			float num = Vector3.Magnitude(this);
			if (num > 1E-05f)
			{
				this /= num;
			}
			else
			{
				this = Vector3.zero;
			}
		}

		// Token: 0x17000233 RID: 563
		// (get) Token: 0x06000930 RID: 2352 RVA: 0x0000B874 File Offset: 0x00009A74
		public Vector3 normalized
		{
			get
			{
				return Vector3.Normalize(this);
			}
		}

		// Token: 0x06000931 RID: 2353 RVA: 0x0000B894 File Offset: 0x00009A94
		public static float Dot(Vector3 lhs, Vector3 rhs)
		{
			return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
		}

		// Token: 0x06000932 RID: 2354 RVA: 0x0000B8D8 File Offset: 0x00009AD8
		public static Vector3 Project(Vector3 vector, Vector3 onNormal)
		{
			float num = Vector3.Dot(onNormal, onNormal);
			Vector3 vector2;
			if (num < Mathf.Epsilon)
			{
				vector2 = Vector3.zero;
			}
			else
			{
				vector2 = onNormal * Vector3.Dot(vector, onNormal) / num;
			}
			return vector2;
		}

		// Token: 0x06000933 RID: 2355 RVA: 0x0000B920 File Offset: 0x00009B20
		public static Vector3 ProjectOnPlane(Vector3 vector, Vector3 planeNormal)
		{
			return vector - Vector3.Project(vector, planeNormal);
		}

		// Token: 0x06000934 RID: 2356 RVA: 0x0000B944 File Offset: 0x00009B44
		public static float Angle(Vector3 from, Vector3 to)
		{
			return Mathf.Acos(Mathf.Clamp(Vector3.Dot(from.normalized, to.normalized), -1f, 1f)) * 57.29578f;
		}

		// Token: 0x06000935 RID: 2357 RVA: 0x0000B988 File Offset: 0x00009B88
		public static float SignedAngle(Vector3 from, Vector3 to, Vector3 axis)
		{
			Vector3 normalized = from.normalized;
			Vector3 normalized2 = to.normalized;
			float num = Mathf.Acos(Mathf.Clamp(Vector3.Dot(normalized, normalized2), -1f, 1f)) * 57.29578f;
			float num2 = Mathf.Sign(Vector3.Dot(axis, Vector3.Cross(normalized, normalized2)));
			return num * num2;
		}

		// Token: 0x06000936 RID: 2358 RVA: 0x0000B9E8 File Offset: 0x00009BE8
		public static float Distance(Vector3 a, Vector3 b)
		{
			Vector3 vector = new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
			return Mathf.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
		}

		// Token: 0x06000937 RID: 2359 RVA: 0x0000BA68 File Offset: 0x00009C68
		public static Vector3 ClampMagnitude(Vector3 vector, float maxLength)
		{
			Vector3 vector2;
			if (vector.sqrMagnitude > maxLength * maxLength)
			{
				vector2 = vector.normalized * maxLength;
			}
			else
			{
				vector2 = vector;
			}
			return vector2;
		}

		// Token: 0x06000938 RID: 2360 RVA: 0x0000BAA0 File Offset: 0x00009CA0
		public static float Magnitude(Vector3 vector)
		{
			return Mathf.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
		}

		// Token: 0x17000234 RID: 564
		// (get) Token: 0x06000939 RID: 2361 RVA: 0x0000BAEC File Offset: 0x00009CEC
		public float magnitude
		{
			get
			{
				return Mathf.Sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
			}
		}

		// Token: 0x0600093A RID: 2362 RVA: 0x0000BB30 File Offset: 0x00009D30
		public static float SqrMagnitude(Vector3 vector)
		{
			return vector.x * vector.x + vector.y * vector.y + vector.z * vector.z;
		}

		// Token: 0x17000235 RID: 565
		// (get) Token: 0x0600093B RID: 2363 RVA: 0x0000BB74 File Offset: 0x00009D74
		public float sqrMagnitude
		{
			get
			{
				return this.x * this.x + this.y * this.y + this.z * this.z;
			}
		}

		// Token: 0x0600093C RID: 2364 RVA: 0x0000BBB4 File Offset: 0x00009DB4
		public static Vector3 Min(Vector3 lhs, Vector3 rhs)
		{
			return new Vector3(Mathf.Min(lhs.x, rhs.x), Mathf.Min(lhs.y, rhs.y), Mathf.Min(lhs.z, rhs.z));
		}

		// Token: 0x0600093D RID: 2365 RVA: 0x0000BC08 File Offset: 0x00009E08
		public static Vector3 Max(Vector3 lhs, Vector3 rhs)
		{
			return new Vector3(Mathf.Max(lhs.x, rhs.x), Mathf.Max(lhs.y, rhs.y), Mathf.Max(lhs.z, rhs.z));
		}

		// Token: 0x17000236 RID: 566
		// (get) Token: 0x0600093E RID: 2366 RVA: 0x0000BC5C File Offset: 0x00009E5C
		public static Vector3 zero
		{
			get
			{
				return Vector3.zeroVector;
			}
		}

		// Token: 0x17000237 RID: 567
		// (get) Token: 0x0600093F RID: 2367 RVA: 0x0000BC78 File Offset: 0x00009E78
		public static Vector3 one
		{
			get
			{
				return Vector3.oneVector;
			}
		}

		// Token: 0x17000238 RID: 568
		// (get) Token: 0x06000940 RID: 2368 RVA: 0x0000BC94 File Offset: 0x00009E94
		public static Vector3 forward
		{
			get
			{
				return Vector3.forwardVector;
			}
		}

		// Token: 0x17000239 RID: 569
		// (get) Token: 0x06000941 RID: 2369 RVA: 0x0000BCB0 File Offset: 0x00009EB0
		public static Vector3 back
		{
			get
			{
				return Vector3.backVector;
			}
		}

		// Token: 0x1700023A RID: 570
		// (get) Token: 0x06000942 RID: 2370 RVA: 0x0000BCCC File Offset: 0x00009ECC
		public static Vector3 up
		{
			get
			{
				return Vector3.upVector;
			}
		}

		// Token: 0x1700023B RID: 571
		// (get) Token: 0x06000943 RID: 2371 RVA: 0x0000BCE8 File Offset: 0x00009EE8
		public static Vector3 down
		{
			get
			{
				return Vector3.downVector;
			}
		}

		// Token: 0x1700023C RID: 572
		// (get) Token: 0x06000944 RID: 2372 RVA: 0x0000BD04 File Offset: 0x00009F04
		public static Vector3 left
		{
			get
			{
				return Vector3.leftVector;
			}
		}

		// Token: 0x1700023D RID: 573
		// (get) Token: 0x06000945 RID: 2373 RVA: 0x0000BD20 File Offset: 0x00009F20
		public static Vector3 right
		{
			get
			{
				return Vector3.rightVector;
			}
		}

		// Token: 0x1700023E RID: 574
		// (get) Token: 0x06000946 RID: 2374 RVA: 0x0000BD3C File Offset: 0x00009F3C
		public static Vector3 positiveInfinity
		{
			get
			{
				return Vector3.positiveInfinityVector;
			}
		}

		// Token: 0x1700023F RID: 575
		// (get) Token: 0x06000947 RID: 2375 RVA: 0x0000BD58 File Offset: 0x00009F58
		public static Vector3 negativeInfinity
		{
			get
			{
				return Vector3.negativeInfinityVector;
			}
		}

		// Token: 0x06000948 RID: 2376 RVA: 0x0000BD74 File Offset: 0x00009F74
		public static Vector3 operator +(Vector3 a, Vector3 b)
		{
			return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
		}

		// Token: 0x06000949 RID: 2377 RVA: 0x0000BDBC File Offset: 0x00009FBC
		public static Vector3 operator -(Vector3 a, Vector3 b)
		{
			return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
		}

		// Token: 0x0600094A RID: 2378 RVA: 0x0000BE04 File Offset: 0x0000A004
		public static Vector3 operator -(Vector3 a)
		{
			return new Vector3(-a.x, -a.y, -a.z);
		}

		// Token: 0x0600094B RID: 2379 RVA: 0x0000BE38 File Offset: 0x0000A038
		public static Vector3 operator *(Vector3 a, float d)
		{
			return new Vector3(a.x * d, a.y * d, a.z * d);
		}

		// Token: 0x0600094C RID: 2380 RVA: 0x0000BE70 File Offset: 0x0000A070
		public static Vector3 operator *(float d, Vector3 a)
		{
			return new Vector3(a.x * d, a.y * d, a.z * d);
		}

		// Token: 0x0600094D RID: 2381 RVA: 0x0000BEA8 File Offset: 0x0000A0A8
		public static Vector3 operator /(Vector3 a, float d)
		{
			return new Vector3(a.x / d, a.y / d, a.z / d);
		}

		// Token: 0x0600094E RID: 2382 RVA: 0x0000BEE0 File Offset: 0x0000A0E0
		public static bool operator ==(Vector3 lhs, Vector3 rhs)
		{
			return Vector3.SqrMagnitude(lhs - rhs) < 9.9999994E-11f;
		}

		// Token: 0x0600094F RID: 2383 RVA: 0x0000BF08 File Offset: 0x0000A108
		public static bool operator !=(Vector3 lhs, Vector3 rhs)
		{
			return !(lhs == rhs);
		}

		// Token: 0x06000950 RID: 2384 RVA: 0x0000BF28 File Offset: 0x0000A128
		public override string ToString()
		{
			return UnityString.Format("({0:F1}, {1:F1}, {2:F1})", new object[] { this.x, this.y, this.z });
		}

		// Token: 0x06000951 RID: 2385 RVA: 0x0000BF78 File Offset: 0x0000A178
		public string ToString(string format)
		{
			return UnityString.Format("({0}, {1}, {2})", new object[]
			{
				this.x.ToString(format),
				this.y.ToString(format),
				this.z.ToString(format)
			});
		}

		// Token: 0x17000240 RID: 576
		// (get) Token: 0x06000952 RID: 2386 RVA: 0x0000BFCC File Offset: 0x0000A1CC
		[Obsolete("Use Vector3.forward instead.")]
		public static Vector3 fwd
		{
			get
			{
				return new Vector3(0f, 0f, 1f);
			}
		}

		// Token: 0x06000953 RID: 2387 RVA: 0x0000BFF8 File Offset: 0x0000A1F8
		[Obsolete("Use Vector3.Angle instead. AngleBetween uses radians instead of degrees and was deprecated for this reason")]
		public static float AngleBetween(Vector3 from, Vector3 to)
		{
			return Mathf.Acos(Mathf.Clamp(Vector3.Dot(from.normalized, to.normalized), -1f, 1f));
		}

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

		// Token: 0x040000D2 RID: 210
		public float x;

		// Token: 0x040000D3 RID: 211
		public float y;

		// Token: 0x040000D4 RID: 212
		public float z;

		// Token: 0x040000D5 RID: 213
		private static readonly Vector3 zeroVector = new Vector3(0f, 0f, 0f);

		// Token: 0x040000D6 RID: 214
		private static readonly Vector3 oneVector = new Vector3(1f, 1f, 1f);

		// Token: 0x040000D7 RID: 215
		private static readonly Vector3 upVector = new Vector3(0f, 1f, 0f);

		// Token: 0x040000D8 RID: 216
		private static readonly Vector3 downVector = new Vector3(0f, -1f, 0f);

		// Token: 0x040000D9 RID: 217
		private static readonly Vector3 leftVector = new Vector3(-1f, 0f, 0f);

		// Token: 0x040000DA RID: 218
		private static readonly Vector3 rightVector = new Vector3(1f, 0f, 0f);

		// Token: 0x040000DB RID: 219
		private static readonly Vector3 forwardVector = new Vector3(0f, 0f, 1f);

		// Token: 0x040000DC RID: 220
		private static readonly Vector3 backVector = new Vector3(0f, 0f, -1f);

		// Token: 0x040000DD RID: 221
		private static readonly Vector3 positiveInfinityVector = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);

		// Token: 0x040000DE RID: 222
		private static readonly Vector3 negativeInfinityVector = new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);
	}
}