Determine corners of a specific plane in the frustum

Question

I'm working on a game with a 2D view in a 3D world. It's a kind of shoot'em up. I've a spaceship at the center of the screen and i want that ennemies appear at the borders of my window. Now i don't know how to determine positions of the borders of the window.

For example, my camera is at (0,0,0) and looking forward (0,0,1). I set my spaceship at (0,0,50). I also know the near plane (1) and the far plane(1000). I think i'd have to find the 4 corners of the plane in the frustum whose z position is 50, and with these corner i can determine borders. But i don't know how to determine x and y.

Answer 1

Disclaimer: This solution really is simplified for your particular problem, because your camera is looking straight down the Z axis of the world's coordinate system. Also, the center point at 50 units away is already given as (0, 0, 50). If your camera's viewing direction was an arbitrary vector, there would be more multiplications involving the distance with a cross product of the viewing vector and the camera's Up vector.

Determining the borders of a plane at a given distance is dependent on the FOV angle in which the view is projected. Usually, the FOV angle is measured in the Y axis for rectangular viewports.

For any given distance Z from the camera, the shortest distance D from the center point of a plane perpendicular to the viewing vector at Z to one of its borders above or below the center (really, the intersection of the plane and frustum) is D = tan(FOV / 2) * Z . Add and subtract D from the center point's Y component to get the maximum and minimum Y extents.

To get the minimum and maximum X extents, add and subtract D * aspect_ratio.

Now getting the location of the plane's corners is simply plugging in the mix/max X and Y in its four possible combinations along with the Z distance.

Answer 2

This is a more general solution

To start you will need some data.

The Camera's position represented by P (this is a point)

The normalized viewing vector represented by v

The Camera's up vector represented by up

The Camera's right vector represented by w (this is the cross product of v X up)

The near distance represented by nDis

The far distance represented by fDis

The field of view represented by fov (this usually in radians)

The aspect ratio represented by ar (this is the width of the screen divided by the height)

---

First we will get the width and height of the near plane

Hnear = 2 * tan(fov / 2) * nDis

Wnear = Hnear * ar

---

Then we do the same for the far plane

Hfar = 2 * tan(fov / 2) * fDis

Wfar = Hfar * ar

---

Now we get the center of the planes

Cnear = P + v * nDis

Cfar = P + v * fDis

---

And now we get our points

Near Top Left = Cnear + (up * (Hnear / 2)) - (w * (Wnear / 2))

Near Top Right = Cnear + (up * (Hnear / 2)) + (w * (Wnear / 2))

Near Bottom Left = Cnear - (up * (Hnear / 2)) - (w * (Wnear /2))

Near Bottom Right = Cnear + (up * (Hnear / 2)) + (w * (Wnear / 2))

Far Top Left = Cfar + (up * (Hfar / 2)) - (w * Wfar / 2))

Far Top Right = Cfar + (up * (Hfar / 2)) + (w * Wfar / 2))

Far Bottom Left = Cfar - (up * (Hfar / 2)) - (w * Wfar / 2))

Far Bottom Right = Cfar - (up * (Hfar / 2)) + (w * Wfar / 2))

---

Common assumptions that might be useful:

• Most games have their field of view set at 110 degrees as this is close to the human field of view
• The camera is most often set at the origin (0,0,0)
• The view vector is usually along the negative Z axis (0,0,-1)
• The up vector is usually along the Y axis (0,1,0)
• The right vector is usually along the X axis (1,0,0)

Answer 3

Conisdering you translate your "camera" by writing something like: gltranslatef(1, 3, 0). Make values such as posX and posY, and whenever you translate your camera, add to those values. Then when you add your enemy set it's X value to posX and it's Y value to posY for the enemy to appear where it would if the camera was at the origin.