Game Development Reference
In-Depth Information
Our method
Accum. buffer
Depth peeling
Homunculus ( K = 17)
(3 / 6 / 36)45
(6 / 22 / 36)64
4 , 809
Dragons ( K = 22)
(14 / 6 / 53)73
(114 / 28 / 52)194
4 , 163
Tab l e 2 . 1 . Performance comparisons, in ms, of our method using the A-buffer, with
depth peeling (as in [Schedl and Wimmer 12]), and with the accumulation-buffer method
for the scenes Homunculus (74k faces) and Dragons
(6M faces). Renderings have the
resolution 1024
1024 and M = 8. Note that the rendering times in brackets represent
the costs for (scene rendering/matting/blurring).
use 32-bit float textures (
L RGBA32F for color and depth and
L R32F for the
We compare our method to the accumulation buffer method and to an im-
plementation of our method with depth peeling (as implemented in [Schedl and
Wimmer 12]). The methods are applied to the scenes Homunculus (74,000 trian-
gles) and Dragons (6,000,000 triangles), shown in Figure 2.7 , next to a pinhole
rendering of the scenes. In Table 2.1 the rendering times are shown. The re-
trieval of M = 8 hidden fragments is very costly with the previously used depth
peeling, especially in complex scenes such as Dragons . Although simpler scenes
(e.g., Homunculus ) can be rendered several times with less impact, the latter
might be less practical for applications with a constrained rendering budget. Our
optimized A-buffer method also does more ecient layer matting, because with
the counter texture we don't have to process empty input buffer fragments. The
costs for blurring one depth layer are quite similar in both scenes.
The reference accumulation-buffer technique is implemented in OpenGL and
uses a 32-bit-per-channel float texture for accumulation. The lens samples are
positioned with a Gaussian distribution.
In [Schedl and Wimmer 12] we also compare our method to a ray-traversal
technique, and we show that the rendering costs for [Lee et al. 10] are higher ( >
) at comparable settings. Note that for the scenes in [Schedl and Wimmer 12],
only M = 4 input buffers are used, which is often sucient.
We have shown an algorithm to render high-quality DoF effects, in particular
including the partial occlusion effect. We use an A-buffer to avoid having to
rerender the scene, which would be a costly operation. With recursive Gaussian
filters, high-blur radii can be simulated eciently, while previous methods pro-
duce sampling artifacts when too few rays are used. However, since blurring is
the most costly operation, if higher frame rates are needed and visual quality can
be sacrificed, faster methods (e.g., box and pyramid filters) can be used. With
the usage of faster blurring methods, our method could be used in real-time ap-
Search Nedrilad ::

Custom Search