Q2Computer Graphics and Multimedia

3D clipping removes parts of geometric primitives (lines, polygons) that fall outside the 3D view volume (view frustum). The view frustum is defined by 6 clipping planes: near, far, left, right, top, and bottom. Clipping is typically performed after the projection transform but before perspective division.

Extension of the 2D Cohen-Sutherland algorithm using 6-bit region codes (one bit per clipping plane: left, right, bottom, top, near, far). Trivial accept/reject tests are performed first, then successive clipping against active planes for remaining cases.

Uses the parametric form of the line P(t)=P0+t(P1-P0) and finds parameter values at intersection with each clipping plane. Computes tEntry (maximum of lower t-values) and tExit (minimum of upper t-values). If tEntry ≤ tExit and both in [0,1], the line segment between them is visible. More efficient than Cohen-Sutherland for general convex volumes.

In modern pipelines, clipping is performed in homogeneous clip space (before perspective division) using the six frustum planes defined by -w ≤ x ≤ w, -w ≤ y ≤ w, -w ≤ z ≤ w. Sutherland-Hodgman polygon clipping extended to 3D against each of the 6 planes.

For closed solid objects, polygons whose outward-facing normal points away from the viewer are not visible (back faces). Back-face culling discards them before rendering, reducing polygon count by ~50%.

Detection method: Compute the surface normal N of each polygon. If N · V > 0 (where V is the view direction from polygon to eye), the polygon is a front face and is rendered. If N · V ≤ 0, it is a back face and is culled. In view space, if the z-component of the normal Nz < 0 for polygons facing the viewer (assuming camera looks along -Z), the face is culled.

The Z-Buffer algorithm is the most widely used hidden surface removal technique, implemented in hardware on all modern GPUs. It uses two buffers: a color buffer (stores pixel colors) and a depth buffer (z-buffer, stores the depth/z-value of the closest surface rendered for each pixel).

• Initialize z-buffer to maximum depth (z = +∞ or max float) and color buffer to background color.
• For each polygon in the scene:
• For each pixel (x,y) covered by the polygon:
• Compute interpolated depth z at (x,y) for this polygon.
• If z < zbuffer[x][y] (new surface is closer to viewer):
• Update zbuffer[x][y] = z.
• Update colorbuffer[x][y] = shaded color of surface at (x,y).
• After all polygons processed, the color buffer contains the final visible image.

• Correctness: Handles arbitrary complex scenes including intersecting and overlapping polygons.
• Order-independent: Polygons can be processed in any order.
• Memory: Requires z-buffer same size as framebuffer (e.g., ~8 MB for 1080p at 32-bit depth).
• Z-fighting: Precision issues when two surfaces have very similar z-values — resolved with logarithmic depth buffer.
• Hardware: Implemented natively in all modern GPU fixed-function pipelines.