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

namespace ProBuilder2.Common
{
	// Token: 0x0200003B RID: 59
	public static class pb_Projection
	{
		// Token: 0x060001DE RID: 478 RVA: 0x00017AD5 File Offset: 0x00015ED5
		public static Vector2[] PlanarProject(IList<Vector3> verts, Vector3 planeNormal)
		{
			return pb_Projection.PlanarProject(verts.ToArray<Vector3>(), planeNormal, pb_Projection.VectorToProjectionAxis(planeNormal), null);
		}

		// Token: 0x060001DF RID: 479 RVA: 0x00017AEC File Offset: 0x00015EEC
		public static Vector2[] PlanarProject(pb_Object pb, pb_Face face)
		{
			Vector3 vector = pb_Math.Normal(pb, face);
			return pb_Projection.PlanarProject(pb.vertices, vector, pb_Projection.VectorToProjectionAxis(vector), face.indices);
		}

		// Token: 0x060001E0 RID: 480 RVA: 0x00017B1C File Offset: 0x00015F1C
		public static Vector2[] PlanarProject(IList<pb_Vertex> vertices, IList<int> indices)
		{
			int count = indices.Count;
			Vector3[] array = new Vector3[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = vertices[indices[i]].position;
			}
			Vector3 vector = pb_Math.Normal(vertices, indices);
			ProjectionAxis projectionAxis = pb_Projection.VectorToProjectionAxis(vector);
			return pb_Projection.PlanarProject(array, vector, projectionAxis, null);
		}

		// Token: 0x060001E1 RID: 481 RVA: 0x00017B84 File Offset: 0x00015F84
		public static Vector2[] PlanarProject(Vector3[] verts, Vector3 planeNormal, ProjectionAxis projectionAxis, int[] indices = null)
		{
			int num = ((indices != null && indices.Length >= 1) ? indices.Length : verts.Length);
			Vector2[] array = new Vector2[num];
			Vector3 vector = Vector3.zero;
			switch (projectionAxis)
			{
			case ProjectionAxis.X:
			case ProjectionAxis.X_Negative:
				vector = Vector3.up;
				break;
			case ProjectionAxis.Y:
			case ProjectionAxis.Y_Negative:
				vector = Vector3.forward;
				break;
			case ProjectionAxis.Z:
			case ProjectionAxis.Z_Negative:
				vector = Vector3.up;
				break;
			}
			Vector3 vector2 = Vector3.Cross(planeNormal, vector);
			vector2.Normalize();
			Vector3 vector3 = Vector3.Cross(vector2, planeNormal);
			vector3.Normalize();
			for (int i = 0; i < num; i++)
			{
				int num2 = ((indices == null) ? i : indices[i]);
				float num3 = Vector3.Dot(vector2, verts[num2]);
				float num4 = Vector3.Dot(vector3, verts[num2]);
				array[i] = new Vector2(num3, num4);
			}
			return array;
		}

		// Token: 0x060001E2 RID: 482 RVA: 0x00017C88 File Offset: 0x00016088
		public static void PlanarProject(Vector3[] verts, Vector2[] uvs, int[] indices, Vector3 planeNormal, ProjectionAxis projectionAxis)
		{
			Vector3 vector;
			switch (projectionAxis)
			{
			case ProjectionAxis.X:
			case ProjectionAxis.X_Negative:
				vector = Vector3.up;
				break;
			case ProjectionAxis.Y:
			case ProjectionAxis.Y_Negative:
				vector = Vector3.forward;
				break;
			case ProjectionAxis.Z:
			case ProjectionAxis.Z_Negative:
				vector = Vector3.up;
				break;
			default:
				vector = Vector3.up;
				break;
			}
			pb_Math.Cross(planeNormal, vector, ref pb_Projection.t_uaxis.x, ref pb_Projection.t_uaxis.y, ref pb_Projection.t_uaxis.z);
			pb_Projection.t_uaxis.Normalize();
			pb_Math.Cross(pb_Projection.t_uaxis, planeNormal, ref pb_Projection.t_vaxis.x, ref pb_Projection.t_vaxis.y, ref pb_Projection.t_vaxis.z);
			pb_Projection.t_vaxis.Normalize();
			int num = indices.Length;
			for (int i = 0; i < num; i++)
			{
				int num2 = indices[i];
				uvs[num2].x = Vector3.Dot(pb_Projection.t_uaxis, verts[num2]);
				uvs[num2].y = Vector3.Dot(pb_Projection.t_vaxis, verts[num2]);
			}
		}

		// Token: 0x060001E3 RID: 483 RVA: 0x00017DA8 File Offset: 0x000161A8
		public static Vector2[] SphericalProject(IList<Vector3> vertices, IList<int> indices = null)
		{
			int num = ((indices != null) ? indices.Count : vertices.Count);
			Vector2[] array = new Vector2[num];
			Vector3 vector = pb_Math.Average(vertices, indices);
			for (int i = 0; i < num; i++)
			{
				int num2 = ((indices != null) ? indices[i] : i);
				Vector3 vector2 = vertices[num2] - vector;
				vector2.Normalize();
				array[i].x = 0.5f + Mathf.Atan2(vector2.z, vector2.x) / 6.2831855f;
				array[i].y = 0.5f - Mathf.Asin(vector2.y) / 3.1415927f;
			}
			return array;
		}

		// Token: 0x060001E4 RID: 484 RVA: 0x00017E6C File Offset: 0x0001626C
		public static IList<Vector2> Sort(IList<Vector2> verts, SortMethod method = SortMethod.CounterClockwise)
		{
			Vector2 vector = pb_Math.Average(verts, null);
			Vector2 up = Vector2.up;
			int count = verts.Count;
			List<pb_Tuple<float, Vector2>> list = new List<pb_Tuple<float, Vector2>>(count);
			for (int i = 0; i < count; i++)
			{
				list.Add(new pb_Tuple<float, Vector2>(pb_Math.SignedAngle(up, verts[i] - vector), verts[i]));
			}
			list.Sort((pb_Tuple<float, Vector2> a, pb_Tuple<float, Vector2> b) => (a.Item1 >= b.Item1) ? 1 : (-1));
			IList<Vector2> list2 = list.Select((pb_Tuple<float, Vector2> x) => x.Item2).ToList<Vector2>();
			if (method == SortMethod.Clockwise)
			{
				list2.Reverse<Vector2>();
			}
			return list2;
		}

		// Token: 0x060001E5 RID: 485 RVA: 0x00017F30 File Offset: 0x00016330
		public static Vector3 ProjectionAxisToVector(ProjectionAxis axis)
		{
			switch (axis)
			{
			case ProjectionAxis.X:
				return Vector3.right;
			case ProjectionAxis.Y:
				return Vector3.up;
			case ProjectionAxis.Z:
				return Vector3.forward;
			case ProjectionAxis.X_Negative:
				return -Vector3.right;
			case ProjectionAxis.Y_Negative:
				return -Vector3.up;
			case ProjectionAxis.Z_Negative:
				return -Vector3.forward;
			default:
				return Vector3.zero;
			}
		}

		// Token: 0x060001E6 RID: 486 RVA: 0x00017F98 File Offset: 0x00016398
		public static ProjectionAxis VectorToProjectionAxis(Vector3 plane)
		{
			if (Mathf.Abs(plane.x) > Mathf.Abs(plane.y) && Mathf.Abs(plane.x) > Mathf.Abs(plane.z))
			{
				return (plane.x <= 0f) ? ProjectionAxis.X_Negative : ProjectionAxis.X;
			}
			if (Mathf.Abs(plane.y) > Mathf.Abs(plane.z))
			{
				return (plane.y <= 0f) ? ProjectionAxis.Y_Negative : ProjectionAxis.Y;
			}
			return (plane.z <= 0f) ? ProjectionAxis.Z_Negative : ProjectionAxis.Z;
		}

		// Token: 0x060001E7 RID: 487 RVA: 0x00018048 File Offset: 0x00016448
		public static Plane FindBestPlane<T>(IList<T> points, Func<T, Vector3> selector, IList<int> indices = null)
		{
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			float num5 = 0f;
			float num6 = 0f;
			bool flag = indices != null && indices.Count > 0;
			int num7 = ((!flag) ? points.Count : indices.Count);
			Vector3 vector = points.Average(selector, indices);
			for (int i = 0; i < num7; i++)
			{
				Vector3 vector2 = selector(points[(!flag) ? i : indices[i]]) - vector;
				num += vector2.x * vector2.x;
				num2 += vector2.x * vector2.y;
				num3 += vector2.x * vector2.z;
				num4 += vector2.y * vector2.y;
				num5 += vector2.y * vector2.z;
				num6 += vector2.z * vector2.z;
			}
			float num8 = num4 * num6 - num5 * num5;
			float num9 = num * num6 - num3 * num3;
			float num10 = num * num4 - num2 * num2;
			Vector3 vector3;
			if (num8 > num9 && num8 > num10)
			{
				vector3 = new Vector3(1f, (num3 * num5 - num2 * num6) / num8, (num2 * num5 - num3 * num4) / num8);
			}
			else if (num9 > num10)
			{
				vector3 = new Vector3((num5 * num3 - num2 * num6) / num9, 1f, (num2 * num3 - num5 * num) / num9);
			}
			else
			{
				vector3 = new Vector3((num5 * num2 - num3 * num4) / num10, (num3 * num2 - num5 * num) / num10, 1f);
			}
			vector3.Normalize();
			return new Plane(vector3, vector);
		}

		// Token: 0x060001E8 RID: 488 RVA: 0x00018224 File Offset: 0x00016624
		public static Plane FindBestPlane(Vector3[] points, int[] indices = null)
		{
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			float num5 = 0f;
			float num6 = 0f;
			bool flag = indices != null && indices.Length > 0;
			int num7 = ((!flag) ? points.Length : indices.Length);
			Vector3 zero = Vector3.zero;
			Vector3 zero2 = Vector3.zero;
			for (int i = 0; i < num7; i++)
			{
				zero.x += points[(!flag) ? i : indices[i]].x;
				zero.y += points[(!flag) ? i : indices[i]].y;
				zero.z += points[(!flag) ? i : indices[i]].z;
			}
			zero.x /= (float)num7;
			zero.y /= (float)num7;
			zero.z /= (float)num7;
			for (int j = 0; j < num7; j++)
			{
				Vector3 vector = points[(!flag) ? j : indices[j]] - zero;
				num += vector.x * vector.x;
				num2 += vector.x * vector.y;
				num3 += vector.x * vector.z;
				num4 += vector.y * vector.y;
				num5 += vector.y * vector.z;
				num6 += vector.z * vector.z;
			}
			float num8 = num4 * num6 - num5 * num5;
			float num9 = num * num6 - num3 * num3;
			float num10 = num * num4 - num2 * num2;
			if (num8 > num9 && num8 > num10)
			{
				zero2.x = 1f;
				zero2.y = (num3 * num5 - num2 * num6) / num8;
				zero2.z = (num2 * num5 - num3 * num4) / num8;
			}
			else if (num9 > num10)
			{
				zero2.x = (num5 * num3 - num2 * num6) / num9;
				zero2.y = 1f;
				zero2.z = (num2 * num3 - num5 * num) / num9;
			}
			else
			{
				zero2.x = (num5 * num2 - num3 * num4) / num10;
				zero2.y = (num3 * num2 - num5 * num) / num10;
				zero2.z = 1f;
			}
			zero2.Normalize();
			return new Plane(zero2, zero);
		}

		// Token: 0x0400016B RID: 363
		private static Vector3 t_uaxis = Vector3.zero;

		// Token: 0x0400016C RID: 364
		private static Vector3 t_vaxis = Vector3.zero;
	}
}