niko
906 lines
30 KiB
C#
906 lines
30 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|