VTK/Depth Peeling

Definition

Depth peeling is a multipass technique to render translucent polygonal geometry without sorting polygons. It was added to VTK on November 27th 2006.

The algorithm peels the translucent geometry from front to back until there is no more geometry to render. The iteration loop stops either if it reaches the maximum number of iterations set by the user or if the number of pixels modified by the last peel is less than some ratio of the area of the window (this ratio is set by the user, if the ratio is set to 0.0, it means the user wants the exact result. A ratio of 0.2 will render faster than a ratio 0.1).

Pros

• Translucent geometry does not have to be sorted.

Cons

• The algorithm is inherently slow due to rendering the geometry multiple times.
• The implementation based on OpenGL API requires a couple of extensions, restricting its usage to recent GPU.

Usage

Required OpenGL extensions

• GL_ARB_depth_texture
• GL_ARB_shadow
• GL_EXT_shadow_funcs
• GL_ARB_vertex_shader
• GL_ARB_fragment_shader
• GL_ARB_shader_objects
• GL_ARB_occlusion_query
• GL_ARB_multitexture
• GL_ARB_texture_rectangle
• GL_SGIS_texture_edge_clamp or GL_EXT_texture_edge_clamp or OpenGL 1.2

OpenGL context requirement

• at least 8 alpha bits (by default vtkRenderWindow does not ask for alpha bit planes, make sure to call vtkRenderWindow::SetAlphaBitPlanes(1))

VTK calls

The interface is in vtkRenderer.

• 1. Use a render window with alpha bits (as initial value is 0 (false) ):

renderWindow->SetAlphaBitPlanes(1);

• 2. Choose to use depth peeling (if supported) (initial value is 0 (false) )

renderer->SetUseDepthPeeling(1);

• 3. Set depth peeling parameters.
  • Set the maximum number of rendering passes (initial value is 4)

renderer->SetMaximumNumberOfPeels(100);

• • Set the occlusion ratio (initial value is 0.0, exact image)

renderer->SetOcclusionRatio(0.1);

• 4. Render
• 5. Check if depth peeling was actually used:

int depthPeelingWasUsed=renderer->GetLastRenderingUsedDepthPeeling();

Implementation notes

Modified files

in VTK/Rendering:

vtkOpenGLActor.cxx
vtkOpenGLRenderer.cxx
vtkOpenGLRenderer.h
vtkRenderer.cxx
vtkRenderer.h
Testing/Cxx/CMakeLists.txt
Testing/Cxx/TestOpacity.cxx

VTK changes

Before the changes, Render of vtkRenderer used to iterate over all props and call RenderTranslucentGeometry on each of them. Now, it calls a virtual method DeviceRenderTranslucentGeometry(). By default this method call UpdateTranslucentGeometry(). And UpdateTranslucentGeometry() do exactly what Render() used to do.

In vtkOpenGLRenderer, DeviceRenderTranslucentGeometry() is overridden to use depth peeling flags and implement depth peeling technique. For each peel it will call UpdateTranslucentGeometry().

It uses a lot of GPU RAM because each rgba buffer of each peel have to be saved. The last step is to do compositing with each layer, back-to-front order ( if it was possible to do front-to-back compositing, we could perform compositing on the fly and we would not need to store each peel.) Compositing is done by rendering each layer as a texture on a quad.

As we first render opaque geometry, we use it to cull transparent geometry, limiting the number of required layers.

References

• [1] Interactive Order-Independent Transparency Cass Everitt NVIDIA (technical paper 05/15/2001 developer.nvidia.com/attach/6545 and slides developer.nvidia.com/attach/6402)
• [2] GPU-Accelerated High-Quality Hidden Surface Removal Daniel Wexler, Larry Gritz, Eric Enderton, Jonathan Rice, Graphics Hardware 2005, 30-31 July 2005, Los Angeles CA, ACM
• [3] GPU-based Tiled Ray Casting using Depth Peeling Fábio F. Bernardon Christian A. Pagot João L. Comba Cládio T. Silva www.inf.ufrgs.br/~comba/papers/2006/gpu_volume_ray_casting.pdf
• [4] GPU-based Transparent Polygonal Geometry in Volume Rendering home.dataparty.no/kristian/school/ntnu/masterthesis/embedded-geometry-paper.pdf (extension 297 GL_EXT_depth_bounds_test www.opengl.org/registry/specs/EXT/depth_bounds_test.txt)
• [5] Occlusion slides from Nvidia at Game Developer Conference 2002: developer.nvidia.com/attach/6715
• [6] Thomas Porter and Tom Duff, "Compositing Digital Images", Computer Graphics, Volume 18, Number 3, July 1984 (ACM Siggraph). Pretty good reference about compositing/alpha arithmetic.
• [7] Multi-Layer Depth Peeling via Fragment Sort research.microsoft.com/research/pubs/view.aspx?tr_id=1125
• [8] Release Notes for NVIDIA OpenGL Shading Language Support download.nvidia.com/developer/GLSL/GLSL%20Release%20Notes%20for%20Release%2060.pdf (from developer.nvidia.com/object/nvemulate.html )

Glossary

OIT: Order Independent Transparency