# OpenGL Covering OpenGL viewport with a quad in perspective projection?

This topic is 1978 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

Hi,

EDIT:
I'm causing confusion with unneeded details, the simplfied question I'm asking is:

Given a perspective projection, with known FOV, aspect ratio, etc, how can I find the corners of the view frustum at a given distance from the eye coordinate?

I'm sure I'm just missing something silly but it is driving me crazy!  As far as I can tell, in order to generate my corners, all I should need to do is use simple trig, ie:

frustumHalfWidth  = tan(viewportHorzFOVRads / 2.0))  * distanceFromCamera
frustumHalfHeight = tan(viewportVertFOVRads / 2.0))  * distanceFromCamera

In my tests if I render a quad at the specified distanceFromCamera using the calculated frustumWidth/Heights, it always appears 'too big' (or too close to camera depending on how you look at the problem).   I need to move the camera away from the quad along the z axis to get it to 'shrink' to viewport frustum size.

Can anyone explain why the math above wouldn't generate quad corners that fall on the horizontal and vertical edges of the viewport frustum?

Edited by Grumple

##### Share on other sites

Looks all right, but it's taken very much out of context and it's impossible to say if it's used correctly.

But I also want to ask: is the reason you're doing this because it's some kind of assignment and you have to show that you understand projections, or that you are under the misconception that you can't have more than one projection matrix?

With as little context as you actually provided, is it not a solution to draw this quad with an orthographic projection, and the rest with a perspective projection? After all, it seems like all you're after is getting the quad to fit to the screen.

##### Share on other sites

This is a personal project that involves displaying imagery captured with a real life camera at correct perspective in opengl.  Ultimately I don't really need or want it to perfectly cover the viewport, but I'm using this test case to ensure I have a good grasp on the projection.

My theory for this experiment is that if I have a camera with a 90 degree horizontal field of view, I should be able to create a GL viewport with the same field of view and aspect ratio, then perfectly cover the viewport with an image from the camera in my opengl scene.

The real goal is to ensure I can make my Opengl scene match the real world camera conditions at the time an image was taken.

##### Share on other sites

If your camera image is mapped to the entire screen, then the projection setup you use when drawing the image is entirely irrelevant and will have no relation to the camera capturing the image. You need to set up the matrix correctly for other things you draw, of course, and that involves matching the FOV, orientation, aspect ratio and such. But for the captured image itself, this process is entirely irrelevant.

##### Share on other sites

Yeah, the image stuff is certainly not critical to this specific problem, I was just giving some background information.

Maybe I should reword my problem to avoid confusion:

Given a perspective projection, with known FOV, aspect ratio, etc, how can I find the corners of the view frustum at a given distance from the eye coordinate?

##### Share on other sites

The formulas you gave your first post will do just that, given that you have calculated the field of view correctly based on the aspect ratio.

hfov = atan(tan(vfov/2)*aspect)*2;


##### Share on other sites

You can convert points from clipping space to camera space by multiplying vertices in clipping space. Clipping space is the view space between camera space and the screen. The x, y, and z of all of the points lie between -1 and 1. X and Y represent the screen position and Z represents the depth.  So the vertex (-1, 1, -1) transformed to camera space represents the top left corner sitting on the near clipping plane. Moving Z from -1 to 1 moves the transformed point from the near clipping plane to the far clipping plane.

To transform from clipping space to camera space you first take the inverse of the perspective matrix, I will refer to this matrix as P-1. For each vertex you add a fourth component, w, and set its value to 1. So (-1, 1, -1) becomes (-1, 1, -1, 1). You multiply the resulting 4 dimensional vector by P-1. After multiplying by P-1 you divide the entire vector its own w value. The resulting vector will be in camera space. You can then multiply the point by camera world matrix to convert that point to world space.

That is more or less what gluUnProject does, if you want to go this route I would recommend using gluUnProject.

The four points you would have to transform using this method to get a quad to cover the whole screen would be (-1, -1, z) (-1, 1, z) (1, 1, z) (1, -1, z) where z = (zFar + zNear + 2 * zFar * zNear / desiredZ) / (zFar - zNear). desiredZ is how far you want the plane and zNear and zFar are the near and far clipping plane distances for the camera.

That will give you the four corners of the quad that will cover the screen sitting at desiredZ away from the camera.

Although I would just recommend you set both the perspective and modelview matrix to the identity matrix and then render the quad (-1, -1, z) (-1, 1, z) (1, 1, z) (1, -1, z) where z is the same as I have described above. The reason why I would do this is if you try to calculate the quad in world space you are essentially transforming geometry from clipping space to world space then back again. By using the identity for the perspective matrix and modelview matrix you dont actually do any transformation because the geometry is pre transformed.

##### Share on other sites

Thanks to both of you for your help.   Having had Brother Bob confirm my general approach was something that 'should work', I took a closer look at some of my core functionality.

It appears the implementation I was using to generate a perspective projection matrix was wrong.  It's always worked for me and I've never tested it to this kind of accuracy.  After reviewing a tutorial on proper setup and making some changes to my gluPerspective() replacement, I'm getting the intended results when I render my 'full screen' quad.

HappyCoder, that is also a very useful trick that I hadn't thought of.

Cheers!

1. 1
2. 2
3. 3
Rutin
16
4. 4
5. 5
JoeJ
12

• 10
• 9
• 14
• 10
• 25
• ### Forum Statistics

• Total Topics
632646
• Total Posts
3007637
• ### Who's Online (See full list)

There are no registered users currently online

×