using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using ProBuilder2.Common;
using UnityEngine;

namespace ProBuilder2.MeshOperations
{
	// Token: 0x02000002 RID: 2
	public static class pbMeshOps
	{
		// Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000450
		public static void CenterPivot(this pb_Object pb, int[] indices)
		{
			Vector3 vector = Vector3.zero;
			if (indices != null && indices.Length > 0)
			{
				Vector3[] array = pb.VerticesInWorldSpace(indices);
				foreach (Vector3 vector2 in array)
				{
					vector += vector2;
				}
				vector /= (float)array.Length;
			}
			else
			{
				vector = pb.transform.TransformPoint(pb.msh.bounds.center);
			}
			Vector3 vector3 = pb.transform.position - vector;
			pb.transform.position = vector;
			pb.ToMesh();
			pb.TranslateVertices_World(pb.msh.triangles, vector3);
			pb.Refresh(RefreshMask.All);
		}

		// Token: 0x06000002 RID: 2 RVA: 0x00002120 File Offset: 0x00000520
		public static void CenterPivot(this pb_Object pb, Vector3 worldPosition)
		{
			Vector3 vector = pb.transform.position - worldPosition;
			pb.transform.position = worldPosition;
			pb.ToMesh();
			pb.TranslateVertices_World(pb.msh.triangles, vector);
			pb.Refresh(RefreshMask.All);
		}

		// Token: 0x06000003 RID: 3 RVA: 0x00002170 File Offset: 0x00000570
		public static void FreezeScaleTransform(this pb_Object pb)
		{
			Vector3[] vertices = pb.vertices;
			for (int i = 0; i < vertices.Length; i++)
			{
				vertices[i] = Vector3.Scale(vertices[i], pb.transform.localScale);
			}
			pb.SetVertices(vertices);
			pb.transform.localScale = new Vector3(1f, 1f, 1f);
		}

		// Token: 0x06000004 RID: 4 RVA: 0x000021E8 File Offset: 0x000005E8
		[Obsolete("Please use `bool Extrude(this pb_Object pb, pb_Face[] faces, ExtrudeMethod method, float distance)`")]
		public static bool Extrude(this pb_Object pb, pb_Face[] faces, float extrudeDistance)
		{
			pb_Face[] array;
			return pb.Extrude(faces, extrudeDistance, true, out array);
		}

		// Token: 0x06000005 RID: 5 RVA: 0x00002200 File Offset: 0x00000600
		[Obsolete("Please use `bool Extrude(this pb_Object pb, pb_Face[] faces, ExtrudeMethod method, float distance)`")]
		public static bool Extrude(this pb_Object pb, pb_Face[] faces, float extrudeDistance, bool extrudeAsGroup, out pb_Face[] appendedFaces)
		{
			return pb.Extrude(faces, (!extrudeAsGroup) ? ExtrudeMethod.IndividualFaces : ExtrudeMethod.VertexNormal, extrudeDistance, out appendedFaces);
		}

		// Token: 0x06000006 RID: 6 RVA: 0x0000221C File Offset: 0x0000061C
		[Obsolete("Please use `bool Extrude(this pb_Object pb, pb_Face[] faces, ExtrudeMethod method, float distance)`")]
		public static bool Extrude(this pb_Object pb, pb_Face[] faces, ExtrudeMethod method, float extrudeDistance, out pb_Face[] appendedFaces)
		{
			appendedFaces = null;
			if (faces == null || faces.Length < 1)
			{
				return false;
			}
			pb_IntArray[] sharedIndices = pb.GetSharedIndices();
			Dictionary<int, int> dictionary = sharedIndices.ToDictionary();
			int vertexCount = pb.vertexCount;
			Vector3[] array = pb.vertices;
			bool flag = method != ExtrudeMethod.IndividualFaces;
			pb_Edge[][] array2;
			if (flag)
			{
				(array2 = new pb_Edge[1][])[0] = pbMeshUtils.GetPerimeterEdges(dictionary, faces).ToArray<pb_Edge>();
			}
			else
			{
				array2 = faces.Select((pb_Face x) => x.edges).ToArray<pb_Edge[]>();
			}
			pb_Edge[][] array3 = array2;
			if (array3 == null || array3.Length < 1 || (flag && array3[0].Length < 3))
			{
				Debug.LogWarning("No perimeter edges found.  Try deselecting and reselecting this object and trying again.");
				return false;
			}
			pb_Face[][] array4 = new pb_Face[array3.Length][];
			int[][] array5 = new int[array3.Length][];
			for (int i = 0; i < array3.Length; i++)
			{
				int num = 0;
				array5[i] = new int[array3[i].Length * 2];
				array4[i] = new pb_Face[array3[i].Length];
				for (int j = 0; j < array3[i].Length; j++)
				{
					foreach (pb_Face pb_Face in faces)
					{
						if (pb_Face.edges.Contains(array3[i][j]))
						{
							array4[i][j] = pb_Face;
							break;
						}
					}
					array5[i][num++] = array3[i][j].x;
					array5[i][num++] = array3[i][j].y;
				}
			}
			List<pb_Edge>[] array6 = new List<pb_Edge>[array3.Length];
			Vector3[] normals = pb.msh.normals;
			Vector3[] array7 = new Vector3[vertexCount];
			List<Vector3[]> list = new List<Vector3[]>();
			List<Color[]> list2 = new List<Color[]>();
			List<Vector2[]> list3 = new List<Vector2[]>();
			List<pb_Face> list4 = new List<pb_Face>();
			List<int[]> list5 = new List<int[]>();
			for (int l = 0; l < array3.Length; l++)
			{
				array6[l] = new List<pb_Edge>();
				for (int m = 0; m < array3[l].Length; m++)
				{
					pb_Edge pb_Edge = array3[l][m];
					pb_Face pb_Face2 = array4[l][m];
					Vector3 vector = pb_Math.Normal(pb, pb_Face2);
					Vector3 vector2 = Vector3.zero;
					Vector3 vector3 = Vector3.zero;
					if (Mathf.Abs(extrudeDistance) > Mathf.Epsilon)
					{
						if (!flag)
						{
							vector2 = vector;
							vector3 = vector;
						}
						else
						{
							vector2 = pbMeshOps.Norm(sharedIndices[dictionary[pb_Edge.x]], array5[l], normals);
							vector3 = pbMeshOps.Norm(sharedIndices[dictionary[pb_Edge.y]], array5[l], normals);
						}
					}
					int num2 = dictionary[pb_Edge.x];
					int num3 = dictionary[pb_Edge.y];
					float num4 = extrudeDistance;
					float num5 = extrudeDistance;
					if (method == ExtrudeMethod.FaceNormal)
					{
						num4 = pb_Math.Secant(Vector3.Angle(vector, vector2) * 0.017453292f) * extrudeDistance;
						num5 = pb_Math.Secant(Vector3.Angle(vector, vector3) * 0.017453292f) * extrudeDistance;
					}
					array7[pb_Edge.x] = vector2.normalized * num4;
					array7[pb_Edge.y] = vector3.normalized * num5;
					list.Add(new Vector3[]
					{
						array[pb_Edge.x],
						array[pb_Edge.y],
						array[pb_Edge.x] + array7[pb_Edge.x],
						array[pb_Edge.y] + array7[pb_Edge.y]
					});
					list2.Add(new Color[]
					{
						pb.colors[pb_Edge.x],
						pb.colors[pb_Edge.y],
						pb.colors[pb_Edge.x],
						pb.colors[pb_Edge.y]
					});
					list3.Add(new Vector2[4]);
					list4.Add(new pb_Face(new int[] { 0, 1, 2, 1, 3, 2 }, pb_Face2.material, new pb_UV(pb_Face2.uv), pb_Face2.smoothingGroup, -1, -1, false));
					list5.Add(new int[] { num2, num3, -1, -1 });
					array6[l].Add(new pb_Edge(num2, -1));
					array6[l].Add(new pb_Edge(num3, -1));
				}
			}
			appendedFaces = pb.AppendFaces(list.ToArray(), list2.ToArray(), list3.ToArray(), list4.ToArray(), list5.ToArray());
			int n = 0;
			int num6 = 0;
			while (n < array6.Length)
			{
				for (int num7 = 0; num7 < array6[n].Count; num7 += 2)
				{
					array6[n][num7].y = appendedFaces[num6].indices[2];
					array6[n][num7 + 1].y = appendedFaces[num6++].indices[4];
				}
				n++;
			}
			pb_IntArray[] array8 = pb.sharedIndices;
			Dictionary<int, int> dictionary2 = array8.ToDictionary();
			for (int num8 = 0; num8 < array6.Length; num8++)
			{
				for (int num9 = 0; num9 < array6[num8].Count - 1; num9++)
				{
					int x2 = array6[num8][num9].x;
					for (int num10 = num9 + 1; num10 < array6[num8].Count; num10++)
					{
						if (array6[num8][num10].x == x2)
						{
							dictionary2[array6[num8][num9].y] = dictionary2[array6[num8][num10].y];
							break;
						}
					}
				}
			}
			array = pb.vertices;
			foreach (pb_Face pb_Face3 in faces)
			{
				pb_Face3.smoothingGroup = -1;
				pb_Face3.textureGroup = -1;
			}
			if (flag)
			{
				foreach (pb_Face pb_Face4 in faces)
				{
					int[] distinctIndices = pb_Face4.distinctIndices;
					foreach (int num14 in distinctIndices)
					{
						int num15 = array8.IndexOf(num14);
						for (int num16 = 0; num16 < array5.Length; num16++)
						{
							for (int num17 = 0; num17 < array6[num16].Count; num17++)
							{
								if (num15 == array6[num16][num17].x)
								{
									dictionary2[num14] = dictionary2[array6[num16][num17].y];
									break;
								}
							}
						}
					}
				}
			}
			else
			{
				for (int num18 = 0; num18 < array4.Length; num18++)
				{
					int[] array10 = pb_Face.AllTrianglesDistinct(array4[num18]);
					for (int num19 = 0; num19 < array10.Length; num19++)
					{
						int num20 = array10[num19];
						int old_si_index = dictionary[num20];
						int num21 = array6[num18].FindIndex((pb_Edge x) => x.x == old_si_index);
						if (num21 >= 0)
						{
							int y = array6[num18][num21].y;
							if (dictionary2.ContainsKey(y))
							{
								dictionary2[num20] = dictionary2[y];
							}
						}
					}
				}
			}
			array8 = dictionary2.ToSharedIndices();
			pb.SplitUVs(pb_Face.AllTriangles(faces));
			int[] array11 = pb_Face.AllTrianglesDistinct(faces);
			float num22 = extrudeDistance;
			foreach (pb_Face pb_Face5 in faces)
			{
				Vector3 vector4 = pb_Math.Normal(array[pb_Face5.indices[0]], array[pb_Face5.indices[1]], array[pb_Face5.indices[2]]);
				Vector3 vector5 = ((!flag) ? vector4 : Vector3.zero);
				foreach (int num25 in pb_Face5.distinctIndices)
				{
					if (flag)
					{
						vector5 = pbMeshOps.Norm(sharedIndices[dictionary[num25]], array11, normals);
						if (method == ExtrudeMethod.FaceNormal)
						{
							num22 = pb_Math.Secant(Vector3.Angle(vector4, vector5) * 0.017453292f) * extrudeDistance;
						}
					}
					array[num25] += vector5.normalized * num22;
				}
			}
			pb.SetSharedIndices(array8);
			pb.SetVertices(array);
			List<pb_Face> list6 = new List<pb_Face>(appendedFaces);
			list6.AddRange(faces);
			HashSet<pb_Face> hashSet = new HashSet<pb_Face>(faces);
			List<pb_WingedEdge> wingedEdges = pb_WingedEdge.GetWingedEdges(pb, list6, false, null);
			foreach (pb_WingedEdge pb_WingedEdge in wingedEdges)
			{
				if (hashSet.Contains(pb_WingedEdge.face))
				{
					hashSet.Remove(pb_WingedEdge.face);
					pb_WingedEdgeEnumerator enumerator2 = pb_WingedEdge.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							pb_WingedEdge pb_WingedEdge2 = enumerator2.Current;
							pb_ConformNormals.ConformOppositeNormal(pb_WingedEdge2);
						}
					}
					finally
					{
						IDisposable disposable;
						if ((disposable = enumerator2 as IDisposable) != null)
						{
							disposable.Dispose();
						}
					}
				}
			}
			return true;
		}

		// Token: 0x06000007 RID: 7 RVA: 0x00002CBC File Offset: 0x000010BC
		private static Vector3 Norm(int[] shared, int[] all, Vector3[] norm)
		{
			Vector3 vector = Vector3.zero;
			int num = 0;
			for (int i = 0; i < all.Length; i++)
			{
				if (Array.IndexOf<int>(shared, all[i]) > -1)
				{
					vector += norm[all[i]];
					num++;
				}
			}
			return vector / (float)num;
		}

		// Token: 0x06000008 RID: 8 RVA: 0x00002D18 File Offset: 0x00001118
		public static bool Extrude(this pb_Object pb, pb_Edge[] edges, float extrudeDistance, bool extrudeAsGroup, bool enableManifoldExtrude, out pb_Edge[] extrudedEdges)
		{
			pb_IntArray[] array = pb.sharedIndices;
			Dictionary<int, int> dictionary = array.ToDictionary();
			List<pb_Edge> list = new List<pb_Edge>();
			List<pb_Face> list2 = new List<pb_Face>();
			foreach (pb_Edge pb_Edge in edges)
			{
				int num = 0;
				pb_Face pb_Face = null;
				foreach (pb_Face pb_Face2 in pb.faces)
				{
					if (pb_Face2.edges.IndexOf(pb_Edge, dictionary) > -1)
					{
						pb_Face = pb_Face2;
						if (++num > 1)
						{
							break;
						}
					}
				}
				if (enableManifoldExtrude || num < 2)
				{
					list.Add(pb_Edge);
					list2.Add(pb_Face);
				}
			}
			if (list.Count < 1)
			{
				extrudedEdges = null;
				return false;
			}
			Vector3[] vertices = pb.vertices;
			Vector3[] normals = pb.msh.normals;
			int[] array2 = new int[list.Count * 2];
			int num2 = 0;
			for (int k = 0; k < list.Count; k++)
			{
				array2[num2++] = list[k].x;
				array2[num2++] = list[k].y;
			}
			List<pb_Edge> list3 = new List<pb_Edge>();
			List<pb_Edge> list4 = new List<pb_Edge>();
			for (int l = 0; l < list.Count; l++)
			{
				pb_Edge pb_Edge2 = list[l];
				pb_Face pb_Face3 = list2[l];
				Vector3 vector = ((!extrudeAsGroup) ? pb_Math.Normal(pb, pb_Face3) : pbMeshOps.Norm(array[dictionary[pb_Edge2.x]], array2, normals));
				Vector3 vector2 = ((!extrudeAsGroup) ? pb_Math.Normal(pb, pb_Face3) : pbMeshOps.Norm(array[dictionary[pb_Edge2.y]], array2, normals));
				int num3 = dictionary[pb_Edge2.x];
				int num4 = dictionary[pb_Edge2.y];
				pb_Face pb_Face4 = pb.AppendFace(new Vector3[]
				{
					vertices[pb_Edge2.x],
					vertices[pb_Edge2.y],
					vertices[pb_Edge2.x] + vector.normalized * extrudeDistance,
					vertices[pb_Edge2.y] + vector2.normalized * extrudeDistance
				}, new Color[]
				{
					pb.colors[pb_Edge2.x],
					pb.colors[pb_Edge2.y],
					pb.colors[pb_Edge2.x],
					pb.colors[pb_Edge2.y]
				}, new Vector2[4], new pb_Face(new int[] { 2, 1, 0, 2, 3, 1 }, pb_Face3.material, new pb_UV(), 0, -1, -1, false), new int[] { num3, num4, -1, -1 });
				list4.Add(new pb_Edge(pb_Face4.indices[3], pb_Face4.indices[4]));
				list3.Add(new pb_Edge(num3, pb_Face4.indices[3]));
				list3.Add(new pb_Edge(num4, pb_Face4.indices[4]));
			}
			array = pb.sharedIndices;
			if (extrudeAsGroup)
			{
				for (int m = 0; m < list3.Count; m++)
				{
					int x = list3[m].x;
					for (int n = 0; n < list3.Count; n++)
					{
						if (n != m)
						{
							if (list3[n].x == x)
							{
								pb_IntArrayUtility.MergeSharedIndices(ref array, list3[n].y, list3[m].y);
								break;
							}
						}
					}
				}
			}
			pb.SetSharedIndices(array);
			foreach (pb_Face pb_Face5 in pb.faces)
			{
				pb_Face5.RebuildCaches();
			}
			extrudedEdges = list4.ToArray();
			return true;
		}

		// Token: 0x06000009 RID: 9 RVA: 0x000031CC File Offset: 0x000015CC
		public static List<pb_Face> DetachFaces(this pb_Object pb, IEnumerable<pb_Face> faces)
		{
			List<pb_Vertex> list = new List<pb_Vertex>(pb_Vertex.GetVertices(pb, null));
			int num = pb.sharedIndices.Length;
			Dictionary<int, int> dictionary = pb.sharedIndices.ToDictionary();
			List<pb_FaceRebuildData> list2 = new List<pb_FaceRebuildData>();
			foreach (pb_Face pb_Face in faces)
			{
				pb_FaceRebuildData pb_FaceRebuildData = new pb_FaceRebuildData();
				pb_FaceRebuildData.vertices = new List<pb_Vertex>();
				pb_FaceRebuildData.sharedIndices = new List<int>();
				pb_FaceRebuildData.face = new pb_Face(pb_Face);
				Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
				int[] array = new int[pb_Face.indices.Length];
				for (int i = 0; i < pb_Face.indices.Length; i++)
				{
					int count;
					if (dictionary2.TryGetValue(pb_Face.indices[i], out count))
					{
						array[i] = count;
					}
					else
					{
						count = pb_FaceRebuildData.vertices.Count;
						array[i] = count;
						dictionary2.Add(pb_Face.indices[i], count);
						pb_FaceRebuildData.vertices.Add(list[pb_Face.indices[i]]);
						pb_FaceRebuildData.sharedIndices.Add(dictionary[pb_Face.indices[i]] + num);
					}
				}
				pb_FaceRebuildData.face.SetIndices(array.ToArray<int>());
				list2.Add(pb_FaceRebuildData);
			}
			pb_FaceRebuildData.Apply(list2, pb, list, null, dictionary, null);
			pb.DeleteFaces(faces);
			pb.ToMesh();
			return list2.Select((pb_FaceRebuildData x) => x.face).ToList<pb_Face>();
		}

		// Token: 0x0600000A RID: 10 RVA: 0x00003398 File Offset: 0x00001798
		public static bool Bridge(this pb_Object pb, pb_Edge a, pb_Edge b, bool enforcePerimiterEdgesOnly = false)
		{
			pb_IntArray[] sharedIndices = pb.GetSharedIndices();
			Dictionary<int, int> dictionary = sharedIndices.ToDictionary();
			if (enforcePerimiterEdgesOnly && (pbMeshUtils.GetNeighborFaces(pb, a, null).Count > 1 || pbMeshUtils.GetNeighborFaces(pb, b, null).Count > 1))
			{
				return false;
			}
			foreach (pb_Face pb_Face in pb.faces)
			{
				if (pb_Face.edges.IndexOf(a, dictionary) >= 0 && pb_Face.edges.IndexOf(b, dictionary) >= 0)
				{
					Debug.LogWarning("Face already exists between these two edges!");
					return false;
				}
			}
			Vector3[] vertices = pb.vertices;
			pb_UV pb_UV = new pb_UV();
			Material material = pb_Constant.DefaultMaterial;
			pb_Tuple<pb_Face, pb_Edge> pb_Tuple = null;
			if (!pb_Edge.ValidateEdge(pb, a, out pb_Tuple))
			{
				pb_Edge.ValidateEdge(pb, b, out pb_Tuple);
			}
			if (pb_Tuple != null)
			{
				pb_UV = new pb_UV(pb_Tuple.Item1.uv);
				material = pb_Tuple.Item1.material;
			}
			Vector3[] array;
			Color[] array2;
			int[] array3;
			if (a.Contains(b.x, sharedIndices) || a.Contains(b.y, sharedIndices))
			{
				array = new Vector3[3];
				array2 = new Color[3];
				array3 = new int[3];
				bool flag = Array.IndexOf<int>(sharedIndices[sharedIndices.IndexOf(a.x)], b.x) > -1;
				bool flag2 = Array.IndexOf<int>(sharedIndices[sharedIndices.IndexOf(a.x)], b.y) > -1;
				bool flag3 = Array.IndexOf<int>(sharedIndices[sharedIndices.IndexOf(a.y)], b.x) > -1;
				bool flag4 = Array.IndexOf<int>(sharedIndices[sharedIndices.IndexOf(a.y)], b.y) > -1;
				if (flag)
				{
					array[0] = vertices[a.x];
					array2[0] = pb.colors[a.x];
					array3[0] = sharedIndices.IndexOf(a.x);
					array[1] = vertices[a.y];
					array2[1] = pb.colors[a.y];
					array3[1] = sharedIndices.IndexOf(a.y);
					array[2] = vertices[b.y];
					array2[2] = pb.colors[b.y];
					array3[2] = sharedIndices.IndexOf(b.y);
				}
				else if (flag2)
				{
					array[0] = vertices[a.x];
					array2[0] = pb.colors[a.x];
					array3[0] = sharedIndices.IndexOf(a.x);
					array[1] = vertices[a.y];
					array2[1] = pb.colors[a.y];
					array3[1] = sharedIndices.IndexOf(a.y);
					array[2] = vertices[b.x];
					array2[2] = pb.colors[b.x];
					array3[2] = sharedIndices.IndexOf(b.x);
				}
				else if (flag3)
				{
					array[0] = vertices[a.y];
					array2[0] = pb.colors[a.y];
					array3[0] = sharedIndices.IndexOf(a.y);
					array[1] = vertices[a.x];
					array2[1] = pb.colors[a.x];
					array3[1] = sharedIndices.IndexOf(a.x);
					array[2] = vertices[b.y];
					array2[2] = pb.colors[b.y];
					array3[2] = sharedIndices.IndexOf(b.y);
				}
				else if (flag4)
				{
					array[0] = vertices[a.y];
					array2[0] = pb.colors[a.y];
					array3[0] = sharedIndices.IndexOf(a.y);
					array[1] = vertices[a.x];
					array2[1] = pb.colors[a.x];
					array3[1] = sharedIndices.IndexOf(a.x);
					array[2] = vertices[b.x];
					array2[2] = pb.colors[b.x];
					array3[2] = sharedIndices.IndexOf(b.x);
				}
				Vector3[] array4 = array;
				Color[] array5 = array2;
				Vector2[] array6 = new Vector2[array.Length];
				int[] array8;
				if (flag || flag2)
				{
					int[] array7 = new int[3];
					array7[0] = 2;
					array8 = array7;
					array7[1] = 1;
				}
				else
				{
					int[] array9 = new int[3];
					array9[1] = 1;
					array8 = array9;
					array9[2] = 2;
				}
				pb.AppendFace(array4, array5, array6, new pb_Face(array8, material, pb_UV, 0, -1, -1, false), array3);
				return true;
			}
			array = new Vector3[4];
			array2 = new Color[4];
			array3 = new int[4];
			array[0] = vertices[a.x];
			array2[0] = pb.colors[a.x];
			array3[0] = sharedIndices.IndexOf(a.x);
			array[1] = vertices[a.y];
			array2[1] = pb.colors[a.y];
			array3[1] = sharedIndices.IndexOf(a.y);
			Vector3 normalized = Vector3.Cross(vertices[b.x] - vertices[a.x], vertices[a.y] - vertices[a.x]).normalized;
			Vector2[] array10 = pb_Projection.PlanarProject(new Vector3[]
			{
				vertices[a.x],
				vertices[a.y],
				vertices[b.x],
				vertices[b.y]
			}, normalized);
			Vector2 zero = Vector2.zero;
			if (!pb_Math.GetLineSegmentIntersect(array10[0], array10[2], array10[1], array10[3], ref zero))
			{
				array[2] = vertices[b.x];
				array2[2] = pb.colors[b.x];
				array3[2] = sharedIndices.IndexOf(b.x);
				array[3] = vertices[b.y];
				array2[3] = pb.colors[b.y];
				array3[3] = sharedIndices.IndexOf(b.y);
			}
			else
			{
				array[2] = vertices[b.y];
				array2[2] = pb.colors[b.y];
				array3[2] = sharedIndices.IndexOf(b.y);
				array[3] = vertices[b.x];
				array2[3] = pb.colors[b.x];
				array3[3] = sharedIndices.IndexOf(b.x);
			}
			pb.AppendFace(array, array2, new Vector2[array.Length], new pb_Face(new int[] { 2, 1, 0, 2, 3, 1 }, material, pb_UV, 0, -1, -1, false), array3);
			return true;
		}

		// Token: 0x0600000B RID: 11 RVA: 0x00003D24 File Offset: 0x00002124
		public static bool CombineObjects(pb_Object[] pbs, out pb_Object combined)
		{
			combined = null;
			if (pbs.Length < 1)
			{
				return false;
			}
			List<Vector3> list = new List<Vector3>();
			List<Vector2> list2 = new List<Vector2>();
			List<Color> list3 = new List<Color>();
			List<pb_Face> list4 = new List<pb_Face>();
			List<pb_IntArray> list5 = new List<pb_IntArray>();
			List<pb_IntArray> list6 = new List<pb_IntArray>();
			foreach (pb_Object pb_Object in pbs)
			{
				int count = list.Count;
				list.AddRange(pb_Object.VerticesInWorldSpace());
				list2.AddRange(pb_Object.uv);
				list3.AddRange(pb_Object.colors);
				pb_Face[] array = new pb_Face[pb_Object.faces.Length];
				for (int j = 0; j < array.Length; j++)
				{
					array[j] = new pb_Face(pb_Object.faces[j]);
					array[j].manualUV = true;
					array[j].ShiftIndices(count);
					array[j].RebuildCaches();
				}
				list4.AddRange(array);
				pb_IntArray[] sharedIndices = pb_Object.GetSharedIndices();
				for (int k = 0; k < sharedIndices.Length; k++)
				{
					for (int l = 0; l < sharedIndices[k].Length; l++)
					{
						pb_IntArray pb_IntArray;
						int num;
						(pb_IntArray = sharedIndices[k])[num = l] = pb_IntArray[num] + count;
					}
				}
				list5.AddRange(sharedIndices);
				pb_IntArray[] sharedIndicesUV = pb_Object.GetSharedIndicesUV();
				for (int m = 0; m < sharedIndicesUV.Length; m++)
				{
					for (int n = 0; n < sharedIndicesUV[m].Length; n++)
					{
						pb_IntArray pb_IntArray;
						int num2;
						(pb_IntArray = sharedIndicesUV[m])[num2 = n] = pb_IntArray[num2] + count;
					}
				}
				list6.AddRange(sharedIndicesUV);
			}
			GameObject gameObject = global::UnityEngine.Object.Instantiate<GameObject>(pbs[0].gameObject);
			gameObject.transform.position = Vector3.zero;
			gameObject.transform.localRotation = Quaternion.identity;
			gameObject.transform.localScale = Vector3.one;
			IEnumerator enumerator = gameObject.transform.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					object obj = enumerator.Current;
					Transform transform = (Transform)obj;
					global::UnityEngine.Object.DestroyImmediate(transform.gameObject);
				}
			}
			finally
			{
				IDisposable disposable;
				if ((disposable = enumerator as IDisposable) != null)
				{
					disposable.Dispose();
				}
			}
			if (gameObject.GetComponent<pb_Object>())
			{
				global::UnityEngine.Object.DestroyImmediate(gameObject.GetComponent<pb_Object>());
			}
			if (gameObject.GetComponent<pb_Entity>())
			{
				global::UnityEngine.Object.DestroyImmediate(gameObject.GetComponent<pb_Entity>());
			}
			combined = gameObject.AddComponent<pb_Object>();
			combined.SetVertices(list.ToArray());
			combined.SetUV(list2.ToArray());
			combined.SetColors(list3.ToArray());
			combined.SetFaces(list4.ToArray());
			combined.SetSharedIndices(list5.ToArray() ?? pb_IntArrayUtility.ExtractSharedIndices(list.ToArray()));
			combined.SetSharedIndicesUV(list6.ToArray() ?? new pb_IntArray[0]);
			combined.ToMesh();
			combined.GetComponent<pb_Entity>().SetEntity(pbs[0].GetComponent<pb_Entity>().entityType);
			combined.CenterPivot(pbs[0].transform.position);
			combined.Refresh(RefreshMask.All);
			foreach (pb_Object pb_Object2 in pbs)
			{
				pb_Object2.Verify();
			}
			return true;
		}

		// Token: 0x0600000C RID: 12 RVA: 0x000040B4 File Offset: 0x000024B4
		public static pb_Object CreatePbObjectWithTransform(Transform t, bool preserveFaces)
		{
			Mesh sharedMesh = t.GetComponent<MeshFilter>().sharedMesh;
			Vector3[] meshAttribute = pb_MeshUtility.GetMeshAttribute<Vector3[]>(t.gameObject, (Mesh x) => x.vertices);
			Color[] meshAttribute2 = pb_MeshUtility.GetMeshAttribute<Color[]>(t.gameObject, (Mesh x) => x.colors);
			Vector2[] meshAttribute3 = pb_MeshUtility.GetMeshAttribute<Vector2[]>(t.gameObject, (Mesh x) => x.uv);
			List<Vector3> list = ((!preserveFaces) ? new List<Vector3>() : new List<Vector3>(sharedMesh.vertices));
			List<Color> list2 = ((!preserveFaces) ? new List<Color>() : new List<Color>(sharedMesh.colors));
			List<Vector2> list3 = ((!preserveFaces) ? new List<Vector2>() : new List<Vector2>(sharedMesh.uv));
			List<pb_Face> list4 = new List<pb_Face>();
			for (int i = 0; i < sharedMesh.subMeshCount; i++)
			{
				int[] triangles = sharedMesh.GetTriangles(i);
				for (int j = 0; j < triangles.Length; j += 3)
				{
					int num = -1;
					if (preserveFaces)
					{
						for (int k = 0; k < list4.Count; k++)
						{
							if (list4[k].distinctIndices.Contains(triangles[j]) || list4[k].distinctIndices.Contains(triangles[j + 1]) || list4[k].distinctIndices.Contains(triangles[j + 2]))
							{
								num = k;
								break;
							}
						}
					}
					if (num > -1 && preserveFaces)
					{
						int num2 = list4[num].indices.Length;
						int[] array = new int[num2 + 3];
						Array.Copy(list4[num].indices, 0, array, 0, num2);
						array[num2] = triangles[j];
						array[num2 + 1] = triangles[j + 1];
						array[num2 + 2] = triangles[j + 2];
						list4[num].SetIndices(array);
						list4[num].RebuildCaches();
					}
					else
					{
						int[] array2;
						if (preserveFaces)
						{
							array2 = new int[]
							{
								triangles[j],
								triangles[j + 1],
								triangles[j + 2]
							};
						}
						else
						{
							list.Add(meshAttribute[triangles[j]]);
							list.Add(meshAttribute[triangles[j + 1]]);
							list.Add(meshAttribute[triangles[j + 2]]);
							list2.Add((meshAttribute2 == null) ? Color.white : meshAttribute2[triangles[j]]);
							list2.Add((meshAttribute2 == null) ? Color.white : meshAttribute2[triangles[j + 1]]);
							list2.Add((meshAttribute2 == null) ? Color.white : meshAttribute2[triangles[j + 2]]);
							list3.Add(meshAttribute3[triangles[j]]);
							list3.Add(meshAttribute3[triangles[j + 1]]);
							list3.Add(meshAttribute3[triangles[j + 2]]);
							array2 = new int[]
							{
								j,
								j + 1,
								j + 2
							};
						}
						list4.Add(new pb_Face(array2, t.GetComponent<MeshRenderer>().sharedMaterials[i], new pb_UV(), 0, -1, -1, true));
					}
				}
			}
			GameObject gameObject = global::UnityEngine.Object.Instantiate<GameObject>(t.gameObject);
			gameObject.GetComponent<MeshFilter>().sharedMesh = null;
			pb_Object pb_Object = gameObject.AddComponent<pb_Object>();
			pb_Object.GeometryWithVerticesFaces(list.ToArray(), list4.ToArray());
			pb_Object.SetColors(list2.ToArray());
			pb_Object.SetUV(list3.ToArray());
			pb_Object.gameObject.name = t.name;
			gameObject.transform.position = t.position;
			gameObject.transform.localRotation = t.localRotation;
			gameObject.transform.localScale = t.localScale;
			pb_Object.CenterPivot(null);
			return pb_Object;
		}

		// Token: 0x0600000D RID: 13 RVA: 0x0000451C File Offset: 0x0000291C
		public static bool ResetPbObjectWithMeshFilter(pb_Object pb, bool preserveFaces)
		{
			MeshFilter component = pb.gameObject.GetComponent<MeshFilter>();
			if (component == null || component.sharedMesh == null)
			{
				pb_Log.Error(pb.name + " does not have a mesh or Mesh Filter component.");
				return false;
			}
			Mesh sharedMesh = component.sharedMesh;
			int vertexCount = sharedMesh.vertexCount;
			Vector3[] meshAttribute = pb_MeshUtility.GetMeshAttribute<Vector3[]>(pb.gameObject, (Mesh x) => x.vertices);
			Color[] meshAttribute2 = pb_MeshUtility.GetMeshAttribute<Color[]>(pb.gameObject, (Mesh x) => x.colors);
			Vector2[] meshAttribute3 = pb_MeshUtility.GetMeshAttribute<Vector2[]>(pb.gameObject, (Mesh x) => x.uv);
			List<Vector3> list = ((!preserveFaces) ? new List<Vector3>() : new List<Vector3>(sharedMesh.vertices));
			List<Color> list2 = ((!preserveFaces) ? new List<Color>() : new List<Color>(sharedMesh.colors));
			List<Vector2> list3 = ((!preserveFaces) ? new List<Vector2>() : new List<Vector2>(sharedMesh.uv));
			List<pb_Face> list4 = new List<pb_Face>();
			MeshRenderer meshRenderer = pb.gameObject.GetComponent<MeshRenderer>();
			if (meshRenderer == null)
			{
				meshRenderer = pb.gameObject.AddComponent<MeshRenderer>();
			}
			Material[] sharedMaterials = meshRenderer.sharedMaterials;
			int num = sharedMaterials.Length;
			for (int i = 0; i < sharedMesh.subMeshCount; i++)
			{
				int[] triangles = sharedMesh.GetTriangles(i);
				for (int j = 0; j < triangles.Length; j += 3)
				{
					int num2 = -1;
					if (preserveFaces)
					{
						for (int k = 0; k < list4.Count; k++)
						{
							if (list4[k].distinctIndices.Contains(triangles[j]) || list4[k].distinctIndices.Contains(triangles[j + 1]) || list4[k].distinctIndices.Contains(triangles[j + 2]))
							{
								num2 = k;
								break;
							}
						}
					}
					if (num2 > -1 && preserveFaces)
					{
						int num3 = list4[num2].indices.Length;
						int[] array = new int[num3 + 3];
						Array.Copy(list4[num2].indices, 0, array, 0, num3);
						array[num3] = triangles[j];
						array[num3 + 1] = triangles[j + 1];
						array[num3 + 2] = triangles[j + 2];
						list4[num2].SetIndices(array);
						list4[num2].RebuildCaches();
					}
					else
					{
						int[] array2;
						if (preserveFaces)
						{
							array2 = new int[]
							{
								triangles[j],
								triangles[j + 1],
								triangles[j + 2]
							};
						}
						else
						{
							list.Add(meshAttribute[triangles[j]]);
							list.Add(meshAttribute[triangles[j + 1]]);
							list.Add(meshAttribute[triangles[j + 2]]);
							list2.Add((meshAttribute2 == null || meshAttribute2.Length != vertexCount) ? Color.white : meshAttribute2[triangles[j]]);
							list2.Add((meshAttribute2 == null || meshAttribute2.Length != vertexCount) ? Color.white : meshAttribute2[triangles[j + 1]]);
							list2.Add((meshAttribute2 == null || meshAttribute2.Length != vertexCount) ? Color.white : meshAttribute2[triangles[j + 2]]);
							list3.Add(meshAttribute3[triangles[j]]);
							list3.Add(meshAttribute3[triangles[j + 1]]);
							list3.Add(meshAttribute3[triangles[j + 2]]);
							array2 = new int[]
							{
								j,
								j + 1,
								j + 2
							};
						}
						list4.Add(new pb_Face(array2, sharedMaterials[(i < num) ? i : (num - 1)], new pb_UV(), 0, -1, -1, true));
					}
				}
			}
			pb.SetVertices(list.ToArray());
			pb.SetUV(list3.ToArray());
			pb.SetFaces(list4.ToArray());
			pb.SetSharedIndices(pb_IntArrayUtility.ExtractSharedIndices(list.ToArray()));
			pb.SetColors(list2.ToArray());
			return true;
		}
	}
}