Perspective matrix, OpenGL style

Transcription

1 Perspective matrix, OpenGL style Stefan Gustavson May 7, 016 Gortler s book presents perspective transformation using a slightly different matrix than what is common in OpenGL applications. This document presents the derivation of a perspective matrix with the conventions traditionally used in OpenGL. Gortler has reasons to flip the sign of his depth coordinate, but almost nobody else does it that way, so it s a bit confusing. This document presents a perspective matrix with the same coordinate conventions and the same parameters as the traditional OpenGL function gluperspective. That function is now deprecated, but most modern functions which create a perspective matrix for OpenGL are based on it. The function gluperspective is still available for backwards compatibility reasons, and its documentation is on However, use it only for reference please don t write code that actually uses the function. 1 Notation Let s begin by setting up the requirements for our perspective projection. Following OpenGL convention, we assume that the camera is at the origin, that the view plane is the (x, y) plane and that we have a right-handed coordinate system, such that the z axis points toward the viewer and the entire scene is in negative z, as presented in the top half of Figure 1 and correspondingly in Figure. Figure will be referenced further in sections and 3. The rectangular cone with its apex at the origin in the view coordinates (the position of the camera) is called the view frustum. 1

2 y v x v z v y c x c z c Figure 1: The task of the perspective transformation is to transform the view frustum in view coordinates (top) to a cube in clipping coordinates (bottom). Note that by convention, the near plane (shaded) is transformed into negative z c in OpenGL, meaning that larger z c are farther from the camera in depth buffer comparisons. This is not the obvious choice, nor the only choice, not even necessarily the best choice, it s just a choice.

3 y v = 1 y v v z v z v = -n view space z v = -d z v = -f y c clip space z c z c = -1 z c = 1 Figure : Coordinate systems, parameters and coordinate mapping used in this document. The x coordinate axis points into the page and is not shown, but it behaves just like y. 3

4 Perspective division A perspective projection of the x and y coordinates is just a division with the distance to the camera, and with the setup in, the w coordinate should be computed as z v. The negative sign is there because the entire scene is in negative z, but we want a division with a positive number. Without the negative sign, the x and y coordinates would be flipped and the image would be upside down. After the perspective division with w, the clip space coordinates for x and y are: x c = x v /( z v ) y c = y v /( z v ) In OpenGL, the part of the scene which is displayed is the region 1 x 1, 1 y 1 in clip space. It is usually necessary to also scale the coordinates to get the desired view. One way to specify the scaling is to require that objects at a certain distance, d, should appear in their original size. Simply multiplying x and y with d achieves this: x c = dx v /( z v ) y c = dy v /( z v ) If the image is not square, we need to scale either x or y to map the view to the unit square in clip space. If the image is a times wider than it is tall, we can divide the x coordinate with a: x c = d a x v/( z v ) y c = dy v /( z v ) The distance d at which the size of objects should not change, the distance to the unit sized view plane, is not a very convenient parameter for most situations. Instead, it is customary to specify the field of view for the projection. The relation between the distance d to the view plane and the vertical field of view v is, according to figure 3: 1 d = tan v d = 1 tan v = cot v If the image is a times wider than it s tall, the horizontal field of view v h is: v h = arctan(a tan v ) Of course, the horizontal field of view could be used as a reference instead, and the vertical field of view would be computed similarly. Another common choice is to specify the field of view for the image diagonal, but the principle is the same. That takes care of three of the rows for the perspective matrix: the equations for computing x, y, and w. Getting the z coordinate right, however, is a bit tricky. 4

5 1 d v Figure 3: View plane distance and field of view. 3 Depth In OpenGL, the depth coordinate in clip space, z c, is in the range 1 z c 1, just like x c and y c. In retrospect, this was an unfortunate choice in the design of OpenGL. A better choice would have been to use the range 0 to 1, but we ll leave that aside for now and use the standard approach. 1 As shown in the lower part of Figure, the mapping from view space to clip space flips the direction of the depth coordinate, so that clip space is actually a left-handed system. This is somewhat odd, and Gortler s choice to keep a right-handed system throughout is understandable. However, the left-handed clip space is how OpenGL did it in the 1990 s, it works, and most people are sticking to it. We want to perform the transformation of the depth coordinate in the same matrix operation as that for the perspective division, and the depth z c should only depend on z v, so we can only do one kind of mapping from z v to z c : a linear transformation followed by a division with z v : z c = (αz v + β)/( z v ) To get the mapping presented in Figure, we want the far plane z v = f to map to z c = 1, and the near plane z v = n to map to z c = 1. This gives us two equations: α( f) + β = 1 f α( n) + β = 1 n Solving this for α and β is left as an exercise for the reader. (Yes, really. Do the math. Don t just accept this as magic.) The result is: 1 The depth mapping in OpenGL would actually need to be changed now that a 3-bit floating point depth buffer is the standard, and in modern OpenGL, there are ways to change it to improve the range and precision in the depth buffer. For a detailed description of what is wrong with the standard treatment of depth buffers in OpenGL and Direct3D, and how to fix it, you can read this excellent article: 5

6 α = f + n f n β = fn f n Thus, our final perspective matrix for OpenGL is: d/a P = 0 d f+n f n fn f n where d = 1/ tan(v/), v is the vertical field of view, a is the aspect ratio of the image (its width divided by its height), and n and f are the positive distances to the near and far clipping planes, respectively. 6