4731/543: CS Computer Graphics Lecture 5 (Part IV): Hidden Surface Removal Emmanuel Agu
Hidden surface Removal
n n n n
Drawing polygonal faces on screen consumes CPU cycles We cannot see every surface in scene To save time, draw only surfaces we see Surfaces we cannot see and their elimination methods:
n n n
Occluded surfaces: hidden surface removal (visibility) Back faces: back face culling Faces outside view volume: viewing frustrum culling Object space techniques: applied before vertices are mapped to pixels Image space techniques: applied after vertices have been rasterized
n
Definitions:
n
n
Visibility (hidden surface removal)
n n
A correct rendering requires correct visibility calculations Correct visibility when multiple opaque polygons cover the same screen space, only the closest one is visible (remove the other hidden surfaces)
wrong visibility
Correct visibility
Visibility (hidden surface removal)
n
Goal: determine which objects are visible to the eye
n
Determine what colors to use to paint the pixels
n
Active research subject - lots of algorithms have been proposed in the past (and is still a hot topic)
Visibility (hidden surface removal)
n
Where is visiblity performed in the graphics pipeline?
v1, m1
modeling and viewing
v2, m2 v3, m3
per vertex lighting interpolate vertex colors
projection
Rasterization texturing Shading visibility
viewport mapping
clipping
Display Note: Map (x,y) values to screen (draw) and use z value for depth testing
OpenGL - Image Space Approach
Determine which of the n objects is visible to each pixel
on the image plane
for (each pixel in the image) { determine the object closest to the pixel draw the pixel using the objects color }
Image Space Approach Z-buffer
Method used in most of graphics hardware (and thus OpenGL): Z-buffer (or depth buffer) algorithm Requires lots of memory Recall: after projection transformation, in viewport transformation
n n
n n n
x,y used to draw screen image, mapped to viewport z component is mapped to pseudo-depth with range [0,1]
n n n n
Objects/polygons are made up of vertices Hence, we know depth z at polygon vertices Point on object seen through pixel may be between vertices Need to interpolate to find z
Image Space Approach Z-buffer
Basic Z-buffer idea:
n n
n
n n
rasterize every input polygon For every pixel in the polygon interior, calculate its corresponding z value (by interpolation) Track depth values of closest polygon (smallest z) so far Paint the pixel with the color of the polygon whose z value is the closest to the eye.
Z (depth) buffer algorithm
n n
How to choose the polygon that has the closet Z for a given pixel? Example: eye at z = 0, farther objects have increasingly positive values, between 0 and 1
1. 2. 3. Initialize (clear) every pixel in the z buffer to 1.0 Track polygon zs. As we rasterize polygons, check to see if polygons z through this pixel is less than current minimum z through this pixel Run the following loop:
4.
Z (depth) Buffer Algorithm
For each polygon { for each pixel (x,y) inside the polygon projection area { if (z_polygon_pixel(x,y) < depth_buffer(x,y) ) { depth_buffer(x,y) = z_polygon_pixel(x,y); } color_buffer(x,y) = polygon color at (x,y)
}
}
Note: know depths at vertices. Interpolate for interior z_polygon_pixel(x, y) depths
Z buffer example
Z = 0.5 Z = 0.3
Correct Final image
eye Top View
Z buffer 1: example
Step Initialize the depth buffer
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0
Z buffer example
Step 2: Draw the blue polygon (assuming the OpenGL program draws blue polyon first the order does not affect the final result any way).
Z = 0.5
1.0 1.0 0.5 0.5
1.0 1.0 0.5 0.5
1.0 1.0 1.0 1.0
1.0 1.0 1.0 1.0 eye
Z = 0.3
Z buffer example
Step 3: Draw the yellow polygon
1.0 1.0 0.5 0.5
1.0 0.3 0.3 0.5
1.0 0.3 0.3 1.0
1.0 1.0 1.0 1.0
Z = 0.5 Z = 0.3
eye
z-buffer drawback: wastes resources by rendering a face and then drawing over it
Combined z-buffer and Gouraud Shading (fig 8.31)
for(int y = ybott; y <= ytop; y++) // for each scan line { for(each polygon){ find xleft and xright find dleft and dright, and dinc find colorleft and colorright, and colorinc for(int x = xleft, c = colorleft, d = dleft; x <= xright; x++, c+= colorinc, d+= dinc) color3 if(d < d[x][y]) ytop { color4 y4 put c into the pixel at (x, y) d[x][y] = d; // update closest depth ys }} } ybott
color2
color1 xleft xright
Z-Buffer Depth Compression
n n n n n
Recall that we chose parameters a and b to map z from range [near, far] to pseudodepth range[0,1] This mapping is almost linear close to eye Non-linear further from eye, approaches asymptote Also limited number of bits Thus, two z values close to far plane may map to same pseudodepth: Errors!! F+N
Actual z 1 N F -1 -Pz
a = F N
aPz + b Pz
FN b = 2 N F
OpenGL HSR Commands
n
Primarily three commands to do HSR glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB) instructs openGL to create depth buffer glEnable(GL_DEPTH_TEST) enables depth testing glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) initializes the depth buffer every time we draw a new picture
n
n
n
Back Face Culling
n n
Back faces: faces of opaque object which are pointing away from viewer Back face culling remove back faces (supported by OpenGL)
Back face
n
How to detect back faces?
Back Face Culling
n n n n n n
If we find backface, do not draw, save rendering resour...