Пример #1
0
        public static bool TestIShapeWithConcavePolygon(IShape shape, Vector2 shapePos, Polygon concavePolygon, out Contact?contact)
        {
            List <Vector2[]> concavePolygonComponents = concavePolygon.ConvexComponents();

            Vector2 concavePolygonAnchor = concavePolygon[0];

            Vector2[] shapeAxes = shape.CalculateAxes();
            Vector2[] axes;

            foreach (Vector2[] component in concavePolygonComponents)
            {
                Polygon componentPolygon = new Polygon(component);
                componentPolygon.Translate(concavePolygonAnchor);

                axes = new Vector2[shapeAxes.Length + componentPolygon.Normals.Length];

                shapeAxes.CopyTo(axes, 0);
                componentPolygon.Normals.CopyTo(axes, shapeAxes.Length);

                if (TestIShapeWithConvexPolygon(shape, shapePos, componentPolygon, axes, out contact))
                {
                    return(true);
                }
            }

            contact = null;
            return(false);
        }
Пример #2
0
        private static bool TestConcavePolygons(Polygon A, Polygon B, IEnumerable <Vector2> axes, out Contact?contact)
        {
            List <Vector2[]> componentsA = A.ConvexComponents(),
                             componentsB = B.ConvexComponents();

            Vector2 polyAAnchor = A[0],
                    polyBAnchor = B[0];

            foreach (Vector2[] componentA in componentsA)
            {
                Polygon componentPolyA = new Polygon(componentA);
                componentPolyA.Translate(polyAAnchor);

                foreach (Vector2[] componentB in componentsB)
                {
                    Polygon componentPolyB = new Polygon(componentB);
                    componentPolyB.Translate(polyBAnchor);

                    if (TestConvexPolygons(componentPolyA, componentPolyB, axes, out contact))
                    {
                        return(true);
                    }
                }
            }

            contact = null;
            return(false);
        }
Пример #3
0
        private static bool TestConcavePolygons(Polygon A, Polygon B, out Contact?contact)
        {
            List <Vector2[]> componentsA = A.ConvexComponents(),
                             componentsB = B.ConvexComponents();

            Vector2 polyAAnchor = A[0],
                    polyBAnchor = B[0];

            Vector2[] axes;
            int       i;

            foreach (Vector2[] componentA in componentsA)
            {
                Polygon componentPolyA = new Polygon(componentA);
                componentPolyA.Translate(polyAAnchor);

                foreach (Vector2[] componentB in componentsB)
                {
                    Polygon componentPolyB = new Polygon(componentB);
                    componentPolyB.Translate(polyBAnchor);

                    axes = new Vector2[componentPolyA.Normals.Length + componentPolyB.Normals.Length];

                    i = 0;

                    // component polygon A axes
                    foreach (Vector2 normal in componentPolyA.Normals)
                    {
                        axes[i] = normal;
                        i++;
                    }

                    // component polygon B axes
                    foreach (Vector2 normal in componentPolyB.Normals)
                    {
                        axes[i] = normal;
                        i++;
                    }

                    if (TestConvexPolygons(componentPolyA, componentPolyB, axes, out contact))
                    {
                        return(true);
                    }
                }
            }

            contact = null;
            return(false);
        }
Пример #4
0
        public Polygon(Polygon polygon)
        {
            _vertices = new List <Vector2>(polygon._vertices);

            foreach (Vector2[] component in polygon.ConvexComponents())
            {
                _convexComponents.Add(component);
            }

            IsConvex = polygon.IsConvex;

            Normals = new Vector2[polygon.Normals.Length];
            polygon.Normals.CopyTo(Normals, 0);

            Center = polygon.Center;

            _needRecalculateComponents = polygon._needRecalculateComponents;
        }
Пример #5
0
        public static bool TestLineSegmentWithConcavePolygon(Vector2 startPoint, Vector2 endPoint, Polygon concavePolygon, IEnumerable <Vector2> axes, out Contact?contact)
        {
            List <Vector2[]> concavePolygonComponents = concavePolygon.ConvexComponents();
            Vector2          concavePolygonAnchor     = concavePolygon[0];

            foreach (Vector2[] component in concavePolygonComponents)
            {
                Polygon componentPolygon = new Polygon(component);
                componentPolygon.Translate(concavePolygonAnchor);

                if (TestLineSegmentWithConvexPolygon(startPoint, endPoint, componentPolygon, axes, out contact))
                {
                    return(true);
                }
            }

            contact = null;
            return(false);
        }
Пример #6
0
        private static bool TestConvexPolygonWithConcavePolygon(Polygon convexPolygon, Polygon concavePolygon, IEnumerable <Vector2> axes, out Contact?contact)
        {
            List <Vector2[]> concavePolygonComponents = concavePolygon.ConvexComponents();
            Vector2          concavePolygonAnchor     = concavePolygon[0];

            foreach (Vector2[] component in concavePolygonComponents)
            {
                Polygon componentPolygon = new Polygon(component);
                componentPolygon.Translate(concavePolygonAnchor);

                if (TestConvexPolygons(convexPolygon, componentPolygon, axes, out contact))
                {
                    return(true);
                }
            }

            contact = null;
            return(false);
        }
Пример #7
0
        public static bool TestIShapeWithConcavePolygon(IShape shape, Vector2 shapePos, Polygon concavePolygon, ICollection <Vector2> axes, out Contact?contact)
        {
            List <Vector2[]> concavePolygonComponents = concavePolygon.ConvexComponents();

            Vector2 concavePolygonAnchor = concavePolygon[0];

            foreach (Vector2[] component in concavePolygonComponents)
            {
                Polygon componentPolygon = new Polygon(component);
                componentPolygon.Translate(concavePolygonAnchor);

                if (TestIShapeWithConvexPolygon(shape, shapePos, componentPolygon, axes, out contact))
                {
                    return(true);
                }
            }

            contact = null;
            return(false);
        }
Пример #8
0
        private static bool TestConvexPolygonWithConcavePolygon(Polygon convexPolygon, Polygon concavePolygon, out Contact?contact)
        {
            List <Vector2[]> concavePolygonComponents = concavePolygon.ConvexComponents();

            Vector2 concavePolygonAnchor = concavePolygon[0];

            Vector2[] axes;
            int       i;

            foreach (Vector2[] component in concavePolygonComponents)
            {
                Polygon componentPolygon = new Polygon(component);
                componentPolygon.Translate(concavePolygonAnchor);

                axes = new Vector2[componentPolygon.Normals.Length + convexPolygon.Normals.Length];

                i = 0;

                // component polygon A axes
                foreach (Vector2 normal in convexPolygon.Normals)
                {
                    axes[i] = normal;
                    i++;
                }

                // component polygon B axes
                foreach (Vector2 normal in componentPolygon.Normals)
                {
                    axes[i] = normal;
                    i++;
                }

                if (TestConvexPolygons(convexPolygon, componentPolygon, axes, out contact))
                {
                    return(true);
                }
            }

            contact = null;
            return(false);
        }
Пример #9
0
        public static bool TestLineSegmentWithConcavePolygon(Vector2 startPoint, Vector2 endPoint, Polygon concavePolygon, out Contact?contact)
        {
            List <Vector2[]> concavePolygonComponents = concavePolygon.ConvexComponents();
            Vector2          concavePolygonAnchor     = concavePolygon[0];

            Vector2 direction = (endPoint - startPoint).Normalized();

            Vector2[] axes;
            int       i;

            foreach (Vector2[] component in concavePolygonComponents)
            {
                Polygon componentPolygon = new Polygon(component);
                componentPolygon.Translate(concavePolygonAnchor);

                axes = new Vector2[2 + componentPolygon.Normals.Length];

                axes[0] = direction;
                axes[1] = direction.PerpendicularCW();

                i = 2;

                // component polygon A axes
                foreach (Vector2 normal in componentPolygon.Normals)
                {
                    axes[i] = normal;
                    i++;
                }

                if (TestLineSegmentWithConvexPolygon(startPoint, endPoint, componentPolygon, axes, out contact))
                {
                    return(true);
                }
            }

            contact = null;
            return(false);
        }