1. CAP4730: Computational Structures in Computer Graphics Visible Surface Determination

2. Outline The goal of visible surface determination Normals Backface Culling Depth Buffer BSP Trees Determining if something isn’t in the view frustum (research topics)

3. Goal of Visible Surface Determination To draw only the surfaces (triangles) that are visible, given a view point and a view direction

4. Three reasons to not draw something 1. It isn’t in the view frustum 2. It is “back facing” 3. Something is in front of it (occlusion) We need to do this computation quickly. How quickly?

5. Surface Normal Surface Normal - vector perpendicular to the surface Three non-collinear points (that make up a triangle), also describes a plane. The normal is the vector perpendicular to this plane.

6. Normals

7. How do we compute a normal? Q: Given a Triangle, how do we compute a normal? A: Normal = V 0 V 1 X V 0 V 2 But…. we know V 0 V 1 X V 0 V 2 != V 0 V 2 X V 0 V 1

8. Vertex Order Vertex order matters. We usually agree that counterclockwise determines which “side” or a triangle is labelled the “front”. Think: Right handed coordinate system.

9. What do the normals tell us? Q: How can we use normals to tell us which “face” of a triangle we see?

10. Examine the angle between the normal and the view direction V N Front if V. N <0

11. Viewing Coordinates If we are in viewing coordinates, how can we simplify our comparison? Think about the different components of the normals you want and don’t want.

12. Backface Culling Before scan converting a triangle, determine if it is facing you Compute the dot product between the view vector (V) and triangle normal (N) Simplify this to examining only the z component of the normal If N z <0 then it is a front facing triangle, and you should scan convert it What surface visibility problems does this solve? Not solve? Review OpenGL code

13. Multiple Objects If we want to draw: We can sort in z. What are the advantages? Disadvantages? Called Painter’s Algorithm or splatting.

14. Painter’s Algorithm Subtleties What do we mean sort in z? That is for a triangle, what is its representative z value? –Minimum z –Maximum z –Polygon’s centroid Work cost = sort + draw We still use Painter’s Algorithms for blended objects (discussed in the Blending Lesson) An object space visibility algorithm

15. Side View

16. Side View - What is a solution?

17. Even Worse… Why?

18. Painter’s Algorithm Pros: –No extra memory –Relatively fast –Easy to understand and implement Cons: –Precision issues (and additional work to handle them) –Sort stage –Intersecting objects

19. Depth Buffers Goal: We want to only draw something if it appears in front of what is already drawn. What does this require? Can we do this on a per object basis?

20. Depth Buffers We can’t do it object based, it must be image based. What do we know about the x,y,z points where the objects overlap? Remember our “eye” or “camera” is at the origin of our view coordinates. What does that mean need to store?

21. Side View

22. Algorithm We need to have an additional value for each pixel that stores the depth value. What is the data type for the depth value? How much memory does this require? Playstation 1 had 2 MB. The first 512 x 512 framebuffer cost $50,000 Called Depth Buffering or Z buffering

23. Depth Buffer Algorithm Begin frame –Clear color –Clear depth to z = z max Draw Triangles –When scan converting z new pixel < z value at the pixel, set color and z value at the pixel = z new pixel –What does it mean if z new pixel > z value at the pixel ? –Why do we clear the depth buffer? –Now we see why it is sometimes called the z buffer

24. Computing the z new pixel Q: We can compute the z nsc at the vertices, but what is the z nsc as we scan convert? A: We interpolate z nsc while we scan convert too!

25. Metrics for Visibility Algorithms Running Time - 1 extra compare Storage Overhead - 1 extra field per pixel Overdraw - we have to scan convert all triangles Memory Bandwidth - how much we have to retrieve from memory. Increased Precision - Let’s examine the possible values of z and what that means

26. Z Buffer Precision What does the # of bits for a depth buffer element mean? The z from eye space to normalized screen space is not linear. That is we do not have the same precision across z. (we divided by z). In fact, half of our precision is in z=0 and z=0.5. What does this mean? What happens if we do NOT have enough precision?

27. Z Fighting If we do not have enough precision in the depth buffer, we can not determine which fragment should be “in front”. What does this mean for the near and far plane? We want them to as closely approximate our volume

28. Z Fighting Zoomed In Run Demo

29. Don’t forget Even in 1994, memory wasn’t cheap. If we wanted 1024x768x16bit = 1.6 MB additional memory. Depth Buffers weren’t common till recently because of this. Since we have to draw every triangle -> fill rate goes UP. Currently graphics cards approach the many billions of pixels per second. An image space algorithm Let’s review OpenGL code

30. Depth Buffer Algorithm Pros: –Easy to understand and implement –per pixel “correct” answer –no preprocess –draw objects in any order –no need to redivide objects Cons: –Z precision –additional memory –Z fighting

31. BSP Trees (Fuchs, et. al 1980) Binary Space Partitioning –Doom and most games before depthbuffers (circa 1994-95) –Given a world, we want to build a data structure that given any point, it can return a sorted list of objects –What assumptions are we making? –Note, what happens in those “old” games like Doom?

32. BSP Trees Two stages: –preprocess - we do this at the “offline” –runtime - what we do per frame Draw parallels to Doom –Since this is easier in 2D, note all “old” FPS are really 3D.

33. BSP Algorithm For a viewpoint, determine where it sits on the tree. Now draw objects on the “other half of the tree” –farside.draw(viewpoint) –nearside.draw(viewpoint) Intuition - we draw things farther away first Is this an image space or object space algorithm?

36. BSP Trees Pros –Preprocess step means fast determination of what we can see and can’t –Works in 3D -> Quake1 –Painter’s algorithm Pros Cons –Still has intersecting object problems –Static scene

37. Determining if something is viewable Viewfrustum Culling (football example) Cells and Portals –definitions cell portal –preprocess step –runtime computation –where do we see it? Quake3