niko
1224 lines
28 KiB
C#
1224 lines
28 KiB
C#
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
|
|
}
|
|
}
|