using System;
using System.Collections.Generic;
using UnityEngine.EventSystems;
using UnityEngine.Serialization;

namespace UnityEngine.UI
{
	// Token: 0x0200004A RID: 74
	[AddComponentMenu("Event/Graphic Raycaster")]
	[RequireComponent(typeof(Canvas))]
	public class GraphicRaycaster : BaseRaycaster
	{
		// Token: 0x0600025F RID: 607 RVA: 0x0000BF2F File Offset: 0x0000A32F
		protected GraphicRaycaster()
		{
		}

		// Token: 0x1700009B RID: 155
		// (get) Token: 0x06000260 RID: 608 RVA: 0x0000BF60 File Offset: 0x0000A360
		public override int sortOrderPriority
		{
			get
			{
				int num;
				if (this.canvas.renderMode == RenderMode.ScreenSpaceOverlay)
				{
					num = this.canvas.sortingOrder;
				}
				else
				{
					num = base.sortOrderPriority;
				}
				return num;
			}
		}

		// Token: 0x1700009C RID: 156
		// (get) Token: 0x06000261 RID: 609 RVA: 0x0000BF9C File Offset: 0x0000A39C
		public override int renderOrderPriority
		{
			get
			{
				int num;
				if (this.canvas.renderMode == RenderMode.ScreenSpaceOverlay)
				{
					num = this.canvas.rootCanvas.renderOrder;
				}
				else
				{
					num = base.renderOrderPriority;
				}
				return num;
			}
		}

		// Token: 0x1700009D RID: 157
		// (get) Token: 0x06000262 RID: 610 RVA: 0x0000BFE0 File Offset: 0x0000A3E0
		// (set) Token: 0x06000263 RID: 611 RVA: 0x0000BFFB File Offset: 0x0000A3FB
		public bool ignoreReversedGraphics
		{
			get
			{
				return this.m_IgnoreReversedGraphics;
			}
			set
			{
				this.m_IgnoreReversedGraphics = value;
			}
		}

		// Token: 0x1700009E RID: 158
		// (get) Token: 0x06000264 RID: 612 RVA: 0x0000C008 File Offset: 0x0000A408
		// (set) Token: 0x06000265 RID: 613 RVA: 0x0000C023 File Offset: 0x0000A423
		public GraphicRaycaster.BlockingObjects blockingObjects
		{
			get
			{
				return this.m_BlockingObjects;
			}
			set
			{
				this.m_BlockingObjects = value;
			}
		}

		// Token: 0x1700009F RID: 159
		// (get) Token: 0x06000266 RID: 614 RVA: 0x0000C030 File Offset: 0x0000A430
		private Canvas canvas
		{
			get
			{
				Canvas canvas;
				if (this.m_Canvas != null)
				{
					canvas = this.m_Canvas;
				}
				else
				{
					this.m_Canvas = base.GetComponent<Canvas>();
					canvas = this.m_Canvas;
				}
				return canvas;
			}
		}

		// Token: 0x06000267 RID: 615 RVA: 0x0000C074 File Offset: 0x0000A474
		public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
		{
			if (!(this.canvas == null))
			{
				int num;
				if (this.canvas.renderMode == RenderMode.ScreenSpaceOverlay || !this.eventCamera)
				{
					num = this.canvas.targetDisplay;
				}
				else
				{
					num = this.eventCamera.targetDisplay;
				}
				Vector3 vector = Display.RelativeMouseAt(eventData.position);
				if (vector != Vector3.zero)
				{
					int num2 = (int)vector.z;
					if (num2 != num)
					{
						return;
					}
				}
				else
				{
					vector = eventData.position;
				}
				Vector2 vector2;
				if (this.eventCamera == null)
				{
					float num3 = (float)Screen.width;
					float num4 = (float)Screen.height;
					if (num > 0 && num < Display.displays.Length)
					{
						num3 = (float)Display.displays[num].systemWidth;
						num4 = (float)Display.displays[num].systemHeight;
					}
					vector2 = new Vector2(vector.x / num3, vector.y / num4);
				}
				else
				{
					vector2 = this.eventCamera.ScreenToViewportPoint(vector);
				}
				if (vector2.x >= 0f && vector2.x <= 1f && vector2.y >= 0f && vector2.y <= 1f)
				{
					float num5 = float.MaxValue;
					Ray ray = default(Ray);
					if (this.eventCamera != null)
					{
						ray = this.eventCamera.ScreenPointToRay(vector);
					}
					if (this.canvas.renderMode != RenderMode.ScreenSpaceOverlay && this.blockingObjects != GraphicRaycaster.BlockingObjects.None)
					{
						float num6 = 100f;
						if (this.eventCamera != null)
						{
							float z = ray.direction.z;
							num6 = ((!Mathf.Approximately(0f, z)) ? Mathf.Abs((this.eventCamera.farClipPlane - this.eventCamera.nearClipPlane) / z) : float.PositiveInfinity);
						}
						if (this.blockingObjects == GraphicRaycaster.BlockingObjects.ThreeD || this.blockingObjects == GraphicRaycaster.BlockingObjects.All)
						{
							if (ReflectionMethodsCache.Singleton.raycast3D != null)
							{
								RaycastHit[] array = ReflectionMethodsCache.Singleton.raycast3DAll(ray, num6, this.m_BlockingMask);
								if (array.Length > 0)
								{
									num5 = array[0].distance;
								}
							}
						}
						if (this.blockingObjects == GraphicRaycaster.BlockingObjects.TwoD || this.blockingObjects == GraphicRaycaster.BlockingObjects.All)
						{
							if (ReflectionMethodsCache.Singleton.raycast2D != null)
							{
								RaycastHit2D[] array2 = ReflectionMethodsCache.Singleton.getRayIntersectionAll(ray, num6, this.m_BlockingMask);
								if (array2.Length > 0)
								{
									num5 = array2[0].distance;
								}
							}
						}
					}
					this.m_RaycastResults.Clear();
					GraphicRaycaster.Raycast(this.canvas, this.eventCamera, vector, this.m_RaycastResults);
					int i = 0;
					while (i < this.m_RaycastResults.Count)
					{
						GameObject gameObject = this.m_RaycastResults[i].gameObject;
						bool flag = true;
						if (this.ignoreReversedGraphics)
						{
							if (this.eventCamera == null)
							{
								Vector3 vector3 = gameObject.transform.rotation * Vector3.forward;
								flag = Vector3.Dot(Vector3.forward, vector3) > 0f;
							}
							else
							{
								Vector3 vector4 = this.eventCamera.transform.rotation * Vector3.forward;
								Vector3 vector5 = gameObject.transform.rotation * Vector3.forward;
								flag = Vector3.Dot(vector4, vector5) > 0f;
							}
						}
						if (flag)
						{
							float num7;
							if (this.eventCamera == null || this.canvas.renderMode == RenderMode.ScreenSpaceOverlay)
							{
								num7 = 0f;
							}
							else
							{
								Transform transform = gameObject.transform;
								Vector3 forward = transform.forward;
								num7 = Vector3.Dot(forward, transform.position - this.eventCamera.transform.position) / Vector3.Dot(forward, ray.direction);
								if (num7 < 0f)
								{
									goto IL_4F9;
								}
							}
							if (num7 < num5)
							{
								RaycastResult raycastResult = new RaycastResult
								{
									gameObject = gameObject,
									module = this,
									distance = num7,
									screenPosition = vector,
									index = (float)resultAppendList.Count,
									depth = this.m_RaycastResults[i].depth,
									sortingLayer = this.canvas.sortingLayerID,
									sortingOrder = this.canvas.sortingOrder
								};
								resultAppendList.Add(raycastResult);
							}
						}
						IL_4F9:
						i++;
						continue;
						goto IL_4F9;
					}
				}
			}
		}

		// Token: 0x170000A0 RID: 160
		// (get) Token: 0x06000268 RID: 616 RVA: 0x0000C594 File Offset: 0x0000A994
		public override Camera eventCamera
		{
			get
			{
				Camera camera;
				if (this.canvas.renderMode == RenderMode.ScreenSpaceOverlay || (this.canvas.renderMode == RenderMode.ScreenSpaceCamera && this.canvas.worldCamera == null))
				{
					camera = null;
				}
				else
				{
					camera = ((!(this.canvas.worldCamera != null)) ? Camera.main : this.canvas.worldCamera);
				}
				return camera;
			}
		}

		// Token: 0x06000269 RID: 617 RVA: 0x0000C614 File Offset: 0x0000AA14
		private static void Raycast(Canvas canvas, Camera eventCamera, Vector2 pointerPosition, List<Graphic> results)
		{
			IList<Graphic> graphicsForCanvas = GraphicRegistry.GetGraphicsForCanvas(canvas);
			for (int i = 0; i < graphicsForCanvas.Count; i++)
			{
				Graphic graphic = graphicsForCanvas[i];
				if (!graphic.canvasRenderer.cull)
				{
					if (graphic.depth != -1 && graphic.raycastTarget)
					{
						if (RectTransformUtility.RectangleContainsScreenPoint(graphic.rectTransform, pointerPosition, eventCamera))
						{
							if (graphic.Raycast(pointerPosition, eventCamera))
							{
								GraphicRaycaster.s_SortedGraphics.Add(graphic);
							}
						}
					}
				}
			}
			GraphicRaycaster.s_SortedGraphics.Sort((Graphic g1, Graphic g2) => g2.depth.CompareTo(g1.depth));
			for (int j = 0; j < GraphicRaycaster.s_SortedGraphics.Count; j++)
			{
				results.Add(GraphicRaycaster.s_SortedGraphics[j]);
			}
			GraphicRaycaster.s_SortedGraphics.Clear();
		}

		// Token: 0x04000118 RID: 280
		protected const int kNoEventMaskSet = -1;

		// Token: 0x04000119 RID: 281
		[FormerlySerializedAs("ignoreReversedGraphics")]
		[SerializeField]
		private bool m_IgnoreReversedGraphics = true;

		// Token: 0x0400011A RID: 282
		[FormerlySerializedAs("blockingObjects")]
		[SerializeField]
		private GraphicRaycaster.BlockingObjects m_BlockingObjects = GraphicRaycaster.BlockingObjects.None;

		// Token: 0x0400011B RID: 283
		[SerializeField]
		protected LayerMask m_BlockingMask = -1;

		// Token: 0x0400011C RID: 284
		private Canvas m_Canvas;

		// Token: 0x0400011D RID: 285
		[NonSerialized]
		private List<Graphic> m_RaycastResults = new List<Graphic>();

		// Token: 0x0400011E RID: 286
		[NonSerialized]
		private static readonly List<Graphic> s_SortedGraphics = new List<Graphic>();

		// Token: 0x0200004B RID: 75
		public enum BlockingObjects
		{
			// Token: 0x04000121 RID: 289
			None,
			// Token: 0x04000122 RID: 290
			TwoD,
			// Token: 0x04000123 RID: 291
			ThreeD,
			// Token: 0x04000124 RID: 292
			All
		}
	}
}