Visibility culling
Download
1 / 149

Visibility Culling - PowerPoint PPT Presentation


  • 70 Views
  • Uploaded on
  • Presentation posted in: General

Visibility Culling. Roger A. Crawfis CIS 781 The Ohio State University. Interactive Frame Rates Are Difficult To Achieve. The Problem. Two keys for an interactive system Interactive rendering speed: too many polygons – difficult!!

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Visibility Culling ' - xaria


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Visibility culling

Visibility Culling

Roger A. Crawfis

CIS 781

The Ohio State University


Interactive frame rates are difficult to achieve
Interactive Frame Rates Are Difficult To Achieve


The problem
The Problem

  • Two keys for an interactive system

    • Interactive rendering speed: too many polygons – difficult!!

    • Uniform frame rate: varied scene complexity – difficult!!


Possible solutions
Possible Solutions

  • Visibility Culling – back face culling, frustum culling, occlusion culling (might not be sufficient)

  • Levels of Detail (LOD) – hierarchical structures and choose one to satisfy the frame rate requirement


Lod selections
LOD Selections

How to pick the

Optimal ones??!!


Occlusion culling
Occlusion Culling

  • Hidden Surface Removal methods are not fast enough for massive models on current hardware

  • Occlusion Culling avoids rendering primitives that are occluded by another part of the scene

  • Occlusion Culling techniques are ideally output sensitive – runtime is proportional to the size of exact visibility set


Related work
Related Work

  • Hierarchical Z-Buffer

    • Image space occlusion culling method [Greene’93]

    • Build a layered Z-pyramid with a different resolution of the Z-buffer at each level

    • Allows quick accept/reject

  • Hierarchical LODs

    • Simplification Culling : Approximate entire branch of the scene graph by an HLOD

    • Can we use HLODs as occluders/occludees?


Visibility in games
Visibility in Games

  • What do we need it for?

    • Increase of rendering speed by removing unseen scene data from the rendering pipeline as early as possible

    • Reduction of data transfers to the graphics hardware

    • Current games would not be possible without visibility calculations


Visibility methods
Visibility methods

  • 2 very different categories:

    • Visibility from a region (Portals, PVS)

      • (Quake, Unreal, Severance and co.)

    • Visibility from a point (Z-Buffer, BFC,...)

      • Racing games, outdoor scenes, sports games etc.


Point visibility occlusion
Point-Visibility Occlusion

  • Traditionally used:

    • Back-Face culling

    • Z-Buffering

    • View frustum culling

      • Octree

      • Quadtree


A psx example
A PSX Example

  • Iron Soldier 3 on PSX:

    • View frustum culling based on a quad-tree

    • Back-face culling

    • Painters algorithm

Only culling to the leftand right sides of theviewing frustum.


New occlusion methods
New Occlusion Methods

  • Image-space occlusion culling

    • Hierarchical Z-Buffering

    • Hierarchical Occlusion Maps

  • Object-space occlusion culling

    • Hierarchical View Frustum culling

    • Hierarchical Back-Face culling


Visibility culling1
Visibility Culling

  • We will look at these:

    • Hierarchical Back-face culling

    • View-frustum culling

    • Occlusion culling

    • Detail culling


Hierarchical back face culling
Hierarchical Back-Face Culling

  • Partitions each model into clusters

  • Primitives in one cluster are:

    • Facing into similar directions

    • Lie close to each other

  • If the cluster fails the visibility test, all primitives in this cluster are culled



Normal maps
Normal Maps

  • Create a data structure that places each polygon in the space according to its normal direction.

  • Partition this space and then simply look at those partitions that might have visible polygons.

phi

theta


View frustum culling

View-Frustum Culling

  • Remove objects that are outside the viewing frustum

Mostly done in “Application Stage”


View frustum culling1
View-Frustum Culling

  • Culling against bounding volumes to save time

  • Bounding volumes – AABB, OBB, Spheres, etc. – easy to compute, as tight as possible

Sphere

OBB

AABB


View frustum culling2
View-Frustum Culling

  • Often done hierarchically to save time

In-order, top-down

traversal and test


View frustum culling3
View-Frustum Culling

  • Two popular hierarchical data structures – BSP Tree and Octree

Axis-Aligned BSP

Polygon-Aligned BSP

Intersecting?


View frustum culling4
View-Frustum Culling

  • Octree

  • A parent has 8 childrens

  • Subdivide the space until the

  • number of primitives within

  • each leaf node is less than a

  • threshold

  • In-order, top-down traversal


Hierarchical z buffer
Hierarchical Z-Buffer

  • Z-Buffer is arranged in an image pyramid.

  • Scene is partitioned in an octree.

  • Octree nodes are tested against the Z-Pyramid where pixels have the same size.

  • Visible nodes serve as input for the next frame.

  • Relies on HW visibility query.



Hierarchical occlusion maps
Hierarchical occlusion maps

  • Potential occluders are pre-selected

  • These occluders are rendered to the occlusion map. The hierarchy can be built with MIP-Mapping HW

  • Depth test after occlusion test

  • Separate depth estimation buffer


Hierarchical view frustum culling
Hierarchical View Frustum Culling

  • Speeds up VFC by testing only 2 box corners of a bounding box first.

  • Plane coherency during frame advancing

  • Test against VF-octants.

  • BB-Child masking


Detail culling
Detail Culling

  • A technique that sacrifices quality for speed

  • Base on the size of projected BV – if it is too small, discard it.

  • Also often done hierarchically.

Always helps to create a hierarchical

structure, or scene graph.


Occlusion culling1
Occlusion Culling

  • Discard objects that are occluded

  • Z-buffer is not the smartest algorithm in the world (particularly for high depth-

    complexity scenes)

  • We want to avoid the processing of invisible objects


Occlusion culling2
Occlusion Culling

  • G: input graphics data

  • Or: occlusion representation

  • The problem:

  • algorithms for isOccluded()

  • Fast update Or

OcclusionCulling (G)

Or = empty

For each object g in G

if (isOccluded(g, Or))

skip g

else

render (g)

update (Or)

end

End


Hierarchical visibility
Hierarchical Visibility

  • Object-space octree

    • Primitives in a octree node are hidden if the octree node (cube) is hidden

    • A octree cube is hidden if its 6 faces are hidden polygons

    • Hierarchical visibility test:


Hierarchical visibility obj sp
Hierarchical Visibility (obj-sp.)

From the root of octree:

  • View-frustum culling

  • Scan conversion each of the 6 faces and perform z-buffering

  • If all 6 faces are hidden, discard the entire node and sub-branches

  • Otherwise, render the primitives here and traverse the front-to-back children recursively

A conservative algorithm – why?


Hierarchical visibility obj sp1
Hierarchical Visibility (obj-sp.)

  • Scan conversion the octree faces can be expensive – cover a large number of pixels (overhead)

  • How can we reduce the overhead?

  • Goal: quickly conclude that a large polygon is hidden

  • Method: use hierarchical z-buffer !


Hierarchical z buffer1
Hierarchical Z-buffer

An image-space approach

  • Create a Z-pyramid

1 value

¼ resolution

½ resolution

Original Z-buffer


Hierarchical z buffer 2

0 3 1 2

  • 6

9

3 9 1 2

9 2

9 1 2 2

Hierarchical Z-buffer (2)

Keep the maximum value


Hierarchical z buffer2
Hierarchical Z-buffer

update

Visibility (OctreeNode N)

if (isOccluded (N, Zp) then return;

for each primitive p in N

render and update Zp

end

for each child node C of N in front-to-back order

Visibility ( C )

end


Some practical issues
Some Practical Issues

  • A fast software algorithm

  • Lack of hardware support

    • Scan conversion

    • Efficient query of if a polygon is visible (without render it)

    • Z feedback


Combining with hardware
Combining with hardware

  • Utilizing frame-to-frame coherence

    • First frame – regular HZ algorithm (software)

      • Remember the visible octree nodes

    • Second frame (view changes slightly)

      • Render the previous visible nodes using OpenGL

      • Read back the Z-buffer and construct Z-pyramid

      • Perform regular HZ (software)

    • What about the third frame?

    • Utilizing hardware to perform rendering and Z-buffering – considerably faster


Hierarchical occlusion map
Hierarchical Occlusion Map

Zhang et al

SIGGRAPH 98


Basic ideas
Basic Ideas

  • Choose a set of graphics objects from the scene as Occluders

  • Use the occluders to define an Occlusion Map (hierarchically)

  • Compare the rest of scene against the occlusion map


Example
Example

Blue: Occluders

Red: Occludees


Algorithm pipeline

Occluder Viewing Frustum Occluder Rendering

Database Culling Selection

Build Occlusion

Map Hierarchy

Real Viewing Frustum Occlusion Test

Scene Culling

Algorithm Pipeline


2 step occlusion test
2-Step Occlusion Test Rendering

  • Overlap Test

  • Overlap Test

Overlap + Depth = Occlusion


Why decomposition
Why decomposition? Rendering

  • The occlusion test is done approximately (conservatively)

  • We can afford to be more conservative in depth test than overlap test



Overlap test occlusion map
Overlap Test – Occlusion Map Rendering

  • Representation of projection for overlap test: occlusion map

  • A gray scale image – each pixel represents one block of screen region

  • Generate by rendering occluders


Occlusion map om
Occlusion Map (OM) Rendering

  • Each pixel of the occlusion map has an opacity, which represents the ratio of the sum of the opaque areas in the block to the total area.

  • If fully covered, p= 1, if anti-alised pixel, p <1)

  • Occlusion map: the alpha channel of an image


Overlap test using om
Overlap Test using OM Rendering

For each potential occludee, we can scan-convert

it and compare against the opacity of the pixels it

overlaps Expensive!!

  • Conservative Approximation: use the screen-space

  • bounding box of the occludee (a superset of the actual

  • covered pixels)

  • If all the pixels inside the bounding box are opaque,

  • the object is occluded.


Hierarchical occlusion map1
Hierarchical Occlusion Map Rendering

Like hierarchical Z-buffer, we can create a hierachy to

speed up the comparison (for large objects)

The low resolution pixel is

an average of the high

resolution pixels


Overlap test using hom
Overlap Test using HOM Rendering

Basic Algorithm

  • Start from the lowest resolution

  • If the pixel cover the bounding

  • rectangle has a value 1,

  • the object is occluded

  • Otherwise traverse down the

  • hierarchy:

    • If all children =1: occluded

    • If all children =0; not occluded

    • Otherwise, traverse down further


Approximate overlap test
Approximate Overlap Test Rendering

  • Instead of concluding an object is occluded only when the bounding box is within pixels with opacity 1, we can use an threshold between [0,1]

  • Early termination in the high level of the hierarchy

  • What does it mean when a block has high opacity but not one?

This is the unique feature of HOM !!


Depth test
Depth Test Rendering

Approximate Z (depth) test:

  • A single Z Plane

A single Z plane

to separate the

occluders from

occludees.


Depth test1
Depth Test Rendering

  • Break the screen into small regions

  • Build at each frame

  • Instead of using Z-buffer, use

  • the occluder’s bounding

  • volume’s farthest Z

  • Compare each potential

  • occludee’s nearest Z (con-

  • servative test)


Occluder selection
Occluder Selection Rendering

Ideal occluder: the visible objects – it’s a joke

View-dependent occluder: too expensive

Solution: Estimate and build an occluder database

Discard objects that do not server as

good occluders


Occluder selection1
Occluder Selection Rendering

  • Size: not too small

  • Redundant: detail polygons (clock on the wall)

  • Complexity: Complex polygons are not preferred (why?)

  • Done at run time – sort the occluders in depth, add them in order until reach the polygon count.


Visibility culling
OPS Rendering

  • View-independent Occluders

X

Z


Visibility culling
OPS Rendering

  • View-dependent Occluders


Occludders
Occludders Rendering

  • In practice, use traditional, static LOD’s

    • More restrictive view-independent OPS

    • Well-studied and available

    • Low run-time overhead

    • Shared with final rendering, no extra memory

    • Area-preserving [Erikson 98]


Occluder selection2
Occluder selection Rendering

  • At run time

    • Distance-based selection with a polygon budget

    • Temporal coherence

  • Visibility sampling

    • Pre-compute visible objects on a 3-D grid

    • Facilitates run-time selection


Implementation
Implementation Rendering

  • A two-pass framework

Occluder

Rendering

LOD

Selection

View

Scene

Frustum

Build Occlusion

Database

Culling

Representation

Occlusion

LOD

Culling


Results
Results Rendering

  • The city model


Results1
Results Rendering

  • The city model

    • 312,524 polygons

    • Single CPU

    • 5,000 occluder polygons

    • Depth estimation buffer

    • Opacity thresholds 1.0

    • Lighting; display lists; no triangle strips


Results2
Results Rendering


Results3
Results Rendering


Results4
Results Rendering

  • Auxiliary Machine Room (AMR)


Results5
Results Rendering

  • AMR

    • 632,252 polygons

    • 3 CPUs

    • 25,000 occluder polygons

    • No-background z-buffer

    • Approximate culling (0.85 for level 64x64)

    • LOD

    • Lighting; display lists; no triangle strips


Results6
Results Rendering


Results7
Results Rendering


Results8
Results Rendering


Results9
Results Rendering

  • The power plant model


Results10
Results Rendering

  • The power plant model

    • 15 million triangles

    • 3 CPUs

    • Visibility pre-processing on a 20x20 grid (~15min)

    • No-background z-buffer

    • 18,000 occluder polygons

    • opacity thresholds from 0.85 and up

    • LOD


Results11
Results Rendering


Conclusion
Conclusion Rendering

  • Goals achieved

    • Generality

      • Any model, any occluder

      • Occluder fusion

    • Speed-up

      • Accelerate interactive graphics

    • Ease of implementation

      • Configurability

      • Robustness


Hp hardware occlusion
HP hardware occlusion Rendering

  • Extend OpenGL – add an OCCLUSION_MODE

  • The bounding box of an object is scan converted

  • A flag is set if any pixel of the BB faces is visible

  • Only need to read back one flag, instead of the entire frame buffer

  • Tradeoff – valuable rendering time is used to render useless BB faces (need to be used wisely)

  • Reportedly 25%-100% speedup were observed


The real world
The Real World Rendering

  • Scientific approaches often too complicated

  • Science often uses models with hundreds of thousands of vertices, games don’t. (LOD)

  • Game developers “pick” ideas from different algorithms

  • Research has impact on hardware design!


Gaming industry
Gaming Industry Rendering

  • Parts of the Hierarchical Z-Buffer (HZB) are used sometimes

  • Runtime-LOD is used as input for a simple HZB

  • View Frustum Culling (VFC) is almost always used.

  • Hierarchical Occlusion Maps introduce too much overhead for games, and the z-buffer is there anyway


The real world 3
The Real World (3) Rendering

  • PSX-One doesn’t even have a z-buffer

  • ATI’s Radeon has parts of a HZB (Called Hyper-Z)

  • GForce2 only has a z-buffer

  • GForce3 similar to Radeon, but supports HZB visibility query

  • Dreamcasts Power-VR2 works pretty different (Infinite planes)


Conclusions
Conclusions Rendering

  • Visibility algorithms are used in many different applications

    • Occlusion culling

    • Shadow calculations

    • Radiosity

    • Volumetric lights

  • All these fields benefit from advances in visibility techniques


Recap
Recap Rendering

  • Visibility culling: don’t render what can’t be seen

    • Off-screen: view-frustum culling

    • Z-buffered away: occlusion culling

  • Cells and portals

    • Works well for architectural models

    • Teller: accurate, complex, a bit slow

    • pfPortals: fast, cheap, easy


Hierarchical z buffer3
Hierarchical Z-Buffer Rendering

  • Q: What do you think this is?

  • Replace Z-buffer with a Z-pyramid

    • Lowest level: full-resolution Z-buffer

    • Higher levels: each pixel represents what?

      • A: Maximum distance of geometry visible to the four pixels “underneath” it

  • Q: How is this going to help?


Hierarchical z buffer4
Hierarchical Z-Buffer Rendering

  • 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

  • Amounts to hierarchical rasterization of the polygon, with early termination

    • Must update higher levels as we go


Hierarchical z buffer5
Hierarchical Z-Buffer Rendering

  • Z-pyramid exploits image-space coherence: polygon occluded in one pixel is probably occluded nearby

  • HZB also exploits object-space coherence: polygons near an occluded polygon are probably occluded

  • Q: How might you use object-space coherence?


Hierarchical z buffer6
Hierarchical Z-Buffer Rendering

  • 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

  • If cube faces are occluded, ignore the entire node

  • Query Z-pyramid to “render” cubes


Hierarchical z buffer7
Hierarchical Z-Buffer Rendering

  • Exploit temporal coherence (What?)

  • HZB operates at max efficiency when Z-pyramid is already built

  • Idea: most polygons affecting Z-buffer (“nearest polygons”) are the same from frame to frame

  • So start by rendering the polygons (octree nodes) visible last frame


Hierarchical occlusion maps stolen by dave luebke from the ph d defense presentation of

Hierarchical Occlusion Maps Rendering stolen by Dave Luebke from thePh.D. Defense presentation of:

Hansong Zhang

Department of Computer Science

UNC-Chapel Hill


Visibility culling2
Visibility Culling Rendering

  • Discard objects not visible to the viewer

View-frustum culling

Back-face culling

View

View

Frustum

Point

Occlusion culling


Hierarchical occlusion maps overview
Hierarchical Occlusion Maps: Overview Rendering

Blue parts: occluders Red parts: occludees


Effective algorithms
Effective Rendering Algorithms

  • Generality

    • Arbitrary models

  • Speed-up

    • Significant, fast culling for interactive graphics

  • Portability

    • Few hardware assumptions

    • Robustness


  • Thesis statement
    Thesis Statement Rendering

    • By properly decomposing the occlusion-culling problem and efficiently representing occlusion, we can obtain effective algorithms and systems for occlusion culling.


    Observations
    Observations Rendering

    • Want to handle cumulative occlusion

    A

    B

    View

    Point


    Observations1
    Observations Rendering

    • Want an occlusion representation (OR)

      • Fast to compute

      • Fast to use

    A

    B

    View

    Point


    Observations2
    Observations Rendering

    • Progressive occlusion culling

      Initialize OR to null

      for each object

      Occlusion test against OR

      if culled

      Discard object

      else

      Render object

      Update OR


    Observations3

    #passes = #updates Rendering

    Observations

    • Multi-pass occlusion culling

      Initialize OR to null; initialize PO to empty

      for each object

      Occlusion test against OR

      If culled

      Discard object

      else

      Render object

      Add object to PO

      if PO is large enough

      Update OR with objects in PO

    The set of potential occluders


    Observations4
    Observations Rendering

    • Special case: one-pass occlusion culling

      • Select occluders until PO is large enough

      • Update (build) occlusion representation

      • Occlusion culling & final rendering


    Problem decomposition

    View Rendering

    X

    Point

    Y

    Z

    Problem Decomposition

    • Occlusion = depth + overlap


    Problem decomposition1
    Problem Decomposition Rendering

    • Verifying occlusion

      • Overlap tests

        • Based on representations for projection

      • Depth tests

        • Based on representations for depth


    Visibility culling

    Occlusion Maps Rendering

    Rendered Image

    Occlusion Map


    Occlusion maps
    Occlusion Maps Rendering

    • An occlusion map

      • Corresponds to a screen subdivision

      • Records average opacity for each partition

    • Can be generated by rendering occluders

      • Record pixel opacities (pixel coverage)

    • Merge projections of occluders

    • Represent occlusion in image-space


    Occlusion map pyramid
    Occlusion Map Pyramid Rendering

    64 x 64

    32 x 32

    16 x 16



    Occlusion map pyramid2
    Occlusion Map Pyramid Rendering

    • Analyzing cumulative projection

      • A hierarchy of occlusion maps (HOM)

      • Made by recursive averaging (low-pass filtering)

      • Record average opacities for blocks of pixels

      • Represent occlusion at multiple resolutions

      • Construction accelerated by hardware


    Overlap tests
    Overlap Tests Rendering

    • Problem: is the projection of tested object inside the cumulative projection of the occluders?

    • Cumulative projection of occluders: the pyramid

    • Projection of the tested object

      • Conservative overestimation

        • Bounding boxes (BB)

        • Bounding rectangles (BR) of BB’s


    Overlap tests1
    Overlap Tests Rendering

    • The basic algorithm

    • Given: HOM pyramid; the object to be tested

    • Compute BR and the initial level in the pyramid

    • for each pixel touched by the BR

    • if pixel is fully opaque

    • continue

    • else

    • if level = 0

    • return FALSE

    • else

    • descend...


    Overlap tests2
    Overlap Tests Rendering

    • Evaluating opacity: early termination

      • Conservative rejection

      • Aggressive approximate culling

      • Predictive rejection


    Conservative rejection
    Conservative Rejection Rendering

    • A low-opacity pixel does not correspond to many high-opacity pixels at finer levels

    • The transparency threshold

    1

    1

    1

    1

    1

    0.8

    1

    1

    0.9

    0.9

    0.1

    0

    0.2

    0.3

    0

    0


    Aggressive approximate culling
    Aggressive Approximate Culling Rendering

    • Ignoring barely-visible objects

      • Small holes in or among objects

      • To ignore the small holes

        • LPF suppresses noise — holes “dissolve”

        • Thresholding: regard “very high” opacity as fully opaque

      • The opacity threshold: the opacity above which a pixel is considered to be fully opaque


    Aggressive approximate culling1

    1 Rendering

    0

    2

    3

    4

    Aggressive Approximate Culling


    Aggressive approximate culling2
    Aggressive Approximate culling Rendering

    • Further descent not necessary when fully opaque

      • Tests terminated before holes are reached

    • Need different opacity thresholds for each level


    Predictive rejection
    Predictive Rejection Rendering

    • Terminate the test knowing it must fail later...


    Summary levels of visibility
    Summary: Levels of Visibility Rendering

    • The continuum between being visible and non-visible

    Occlusion Maps

    Potential Occludees

    Almost visible

    Almost non-visible

    Almost transparent

    (low opacity)

    Almost opaque

    (high opacity)


    Resolving depth

    B does not occlude Rendering any part of A

    Resolving Depth

    • What’s left of the occlusion test?

    “A occludes B” = “A’s projection contains B’s” + ?

    B

    A

    Another interpretation...


    Resolving depth1
    Resolving Depth Rendering

    • Depth representations

      • Define a boundary beyond which an object overlapping occluders is definitely occluded

      • Conservative estimates:

        • A single plane

        • Depth estimation buffer

      • No-background z-buffer


    A single plane
    A single plane Rendering

    • … at the farthest vertex of the occluders

    Image

    plane

    The plane

    Occluders

    The point with nearest depth

    Viewing direction

    This object passes the depth test

    A


    Depth estimation buffer
    Depth Estimation Buffer Rendering

    • Like a low-res depth buffer

      • Uniform subdivision of the screen

      • A plane for each partition

      • Defines the far boundary

      • Updates (i.e. computing depth representation)

        • Occluder bounding rectangle at farthest depth

      • Depth tests

        • Occudee bounding rectangle at nearest depth


    Depth estimation buffer1
    Depth Estimation Buffer Rendering

    Transformed view-frustum

    D. E. B.

    Image

    plane

    Bounding rectangle at farthest depth

    Bounding rectangle at nearest depth

    Viewing direction

    B

    Occluders

    A


    Depth estimation buffer2
    Depth Estimation Buffer Rendering

    • Trade-off

      • Advantages

        • Removes need for strict depth sorting

        • Speed

        • Portability

      • Disadvantages

        • Conservative far boundary

        • Requires good bounding volumes


    No background z buffer
    No-Background Z-Buffer Rendering

    • The z-buffer from occluder rendering...

      • is by itself an full occlusion representation

      • has to be modified to support our depth tests

    • “Removing” background depth values

      • Replace them the “foreground” depth values

    • Captures the near boundary


    No background z buffer1
    No-Background Z-Buffer Rendering

    Transformed view-frustum

    Image

    plane

    D. E. B

    Occluders

    N. B. Z

    Viewing direction

    A

    Objects passing the depth tests


    No background z buffer2
    No-Background Z-Buffer Rendering

    • Trade-off

      • Advantages

        • Captures the near boundary

        • Less sensitive to bounding boxes

      • Disadvantages

        • Assumes quickly accessible z-buffer

        • Resolution same as occlusion maps (however…)


    Occluder selection3
    Occluder Selection Rendering

    • Occlusion-preserving simplification (OPS)

    • Run-time selection

    • Visibility pre-processing


    Visibility culling
    OPS Rendering

    • View-independent OPS

    X

    Z


    Visibility culling
    OPS Rendering

    • View-dependent OPS


    Visibility culling
    OPS Rendering

    • In practice, use traditional, static LOD’s

      • More restrictive view-independent OPS

      • Well-studied and available

      • Low run-time overhead

      • Shared with final rendering, no extra memory

      • Area-preserving [Erikson 98]

    • Conservative OPS (COPS)...


    Occluder selection4
    Occluder selection Rendering

    • At run time

      • Distance-based selection with a polygon budget

      • Temporal coherence

    • Visibility sampling

      • Pre-compute visible objects on a 3-D grid

      • Facilitates run-time selection


    Implementation1
    Implementation Rendering

    • A two-pass framework

    Occluder

    Rendering

    LOD

    Selection

    View

    Scene

    Frustum

    Build Occlusion

    Database

    Culling

    Representation

    Occlusion

    LOD

    Culling


    Implementation2

    FinalDraw Rendering N+1

    OccSelN

    CullN

    CullN+2

    Implementation

    • Pipelining

    OccSelN+1

    OccSelN+2

    OccSelN+3

    OccDrawN

    FinalDrawN

    OccDrawN+1

    FinalDrawN+1

    OccDrawN+2

    CullN+1


    Implementation3
    Implementation Rendering

    • Uses bounding volume hierarchy

    • Active layers of the pyramid: 4x4 - 64x64

    • Resolutions

      • Occluder rendering - 256x256

      • D. E. B. - 64x64

    • Test platforms

      • SGI Onyx II, 4 195Mhz R10000, InfiniteReality

      • SGI Onyx I, 4 250MHz R4400, InfiniteReality


    Results12
    Results Rendering

    • The city model


    Results13
    Results Rendering

    • The city model

      • 312,524 polygons

      • Single CPU

      • 5,000 occluder polygons

      • Depth estimation buffer

      • Opacity thresholds 1.0

      • Lighting; display lists; no triangle strips


    Results14
    Results Rendering


    Results15
    Results Rendering


    Results16
    Results Rendering

    • Auxiliary Machine Room (AMR)


    Results17
    Results Rendering

    • AMR

      • 632,252 polygons

      • 3 CPUs

      • 25,000 occluder polygons

      • No-background z-buffer

      • Approximate culling (0.85 for level 64x64)

      • LOD

      • Lighting; display lists; no triangle strips


    Results18
    Results Rendering


    Results19
    Results Rendering


    Results20
    Results Rendering


    Results21
    Results Rendering

    • The power plant model


    Results22
    Results Rendering

    • The power plant model

      • 15 million triangles

      • 3 CPUs

      • Visibility pre-processing on a 20x20 grid (~15min)

      • No-background z-buffer

      • 18,000 occluder polygons

      • opacity thresholds from 0.85 and up

      • LOD


    Results23
    Results Rendering


    Conclusion1
    Conclusion Rendering

    • Goals achieved

      • Generality

        • Any model, any occluder

        • Occluder fusion

      • Speed-up

        • Accelerate interactive graphics

      • Ease of implementation

        • Configurability

        • Robustness


    Conclusion2
    Conclusion Rendering

    • Main contributions:

      • Problem decomposition

        • Overlap tests and depth tests

      • Occlusion representations

        • Occlusion maps

        • Depth Estimation Buffer

        • No-Background Z-Buffer


    Conclusion3
    Conclusion Rendering

    • Main contributions

      • Hierarchical occlusion maps

        • Analysis of occlusion at multiple resolutions

        • High-level opacity estimation

        • Aggressive approximate culling

        • Levels of visibility

      • The first occlusion culling algorithm for general models and interactive 3-D graphics


    Future work
    Future Work Rendering

    • Other implementations...

      • PC’s and games

        • How much can be done in software?

      • Integration into hardware

        • More progressive updates to occlusion representation

        • Less conservative culling

      • Wide-spread use of occlusion culling


    Early splat elimination
    Early Splat Elimination Rendering

    • Need: splat visibility test

      • a voxel is only visible if the volume material in front is not opaque

    screen

    occluded voxel: does not pass visibility test

    wall of occluding voxels

    occlusion map = opacity image


    Visibility test naive
    Visibility Test - Naive Rendering

    • Check opacity of every pixel within footprint

      • number of pixels to be checked is large

    voxel footprint

    opaque area

    voxel kernel

    opacity buffer


    Visibility test efficient
    Visibility Test - Efficient Rendering

    IEEE Trans. Vis. and Comp. Graph. ‘99

    • Compute occlusion map after each sheet-buffer compositing

    project

    do not project

    opacity  threshold

    opacity < threshold

    occlusion map

    opacity = 0



    ad
  • Login