1 / 86

Visibility

Visibility. Aaron Bloomfield CS 445: Introduction to Graphics Fall 2006 (Slide set originally by David Luebke). Overview. Analytic Visibility Algorithms BSPs Warnock's Algorithm Z-Buffer Algorithm Visibility Culling Cells and Portals Occlusion Culling Hierarchical Z-Buffer

varick
Download Presentation

Visibility

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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:

More Related