Visibility

1. Visibility Aaron Bloomfield CS 445: Introduction to Graphics Fall 2006 (Slide set originally by David Luebke)

2. Overview • Analytic Visibility Algorithms • BSPs • Warnock's Algorithm • Z-Buffer Algorithm • Visibility Culling • Cells and Portals • Occlusion Culling • Hierarchical Z-Buffer • Modern Occlusion Culling • Fog

3. Occlusion • For most interesting scenes, some polygons will overlap: • To render the correct image, we need to determine which polygons occlude which

4. Painter’s Algorithm • Simple approach: render the polygons from back to front, “painting over” previous polygons: • Draw blue, then green, then pink • Will this work in general?

5. Painter’s Algorithm: Problems • Intersecting polygons present a problem • Even non-intersecting polygons can form a cycle with no valid visibility order:

6. Analytic Visibility Algorithms • Early visibility algorithms computed the set of visible polygon fragments directly, then rendered the fragments to a display: • Now known as analytic visibility algorithms

7. Analytic Visibility Algorithms • What is the minimum worst-case cost of computing the fragments for a scene composed of n polygons? • Answer: O(n2)

8. Analytic Visibility Algorithms • So, for about a decade (late 60s to late 70s) there was intense interest in finding efficient algorithms for hidden surface removal • We’ll talk about two analytic visibility algorithms: • Binary Space-Partition (BSP) Trees • Warnock’s Algorithm

9. Overview • Analytic Visibility Algorithms • BSPs • Warnock's Algorithm • Z-Buffer Algorithm • Visibility Culling • Cells and Portals • Occlusion Culling • Hierarchical Z-Buffer • Modern Occlusion Culling • Fog

10. Binary Space Partition Trees (1979) • Basic algorithm • For each triangle (or polygon) t in the scene • Find the plane that t implicitly forms • Let the eyepoint be on one side of t • Then t can be drawn before all triangles on the other side of t • So we draw the “far” stuff first, then t, then the “near” stuff • Restrictions • Only works on a scene where no polygons crosses a plane defined by another polygon • This also means you can’t have a cycle • This restriction is relaxed by a preprocessing step • Split up such triangles into multiple triangles

11. Binary Space Partition Trees • BSP tree: organize all of space (hence partition)into a binary tree • Preprocess: overlay a binary tree on objects in the scene • This includes the step of splitting a primitive that crosses a plane into multiple primitives • Runtime: correctly traversing this tree enumerates objects from back to front • Idea: divide space recursively into half-spaces by choosing splitting planes • Splitting planes can be arbitrarily oriented • Notice: nodes are always convex

12. BSP Trees: Objects 9 8 7 6 5 4 1 2 3

13. BSP Trees: Objects 9 8 7 6 8 9 1 2 3 6 7 4 5 5 4 1 2 3

14. BSP Trees: Objects 9 8 7 6 5 4 7 8 9 2 5 6 3 4 1 1 2 3

15. BSP Trees: Objects 9 8 7 6 5 1 4 1 2 3 2 8 7 9 6 5 4 3

16. BSP Trees: Objects 9 8 7 6 5 1 4 1 2 3 8 6 5 3 7 9 2 4

17. Rendering BSP Trees renderBSP(BSPtree *T) BSPtree *near, far; if (eye on left side of T->plane) near = T->left; far = T->right; else near = T->right; far = T->left; renderBSP(far); if (T is a leaf node) renderObject(T) renderBSP(near);

18. Rendering BSP Trees 9 8 7 6 5 1 4 1 2 3 8 6 5 3 7 9 2 4

19. Rendering BSP Trees 9 8 7 6 5 1 4 1 2 3 8 6 5 3 7 9 2 4

20. Polygons: BSP Tree Construction • Split along the plane containing any polygon • Classify all polygons into positive or negative half-space of the plane • If a polygon intersects plane, split it into two • The aforementioned preprocessing step • Recurse down the negative half-space • Recurse down the positive half-space

21. Polygons: BSP Tree Traversal • Query: given a viewpoint, produce an ordered list of (possibly split) polygons from back to front: BSPnode::Draw(Vec3 viewpt) Classify viewpt: in + or - half-space of node->plane? // Call that the “near” half-space farchild->draw(viewpt); render node->polygon; // always on node->plane nearchild->draw(viewpt); • Intuitively: at each partition, draw the stuff on the farther side, then the polygon on the partition, then the stuff on the nearer side

22. Discussion: BSP Tree Cons • No bunnies were harmed in my example • But what if a splitting plane passes through an object? • Split the object; give half to each node: • Worst case: can create up to O(n3) objects! Ouch

23. BSP Trees • A BSP Tree increases storage requirements by splitting polygons • What is the worst-case storage cost of a BSP tree on n polygons? • But rendering a BSP tree is fairly efficient • What is the expected cost of a single query, for a given viewpoint, on a BSP tree with m nodes?

24. BSP Demo • Nice demo: • http://symbolcraft.com/graphics/bsp/index.html • Also has a link to the BSP Tree FAQ

25. Summary: BSP Trees • Pros: • Simple, elegant scheme • Only writes to framebuffer (i.e., painters algorithm) • Thus once very popular for video games (but no longer, at least on PC platform) • Still very useful for other reasons (more later)

26. Summary: BSP Trees • Cons: • Computationally intense preprocess stage restricts algorithm to static scenes • Worst-case time to construct tree: O(n3) • Splitting increases polygon count • Again, O(n3) worst case

27. Overview • Analytic Visibility Algorithms • BSPs • Warnock's Algorithm • Z-Buffer Algorithm • Visibility Culling • Cells and Portals • Occlusion Culling • Hierarchical Z-Buffer • Modern Occlusion Culling • Fog

28. Warnock’s Algorithm (1969) • Elegant scheme based on a powerful general approach common in graphics: if the situation is too complex, subdivide • Start with a root viewport and a list of all primitives • Then recursively: • Clip objects to viewport • If number of objects incident to viewport is zero or one, visibility is trivial • Otherwise, subdivide into smaller viewports, distribute primitives among them, and recurse

29. Warnock’s Algorithm • What is the terminating condition? • How to determine the correct visible surface in this case?

30. Warnock’s Algorithm • Pros: • Very elegant scheme • Extends to any primitive type • Cons: • Hard to embed hierarchical schemes in hardware • Complex scenes usually have small polygons and high depth complexity • Thus most screen regions come down to the single-pixel case

31. Overview • Analytic Visibility Algorithms • BSPs • Warnock's Algorithm • Z-Buffer Algorithm • Visibility Culling • Cells and Portals • Occlusion Culling • Hierarchical Z-Buffer • Modern Occlusion Culling • Fog

32. The Z-Buffer Algorithm • Both BSP trees and Warnock’s algorithm were proposed when memory was expensive • Ed Catmull (mid-70s) proposed a radical new approach called the z-buffer • (He went on to help found a little company named Pixar) • The big idea: resolve visibility independently at each pixel

33. The Z-Buffer Algorithm • We know how to rasterize polygons into an image discretized into pixels:

34. The Z-Buffer Algorithm • What happens if multiple primitives occupy the same pixel on the screen? Which is allowed to paint the pixel?

35. The Z-Buffer Algorithm • Idea: retain depth (Z in eye coordinates) through projection transform • Recall canonical viewing volumes • Can transform canonical perspective volume into canonical parallel volume with:

36. The Z-Buffer Algorithm • Augment framebuffer with Z-buffer or depth buffer which stores Z value at each pixel • At frame beginning initialize all pixel depths to  • When rasterizing, interpolate depth (Z) across polygon and store in pixel of Z-buffer • Suppress writing to a pixel if its Z value is more distant than the Z value already stored there • “More distant”: greater than or less than, depending

37. Interpolating Z • Edge equations: Z is just another planar parameter: z = Ax + By + C • Look familiar? • Total cost: • 1 more parameter to increment in inner loop • 3x3 matrix multiply for setup • See interpolating color discussion from aprevious lecture • Edge walking: can interpolate Z along edges and across spans

38. The Z-Buffer Algorithm • How much memory does the Z-buffer use? • Does the image rendered depend on the drawing order? • Does the time to render the image depend on the drawing order? • How much of the pipeline do occluded polygons traverse? • What does this imply for the front of the pipeline? • How does Z-buffer load scale with visible polygons? • With framebuffer resolution?

39. Z-Buffer Pros • Simple!!! • Easy to implement in hardware • Polygons can be processed in arbitrary order • Easily handles polygon interpenetration • Enablesdeferred shading • Rasterize shading parameters (e.g., surface normal) and only shade final visible fragments • When does this help?

40. Z-Buffer Cons • Lots of memory (e.g. 1280x1024x32 bits) • Read-Modify-Write in inner loop requires fast memory • Hard to do analytic antialiasing • Hard to simulate translucent polygons • Precision issues (scintillating, worse with perspective projection)

41. Overview • Analytic Visibility Algorithms • BSPs • Warnock's Algorithm • Z-Buffer Algorithm • Visibility Culling • Cells and Portals • Occlusion Culling • Hierarchical Z-Buffer • Modern Occlusion Culling • Fog

42. Visibility Culling • The basic idea: don’t render what can’t be seen • Off-screen: view-frustum culling • Solved by clipping • Occluded by other objects: occlusion culling • Solved by Z-buffer • The obvious question: why bother? • The (obvious) answer: efficiency • Clipping and Z-buffering take time linear to the number of primitives

43. The Goal • Our goal: quickly eliminate large portions of the scene which will not be visible in the final image • Not the exact visibility solution, but a quick-and-dirty conservative estimate of which primitives might be visible • Z-buffer & clip this for the exact solution • This conservative estimate is called the potentially visible set or PVS

44. Visibility Culling • The remainder of this talk will cover: • View-frustum culling (briefly) • Occlusion culling in architectural environments • General occlusion culling

45. View-Frustum Culling • An old idea (Clark 76): • Organize primitives into clumps • Before rendering the primitives in a clump, test a bounding volume against the view frustum • If the clump is entirely outside the view frustum, don’t render any of the primitives • If the clump intersects the view frustum, add to PVS and render normally

46. Efficient View-Frustum Culling • How big should the clumps be? • Choose minimum size so:cost testing bounding volume << cost clipping primitives • Organize clumps into a hierarchy of bounding volumes for more efficient testing • If a clump is entirely outside or entirely inside view frustum, no need to test its children

47. Efficient View-Frustum Culling • What shape should the bounding volumes be? • Spheres and axis-aligned bounding boxes: simple to calculate, cheap to test • Oriented bounding boxesconverge asymptotically faster in theory • Lots of other volumes have been proposed, but most people still use spheres or AABBs.

48. Overview • Analytic Visibility Algorithms • BSPs • Warnock's Algorithm • Z-Buffer Algorithm • Visibility Culling • Cells and Portals • Occlusion Culling • Hierarchical Z-Buffer • Modern Occlusion Culling • Fog

49. Cells & Portals • Goal: walk through architectural models (buildings, cities, catacombs) • These divide naturally into cells • Rooms, alcoves, corridors… • Transparent portalsconnect cells • Doorways, entrances, windows… • Notice: cells only see other cells through portals

50. Cells & Portals • An example: