C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Utilities/IntersectionTest.cs

//-----------------------------------------------------------------------------
// IntersectionTest.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.Utilities
{
    using System;
    using Microsoft.Xna.Framework;

    public static class IntersectionTest
    {
        public static bool CircleInCircle2D(Vector2 centerA, double radiusA, Vector2 centerB, double radiusB)
        {
            if ((radiusA < 0.0) || (radiusB < 0.0))
            {
                return false;
            }

            double dX = (double)(centerB.X - centerA.X);
            double dY = (double)(centerB.Y - centerA.Y);
            double d = Math.Sqrt(dX * dX + dY * dY);

            // circles do not intersect if they are too far apart
            if (d > (radiusA + radiusB))
            {
                return false;
            }

            return true;
        }

        public static bool PointInPolygon2D(Vector2[] polygonVertex, Vector2 testVertex)
        {
            bool c = false;
            int nvert = polygonVertex.Length;
            if (nvert > 2)
            {
                int i, j;
                for (i = 0, j = nvert - 1; i < nvert; j = i++)
                {
                    if (((polygonVertex[i].Y > testVertex.Y) != (polygonVertex[j].Y > testVertex.Y)) &&
                     (testVertex.X < (polygonVertex[j].X - polygonVertex[i].X) *
                     (testVertex.Y - polygonVertex[i].Y) /
                     (polygonVertex[j].Y - polygonVertex[i].Y) + polygonVertex[i].X))
                    {
                        c = !c;
                    }
                }
            }

            return c;
        }

        public static bool TriangleTriangleIntersect2D(
            Vector2 p1,
            Vector2 q1,
            Vector2 r1,
            Vector2 p2,
            Vector2 q2,
            Vector2 r2)
        {
            if (Orientation2D(p1, q1, r1) < 0.0f)
            {
                if (Orientation2D(p2, q2, r2) < 0.0f)
                {
                    return CcwTriTriIntersection2D(p1, r1, q1, p2, r2, q2);
                }
                else
                {
                    return CcwTriTriIntersection2D(p1, r1, q1, p2, q2, r2);
                }
            }
            else
            {
                if (Orientation2D(p2, q2, r2) < 0.0f)
                {
                    return CcwTriTriIntersection2D(p1, q1, r1, p2, r2, q2);
                }
                else
                {
                    return CcwTriTriIntersection2D(p1, q1, r1, p2, q2, r2);
                }
            }
        }


        private static bool CcwTriTriIntersection2D(
            Vector2 p1,
            Vector2 q1,
            Vector2 r1,
            Vector2 p2,
            Vector2 q2,
            Vector2 r2)
        {
            if (Orientation2D(p2, q2, p1) >= 0.0f)
            {
                if (Orientation2D(q2, r2, p1) >= 0.0f)
                {
                    if (Orientation2D(r2, p2, p1) >= 0.0f)
                    {
                        return true;
                    }
                    else
                    {
                        return TestEdgeIntersection(p1, q1, r1, p2, q2, r2);
                    }
                }
                else
                {
                    if (Orientation2D(r2, p2, p1) >= 0.0f)
                    {
                        return TestEdgeIntersection(p1, q1, r1, r2, p2, q2);
                    }
                    else
                    {
                        return TestVertexIntersection2D(p1, q1, r1, p2, q2, r2);
                    }
                }
            }
            else
            {
                if (Orientation2D(q2, r2, p1) >= 0.0f)
                {
                    if (Orientation2D(r2, p2, p1) >= 0.0f)
                    {
                        return TestEdgeIntersection(p1, q1, r1, q2, r2, p2);
                    }
                    else
                    {
                        return TestVertexIntersection2D(p1, q1, r1, q2, r2, p2);
                    }
                }
                else
                {
                    return TestVertexIntersection2D(p1, q1, r1, r2, p2, q2);
                }
            }
        }

        private static float Orientation2D(Vector2 p, Vector2 q, Vector2 r)
        {
            return ((p.X - r.X) * (q.Y - r.Y) - (p.Y - r.Y) * (q.X - r.X));
        }

        private static bool TestEdgeIntersection(
            Vector2 p1, 
            Vector2 q1, 
            Vector2 r1, 
            Vector2 p2, 
            Vector2 q2, 
            Vector2 r2)
        {
            if (Orientation2D(r2, p2, q1) >= 0.0f)
            {
                if (Orientation2D(p1, p2, q1) >= 0.0f)
                {
                    if (Orientation2D(p1, q1, r2) >= 0.0f)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    if (Orientation2D(q1, r1, p2) >= 0.0f)
                    {
                        if (Orientation2D(r1, p1, p2) >= 0.0f)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            else
            {
                if (Orientation2D(r2, p2, r1) >= 0.0f)
                {
                    if (Orientation2D(p1, p2, r1) >= 0.0f)
                    {
                        if (Orientation2D(p1, r1, r2) >= 0.0f)
                        {
                            return true;
                        }
                        else
                        {
                            if (Orientation2D(q1, r1, r2) >= 0.0f)
                            {
                                return true;
                            }
                            else
                            {
                                return false;
                            }
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
        }

        private static bool TestVertexIntersection2D(
            Vector2 p1,
            Vector2 q1,
            Vector2 r1,
            Vector2 p2,
            Vector2 q2,
            Vector2 r2)
        {
            if (Orientation2D(r2, p2, q1) >= 0.0f)
            {
                if (Orientation2D(r2, q2, q1) <= 0.0f)
                {
                    if (Orientation2D(p1, p2, q1) > 0.0f)
                    {
                        if (Orientation2D(p1, q2, q1) <= 0.0f)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (Orientation2D(p1, p2, r1) >= 0.0f)
                        {
                            if (Orientation2D(q1, r1, p2) >= 0.0f)
                            {
                                return true;
                            }
                            else
                            {
                                return false;
                            }
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    if (Orientation2D(p1, q2, q1) <= 0.0f)
                    {
                        if (Orientation2D(r2, q2, r1) <= 0.0f)
                        {
                            if (Orientation2D(q1, r1, q2) >= 0.0f)
                            {
                                return true;
                            }
                            else
                            {
                                return false;
                            }
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            else
            {
                if (Orientation2D(r2, p2, r1) >= 0.0f)
                {
                    if (Orientation2D(q1, r1, r2) >= 0.0f)
                    {
                        if (Orientation2D(p1, p2, r1) >= 0.0f)
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (Orientation2D(q1, r1, q2) >= 0.0f)
                        {
                            if (Orientation2D(r2, r1, q2) >= 0.0f)
                            {
                                return true;
                            }
                            else
                            {
                                return false;
                            }
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    return false;
                }
            }
        }
    }
}

---