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

namespace ProBuilder2.Common
{
	// Token: 0x02000026 RID: 38
	public static class pb_HandleUtility
	{
		// Token: 0x060000BB RID: 187 RVA: 0x000100A5 File Offset: 0x0000E4A5
		public static bool FaceRaycast(Ray InWorldRay, pb_Object mesh, out pb_RaycastHit hit, HashSet<pb_Face> ignore = null)
		{
			return pb_HandleUtility.FaceRaycast(InWorldRay, mesh, out hit, float.PositiveInfinity, Culling.Front, ignore);
		}

		// Token: 0x060000BC RID: 188 RVA: 0x000100B8 File Offset: 0x0000E4B8
		public static bool FaceRaycast(Ray InWorldRay, pb_Object mesh, out pb_RaycastHit hit, float distance, Culling cullingMode, HashSet<pb_Face> ignore = null)
		{
			InWorldRay.origin -= mesh.transform.position;
			InWorldRay.origin = mesh.transform.worldToLocalMatrix * InWorldRay.origin;
			InWorldRay.direction = mesh.transform.worldToLocalMatrix * InWorldRay.direction;
			Vector3[] vertices = mesh.vertices;
			float num = 0f;
			Vector3 zero = Vector3.zero;
			float num2 = float.PositiveInfinity;
			int num3 = -1;
			Vector3 vector = Vector3.zero;
			for (int i = 0; i < mesh.faces.Length; i++)
			{
				if (ignore == null || !ignore.Contains(mesh.faces[i]))
				{
					int[] indices = mesh.faces[i].indices;
					for (int j = 0; j < indices.Length; j += 3)
					{
						Vector3 vector2 = vertices[indices[j]];
						Vector3 vector3 = vertices[indices[j + 1]];
						Vector3 vector4 = vertices[indices[j + 2]];
						Vector3 vector5 = Vector3.Cross(vector3 - vector2, vector4 - vector2);
						float num4 = Vector3.Dot(InWorldRay.direction, vector5);
						bool flag = false;
						if (cullingMode != Culling.Front)
						{
							if (cullingMode == Culling.Back)
							{
								if (num4 < 0f)
								{
									flag = true;
								}
							}
						}
						else if (num4 > 0f)
						{
							flag = true;
						}
						if (!flag && pb_Math.RayIntersectsTriangle(InWorldRay, vector2, vector3, vector4, out num, out zero))
						{
							if (num <= num2 && num <= distance)
							{
								vector = vector5;
								num3 = i;
								num2 = num;
							}
						}
					}
				}
			}
			hit = new pb_RaycastHit(num2, InWorldRay.GetPoint(num2), vector, num3);
			return num3 > -1;
		}

		// Token: 0x060000BD RID: 189 RVA: 0x000102B8 File Offset: 0x0000E6B8
		public static bool FaceRaycast(Ray InWorldRay, pb_Object mesh, out List<pb_RaycastHit> hits, float distance, Culling cullingMode, HashSet<pb_Face> ignore = null)
		{
			InWorldRay.origin -= mesh.transform.position;
			InWorldRay.origin = mesh.transform.worldToLocalMatrix * InWorldRay.origin;
			InWorldRay.direction = mesh.transform.worldToLocalMatrix * InWorldRay.direction;
			Vector3[] vertices = mesh.vertices;
			float num = 0f;
			Vector3 zero = Vector3.zero;
			hits = new List<pb_RaycastHit>();
			for (int i = 0; i < mesh.faces.Length; i++)
			{
				if (ignore == null || !ignore.Contains(mesh.faces[i]))
				{
					int[] indices = mesh.faces[i].indices;
					for (int j = 0; j < indices.Length; j += 3)
					{
						Vector3 vector = vertices[indices[j]];
						Vector3 vector2 = vertices[indices[j + 1]];
						Vector3 vector3 = vertices[indices[j + 2]];
						if (pb_Math.RayIntersectsTriangle(InWorldRay, vector, vector2, vector3, out num, out zero))
						{
							Vector3 vector4 = Vector3.Cross(vector2 - vector, vector3 - vector);
							if (cullingMode != Culling.Front)
							{
								if (cullingMode != Culling.Back)
								{
									if (cullingMode == Culling.FrontBack)
									{
										goto IL_199;
									}
								}
								else
								{
									float num2 = Vector3.Dot(InWorldRay.direction, vector4);
									if (num2 > 0f)
									{
										goto IL_199;
									}
								}
							}
							else
							{
								float num2 = Vector3.Dot(InWorldRay.direction, -vector4);
								if (num2 > 0f)
								{
									goto IL_199;
								}
							}
							goto IL_1BC;
							IL_199:
							hits.Add(new pb_RaycastHit(num, InWorldRay.GetPoint(num), vector4, i));
						}
						IL_1BC:;
					}
				}
			}
			return hits.Count > 0;
		}

		// Token: 0x060000BE RID: 190 RVA: 0x000104B4 File Offset: 0x0000E8B4
		public static Ray InverseTransformRay(this Transform transform, Ray InWorldRay)
		{
			Vector3 vector = InWorldRay.origin;
			vector -= transform.position;
			vector = transform.worldToLocalMatrix * vector;
			Vector3 vector2 = transform.worldToLocalMatrix.MultiplyVector(InWorldRay.direction);
			return new Ray(vector, vector2);
		}

		// Token: 0x060000BF RID: 191 RVA: 0x0001050C File Offset: 0x0000E90C
		public static bool WorldRaycast(Ray InWorldRay, Transform transform, Vector3[] vertices, int[] triangles, out pb_RaycastHit hit, float distance = float.PositiveInfinity, Culling cullingMode = Culling.Front)
		{
			Ray ray = transform.InverseTransformRay(InWorldRay);
			return pb_HandleUtility.MeshRaycast(ray, vertices, triangles, out hit, distance, cullingMode);
		}

		// Token: 0x060000C0 RID: 192 RVA: 0x00010530 File Offset: 0x0000E930
		public static bool MeshRaycast(Ray InRay, Vector3[] vertices, int[] triangles, out pb_RaycastHit hit, float distance = float.PositiveInfinity, Culling cullingMode = Culling.Front)
		{
			float num = float.PositiveInfinity;
			Vector3 vector = new Vector3(0f, 0f, 0f);
			int num2 = -1;
			Vector3 origin = InRay.origin;
			Vector3 direction = InRay.direction;
			for (int i = 0; i < triangles.Length; i += 3)
			{
				Vector3 vector2 = vertices[triangles[i]];
				Vector3 vector3 = vertices[triangles[i + 1]];
				Vector3 vector4 = vertices[triangles[i + 2]];
				if (pb_Math.RayIntersectsTriangle2(origin, direction, vector2, vector3, vector4, ref distance, ref vector))
				{
					num2 = i / 3;
					num = distance;
					break;
				}
			}
			hit = new pb_RaycastHit(num, InRay.GetPoint(num), vector, num2);
			return num2 > -1;
		}

		// Token: 0x060000C1 RID: 193 RVA: 0x000105F8 File Offset: 0x0000E9F8
		public static bool EdgeRaycast(Camera cam, Vector2 mousePosition, pb_Object mesh, pb_Edge[] edges, Vector3[] verticesInWorldSpace, out pb_Edge edge)
		{
			float num = float.PositiveInfinity;
			edge = null;
			GameObject gameObject = pb_HandleUtility.ObjectRaycast(cam, mousePosition, (GameObject[])Resources.FindObjectsOfTypeAll(typeof(GameObject)));
			if (gameObject == null || gameObject != mesh.gameObject)
			{
				int width = Screen.width;
				int height = Screen.height;
				for (int i = 0; i < edges.Length; i++)
				{
					Vector3 vector = verticesInWorldSpace[edges[i].x];
					Vector3 vector2 = verticesInWorldSpace[edges[i].y];
					float num2 = pb_HandleUtility.DistancePoint2DToLine(cam, mousePosition, vector, vector2);
					if (num2 < num && num2 < 20f)
					{
						Vector3 vector3 = cam.WorldToScreenPoint(vector);
						if (vector3.z > 0f && vector3.x >= 0f && vector3.y >= 0f && vector3.x <= (float)width && vector3.y <= (float)height)
						{
							Vector3 vector4 = cam.WorldToScreenPoint(vector2);
							if (vector4.z > 0f && vector4.x >= 0f && vector4.y >= 0f && vector4.x <= (float)width && vector4.y <= (float)height)
							{
								num = num2;
								edge = edges[i];
							}
						}
					}
				}
			}
			else
			{
				Ray ray = cam.ScreenPointToRay(mousePosition);
				List<pb_RaycastHit> list;
				if (pb_HandleUtility.FaceRaycast(ray, mesh, out list, float.PositiveInfinity, Culling.FrontBack, null))
				{
					list.Sort((pb_RaycastHit x, pb_RaycastHit y) => x.distance.CompareTo(y.distance));
					Vector3[] vertices = mesh.vertices;
					for (int j = 0; j < list.Count; j++)
					{
						if (!pb_HandleUtility.PointIsOccluded(cam, mesh, mesh.transform.TransformPoint(list[j].point)))
						{
							foreach (pb_Edge pb_Edge in mesh.faces[list[j].face].GetAllEdges())
							{
								float num3 = pb_Math.DistancePointLineSegment(list[j].point, vertices[pb_Edge.x], vertices[pb_Edge.y]);
								if (num3 < num)
								{
									num = num3;
									edge = pb_Edge;
								}
							}
							if (Vector3.Dot(ray.direction, mesh.transform.TransformDirection(list[j].normal)) < 0f)
							{
								break;
							}
						}
					}
					if (edge != null && pb_HandleUtility.DistancePoint2DToLine(cam, mousePosition, mesh.transform.TransformPoint(vertices[edge.x]), mesh.transform.TransformPoint(vertices[edge.y])) > 20f)
					{
						edge = null;
					}
				}
			}
			return edge != null;
		}

		// Token: 0x060000C2 RID: 194 RVA: 0x00010940 File Offset: 0x0000ED40
		public static GameObject ObjectRaycast(Camera cam, Vector2 mousePosition, GameObject[] objects)
		{
			return null;
		}

		// Token: 0x060000C3 RID: 195 RVA: 0x00010944 File Offset: 0x0000ED44
		public static float DistancePoint2DToLine(Camera cam, Vector2 mousePosition, Vector3 worldPosition1, Vector3 worldPosition2)
		{
			Vector2 vector = cam.WorldToScreenPoint(worldPosition1);
			Vector2 vector2 = cam.WorldToScreenPoint(worldPosition2);
			return pb_Math.DistancePointLineSegment(mousePosition, vector, vector2);
		}

		// Token: 0x060000C4 RID: 196 RVA: 0x00010974 File Offset: 0x0000ED74
		public static bool PointIsOccluded(Camera cam, pb_Object pb, Vector3 worldPoint)
		{
			Vector3 normalized = (cam.transform.position - worldPoint).normalized;
			Ray ray = new Ray(worldPoint + normalized * 0.0001f, normalized);
			pb_RaycastHit pb_RaycastHit;
			return pb_HandleUtility.FaceRaycast(ray, pb, out pb_RaycastHit, Vector3.Distance(cam.transform.position, worldPoint), Culling.Back, null);
		}

		// Token: 0x060000C5 RID: 197 RVA: 0x000109D0 File Offset: 0x0000EDD0
		public static bool IsOccluded(Camera cam, pb_Object pb, pb_Face face)
		{
			Vector3 vector = Vector3.zero;
			int num = face.distinctIndices.Length;
			for (int i = 0; i < num; i++)
			{
				vector += pb.vertices[face.distinctIndices[i]];
			}
			vector *= 1f / (float)num;
			return pb_HandleUtility.PointIsOccluded(cam, pb, pb.transform.TransformPoint(vector));
		}

		// Token: 0x0400010E RID: 270
		private const float MAX_EDGE_SELECT_DISTANCE = 20f;
	}
}