Interactive Order-Independent Transparency

Transcription

1 Interative Order-Independent Transpareny Cass Everitt NVIDIA OpenGL Appliations Engineering (a) (b) Figure. These images illustrate orret (a) and inorret (b) rendering of transparent surfaes. Introdution Corretly rendering non-refrative transparent surfaes ith ore OpenGL funtionality [9] has the vexing requirements of depth-sorted traversal and noninterseting polygons. This is frustrating for most appliation developers using OpenGL beause the natural order of sene traversal (usually one objet at a time) rarely satisfies these requirements. Objets an be omplex, ith their on transformation hierarhies. Even more troublesome, ith advaned graphis hardare, the verties and fragments of objets may be altered by user-defined per-vertex or per-fragment operations ithin the GPU. When these features are employed, it beomes intratable to guarantee that fragments ill arrive in sorted order for eah pixel. The tehnique presented here solves the problem of order dependene by using a tehnique e all depth peeling. Depth peeling is a fragment-level depth sorting tehnique desribed by Mammen using Virtual Pixel Maps [7] and by Diefenbah using a dual depth buffer [3]. Though no dual depth buffer hardare fitting Diefenbah s desription exists, Bastos observed that shado mapping hardare in onjuntion ith alpha test an be used to ahieve the same effet []. Using this variation of depth peeling, eah unique depth in the sene is extrated into layers, and the layers are omposited in depth-sorted order to produe the orretly blended final image. The peeling of a layer requires a single order-independent pass over the sene. Figure ontrasts orret and inorret rendering of transparent surfaes.

2 The goal of this doument is to enable OpenGL developers to implement this tehnique ith NVIDIA OpenGL extensions and GeFore3 hardare. Sine shado mapping is integral to the tehnique a very basi introdution is provided, but the interested reader is enouraged to explore the referened material for more detail. Shado Mapping Shado mapping is a multi-pass shadoing tehnique developed by Lane Williams [] in 978. In the first pass, the sene is rendered from the light s point of vie. The depth buffer generated in that pass is opied to a speial depth texture or shado map. In the seond pass, the shado map is projeted onto the sene using projetive texture mapping [0, 4]. Unlike regular D projetive texture mapping here the r oordinate is unused, e use the r oordinate to ompute the distane of the rasterized fragment to the light soure. Then, the lookup of (s,t) is the distane to the nearest surfae to the light soure (along that diretion). If r lookup(s,t), then the urrent fragment is visible to the light soure, and therefore not in shado. Essentially, e use depth-buffering in the first pass to determine hih surfaes are visible from the light s point of vie, and in the seond pass e sho those surfaes as illuminated. Figure helps illustrate this onept. Figure. These diagrams ere taken from Mark Kilgard s shado mapping presentation at GDC 00. They illustrate the shadoing omparison that ours in shado mapping. We use the SGIX_shado and SGIX_depth_texture extensions [8] to take advantage of GeFore3 shado mapping hardare in OpenGL. The SGIX_shado extension provides the ability to ompute a omparison of the r texture oordinate ith the results of the D lookup. The SGIX_depth_texture extension exposes GL_DEPTH_COMPONENT internal texture formats and defines semantis for glcopytex{sub}imaged for fast opies from the depth buffer to a depth texture. These features are fully aelerated on GeFore3. It has been shon by Heidrih [5] that multitexturing an be used to implement a limited form of shado mapping. It is limited in that it requires multiple texture units and it only supports nearest filtering and 8-bit depth texels (6-bit depth on GeFore [6]). For depth peeling, e need full depth buffer preision (4 bits) that neessitates the use of the SGIX shadoing extensions.

3 Depth Peeling Depth peeling is the underlying tehnique that makes this approah for orderindependent transpareny possible. The standard depth test gives us the nearest fragment at eah pixel, but there is also a fragment that is seond nearest, third nearest, and so on. Standard depth testing gives us the nearest fragment ithout imposing any ordering restritions, hoever, it does not give us any straightforard ay to render the seond nearest or n th nearest surfae. Depth peeling solves this problem. The essene of hat happens ith this tehnique is that ith n passes over a sene, e an get n layers deeper into the sene. For example, ith passes over the sene, e an extrat the nearest and seond nearest surfaes in a sene. We get both the depth and olor (RGBA) information for eah layer. The images e get from peeling aay depth are shon in Figure 3. It an be quite onfusing to make sense of the images of layer and beyond, beause the notion of a seond nearest surfae is unintuitive. To help distinguish the various surfaes, the teapot is rendered ith to-sided lighting (outside is red and inside is green), and the ground plane is dran in blue. Note that the image labeled Layer is in the shape of a teapot, but most of the fragments in that layer are from the ground plane (they are blue). Without the oloring, this ould be diffiult to interpret. Layer 0 Layer Layer Layer 3 Figure 3. These images illustrate simple depth peeling. Layer 0 shos the nearest depths, layer shos the seond depths, and so on. To-sided lighting ith vivid oloring is used to help distinguish the surfaes.

4 Layer 0 Layer Layer 0 depth 0 depth 0 depth Figure 4. Depth peeling strips aay depth layers ith eah suessive pass. The frames above sho the frontmost (leftmost) surfaes as bold blak lines, hidden surfaes as thin blak lines, and peeled aay surfaes as light grey lines. Figure 4 provides a more diagrammati vie of depth peeling. The diagrams there are analogous to the images in Figure 3, exept e are no looking at a ross setion of the vie volume and highlighting eah layer. It is evident from the vie in Figure 4 that the depths vary ithin eah layer, and the number of samples is dereasing. The peeling proess learly happens at the fragment level, so the piees are generally not hole polygons. The proess of depth peeling is atually a straightforard multi-pass algorithm. In the first pass e render as normal, and the depth test gives us the nearest surfae. In the seond pass, e use the depth buffer omputed in the first pass to peel aay depths that are less than or equal to nearest depths from the first pass. The seond pass generates a depth buffer for the seond nearest surfae, hih an be used to peel aay the first and seond nearest surfaes in the third pass. The pattern is simple, but there is a ath. We need to perform to depth tests per fragment for it to ork! Multiple Depth Tests The most natural ay to desribe this tehnique is to imagine that OpenGL supported multiple simultaneous depth units, eah ith its on depth buffer and assoiated state. We diverge from Diefenbah s dual depth buffer API in that e assume there are n depth units, all riteable, that are exeuted in sequential order. The first depth test to fail disards the fragment and terminates further proessing. The pseudoode in Listing implements depth peeling using to depth units. In eah pass exept the first, depth unit 0 is used to peel aay the previously nearest fragments hile the depth unit performs regular depth-buffering. We deouple the depth buffer from the depth unit beause it simplifies the presentation of the for (i=0; i<num_passes; i++) { lear olor buffer A = i % B = (i+) % depth unit 0: if(i == 0) disable depth test else enable depth test bind buffer A disable depth rites set depth fun to GREATER depth unit : bind buffer B lear depth buffer enable depth rites enable depth test set depth fun to LESS render sene save olor buffer RGBA as layer i } Listing. Pseudoode for depth peeling using multiple simultaneous depth buffers.

5 algorithm and more losely mathes the semantis of ARB_multitexture. This deoupling is onvenient beause e need to use the depth buffer produed by depth unit in pass i as the peeling depth buffer for depth unit 0 in pass i+. It is also orth mentioning that e only enable depth rites on depth unit. This ill be important later. Shado Mapping as Depth Test Shado mapping is a depth test. For the purposes of our disussion, there are only a fe major differenes beteen shado mapping and the depth-buffer algorithm: the shado mapping omparison sets a fragment olor attribute, the shado mapping depth test is not tied to the amera position, and the shado map (depth buffer) is not riteable during the shado omparison (depth test). It is not diffiult to ompensate for these differenes. We rite the results of the shado mapping omparison to fragment alpha and use alpha test to disard fragments that fail the depth test e have hosen. We make the orientation and resolution of the shado map idential to that of the amera. We an then use shado mapping as a readonly depth test. This is good nes, beause this is all e needed to implement depth peeling as desribed in the previous setion using our imaginary multiple depth test OpenGL. Exept no, e an atually implement it using real OpenGL and ith hardare aeleration! An Invariane Issue As simple as depth peeling sounds, it is atually pretty intolerant to variane. Due to the nature of the tehnique, many of the fragments generated in eah pass ill be on the razor s edge of the omparison. In our imaginary OpenGL that supports multiple depth tests, e ould not expet variane to be a problem beause e are re-using the same interpolator to ompute depth the same ay in eah pass. Things are a little more ompliated hen e use shado mapping as a depth test, though. This is primarily beause z (indo spae z) is interpolated linearly in indo spae at the preision of the urrent depth buffer, and r and q are interpolated linearly in lip spae (hyperbolially in indo spae) at high preision The possible differenes in preision and/or interpolation implementation are the hazards that ause variane. Consider the depth interpolation in Equation, hih is linear in indo spae. z z z z = = z + ( ) z = + ( ) ()

6 Where z is indo spae z, z is lip spae z, is lip spae, and the numeri speifiers and indiate to points that are being interpolated. When e perform shado mapping, e must interpolate quantities as texture oordinates hih vary linearly in lip spae, so e interpolate z and as the r and q texture oordinates respetively, and use the r/q quotient to produe a value that varies linearly in indo spae. For the partiular ase e have been onsidering, shado mapping from the amera s point of vie e get Equations and 3. When e ompute the r/q quotient, e reognize that the denominators in Equations and 3 anel, and that for our speial ase of shado mapping from the amera s point of vie, the numerator of Equation 3 is. This leaves only the numerator of Equation, hih is idential to the expression in Equation. While this is algebraially true, the hardare may not be able to make some of these anellations. For fragments ith the same depth, hardare ould evaluate the omparison shon in (4). The left side of the expression interpolates three quantities and performs four divides hile the right simply interpolates one quantity. Lukily GeFore3 s NV_texture_shader extension [8] supports a mode alled GL_DOT_PRODUCT_DEPTH_REPLACE_NV that allos us to ompute fragment depth using texture oordinates. The depth omputed in this texture shader replaes the fragment depth that as omputed in the rasterizer. This means that for GeFore3, e an ) ( ) ( z z z r + + = = ) ( ) ( q + + = = () (3) z z (4)

7 ompute the depth that e store in the depth buffer in exatly the same ay that e ompute it hen making the omparison. When e use this texture shader in generating our shado map, there are no varianes in the least signifiant bits. This is nie beause it means e do not have to employ fudge fators to deal ith LSB variane. The depth replae texture shader is very general, and this is a very simple use of it. Figure 5 illustrates the general operation of the depth replae texture shader. Figure 5. This diagram is a slightly modified slide taken from Dominé and Spitzer s GDC 00 presentation on GeFore3 texture shaders. It desribes the depth replae texture shader. For our purposes, e really only ant to interpolate z and using a single texture oordinate for eah, so e use a x GL_UNSIGNED_HILO_NV texture here H and L are zero. By definition, the 3 rd omponent of an unsigned HILO is, so e perform a dot produt of (S, T, R) ith (0, 0, ). In this ay, e an interpolate the R oordinates of stages and, and e use texture oordinate generation to make sure that R is z and R is. When e perform the division z / at eah fragment, e are effetively interpolating indo spae depth in the same ay that s/q does it in the subsequent shado mapping pass. There is one larifiation e should make. When e onsider the standard transformation pipeline, e often plae the perspetive divide before the vieport and depth range sale and bias. The depth replae texture shader and shado mapping depth omputation perform the divide (z / and s/q respetively) as the final operation. This means that e must apply the depth range sale and bias before the perspetive divide. Or, said another ay, for depth replae and shado mapping, e must transform oordinates into homogeneous indo oordinates rather than homogeneous lip spae.

8 glativetexturearb(gl_texture0_arb); simple_x_uhilo.bind(); gltexenvi(gl_texture_shader_nv, GL_SHADER_OPERATION_NV, GL_TEXTURE_D); matrix4f m; glativetexturearb(gl_texture_arb); gltexenvi(gl_texture_shader_nv, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV); gltexenvi(gl_texture_shader_nv, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB); gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_NONE); glmatrixmode(gl_modelview); glpushmatrix(); glloadidentity(); eye_linear_texgen(); // set EYE_LINEAR texgen ith identity planes texgen(true); // enable texgen on s,t,r, and q glpopmatrix(); glmatrixmode(gl_texture); glloadidentity(); gltranslatef( 0, 0,.5); glsalef( 0, 0,.5); reshaper.apply_perspetive(); // apply the amera s perspetive projetion matrix glmatrixmode(gl_modelview); glativetexturearb(gl_texture_arb); gltexenvi(gl_texture_shader_nv, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_DEPTH_REPLACE_NV); gltexenvi(gl_texture_shader_nv, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB); gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_NONE); glpushmatrix(); glloadidentity(); eye_linear_texgen(); // set EYE_LINEAR texgen ith identity planes texgen(true); // enable texgen on s,t,r, and q glpopmatrix(); glmatrixmode(gl_texture); glloadidentity(); m(0,0) = 0; m(0,) = 0; m(0,) = 0; m(0,3) = 0; m(,0) = 0; m(,) = 0; m(,) = 0; m(,3) = 0; m(,0) = 0; m(,) = 0; m(,) = 0; m(,3) = ; // move q to r m(3,0) = 0; m(3,) = 0; m(3,) = 0; m(3,3) = 0; glmultmatrix(m); reshaper.apply_perspetive(); // apply the amera s perspetive projetion matrix glmatrixmode(gl_modelview); glativetexturearb(gl_texture3_arb); gltexenvi(gl_texture_shader_nv, GL_SHADER_OPERATION_NV, GL_TEXTURE_RECTANGLE_NV); gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_NONE); glativetexturearb(gl_texture0_arb); Listing. Example ode for setting up depth replae texture shader for use in depth peeling. The ode in Listing illustrates ho to set up the GL_DOT_PRODUCT_DEPTH_- REPLACE_NV texture shader to ompute indo z in a ay that losely mathes the standard projetive texture mapping omputation of indo z. For illustrative purposes, e use eye linear texgen ith an identity mapping for the r oordinate [ ], and e use the texture matrix to perform the transforms. The most effiient approah ould be to enode the transform in the texgen plane. Another slightly odd aspet the depth replae texture shader is illustrated in the ode in Listing. It is that the homogeneous indo oordinate must be moved from the fourth ro of the texture matrix into the r oordinate. This is beause the dot produt texture shaders only perform a 3-omponent dot produt, so all quantities must be in the s, t, or r oordinates.

9 Putting It All Together No e have a ay to ompute the RGBA olor for eah unique depth at every pixel. These are stored as separate layers (or vieport-sized textures). All that remains is to ompute the orret order-dependent olor at eah pixel by ompositing the layers in order. Rendering eah layer as vieport-sized textured quad does this. For bak-to-front ompositing a (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) blending funtion is used. Figure 5 illustrates the results of ompositing of the layers into a final image. Note also that the bottom to images in Figure 5 look virtually (but not ompletely) idential. For ompletely orret results e should extrat every semitransparent sample up to the first opaque sample, but in pratie that is not neessary. The nature of the transpareny omputation is that samples further bak have diminished effet, so trunation is a reasonable (and effiient) form of approximation. For example, the sene in Figure 5 is good enough after three layers. layer layers 3 layers 4 layers Figure 5. The depth peeled layers of the sene are orretly sorted per-fragment. If e simply save the olor (RGBA) for eah layer, e an omposite them in depth-sorted order as a final pass. These images illustrate blending more layers for more orret transpareny.

10 Conlusion The tehnique presented is a straightforard and onvenient ay to render senes ith transpareny beause it does not require that the sene be rendered in sorted order, and it makes good use of graphis hardare. In addition, there may be no pratial alternative to this approah of layer extration and ompositing for senes that annot be rendered in sorted order in a single pass. Some of the figures in this paper ome from the layerz and order_independent_- transpareny demos that an be found in the NVIDIA OpenGL SDK, hih an be found at The demos only illustrate the tehnique desribed here, but many variations like those desribed in Diefenbah [3] are possible. The GDC 00 presentations that ere used in some figures are also available at the above eb site. Aknoledgements Rui Bastos ame up ith the very lever idea of depth peeling using shado mapping hardare support hen he as onsidering hardare aelerated Woo shado maps for GeFore3 (hitepaper on that topi to follo soon). I had help from Mark Kilgard on the appropriate texture oordinate generation setup for the depth replae texture shader that solves the invariane problem. He also provided invaluable feedbak on early drafts of this paper. Referenes [] James F. Blinn. Hyperboli interpolation. IEEE Computer Graphis (SIGGRAPH) and Appliations, (4):89 94, July 99. [] Rui Bastos. Personal ommuniation. Feb 00. [3] Paul Diefenbah. Pipeline Rendering: Interation and Realism Through Hardare- Based Multi-PassRendering. University of Pennsylvania, Department of Computer Siene, Ph.D. dissertation, 996. [4] Cass Everitt. Projetive texture mapping. 3C08856A38007DE5E6. 00 [5] Wolfgang Heidrih. High quality shading and lighting for hardare-aelerated rendering [6] Mark Kilgard. GDC 00 Shado mapping ith today s OpenGL hardare. 7EFC8856A Marh 00. [7] Abraham Mammen. Transpareny and antialiasing algorithms Implemented ith the virtual pixel maps tehnique. IEEE Computer Graphis and Appliations, 9(4): 43-55, July 989.

11 [8] NVIDIA OpenGL Extensions Speifiations. 5D688568E007AA680. Marh 00. [9] Mark Segal and Kurt Akeley. The OpenGL Graphis System: A Speifiation (Version..)..opengl.org [0] Mark Segal, et al. Fast shados and lighting effets using texture mapping. In Proeedings of SIGGRAPH 9, pages 49-5, 99. [] Lane Williams. Casting urved shados on urved surfaes. In Proeedings of SIGGRAPH 78, pages 70-74, 978.