C# Polygon.IsPointInside方法代码示例

//.........这里部分代码省略.........
                                {
                                    nextOtherIndex = 0;
                                }
                                nextOtherVector = otherVertices[nextOtherIndex] - cp.Position;
                            }

                            float thisVectorLength = nextThisVector.Length();
                            float otherVectorLength = nextOtherVector.Length();

                            float smallestDistance = System.Math.Min(thisVectorLength, otherVectorLength);

                            nextThisVector.Normalize();
                            nextOtherVector.Normalize();

                            nextThisVector *= smallestDistance / 2.0f;
                            nextOtherVector *= smallestDistance / 2.0f;

                            nextThisVector += cp.Position;
                            nextOtherVector += cp.Position;

                            if (nextThisVector == nextOtherVector)
                            {

                                forceUseThis = thisVectorLength < otherVectorLength;
                                forceUseOther = !forceUseThis;

                                break;
                            }



                            double minimumDistance = .00001;

                            if (polygon.IsPointInside(ref nextOtherVector))
                            {
                                distanceAwayFromThis = 0;
                            }
                            else
                            {
                                distanceAwayFromThis = polygon.VectorFrom(nextOtherVector.X, nextOtherVector.Y).Length();

                                if (distanceAwayFromThis < minimumDistance)
                                {
                                    distanceAwayFromThis = 0;
                                }
                            }

                            if (otherPolygon.IsPointInside(ref nextThisVector))
                            {
                                distanceAwayFromOther = 0;
                            }
                            else
                            {
                                distanceAwayFromOther = otherPolygon.VectorFrom(nextThisVector.X, nextThisVector.Y).Length();

                                if (distanceAwayFromOther < minimumDistance)
                                {
                                    distanceAwayFromOther = 0;
                                }
                            }

                            if (distanceAwayFromOther == distanceAwayFromThis)
                            {
                                // We need a tiebreaker.  Let's move an extra index and see what happens, shall we?
                                nextThisIndex++;
                                if (nextThisIndex == thisVertices.Count - 1)

        private static int GetPointToStartAt(Polygon polygon, Polygon otherPolygon)
        {
            int firstPointToStartAt = 0;

            double furthestAwayDistance = otherPolygon.VectorFrom(polygon.mVertices[0].Position.X, polygon.mVertices[0].Position.Y).LengthSquared();


            for (int i = 1; i < polygon.mVertices.Length - 1; i++)
            {
                double distance = otherPolygon.VectorFrom(polygon.mVertices[i].Position.X, polygon.mVertices[i].Position.Y).LengthSquared();

                if(distance > furthestAwayDistance &&
                    !otherPolygon.IsPointInside(ref polygon.mVertices[i].Position))
                {
                    firstPointToStartAt = i;
                    furthestAwayDistance = distance;
                }
            }
            return firstPointToStartAt;
        }

        public bool CollideAgainst(Polygon polygon)
        {
            polygon.UpdateDependencies(TimeManager.CurrentTime);

            // Check if one of the segment's endpoints is inside the Polygon
            if (polygon.IsPointInside(Point1.X, Point1.Y))
            {
                polygon.mLastCollisionPoint = Point1;
                return true;
            }                                                  

            if (polygon.IsPointInside(Point2.X, Point2.Y))
            {
                polygon.mLastCollisionPoint = Point2;
                return true;
            }

            Point intersectionPoint;

            // Check if one of the polygon's edges intersects the line segment
            for (int i = 0; i < polygon.Points.Count - 1; i++)
            {
                if (Intersects(new Segment(
                      new Point(polygon.Position.X + polygon.Points[i].X,
                                polygon.Position.Y + polygon.Points[i].Y),
                      new Point(polygon.Position.X + polygon.Points[i + 1].X,
                                polygon.Position.Y + polygon.Points[i + 1].Y)), out intersectionPoint))
                {
                    polygon.mLastCollisionPoint = intersectionPoint;
                    return true;
                }
            }

            // No collision
            return false;
        }

    static bool TryInsertHole(Polygon parent, Polygon hole)
    {
        //Can't go in.
        if (!parent.IsPointInside(hole[0]))
            return false;

        if (parent.Holes != null)
            foreach (var item in parent.Holes)
            {
                if (TryInsertHole(item, hole))
                    return true;
            }
        //it doesn't fit into any of the daughter holes.
        parent.AddHole(hole);
        return true;
    }

    public List<TriangulationPoint> GenerateGridPoints(Bounds bounds, float subdivLevel, Polygon _polygon)
    {
        List<TriangulationPoint> GridPoints = new List<TriangulationPoint> ();
        float numberDivisions = 6;

        float width = bounds.max.x - bounds.min.x;
        float height = bounds.max.y - bounds.min.y;

        float subdivWidth = width / (subdivLevel*numberDivisions);
        float subdivHeight = height / ((subdivLevel*numberDivisions) );

        float averagedLength = (subdivWidth + subdivHeight) / 2;
        float widthHeight = (width + height) / 2;

        for(int i=1;i<(subdivLevel*numberDivisions/widthHeight)*width;i++)
        {
            for(int j=1;j<(subdivLevel*numberDivisions/widthHeight)*height;j++)
            {
                float xPos = (i*averagedLength) + bounds.min.x;
                float yPos = (j*averagedLength) + bounds.min.y;
                TriangulationPoint t = new TriangulationPoint (xPos, yPos);
                if(_polygon.IsPointInside(t))
                    GridPoints.Add(t);

            }
        }
        return GridPoints;
    }

 private static bool Check( Triangle tri, Polygon boundary )
 {
     if( boundary == null ||
         (boundary.IsPointInside( tri.a ) &&
         boundary.IsPointInside( tri.b ) &&
         boundary.IsPointInside( tri.c )) )
         return true;
     return false;
 }