using System;

namespace UnityEngine
{
	// Token: 0x02000181 RID: 385
	[Serializable]
	public struct ContactFilter2D
	{
		// Token: 0x06001D23 RID: 7459 RVA: 0x000242C4 File Offset: 0x000224C4
		public ContactFilter2D NoFilter()
		{
			this.useTriggers = true;
			this.useLayerMask = false;
			this.layerMask = -1;
			this.useDepth = false;
			this.useOutsideDepth = false;
			this.minDepth = float.NegativeInfinity;
			this.maxDepth = float.PositiveInfinity;
			this.useNormalAngle = false;
			this.useOutsideNormalAngle = false;
			this.minNormalAngle = 0f;
			this.maxNormalAngle = 359.9999f;
			return this;
		}

		// Token: 0x06001D24 RID: 7460 RVA: 0x00024344 File Offset: 0x00022544
		private void CheckConsistency()
		{
			this.minDepth = ((this.minDepth != float.NegativeInfinity && this.minDepth != float.PositiveInfinity && !float.IsNaN(this.minDepth)) ? this.minDepth : float.MinValue);
			this.maxDepth = ((this.maxDepth != float.NegativeInfinity && this.maxDepth != float.PositiveInfinity && !float.IsNaN(this.maxDepth)) ? this.maxDepth : float.MaxValue);
			if (this.minDepth > this.maxDepth)
			{
				float num = this.minDepth;
				this.minDepth = this.maxDepth;
				this.maxDepth = num;
			}
			this.minNormalAngle = ((!float.IsNaN(this.minNormalAngle)) ? Mathf.Clamp(this.minNormalAngle, 0f, 359.9999f) : 0f);
			this.maxNormalAngle = ((!float.IsNaN(this.maxNormalAngle)) ? Mathf.Clamp(this.maxNormalAngle, 0f, 359.9999f) : 359.9999f);
			if (this.minNormalAngle > this.maxNormalAngle)
			{
				float num2 = this.minNormalAngle;
				this.minNormalAngle = this.maxNormalAngle;
				this.maxNormalAngle = num2;
			}
		}

		// Token: 0x06001D25 RID: 7461 RVA: 0x000244A4 File Offset: 0x000226A4
		public void ClearLayerMask()
		{
			this.useLayerMask = false;
		}

		// Token: 0x06001D26 RID: 7462 RVA: 0x000244B0 File Offset: 0x000226B0
		public void SetLayerMask(LayerMask layerMask)
		{
			this.layerMask = layerMask;
			this.useLayerMask = true;
		}

		// Token: 0x06001D27 RID: 7463 RVA: 0x000244C4 File Offset: 0x000226C4
		public void ClearDepth()
		{
			this.useDepth = false;
		}

		// Token: 0x06001D28 RID: 7464 RVA: 0x000244D0 File Offset: 0x000226D0
		public void SetDepth(float minDepth, float maxDepth)
		{
			this.minDepth = minDepth;
			this.maxDepth = maxDepth;
			this.useDepth = true;
			this.CheckConsistency();
		}

		// Token: 0x06001D29 RID: 7465 RVA: 0x000244F0 File Offset: 0x000226F0
		public void ClearNormalAngle()
		{
			this.useNormalAngle = false;
		}

		// Token: 0x06001D2A RID: 7466 RVA: 0x000244FC File Offset: 0x000226FC
		public void SetNormalAngle(float minNormalAngle, float maxNormalAngle)
		{
			this.minNormalAngle = minNormalAngle;
			this.maxNormalAngle = maxNormalAngle;
			this.useNormalAngle = true;
			this.CheckConsistency();
		}

		// Token: 0x17000651 RID: 1617
		// (get) Token: 0x06001D2B RID: 7467 RVA: 0x0002451C File Offset: 0x0002271C
		public bool isFiltering
		{
			get
			{
				return !this.useTriggers || this.useLayerMask || this.useDepth || this.useNormalAngle;
			}
		}

		// Token: 0x06001D2C RID: 7468 RVA: 0x0002455C File Offset: 0x0002275C
		public bool IsFilteringTrigger(Collider2D collider)
		{
			return !this.useTriggers && collider.isTrigger;
		}

		// Token: 0x06001D2D RID: 7469 RVA: 0x00024588 File Offset: 0x00022788
		public bool IsFilteringLayerMask(GameObject obj)
		{
			return this.useLayerMask && (this.layerMask & (1 << obj.layer)) == 0;
		}

		// Token: 0x06001D2E RID: 7470 RVA: 0x000245C8 File Offset: 0x000227C8
		public bool IsFilteringDepth(GameObject obj)
		{
			bool flag;
			if (!this.useDepth)
			{
				flag = false;
			}
			else
			{
				if (this.minDepth > this.maxDepth)
				{
					float num = this.minDepth;
					this.minDepth = this.maxDepth;
					this.maxDepth = num;
				}
				float z = obj.transform.position.z;
				bool flag2 = z < this.minDepth || z > this.maxDepth;
				if (this.useOutsideDepth)
				{
					flag = !flag2;
				}
				else
				{
					flag = flag2;
				}
			}
			return flag;
		}

		// Token: 0x06001D2F RID: 7471 RVA: 0x00024664 File Offset: 0x00022864
		public bool IsFilteringNormalAngle(Vector2 normal)
		{
			float num = Mathf.Atan2(normal.y, normal.x) * 57.29578f;
			return this.IsFilteringNormalAngle(num);
		}

		// Token: 0x06001D30 RID: 7472 RVA: 0x0002469C File Offset: 0x0002289C
		public bool IsFilteringNormalAngle(float angle)
		{
			angle -= Mathf.Floor(angle / 359.9999f) * 359.9999f;
			float num = Mathf.Clamp(this.minNormalAngle, 0f, 359.9999f);
			float num2 = Mathf.Clamp(this.maxNormalAngle, 0f, 359.9999f);
			if (num > num2)
			{
				float num3 = num;
				num = num2;
				num2 = num3;
			}
			bool flag = angle < num || angle > num2;
			bool flag2;
			if (this.useOutsideNormalAngle)
			{
				flag2 = !flag;
			}
			else
			{
				flag2 = flag;
			}
			return flag2;
		}

		// Token: 0x06001D31 RID: 7473 RVA: 0x0002472C File Offset: 0x0002292C
		internal static ContactFilter2D CreateLegacyFilter(int layerMask, float minDepth, float maxDepth)
		{
			ContactFilter2D contactFilter2D = default(ContactFilter2D);
			contactFilter2D.useTriggers = Physics2D.queriesHitTriggers;
			contactFilter2D.SetLayerMask(layerMask);
			contactFilter2D.SetDepth(minDepth, maxDepth);
			return contactFilter2D;
		}

		// Token: 0x04000439 RID: 1081
		public bool useTriggers;

		// Token: 0x0400043A RID: 1082
		public bool useLayerMask;

		// Token: 0x0400043B RID: 1083
		public bool useDepth;

		// Token: 0x0400043C RID: 1084
		public bool useOutsideDepth;

		// Token: 0x0400043D RID: 1085
		public bool useNormalAngle;

		// Token: 0x0400043E RID: 1086
		public bool useOutsideNormalAngle;

		// Token: 0x0400043F RID: 1087
		public LayerMask layerMask;

		// Token: 0x04000440 RID: 1088
		public float minDepth;

		// Token: 0x04000441 RID: 1089
		public float maxDepth;

		// Token: 0x04000442 RID: 1090
		public float minNormalAngle;

		// Token: 0x04000443 RID: 1091
		public float maxNormalAngle;

		// Token: 0x04000444 RID: 1092
		public const float NormalAngleUpperLimit = 359.9999f;
	}
}