niko
1139 lines
29 KiB
C#
1139 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using ProBuilder2.Common;
|
|
using UnityEngine;
|
|
|
|
// Token: 0x02000034 RID: 52
|
|
[AddComponentMenu("")]
|
|
[DisallowMultipleComponent]
|
|
[RequireComponent(typeof(MeshFilter))]
|
|
[RequireComponent(typeof(MeshRenderer))]
|
|
[RequireComponent(typeof(pb_Entity))]
|
|
[ExecuteInEditMode]
|
|
public class pb_Object : MonoBehaviour
|
|
{
|
|
// Token: 0x0600015B RID: 347 RVA: 0x000150F4 File Offset: 0x000134F4
|
|
private void Awake()
|
|
{
|
|
if (base.GetComponent<MeshRenderer>().isPartOfStaticBatch)
|
|
{
|
|
return;
|
|
}
|
|
Vector3[] array = ((!(this.msh != null)) ? null : this.msh.normals);
|
|
if (array == null || array.Length != this.msh.vertexCount || (array.Length > 0 && array[0] == Vector3.zero))
|
|
{
|
|
if (this._vertices == null)
|
|
{
|
|
return;
|
|
}
|
|
this.ToMesh();
|
|
this.Refresh(RefreshMask.All);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600015C RID: 348 RVA: 0x00015190 File Offset: 0x00013590
|
|
public static pb_Object InitWithObject(pb_Object pb)
|
|
{
|
|
Vector3[] array = new Vector3[pb.vertexCount];
|
|
Array.Copy(pb.vertices, array, pb.vertexCount);
|
|
Vector2[] array2 = new Vector2[pb.vertexCount];
|
|
Array.Copy(pb.uv, array2, pb.vertexCount);
|
|
Color[] array3 = new Color[pb.vertexCount];
|
|
Array.Copy(pb.colors, array3, pb.vertexCount);
|
|
pb_Face[] array4 = new pb_Face[pb.faces.Length];
|
|
for (int i = 0; i < array4.Length; i++)
|
|
{
|
|
array4[i] = new pb_Face(pb.faces[i]);
|
|
}
|
|
pb_Object pb_Object = pb_Object.CreateInstanceWithElements(array, array2, array3, array4, pb.GetSharedIndices(), pb.GetSharedIndicesUV());
|
|
pb_Object.gameObject.name = pb.gameObject.name + "-clone";
|
|
return pb_Object;
|
|
}
|
|
|
|
// Token: 0x0600015D RID: 349 RVA: 0x0001526C File Offset: 0x0001366C
|
|
public static pb_Object CreateInstanceWithPoints(Vector3[] vertices)
|
|
{
|
|
if (vertices.Length % 4 != 0)
|
|
{
|
|
global::UnityEngine.Debug.LogWarning("Invalid Geometry. Make sure vertices in are pairs of 4 (faces).");
|
|
return null;
|
|
}
|
|
GameObject gameObject = new GameObject();
|
|
pb_Object pb_Object = gameObject.AddComponent<pb_Object>();
|
|
gameObject.name = "ProBuilder Mesh";
|
|
pb_Object.GeometryWithPoints(vertices);
|
|
pb_Object.GetComponent<pb_Entity>().SetEntity(EntityType.Detail);
|
|
return pb_Object;
|
|
}
|
|
|
|
// Token: 0x0600015E RID: 350 RVA: 0x000152BC File Offset: 0x000136BC
|
|
public static pb_Object CreateInstanceWithVerticesFaces(Vector3[] v, pb_Face[] f)
|
|
{
|
|
GameObject gameObject = new GameObject();
|
|
pb_Object pb_Object = gameObject.AddComponent<pb_Object>();
|
|
gameObject.name = "ProBuilder Mesh";
|
|
pb_Object.GeometryWithVerticesFaces(v, f);
|
|
return pb_Object;
|
|
}
|
|
|
|
// Token: 0x0600015F RID: 351 RVA: 0x000152EC File Offset: 0x000136EC
|
|
public static pb_Object CreateInstanceWithElements(Vector3[] v, Vector2[] u, Color[] c, pb_Face[] f, pb_IntArray[] si, pb_IntArray[] si_uv)
|
|
{
|
|
GameObject gameObject = new GameObject();
|
|
pb_Object pb_Object = gameObject.AddComponent<pb_Object>();
|
|
pb_Object.SetVertices(v);
|
|
pb_Object.SetUV(u);
|
|
pb_Object.SetColors(c);
|
|
pb_Object.SetSharedIndices(si ?? pb_IntArrayUtility.ExtractSharedIndices(v));
|
|
pb_Object.SetSharedIndicesUV(si_uv ?? new pb_IntArray[0]);
|
|
pb_Object.SetFaces(f);
|
|
pb_Object.ToMesh();
|
|
pb_Object.Refresh(RefreshMask.All);
|
|
pb_Object.GetComponent<pb_Entity>().SetEntity(EntityType.Detail);
|
|
return pb_Object;
|
|
}
|
|
|
|
// Token: 0x06000160 RID: 352 RVA: 0x0001536C File Offset: 0x0001376C
|
|
public static pb_Object CreateInstanceWithElements(pb_Vertex[] vertices, pb_Face[] faces, pb_IntArray[] si, pb_IntArray[] si_uv)
|
|
{
|
|
GameObject gameObject = new GameObject();
|
|
pb_Object pb_Object = gameObject.AddComponent<pb_Object>();
|
|
Vector3[] array;
|
|
Color[] array2;
|
|
Vector2[] array3;
|
|
Vector3[] array4;
|
|
Vector4[] array5;
|
|
Vector2[] array6;
|
|
List<Vector4> list;
|
|
List<Vector4> list2;
|
|
pb_Vertex.GetArrays(vertices, out array, out array2, out array3, out array4, out array5, out array6, out list, out list2);
|
|
pb_Object.SetVertices(array);
|
|
pb_Object.SetColors(array2);
|
|
pb_Object.SetUV(array3);
|
|
if (list != null)
|
|
{
|
|
pb_Object._uv3 = list;
|
|
}
|
|
if (list2 != null)
|
|
{
|
|
pb_Object._uv4 = list2;
|
|
}
|
|
pb_Object.SetSharedIndices(si ?? pb_IntArrayUtility.ExtractSharedIndices(array));
|
|
pb_Object.SetSharedIndicesUV(si_uv ?? new pb_IntArray[0]);
|
|
pb_Object.SetFaces(faces);
|
|
pb_Object.ToMesh();
|
|
pb_Object.Refresh(RefreshMask.All);
|
|
pb_Object.GetComponent<pb_Entity>().SetEntity(EntityType.Detail);
|
|
return pb_Object;
|
|
}
|
|
|
|
// Token: 0x17000019 RID: 25
|
|
// (get) Token: 0x06000161 RID: 353 RVA: 0x0001541D File Offset: 0x0001381D
|
|
private pb_Face[] _faces
|
|
{
|
|
get
|
|
{
|
|
return this._quads;
|
|
}
|
|
}
|
|
|
|
// Token: 0x14000001 RID: 1
|
|
// (add) Token: 0x06000162 RID: 354 RVA: 0x00015428 File Offset: 0x00013828
|
|
// (remove) Token: 0x06000163 RID: 355 RVA: 0x0001545C File Offset: 0x0001385C
|
|
[field: DebuggerBrowsable(DebuggerBrowsableState.Never)]
|
|
public static event Action<pb_Object> onDestroyObject;
|
|
|
|
// Token: 0x1700001A RID: 26
|
|
// (get) Token: 0x06000164 RID: 356 RVA: 0x00015490 File Offset: 0x00013890
|
|
// (set) Token: 0x06000165 RID: 357 RVA: 0x0001549D File Offset: 0x0001389D
|
|
public Mesh msh
|
|
{
|
|
get
|
|
{
|
|
return base.GetComponent<MeshFilter>().sharedMesh;
|
|
}
|
|
set
|
|
{
|
|
base.gameObject.GetComponent<MeshFilter>().sharedMesh = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001B RID: 27
|
|
// (get) Token: 0x06000166 RID: 358 RVA: 0x000154B0 File Offset: 0x000138B0
|
|
public pb_Face[] faces
|
|
{
|
|
get
|
|
{
|
|
return this._quads;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001C RID: 28
|
|
// (get) Token: 0x06000167 RID: 359 RVA: 0x000154B8 File Offset: 0x000138B8
|
|
public pb_Face[] quads
|
|
{
|
|
get
|
|
{
|
|
global::UnityEngine.Debug.LogWarning("pb_Quad is deprecated. Please use pb_Face instead.");
|
|
return this._quads;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001D RID: 29
|
|
// (get) Token: 0x06000168 RID: 360 RVA: 0x000154CA File Offset: 0x000138CA
|
|
public pb_IntArray[] sharedIndices
|
|
{
|
|
get
|
|
{
|
|
return this._sharedIndices;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001E RID: 30
|
|
// (get) Token: 0x06000169 RID: 361 RVA: 0x000154D2 File Offset: 0x000138D2
|
|
public pb_IntArray[] sharedIndicesUV
|
|
{
|
|
get
|
|
{
|
|
return this._sharedIndicesUV;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001F RID: 31
|
|
// (get) Token: 0x0600016A RID: 362 RVA: 0x000154DA File Offset: 0x000138DA
|
|
public int id
|
|
{
|
|
get
|
|
{
|
|
return base.gameObject.GetInstanceID();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000020 RID: 32
|
|
// (get) Token: 0x0600016B RID: 363 RVA: 0x000154E7 File Offset: 0x000138E7
|
|
public Vector3[] vertices
|
|
{
|
|
get
|
|
{
|
|
return this._vertices;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000021 RID: 33
|
|
// (get) Token: 0x0600016C RID: 364 RVA: 0x000154EF File Offset: 0x000138EF
|
|
public Color[] colors
|
|
{
|
|
get
|
|
{
|
|
return this._colors;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000022 RID: 34
|
|
// (get) Token: 0x0600016D RID: 365 RVA: 0x000154F7 File Offset: 0x000138F7
|
|
public Vector2[] uv
|
|
{
|
|
get
|
|
{
|
|
return this._uv;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000023 RID: 35
|
|
// (get) Token: 0x0600016E RID: 366 RVA: 0x000154FF File Offset: 0x000138FF
|
|
public bool hasUv3
|
|
{
|
|
get
|
|
{
|
|
return this._uv3 != null && this._uv3.Count == this.vertexCount;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000024 RID: 36
|
|
// (get) Token: 0x0600016F RID: 367 RVA: 0x00015522 File Offset: 0x00013922
|
|
public bool hasUv4
|
|
{
|
|
get
|
|
{
|
|
return this._uv4 != null && this._uv4.Count == this.vertexCount;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000025 RID: 37
|
|
// (get) Token: 0x06000170 RID: 368 RVA: 0x00015545 File Offset: 0x00013945
|
|
public List<Vector4> uv3
|
|
{
|
|
get
|
|
{
|
|
return this._uv3;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000026 RID: 38
|
|
// (get) Token: 0x06000171 RID: 369 RVA: 0x0001554D File Offset: 0x0001394D
|
|
public List<Vector4> uv4
|
|
{
|
|
get
|
|
{
|
|
return this._uv4;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000027 RID: 39
|
|
// (get) Token: 0x06000172 RID: 370 RVA: 0x00015555 File Offset: 0x00013955
|
|
public int faceCount
|
|
{
|
|
get
|
|
{
|
|
return (this._faces != null) ? this._faces.Length : 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000028 RID: 40
|
|
// (get) Token: 0x06000173 RID: 371 RVA: 0x00015570 File Offset: 0x00013970
|
|
public int vertexCount
|
|
{
|
|
get
|
|
{
|
|
return (this._vertices != null) ? this._vertices.Length : 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000029 RID: 41
|
|
// (get) Token: 0x06000174 RID: 372 RVA: 0x0001558B File Offset: 0x0001398B
|
|
public int triangleCount
|
|
{
|
|
get
|
|
{
|
|
int num;
|
|
if (this._faces == null)
|
|
{
|
|
num = 0;
|
|
}
|
|
else
|
|
{
|
|
num = this._faces.Sum((pb_Face x) => x.indices.Length);
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000175 RID: 373 RVA: 0x000155C8 File Offset: 0x000139C8
|
|
public pb_IntArray[] GetSharedIndices()
|
|
{
|
|
int num = this._sharedIndices.Length;
|
|
pb_IntArray[] array = new pb_IntArray[num];
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
int[] array2 = new int[this._sharedIndices[i].Length];
|
|
Array.Copy(this._sharedIndices[i].array, array2, array2.Length);
|
|
array[i] = new pb_IntArray(array2);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06000176 RID: 374 RVA: 0x0001562C File Offset: 0x00013A2C
|
|
public pb_IntArray[] GetSharedIndicesUV()
|
|
{
|
|
int num = this._sharedIndicesUV.Length;
|
|
pb_IntArray[] array = new pb_IntArray[num];
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
int[] array2 = new int[this._sharedIndicesUV[i].Length];
|
|
Array.Copy(this._sharedIndicesUV[i].array, array2, array2.Length);
|
|
array[i] = new pb_IntArray(array2);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x1700002A RID: 42
|
|
// (get) Token: 0x06000177 RID: 375 RVA: 0x0001568E File Offset: 0x00013A8E
|
|
public pb_Face[] SelectedFaces
|
|
{
|
|
get
|
|
{
|
|
return this.faces.ValuesWithIndices(this.m_selectedFaces);
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002B RID: 43
|
|
// (get) Token: 0x06000178 RID: 376 RVA: 0x000156A1 File Offset: 0x00013AA1
|
|
public int SelectedFaceCount
|
|
{
|
|
get
|
|
{
|
|
return this.m_selectedFaces.Length;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002C RID: 44
|
|
// (get) Token: 0x06000179 RID: 377 RVA: 0x000156AB File Offset: 0x00013AAB
|
|
public int[] SelectedTriangles
|
|
{
|
|
get
|
|
{
|
|
return this.m_selectedTriangles;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002D RID: 45
|
|
// (get) Token: 0x0600017A RID: 378 RVA: 0x000156B3 File Offset: 0x00013AB3
|
|
public int SelectedTriangleCount
|
|
{
|
|
get
|
|
{
|
|
return this.m_selectedTriangles.Length;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002E RID: 46
|
|
// (get) Token: 0x0600017B RID: 379 RVA: 0x000156BD File Offset: 0x00013ABD
|
|
public pb_Edge[] SelectedEdges
|
|
{
|
|
get
|
|
{
|
|
return this.m_SelectedEdges;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002F RID: 47
|
|
// (get) Token: 0x0600017C RID: 380 RVA: 0x000156C5 File Offset: 0x00013AC5
|
|
public int SelectedEdgeCount
|
|
{
|
|
get
|
|
{
|
|
return this.m_SelectedEdges.Length;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600017D RID: 381 RVA: 0x000156D0 File Offset: 0x00013AD0
|
|
public void AddToFaceSelection(pb_Face face)
|
|
{
|
|
int num = Array.IndexOf<pb_Face>(this.faces, face);
|
|
if (num > -1)
|
|
{
|
|
this.SetSelectedFaces(this.m_selectedFaces.Add(num));
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600017E RID: 382 RVA: 0x00015704 File Offset: 0x00013B04
|
|
public void SetSelectedFaces(IEnumerable<pb_Face> selected)
|
|
{
|
|
List<int> list = new List<int>();
|
|
foreach (pb_Face pb_Face in selected)
|
|
{
|
|
int num = Array.IndexOf<pb_Face>(this.faces, pb_Face);
|
|
if (num > -1)
|
|
{
|
|
list.Add(num);
|
|
}
|
|
}
|
|
this.SetSelectedFaces(list);
|
|
}
|
|
|
|
// Token: 0x0600017F RID: 383 RVA: 0x0001577C File Offset: 0x00013B7C
|
|
public void SetSelectedFaces(IEnumerable<int> selected)
|
|
{
|
|
this.m_selectedFaces = selected.ToArray<int>();
|
|
this.m_selectedTriangles = pb_Face.AllTriangles(this.SelectedFaces);
|
|
pb_Edge[] array = pb_Edge.AllEdges(this.SelectedFaces);
|
|
int num = array.Length;
|
|
this.m_SelectedEdges = new pb_Edge[num];
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
this.m_SelectedEdges[i] = new pb_Edge(array[i]);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000180 RID: 384 RVA: 0x000157E4 File Offset: 0x00013BE4
|
|
public void SetSelectedEdges(IEnumerable<pb_Edge> edges)
|
|
{
|
|
this.m_selectedFaces = new int[0];
|
|
this.m_SelectedEdges = edges.Select((pb_Edge x) => new pb_Edge(x)).ToArray<pb_Edge>();
|
|
this.m_selectedTriangles = this.m_SelectedEdges.AllTriangles();
|
|
}
|
|
|
|
// Token: 0x06000181 RID: 385 RVA: 0x0001583C File Offset: 0x00013C3C
|
|
public void SetSelectedTriangles(int[] tris)
|
|
{
|
|
this.m_selectedFaces = new int[0];
|
|
this.m_SelectedEdges = new pb_Edge[0];
|
|
this.m_selectedTriangles = tris ?? new int[0];
|
|
}
|
|
|
|
// Token: 0x06000182 RID: 386 RVA: 0x0001586A File Offset: 0x00013C6A
|
|
public void RemoveFromFaceSelectionAtIndex(int index)
|
|
{
|
|
this.SetSelectedFaces(this.m_selectedFaces.RemoveAt(index));
|
|
}
|
|
|
|
// Token: 0x06000183 RID: 387 RVA: 0x00015880 File Offset: 0x00013C80
|
|
public void RemoveFromFaceSelection(pb_Face face)
|
|
{
|
|
int num = Array.IndexOf<pb_Face>(this.faces, face);
|
|
if (num > -1)
|
|
{
|
|
this.SetSelectedFaces(this.m_selectedFaces.Remove(num));
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000184 RID: 388 RVA: 0x000158B3 File Offset: 0x00013CB3
|
|
public void ClearSelection()
|
|
{
|
|
this.m_selectedFaces = new int[0];
|
|
this.m_SelectedEdges = new pb_Edge[0];
|
|
this.m_selectedTriangles = new int[0];
|
|
}
|
|
|
|
// Token: 0x06000185 RID: 389 RVA: 0x000158D9 File Offset: 0x00013CD9
|
|
public void SetVertices(Vector3[] v)
|
|
{
|
|
this._vertices = v;
|
|
}
|
|
|
|
// Token: 0x06000186 RID: 390 RVA: 0x000158E4 File Offset: 0x00013CE4
|
|
public void SetVertices(IList<pb_Vertex> vertices, bool applyMesh = false)
|
|
{
|
|
Vector3[] array;
|
|
Color[] array2;
|
|
Vector2[] array3;
|
|
Vector3[] array4;
|
|
Vector4[] array5;
|
|
Vector2[] array6;
|
|
List<Vector4> list;
|
|
List<Vector4> list2;
|
|
pb_Vertex.GetArrays(vertices, out array, out array2, out array3, out array4, out array5, out array6, out list, out list2);
|
|
this.SetVertices(array);
|
|
this.SetColors(array2);
|
|
this.SetUV(array3);
|
|
if (list != null)
|
|
{
|
|
this._uv3 = list;
|
|
}
|
|
if (list2 != null)
|
|
{
|
|
this._uv4 = list2;
|
|
}
|
|
if (applyMesh)
|
|
{
|
|
Mesh msh = this.msh;
|
|
pb_Vertex pb_Vertex = vertices[0];
|
|
if (pb_Vertex.hasPosition)
|
|
{
|
|
msh.vertices = array;
|
|
}
|
|
if (pb_Vertex.hasColor)
|
|
{
|
|
msh.colors = array2;
|
|
}
|
|
if (pb_Vertex.hasUv0)
|
|
{
|
|
msh.uv = array3;
|
|
}
|
|
if (pb_Vertex.hasNormal)
|
|
{
|
|
msh.normals = array4;
|
|
}
|
|
if (pb_Vertex.hasTangent)
|
|
{
|
|
msh.tangents = array5;
|
|
}
|
|
if (pb_Vertex.hasUv2)
|
|
{
|
|
msh.uv2 = array6;
|
|
}
|
|
if (pb_Vertex.hasUv3 && list != null)
|
|
{
|
|
msh.SetUVs(2, list);
|
|
}
|
|
if (pb_Vertex.hasUv4 && list2 != null)
|
|
{
|
|
msh.SetUVs(3, list2);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000187 RID: 391 RVA: 0x00015A05 File Offset: 0x00013E05
|
|
public void SetUV(Vector2[] uvs)
|
|
{
|
|
this._uv = uvs;
|
|
}
|
|
|
|
// Token: 0x06000188 RID: 392 RVA: 0x00015A10 File Offset: 0x00013E10
|
|
public void SetFaces(pb_Face[] _qds)
|
|
{
|
|
this._quads = _qds.Where((pb_Face x) => x != null).ToArray<pb_Face>();
|
|
if (this._quads.Length != _qds.Length)
|
|
{
|
|
global::UnityEngine.Debug.LogWarning("SetFaces() pruned " + (_qds.Length - this._quads.Length) + " null faces from this object.");
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000189 RID: 393 RVA: 0x00015A80 File Offset: 0x00013E80
|
|
public void SetSharedIndices(pb_IntArray[] si)
|
|
{
|
|
this._sharedIndices = si;
|
|
}
|
|
|
|
// Token: 0x0600018A RID: 394 RVA: 0x00015A89 File Offset: 0x00013E89
|
|
public void SetSharedIndices(IEnumerable<KeyValuePair<int, int>> si)
|
|
{
|
|
this._sharedIndices = si.ToSharedIndices();
|
|
}
|
|
|
|
// Token: 0x0600018B RID: 395 RVA: 0x00015A97 File Offset: 0x00013E97
|
|
public void SetSharedIndicesUV(pb_IntArray[] si)
|
|
{
|
|
this._sharedIndicesUV = si;
|
|
}
|
|
|
|
// Token: 0x0600018C RID: 396 RVA: 0x00015AA0 File Offset: 0x00013EA0
|
|
public void SetSharedIndicesUV(IEnumerable<KeyValuePair<int, int>> si)
|
|
{
|
|
this._sharedIndicesUV = si.ToSharedIndices();
|
|
}
|
|
|
|
// Token: 0x0600018D RID: 397 RVA: 0x00015AB0 File Offset: 0x00013EB0
|
|
private void GeometryWithPoints(Vector3[] v)
|
|
{
|
|
pb_Face[] array = new pb_Face[v.Length / 4];
|
|
for (int i = 0; i < v.Length; i += 4)
|
|
{
|
|
array[i / 4] = new pb_Face(new int[]
|
|
{
|
|
i,
|
|
i + 1,
|
|
i + 2,
|
|
i + 1,
|
|
i + 3,
|
|
i + 2
|
|
}, pb_Constant.DefaultMaterial, new pb_UV(), 0, -1, -1, false);
|
|
}
|
|
this.SetVertices(v);
|
|
this.SetUV(new Vector2[v.Length]);
|
|
this.SetColors(pbUtil.FilledArray<Color>(Color.white, v.Length));
|
|
this.SetFaces(array);
|
|
this.SetSharedIndices(pb_IntArrayUtility.ExtractSharedIndices(v));
|
|
this.ToMesh();
|
|
this.Refresh(RefreshMask.All);
|
|
}
|
|
|
|
// Token: 0x0600018E RID: 398 RVA: 0x00015B68 File Offset: 0x00013F68
|
|
public void GeometryWithVerticesFaces(Vector3[] v, pb_Face[] f)
|
|
{
|
|
this.SetVertices(v);
|
|
this.SetUV(new Vector2[v.Length]);
|
|
this.SetFaces(f);
|
|
this.SetSharedIndices(pb_IntArrayUtility.ExtractSharedIndices(v));
|
|
this.ToMesh();
|
|
this.Refresh(RefreshMask.All);
|
|
}
|
|
|
|
// Token: 0x0600018F RID: 399 RVA: 0x00015BA4 File Offset: 0x00013FA4
|
|
private void GeometryWithVerticesFacesIndices(Vector3[] v, pb_Face[] f, pb_IntArray[] s)
|
|
{
|
|
this.SetFaces(f);
|
|
this.SetVertices(v);
|
|
this.SetUV(new Vector2[v.Length]);
|
|
this.SetSharedIndices(s);
|
|
if (this.msh != null)
|
|
{
|
|
global::UnityEngine.Object.DestroyImmediate(this.msh);
|
|
}
|
|
this.ToMesh();
|
|
this.Refresh(RefreshMask.All);
|
|
}
|
|
|
|
// Token: 0x06000190 RID: 400 RVA: 0x00015C04 File Offset: 0x00014004
|
|
public MeshRebuildReason Verify()
|
|
{
|
|
if (this.msh == null)
|
|
{
|
|
try
|
|
{
|
|
this.ToMesh();
|
|
this.Refresh(RefreshMask.All);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
global::UnityEngine.Debug.LogError("Failed rebuilding null pb_Object. Cached mesh attributes are invalid or missing.\n" + ex.ToString());
|
|
}
|
|
return MeshRebuildReason.Null;
|
|
}
|
|
int num;
|
|
int.TryParse(this.msh.name.Replace("pb_Mesh", string.Empty), out num);
|
|
if (num != this.id)
|
|
{
|
|
return MeshRebuildReason.InstanceIDMismatch;
|
|
}
|
|
return (this.msh.uv2 != null) ? MeshRebuildReason.None : MeshRebuildReason.Lightmap;
|
|
}
|
|
|
|
// Token: 0x06000191 RID: 401 RVA: 0x00015CAC File Offset: 0x000140AC
|
|
public void ToMesh()
|
|
{
|
|
Mesh mesh = this.msh;
|
|
if (mesh != null && mesh.vertexCount == this._vertices.Length)
|
|
{
|
|
mesh = this.msh;
|
|
mesh.vertices = this._vertices;
|
|
if (this._uv != null)
|
|
{
|
|
mesh.uv = this._uv;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mesh == null)
|
|
{
|
|
mesh = new Mesh();
|
|
}
|
|
else
|
|
{
|
|
mesh.Clear();
|
|
}
|
|
mesh.vertices = this._vertices;
|
|
}
|
|
mesh.uv2 = null;
|
|
int[][] array;
|
|
Material[] array2;
|
|
mesh.subMeshCount = pb_Face.MeshTriangles(this.faces, out array, out array2);
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
mesh.SetTriangles(array[i], i);
|
|
}
|
|
mesh.name = "pb_Mesh" + this.id;
|
|
base.GetComponent<MeshFilter>().sharedMesh = mesh;
|
|
base.GetComponent<MeshRenderer>().sharedMaterials = array2;
|
|
}
|
|
|
|
// Token: 0x06000192 RID: 402 RVA: 0x00015DA4 File Offset: 0x000141A4
|
|
public void MakeUnique()
|
|
{
|
|
pb_Face[] array = new pb_Face[this._faces.Length];
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
array[i] = new pb_Face(this._faces[i]);
|
|
}
|
|
pb_IntArray[] array2 = new pb_IntArray[this._sharedIndices.Length];
|
|
Array.Copy(this._sharedIndices, array2, array2.Length);
|
|
this.SetSharedIndices(array2);
|
|
this.SetFaces(array);
|
|
Vector3[] array3 = new Vector3[this.vertexCount];
|
|
Array.Copy(this._vertices, array3, this.vertexCount);
|
|
this.SetVertices(array3);
|
|
if (this._uv != null && this._uv.Length == this.vertexCount)
|
|
{
|
|
Vector2[] array4 = new Vector2[this.vertexCount];
|
|
Array.Copy(this._uv, array4, this.vertexCount);
|
|
this.SetUV(array4);
|
|
}
|
|
this.msh = new Mesh();
|
|
this.ToMesh();
|
|
this.Refresh(RefreshMask.All);
|
|
}
|
|
|
|
// Token: 0x06000193 RID: 403 RVA: 0x00015E98 File Offset: 0x00014298
|
|
public void Refresh(RefreshMask mask = RefreshMask.All)
|
|
{
|
|
if ((ushort)(mask & RefreshMask.UV) > 0)
|
|
{
|
|
this.RefreshUV();
|
|
}
|
|
if ((ushort)(mask & RefreshMask.Colors) > 0)
|
|
{
|
|
this.RefreshColors();
|
|
}
|
|
if ((ushort)(mask & RefreshMask.Normals) > 0)
|
|
{
|
|
this.RefreshNormals();
|
|
}
|
|
if ((ushort)(mask & RefreshMask.Tangents) > 0)
|
|
{
|
|
this.RefreshTangents();
|
|
}
|
|
if ((ushort)(mask & RefreshMask.Collisions) > 0)
|
|
{
|
|
this.RefreshCollisions();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000194 RID: 404 RVA: 0x00015EF8 File Offset: 0x000142F8
|
|
public void RefreshCollisions()
|
|
{
|
|
Mesh msh = this.msh;
|
|
msh.RecalculateBounds();
|
|
if (!this.userCollisions && base.GetComponent<Collider>())
|
|
{
|
|
foreach (Collider collider in base.gameObject.GetComponents<Collider>())
|
|
{
|
|
Type type = collider.GetType();
|
|
if (type == typeof(BoxCollider))
|
|
{
|
|
((BoxCollider)collider).center = msh.bounds.center;
|
|
((BoxCollider)collider).size = msh.bounds.size;
|
|
}
|
|
else if (type == typeof(SphereCollider))
|
|
{
|
|
((SphereCollider)collider).center = msh.bounds.center;
|
|
((SphereCollider)collider).radius = pb_Math.LargestValue(msh.bounds.extents);
|
|
}
|
|
else if (type == typeof(CapsuleCollider))
|
|
{
|
|
((CapsuleCollider)collider).center = msh.bounds.center;
|
|
Vector2 vector = new Vector2(msh.bounds.extents.x, msh.bounds.extents.z);
|
|
((CapsuleCollider)collider).radius = pb_Math.LargestValue(vector);
|
|
((CapsuleCollider)collider).height = msh.bounds.size.y;
|
|
}
|
|
else if (type == typeof(WheelCollider))
|
|
{
|
|
((WheelCollider)collider).center = msh.bounds.center;
|
|
((WheelCollider)collider).radius = pb_Math.LargestValue(msh.bounds.extents);
|
|
}
|
|
else if (type == typeof(MeshCollider))
|
|
{
|
|
base.gameObject.GetComponent<MeshCollider>().sharedMesh = null;
|
|
base.gameObject.GetComponent<MeshCollider>().sharedMesh = msh;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000195 RID: 405 RVA: 0x00016110 File Offset: 0x00014510
|
|
public int GetUnusedTextureGroup(int i = 1)
|
|
{
|
|
while (Array.Exists<pb_Face>(this.faces, (pb_Face element) => element.textureGroup == i))
|
|
{
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
// Token: 0x06000196 RID: 406 RVA: 0x00016160 File Offset: 0x00014560
|
|
public int UnusedElementGroup(int i = 1)
|
|
{
|
|
while (Array.Exists<pb_Face>(this.faces, (pb_Face element) => element.elementGroup == i))
|
|
{
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
// Token: 0x06000197 RID: 407 RVA: 0x000161AF File Offset: 0x000145AF
|
|
public void RefreshUV()
|
|
{
|
|
this.RefreshUV(this.faces);
|
|
}
|
|
|
|
// Token: 0x06000198 RID: 408 RVA: 0x000161C0 File Offset: 0x000145C0
|
|
public void GetUVs(int channel, List<Vector4> uvs)
|
|
{
|
|
uvs.Clear();
|
|
switch (channel)
|
|
{
|
|
default:
|
|
{
|
|
for (int i = 0; i < this.vertexCount; i++)
|
|
{
|
|
uvs.Add(this._uv[i]);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
if (this.msh != null && this.msh.uv2 != null)
|
|
{
|
|
Vector2[] uv = this.msh.uv2;
|
|
for (int j = 0; j < uv.Length; j++)
|
|
{
|
|
uvs.Add(uv[j]);
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
if (this._uv3 != null)
|
|
{
|
|
uvs.AddRange(this._uv3);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (this._uv4 != null)
|
|
{
|
|
uvs.AddRange(this._uv4);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000199 RID: 409 RVA: 0x000162BC File Offset: 0x000146BC
|
|
public void SetUVs(int channel, List<Vector4> uvs)
|
|
{
|
|
switch (channel)
|
|
{
|
|
case 1:
|
|
this.msh.uv2 = uvs.Cast<Vector2>().ToArray<Vector2>();
|
|
return;
|
|
case 2:
|
|
this._uv3 = uvs;
|
|
return;
|
|
case 3:
|
|
this._uv4 = uvs;
|
|
return;
|
|
}
|
|
this._uv = uvs.Cast<Vector2>().ToArray<Vector2>();
|
|
}
|
|
|
|
// Token: 0x0600019A RID: 410 RVA: 0x00016330 File Offset: 0x00014730
|
|
public void RefreshUV(IEnumerable<pb_Face> facesToRefresh)
|
|
{
|
|
Vector2[] uv = this.msh.uv;
|
|
Vector2[] array;
|
|
if (this._uv != null && this._uv.Length == this.vertexCount)
|
|
{
|
|
array = this._uv;
|
|
}
|
|
else if (uv != null && uv.Length == this.vertexCount)
|
|
{
|
|
array = uv;
|
|
}
|
|
else
|
|
{
|
|
foreach (pb_Face pb_Face in this.faces)
|
|
{
|
|
pb_Face.manualUV = false;
|
|
}
|
|
facesToRefresh = this.faces;
|
|
array = new Vector2[this.vertexCount];
|
|
}
|
|
int num = -2;
|
|
Dictionary<int, List<pb_Face>> dictionary = new Dictionary<int, List<pb_Face>>();
|
|
bool flag = false;
|
|
foreach (pb_Face pb_Face2 in facesToRefresh)
|
|
{
|
|
if (pb_Face2.uv.useWorldSpace)
|
|
{
|
|
flag = true;
|
|
}
|
|
if (pb_Face2 != null && !pb_Face2.manualUV)
|
|
{
|
|
List<pb_Face> list;
|
|
if (pb_Face2.textureGroup > 0 && dictionary.TryGetValue(pb_Face2.textureGroup, out list))
|
|
{
|
|
list.Add(pb_Face2);
|
|
}
|
|
else
|
|
{
|
|
Dictionary<int, List<pb_Face>> dictionary2 = dictionary;
|
|
int num2;
|
|
if (pb_Face2.textureGroup > 0)
|
|
{
|
|
num2 = pb_Face2.textureGroup;
|
|
}
|
|
else
|
|
{
|
|
num = (num2 = num) - 1;
|
|
}
|
|
dictionary2.Add(num2, new List<pb_Face> { pb_Face2 });
|
|
}
|
|
}
|
|
}
|
|
if (this.faces.Length != facesToRefresh.Count<pb_Face>())
|
|
{
|
|
foreach (pb_Face pb_Face3 in this.faces)
|
|
{
|
|
if (!pb_Face3.manualUV)
|
|
{
|
|
if (dictionary.ContainsKey(pb_Face3.textureGroup) && !dictionary[pb_Face3.textureGroup].Contains(pb_Face3))
|
|
{
|
|
dictionary[pb_Face3.textureGroup].Add(pb_Face3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
num = 0;
|
|
Vector3[] array2 = ((!flag) ? null : base.transform.ToWorldSpace(this.vertices));
|
|
foreach (KeyValuePair<int, List<pb_Face>> keyValuePair in dictionary)
|
|
{
|
|
int[] array3 = pb_Face.AllTrianglesDistinct(keyValuePair.Value).ToArray();
|
|
Vector3 vector;
|
|
if (keyValuePair.Value.Count > 1)
|
|
{
|
|
vector = pb_Projection.FindBestPlane(this._vertices, array3).normal;
|
|
}
|
|
else
|
|
{
|
|
vector = pb_Math.Normal(this, keyValuePair.Value[0]);
|
|
}
|
|
if (keyValuePair.Value[0].uv.useWorldSpace)
|
|
{
|
|
pb_UVUtility.PlanarMap2(array2, array, array3, keyValuePair.Value[0].uv, base.transform.TransformDirection(vector));
|
|
}
|
|
else
|
|
{
|
|
pb_UVUtility.PlanarMap2(this.vertices, array, array3, keyValuePair.Value[0].uv, vector);
|
|
}
|
|
Vector2 localPivot = keyValuePair.Value[0].uv.localPivot;
|
|
foreach (pb_Face pb_Face4 in keyValuePair.Value)
|
|
{
|
|
pb_Face4.uv.localPivot = localPivot;
|
|
}
|
|
}
|
|
this._uv = array;
|
|
this.msh.uv = array;
|
|
}
|
|
|
|
// Token: 0x0600019B RID: 411 RVA: 0x00016714 File Offset: 0x00014B14
|
|
public void SetFaceMaterial(pb_Face[] quad, Material mat)
|
|
{
|
|
for (int i = 0; i < quad.Length; i++)
|
|
{
|
|
quad[i].material = mat;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600019C RID: 412 RVA: 0x0001673E File Offset: 0x00014B3E
|
|
public void SetUV2(Vector2[] v)
|
|
{
|
|
base.GetComponent<MeshFilter>().sharedMesh.uv2 = v;
|
|
}
|
|
|
|
// Token: 0x0600019D RID: 413 RVA: 0x00016754 File Offset: 0x00014B54
|
|
public void RefreshColors()
|
|
{
|
|
Mesh sharedMesh = base.GetComponent<MeshFilter>().sharedMesh;
|
|
if (this._colors == null || this._colors.Length != this.vertexCount)
|
|
{
|
|
this._colors = pbUtil.FilledArray<Color>(Color.white, this.vertexCount);
|
|
}
|
|
sharedMesh.colors = this._colors;
|
|
}
|
|
|
|
// Token: 0x0600019E RID: 414 RVA: 0x000167AD File Offset: 0x00014BAD
|
|
public void SetColors(Color[] InColors)
|
|
{
|
|
this._colors = ((InColors.Length != this.vertexCount) ? pbUtil.FilledArray<Color>(Color.white, this.vertexCount) : InColors);
|
|
}
|
|
|
|
// Token: 0x0600019F RID: 415 RVA: 0x000167DC File Offset: 0x00014BDC
|
|
public void SetFaceColor(pb_Face face, Color color)
|
|
{
|
|
if (this._colors == null)
|
|
{
|
|
this._colors = pbUtil.FilledArray<Color>(Color.white, this.vertexCount);
|
|
}
|
|
foreach (int num in face.distinctIndices)
|
|
{
|
|
this._colors[num] = color;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001A0 RID: 416 RVA: 0x0001683B File Offset: 0x00014C3B
|
|
public void SetTangents(Vector4[] tangents)
|
|
{
|
|
this._tangents = tangents;
|
|
}
|
|
|
|
// Token: 0x060001A1 RID: 417 RVA: 0x00016844 File Offset: 0x00014C44
|
|
public void RefreshNormals()
|
|
{
|
|
this.msh.RecalculateNormals();
|
|
Vector3[] normals = this.msh.normals;
|
|
pb_MeshUtility.SmoothNormals(this, ref normals);
|
|
base.GetComponent<MeshFilter>().sharedMesh.normals = normals;
|
|
}
|
|
|
|
// Token: 0x060001A2 RID: 418 RVA: 0x00016884 File Offset: 0x00014C84
|
|
public void RefreshTangents()
|
|
{
|
|
Mesh sharedMesh = base.GetComponent<MeshFilter>().sharedMesh;
|
|
if (this._tangents != null && this._tangents.Length == this.vertexCount)
|
|
{
|
|
sharedMesh.tangents = this._tangents;
|
|
}
|
|
else
|
|
{
|
|
pb_MeshUtility.GenerateTangent(ref sharedMesh);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001A3 RID: 419 RVA: 0x000168D4 File Offset: 0x00014CD4
|
|
public void OnDestroy()
|
|
{
|
|
if (!this.dontDestroyMeshOnDelete && Application.isEditor && !Application.isPlaying && Time.frameCount > 0)
|
|
{
|
|
if (pb_Object.onDestroyObject != null)
|
|
{
|
|
pb_Object.onDestroyObject(this);
|
|
}
|
|
else
|
|
{
|
|
global::UnityEngine.Object.DestroyImmediate(base.gameObject.GetComponent<MeshFilter>().sharedMesh, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x04000132 RID: 306
|
|
[SerializeField]
|
|
private pb_Face[] _quads;
|
|
|
|
// Token: 0x04000133 RID: 307
|
|
[SerializeField]
|
|
private pb_IntArray[] _sharedIndices;
|
|
|
|
// Token: 0x04000134 RID: 308
|
|
[SerializeField]
|
|
private Vector3[] _vertices;
|
|
|
|
// Token: 0x04000135 RID: 309
|
|
[SerializeField]
|
|
private Vector2[] _uv;
|
|
|
|
// Token: 0x04000136 RID: 310
|
|
[SerializeField]
|
|
private List<Vector4> _uv3;
|
|
|
|
// Token: 0x04000137 RID: 311
|
|
[SerializeField]
|
|
private List<Vector4> _uv4;
|
|
|
|
// Token: 0x04000138 RID: 312
|
|
[SerializeField]
|
|
private Vector4[] _tangents;
|
|
|
|
// Token: 0x04000139 RID: 313
|
|
[SerializeField]
|
|
private pb_IntArray[] _sharedIndicesUV = new pb_IntArray[0];
|
|
|
|
// Token: 0x0400013A RID: 314
|
|
[SerializeField]
|
|
private Color[] _colors;
|
|
|
|
// Token: 0x0400013B RID: 315
|
|
public bool userCollisions;
|
|
|
|
// Token: 0x0400013C RID: 316
|
|
public bool isSelectable = true;
|
|
|
|
// Token: 0x0400013D RID: 317
|
|
public pb_UnwrapParameters unwrapParameters = new pb_UnwrapParameters();
|
|
|
|
// Token: 0x0400013E RID: 318
|
|
public string asset_guid;
|
|
|
|
// Token: 0x04000140 RID: 320
|
|
public bool dontDestroyMeshOnDelete;
|
|
|
|
// Token: 0x04000141 RID: 321
|
|
[SerializeField]
|
|
private int[] m_selectedFaces = new int[0];
|
|
|
|
// Token: 0x04000142 RID: 322
|
|
[SerializeField]
|
|
private pb_Edge[] m_SelectedEdges = new pb_Edge[0];
|
|
|
|
// Token: 0x04000143 RID: 323
|
|
[SerializeField]
|
|
private int[] m_selectedTriangles = new int[0];
|
|
}
|