niko
573 lines
14 KiB
C#
573 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
|
|
namespace ProBuilder2.Common
|
|
{
|
|
// Token: 0x02000025 RID: 37
|
|
[Serializable]
|
|
public class pb_Face
|
|
{
|
|
// Token: 0x06000093 RID: 147 RVA: 0x0000F405 File Offset: 0x0000D805
|
|
public pb_Face()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000094 RID: 148 RVA: 0x0000F414 File Offset: 0x0000D814
|
|
public pb_Face(int[] i)
|
|
{
|
|
this.SetIndices(i);
|
|
this._uv = new pb_UV();
|
|
this._mat = pb_Constant.DefaultMaterial;
|
|
this._smoothingGroup = 0;
|
|
this.elementGroup = 0;
|
|
}
|
|
|
|
// Token: 0x06000095 RID: 149 RVA: 0x0000F450 File Offset: 0x0000D850
|
|
public pb_Face(int[] i, Material m, pb_UV u, int smoothingGroup, int textureGroup, int elementGroup, bool manualUV)
|
|
{
|
|
this.SetIndices(i);
|
|
this._uv = new pb_UV(u);
|
|
this._mat = m;
|
|
this._smoothingGroup = smoothingGroup;
|
|
this.textureGroup = textureGroup;
|
|
this.elementGroup = elementGroup;
|
|
this.manualUV = manualUV;
|
|
}
|
|
|
|
// Token: 0x06000096 RID: 150 RVA: 0x0000F4A4 File Offset: 0x0000D8A4
|
|
public pb_Face(pb_Face face)
|
|
{
|
|
this._indices = new int[face.indices.Length];
|
|
Array.Copy(face.indices, this._indices, face.indices.Length);
|
|
this._uv = new pb_UV(face.uv);
|
|
this._mat = face.material;
|
|
this._smoothingGroup = face.smoothingGroup;
|
|
this.textureGroup = face.textureGroup;
|
|
this.elementGroup = face.elementGroup;
|
|
this.manualUV = face.manualUV;
|
|
this.RebuildCaches();
|
|
}
|
|
|
|
// Token: 0x06000097 RID: 151 RVA: 0x0000F540 File Offset: 0x0000D940
|
|
public void CopyFrom(pb_Face other)
|
|
{
|
|
int num = ((other.indices != null) ? other.indices.Length : 0);
|
|
this._indices = new int[num];
|
|
Array.Copy(other.indices, this._indices, num);
|
|
this._smoothingGroup = other.smoothingGroup;
|
|
this._uv = new pb_UV(other.uv);
|
|
this._mat = other.material;
|
|
this.manualUV = other.manualUV;
|
|
this.elementGroup = other.elementGroup;
|
|
this.RebuildCaches();
|
|
}
|
|
|
|
// Token: 0x1700000F RID: 15
|
|
// (get) Token: 0x06000098 RID: 152 RVA: 0x0000F5CC File Offset: 0x0000D9CC
|
|
public int[] indices
|
|
{
|
|
get
|
|
{
|
|
return this._indices;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000010 RID: 16
|
|
// (get) Token: 0x06000099 RID: 153 RVA: 0x0000F5D4 File Offset: 0x0000D9D4
|
|
public int[] distinctIndices
|
|
{
|
|
get
|
|
{
|
|
return (this._distinctIndices != null) ? this._distinctIndices : this.CacheDistinctIndices();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000011 RID: 17
|
|
// (get) Token: 0x0600009A RID: 154 RVA: 0x0000F5F2 File Offset: 0x0000D9F2
|
|
public pb_Edge[] edges
|
|
{
|
|
get
|
|
{
|
|
return (this._edges != null) ? this._edges : this.CacheEdges();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000012 RID: 18
|
|
// (get) Token: 0x0600009B RID: 155 RVA: 0x0000F610 File Offset: 0x0000DA10
|
|
// (set) Token: 0x0600009C RID: 156 RVA: 0x0000F618 File Offset: 0x0000DA18
|
|
public int smoothingGroup
|
|
{
|
|
get
|
|
{
|
|
return this._smoothingGroup;
|
|
}
|
|
set
|
|
{
|
|
this._smoothingGroup = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000013 RID: 19
|
|
// (get) Token: 0x0600009D RID: 157 RVA: 0x0000F621 File Offset: 0x0000DA21
|
|
// (set) Token: 0x0600009E RID: 158 RVA: 0x0000F629 File Offset: 0x0000DA29
|
|
public Material material
|
|
{
|
|
get
|
|
{
|
|
return this._mat;
|
|
}
|
|
set
|
|
{
|
|
this._mat = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000014 RID: 20
|
|
// (get) Token: 0x0600009F RID: 159 RVA: 0x0000F632 File Offset: 0x0000DA32
|
|
// (set) Token: 0x060000A0 RID: 160 RVA: 0x0000F63A File Offset: 0x0000DA3A
|
|
public pb_UV uv
|
|
{
|
|
get
|
|
{
|
|
return this._uv;
|
|
}
|
|
set
|
|
{
|
|
this._uv = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000A1 RID: 161 RVA: 0x0000F643 File Offset: 0x0000DA43
|
|
[Obsolete("Use face.material property.")]
|
|
public void SetMaterial(Material material)
|
|
{
|
|
this._mat = material;
|
|
}
|
|
|
|
// Token: 0x060000A2 RID: 162 RVA: 0x0000F64C File Offset: 0x0000DA4C
|
|
[Obsolete("Use face.uv property.")]
|
|
public void SetUV(pb_UV uvs)
|
|
{
|
|
this._uv = uvs;
|
|
}
|
|
|
|
// Token: 0x060000A3 RID: 163 RVA: 0x0000F655 File Offset: 0x0000DA55
|
|
[Obsolete("Use face.smoothingGroup property.")]
|
|
public void SetSmoothingGroup(int smoothing)
|
|
{
|
|
this._smoothingGroup = smoothing;
|
|
}
|
|
|
|
// Token: 0x060000A4 RID: 164 RVA: 0x0000F65E File Offset: 0x0000DA5E
|
|
public bool IsValid()
|
|
{
|
|
return this.indices.Length > 2;
|
|
}
|
|
|
|
// Token: 0x060000A5 RID: 165 RVA: 0x0000F66C File Offset: 0x0000DA6C
|
|
public Vector3[] GetDistinctVertices(Vector3[] verts)
|
|
{
|
|
int[] distinctIndices = this.distinctIndices;
|
|
Vector3[] array = new Vector3[distinctIndices.Length];
|
|
for (int i = 0; i < distinctIndices.Length; i++)
|
|
{
|
|
array[i] = verts[distinctIndices[i]];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060000A6 RID: 166 RVA: 0x0000F6B8 File Offset: 0x0000DAB8
|
|
public int[] GetTriangle(int index)
|
|
{
|
|
if (index * 3 + 3 > this.indices.Length)
|
|
{
|
|
return null;
|
|
}
|
|
return new int[]
|
|
{
|
|
this.indices[index * 3],
|
|
this.indices[index * 3 + 1],
|
|
this.indices[index * 3 + 2]
|
|
};
|
|
}
|
|
|
|
// Token: 0x060000A7 RID: 167 RVA: 0x0000F70C File Offset: 0x0000DB0C
|
|
public pb_Edge[] GetAllEdges()
|
|
{
|
|
pb_Edge[] array = new pb_Edge[this.indices.Length];
|
|
for (int i = 0; i < this.indices.Length; i += 3)
|
|
{
|
|
array[i] = new pb_Edge(this.indices[i], this.indices[i + 1]);
|
|
array[i + 1] = new pb_Edge(this.indices[i + 1], this.indices[i + 2]);
|
|
array[i + 2] = new pb_Edge(this.indices[i + 2], this.indices[i]);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060000A8 RID: 168 RVA: 0x0000F795 File Offset: 0x0000DB95
|
|
public void SetIndices(int[] i)
|
|
{
|
|
this._indices = i;
|
|
this.RebuildCaches();
|
|
}
|
|
|
|
// Token: 0x060000A9 RID: 169 RVA: 0x0000F7A4 File Offset: 0x0000DBA4
|
|
public void ShiftIndices(int offset)
|
|
{
|
|
for (int i = 0; i < this._indices.Length; i++)
|
|
{
|
|
this._indices[i] += offset;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000AA RID: 170 RVA: 0x0000F7DC File Offset: 0x0000DBDC
|
|
public int SmallestIndexValue()
|
|
{
|
|
int num = this._indices[0];
|
|
for (int i = 0; i < this._indices.Length; i++)
|
|
{
|
|
if (this._indices[i] < num)
|
|
{
|
|
num = this._indices[i];
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x060000AB RID: 171 RVA: 0x0000F824 File Offset: 0x0000DC24
|
|
public void ShiftIndicesToZero()
|
|
{
|
|
int num = this.SmallestIndexValue();
|
|
for (int i = 0; i < this.indices.Length; i++)
|
|
{
|
|
this._indices[i] -= num;
|
|
}
|
|
for (int j = 0; j < this._distinctIndices.Length; j++)
|
|
{
|
|
this._distinctIndices[j] -= num;
|
|
}
|
|
for (int k = 0; k < this._edges.Length; k++)
|
|
{
|
|
this._edges[k].x -= num;
|
|
this._edges[k].y -= num;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000AC RID: 172 RVA: 0x0000F8CF File Offset: 0x0000DCCF
|
|
public void ReverseIndices()
|
|
{
|
|
Array.Reverse(this._indices);
|
|
this.RebuildCaches();
|
|
}
|
|
|
|
// Token: 0x060000AD RID: 173 RVA: 0x0000F8E2 File Offset: 0x0000DCE2
|
|
public void RebuildCaches()
|
|
{
|
|
this.CacheDistinctIndices();
|
|
this.CacheEdges();
|
|
}
|
|
|
|
// Token: 0x060000AE RID: 174 RVA: 0x0000F8F4 File Offset: 0x0000DCF4
|
|
private pb_Edge[] CacheEdges()
|
|
{
|
|
if (this._indices == null)
|
|
{
|
|
return null;
|
|
}
|
|
HashSet<pb_Edge> hashSet = new HashSet<pb_Edge>();
|
|
List<pb_Edge> list = new List<pb_Edge>();
|
|
for (int i = 0; i < this.indices.Length; i += 3)
|
|
{
|
|
pb_Edge pb_Edge = new pb_Edge(this.indices[i], this.indices[i + 1]);
|
|
pb_Edge pb_Edge2 = new pb_Edge(this.indices[i + 1], this.indices[i + 2]);
|
|
pb_Edge pb_Edge3 = new pb_Edge(this.indices[i + 2], this.indices[i]);
|
|
if (!hashSet.Add(pb_Edge))
|
|
{
|
|
list.Add(pb_Edge);
|
|
}
|
|
if (!hashSet.Add(pb_Edge2))
|
|
{
|
|
list.Add(pb_Edge2);
|
|
}
|
|
if (!hashSet.Add(pb_Edge3))
|
|
{
|
|
list.Add(pb_Edge3);
|
|
}
|
|
}
|
|
hashSet.ExceptWith(list);
|
|
this._edges = hashSet.ToArray<pb_Edge>();
|
|
return this._edges;
|
|
}
|
|
|
|
// Token: 0x060000AF RID: 175 RVA: 0x0000F9D5 File Offset: 0x0000DDD5
|
|
private int[] CacheDistinctIndices()
|
|
{
|
|
if (this._indices == null)
|
|
{
|
|
return null;
|
|
}
|
|
this._distinctIndices = new HashSet<int>(this._indices).ToArray<int>();
|
|
return this.distinctIndices;
|
|
}
|
|
|
|
// Token: 0x060000B0 RID: 176 RVA: 0x0000FA00 File Offset: 0x0000DE00
|
|
public bool Contains(int[] triangle)
|
|
{
|
|
for (int i = 0; i < this.indices.Length; i += 3)
|
|
{
|
|
if (triangle.Contains(this.indices[i]) && triangle.Contains(this.indices[i + 1]) && triangle.Contains(this.indices[i + 2]))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Token: 0x060000B1 RID: 177 RVA: 0x0000FA68 File Offset: 0x0000DE68
|
|
public static int[] AllTriangles(pb_Face[] q)
|
|
{
|
|
List<int> list = new List<int>(q.Length * 6);
|
|
foreach (pb_Face pb_Face in q)
|
|
{
|
|
list.AddRange(pb_Face.indices);
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x060000B2 RID: 178 RVA: 0x0000FAAC File Offset: 0x0000DEAC
|
|
public static int[] AllTriangles(List<pb_Face> q)
|
|
{
|
|
List<int> list = new List<int>(q.Count * 6);
|
|
foreach (pb_Face pb_Face in q)
|
|
{
|
|
list.AddRange(pb_Face.indices);
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x060000B3 RID: 179 RVA: 0x0000FB1C File Offset: 0x0000DF1C
|
|
public static int[] AllTrianglesDistinct(pb_Face[] q)
|
|
{
|
|
List<int> list = new List<int>();
|
|
foreach (pb_Face pb_Face in q)
|
|
{
|
|
list.AddRange(pb_Face.distinctIndices);
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
// Token: 0x060000B4 RID: 180 RVA: 0x0000FB5C File Offset: 0x0000DF5C
|
|
public static List<int> AllTrianglesDistinct(List<pb_Face> f)
|
|
{
|
|
List<int> list = new List<int>();
|
|
foreach (pb_Face pb_Face in f)
|
|
{
|
|
list.AddRange(pb_Face.distinctIndices);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
// Token: 0x060000B5 RID: 181 RVA: 0x0000FBC0 File Offset: 0x0000DFC0
|
|
public void ToQuadOrTriangles(out int[] quadOrTris)
|
|
{
|
|
if (this.ToQuad(out quadOrTris))
|
|
{
|
|
return;
|
|
}
|
|
int num = ((this.indices != null) ? Math.Max(0, this.indices.Length) : 0);
|
|
quadOrTris = new int[num];
|
|
Array.Copy(this.indices, quadOrTris, num);
|
|
}
|
|
|
|
// Token: 0x060000B6 RID: 182 RVA: 0x0000FC10 File Offset: 0x0000E010
|
|
public int[] ToQuad()
|
|
{
|
|
int[] array;
|
|
this.ToQuad(out array);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060000B7 RID: 183 RVA: 0x0000FC28 File Offset: 0x0000E028
|
|
public bool ToQuad(out int[] quad)
|
|
{
|
|
if (this.indices == null || this.indices.Length != 6)
|
|
{
|
|
quad = null;
|
|
return false;
|
|
}
|
|
quad = new int[]
|
|
{
|
|
this.edges[0].x,
|
|
this.edges[0].y,
|
|
-1,
|
|
-1
|
|
};
|
|
if (this.edges[1].x == quad[1])
|
|
{
|
|
quad[2] = this.edges[1].y;
|
|
}
|
|
else if (this.edges[2].x == quad[1])
|
|
{
|
|
quad[2] = this.edges[2].y;
|
|
}
|
|
else if (this.edges[3].x == quad[1])
|
|
{
|
|
quad[2] = this.edges[3].y;
|
|
}
|
|
if (this.edges[1].x == quad[2])
|
|
{
|
|
quad[3] = this.edges[1].y;
|
|
}
|
|
else if (this.edges[2].x == quad[2])
|
|
{
|
|
quad[3] = this.edges[2].y;
|
|
}
|
|
else if (this.edges[3].x == quad[2])
|
|
{
|
|
quad[3] = this.edges[3].y;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x060000B8 RID: 184 RVA: 0x0000FD84 File Offset: 0x0000E184
|
|
public static int MeshTriangles(pb_Face[] faces, out int[][] submeshes, out Material[] materials)
|
|
{
|
|
Dictionary<Material, List<pb_Face>> dictionary = new Dictionary<Material, List<pb_Face>>();
|
|
int i;
|
|
for (i = 0; i < faces.Length; i++)
|
|
{
|
|
if (faces[i] == null)
|
|
{
|
|
Debug.LogWarning("Null face found! Skipping these triangles.");
|
|
}
|
|
else
|
|
{
|
|
Material material = faces[i].material ?? pb_Constant.UnityDefaultDiffuse;
|
|
if (dictionary.ContainsKey(material))
|
|
{
|
|
dictionary[material].Add(faces[i]);
|
|
}
|
|
else
|
|
{
|
|
dictionary.Add(material, new List<pb_Face>(1) { faces[i] });
|
|
}
|
|
}
|
|
}
|
|
materials = new Material[dictionary.Count];
|
|
submeshes = new int[materials.Length][];
|
|
i = 0;
|
|
foreach (KeyValuePair<Material, List<pb_Face>> keyValuePair in dictionary)
|
|
{
|
|
submeshes[i] = pb_Face.AllTriangles(keyValuePair.Value);
|
|
materials[i] = keyValuePair.Key;
|
|
i++;
|
|
}
|
|
return submeshes.Length;
|
|
}
|
|
|
|
// Token: 0x060000B9 RID: 185 RVA: 0x0000FE94 File Offset: 0x0000E294
|
|
public override string ToString()
|
|
{
|
|
if (this.indices.Length % 3 != 0)
|
|
{
|
|
return "Index count is not a multiple of 3.";
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < this.indices.Length; i += 3)
|
|
{
|
|
stringBuilder.Append("[");
|
|
stringBuilder.Append(this.indices[i]);
|
|
stringBuilder.Append(", ");
|
|
stringBuilder.Append(this.indices[i + 1]);
|
|
stringBuilder.Append(", ");
|
|
stringBuilder.Append(this.indices[i + 2]);
|
|
stringBuilder.Append("]");
|
|
if (i < this.indices.Length - 3)
|
|
{
|
|
stringBuilder.Append(", ");
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x060000BA RID: 186 RVA: 0x0000FF58 File Offset: 0x0000E358
|
|
public string ToStringDetailed()
|
|
{
|
|
string text = string.Concat(new object[]
|
|
{
|
|
"index count: ",
|
|
this._indices.Length,
|
|
"\nmat name : ",
|
|
this.material.name,
|
|
"\nisManual : ",
|
|
this.manualUV,
|
|
"\nsmoothing group: ",
|
|
this.smoothingGroup,
|
|
"\n"
|
|
});
|
|
for (int i = 0; i < this.indices.Length; i += 3)
|
|
{
|
|
string text2 = text;
|
|
text = string.Concat(new object[]
|
|
{
|
|
text2,
|
|
"Tri ",
|
|
i,
|
|
": ",
|
|
this._indices[i],
|
|
", ",
|
|
this._indices[i + 1],
|
|
", ",
|
|
this._indices[i + 2],
|
|
"\n"
|
|
});
|
|
}
|
|
text += "Distinct Indices:\n";
|
|
for (int j = 0; j < this.distinctIndices.Length; j++)
|
|
{
|
|
text = text + this.distinctIndices[j] + ", ";
|
|
}
|
|
return text;
|
|
}
|
|
|
|
// Token: 0x04000104 RID: 260
|
|
public const int MAX_SMOOTH_GROUPS = 24;
|
|
|
|
// Token: 0x04000105 RID: 261
|
|
[SerializeField]
|
|
private int[] _indices;
|
|
|
|
// Token: 0x04000106 RID: 262
|
|
[SerializeField]
|
|
private int[] _distinctIndices;
|
|
|
|
// Token: 0x04000107 RID: 263
|
|
[SerializeField]
|
|
private pb_Edge[] _edges;
|
|
|
|
// Token: 0x04000108 RID: 264
|
|
[SerializeField]
|
|
private int _smoothingGroup;
|
|
|
|
// Token: 0x04000109 RID: 265
|
|
[SerializeField]
|
|
private pb_UV _uv;
|
|
|
|
// Token: 0x0400010A RID: 266
|
|
[SerializeField]
|
|
private Material _mat;
|
|
|
|
// Token: 0x0400010B RID: 267
|
|
public bool manualUV;
|
|
|
|
// Token: 0x0400010C RID: 268
|
|
public int elementGroup;
|
|
|
|
// Token: 0x0400010D RID: 269
|
|
public int textureGroup = -1;
|
|
}
|
|
}
|