/// <summary> /// Returns a polygon, based on this polygon, that is reflected along the given axes. /// </summary> /// <param name="reflectX">If true, the polygon will be reflected along the x-axis. </param> /// <param name="reflectY">If true, the polygon will be reflected along the y-axis. </param> /// <returns></returns> public Polygon2D GetReflected(bool reflectX, bool reflectY) { Polygon2D polygonResult = new Polygon2D(); foreach (Vector2D point in this.Points) { double resultX = point.X; double resultY = point.Y; if (reflectX) { resultX = -resultX; } if (reflectY) { resultY = -resultY; } polygonResult.Points.Add(new Vector2D(resultX, resultY)); } return(polygonResult); }
/// <summary> /// Returns the result of a collision check of this polygon with the given polygon. /// </summary> /// <param name="polygon">A polygon to check against. </param> /// <returns></returns> public PolygonCollisionResult PolygonCollision(Polygon2D polygon) { PolygonCollisionResult result = new PolygonCollisionResult(); if (polygon == null) // No collsion checking possible. { return(result); } else // Initialization. { result.Intersect = true; } int edgeCountA = this.Points.Count; int edgeCountB = polygon.Points.Count; //float minIntervalDistance = float.PositiveInfinity; Vector2D vectAxisTranslation = new Vector2D(); Vector2D vectEdge; // Loop through all the edges of both polygons for (int edgeIndex = 0; edgeIndex < edgeCountA + edgeCountB; edgeIndex++) { if (edgeIndex < edgeCountA) // Iterating over the edges of polygon A. { if (edgeIndex == edgeCountA - 1) { vectEdge = this.Points[0] - this.Points[edgeIndex]; } else { vectEdge = this.Points[edgeIndex + 1] - this.Points[edgeIndex]; } } else // Iterating over the edges of polygon B. { if (edgeIndex == edgeCountA + edgeCountB - 1) { vectEdge = polygon.Points[0] - polygon.Points[edgeIndex - edgeCountA]; } else { vectEdge = polygon.Points[edgeIndex - edgeCountA + 1] - polygon.Points[edgeIndex - edgeCountA]; } } // ===== 1. Find if the polygons are currently intersecting ===== // Find the axis perpendicular to the current edge Vector2D vectAxis = new Vector2D(-vectEdge.Y, vectEdge.X); vectAxis = vectAxis.GetNormalized(); // Find the projection of the polygon on the current axis Interval intervalA = this.Project(vectAxis); Interval intervalB = polygon.Project(vectAxis); // Check if the polygon projections are currentlty intersecting if (intervalA.GetIntervalDistance(intervalB) > 0) { result.Intersect = false; } //// ===== 2. Now find if the polygons *will* intersect ===== //// Project the velocity on the current axis //float velocityProjection = (float)vectAxis.GetDotProduct(velocity); //// Get the projection of polygon A during the movement //if (velocityProjection < 0) //{ // intervalA.min += velocityProjection; //} //else //{ // intervalA.max += velocityProjection; //} //// Do the same test as above for the new projection //float intervalDistance = intervalA.GetIntervalDistance(intervalB); //if (intervalDistance > 0) // result.WillIntersect = false; //// If the polygons are not intersecting and won't intersect, exit the loop //if (!result.Intersect && !result.WillIntersect) // break; //// Check if the current interval distance is the minimum one. If so store //// the interval distance and the current distance. //// This will be used to calculate the minimum translation vector //intervalDistance = Math.Abs(intervalDistance); //if (intervalDistance < minIntervalDistance) //{ // minIntervalDistance = intervalDistance; // vectAxisTranslation = vectAxis; // csVector2D d = this.vectCenter - polygon.vectCenter; // if (d.GetDotProduct(vectAxisTranslation) < 0) // vectAxisTranslation = -vectAxisTranslation; //} } //// The minimum translation vector //// can be used to push the polygons appart. //result.MinimumTranslationVector = vectAxisTranslation * minIntervalDistance; return(result); }
/// <summary> /// Returns the result of a collision check of the given polygons. /// </summary> /// <param name="polygonA">A polygon to check. </param> /// <param name="polygonB">A polygon to check against. </param> /// <returns></returns> public static PolygonCollisionResult PolygonCollision(Polygon2D polygonA, Polygon2D polygonB) { return(polygonA.PolygonCollision(polygonB)); }