1. Setting the Stage: What Does Perspective Projection Do?

The perspective projection matrix transforms 3D points from camera space (or view space) into clip space (before clipping and normalization). The key goals of a perspective projection matrix are:

• Mapping 3D points to 2D while preserving the depth information.
• Foreshortening: Objects further away from the camera appear smaller.
• Clipping: Points outside the view frustum (outside the near and far planes, or outside the left, right, top, and bottom planes) are clipped.

Both OpenGL and Direct3D use a 4x4 matrix to achieve this, but they handle things like depth range and homogeneous coordinates differently. These differences give us two distinct forms of the projection matrix.

2. General Perspective Projection Matrix Setup

A perspective projection matrix typically involves the following parameters:

• Field of view (FOV) — defines the viewing angle.
• Aspect ratio (AR) — the ratio of the width to the height of the image.
• Near plane (n) and far plane (f) — these define the depth range of the scene being rendered.
• Frustum bounds — the left, right, top, and bottom boundaries of the view frustum (a truncated pyramid that represents the visible part of the scene).

The view frustum is defined by:

• $l$: Left boundary of the near plane.
• $r$: Right boundary of the near plane.
• $b$: Bottom boundary of the near plane.
• $t$: Top boundary of the near plane.
• $n$: Distance to the near clipping plane.
• $f$: Distance to the far clipping plane.

3. Deriving the Perspective Projection Matrix

(a) Frustum Definition

The frustum is a truncated pyramid that defines the visible region of the 3D scene:

• Near clipping plane: The rectangle at $z=n$, defined by $[l,r]$ in the horizontal direction and $[b,t]$ in the vertical direction.
• Far clipping plane: The rectangle at $z=f$, also bounded horizontally and vertically.

The idea is to map 3D points inside this frustum to a cube (known as clip space) where:

• $x$ is in the range $[-1,1]$,
• $y$ is in the range $[-1,1]$,
• For OpenGL, $z$ is in the range $[-1,1]$,
• For Direct3D, $z$ is in the range $[0,1]$.

(b) Perspective Projection Matrix Form

To map the 3D frustum to this normalized clip space, we use a perspective projection matrix. For both OpenGL and Direct3D, the general form of the matrix is the same:

$$P_{4x4}=\left[\begin{array}{cccc}\frac{2n}{r-l}& 0& \frac{r+l}{r-l}& 0\\ 0& \frac{2n}{t-b}& \frac{t+b}{t-b}& 0\\ 0& 0& \frac{f+n}{n-f}& \frac{2fn}{n-f}\\ 0& 0& -1& 0\end{array}\right]$$

Where:

• $r$, $l$: Right and left boundaries of the frustum at the near plane.
• $t$, $b$: Top and bottom boundaries of the frustum at the near plane.
• $n,f$: Near and far clipping distances.

© Breaking Down the Matrix:

Let’s break down each part of this matrix:

• First row (horizontal scaling):
  $$\frac{2n}{r-l}$$
  This scales the x-coordinate into the range $[-1,1]$ in clip space. The $r-l$ term ensures the width of the frustum is correctly mapped, and the factor of $2n$ accounts for the depth and field of view.

  The third element of the first row,
  $$\frac{r+l}{r-l}$$
  adjusts for the horizontal offset of the frustum (if it’s centered or not).

• Second row (vertical scaling):
  $$\frac{2n}{t-b}$$
  This scales the y-coordinate into the range $[-1,1]$ in clip space. Similar to the horizontal scaling, this term ensures the height of the frustum is correctly mapped.

  The third element of the second row,
  $$\frac{t+b}{t-b}$$
  adjusts for the vertical offset of the frustum.

• Third row (depth scaling):
  $$\frac{f+n}{n-f}$$
  This term maps the z-coordinate (depth) from the range $[n,f]$ in camera space into the clip space range. Here’s where the difference between OpenGL and Direct3D comes in:

  • In OpenGL, we want $z$ to be mapped into the range $[-1,1]$.
  • In Direct3D, we want $z$ to be mapped into the range $[0,1]$.

  The fourth element of the third row,
  $$\frac{2fn}{n-f}$$
  ensures that the depth values are correctly scaled.

• Fourth row:
  $$-1$$
  This term ensures the correct perspective divide happens, where after applying the transformation, the coordinates are divided by $w$ to obtain normalized device coordinates (NDC).

4. Differences Between OpenGL and Direct3D Matrices

Now, let’s focus on the key differences between the OpenGL and Direct3D perspective projection matrices.

(a) Depth Range Differences (Third Row)

• OpenGL: The depth range is mapped to $[-1,1]$. This is why the term $\frac{f+n}{n-f}$ is used in the $M_{33}$ element of the OpenGL matrix. It ensures that $z$ values at the near plane ($z=n$) are mapped to $-1$ and at the far plane ($z=f$) are mapped to $1$.

  This explains why $M_{33}=1$ in OpenGL, as OpenGL uses a symmetric depth range around 0.

• Direct3D: The depth range is mapped to $[0,1]$. In Direct3D, $P_{33}=-1$ because Direct3D maps the near plane to $z=0$ and the far plane to $z=1$. This convention is more compatible with common buffer formats (where a depth of 0 corresponds to the near plane and 1 corresponds to the far plane).

(b) $c_x$ and $c_y$ (Principal Point Offsets)

The terms $c_x$ and $c_y$ (the third elements in the first and second rows) represent the offsets for the principal point (the center of projection) on the image plane. These terms are different because they depend on how the frustum is defined:

• In OpenGL, the frustum is typically symmetric, so $c_x$ and $c_y$ are often 0 when the frustum is centered. This means that the projection is symmetric around the origin in clip space.

• In Direct3D, the frustum may be defined differently, or the principal point may be offset from the center (especially if the projection is not symmetric). This can lead to non-zero values for $c_x$ and $c_y$.

5. Alternative Form: Field of View (FOV) Perspective Matrix

In some cases, instead of defining the frustum with explicit bounds $(r,l,t,b)$, it’s more intuitive to use the field of view (FOV) and aspect ratio. The projection matrix in this form is often used for cameras:

$$P_{4x4}=\left[\begin{array}{cccc}\frac{1}{AR\cdot \tan (\frac{FOV}{2})}& 0& 0& 0\\ 0& \frac{1}{\tan (\frac{FOV}{2})}& 0& 0\\ 0& 0& \frac{f+n}{n-f}& \frac{2fn}{n-f}\\ 0& 0& -1& 0\end{array}\right]$$

Where:

• $FOV$ is the field of view angle.
• $AR$ is the aspect ratio (width/height).
• $n$ and $f$ are the near and far clipping planes.