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

namespace ProBuilder2.Common
{
	// Token: 0x0200005A RID: 90
	public class pb_Vertex : IEquatable<pb_Vertex>
	{
		// Token: 0x06000298 RID: 664 RVA: 0x0001FB4D File Offset: 0x0001DF4D
		public pb_Vertex(bool hasAllValues = false)
		{
			this.hasPosition = hasAllValues;
			this.hasColor = hasAllValues;
			this.hasNormal = hasAllValues;
			this.hasTangent = hasAllValues;
			this.hasUv0 = hasAllValues;
			this.hasUv2 = hasAllValues;
			this.hasUv3 = hasAllValues;
			this.hasUv4 = hasAllValues;
		}

		// Token: 0x06000299 RID: 665 RVA: 0x0001FB90 File Offset: 0x0001DF90
		public pb_Vertex(pb_Vertex v)
		{
			this.position = v.position;
			this.hasPosition = v.hasPosition;
			this.color = v.color;
			this.hasColor = v.hasColor;
			this.uv0 = v.uv0;
			this.hasUv0 = v.hasUv0;
			this.normal = v.normal;
			this.hasNormal = v.hasNormal;
			this.tangent = v.tangent;
			this.hasTangent = v.hasTangent;
			this.uv2 = v.uv2;
			this.hasUv2 = v.hasUv2;
			this.uv3 = v.uv3;
			this.hasUv3 = v.hasUv3;
			this.uv4 = v.uv4;
			this.hasUv4 = v.hasUv4;
		}

		// Token: 0x0600029A RID: 666 RVA: 0x0001FC63 File Offset: 0x0001E063
		public override bool Equals(object other)
		{
			return other is pb_Vertex && this.Equals(other as pb_Vertex);
		}

		// Token: 0x0600029B RID: 667 RVA: 0x0001FC80 File Offset: 0x0001E080
		public bool Equals(pb_Vertex other)
		{
			return other != null && (this.position.Approx3(other.position, 0.0001f) && this.color.ApproxC(other.color, 0.0001f) && this.normal.Approx3(other.normal, 0.0001f) && this.tangent.Approx4(other.tangent, 0.0001f) && this.uv0.Approx2(other.uv0, 0.0001f) && this.uv2.Approx2(other.uv2, 0.0001f) && this.uv3.Approx4(other.uv3, 0.0001f)) && this.uv4.Approx4(other.uv4, 0.0001f);
		}

		// Token: 0x0600029C RID: 668 RVA: 0x0001FD6C File Offset: 0x0001E16C
		public override int GetHashCode()
		{
			int num = 783 + pb_Vector.GetHashCode(this.position);
			num = num * 29 + pb_Vector.GetHashCode(this.uv0);
			return num * 31 + pb_Vector.GetHashCode(this.normal);
		}

		// Token: 0x0600029D RID: 669 RVA: 0x0001FDB0 File Offset: 0x0001E1B0
		public static pb_Vertex operator +(pb_Vertex a, pb_Vertex b)
		{
			pb_Vertex pb_Vertex = new pb_Vertex(a);
			pb_Vertex.Add(b);
			return pb_Vertex;
		}

		// Token: 0x0600029E RID: 670 RVA: 0x0001FDCC File Offset: 0x0001E1CC
		public void Add(pb_Vertex b)
		{
			this.position += b.position;
			this.color += b.color;
			this.normal += b.normal;
			this.tangent += b.tangent;
			this.uv0 += b.uv0;
			this.uv2 += b.uv2;
			this.uv3 += b.uv3;
			this.uv4 += b.uv4;
		}

		// Token: 0x0600029F RID: 671 RVA: 0x0001FE94 File Offset: 0x0001E294
		public static pb_Vertex operator -(pb_Vertex a, pb_Vertex b)
		{
			pb_Vertex pb_Vertex = new pb_Vertex(a);
			pb_Vertex.Subtract(b);
			return pb_Vertex;
		}

		// Token: 0x060002A0 RID: 672 RVA: 0x0001FEB0 File Offset: 0x0001E2B0
		public void Subtract(pb_Vertex b)
		{
			this.position -= b.position;
			this.color -= b.color;
			this.normal -= b.normal;
			this.tangent -= b.tangent;
			this.uv0 -= b.uv0;
			this.uv2 -= b.uv2;
			this.uv3 -= b.uv3;
			this.uv4 -= b.uv4;
		}

		// Token: 0x060002A1 RID: 673 RVA: 0x0001FF78 File Offset: 0x0001E378
		public static pb_Vertex operator *(pb_Vertex a, float value)
		{
			pb_Vertex pb_Vertex = new pb_Vertex(a);
			pb_Vertex.Multiply(value);
			return pb_Vertex;
		}

		// Token: 0x060002A2 RID: 674 RVA: 0x0001FF94 File Offset: 0x0001E394
		public void Multiply(float value)
		{
			this.position *= value;
			this.color *= value;
			this.normal *= value;
			this.tangent *= value;
			this.uv0 *= value;
			this.uv2 *= value;
			this.uv3 *= value;
			this.uv4 *= value;
		}

		// Token: 0x060002A3 RID: 675 RVA: 0x00020034 File Offset: 0x0001E434
		public static pb_Vertex operator /(pb_Vertex a, float value)
		{
			pb_Vertex pb_Vertex = new pb_Vertex(a);
			pb_Vertex.Divide(value);
			return pb_Vertex;
		}

		// Token: 0x060002A4 RID: 676 RVA: 0x00020050 File Offset: 0x0001E450
		public void Divide(float value)
		{
			this.position /= value;
			this.color /= value;
			this.normal /= value;
			this.tangent /= value;
			this.uv0 /= value;
			this.uv2 /= value;
			this.uv3 /= value;
			this.uv4 /= value;
		}

		// Token: 0x060002A5 RID: 677 RVA: 0x000200F0 File Offset: 0x0001E4F0
		public void Normalize()
		{
			this.position.Normalize();
			Vector4 vector = this.color;
			vector.Normalize();
			this.color.r = vector.x;
			this.color.g = vector.y;
			this.color.b = vector.z;
			this.color.a = vector.w;
			this.normal.Normalize();
			this.tangent.Normalize();
			this.uv0.Normalize();
			this.uv2.Normalize();
			this.uv3.Normalize();
			this.uv4.Normalize();
		}

		// Token: 0x060002A6 RID: 678 RVA: 0x000201A5 File Offset: 0x0001E5A5
		public override string ToString()
		{
			return this.position.ToString();
		}

		// Token: 0x060002A7 RID: 679 RVA: 0x000201B8 File Offset: 0x0001E5B8
		public static pb_Vertex[] GetVertices(pb_Object pb, IList<int> indices = null)
		{
			int vertexCount = pb.vertexCount;
			int num = ((indices == null) ? pb.vertexCount : indices.Count);
			pb_Vertex[] array = new pb_Vertex[num];
			Vector3[] vertices = pb.vertices;
			Color[] colors = pb.colors;
			Vector2[] uv = pb.uv;
			Vector3[] normals = pb.msh.normals;
			Vector4[] tangents = pb.msh.tangents;
			Vector2[] array2 = pb.msh.uv2;
			List<Vector4> list = new List<Vector4>();
			List<Vector4> list2 = new List<Vector4>();
			pb.GetUVs(2, list);
			pb.GetUVs(3, list2);
			bool flag = vertices != null && vertices.Count<Vector3>() == vertexCount;
			bool flag2 = colors != null && colors.Count<Color>() == vertexCount;
			bool flag3 = normals != null && normals.Count<Vector3>() == vertexCount;
			bool flag4 = tangents != null && tangents.Count<Vector4>() == vertexCount;
			bool flag5 = uv != null && uv.Count<Vector2>() == vertexCount;
			bool flag6 = array2 != null && array2.Count<Vector2>() == vertexCount;
			bool flag7 = list != null && list.Count<Vector4>() == vertexCount;
			bool flag8 = list2 != null && list2.Count<Vector4>() == vertexCount;
			for (int i = 0; i < num; i++)
			{
				array[i] = new pb_Vertex(false);
				int num2 = ((indices != null) ? indices[i] : i);
				if (flag)
				{
					array[i].hasPosition = true;
					array[i].position = vertices[num2];
				}
				if (flag2)
				{
					array[i].hasColor = true;
					array[i].color = colors[num2];
				}
				if (flag3)
				{
					array[i].hasNormal = true;
					array[i].normal = normals[num2];
				}
				if (flag4)
				{
					array[i].hasTangent = true;
					array[i].tangent = tangents[num2];
				}
				if (flag5)
				{
					array[i].hasUv0 = true;
					array[i].uv0 = uv[num2];
				}
				if (flag6)
				{
					array[i].hasUv2 = true;
					array[i].uv2 = array2[num2];
				}
				if (flag7)
				{
					array[i].hasUv3 = true;
					array[i].uv3 = list[num2];
				}
				if (flag8)
				{
					array[i].hasUv4 = true;
					array[i].uv4 = list2[num2];
				}
			}
			return array;
		}

		// Token: 0x060002A8 RID: 680 RVA: 0x00020464 File Offset: 0x0001E864
		public static pb_Vertex[] GetVertices(Mesh m)
		{
			if (m == null)
			{
				return null;
			}
			int vertexCount = m.vertexCount;
			pb_Vertex[] array = new pb_Vertex[vertexCount];
			Vector3[] vertices = m.vertices;
			Color[] colors = m.colors;
			Vector3[] normals = m.normals;
			Vector4[] tangents = m.tangents;
			Vector2[] uv = m.uv;
			Vector2[] array2 = m.uv2;
			List<Vector4> list = new List<Vector4>();
			List<Vector4> list2 = new List<Vector4>();
			m.GetUVs(2, list);
			m.GetUVs(3, list2);
			bool flag = vertices != null && vertices.Count<Vector3>() == vertexCount;
			bool flag2 = colors != null && colors.Count<Color>() == vertexCount;
			bool flag3 = normals != null && normals.Count<Vector3>() == vertexCount;
			bool flag4 = tangents != null && tangents.Count<Vector4>() == vertexCount;
			bool flag5 = uv != null && uv.Count<Vector2>() == vertexCount;
			bool flag6 = array2 != null && array2.Count<Vector2>() == vertexCount;
			bool flag7 = list != null && list.Count<Vector4>() == vertexCount;
			bool flag8 = list2 != null && list2.Count<Vector4>() == vertexCount;
			for (int i = 0; i < vertexCount; i++)
			{
				array[i] = new pb_Vertex(false);
				if (flag)
				{
					array[i].hasPosition = true;
					array[i].position = vertices[i];
				}
				if (flag2)
				{
					array[i].hasColor = true;
					array[i].color = colors[i];
				}
				if (flag3)
				{
					array[i].hasNormal = true;
					array[i].normal = normals[i];
				}
				if (flag4)
				{
					array[i].hasTangent = true;
					array[i].tangent = tangents[i];
				}
				if (flag5)
				{
					array[i].hasUv0 = true;
					array[i].uv0 = uv[i];
				}
				if (flag6)
				{
					array[i].hasUv2 = true;
					array[i].uv2 = array2[i];
				}
				if (flag7)
				{
					array[i].hasUv3 = true;
					array[i].uv3 = list[i];
				}
				if (flag8)
				{
					array[i].hasUv4 = true;
					array[i].uv4 = list2[i];
				}
			}
			return array;
		}

		// Token: 0x060002A9 RID: 681 RVA: 0x000206DC File Offset: 0x0001EADC
		public static void GetArrays(IList<pb_Vertex> vertices, out Vector3[] position, out Color[] color, out Vector2[] uv0, out Vector3[] normal, out Vector4[] tangent, out Vector2[] uv2, out List<Vector4> uv3, out List<Vector4> uv4)
		{
			int count = vertices.Count;
			position = new Vector3[count];
			color = new Color[count];
			uv0 = new Vector2[count];
			normal = new Vector3[count];
			tangent = new Vector4[count];
			uv2 = new Vector2[count];
			uv3 = new List<Vector4>(count);
			uv4 = new List<Vector4>(count);
			for (int i = 0; i < count; i++)
			{
				position[i] = vertices[i].position;
				color[i] = vertices[i].color;
				uv0[i] = vertices[i].uv0;
				normal[i] = vertices[i].normal;
				tangent[i] = vertices[i].tangent;
				uv2[i] = vertices[i].uv2;
				uv3.Add(vertices[i].uv3);
				uv4.Add(vertices[i].uv4);
			}
		}

		// Token: 0x060002AA RID: 682 RVA: 0x00020808 File Offset: 0x0001EC08
		public static void SetMesh(Mesh m, IList<pb_Vertex> vertices)
		{
			Vector3[] array = null;
			Color[] array2 = null;
			Vector2[] array3 = null;
			Vector3[] array4 = null;
			Vector4[] array5 = null;
			Vector2[] array6 = null;
			List<Vector4> list = null;
			List<Vector4> list2 = null;
			pb_Vertex.GetArrays(vertices, out array, out array2, out array3, out array4, out array5, out array6, out list, out list2);
			m.Clear();
			pb_Vertex pb_Vertex = vertices[0];
			if (pb_Vertex.hasPosition)
			{
				m.vertices = array;
			}
			if (pb_Vertex.hasColor)
			{
				m.colors = array2;
			}
			if (pb_Vertex.hasUv0)
			{
				m.uv = array3;
			}
			if (pb_Vertex.hasNormal)
			{
				m.normals = array4;
			}
			if (pb_Vertex.hasTangent)
			{
				m.tangents = array5;
			}
			if (pb_Vertex.hasUv2)
			{
				m.uv2 = array6;
			}
			if (pb_Vertex.hasUv3 && list != null)
			{
				m.SetUVs(2, list);
			}
			if (pb_Vertex.hasUv4 && list2 != null)
			{
				m.SetUVs(3, list2);
			}
		}

		// Token: 0x060002AB RID: 683 RVA: 0x000208FC File Offset: 0x0001ECFC
		public static pb_Vertex Average(IList<pb_Vertex> vertices, IList<int> indices = null)
		{
			pb_Vertex pb_Vertex = new pb_Vertex(false);
			int num = ((indices == null) ? vertices.Count : indices.Count);
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			for (int i = 0; i < num; i++)
			{
				int num7 = ((indices != null) ? indices[i] : i);
				pb_Vertex.position += vertices[num7].position;
				pb_Vertex.color += vertices[num7].color;
				pb_Vertex.uv0 += vertices[num7].uv0;
				if (vertices[num7].hasNormal)
				{
					num2++;
					pb_Vertex.normal += vertices[num7].normal;
				}
				if (vertices[num7].hasTangent)
				{
					num3++;
					pb_Vertex.tangent += vertices[num7].tangent;
				}
				if (vertices[num7].hasUv2)
				{
					num4++;
					pb_Vertex.uv2 += vertices[num7].uv2;
				}
				if (vertices[num7].hasUv3)
				{
					num5++;
					pb_Vertex.uv3 += vertices[num7].uv3;
				}
				if (vertices[num7].hasUv4)
				{
					num6++;
					pb_Vertex.uv4 += vertices[num7].uv4;
				}
			}
			pb_Vertex.position *= 1f / (float)num;
			pb_Vertex.color *= 1f / (float)num;
			pb_Vertex.uv0 *= 1f / (float)num;
			pb_Vertex.normal *= 1f / (float)num2;
			pb_Vertex.tangent *= 1f / (float)num3;
			pb_Vertex.uv2 *= 1f / (float)num4;
			pb_Vertex.uv3 *= 1f / (float)num5;
			pb_Vertex.uv4 *= 1f / (float)num6;
			return pb_Vertex;
		}

		// Token: 0x060002AC RID: 684 RVA: 0x00020B94 File Offset: 0x0001EF94
		public static pb_Vertex Mix(pb_Vertex x, pb_Vertex y, float a)
		{
			float num = 1f - a;
			pb_Vertex pb_Vertex = new pb_Vertex(false);
			pb_Vertex.position = x.position * num + y.position * a;
			pb_Vertex.color = x.color * num + y.color * a;
			pb_Vertex.uv0 = x.uv0 * num + y.uv0 * a;
			if (x.hasNormal && y.hasNormal)
			{
				pb_Vertex.normal = x.normal * num + y.normal * a;
			}
			else if (x.hasNormal)
			{
				pb_Vertex.normal = x.normal;
			}
			else if (y.hasNormal)
			{
				pb_Vertex.normal = y.normal;
			}
			if (x.hasTangent && y.hasTangent)
			{
				pb_Vertex.tangent = x.tangent * num + y.tangent * a;
			}
			else if (x.hasTangent)
			{
				pb_Vertex.tangent = x.tangent;
			}
			else if (y.hasTangent)
			{
				pb_Vertex.tangent = y.tangent;
			}
			if (x.hasUv2 && y.hasUv2)
			{
				pb_Vertex.uv2 = x.uv2 * num + y.uv2 * a;
			}
			else if (x.hasUv2)
			{
				pb_Vertex.uv2 = x.uv2;
			}
			else if (y.hasUv2)
			{
				pb_Vertex.uv2 = y.uv2;
			}
			if (x.hasUv3 && y.hasUv3)
			{
				pb_Vertex.uv3 = x.uv3 * num + y.uv3 * a;
			}
			else if (x.hasUv3)
			{
				pb_Vertex.uv3 = x.uv3;
			}
			else if (y.hasUv3)
			{
				pb_Vertex.uv3 = y.uv3;
			}
			if (x.hasUv4 && y.hasUv4)
			{
				pb_Vertex.uv4 = x.uv4 * num + y.uv4 * a;
			}
			else if (x.hasUv4)
			{
				pb_Vertex.uv4 = x.uv4;
			}
			else if (y.hasUv4)
			{
				pb_Vertex.uv4 = y.uv4;
			}
			return pb_Vertex;
		}

		// Token: 0x040001D9 RID: 473
		public Vector3 position;

		// Token: 0x040001DA RID: 474
		public Color color;

		// Token: 0x040001DB RID: 475
		public Vector3 normal;

		// Token: 0x040001DC RID: 476
		public Vector4 tangent;

		// Token: 0x040001DD RID: 477
		public Vector2 uv0;

		// Token: 0x040001DE RID: 478
		public Vector2 uv2;

		// Token: 0x040001DF RID: 479
		public Vector4 uv3;

		// Token: 0x040001E0 RID: 480
		public Vector4 uv4;

		// Token: 0x040001E1 RID: 481
		public bool hasPosition;

		// Token: 0x040001E2 RID: 482
		public bool hasColor;

		// Token: 0x040001E3 RID: 483
		public bool hasNormal;

		// Token: 0x040001E4 RID: 484
		public bool hasTangent;

		// Token: 0x040001E5 RID: 485
		public bool hasUv0;

		// Token: 0x040001E6 RID: 486
		public bool hasUv2;

		// Token: 0x040001E7 RID: 487
		public bool hasUv3;

		// Token: 0x040001E8 RID: 488
		public bool hasUv4;
	}
}