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

namespace UnityEngine
{
	// Token: 0x02000087 RID: 135
	public struct Mathf
	{
		// Token: 0x060009E9 RID: 2537
		[ThreadAndSerializationSafe]
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern int ClosestPowerOfTwo(int value);

		// Token: 0x060009EA RID: 2538
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern float GammaToLinearSpace(float value);

		// Token: 0x060009EB RID: 2539
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern float LinearToGammaSpace(float value);

		// Token: 0x060009EC RID: 2540 RVA: 0x0000EAE4 File Offset: 0x0000CCE4
		public static Color CorrelatedColorTemperatureToRGB(float kelvin)
		{
			Color color;
			Mathf.INTERNAL_CALL_CorrelatedColorTemperatureToRGB(kelvin, out color);
			return color;
		}

		// Token: 0x060009ED RID: 2541
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_CorrelatedColorTemperatureToRGB(float kelvin, out Color value);

		// Token: 0x060009EE RID: 2542
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern bool IsPowerOfTwo(int value);

		// Token: 0x060009EF RID: 2543
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern int NextPowerOfTwo(int value);

		// Token: 0x060009F0 RID: 2544
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern float PerlinNoise(float x, float y);

		// Token: 0x060009F1 RID: 2545
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern ushort FloatToHalf(float val);

		// Token: 0x060009F2 RID: 2546
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern float HalfToFloat(ushort val);

		// Token: 0x060009F3 RID: 2547 RVA: 0x0000EB04 File Offset: 0x0000CD04
		public static float Sin(float f)
		{
			return (float)Math.Sin((double)f);
		}

		// Token: 0x060009F4 RID: 2548 RVA: 0x0000EB24 File Offset: 0x0000CD24
		public static float Cos(float f)
		{
			return (float)Math.Cos((double)f);
		}

		// Token: 0x060009F5 RID: 2549 RVA: 0x0000EB44 File Offset: 0x0000CD44
		public static float Tan(float f)
		{
			return (float)Math.Tan((double)f);
		}

		// Token: 0x060009F6 RID: 2550 RVA: 0x0000EB64 File Offset: 0x0000CD64
		public static float Asin(float f)
		{
			return (float)Math.Asin((double)f);
		}

		// Token: 0x060009F7 RID: 2551 RVA: 0x0000EB84 File Offset: 0x0000CD84
		public static float Acos(float f)
		{
			return (float)Math.Acos((double)f);
		}

		// Token: 0x060009F8 RID: 2552 RVA: 0x0000EBA4 File Offset: 0x0000CDA4
		public static float Atan(float f)
		{
			return (float)Math.Atan((double)f);
		}

		// Token: 0x060009F9 RID: 2553 RVA: 0x0000EBC4 File Offset: 0x0000CDC4
		public static float Atan2(float y, float x)
		{
			return (float)Math.Atan2((double)y, (double)x);
		}

		// Token: 0x060009FA RID: 2554 RVA: 0x0000EBE4 File Offset: 0x0000CDE4
		public static float Sqrt(float f)
		{
			return (float)Math.Sqrt((double)f);
		}

		// Token: 0x060009FB RID: 2555 RVA: 0x0000EC04 File Offset: 0x0000CE04
		public static float Abs(float f)
		{
			return Math.Abs(f);
		}

		// Token: 0x060009FC RID: 2556 RVA: 0x0000EC20 File Offset: 0x0000CE20
		public static int Abs(int value)
		{
			return Math.Abs(value);
		}

		// Token: 0x060009FD RID: 2557 RVA: 0x0000EC3C File Offset: 0x0000CE3C
		public static float Min(float a, float b)
		{
			return (a >= b) ? b : a;
		}

		// Token: 0x060009FE RID: 2558 RVA: 0x0000EC60 File Offset: 0x0000CE60
		public static float Min(params float[] values)
		{
			int num = values.Length;
			float num2;
			if (num == 0)
			{
				num2 = 0f;
			}
			else
			{
				float num3 = values[0];
				for (int i = 1; i < num; i++)
				{
					if (values[i] < num3)
					{
						num3 = values[i];
					}
				}
				num2 = num3;
			}
			return num2;
		}

		// Token: 0x060009FF RID: 2559 RVA: 0x0000ECB0 File Offset: 0x0000CEB0
		public static int Min(int a, int b)
		{
			return (a >= b) ? b : a;
		}

		// Token: 0x06000A00 RID: 2560 RVA: 0x0000ECD4 File Offset: 0x0000CED4
		public static int Min(params int[] values)
		{
			int num = values.Length;
			int num2;
			if (num == 0)
			{
				num2 = 0;
			}
			else
			{
				int num3 = values[0];
				for (int i = 1; i < num; i++)
				{
					if (values[i] < num3)
					{
						num3 = values[i];
					}
				}
				num2 = num3;
			}
			return num2;
		}

		// Token: 0x06000A01 RID: 2561 RVA: 0x0000ED20 File Offset: 0x0000CF20
		public static float Max(float a, float b)
		{
			return (a <= b) ? b : a;
		}

		// Token: 0x06000A02 RID: 2562 RVA: 0x0000ED44 File Offset: 0x0000CF44
		public static float Max(params float[] values)
		{
			int num = values.Length;
			float num2;
			if (num == 0)
			{
				num2 = 0f;
			}
			else
			{
				float num3 = values[0];
				for (int i = 1; i < num; i++)
				{
					if (values[i] > num3)
					{
						num3 = values[i];
					}
				}
				num2 = num3;
			}
			return num2;
		}

		// Token: 0x06000A03 RID: 2563 RVA: 0x0000ED94 File Offset: 0x0000CF94
		public static int Max(int a, int b)
		{
			return (a <= b) ? b : a;
		}

		// Token: 0x06000A04 RID: 2564 RVA: 0x0000EDB8 File Offset: 0x0000CFB8
		public static int Max(params int[] values)
		{
			int num = values.Length;
			int num2;
			if (num == 0)
			{
				num2 = 0;
			}
			else
			{
				int num3 = values[0];
				for (int i = 1; i < num; i++)
				{
					if (values[i] > num3)
					{
						num3 = values[i];
					}
				}
				num2 = num3;
			}
			return num2;
		}

		// Token: 0x06000A05 RID: 2565 RVA: 0x0000EE04 File Offset: 0x0000D004
		public static float Pow(float f, float p)
		{
			return (float)Math.Pow((double)f, (double)p);
		}

		// Token: 0x06000A06 RID: 2566 RVA: 0x0000EE24 File Offset: 0x0000D024
		public static float Exp(float power)
		{
			return (float)Math.Exp((double)power);
		}

		// Token: 0x06000A07 RID: 2567 RVA: 0x0000EE44 File Offset: 0x0000D044
		public static float Log(float f, float p)
		{
			return (float)Math.Log((double)f, (double)p);
		}

		// Token: 0x06000A08 RID: 2568 RVA: 0x0000EE64 File Offset: 0x0000D064
		public static float Log(float f)
		{
			return (float)Math.Log((double)f);
		}

		// Token: 0x06000A09 RID: 2569 RVA: 0x0000EE84 File Offset: 0x0000D084
		public static float Log10(float f)
		{
			return (float)Math.Log10((double)f);
		}

		// Token: 0x06000A0A RID: 2570 RVA: 0x0000EEA4 File Offset: 0x0000D0A4
		public static float Ceil(float f)
		{
			return (float)Math.Ceiling((double)f);
		}

		// Token: 0x06000A0B RID: 2571 RVA: 0x0000EEC4 File Offset: 0x0000D0C4
		public static float Floor(float f)
		{
			return (float)Math.Floor((double)f);
		}

		// Token: 0x06000A0C RID: 2572 RVA: 0x0000EEE4 File Offset: 0x0000D0E4
		public static float Round(float f)
		{
			return (float)Math.Round((double)f);
		}

		// Token: 0x06000A0D RID: 2573 RVA: 0x0000EF04 File Offset: 0x0000D104
		public static int CeilToInt(float f)
		{
			return (int)Math.Ceiling((double)f);
		}

		// Token: 0x06000A0E RID: 2574 RVA: 0x0000EF24 File Offset: 0x0000D124
		public static int FloorToInt(float f)
		{
			return (int)Math.Floor((double)f);
		}

		// Token: 0x06000A0F RID: 2575 RVA: 0x0000EF44 File Offset: 0x0000D144
		public static int RoundToInt(float f)
		{
			return (int)Math.Round((double)f);
		}

		// Token: 0x06000A10 RID: 2576 RVA: 0x0000EF64 File Offset: 0x0000D164
		public static float Sign(float f)
		{
			return (f < 0f) ? (-1f) : 1f;
		}

		// Token: 0x06000A11 RID: 2577 RVA: 0x0000EF94 File Offset: 0x0000D194
		public static float Clamp(float value, float min, float max)
		{
			if (value < min)
			{
				value = min;
			}
			else if (value > max)
			{
				value = max;
			}
			return value;
		}

		// Token: 0x06000A12 RID: 2578 RVA: 0x0000EFC4 File Offset: 0x0000D1C4
		public static int Clamp(int value, int min, int max)
		{
			if (value < min)
			{
				value = min;
			}
			else if (value > max)
			{
				value = max;
			}
			return value;
		}

		// Token: 0x06000A13 RID: 2579 RVA: 0x0000EFF4 File Offset: 0x0000D1F4
		public static float Clamp01(float value)
		{
			float num;
			if (value < 0f)
			{
				num = 0f;
			}
			else if (value > 1f)
			{
				num = 1f;
			}
			else
			{
				num = value;
			}
			return num;
		}

		// Token: 0x06000A14 RID: 2580 RVA: 0x0000F038 File Offset: 0x0000D238
		public static float Lerp(float a, float b, float t)
		{
			return a + (b - a) * Mathf.Clamp01(t);
		}

		// Token: 0x06000A15 RID: 2581 RVA: 0x0000F05C File Offset: 0x0000D25C
		public static float LerpUnclamped(float a, float b, float t)
		{
			return a + (b - a) * t;
		}

		// Token: 0x06000A16 RID: 2582 RVA: 0x0000F078 File Offset: 0x0000D278
		public static float LerpAngle(float a, float b, float t)
		{
			float num = Mathf.Repeat(b - a, 360f);
			if (num > 180f)
			{
				num -= 360f;
			}
			return a + num * Mathf.Clamp01(t);
		}

		// Token: 0x06000A17 RID: 2583 RVA: 0x0000F0B8 File Offset: 0x0000D2B8
		public static float MoveTowards(float current, float target, float maxDelta)
		{
			float num;
			if (Mathf.Abs(target - current) <= maxDelta)
			{
				num = target;
			}
			else
			{
				num = current + Mathf.Sign(target - current) * maxDelta;
			}
			return num;
		}

		// Token: 0x06000A18 RID: 2584 RVA: 0x0000F0F0 File Offset: 0x0000D2F0
		public static float MoveTowardsAngle(float current, float target, float maxDelta)
		{
			float num = Mathf.DeltaAngle(current, target);
			float num2;
			if (-maxDelta < num && num < maxDelta)
			{
				num2 = target;
			}
			else
			{
				target = current + num;
				num2 = Mathf.MoveTowards(current, target, maxDelta);
			}
			return num2;
		}

		// Token: 0x06000A19 RID: 2585 RVA: 0x0000F130 File Offset: 0x0000D330
		public static float SmoothStep(float from, float to, float t)
		{
			t = Mathf.Clamp01(t);
			t = -2f * t * t * t + 3f * t * t;
			return to * t + from * (1f - t);
		}

		// Token: 0x06000A1A RID: 2586 RVA: 0x0000F174 File Offset: 0x0000D374
		public static float Gamma(float value, float absmax, float gamma)
		{
			bool flag = false;
			if (value < 0f)
			{
				flag = true;
			}
			float num = Mathf.Abs(value);
			float num2;
			if (num > absmax)
			{
				num2 = ((!flag) ? num : (-num));
			}
			else
			{
				float num3 = Mathf.Pow(num / absmax, gamma) * absmax;
				num2 = ((!flag) ? num3 : (-num3));
			}
			return num2;
		}

		// Token: 0x06000A1B RID: 2587 RVA: 0x0000F1D4 File Offset: 0x0000D3D4
		public static bool Approximately(float a, float b)
		{
			return Mathf.Abs(b - a) < Mathf.Max(1E-06f * Mathf.Max(Mathf.Abs(a), Mathf.Abs(b)), Mathf.Epsilon * 8f);
		}

		// Token: 0x06000A1C RID: 2588 RVA: 0x0000F21C File Offset: 0x0000D41C
		[ExcludeFromDocs]
		public static float SmoothDamp(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed)
		{
			float deltaTime = Time.deltaTime;
			return Mathf.SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
		}

		// Token: 0x06000A1D RID: 2589 RVA: 0x0000F244 File Offset: 0x0000D444
		[ExcludeFromDocs]
		public static float SmoothDamp(float current, float target, ref float currentVelocity, float smoothTime)
		{
			float deltaTime = Time.deltaTime;
			float positiveInfinity = float.PositiveInfinity;
			return Mathf.SmoothDamp(current, target, ref currentVelocity, smoothTime, positiveInfinity, deltaTime);
		}

		// Token: 0x06000A1E RID: 2590 RVA: 0x0000F270 File Offset: 0x0000D470
		public static float SmoothDamp(float current, float target, ref float 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);
			float num4 = current - target;
			float num5 = target;
			float num6 = maxSpeed * smoothTime;
			num4 = Mathf.Clamp(num4, -num6, num6);
			target = current - num4;
			float num7 = (currentVelocity + num * num4) * deltaTime;
			currentVelocity = (currentVelocity - num * num7) * num3;
			float num8 = target + (num4 + num7) * num3;
			if (num5 - current > 0f == num8 > num5)
			{
				num8 = num5;
				currentVelocity = (num8 - num5) / deltaTime;
			}
			return num8;
		}

		// Token: 0x06000A1F RID: 2591 RVA: 0x0000F32C File Offset: 0x0000D52C
		[ExcludeFromDocs]
		public static float SmoothDampAngle(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed)
		{
			float deltaTime = Time.deltaTime;
			return Mathf.SmoothDampAngle(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
		}

		// Token: 0x06000A20 RID: 2592 RVA: 0x0000F354 File Offset: 0x0000D554
		[ExcludeFromDocs]
		public static float SmoothDampAngle(float current, float target, ref float currentVelocity, float smoothTime)
		{
			float deltaTime = Time.deltaTime;
			float positiveInfinity = float.PositiveInfinity;
			return Mathf.SmoothDampAngle(current, target, ref currentVelocity, smoothTime, positiveInfinity, deltaTime);
		}

		// Token: 0x06000A21 RID: 2593 RVA: 0x0000F380 File Offset: 0x0000D580
		public static float SmoothDampAngle(float current, float target, ref float currentVelocity, float smoothTime, [DefaultValue("Mathf.Infinity")] float maxSpeed, [DefaultValue("Time.deltaTime")] float deltaTime)
		{
			target = current + Mathf.DeltaAngle(current, target);
			return Mathf.SmoothDamp(current, target, ref currentVelocity, smoothTime, maxSpeed, deltaTime);
		}

		// Token: 0x06000A22 RID: 2594 RVA: 0x0000F3B0 File Offset: 0x0000D5B0
		public static float Repeat(float t, float length)
		{
			return Mathf.Clamp(t - Mathf.Floor(t / length) * length, 0f, length);
		}

		// Token: 0x06000A23 RID: 2595 RVA: 0x0000F3DC File Offset: 0x0000D5DC
		public static float PingPong(float t, float length)
		{
			t = Mathf.Repeat(t, length * 2f);
			return length - Mathf.Abs(t - length);
		}

		// Token: 0x06000A24 RID: 2596 RVA: 0x0000F40C File Offset: 0x0000D60C
		public static float InverseLerp(float a, float b, float value)
		{
			float num;
			if (a != b)
			{
				num = Mathf.Clamp01((value - a) / (b - a));
			}
			else
			{
				num = 0f;
			}
			return num;
		}

		// Token: 0x06000A25 RID: 2597 RVA: 0x0000F440 File Offset: 0x0000D640
		public static float DeltaAngle(float current, float target)
		{
			float num = Mathf.Repeat(target - current, 360f);
			if (num > 180f)
			{
				num -= 360f;
			}
			return num;
		}

		// Token: 0x06000A26 RID: 2598 RVA: 0x0000F478 File Offset: 0x0000D678
		internal static bool LineIntersection(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, ref Vector2 result)
		{
			float num = p2.x - p1.x;
			float num2 = p2.y - p1.y;
			float num3 = p4.x - p3.x;
			float num4 = p4.y - p3.y;
			float num5 = num * num4 - num2 * num3;
			bool flag;
			if (num5 == 0f)
			{
				flag = false;
			}
			else
			{
				float num6 = p3.x - p1.x;
				float num7 = p3.y - p1.y;
				float num8 = (num6 * num4 - num7 * num3) / num5;
				result = new Vector2(p1.x + num8 * num, p1.y + num8 * num2);
				flag = true;
			}
			return flag;
		}

		// Token: 0x06000A27 RID: 2599 RVA: 0x0000F540 File Offset: 0x0000D740
		internal static bool LineSegmentIntersection(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, ref Vector2 result)
		{
			float num = p2.x - p1.x;
			float num2 = p2.y - p1.y;
			float num3 = p4.x - p3.x;
			float num4 = p4.y - p3.y;
			float num5 = num * num4 - num2 * num3;
			bool flag;
			if (num5 == 0f)
			{
				flag = false;
			}
			else
			{
				float num6 = p3.x - p1.x;
				float num7 = p3.y - p1.y;
				float num8 = (num6 * num4 - num7 * num3) / num5;
				if (num8 < 0f || num8 > 1f)
				{
					flag = false;
				}
				else
				{
					float num9 = (num6 * num2 - num7 * num) / num5;
					if (num9 < 0f || num9 > 1f)
					{
						flag = false;
					}
					else
					{
						result = new Vector2(p1.x + num8 * num, p1.y + num8 * num2);
						flag = true;
					}
				}
			}
			return flag;
		}

		// Token: 0x06000A28 RID: 2600 RVA: 0x0000F658 File Offset: 0x0000D858
		internal static long RandomToLong(Random r)
		{
			byte[] array = new byte[8];
			r.NextBytes(array);
			return (long)(BitConverter.ToUInt64(array, 0) & 9223372036854775807UL);
		}

		// Token: 0x040000F9 RID: 249
		public const float PI = 3.1415927f;

		// Token: 0x040000FA RID: 250
		public const float Infinity = float.PositiveInfinity;

		// Token: 0x040000FB RID: 251
		public const float NegativeInfinity = float.NegativeInfinity;

		// Token: 0x040000FC RID: 252
		public const float Deg2Rad = 0.017453292f;

		// Token: 0x040000FD RID: 253
		public const float Rad2Deg = 57.29578f;

		// Token: 0x040000FE RID: 254
		public static readonly float Epsilon = ((!MathfInternal.IsFlushToZeroEnabled) ? MathfInternal.FloatMinDenormal : MathfInternal.FloatMinNormal);
	}
}