Is there a way to depict using matrix operations or equivalent, the practice of z-culling in a 3D-to-2D render algorithm

Question

To clarify, the purpose of the question is to try and identify (if possible) a way to accomplish the entire 3D-to-2D projection/render process, including the z-buffering and depth-culling steps, using a chain of matrix multiplication/addition or equivalent operations.

Note: "Simply not possible" would be an acceptable answer, if accurate.

Answer 1

A way to visualize perspective projections is to imagine the camera as consisting of a plane $P$ (the "film") plus a single point $F$ (the "lens") that does not lie on P.

To find the image $I_X \in P$ of an arbitrary point $X$, you intersect the (unique!) line that contains $X$ and $P$ with the plane $P$ -- the point of intersection is then $I_X$.

For orthogonal projections (in place of perspective ones), you only need $P$, and instead of picking lines through $X$ and $F$, you pick lines orthogonal to $P$ and going through $X$.

In reality, you usually want to project arbitrary surfaces and not only points. The standard approach to that is to first split the surface into a number of triangles. Each triangle is then projected onto the image area separately. Note that, since the projections described above have the property that they map straight lines to straight lines, a triangle can be projected by simply projecting its vertices! The resulting triangle in the image plane is then colored with whatever color the triangle is supposed to have (I'm ignoring lighting and texturing here!).

To deal with overlapping objects, each pixel in the image plane is associated with a $z$-Value, in addition to the three color values $R$,$G$ and $B$. When projecting a triangle, you then do the following steps

1. Project the three vertices $v_1, v_2, v_3$, and for each vertex $v_i$ determine the distance $d_i$ between the vertex and the lense
2. Loop over the pixels within the triangle created by the projected vertices in the image plane.
   1. Find the distance $d$ corresponding to the current pixel by interpolating between $d_1, d_2$ and $d_3$. Or alternatively, find $d$ by reverse-projecting the pixel onto the original triangle.
   2. Compare $d$ to the pixel's $z$-value. If the $z$-value is less than $d$, skip the pixel
   3. Otherwise, color the pixel in the triangle's color, and store $d$ in the pixel's $z$-value.

Depth culling is a optimization of this procedure -- you tried to skip whole triangles (or even whole objects) if you can determine before-hand that all their pixels will fail the depth test. But unless you're dealing with very simply scenes, you'll usually still need a $z$-Buffer -- triangles are usually allowed to overlap partially, and depth culling techniques usually won't be able to deal with that correctly on their own.