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
Modern Occlusion Culling
Fog
2
Occlusion

For most interesting scenes, some polygons will
overlap:

To render the correct image, we need to determine
which polygons occlude which
3
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?
4
Painter’s Algorithm: Problems


Intersecting polygons present a problem
Even non-intersecting polygons can form a cycle
with no valid visibility order:
5
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
6
Analytic Visibility Algorithms

What is the minimum worst-case cost of computing
the fragments for a scene composed of n
polygons?

Answer:
O(n2)
7
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
8
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
9
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
10
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
11
BSP Trees: Objects
9
6
8
7
5
4
1
2
3
12
BSP Trees: Objects
9
6
8
7
5
6
7
8
9
1
2
3
4
5
4
1
2
3
13
BSP Trees: Objects
9
6
8
7
5
7
4
1
2
8
9
5
6
2
3
4
1
3
14
BSP Trees: Objects
9
6
8
7
5
1
4
1
2
3
8
7
9
6
5
3
2
4
15
BSP Trees: Objects
9
6
8
7
5
1
4
1
2
3
8
6
7
9
5
3
2
4
16
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);
17
Rendering BSP Trees
9
6
8
7
5
1
4
1
2
3
8
6
7
9
5
3
2
4
18
Rendering BSP Trees
9
6
8
7
5
1
4
1
2
3
8
6
7
9
5
3
2
4
19
Polygons: BSP Tree Construction


Split along the plane containing any polygon
Classify all polygons into positive or negative halfspace 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
20
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
21
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:
Ouch

Worst case: can create up to O(n3) objects!
22
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?
23
BSP Demo

Nice demo:


http://symbolcraft.com/graphics/bsp/index.html
Also has a link to the BSP Tree FAQ
24
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)
25
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
26
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
27
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
28
Warnock’s Algorithm


What is the
terminating
condition?
How to
determine the
correct visible
surface in this
case?
29
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
30
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
31
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
32
The Z-Buffer Algorithm

We know how to rasterize polygons into an image
discretized into pixels:
33
The Z-Buffer Algorithm

What happens if multiple primitives occupy the
same pixel on the screen? Which is allowed to
paint the pixel?
34
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:
1
0
M 
0

0
0
1
0
0
1
0
1  zmin
0
1

0 
 zmin

1  zmin 
0 
0
35
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
36
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 a
previous lecture
Edge walking: can interpolate
Z along edges and across spans


37
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?
38
Z-Buffer Pros





Simple!!!
Easy to implement in hardware
Polygons can be processed in arbitrary order
Easily handles polygon interpenetration
Enables deferred shading


Rasterize shading parameters (e.g., surface normal) and
only shade final visible fragments
When does this help?
39
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)
40
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
41
Visibility Culling

The basic idea: don’t render what can’t be seen

Off-screen: view-frustum culling


Occluded by other objects: occlusion culling



Solved by clipping
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
42
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
43
Visibility Culling

The remainder of this talk will cover:



View-frustum culling (briefly)
Occlusion culling in architectural environments
General occlusion culling
44
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
45
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
46
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 boxes converge asymptotically faster
in theory
Lots of other volumes have been proposed, but most
people still use spheres or AABBs.
47
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
48
Cells & Portals


Goal: walk through architectural models (buildings,
cities, catacombs)
These divide naturally into cells


Transparent portals connect cells


Rooms, alcoves, corridors…
Doorways, entrances, windows…
Notice: cells only see other cells through portals
49
Cells & Portals

An example:
50
Cells & Portals

Idea:

Cells form the basic unit of PVS




PVS = potentially visible set
Create an adjacency graph of cells
Starting with cell containing eyepoint, traverse graph,
rendering visible cells
A cell is only visible if it can be seen through a sequence
of portals

So cell visibility reduces to testing portal sequences for a line of
sight…
51
Cells & Portals
E
A
D
B
F
C
G
H
A
B
E
C
D
F
G
H
52
Cells & Portals
E
A
D
B
F
C
G
H
A
B
E
C
D
F
G
H
53
Cells & Portals
E
A
D
B
F
C
G
H
A
B
E
C
D
F
G
H
54
Cells & Portals
E
A
D
B
F
C
G
H
A
B
E
C
D
F
G
H
55
Cells & Portals
E
A
D
B
F
C
G
H
A
B
E
C
D
F
G
H
56
Cells & Portals
E
A
D
B
C
?
F
G
H
A
B
E
C
D
F
G
?
H
57
Cells & Portals
E
A
D
B
C
X
F
G
H
A
B
E
C
D
X
H
F
G
58
Cells & Portals

View-independent solution: find all cells a particular cell
could possibly see:
E
A
D
B
F
C
G
H
C can only see A, D, E, and H
59
Cells & Portals

View-independent solution: find all cells a particular cell
could possibly see:
E
A
D
B
F
C
G
H
H will never see F
60
Cells and Portals

Questions:



How can we detect whether a given cell is visible from a
given viewpoint?
How can we detect view-independent visibility between
cells?
The key insight:

These problems reduce to eye-portal and portal-portal
visibility
61
Cells and Portals

Airey (1990): view-independent only

Portal-portal visibility determined by ray-casting



Non-conservative portal-portal test resulted in occasional errors
in PVS
Slow preprocess
Order-of-magnitude speedups
62
Cells and Portals: History

Teller (1993): view-independent + view-dependent

Portal-portal visibility calculated by line stabbing using
linear program




Cell-cell visibility stored in stab trees
View-dependent eye-portal visibility
PVS at run time
stage
further
refines
Slow (?) preprocess
Elegant, exact scheme
63
Cells and Portals: History

Luebke & Georges (1995): view-dependent only




Eye-portal visibility determined by intersecting portal
cull boxes
No preprocess (integrate w/ modeling)
Quick, simple hack
Now-archaic public-domain library: pfPortals
64
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
65
General Occlusion Culling

When cells and portals don’t work…



Trees in a forest
A crowded train station
Need general occlusion culling algorithms:



Aggregate occlusion
Dynamic scenes
Non-polygonal scenes
66
General Occlusion Culling

I’ll discuss two algorithms:


Loose front-to-back sorting
Hierarchical Z-Buffer


Ned Greene, SIGGRAPH 93
… and current hardware support
67
Loose Front-To-Back Sorting

Can sort your geometry in roughly front-to-back
order, e.g. by:



Using an octree/BSP tree
Sorting centroids or near points of bounding volumes
Why would this help?

A: Early rejection helps whole fragment pipeline
68
Image-Space Occlusion Culling


Many general occlusion culling algorithms use an
image-space approach
Idea: solve visibility in 2D, on the image plane
69
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
70
Hierarchical Z-Buffer

Replace Z-buffer with a Z-pyramid



Lowest level: full-resolution Z-buffer
Higher levels: each pixel represents the max depth of
the four pixels “underneath” it
Basic idea: hierarchical rasterization of the
polygon, with early termination where polygon is
occluded
71
Hierarchical Z-Buffer

Idea: test polygon against highest level first



If polygon is further than distance recorded in pixel,
stop—it’s occluded
If polygon is closer, recursively check against next lower
level
If polygon is visible at lowest level, set new distance
value and propagate up
72
Hierarchical Z-Buffer

Z-pyramid exploits image-space coherence:


Polygon occluded in a pixel
nearby pixels
is probably occluded in
HZB also exploits object-space coherence

Polygons near an occluded polygon are probably
occluded
73
Hierarchical Z-Buffer

Exploiting object-space coherence:




Subdivide scene with an octree
All geometry in an octree node is contained by a cube
Before rendering the contents of a node, “render” the
faces of its cube (i.e., query the Z-pyramid)
If cube faces are occluded, ignore the entire node
74
Hierarchical Z-Buffer

HZB can exploit temporal coherence



Most polygons affecting the Z-buffer last
will affect Z-buffer this frame
HZB also operates at max efficiency
Z-pyramid already built
frame
when
So start each frame by rendering octree nodes
visible last frame
75
Hierarchical Z-Buffer: Discussion


HZB needs hardware support to be really competitive
Hardware vendors haven’t entirely bought in:



But we’re getting there…




Z-pyramid (and hierarchies in general) unfriendly to hardware
Unpredictable Z-query times generate bubbles in rendering pipe
ATI HyperZ
Similar technology in NVIDIA
Both “under the hood”, not exposed to programmer
At the user level, hardware now supports occlusion queries
76
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
77
Modern Occlusion Culling

Support from hardware would be nice


Want an “occlusion test”: would this polygon be visible if
I rendered it?
How could you use such a test?



Yay! GL_HP_OCCLUSION_TEST extension


Test portal polygons before rendering adjacent cell
Test object bounding boxes before rendering object
But only returns non-visibility
Problems:


CPU/GPU synchronization == bad
Might want to know “how visible” is the polygon
78
Modern Occlusion Culling

GL_NV_OCCLUSION_QUERY to the rescue

Non-blocking query






“Is this occlusion query done yet?”
Multiple queries in flight
Returns number of fragments visible
Note: can actually render object or not
Supports object-space coherence,
coherence
Still lots of issues for efficient culling
temporal
79
111 uses for Occlusion Queries


Occlusion culling (duh)
Others?







Approximate culling
LOD size estimation
Lens flare effects
Transparency
Collision detection (!)
Convergence testing
Side note: GL_ARB_OCCLUSION_QUERY is latest
incarnation

Fixes a possible race condition in NV_occlusion_query
logic
80
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
81
Fog filters – what’s wrong with it?
http://www.cs.mtu.edu/~shene/DigiCam/User-Guide/filter/filter-fog.html
82
Haze and the Z-buffer
83
Fog and the Z-buffer
http://www.cnykayakclub.com/pictures2003.htm
84
Water and the Z-buffer
85
Fog filters – what’s wrong with it?
http://www.cs.mtu.edu/~shene/DigiCam/User-Guide/filter/filter-fog.html
86