示例#1
0
        /// <summary>
        /// 判断AABB与圆形相交
        /// </summary>
        /// <param name="aABBArea"></param>
        /// <param name="target"></param>
        /// <returns></returns>
        public static bool AABB(AABBArea aABBArea, CircleArea target)
        {
            Vector2 v = Vector2.Max(aABBArea.center - target.o, -(aABBArea.center - target.o));
            Vector2 u = Vector2.Max(v - aABBArea.extents, Vector2.zero);

            return(u.sqrMagnitude < target.r * target.r);
        }
示例#2
0
        /// <summary>
        /// 判断OBB与圆形相交
        /// </summary>
        /// <param name="oBBArea"></param>
        /// <param name="target"></param>
        /// <returns></returns>
        public static bool OBB(OBBArea oBBArea, CircleArea target)
        {
            Vector2 p = oBBArea.center - target.o;

            p = Quaternion.AngleAxis(-oBBArea.angle, Vector3.forward) * p;
            Vector2 v = Vector2.Max(p, -p);
            Vector2 u = Vector2.Max(v - oBBArea.extents, Vector2.zero);

            return(u.sqrMagnitude < target.r * target.r);
        }
示例#3
0
        /// <summary>
        /// 判断多边形与圆形相交
        /// </summary>
        /// <param name="polygonArea"></param>
        /// <param name="target"></param>
        /// <returns></returns>
        public static bool PolygonS(PolygonArea polygonArea, CircleArea target)
        {
            if (polygonArea.vertexes.Length < 3)
            {
                Debug.Log("多边形边数小于3.");
                return(false);
            }
            #region 定义临时变量
            //圆心
            Vector2 circleCenter = target.o;
            //半径的平方
            float sqrR = target.r * target.r;
            //多边形顶点
            Vector2[] polygonVertexes = polygonArea.vertexes;
            //圆心指向顶点的向量数组
            Vector2[] directionBetweenCenterAndVertexes = new Vector2[polygonArea.vertexes.Length];
            //多边形的边
            Vector2[] polygonEdges = new Vector2[polygonArea.vertexes.Length];
            for (int i = 0; i < polygonArea.vertexes.Length; i++)
            {
                directionBetweenCenterAndVertexes[i] = polygonVertexes[i] - circleCenter;
                polygonEdges[i] = polygonVertexes[i] - polygonVertexes[(i + 1) % polygonArea.vertexes.Length];
            }
            #endregion

            #region 以下为圆心处于多边形内的判断。
            //总夹角
            float totalAngle = Vector2.SignedAngle(directionBetweenCenterAndVertexes[polygonVertexes.Length - 1], directionBetweenCenterAndVertexes[0]);
            for (int i = 0; i < polygonVertexes.Length - 1; i++)
            {
                totalAngle += Vector2.SignedAngle(directionBetweenCenterAndVertexes[i], directionBetweenCenterAndVertexes[i + 1]);
            }
            if (Mathf.Abs(Mathf.Abs(totalAngle) - 360f) < 0.1f)
            {
                return(true);
            }
            #endregion
            #region 以下为多边形的边与圆形相交的判断。
            for (int i = 0; i < polygonEdges.Length; i++)
            {
                if (SegmentPointSqrDistance(polygonVertexes[i], polygonEdges[i], circleCenter) < sqrR)
                {
                    return(true);
                }
            }
            #endregion
            return(false);
        }
示例#4
0
        /// <summary>
        /// 判断圆形与扇形相交。
        /// </summary>
        /// <param name="sectorArea"></param>
        /// <param name="target"></param>
        /// <returns></returns>
        public static bool Sector(SectorArea sectorArea, CircleArea target)
        {
            Vector2 tempDistance = target.o - sectorArea.o;
            float   halfAngle    = Mathf.Deg2Rad * sectorArea.angle / 2;

            if (tempDistance.sqrMagnitude < (sectorArea.r + target.r) * (sectorArea.r + target.r))
            {
                if (Vector3.Angle(tempDistance, sectorArea.direction) < sectorArea.angle / 2)
                {
                    return(true);
                }
                else
                {
                    Vector2 targetInSectorAxis = new Vector2(Vector2.Dot(tempDistance,
                                                                         sectorArea.direction), Mathf.Abs(Vector2.Dot(tempDistance, new Vector2(-sectorArea.direction.y, sectorArea.direction.x))));
                    Vector2 directionInSectorAxis = sectorArea.r * new Vector2(Mathf.Cos(halfAngle), Mathf.Sin(halfAngle));
                    return(SegmentPointSqrDistance(Vector2.zero, directionInSectorAxis, targetInSectorAxis) <= target.r * target.r);
                }
            }
            return(false);
        }
示例#5
0
 /// <summary>
 /// 判断圆形与圆形相交
 /// </summary>
 /// <param name="circleArea">判断圆</param>
 /// <param name="target">目标圆</param>
 /// <returns></returns>
 public static bool Circle(CircleArea circleArea, CircleArea target)
 {
     return((circleArea.o - target.o).sqrMagnitude < (circleArea.r + target.r) * (circleArea.r + target.r));
 }
示例#6
0
        /// <summary>
        /// 判断胶囊体与圆形相交
        /// </summary>
        /// <param name="capsuleArea"></param>
        /// <param name="circleArea"></param>
        /// <returns></returns>
        public static bool Capsule(CapsuleArea capsuleArea, CircleArea circleArea)
        {
            float sqrD = SegmentPointSqrDistance(capsuleArea.X0, capsuleArea.U, circleArea.o);

            return(sqrD < (circleArea.r + capsuleArea.d) * (circleArea.r + capsuleArea.d));
        }