Clipping in clipping coordinate system and normalized device coordinate system (OpenGL)

Question

I heard clipping should be done in clipping coordinate system. The book suggests a situation that a line is laid from behind camera to in viewing volume. (We define this line as PQ, P is behind camera point) I cannot understand why it can be a problem.

(The book says after finishing normalizing transformation, the P will be laid in front of camera.)

I think before making clipping coordinate system, the camera is on original point (0, 0, 0, 1) because we did viewing transformation. However, in NDCS, I cannot think about camera's location.

And I have second question. In vertex shader, we do model-view transformation and then projection transformation. Finally, we output these vertices to rasterizer. (some vertices's w is not equal to '1')

Here, I have curiosity. The rendering pipeline will automatically do division procedure (by w)? after finishing clipping.

Answer 1

Sometimes not all the model can be seen on screen, mostly because some objects of it lie behind the camera (or "point of view"). Those objects are clipped out. If just a part of the object can't be seen, then just that part must be clipped leaving the rest as seen.

OpenGL clips

OpenGL does this clipping in Clipping Coordinate Space (CCS). This is a cube of size 2w x 2w x 2w where 'w' is the fourth coordinate resulting of (4x4) x (4x1) matrix and point multiplication. A mere comparison of coordinates is enough to tell if the point is clipped or not. If the point passes the test then its coordinates are divided by 'w' (so called "perspective division"). Notice that for ortogonal projections 'w' is always 1, and with perspective it's generally not 1.

CPU clips

If the model is too big perhaps you want to save GPU resources or improve the frame rate. So you decide to skip those objects that are going to get clipped anyhow. Then you do the maths on your own (on CPU) and only send to the GPU the vertices that passed the test. Be aware that some objects may have some vertices clipped while other vertices of this same object may not. Perhaps you do send them to GPU and let it handle these special cases.

You have a volume defined where only objects inside are seen. This volume is defined by six planes. Let's put ourselves in the camera and look at this volume: If your projection is perspective the six planes build a "fustrum", a sort of truncated pyramid. If your projection is orthogonal, the planes form a parallelepiped.

In order to clip or not to clip a vertex you must use the distance form the vertex to each of these six planes. You need a signed distance, this means that the sign tells you what side of the plane is seen form the vertex. If any of the six distance signs is not the right one, the vertex is discarded, clipped.

If a plane is defined by equation Ax+By+Cz+D=0 then the signed distance from p1,p2,p3 is (Ap1+Bp2+Cp3+D)/sqrt(A A+B B+C*C). You only need the sign, so don't bother to calculate the denominator.

Now you have all tools. If you know your planes on "camera view" you can calculate the six distances and clip or not the vertex. But perhaps this is an expensive operation considering that you must transform the vertex coodinates from model to camera (view) spaces, a ViewModel matrix calculation. With the same cost you use your precalculated ProjectionViewModel matrix instead and obtain CCS coordinates, which are much easier to compare to '2w', the size of the CCS cube.

Sometimes you want to skip some vertices not due to they are clipped, but because their depth breaks a criteria you are using. In this case CCS is not the right space to work with, because Z-coordinate is transformed into [-w, w] range, depth is somehow "lost". Instead, you do your clip test in "view space".