How to calculate if a point is contained in rectangular camera viewport with rotation?

Question

I am working with my camera, and am trying to improve it so that I can calculate if a world point is on screen, taking rotation into account. Currently, my camera rectangle is calculated as so:

    public Rectangle Rectangle
    {
        get
        {
            int width = (int)((ViewportWidth / _zoom));
            int height = (int)((ViewportHeight / _zoom));
            return new Rectangle((int)(_pos.X - width / 2), (int)(_pos.Y - height / 2), width, height);
        }
    }

Then, to check if a point is on screen, I call one of the following functions:

    public bool IsOnScreen(Point location)
    {
        return this.Rectangle.Contains(location);
    }

    public bool IsOnScreen(Rectangle bounds)
    {
        return this.Rectangle.Intersects(bounds);
    }

However, none of these calculations take the rotation factor into account; only position and the zoom factor. I know that I can calculate the corners of the camera, in world space, using the following transformations:

var topLeftCorner      = Vector2.Transform(new Vector2(0, 0), Matrix.Invert(ViewMatrix));
var topRightCorner     = Vector2.Transform(new Vector2(ViewportWidth, 0), Matrix.Invert(ViewMatrix));
var bottomLeftCorner   = Vector2.Transform(new Vector2(0, ViewportHeight), Matrix.Invert(ViewMatrix));
var bottomRightCorner  = Vector2.Transform(new Vector2(ViewportWidth, ViewportHeight), Matrix.Invert(ViewMatrix));

However, the rectangle object that I am using is not able to take this into account, since it cannot store rotation. What is the calculation that I can use to check if a point is inside the virtual rectangle with these points, or if a rectangle intersects with the virtual rectangle?

Here's some graphics to better illustrate some of my code:

Answer 1

Since you are working in 3d world space, why not use the BoundingFrustum class?

BoundingFrustum cameraBounds = new BoundingFrustum(view * projection);

if(cameraBounds.contains(location))
{
   // it is in view
}
else
{
  // not in view
}

edit. I assumed you are using XNA. If not, you can still reflect the XNA code to see how to make a Bounding frustum class and a .contains method.

The mechanics behind the BoundingFrustum class:

The ctor creates 6 planes in 3d space; one that is the left edge of all that the camera sees, one that is the right edge, top, bottom, near plane, far plane. It stores those planes for intersection tests just like you want. They can be reset anytime the view or projection changes. They automatically take into account the rotation of the camera. the .Contains method checks the test point (your location) against all 6 planes to decide if it is inside the camera's view or not. http://www.monogame.net/documentation/?page=T_Microsoft_Xna_Framework_BoundingFrustum

Here is a link to many forum questions about the BoundingFrustum found on the old XNA creators hub: http://xboxforums.create.msdn.com/search/SearchResults.aspx?q=BoundingFrustum