using System;
using UnityEngine;

// Token: 0x02000002 RID: 2
public class GETween : MonoBehaviour
{
	// Token: 0x17000001 RID: 1
	// (get) Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
	public static GameObject m_TweenEmpty
	{
		get
		{
			GETween.Init(GETween.m_MaximumTweensCount);
			return GETween._TweenEmpty;
		}
	}

	// Token: 0x06000002 RID: 2 RVA: 0x00002061 File Offset: 0x00000261
	public static void Init()
	{
		GETween.Init(GETween.m_MaximumTweensCount);
	}

	// Token: 0x06000003 RID: 3 RVA: 0x00002070 File Offset: 0x00000270
	public static void Init(int maxSimultaneousTweens)
	{
		if (GETween.m_Tweens == null)
		{
			GETween.m_MaximumTweensCount = maxSimultaneousTweens;
			GETween.m_Tweens = new GETweenItem[GETween.m_MaximumTweensCount];
			GETween.m_TweensFinished = new int[GETween.m_MaximumTweensCount];
			GETween._TweenEmpty = new GameObject();
			GETween._TweenEmpty.name = "-GETween-";
			GETween._TweenEmpty.AddComponent(typeof(GETween));
			GETween._TweenEmpty.isStatic = true;
			GETween._TweenEmpty.hideFlags = HideFlags.HideInHierarchy | HideFlags.DontSaveInEditor | HideFlags.NotEditable;
			global::UnityEngine.Object.DontDestroyOnLoad(GETween._TweenEmpty);
			for (int i = 0; i < GETween.m_MaximumTweensCount; i++)
			{
				GETween.m_Tweens[i] = new GETweenItem();
			}
		}
	}

	// Token: 0x06000004 RID: 4 RVA: 0x00002118 File Offset: 0x00000318
	public static void Reset()
	{
		for (int i = 0; i <= GETween.m_TweenMaxSearch; i++)
		{
			GETween.m_Tweens[i].m_Toggle = false;
		}
		GETween.m_Tweens = null;
		global::UnityEngine.Object.Destroy(GETween._TweenEmpty);
	}

	// Token: 0x06000005 RID: 5 RVA: 0x00002152 File Offset: 0x00000352
	public void Update()
	{
		GETween.update();
	}

	// Token: 0x06000006 RID: 6 RVA: 0x0000215C File Offset: 0x0000035C
	public static void update()
	{
		if (GETween.m_FrameRendered != Time.frameCount)
		{
			GETween.Init();
			GETween.m_dtEstimated = Time.unscaledDeltaTime;
			GETween.m_dtActual = Time.deltaTime;
			GETween.m_MaxTweenReached = 0;
			GETween.m_finishedCnt = 0;
			int num = 0;
			while (num <= GETween.m_TweenMaxSearch && num < GETween.m_MaximumTweensCount)
			{
				if (GETween.m_Tweens[num].m_Toggle)
				{
					GETween.m_MaxTweenReached = num;
					GETween.m_Tween = GETween.m_Tweens[num];
					GETween.m_Transform = GETween.m_Tween.m_Trans;
					GETween.m_TotalTime = GETween.m_Tween.m_Time;
					if (GETween.m_Tween.m_UseEstimatedTime)
					{
						GETween.m_dt = GETween.m_dtEstimated;
						GETween.m_TotalTime = GETween.m_Tween.m_Time;
					}
					else if (GETween.m_Tween.m_Direction == 0f)
					{
						GETween.m_dt = 0f;
					}
					else
					{
						GETween.m_dt = GETween.m_dtActual;
					}
					if (GETween.m_Transform == null)
					{
						GETween.RemoveTween(num);
					}
					else
					{
						GETween.m_IndexAsAnimFinished = false;
						if (GETween.m_Tween.m_Delay <= 0f)
						{
							if (GETween.m_Tween.m_Passed + GETween.m_dt > GETween.m_Tween.m_Time && GETween.m_Tween.m_Direction > 0f)
							{
								GETween.m_IndexAsAnimFinished = true;
								GETween.m_Tween.m_Passed = GETween.m_Tween.m_Time;
							}
							else if (GETween.m_Tween.m_Direction < 0f && GETween.m_Tween.m_Passed - GETween.m_dt < 0f)
							{
								GETween.m_IndexAsAnimFinished = true;
								GETween.m_Tween.m_Passed = float.Epsilon;
							}
						}
						if (!GETween.m_Tween.m_HasInitiliazed && (((double)GETween.m_Tween.m_Passed == 0.0 && (double)GETween.m_Tween.m_Delay == 0.0) || (double)GETween.m_Tween.m_Passed > 0.0))
						{
							GETween.m_Tween.Init();
						}
						if (GETween.m_Tween.m_Delay <= 0f)
						{
							if (GETween.m_TotalTime <= 0f)
							{
								GETween.m_RatioPassed = 0f;
							}
							else
							{
								GETween.m_RatioPassed = GETween.m_Tween.m_Passed / GETween.m_TotalTime;
							}
							if (GETween.m_RatioPassed > 1f)
							{
								GETween.m_RatioPassed = 1f;
							}
							else if (GETween.m_RatioPassed < 0f)
							{
								GETween.m_RatioPassed = 0f;
							}
							switch (GETween.m_Tween.m_TweenType)
							{
							case GETween.GETweenType.linear:
								GETween.m_Value = GETween.m_Tween.m_From.x + GETween.m_Tween.m_Diff.x * GETween.m_RatioPassed;
								break;
							case GETween.GETweenType.easeOutQuad:
								GETween.m_Value = GETween.UpdateEaseOutQuadOpt(GETween.m_Tween.m_From.x, GETween.m_Tween.m_Diff.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInQuad:
								GETween.m_Value = GETween.UpdateEaseInQuadOpt(GETween.m_Tween.m_From.x, GETween.m_Tween.m_Diff.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutQuad:
								GETween.m_Value = GETween.UpdateEaseInOutQuadOpt(GETween.m_Tween.m_From.x, GETween.m_Tween.m_Diff.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInCubic:
								GETween.m_Value = GETween.UpdateEaseInCubic(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutCubic:
								GETween.m_Value = GETween.UpdateEaseOutCubic(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutCubic:
								GETween.m_Value = GETween.UpdateEaseInOutCubic(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInQuart:
								GETween.m_Value = GETween.UpdateEaseInQuart(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutQuart:
								GETween.m_Value = GETween.UpdateEaseOutQuart(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutQuart:
								GETween.m_Value = GETween.UpdateEaseInOutQuart(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInQuint:
								GETween.m_Value = GETween.UpdateEaseInQuint(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutQuint:
								GETween.m_Value = GETween.UpdateEaseOutQuint(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutQuint:
								GETween.m_Value = GETween.UpdateEaseInOutQuint(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInSine:
								GETween.m_Value = GETween.UpdateEaseInSine(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutSine:
								GETween.m_Value = GETween.UpdateEaseOutSine(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutSine:
								GETween.m_Value = GETween.UpdateEaseInOutSine(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInExpo:
								GETween.m_Value = GETween.UpdateEaseInExpo(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutExpo:
								GETween.m_Value = GETween.UpdateEaseOutExpo(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutExpo:
								GETween.m_Value = GETween.UpdateEaseInOutExpo(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInCirc:
								GETween.m_Value = GETween.UpdateEaseInCirc(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutCirc:
								GETween.m_Value = GETween.UpdateEaseOutCirc(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutCirc:
								GETween.m_Value = GETween.UpdateEaseInOutCirc(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInBounce:
								GETween.m_Value = GETween.UpdateEaseInBounce(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutBounce:
								GETween.m_Value = GETween.UpdateEaseOutBounce(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutBounce:
								GETween.m_Value = GETween.UpdateEaseInOutBounce(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInBack:
								GETween.m_Value = GETween.UpdateEaseInBack(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutBack:
								GETween.m_Value = GETween.UpdateEaseOutBack(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutBack:
								GETween.m_Value = GETween.UpdateEaseInOutElastic(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInElastic:
								GETween.m_Value = GETween.UpdateEaseInElastic(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeOutElastic:
								GETween.m_Value = GETween.UpdateEaseOutElastic(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeInOutElastic:
								GETween.m_Value = GETween.UpdateEaseInOutElastic(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							case GETween.GETweenType.easeSpring:
								GETween.m_Value = GETween.UpdateEaseSpring(GETween.m_Tween.m_From.x, GETween.m_Tween.m_To.x, GETween.m_RatioPassed);
								break;
							default:
								GETween.m_Value = GETween.m_Tween.m_From.x + GETween.m_Tween.m_Diff.x * GETween.m_RatioPassed;
								break;
							}
							if (GETween.m_Tween.m_HasUpdateCallback)
							{
								if (GETween.m_Tween.m_OnUpdateFloat != null)
								{
									GETween.m_Tween.m_OnUpdateFloat(GETween.m_Value);
								}
								if (GETween.m_Tween.m_OnUpdateFloatRatio != null)
								{
									GETween.m_Tween.m_OnUpdateFloatRatio(GETween.m_Value, GETween.m_RatioPassed);
								}
							}
						}
						if (GETween.m_IndexAsAnimFinished)
						{
							if (GETween.m_Tween.m_LoopType == GETween.GETweenType.once || GETween.m_Tween.m_LoopCount == 1)
							{
								GETween.m_TweensFinished[GETween.m_finishedCnt] = num;
								GETween.m_finishedCnt++;
							}
							else
							{
								if (GETween.m_Tween.m_LoopCount < 0 || GETween.m_Tween.m_CompleteOnRepeat)
								{
									if (GETween.m_Tween.m_OnComplete != null)
									{
										GETween.m_Tween.m_OnComplete();
									}
									else if (GETween.m_Tween.m_OnCompleteObject != null)
									{
										GETween.m_Tween.m_OnCompleteObject(GETween.m_Tween.m_OnCompleteParam);
									}
								}
								if (GETween.m_Tween.m_LoopCount >= 1)
								{
									GETween.m_Tween.m_LoopCount--;
								}
								if (GETween.m_Tween.m_LoopType == GETween.GETweenType.pingPong)
								{
									GETween.m_Tween.m_Direction = 0f - GETween.m_Tween.m_Direction;
								}
								else
								{
									GETween.m_Tween.m_Passed = float.Epsilon;
								}
							}
						}
						else if (GETween.m_Tween.m_Delay <= 0f)
						{
							GETween.m_Tween.m_Passed += GETween.m_dt * GETween.m_Tween.m_Direction;
						}
						else
						{
							GETween.m_Tween.m_Delay -= GETween.m_dt;
							if (GETween.m_Tween.m_Delay < 0f)
							{
								GETween.m_Tween.m_Passed = 0f;
								GETween.m_Tween.m_Delay = 0f;
							}
						}
					}
				}
				num++;
			}
			GETween.m_TweenMaxSearch = GETween.m_MaxTweenReached;
			GETween.m_FrameRendered = Time.frameCount;
			for (int i = 0; i < GETween.m_finishedCnt; i++)
			{
				GETween.m_IndexB = GETween.m_TweensFinished[i];
				GETween.m_Tween = GETween.m_Tweens[GETween.m_IndexB];
				if (GETween.m_Tween.m_OnComplete != null)
				{
					Action onComplete = GETween.m_Tween.m_OnComplete;
					GETween.RemoveTween(GETween.m_IndexB);
					onComplete();
				}
				else if (GETween.m_Tween.m_OnCompleteObject != null)
				{
					Action<object> onCompleteObject = GETween.m_Tween.m_OnCompleteObject;
					object onCompleteParam = GETween.m_Tween.m_OnCompleteParam;
					GETween.RemoveTween(GETween.m_IndexB);
					onCompleteObject(onCompleteParam);
				}
				else
				{
					GETween.RemoveTween(GETween.m_IndexB);
				}
			}
		}
	}

	// Token: 0x06000007 RID: 7 RVA: 0x00002D2E File Offset: 0x00000F2E
	public static void RemoveTween(int i, int uniqueId)
	{
		if (GETween.m_Tweens[i].UniqueID == uniqueId)
		{
			GETween.RemoveTween(i);
		}
	}

	// Token: 0x06000008 RID: 8 RVA: 0x00002D48 File Offset: 0x00000F48
	public static void RemoveTween(int i)
	{
		if (GETween.m_Tweens[i].m_Toggle)
		{
			GETween.m_Tweens[i].m_Toggle = false;
			if (GETween.m_Tweens[i].m_DestroyOnComplete && GETween.m_Tweens[i].m_Trans.gameObject != GETween._TweenEmpty)
			{
				global::UnityEngine.Object.Destroy(GETween.m_Tweens[i].m_Trans.gameObject);
			}
			GETween.m_Tweens[i].cleanup();
			GETween.m_StartSearch = i;
			if (i + 1 >= GETween.m_TweenMaxSearch)
			{
				GETween.m_StartSearch = 0;
			}
		}
	}

	// Token: 0x06000009 RID: 9 RVA: 0x00002DD3 File Offset: 0x00000FD3
	public static object SendLogError(string error)
	{
		Debug.Log(error);
		return null;
	}

	// Token: 0x0600000A RID: 10 RVA: 0x00002DDC File Offset: 0x00000FDC
	public static GETweenItem MoreInfo()
	{
		GETween.Init();
		bool flag = false;
		GETween.m_IndexB = 0;
		GETween.m_IndexA = GETween.m_StartSearch;
		while (GETween.m_IndexB < GETween.m_MaximumTweensCount)
		{
			if (GETween.m_IndexA >= GETween.m_MaximumTweensCount - 1)
			{
				GETween.m_IndexA = 0;
			}
			if (!GETween.m_Tweens[GETween.m_IndexA].m_Toggle)
			{
				if (GETween.m_IndexA + 1 > GETween.m_TweenMaxSearch)
				{
					GETween.m_TweenMaxSearch = GETween.m_IndexA + 1;
				}
				GETween.m_StartSearch = GETween.m_IndexA + 1;
				flag = true;
				break;
			}
			GETween.m_IndexB++;
			if (GETween.m_IndexB >= GETween.m_MaximumTweensCount)
			{
				return GETween.SendLogError("Out of GETween spaces.") as GETweenItem;
			}
			GETween.m_IndexA++;
		}
		if (!flag)
		{
			GETween.SendLogError("tween not found!");
		}
		GETween.m_Tweens[GETween.m_IndexA].Reset();
		GETween.m_Tweens[GETween.m_IndexA].SetId((uint)GETween.m_IndexA);
		return GETween.m_Tweens[GETween.m_IndexA];
	}

	// Token: 0x0600000B RID: 11 RVA: 0x00002ED7 File Offset: 0x000010D7
	private static GETweenItem AddTween(GameObject gameObject, Vector3 to, float time, GETweenItem tween)
	{
		GETween.Init(GETween.m_MaximumTweensCount);
		if (gameObject == null || tween == null)
		{
			return null;
		}
		tween.m_Trans = gameObject.transform;
		tween.m_To = to;
		tween.m_Time = time;
		return tween;
	}

	// Token: 0x0600000C RID: 12 RVA: 0x00002F0C File Offset: 0x0000110C
	public static GETweenItem TweenValue(GameObject gameObject, Action<float> callOnUpdate, float from, float to, float time)
	{
		return GETween.AddTween(gameObject, new Vector3(to, 0f, 0f), time, GETween.MoreInfo().SetTo(new Vector3(to, 0f, 0f)).SetFrom(new Vector3(from, 0f, 0f))
			.SetOnUpdate(callOnUpdate));
	}

	// Token: 0x0600000D RID: 13 RVA: 0x00002F66 File Offset: 0x00001166
	private static float UpdateEaseOutQuadOpt(float start, float diff, float ratioPassed)
	{
		return -diff * ratioPassed * (ratioPassed - 2f) + start;
	}

	// Token: 0x0600000E RID: 14 RVA: 0x00002F76 File Offset: 0x00001176
	private static float UpdateEaseInQuadOpt(float start, float diff, float ratioPassed)
	{
		return diff * ratioPassed * ratioPassed + start;
	}

	// Token: 0x0600000F RID: 15 RVA: 0x00002F80 File Offset: 0x00001180
	private static float UpdateEaseInOutQuadOpt(float start, float diff, float ratioPassed)
	{
		ratioPassed /= 0.5f;
		if (ratioPassed < 1f)
		{
			return diff / 2f * ratioPassed * ratioPassed + start;
		}
		ratioPassed -= 1f;
		float num = -diff / 2f;
		float num2 = ratioPassed;
		return num * (num2 * (num2 - 2f) - 1f) + start;
	}

	// Token: 0x06000010 RID: 16 RVA: 0x00002FCF File Offset: 0x000011CF
	private static float UpdateEaseLinear(float start, float end, float val)
	{
		return Mathf.Lerp(start, end, val);
	}

	// Token: 0x06000011 RID: 17 RVA: 0x00002FDC File Offset: 0x000011DC
	private static float UpdateEaseSpring(float start, float end, float val)
	{
		val = Mathf.Clamp01(val);
		val = (Mathf.Sin(val * 3.1415927f * (0.2f + 2.5f * val * val * val)) * Mathf.Pow(1f - val, 2.2f) + val) * (1f + 1.2f * (1f - val));
		return start + (end - start) * val;
	}

	// Token: 0x06000012 RID: 18 RVA: 0x00003040 File Offset: 0x00001240
	private static float UpdateEaseInQuad(float start, float end, float val)
	{
		end -= start;
		return end * val * val + start;
	}

	// Token: 0x06000013 RID: 19 RVA: 0x0000304E File Offset: 0x0000124E
	private static float UpdateEaseOutQuad(float start, float end, float val)
	{
		end -= start;
		return -end * val * (val - 2f) + start;
	}

	// Token: 0x06000014 RID: 20 RVA: 0x00003064 File Offset: 0x00001264
	private static float UpdateEaseInOutQuad(float start, float end, float val)
	{
		val /= 0.5f;
		end -= start;
		if (val < 1f)
		{
			return end / 2f * val * val + start;
		}
		val -= 1f;
		float num = -end / 2f;
		float num2 = val;
		return num * (num2 * (num2 - 2f) - 1f) + start;
	}

	// Token: 0x06000015 RID: 21 RVA: 0x000030B8 File Offset: 0x000012B8
	private static float UpdateEaseInCubic(float start, float end, float val)
	{
		end -= start;
		return end * val * val * val + start;
	}

	// Token: 0x06000016 RID: 22 RVA: 0x000030C8 File Offset: 0x000012C8
	private static float UpdateEaseOutCubic(float start, float end, float val)
	{
		val -= 1f;
		end -= start;
		float num = end;
		float num2 = val;
		return num * (num2 * num2 * val + 1f) + start;
	}

	// Token: 0x06000017 RID: 23 RVA: 0x000030E8 File Offset: 0x000012E8
	private static float UpdateEaseInOutCubic(float start, float end, float val)
	{
		val /= 0.5f;
		end -= start;
		if (val < 1f)
		{
			return end / 2f * val * val * val + start;
		}
		val -= 2f;
		float num = end / 2f;
		float num2 = val;
		return num * (num2 * num2 * val + 2f) + start;
	}

	// Token: 0x06000018 RID: 24 RVA: 0x00003139 File Offset: 0x00001339
	private static float UpdateEaseInQuart(float start, float end, float val)
	{
		end -= start;
		return end * val * val * val * val + start;
	}

	// Token: 0x06000019 RID: 25 RVA: 0x0000314B File Offset: 0x0000134B
	private static float UpdateEaseOutQuart(float start, float end, float val)
	{
		val -= 1f;
		end -= start;
		float num = -end;
		float num2 = val;
		return num * (num2 * num2 * val * val - 1f) + start;
	}

	// Token: 0x0600001A RID: 26 RVA: 0x00003170 File Offset: 0x00001370
	private static float UpdateEaseInOutQuart(float start, float end, float val)
	{
		val /= 0.5f;
		end -= start;
		if (val < 1f)
		{
			return end / 2f * val * val * val * val + start;
		}
		val -= 2f;
		float num = -end / 2f;
		float num2 = val;
		return num * (num2 * num2 * val * val - 2f) + start;
	}

	// Token: 0x0600001B RID: 27 RVA: 0x000031C6 File Offset: 0x000013C6
	private static float UpdateEaseInQuint(float start, float end, float val)
	{
		end -= start;
		return end * val * val * val * val * val + start;
	}

	// Token: 0x0600001C RID: 28 RVA: 0x000031DA File Offset: 0x000013DA
	private static float UpdateEaseOutQuint(float start, float end, float val)
	{
		val -= 1f;
		end -= start;
		float num = end;
		float num2 = val;
		return num * (num2 * num2 * val * val * val + 1f) + start;
	}

	// Token: 0x0600001D RID: 29 RVA: 0x00003200 File Offset: 0x00001400
	private static float UpdateEaseInOutQuint(float start, float end, float val)
	{
		val /= 0.5f;
		end -= start;
		if (val < 1f)
		{
			return end / 2f * val * val * val * val * val + start;
		}
		val -= 2f;
		float num = end / 2f;
		float num2 = val;
		return num * (num2 * num2 * val * val * val + 2f) + start;
	}

	// Token: 0x0600001E RID: 30 RVA: 0x00003259 File Offset: 0x00001459
	private static float UpdateEaseInSine(float start, float end, float val)
	{
		end -= start;
		return -end * Mathf.Cos(val / 1f * 1.5707964f) + end + start;
	}

	// Token: 0x0600001F RID: 31 RVA: 0x00003279 File Offset: 0x00001479
	private static float UpdateEaseOutSine(float start, float end, float val)
	{
		end -= start;
		return end * Mathf.Sin(val / 1f * 1.5707964f) + start;
	}

	// Token: 0x06000020 RID: 32 RVA: 0x00003296 File Offset: 0x00001496
	private static float UpdateEaseInOutSine(float start, float end, float val)
	{
		end -= start;
		return -end / 2f * (Mathf.Cos(3.1415927f * val / 1f) - 1f) + start;
	}

	// Token: 0x06000021 RID: 33 RVA: 0x000032C0 File Offset: 0x000014C0
	private static float UpdateEaseInExpo(float start, float end, float val)
	{
		end -= start;
		return end * Mathf.Pow(2f, 10f * (val / 1f - 1f)) + start;
	}

	// Token: 0x06000022 RID: 34 RVA: 0x000032E8 File Offset: 0x000014E8
	private static float UpdateEaseOutExpo(float start, float end, float val)
	{
		end -= start;
		return end * (-Mathf.Pow(2f, -10f * val / 1f) + 1f) + start;
	}

	// Token: 0x06000023 RID: 35 RVA: 0x00003314 File Offset: 0x00001514
	private static float UpdateEaseInOutExpo(float start, float end, float val)
	{
		val /= 0.5f;
		end -= start;
		if (val < 1f)
		{
			return end / 2f * Mathf.Pow(2f, 10f * (val - 1f)) + start;
		}
		val -= 1f;
		return end / 2f * (-Mathf.Pow(2f, -10f * val) + 2f) + start;
	}

	// Token: 0x06000024 RID: 36 RVA: 0x00003384 File Offset: 0x00001584
	private static float UpdateEaseInCirc(float start, float end, float val)
	{
		end -= start;
		return -end * (Mathf.Sqrt(1f - val * val) - 1f) + start;
	}

	// Token: 0x06000025 RID: 37 RVA: 0x000033A4 File Offset: 0x000015A4
	private static float UpdateEaseOutCirc(float start, float end, float val)
	{
		val -= 1f;
		end -= start;
		float num = end;
		float num2 = 1f;
		float num3 = val;
		return num * Mathf.Sqrt(num2 - num3 * num3) + start;
	}

	// Token: 0x06000026 RID: 38 RVA: 0x000033C8 File Offset: 0x000015C8
	private static float UpdateEaseInOutCirc(float start, float end, float val)
	{
		val /= 0.5f;
		end -= start;
		if (val < 1f)
		{
			float num = -end / 2f;
			float num2 = 1f;
			float num3 = val;
			return num * (Mathf.Sqrt(num2 - num3 * num3) - 1f) + start;
		}
		val -= 2f;
		float num4 = end / 2f;
		float num5 = 1f;
		float num6 = val;
		return num4 * (Mathf.Sqrt(num5 - num6 * num6) + 1f) + start;
	}

	// Token: 0x06000027 RID: 39 RVA: 0x00003434 File Offset: 0x00001634
	private static float UpdateEaseInBounce(float start, float end, float val)
	{
		end -= start;
		float num = 1f;
		return end - GETween.UpdateEaseOutBounce(0f, end, num - val) + start;
	}

	// Token: 0x06000028 RID: 40 RVA: 0x00003460 File Offset: 0x00001660
	private static float UpdateEaseOutBounce(float start, float end, float val)
	{
		val /= 1f;
		end -= start;
		if (val < 0.36363637f)
		{
			return end * (7.5625f * val * val) + start;
		}
		if (val < 0.72727275f)
		{
			val -= 0.54545456f;
			return end * (7.5625f * val * val + 0.75f) + start;
		}
		if ((double)val < 0.9090909090909091)
		{
			val -= 0.8181818f;
			return end * (7.5625f * val * val + 0.9375f) + start;
		}
		val -= 0.95454544f;
		return end * (7.5625f * val * val + 0.984375f) + start;
	}

	// Token: 0x06000029 RID: 41 RVA: 0x000034FC File Offset: 0x000016FC
	private static float UpdateEaseInOutBounce(float start, float end, float val)
	{
		end -= start;
		float num = 1f;
		if (val < num / 2f)
		{
			return GETween.UpdateEaseInBounce(0f, end, val * 2f) * 0.5f + start;
		}
		return GETween.UpdateEaseOutBounce(0f, end, val * 2f - num) * 0.5f + end * 0.5f + start;
	}

	// Token: 0x0600002A RID: 42 RVA: 0x00003560 File Offset: 0x00001760
	private static float UpdateEaseInBack(float start, float end, float val)
	{
		end -= start;
		val /= 1f;
		float num = 1.70158f;
		return end * val * val * ((num + 1f) * val - num) + start;
	}

	// Token: 0x0600002B RID: 43 RVA: 0x00003594 File Offset: 0x00001794
	private static float UpdateEaseOutBack(float start, float end, float val)
	{
		float num = 1.70158f;
		end -= start;
		val = val / 1f - 1f;
		float num2 = end;
		float num3 = val;
		return num2 * (num3 * num3 * ((num + 1f) * val + num) + 1f) + start;
	}

	// Token: 0x0600002C RID: 44 RVA: 0x000035D4 File Offset: 0x000017D4
	private static float UpdateEaseInOutBack(float start, float end, float val)
	{
		float num = 1.70158f;
		end -= start;
		val /= 0.5f;
		if (val < 1f)
		{
			num *= 1.525f;
			float num2 = end / 2f;
			float num3 = val;
			return num2 * (num3 * num3 * ((num + 1f) * val - num)) + start;
		}
		val -= 2f;
		num *= 1.525f;
		float num4 = end / 2f;
		float num5 = val;
		return num4 * (num5 * num5 * ((num + 1f) * val + num) + 2f) + start;
	}

	// Token: 0x0600002D RID: 45 RVA: 0x00003650 File Offset: 0x00001850
	private static float UpdateEaseInElastic(float start, float end, float val)
	{
		end -= start;
		float num = 1f;
		float num2 = num * 0.3f;
		float num3 = 0f;
		if (val == 0f)
		{
			return start;
		}
		val /= num;
		if (val == 1f)
		{
			return start + end;
		}
		float num4;
		if (num3 == 0f || num3 < Mathf.Abs(end))
		{
			num3 = end;
			num4 = num2 / 4f;
		}
		else
		{
			num4 = num2 / 6.2831855f * Mathf.Asin(end / num3);
		}
		val -= 1f;
		return -(num3 * Mathf.Pow(2f, 10f * val) * Mathf.Sin((val * num - num4) * 6.2831855f / num2)) + start;
	}

	// Token: 0x0600002E RID: 46 RVA: 0x000036F8 File Offset: 0x000018F8
	private static float UpdateEaseOutElastic(float start, float end, float val)
	{
		end -= start;
		float num = 1f;
		float num2 = num * 0.3f;
		float num3 = 0f;
		if (val == 0f)
		{
			return start;
		}
		val /= num;
		if (val == 1f)
		{
			return start + end;
		}
		float num4;
		if (num3 == 0f || num3 < Mathf.Abs(end))
		{
			num3 = end;
			num4 = num2 / 4f;
		}
		else
		{
			num4 = num2 / 6.2831855f * Mathf.Asin(end / num3);
		}
		return num3 * Mathf.Pow(2f, -10f * val) * Mathf.Sin((val * num - num4) * 6.2831855f / num2) + end + start;
	}

	// Token: 0x0600002F RID: 47 RVA: 0x00003798 File Offset: 0x00001998
	private static float UpdateEaseInOutElastic(float start, float end, float val)
	{
		end -= start;
		float num = 1f;
		float num2 = num * 0.3f;
		float num3 = 0f;
		if (val == 0f)
		{
			return start;
		}
		val /= num / 2f;
		if (val == 2f)
		{
			return start + end;
		}
		float num4;
		if (num3 == 0f || num3 < Mathf.Abs(end))
		{
			num3 = end;
			num4 = num2 / 4f;
		}
		else
		{
			num4 = num2 / 6.2831855f * Mathf.Asin(end / num3);
		}
		if (val < 1f)
		{
			val -= 1f;
			return -0.5f * (num3 * Mathf.Pow(2f, 10f * val) * Mathf.Sin((val * num - num4) * 6.2831855f / num2)) + start;
		}
		val -= 1f;
		return num3 * Mathf.Pow(2f, -10f * val) * Mathf.Sin((val * num - num4) * 6.2831855f / num2) * 0.5f + end + start;
	}

	// Token: 0x04000001 RID: 1
	private static int m_FrameRendered = -1;

	// Token: 0x04000002 RID: 2
	private static float m_dt;

	// Token: 0x04000003 RID: 3
	private static float m_dtActual;

	// Token: 0x04000004 RID: 4
	private static float m_dtEstimated;

	// Token: 0x04000005 RID: 5
	private static int m_finishedCnt;

	// Token: 0x04000006 RID: 6
	private static int m_IndexA;

	// Token: 0x04000007 RID: 7
	private static bool m_IndexAsAnimFinished;

	// Token: 0x04000008 RID: 8
	private static int m_IndexB;

	// Token: 0x04000009 RID: 9
	private static int m_MaximumTweensCount = 800;

	// Token: 0x0400000A RID: 10
	private static int m_MaxTweenReached;

	// Token: 0x0400000B RID: 11
	private static float m_RatioPassed;

	// Token: 0x0400000C RID: 12
	public static int m_StartSearch = 0;

	// Token: 0x0400000D RID: 13
	private static float m_TotalTime;

	// Token: 0x0400000E RID: 14
	private static Transform m_Transform;

	// Token: 0x0400000F RID: 15
	private static GETweenItem m_Tween;

	// Token: 0x04000010 RID: 16
	private static GameObject _TweenEmpty;

	// Token: 0x04000011 RID: 17
	private static int m_TweenMaxSearch = -1;

	// Token: 0x04000012 RID: 18
	private static GETweenItem[] m_Tweens;

	// Token: 0x04000013 RID: 19
	private static int[] m_TweensFinished;

	// Token: 0x04000014 RID: 20
	private static float m_Value;

	// Token: 0x02000004 RID: 4
	public enum GETweenType
	{
		// Token: 0x04000030 RID: 48
		linear,
		// Token: 0x04000031 RID: 49
		easeOutQuad,
		// Token: 0x04000032 RID: 50
		easeInQuad,
		// Token: 0x04000033 RID: 51
		easeInOutQuad,
		// Token: 0x04000034 RID: 52
		easeInCubic,
		// Token: 0x04000035 RID: 53
		easeOutCubic,
		// Token: 0x04000036 RID: 54
		easeInOutCubic,
		// Token: 0x04000037 RID: 55
		easeInQuart,
		// Token: 0x04000038 RID: 56
		easeOutQuart,
		// Token: 0x04000039 RID: 57
		easeInOutQuart,
		// Token: 0x0400003A RID: 58
		easeInQuint,
		// Token: 0x0400003B RID: 59
		easeOutQuint,
		// Token: 0x0400003C RID: 60
		easeInOutQuint,
		// Token: 0x0400003D RID: 61
		easeInSine,
		// Token: 0x0400003E RID: 62
		easeOutSine,
		// Token: 0x0400003F RID: 63
		easeInOutSine,
		// Token: 0x04000040 RID: 64
		easeInExpo,
		// Token: 0x04000041 RID: 65
		easeOutExpo,
		// Token: 0x04000042 RID: 66
		easeInOutExpo,
		// Token: 0x04000043 RID: 67
		easeInCirc,
		// Token: 0x04000044 RID: 68
		easeOutCirc,
		// Token: 0x04000045 RID: 69
		easeInOutCirc,
		// Token: 0x04000046 RID: 70
		easeInBounce,
		// Token: 0x04000047 RID: 71
		easeOutBounce,
		// Token: 0x04000048 RID: 72
		easeInOutBounce,
		// Token: 0x04000049 RID: 73
		easeInBack,
		// Token: 0x0400004A RID: 74
		easeOutBack,
		// Token: 0x0400004B RID: 75
		easeInOutBack,
		// Token: 0x0400004C RID: 76
		easeInElastic,
		// Token: 0x0400004D RID: 77
		easeOutElastic,
		// Token: 0x0400004E RID: 78
		easeInOutElastic,
		// Token: 0x0400004F RID: 79
		easeSpring,
		// Token: 0x04000050 RID: 80
		once,
		// Token: 0x04000051 RID: 81
		pingPong
	}
}