using System;
using System.Collections.Generic;
using UnityEngine;

// Token: 0x02001282 RID: 4738
[RequireComponent(typeof(MeshFilter))]
public class SoftNormalsToVertexColor : MonoBehaviour
{
	// Token: 0x0602914E RID: 168270 RVA: 0x00B7B7DC File Offset: 0x00B799DC
	private void JFFLHAMMGAH()
	{
		if (this.generateOnAwake)
		{
			this.FKAEEMBJHBB();
		}
	}

	// Token: 0x0602914F RID: 168271 RVA: 0x00B7B7F0 File Offset: 0x00B799F0
	private void DHAEEPCMCMI()
	{
		if (this.generateOnAwake)
		{
			this.PAAHFLMMHNB();
		}
	}

	// Token: 0x06029150 RID: 168272 RVA: 0x00B7B804 File Offset: 0x00B79A04
	private void IOBOMGPLHJA()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.GCNPKEKFDOA();
		}
	}

	// Token: 0x06029151 RID: 168273 RVA: 0x00B7B820 File Offset: 0x00B79A20
	private void LIJNAAFGNMO(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i++)
		{
			bool flag = false;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[0]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 0f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 57.29578f;
				float num5 = 180f - num4 - 90f;
				float num6 = 0.5f / Mathf.Sin(num5 * 0.017453292f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029152 RID: 168274 RVA: 0x00B7BB14 File Offset: 0x00B79D14
	private void FNNCEMJECLP()
	{
		if (this.generateOnAwake)
		{
			this.ANFCKJMBIAK();
		}
	}

	// Token: 0x06029153 RID: 168275 RVA: 0x00B7BB28 File Offset: 0x00B79D28
	private void NGHJFABFAOA()
	{
		if (this.generateOnAwake)
		{
			this.DDBMMJLKCGH();
		}
	}

	// Token: 0x06029154 RID: 168276 RVA: 0x00B7BB3C File Offset: 0x00B79D3C
	private void EAICOGODAKM(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i += 0)
		{
			bool flag = false;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[0]] == vertices[i])
				{
					list2.Add(i);
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 176f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 241f;
				float num5 = 43f - num4 - 607f;
				float num6 = 170f / Mathf.Sin(num5 * 217f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029155 RID: 168277 RVA: 0x00B7BE30 File Offset: 0x00B7A030
	private void NMOBMJGJCCC()
	{
		if (this.generateOnAwake)
		{
			this.NAHFJGBBNMP();
		}
	}

	// Token: 0x06029156 RID: 168278 RVA: 0x00B7BE44 File Offset: 0x00B7A044
	private void HMEGFBNPNOH(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i += 0)
		{
			bool flag = false;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[1]] == vertices[i])
				{
					list2.Add(i);
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 110f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 1559f;
				float num5 = 621f - num4 - 222f;
				float num6 = 1337f / Mathf.Sin(num5 * 235f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029157 RID: 168279 RVA: 0x00B7C138 File Offset: 0x00B7A338
	private void AMMMBBEMNOI(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 1; i < vertices.Length; i += 0)
		{
			bool flag = false;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[0]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.Simple)
			{
				float num2 = 1189f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 1243f;
				float num5 = 657f - num4 - 1129f;
				float num6 = 744f / Mathf.Sin(num5 * 1755f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029158 RID: 168280 RVA: 0x00B7C42C File Offset: 0x00B7A62C
	private void JNLIAABLKEH()
	{
		if (this.generateNow)
		{
			this.generateNow = true;
			this.FIPDCDCIJFN();
		}
	}

	// Token: 0x06029159 RID: 168281 RVA: 0x00B7C448 File Offset: 0x00B7A648
	private void Awake()
	{
		if (this.generateOnAwake)
		{
			this.PAAHFLMMHNB();
		}
	}

	// Token: 0x0602915A RID: 168282 RVA: 0x00B7C45C File Offset: 0x00B7A65C
	private void AEMLGBFNAIE()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.KHIANENBIAJ();
		}
	}

	// Token: 0x0602915B RID: 168283 RVA: 0x00B7C478 File Offset: 0x00B7A678
	private void NAHFJGBBNMP()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("_level", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("easetype", base.gameObject);
			return;
		}
		this.PNEBCKMHLOF(component.sharedMesh);
		Debug.Log("{0}reportjoinresult", base.gameObject);
	}

	// Token: 0x0602915C RID: 168284 RVA: 0x00B7C4E8 File Offset: 0x00B7A6E8
	private void AMNNBMEMJGB()
	{
		if (this.generateOnAwake)
		{
			this.ANFCKJMBIAK();
		}
	}

	// Token: 0x0602915D RID: 168285 RVA: 0x00B7C4FC File Offset: 0x00B7A6FC
	private void PNEBCKMHLOF(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 1; i < vertices.Length; i++)
		{
			bool flag = true;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[1]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 1179f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 1278f;
				float num5 = 1293f - num4 - 720f;
				float num6 = 523f / Mathf.Sin(num5 * 1909f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x0602915E RID: 168286 RVA: 0x00B7C7F0 File Offset: 0x00B7A9F0
	private void MELFNMPLBAK()
	{
		if (this.generateOnAwake)
		{
			this.NANCJACJIHC();
		}
	}

	// Token: 0x0602915F RID: 168287 RVA: 0x00B7C804 File Offset: 0x00B7AA04
	private void OFFHHFIMHEE(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i++)
		{
			bool flag = true;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[0]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 1248f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 1618f;
				float num5 = 35f - num4 - 526f;
				float num6 = 118f / Mathf.Sin(num5 * 534f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029160 RID: 168288 RVA: 0x00B7CAF8 File Offset: 0x00B7ACF8
	private void JPLKJMLOPFN()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.CGPJPBJMNPI();
		}
	}

	// Token: 0x06029161 RID: 168289 RVA: 0x00B7CB14 File Offset: 0x00B7AD14
	private void CGPJPBJMNPI()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("OpGetGameList()", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("Continue Exploring To Unlock This Door!", base.gameObject);
			return;
		}
		this.CGGOAMNBOMH(component.sharedMesh);
		Debug.Log("Updating maximum number of players...", base.gameObject);
	}

	// Token: 0x06029162 RID: 168290 RVA: 0x00B7CB84 File Offset: 0x00B7AD84
	private void CGGOAMNBOMH(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 1; i < vertices.Length; i += 0)
		{
			bool flag = true;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[1]] == vertices[i])
				{
					list2.Add(i);
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 1457f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 26f;
				float num5 = 1145f - num4 - 919f;
				float num6 = 97f / Mathf.Sin(num5 * 1084f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029163 RID: 168291 RVA: 0x00B7CE78 File Offset: 0x00B7B078
	private void OHJHJCNFEDM(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i += 0)
		{
			bool flag = true;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[0]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.Simple)
			{
				float num2 = 904f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 719f;
				float num5 = 706f - num4 - 995f;
				float num6 = 654f / Mathf.Sin(num5 * 1185f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029164 RID: 168292 RVA: 0x00B7D16C File Offset: 0x00B7B36C
	private void KOCGAANDADK()
	{
		if (this.generateNow)
		{
			this.generateNow = true;
			this.NANCJACJIHC();
		}
	}

	// Token: 0x06029165 RID: 168293 RVA: 0x00B7D188 File Offset: 0x00B7B388
	private void ANFCKJMBIAK()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("MaxConnectionPerServer must be greater than 0!", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("punchCardRewardsUnclaimed", base.gameObject);
			return;
		}
		this.OHJHJCNFEDM(component.sharedMesh);
		Debug.Log("{0}: {1}", base.gameObject);
	}

	// Token: 0x06029166 RID: 168294 RVA: 0x00B7D1F8 File Offset: 0x00B7B3F8
	private void NHLJJOPDMIN()
	{
		if (this.generateOnAwake)
		{
			this.NANCJACJIHC();
		}
	}

	// Token: 0x06029167 RID: 168295 RVA: 0x00B7D20C File Offset: 0x00B7B40C
	private void FIPDCDCIJFN()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("COLORED_OFF", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("You need to be level ", base.gameObject);
			return;
		}
		this.PNEBCKMHLOF(component.sharedMesh);
		Debug.Log("Connect failed: no UserId specified in authentication values.", base.gameObject);
	}

	// Token: 0x06029168 RID: 168296 RVA: 0x00B7D27C File Offset: 0x00B7B47C
	private void KHIANENBIAJ()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("partyId", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("SC_UBP", base.gameObject);
			return;
		}
		this.CGGOAMNBOMH(component.sharedMesh);
		Debug.Log("disableStandardAssets", base.gameObject);
	}

	// Token: 0x06029169 RID: 168297 RVA: 0x00B7D2EC File Offset: 0x00B7B4EC
	private void ECJEHDFGFFK()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.ANFCKJMBIAK();
		}
	}

	// Token: 0x0602916A RID: 168298 RVA: 0x00B7D308 File Offset: 0x00B7B508
	private void PPFJGFPICBJ()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.KHIANENBIAJ();
		}
	}

	// Token: 0x0602916B RID: 168299 RVA: 0x00B7D324 File Offset: 0x00B7B524
	private void LELHNBCKIEG()
	{
		if (this.generateOnAwake)
		{
			this.CGPJPBJMNPI();
		}
	}

	// Token: 0x0602916C RID: 168300 RVA: 0x00B7D338 File Offset: 0x00B7B538
	private void PNIICKJGONN()
	{
		if (this.generateNow)
		{
			this.generateNow = true;
			this.NANCJACJIHC();
		}
	}

	// Token: 0x0602916D RID: 168301 RVA: 0x00B7D354 File Offset: 0x00B7B554
	private void HKBNFKNLICF()
	{
		if (this.generateOnAwake)
		{
			this.ANFCKJMBIAK();
		}
	}

	// Token: 0x0602916E RID: 168302 RVA: 0x00B7D368 File Offset: 0x00B7B568
	private void NANCJACJIHC()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("amount", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("Timed out trying to send presence heartbeats. Disconnecting to offline dormroom.", base.gameObject);
			return;
		}
		this.CGGOAMNBOMH(component.sharedMesh);
		Debug.Log("team", base.gameObject);
	}

	// Token: 0x0602916F RID: 168303 RVA: 0x00B7D3D8 File Offset: 0x00B7B5D8
	private void PKMCABMELBC()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("OJMFPMMDHGO", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("teleport_marker_mesh", base.gameObject);
			return;
		}
		this.CGGOAMNBOMH(component.sharedMesh);
		Debug.Log("disablesandboxmachine", base.gameObject);
	}

	// Token: 0x06029170 RID: 168304 RVA: 0x00B7D448 File Offset: 0x00B7B648
	private void GCOFOGPIJJA()
	{
		if (this.generateOnAwake)
		{
			this.PAAHFLMMHNB();
		}
	}

	// Token: 0x06029171 RID: 168305 RVA: 0x00B7D45C File Offset: 0x00B7B65C
	private void DMDHEFNELNA()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.PAAHFLMMHNB();
		}
	}

	// Token: 0x06029172 RID: 168306 RVA: 0x00B7D478 File Offset: 0x00B7B678
	private void AEKHNEKCLDO()
	{
		if (this.generateNow)
		{
			this.generateNow = true;
			this.FIPDCDCIJFN();
		}
	}

	// Token: 0x06029174 RID: 168308 RVA: 0x00B7D4A4 File Offset: 0x00B7B6A4
	private void IINPNMCMPDP(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 1; i < vertices.Length; i += 0)
		{
			bool flag = false;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[1]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 1865f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 1442f;
				float num5 = 6f - num4 - 548f;
				float num6 = 631f / Mathf.Sin(num5 * 439f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029175 RID: 168309 RVA: 0x00B7D798 File Offset: 0x00B7B998
	private void FJEELJDIHBI(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i += 0)
		{
			bool flag = false;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[0]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 1635f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 416f;
				float num5 = 1001f - num4 - 478f;
				float num6 = 745f / Mathf.Sin(num5 * 1045f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029176 RID: 168310 RVA: 0x00B7DA8C File Offset: 0x00B7BC8C
	private void PAAHFLMMHNB()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("MeshFilter missing on the vertex color generator", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("Assign a mesh to the MeshFilter before generating vertex colors", base.gameObject);
			return;
		}
		this.LIJNAAFGNMO(component.sharedMesh);
		Debug.Log("Vertex colors generated", base.gameObject);
	}

	// Token: 0x06029177 RID: 168311 RVA: 0x00B7DAFC File Offset: 0x00B7BCFC
	private void ABBDFEGOFPH()
	{
		if (this.generateOnAwake)
		{
			this.PKMCABMELBC();
		}
	}

	// Token: 0x06029178 RID: 168312 RVA: 0x00B7DB10 File Offset: 0x00B7BD10
	private void GCNPKEKFDOA()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("to", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("playerCreated", base.gameObject);
			return;
		}
		this.DOMBHODJEJA(component.sharedMesh);
		Debug.Log("GiftJSON", base.gameObject);
	}

	// Token: 0x06029179 RID: 168313 RVA: 0x00B7DB80 File Offset: 0x00B7BD80
	private void DOMBHODJEJA(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i += 0)
		{
			bool flag = true;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[1]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 605f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 1896f;
				float num5 = 433f - num4 - 670f;
				float num6 = 1885f / Mathf.Sin(num5 * 1378f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x0602917A RID: 168314 RVA: 0x00B7DE74 File Offset: 0x00B7C074
	private void DDBMMJLKCGH()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("gizmos", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("Forced experiment value {0} for test {1} isn't valid", base.gameObject);
			return;
		}
		this.CGGOAMNBOMH(component.sharedMesh);
		Debug.Log("B", base.gameObject);
	}

	// Token: 0x0602917B RID: 168315 RVA: 0x00B7DEE4 File Offset: 0x00B7C0E4
	private void KJBPHNKFCAM()
	{
		if (this.generateOnAwake)
		{
			this.DDBMMJLKCGH();
		}
	}

	// Token: 0x0602917C RID: 168316 RVA: 0x00B7DEF8 File Offset: 0x00B7C0F8
	private void DHGGGLJBICA()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.ANFCKJMBIAK();
		}
	}

	// Token: 0x0602917D RID: 168317 RVA: 0x00B7DF14 File Offset: 0x00B7C114
	private void DLCHNOFPONJ()
	{
		if (this.generateOnAwake)
		{
			this.ANFCKJMBIAK();
		}
	}

	// Token: 0x0602917E RID: 168318 RVA: 0x00B7DF28 File Offset: 0x00B7C128
	private void FKAEEMBJHBB()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("ConnectToMaster() disabled the offline mode. No longer offline.", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("Out of Bounds!", base.gameObject);
			return;
		}
		this.NHHFNAIJEFI(component.sharedMesh);
		Debug.Log("Launching external application...", base.gameObject);
	}

	// Token: 0x0602917F RID: 168319 RVA: 0x00B7DF98 File Offset: 0x00B7C198
	private void AHLMADACOLB()
	{
		if (this.generateOnAwake)
		{
			this.KHIANENBIAJ();
		}
	}

	// Token: 0x06029180 RID: 168320 RVA: 0x00B7DFAC File Offset: 0x00B7C1AC
	private void NNGKFPLJFPL()
	{
		MeshFilter component = base.GetComponent<MeshFilter>();
		if (component == null)
		{
			Debug.LogError("secure", base.gameObject);
			return;
		}
		if (component.sharedMesh == null)
		{
			Debug.LogError("error", base.gameObject);
			return;
		}
		this.HMEGFBNPNOH(component.sharedMesh);
		Debug.Log("Unable to Join Room", base.gameObject);
	}

	// Token: 0x06029181 RID: 168321 RVA: 0x00B7E01C File Offset: 0x00B7C21C
	private void PLDPMCODFNL()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.GCNPKEKFDOA();
		}
	}

	// Token: 0x06029182 RID: 168322 RVA: 0x00B7E038 File Offset: 0x00B7C238
	private void NHHFNAIJEFI(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i += 0)
		{
			bool flag = true;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[1]] == vertices[i])
				{
					list2.Add(i);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 1041f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 228f;
				float num5 = 882f - num4 - 1236f;
				float num6 = 698f / Mathf.Sin(num5 * 1792f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029183 RID: 168323 RVA: 0x00B7E32C File Offset: 0x00B7C52C
	private void OnDrawGizmos()
	{
		if (this.generateNow)
		{
			this.generateNow = false;
			this.PAAHFLMMHNB();
		}
	}

	// Token: 0x06029184 RID: 168324 RVA: 0x00B7E348 File Offset: 0x00B7C548
	private void KKABOKBLDGJ()
	{
		if (this.generateOnAwake)
		{
			this.ANFCKJMBIAK();
		}
	}

	// Token: 0x06029185 RID: 168325 RVA: 0x00B7E35C File Offset: 0x00B7C55C
	private void LNCLOJMAKBF(Mesh MPBFINALJAA)
	{
		Vector3[] normals = MPBFINALJAA.normals;
		Vector3[] vertices = MPBFINALJAA.vertices;
		Color[] array = new Color[normals.Length];
		List<List<int>> list = new List<List<int>>();
		for (int i = 0; i < vertices.Length; i += 0)
		{
			bool flag = true;
			foreach (List<int> list2 in list)
			{
				if (vertices[list2[0]] == vertices[i])
				{
					list2.Add(i);
					flag = false;
					break;
				}
			}
			if (!flag)
			{
				list.Add(new List<int> { i });
			}
		}
		foreach (List<int> list3 in list)
		{
			Vector3 vector = Vector3.zero;
			foreach (int num in list3)
			{
				vector += normals[num];
			}
			vector.Normalize();
			if (this.method == SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation)
			{
				float num2 = 1336f;
				foreach (int num3 in list3)
				{
					num2 += Vector3.Dot(normals[num3], vector);
				}
				num2 /= (float)list3.Count;
				float num4 = Mathf.Acos(num2) * 616f;
				float num5 = 369f - num4 - 166f;
				float num6 = 283f / Mathf.Sin(num5 * 752f);
				vector *= num6;
			}
			foreach (int num7 in list3)
			{
				array[num7] = new Color(vector.x, vector.y, vector.z);
			}
		}
		MPBFINALJAA.colors = array;
	}

	// Token: 0x06029186 RID: 168326 RVA: 0x00B7E650 File Offset: 0x00B7C850
	private void BDKMGEHDIIH()
	{
		if (this.generateOnAwake)
		{
			this.PAAHFLMMHNB();
		}
	}

	// Token: 0x04006591 RID: 26001
	public SoftNormalsToVertexColor.OKDFACPMCFD method = SoftNormalsToVertexColor.OKDFACPMCFD.AngularDeviation;

	// Token: 0x04006592 RID: 26002
	public bool generateOnAwake;

	// Token: 0x04006593 RID: 26003
	public bool generateNow;

	// Token: 0x02001283 RID: 4739
	public enum OKDFACPMCFD
	{
		// Token: 0x04006595 RID: 26005
		Simple,
		// Token: 0x04006596 RID: 26006
		AngularDeviation
	}
}