Multi-fragment effects on the GPU using the k-buffer

Louis Bavoil, Steven P. Callahan, Aaron Lefohn, João L D Comba, Cláudio T. Silva

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Many interactive rendering algorithms require operations on multiple fragments (i.e., ray intersections) at the same pixel location: however, current Graphics Processing Units (GPUs) capture only a single fragment per pixel. Example effects include transparency, translucency, constructive solid geometry, depth-of-field, direct volume rendering, and isosurface visualization. With current GPUs, programmers implement these effects using multiple passes over the scene geometry, often substantially limiting performance. This paper introduces a generalization of the Z-buffer, called the k-buffer, that makes it possible to efficiently implement such algorithms with only a single geometry pass, yet requires only a small, fixed amount of additional memory. The k-buffer uses framebuffer memory as a read-modify-write (RMW) pool of k entries whose use is programmatically defined by a small k-buffer program. We present two proposals for adding k-buffer support to future GPUs and demonstrate numerous multiple-fragment, single-pass graphics algorithms running on both a software-simulated k-buffer and a k-buffer implemented with current GPUs. The goal of this work is to demonstrate the large number of graphics algorithms that the k-buffer enables and that the efficiency is superior to current multipass approaches.

Original languageEnglish (US)
Title of host publicationProceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games
Pages97-104
Number of pages8
DOIs
StatePublished - 2007
EventACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, I3D 2007 - Seattle, WA, United States
Duration: Apr 30 2007May 2 2007

Other

OtherACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, I3D 2007
CountryUnited States
CitySeattle, WA
Period4/30/075/2/07

Fingerprint

Geometry
Pixels
Data storage equipment
Volume rendering
Transparency
Visualization
Graphics processing unit
Rendering (computer graphics)

Keywords

  • Blending
  • CSG
  • Fragment processing
  • Graphics hardware
  • Transparency
  • Visibility ordering
  • Volume rendering

ASJC Scopus subject areas

  • Artificial Intelligence
  • Computational Theory and Mathematics
  • Computer Graphics and Computer-Aided Design
  • Human-Computer Interaction

Cite this

Bavoil, L., Callahan, S. P., Lefohn, A., Comba, J. L. D., & Silva, C. T. (2007). Multi-fragment effects on the GPU using the k-buffer. In Proceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games (pp. 97-104) https://doi.org/10.1145/1230100.1230117

Multi-fragment effects on the GPU using the k-buffer. / Bavoil, Louis; Callahan, Steven P.; Lefohn, Aaron; Comba, João L D; Silva, Cláudio T.

Proceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games. 2007. p. 97-104.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Bavoil, L, Callahan, SP, Lefohn, A, Comba, JLD & Silva, CT 2007, Multi-fragment effects on the GPU using the k-buffer. in Proceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games. pp. 97-104, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games, I3D 2007, Seattle, WA, United States, 4/30/07. https://doi.org/10.1145/1230100.1230117
Bavoil L, Callahan SP, Lefohn A, Comba JLD, Silva CT. Multi-fragment effects on the GPU using the k-buffer. In Proceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games. 2007. p. 97-104 https://doi.org/10.1145/1230100.1230117
Bavoil, Louis ; Callahan, Steven P. ; Lefohn, Aaron ; Comba, João L D ; Silva, Cláudio T. / Multi-fragment effects on the GPU using the k-buffer. Proceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games. 2007. pp. 97-104
@inproceedings{425fbbcd8cfa401c845575e40e0ce987,
title = "Multi-fragment effects on the GPU using the k-buffer",
abstract = "Many interactive rendering algorithms require operations on multiple fragments (i.e., ray intersections) at the same pixel location: however, current Graphics Processing Units (GPUs) capture only a single fragment per pixel. Example effects include transparency, translucency, constructive solid geometry, depth-of-field, direct volume rendering, and isosurface visualization. With current GPUs, programmers implement these effects using multiple passes over the scene geometry, often substantially limiting performance. This paper introduces a generalization of the Z-buffer, called the k-buffer, that makes it possible to efficiently implement such algorithms with only a single geometry pass, yet requires only a small, fixed amount of additional memory. The k-buffer uses framebuffer memory as a read-modify-write (RMW) pool of k entries whose use is programmatically defined by a small k-buffer program. We present two proposals for adding k-buffer support to future GPUs and demonstrate numerous multiple-fragment, single-pass graphics algorithms running on both a software-simulated k-buffer and a k-buffer implemented with current GPUs. The goal of this work is to demonstrate the large number of graphics algorithms that the k-buffer enables and that the efficiency is superior to current multipass approaches.",
keywords = "Blending, CSG, Fragment processing, Graphics hardware, Transparency, Visibility ordering, Volume rendering",
author = "Louis Bavoil and Callahan, {Steven P.} and Aaron Lefohn and Comba, {Jo{\~a}o L D} and Silva, {Cl{\'a}udio T.}",
year = "2007",
doi = "10.1145/1230100.1230117",
language = "English (US)",
isbn = "9781595936288",
pages = "97--104",
booktitle = "Proceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games",

}

TY - GEN

T1 - Multi-fragment effects on the GPU using the k-buffer

AU - Bavoil, Louis

AU - Callahan, Steven P.

AU - Lefohn, Aaron

AU - Comba, João L D

AU - Silva, Cláudio T.

PY - 2007

Y1 - 2007

N2 - Many interactive rendering algorithms require operations on multiple fragments (i.e., ray intersections) at the same pixel location: however, current Graphics Processing Units (GPUs) capture only a single fragment per pixel. Example effects include transparency, translucency, constructive solid geometry, depth-of-field, direct volume rendering, and isosurface visualization. With current GPUs, programmers implement these effects using multiple passes over the scene geometry, often substantially limiting performance. This paper introduces a generalization of the Z-buffer, called the k-buffer, that makes it possible to efficiently implement such algorithms with only a single geometry pass, yet requires only a small, fixed amount of additional memory. The k-buffer uses framebuffer memory as a read-modify-write (RMW) pool of k entries whose use is programmatically defined by a small k-buffer program. We present two proposals for adding k-buffer support to future GPUs and demonstrate numerous multiple-fragment, single-pass graphics algorithms running on both a software-simulated k-buffer and a k-buffer implemented with current GPUs. The goal of this work is to demonstrate the large number of graphics algorithms that the k-buffer enables and that the efficiency is superior to current multipass approaches.

AB - Many interactive rendering algorithms require operations on multiple fragments (i.e., ray intersections) at the same pixel location: however, current Graphics Processing Units (GPUs) capture only a single fragment per pixel. Example effects include transparency, translucency, constructive solid geometry, depth-of-field, direct volume rendering, and isosurface visualization. With current GPUs, programmers implement these effects using multiple passes over the scene geometry, often substantially limiting performance. This paper introduces a generalization of the Z-buffer, called the k-buffer, that makes it possible to efficiently implement such algorithms with only a single geometry pass, yet requires only a small, fixed amount of additional memory. The k-buffer uses framebuffer memory as a read-modify-write (RMW) pool of k entries whose use is programmatically defined by a small k-buffer program. We present two proposals for adding k-buffer support to future GPUs and demonstrate numerous multiple-fragment, single-pass graphics algorithms running on both a software-simulated k-buffer and a k-buffer implemented with current GPUs. The goal of this work is to demonstrate the large number of graphics algorithms that the k-buffer enables and that the efficiency is superior to current multipass approaches.

KW - Blending

KW - CSG

KW - Fragment processing

KW - Graphics hardware

KW - Transparency

KW - Visibility ordering

KW - Volume rendering

UR - http://www.scopus.com/inward/record.url?scp=77950558346&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=77950558346&partnerID=8YFLogxK

U2 - 10.1145/1230100.1230117

DO - 10.1145/1230100.1230117

M3 - Conference contribution

AN - SCOPUS:77950558346

SN - 9781595936288

SP - 97

EP - 104

BT - Proceedings - I3D 2007, ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games

ER -